Yes, it is feasible to implement user-defined material models in ANSYS and MSC.MARC using C or C++. Here’s a guide on how to proceed with this approach:

1. ANSYS: Using C/C++ for User-Defined Material Models

ANSYS primarily uses Fortran for user-defined material models (through usermat.f), but you can integrate C or C++ code through the following methods:

• Fortran-C Interface: You can write your core material model code in C or C++ and then use a Fortran-C interface to connect your C/C++ code with ANSYS. This typically involves:Creating a Fortran Wrapper: Write a Fortran wrapper that calls your C/C++ functions. This wrapper will be included in your usermat.f file. Using ISO_C_BINDING: In Fortran, you can use the ISO_C_BINDING module to interface with C functions. Example Fortran Wrapper: fortranCopy codemodule my_wrapper use, intrinsic :: iso_c_binding interface function my_c_function(arg1, arg2) bind(c) import :: c_int integer(c_int) :: my_c_function integer(c_int), value :: arg1, arg2 end function my_c_function end interface end module my_wrapperExample C Code: cCopy code#include #include #include "my_wrapper.h" int my_c_function(int arg1, int arg2) { // Implementation of your material model return arg1 + arg2; }Compile the C code into a shared library and link it with your ANSYS executable.
• ANSYS Custom Code: In some cases, ANSYS Workbench might offer ways to call external C/C++ libraries via scripting interfaces, though this is less direct than Fortran integration.

2. MSC.MARC: Using C/C++ for User-Defined Material Models

MSC.MARC typically uses Fortran for user subroutines (e.g., hypela2.f), but similar to ANSYS, you can integrate C/C++ code as follows:

• C/C++ Integration: Like with ANSYS, you can create C or C++ functions and call them from Fortran subroutines. This involves:Writing a Fortran Interface: Develop a Fortran interface that can call your C/C++ code. Using ISO_C_BINDING: In Fortran, use ISO_C_BINDING to interface with C functions. Example Fortran Interface: fortranCopy codemodule my_interface use, intrinsic :: iso_c_binding interface function my_c_function(arg1, arg2) bind(c) import :: c_int integer(c_int) :: my_c_function integer(c_int), value :: arg1, arg2 end function my_c_function end interface end module my_interfaceExample C Code: cCopy code#include #include #include "my_interface.h" int my_c_function(int arg1, int arg2) { // Implementation of your material model return arg1 + arg2; }Compile the C code into a shared library and ensure it’s accessible to MSC.MARC.

References and Resources

• ANSYS Documentation: Check ANSYS documentation for details on integrating external code and using Fortran-C interfaces. The ANSYS Developer's Kit might also offer guidance.
• MSC.MARC Documentation: Review the MSC.MARC documentation on user-defined subroutines and integrating external libraries.
• Forums and Communities: Explore forums and user communities for ANSYS and MSC.MARC for practical examples and advice on integrating C/C++ code.

By using these methods, you can leverage C or C++ for complex material modeling tasks while still using Fortran as the interface within ANSYS or MSC.MARC.

Step 1: Compile the Custom C++ File

Navigate to the directory containing Intel's oneAPI compiler and set up the Visual Studio environment variables for 64-bit compilation.

cd C:\Program Files (x86)\Intel\oneAPI\compiler\2025.0\bin "C:\Program Files (x86)\Microsoft Visual Studio\2019\Professional\VC\Auxiliary\Build\vcvarsall.bat" x64

Then compile the C++ source file (main.cpp) into an object file (mainsub_.obj) using the Intel oneAPI compiler (icx). Include necessary libraries like Eigen for matrix operations if required.

icx -m64 -I"G:/konstructor/c_plus_plus_example/Eigen/Eigen" -c "G:\konstructor\c_plus_plus_example\example_mangling\main.cpp" -o mainsub_.obj

Notes:

• -m64: Ensures 64-bit architecture.
• -I: Specifies include paths for external libraries like Eigen.
• -c: Indicates compilation only (no linking).

Step 2: Compile the FORTRAN Material Model

Extract the compilation command for the FORTRAN file from the MSC.MARC logs (e.g., Name_project_job1.log). Use the same compiler and flags as MSC.MARC to ensure compatibility.

ifort /fpp /c /DWIN32_intel -D_IMPLICITNONE /nologo /integer_size:64 -DI64 -DMKL -DOPENMP -DOMP_COMPAT -D_MSCMARC -DWIN64 /I"G:\marc\marc2019\common" /I"G:\marc\marc2019\intelmpi\win64\include" /O2 /Qip /Qvec- /Qsafe-cray-ptr /W1 /Qopenmp /Qopenmp-threadprivate:compat -DMARCHDF=HDF /I"\include\shared" -DCASI -DPARDISO -DMUMPS -DBCSGPU -DCUDA /MD /I"G:\marc\marc2019\mod\win64" -DDDM /object:"G:\konstructor\marc\NeoHooke.obj" "G:\konstructor\marc\NeoHooke.f"

Explanation of Flags:

• /fpp: Enables preprocessing.
• /D: Defines macros for conditional compilation.
• /integer_size:64: Ensures 64-bit integer support.
• /O2: Optimizes for speed.
• /I: Adds include paths for necessary headers.

The output is an object file, NeoHooke.obj, containing your custom material model.

Step 3: Link All Object Files

To create the final executable (NeoHooke.exe), link the compiled object files and libraries. Replace the default main.obj from MSC.MARC with the newly compiled mainsub_.obj.

LINK /nologo /out:"NeoHooke.exe" ^ "G:\marc\marc2019\lib\win64i8\main.obj" ^ "G:\marc\marc2019\lib\win64i8\blkdta.obj" ^ "G:\marc\marc2019\lib\win64i8\comm1.obj" ^ "G:\marc\marc2019\lib\win64i8\comm2.obj" ^ "G:\marc\marc2019\lib\win64i8\comm3.obj" ^ "G:\konstructor\marc\NeoHooke.obj" ^ "G:\marc\marc2019\lib\win64i8\srclib.lib" ^ ... "C:\Program Files (x86)\Intel\oneAPI\compiler\2025.0\bin\mainsub_.obj"

Step 4: Ensure External Function Declaration

In the custom material model source code, declare the external function for compatibility:

EXTERNAL mainsub_

This ensures that MSC.MARC correctly integrates the custom entry point defined in mainsub_.obj.