In addition to standard C and C++ language data types such as real,
int, and so on that you can use to define data in your UDF, there are
ANSYS Fluent-specific data types that are associated with solver data. These data types represent the
computational units for a mesh (Figure 1.1: Mesh Components). Variables that are defined
using these data types are typically supplied as arguments to DEFINE
macros, as well as to other special functions that access ANSYS Fluent solver data.
Some of the more commonly used ANSYS Fluent data types are:
NodeA structure data type that stores data associated with a mesh point.
face_tAn integer data type that identifies a particular face within a face thread.
cell_tAn integer data type that identifies a particular cell within a cell thread.
ThreadA structure data type that
stores data that is common to the group of cells or faces that it
represents. In the Thread data type there
is an array (storage) of pointers that each
point to an array of cell or face values of a particular field variable
(such as pressure, velocity, or gradients). Within that array of pointers,
the index by which to identify a pointer to the array of (cell or
face values of) a particular field variable is of the type Svar. For multiphase applications, there is a thread
structure for each phase, as well as for the mixture. See Multiphase-specific Data Types for details.
SvarAn index used to identify a
pointer in the Thread storage. All possible
values for this index variable are given in the enumeration of that
type in the file src/storage/storage.h. Note
that some values are generated using macros like SV_[COUPLED_]SOLUTION_VAR[_WITH_FC](...), SV_UDS_I(...) or SV_UDSI_G(...) and are therefore not found explicitly in the enumeration. If a
pointer in the storage array of pointers still has the value NULL, memory for the corresponding field variable has
not been allocated yet. A call to the function Alloc_Storage_Vars(domain,
SV_..., ..., SV_NULL); can be used to change that allocation.
The expression if (NULLP(THREAD_STORAGE(t, SV_...))) can be used to test whether the memory for a particular field variable
has already been allocated on a given Thread or not.
DomainA structure data type that stores data associated with a collection of node, face, and cell threads in a mesh. For single-phase applications, there is only a single domain structure. For multiphase applications, there are domain structures for each phase, the interaction between phases, as well as for the mixture. The mixture-level domain is the highest-level structure for a multiphase model. See Multiphase-specific Data Types for details.
Important: All ANSYS Fluent data types are case-sensitive.
When you use a UDF in ANSYS Fluent, your function can access solution variables at individual cells or cell faces in the fluid and boundary zones. UDFs need to be passed appropriate arguments such as a thread reference (that is, a pointer to a particular thread) and the cell or face ID in order to enable individual cells or faces to be accessed. Note that a face ID or cell ID by itself does not uniquely identify the face or cell. A thread pointer is always required along with the ID to identify the thread to which the face (or cell) belongs.
Some UDFs are passed the cell index variable (c) as an argument (such as in DEFINE_PROPERTY(my_function,c,t)), or the face index variable (f) (such
as in DEFINE_UDS_FLUX(my_function,f,t,i)).
If the cell or face index variable (for example, cell_t
c, face_t f) is not passed as
an argument and is needed in the UDF, the variable is always available
to be used by the function after it has been declared locally. See
DEFINE_UDS_FLUX
for an example.
The data structures that are passed to your UDF (as pointers)
depend on the DEFINE macro you are using
and the property or term you are trying to modify. For example, DEFINE_ADJUST UDFs are general-purpose functions that
are passed a domain pointer (d) (such as
in DEFINE_ADJUST(my_function, d)). DEFINE_PROFILE UDFs are passed a thread pointer (t) to the boundary zone to which the function is hooked,
such as in DEFINE_PROFILE(my_function, thread, i).
Some UDFs (such as DEFINE_ON_DEMAND functions) are not passed any pointers to data structures, while
others are not passed the pointer the UDF needs. If your UDF needs
to access a thread or domain pointer that is not directly passed by the solver through an argument, then you will need to
use a special ANSYS Fluent-supplied macro to obtain the pointer in your
UDF. For example, DEFINE_ADJUST is passed
only the domain pointer, so if your UDF needs a thread pointer, it
will have to declare the variable locally and then obtain it using
the special macro Lookup_Thread. An exception
to this is if your UDF needs a thread pointer to loop over all of
the cell threads or all the face threads in a domain (using thread_c_loop(c,t) or thread_f_loop(f,t), respectively) and it is not passed to the DEFINE macro. Since the UDF will be looping over all threads in the domain,
you will not need to use Lookup_Thread to
get the thread pointer to pass it to the looping macro; you will just
need to declare the thread pointer (and cell or face ID) locally before
calling the loop. See
DEFINE_ADJUST
for
an example.
As another example, if you are using DEFINE_ON_DEMAND (which is not passed any pointer argument) to execute an asynchronous
UDF and your UDF needs a domain pointer, then the function will need
to declare the domain variable locally and obtain it using Get_Domain. See
DEFINE_ON_DEMAND
for an example. Refer to Special Macros for details.