You can use DEFINE_ANISOTROPIC_CONDUCTIVITY to specify the conductivity matrix in a solid, in order to simulate anisotropic thermal conductivity. For details about user-defined anisotropic conductivity, see User-Defined Anisotropic Thermal Conductivity in the User’s Guide.

DEFINE_ANISOTROPIC_CONDUCTIVITY (name, c, t, dmatrix)

Function returns

void

There are four arguments to DEFINE_ANISOTROPIC_CONDUCTIVITY: name, c, t, and dmatrix. You supply name, the name of the UDF. c, t, and dmatrix are variables that are passed by the Ansys Fluent solver to your UDF. Your function will compute the conductivity matrix for a single cell and fill dmatrix with it. Note that anisotropic conductivity UDFs are called by Ansys Fluent from within a loop on cell threads. Consequently, your UDF will not need to loop over cells in a thread since Ansys Fluent is doing it outside of the function call.

The following UDF, named cyl_ortho_cond computes the anisotropic conductivity matrix for a cylindrical shell that has different conductivities in radial, tangential, and axial directions. This function can be executed as a compiled UDF.

/******************************************************************************
 UDF for defining the anisotropic conductivity matrix for a cylindrical shell
 ******************************************************************************/
 #include "udf.h"

 /* Computation of anisotropic conductivity matrix for
 * cylindrical orthotropic conductivity */

 /* axis definition for cylindrical conductivity */
 static const real origin[3] = {0.0, 0.0, 0.0};
 static const real axis[3]  = {0.0, 0.0, 1.0};

 /* conductivities in radial, tangential and axial directions */
 static const real cond[3] = {1.0, 0.01, 0.01};

 DEFINE_ANISOTROPIC_CONDUCTIVITY(cyl_ortho_cond,c,t,dmatrix)
 {
    real x[3][3]; /* principal direction matrix for cell in cartesian coords. */
    real xcent[ND_ND];
    real R;
    C_CENTROID(xcent,c,t);
    NV_VV(x[0],=,xcent,-,origin);
   #if RP_3D
      NV_V(x[2],=,axis);
   #endif
   #if RP_3D
      R = NV_DOT(x[0],x[2]);
      NV_VS(x[0],-=,x[2],*,R);
   #endif
    R = NV_MAG(x[0]);
    if (R > 0.0)
       NV_S(x[0],/=,R);
   #if RP_3D
    N3V_CROSS(x[1],x[2],x[0]);
   #else
      x[1][0] = -x[0][1];
      x[1][1] = x[0][0];
   #endif
    /* dmatrix is computed as xT*cond*x */
    dmatrix[0][0] = cond[0]*x[0][0]*x[0][0]
       + cond[1]*x[1][0]*x[1][0]
   #if RP_3D
     + cond[2]*x[2][0]*x[2][0]
   #endif
   ;
    dmatrix[1][1] = cond[0]*x[0][1]*x[0][1]
     + cond[1]*x[1][1]*x[1][1]
   #if RP_3D
     + cond[2]*x[2][1]*x[2][1]
   #endif
     ;
    dmatrix[1][0] = cond[0]*x[0][1]*x[0][0]
     + cond[1]*x[1][1]*x[1][0]
   #if RP_3D
     + cond[2]*x[2][1]*x[2][0]
   #endif
   ;
    dmatrix[0][1] = dmatrix[1][0];

   #if RP_3D
    dmatrix[2][2] = cond[0]*x[0][2]*x[0][2]
     + cond[1]*x[1][2]*x[1][2]
     + cond[2]*x[2][2]*x[2][2]
     ;
    dmatrix[0][2] = cond[0]*x[0][0]*x[0][2]
     + cond[1]*x[1][0]*x[1][2]
     + cond[2]*x[2][0]*x[2][2]
     ;
    dmatrix[2][0] = dmatrix[0][2];
   dmatrix[1][2] = cond[0]*x[0][1]*x[0][2]
     + cond[1]*x[1][1]*x[1][2]
     + cond[2]*x[2][1]*x[2][2]
     ;
    dmatrix[2][1] = dmatrix[1][2];
   #endif
 }

After the UDF that you have defined using DEFINE_ANISOTROPIC_CONDUCTIVITY is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, cyl_ortho_cond) will become visible and selectable in the Create/Edit Materials dialog box in Ansys Fluent. See Hooking DEFINE_ANISOTROPIC_CONDUCTIVITY UDFs for details.

You can use DEFINE_CAPILLARY_PRESSURE to specify your own formulation of capillary pressure for the electrolysis and H2 pump model. For more information about the electrolysis and H2 pump model, see Electrolysis and H2 Pump Model in the Fluent Theory Guide.

DEFINE_CAPILLARY_PRESSURE (name, c, t, cp, dcpdalpha, s)

Function returns

void

There are six arguments to DEFINE_CAPILLARY_PRESSURE: name, c, t, cp, dcpdalpha, and s. You supply name, the name of the UDF. c, t, cp, dcpdalpha, and s are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to set the values of cp, dcpdalpha.

The following example shows how to use the DEFINE_CAPILLARY_PRESSURE UDF to assign constant values to capillary pressure and the capillary pressure gradient in the space of the volume fraction of the liquid phase.

/******************************************************************************
 #include "udf.h"

DEFINE_CAPILLARY_PRESSURE(capillary_pre,c,t,cp,dpcdalpha, s)
{
  *cp = 100;
  *dpcdalpha = 10000;
  return;
}

The following UDF, named capillary_pre, calculates the capillary pressure using the Leverett function with the contact angle less than 90 degrees.

/******************************************************************************
 #include "udf.h"

DEFINE_CAPILLARY_PRESSURE(capillary_pre,c,t,cp,dpcdalpha,s)
{
  real av = 1.417;
  real bv = 2.12;
  real cv = 1.263;
  real theta = 60;
  real sigma = 0.0644;
  real porosity = 0.5;
  real perm = 1e-12;
 
  real Js = av * (1 - s) - bv * (1 - s) * (1 - s) + cv * pow(1 - s, 3);
  real dJsdalpha = - (av - 2 * bv * (1.0 - s) + 3 * cv * (1.0 - s) * (1.0 - s));
 
  *cp = sigma * cos(theta * M_PI / 180.) * sqrt(porosity / perm) * Js;
  *dpcdalpha = sigma * cos(theta * M_PI / 180.) * sqrt(porosity / perm) * dJsdalpha;
 
  return;
}

After the UDF that you have defined using DEFINE_CAPILLARY_PRESSURE is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the Anode and Cathode tabs of the Potential/Electrochemistry dialog box in Ansys Fluent. See Hooking DEFINE_CAPILLARY_PRESSURE UDFs for details.

You can use DEFINE_CHEM_STEP to specify the change in mass fraction due to homogeneous reaction over a time step:

(2–2)

where is the initial mass fraction of species , is time, is the given time step, and is the net rate of change of the ^th species mass fraction. is ^th species mass fraction at the end of the integration.

DEFINE_CHEM_STEP UDFs are used for the laminar finite-rate (with the stiff chemistry solver), EDC and PDF Transport models.

DEFINE_CHEM_STEP (name, c, t, p, num_p, n_spe, dt, pres, temp, yk)

Function returns

void

There are nine arguments to DEFINE_CHEM_STEP: name, c, p, num_p, n_spe, dt, pres, temp, and yk. You supply name, the name of the UDF. c, p, n_spe, dt, pres, temp, and yk are variables that are passed by the Ansys Fluent solver to your UDF. num_p is not used by the function and can be ignored. The output of the function is the array of mass fractions yk after the integration step. The initial mass fractions in array yk are overwritten.

The following UDF, named user_chem_step, assumes that the net volumetric reaction rate is the expression,

(2–3)

where is the number of species.

An analytic solution exists for the integral of this ODE as,

(2–4)

/***************************************************
   Example UDF that demonstrates DEFINE_CHEM_STEP
 ***************************************************/
 #include "udf.h"
 
 DEFINE_CHEM_STEP(user_chem_step,cell,thread,particle,nump,nspe,dt,pres,temp,yk)
 {
   int i;
   double c = 1./(double)nspe;
   double decay = exp(-(*dt));
   for(i=0;i<n_spe;i++)
      yk[i] = (yk[i]-c)*decay + c;
 } 

After the UDF that you have defined using DEFINE_CHEM_STEP is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_chem_step) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_CHEM_STEP UDFs for details.

You can use DEFINE_CPHI to set the value of the mixing constant (see Equation 7–153 and Equation 7–155 in the Theory Guide for details). It is useful for modeling flows where departs substantially from its default value of , which occurs at low Reynolds and/or high Schmidt numbers.

DEFINE_CPHI (name, c, t)

Function returns

real

There are three arguments to DEFINE_CPHI: name, c, and t. You supply name, the name of the UDF. c and t are passed by the Ansys Fluent solver to your UDF. Your UDF will need to compute the real value of the mixing constant () and return it to the solver.

After the UDF that you have defined using DEFINE_CPHI is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent whenever the Composition PDF Transport model is enabled. See Hooking DEFINE_CPHI UDFs for details.

You can use DEFINE_CORNER_FLOW_CORRECTION_CCORNER to specify a custom coefficient for which is used in the corner flow correction term to influence the strength of the corner flow correction if needed for a specific flow.

DEFINE_CORNER_FLOW_CORRECTION_CCORNER (name, c, t)

Function returns

real

There are three arguments to these functions: name, c, and t. You specify the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF returns the real value for the corner flow correction coefficient .

In the following example, a zonal approach is demonstrated. Depending on the x-coordinate, the corner flow correction coefficient has different values.

#include "udf.h"
DEFINE_CORNER_FLOW_CORRECTION_CCORNER(corner_flow_ccorner, c, t)
 {
    real corner_flow_correction_ccorner;
    real xc[ND_ND];
    C_CENTROID(xc,c,t);
    if (xc[0] > 2.0)
      corner_flow_correction_ccorner = 1.1;
    else
      corner_flow_correction_ccorner = 1.0;
    return corner_flow_correction_ccorner;
 }

After the UDF that you have defined using DEFINE_CORNER_FLOW_CORRECTION_CCORNER is interpreted or compiled, the name of the argument that you supplied as the DEFINE macro argument (for example, corner_flow_ccorner) will become visible and selectable in the Viscous Model dialog box in the drop-down menu of the model coefficient.

You can use DEFINE_CURVATURE_CORRECTION_CCURV to specify a custom function for the coefficient which is used in the curvature correction term to influence the strength of the curvature correction, if needed for a specific flow. For more information, see Curvature Correction for the Spalart-Allmaras and Two-Equation Models in the Fluent Theory Guide.

The coefficient should be positive and in the case of a user defined function, the provided value of is automatically limited by max(,0).

DEFINE_CURVATURE_CORRECTION_CCURV (name, c, t)

Function returns

real

There are 3 arguments for DEFINE_CURVATURE_CORRECTION_CCURV: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value for the curvature correction coefficient .

In the following example, a zonal approach is demonstrated: Depending on the x-coordinate, the curvature correction coefficient has different values.

#include "udf.h"
DEFINE_CURVATURE_CORRECTION_CCURV(user_curvcor_ccurv, c, t)
{
  real curvature_correction_ccurv;
  real xc[ND_ND];
  C_CENTROID(xc,c,t);
  if (xc[0] > 2.0)
    curvature_correction_ccurv = 1.1;
  else
    curvature_correction_ccurv = 1.0;
  return curvature_correction_ccurv;
} 

After the UDF that you have defined using DEFINE_CURVATURE_CORRECTION_CCURV is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name that you specified in the DEFINE macro argument (for example, user_curvcor_ccurv) will become visible and selectable in the Viscous Model dialog box in the drop-down menu for the curvature correction coefficient.

You can use DEFINE_DIFFUSIVITY to specify the diffusivity for the species transport equations (for example, mass diffusivity) or for user-defined scalar (UDS) transport equations. For details about UDS diffusivity, see User-Defined Scalar (UDS) Diffusivity in the User’s Guide.

DEFINE_DIFFUSIVITY (name, c, t, i)

Function returns

real

There are four arguments to DEFINE_DIFFUSIVITY: name, c, t, and i. You supply name, the name of the UDF. c, t, and i are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to compute the diffusivity only for a single cell and return the real value to the solver.

Note that diffusivity UDFs are called by Ansys Fluent from within a loop on cell threads. Consequently, your UDF will not need to loop over cells in a thread since Ansys Fluent is doing it outside of the function call.

The following UDF, named mean_age_diff, computes the diffusivity for the mean age of air using a user-defined scalar. Note that the mean age of air calculations do not require that energy, radiation, or species transport calculations have been performed. You will need to set uds-0 = at all inlets and outlets in your model. This function can be executed as an interpreted or compiled UDF.

/**********************************************************************
   UDF that computes diffusivity for mean age using a user-defined
   scalar.
 ***********************************************************************/
 
 #include "udf.h"
 
 DEFINE_DIFFUSIVITY(mean_age_diff,c,t,i)
 {
    return C_R(c,t) * 2.88e-05 + C_MU_EFF(c,t) / 0.7;
 } 

After the UDF that you have defined using DEFINE_DIFFUSIVITY is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name that you specified in the DEFINE macro argument (for example, mean_age_diff) will become visible and selectable in the Create/Edit Materials dialog box in Ansys Fluent. See Hooking DEFINE_DIFFUSIVITY UDFs for details.

You can use DEFINE_DOM_DIFFUSE_REFLECTIVITY to modify the inter-facial reflectivity computed by Ansys Fluent at diffusely reflecting semi-transparent walls, based on the refractive index values. During execution, a DEFINE_DOM_DIFFUSE_REFLECTIVITY function is called by Ansys Fluent for each semi-transparent wall and also for each band (in the case of a non-gray discrete ordinates (DO) model). Therefore the function can be used to modify diffuse reflectivity and diffuse transmissivity values at the interface.

DEFINE_DOM_DIFFUSE_REFLECTIVITY (name, t, nb, n_a, n_b, diff_ref_a, diff_tran_a, diff_ref_b, diff_tran_b)

Function returns

void

There are nine arguments to DEFINE_DOM_DIFFUSE_REFLECTIVITY: name, t, nb, n_a, n_b, diff_ref_a, diff_tran_a, diff_ref_b, and diff_tran_b. You supply name, the name of the UDF. t, nb, n_a, n_b, diff_ref_a, diff_tran_a, diff_ref_b, and diff_tran_b are variables that are passed by the Ansys Fluent solver to your UDF.

The following UDF, named user_dom_diff_refl, modifies diffuse reflectivity and transmissivity values on both the sides of the interface separating medium a and b. The UDF is called for all the semi-transparent walls and prints the value of the diffuse reflectivity and transmissivity values for side a and b.

/* UDF to print the diffuse reflectivity and transmissivity 
 at semi-transparent walls*/
 
 #include "udf.h"
 
 DEFINE_DOM_DIFFUSE_REFLECTIVITY(user_dom_diff_refl,t,nband,n_a,n_b,diff_ref_a,diff_tran_a,diff_ref_b,diff_tran_b)
 {
   printf("diff_ref_a=%f diff_tran_a=%f \n", *diff_ref_a, *diff_tran_a);
   printf("diff_ref_b=%f diff_tran_b=%f \n", *diff_ref_b, *diff_tran_b);
 } 

After the UDF that you have defined using DEFINE_DOM_DIFFUSE_REFLECTIVITY is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_dom_diff_refl) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent.

See Hooking DEFINE_DOM_DIFFUSE_REFLECTIVITY UDFs for details.

You can use DEFINE_DOM_SOURCE to modify the emission term, which is the first term on the right hand side in Equation 5–98 or Equation 5–99 in the Theory Guide, as well as the scattering term (second term on the right hand side of either equation) in the radiative transport equation for the discrete ordinates (DO) model.

DEFINE_DOM_SOURCE (name, c, t, ni, nb, emission, in_scattering, abs_coeff, scat_coeff)

Function returns

void

There are nine arguments to DEFINE_DOM_SOURCE: name, t, c, ni, nb, emission, in_scattering, abs_coeff, and scat_coeff. You supply name, the name of the UDF. c, ni, nb, emission, in_scattering, abs_coeff, and scat_coeff are variables that are passed by the Ansys Fluent solver to your UDF. DEFINE_DOM_SOURCE is called by Ansys Fluent for each cell.

In the following UDF, named dom, the emission term present in the radiative transport equation is modified. The UDF is called for all the cells and increases the emission term by .

/* UDF to alter the emission source term in the DO model */
 
 #include "udf.h"
 
 DEFINE_DOM_SOURCE(dom,c,t,ni,nb,emission,in_scattering,abs_coeff,scat_coeff)
 {
   /* increased the emission by 5% */

   *emission *= 1.05;
 
 } 

After the UDF that you have defined using DEFINE_DOM_SOURCE is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, dom) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. Note that you can hook multiple discrete ordinate source term functions to your model. See Hooking DEFINE_DOM_SOURCE UDFs for details.

You can use DEFINE_DOM_SPECULAR_REFLECTIVITY to modify the inter-facial reflectivity of specularly reflecting semi-transparent walls. You may want to do this if the reflectivity is dependent on other conditions that the standard boundary condition does not allow for (see Specular Semi-Transparent Walls of the Theory Guide for more information). During Ansys Fluent execution, the same UDF is called for all the faces of the semi-transparent wall, for each of the directions.

DEFINE_DOM_SPECULAR_REFLECTIVITY (name, f, t, nband, n_a, n_b, ray_direction, en, internal_reflection, specular_reflectivity, specular_transmissivity)

Function returns

void

There are eleven arguments to DEFINE_DOM_SPECULAR_REFLECTIVITY: name, f, t, nband, n_a, n_b, ray_direction, en, internal_reflection, specular_reflectivity, and specular_transmissivity. You supply name, the name of the UDF. f, t, nband, n_a, n_b, ray_direction, en, internal_reflection, specular_reflectivity, and specular_transmissivity are variables that are passed by the Ansys Fluent solver to your UDF.

In the following UDF, named user_dom_spec_refl, specular reflectivity and transmissivity values are altered for a given ray direction at face f.

/* UDF to alter the specular reflectivity and transmissivity, at
  semi-transparent walls, along direction s at face f */
 
 #include "udf.h"
 
 DEFINE_DOM_SPECULAR_REFLECTIVITY(user_dom_spec_refl,f,t,nband,n_a,n_b,ray_direction,en,internal_reflection,specular_reflectivity,specular_transmissivity)
 {
   real angle, cos_theta;
   real PI = 3.141592;
   cos_theta = NV_DOT(ray_direction, en);
   angle = acos(cos_theta);
   if (angle > 0.785398  && angle < 1.047198)
      {
        *specular_reflectivity = 0.3;
        *specular_transmissivity = 0.7;
      }
 }

After the UDF that you have defined using DEFINE_DOM_SPECULAR_REFLECTIVITY is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_dom_spec_refl) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent.

See Hooking DEFINE_DOM_SPECULAR_REFLECTIVITY UDFs for details.

You can use DEFINE_EC_KINETICS_PARAMETER to customize any of the kinetics parameters (anodic and cathodic transfer coefficient, exchange current density, and equilibrium potential) in the Butler-Volmer equation. The UDF can be hooked up from the Reaction dialog box.

DEFINE_EC_KINETICS_PARAMETER(name, f, fthread)

Function returns

double

There are three arguments to DEFINE_EC_KINETICS_PARAMETER: name, f, and fthread. You supply name, the name of the UDF. f and fthread are variables that are passed by the Ansys Fluent solver to your UDF. After your UDF is compiled and linked, the name that you have chosen for your function will become visible and selectable in the graphical user interface in Ansys Fluent. Your UDF will return a double value to the kinetics parameter which you have hooked up to.

The following compiled UDF, named ec_parameter_Eeq, computes temperature-dependent equilibrium potential through the UDF approach. You can use this type of UDF to compute any of the four kinetics parameters used in the electrochemical reaction (anodic transfer coefficient/anodic Tafel slope, cathodic transfer coefficient/cathodic Tefel slope, exchange current density, and equilibrium potential).

/*******************************************************************
Custom electrochemical reaction kinetics parameter UDF
********************************************************************/
#include "udf.h"
DEFINE_EC_KINETICS_PARAMETER(ec_parameter_Eeq, f, fthread)
{
  real T, Eeq;  
  T = F_T(f, fthread);
  Eeq = 0.8 + 0.0001 * T; 
  return Eeq;
}

After the UDF that you have defined using DEFINE_EC_KINETICS_PARAMETER is compiled and loaded (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, ec_parameter_Eeq) will become visible and selectable after you select the user-defined option for a kinetics parameter in the Reaction dialog box. See Hooking DEFINE_EC_KINETICS_PARAMETER UDFs for details.

You can use DEFINE_EC_RATE to specify a custom electrochemical reaction rate. A custom electrochemical reaction rate function defined using this macro will overwrite the default reaction rate specified in the Create/Edit Materials dialog box.

DEFINE_EC_RATE (name, f, t, r, V, i, didV, Eeq)

Function returns

void

There are eight arguments to DEFINE_EC_RATE: name, f, t, r, V, i, didV, and Eeq. You supply name, the name of the UDF. f, t, r, and V are variables that are passed by the Ansys Fluent solver to your UDF. After your UDF is compiled and linked, the name that you have chosen for your function will become visible and selectable in the graphical user interface in Ansys Fluent. Your UDF will need to set three values referenced by the real pointers i didV, and Eeq.

The following compiled UDF, named user_ec_rate, implements the solver default Butler-Volmer equation through the UDF approach. You can customize a term (for example, the exchange current density i0 or the equilibrium potential Eeq) or the whole rate formula.

/*******************************************************************
 Custom electrochemical reaction rate UDF
 ********************************************************************/
 #include "udf.h"
 DEFINE_EC_RATE(user_ec_rate, f, fthread, r, V, current, didV, Eeq)
 {
   double alpha_a, alpha_c;
   double io;
   double T = F_T(f,fthread);
   double arg1, arg2;
   cxboolean tafelmethod = r->tafelmethod;
   int i;
   double eta;
   io      = update_echem_value(r->Pio, f, fthread);
   alpha_a = update_echem_value(r->Palpha_a, f, fthread);
   alpha_c = update_echem_value(r->Palpha_c, f, fthread);
   *Eeq    = update_echem_value(r->PEeq, f, fthread);
 
   if (tafelmethod) 
   {
     alpha_a = 2.303 * UNIVERSAL_GAS_CONSTANT * 298.15 /(alpha_a * FARADAY_CONSTANT);
     alpha_c = 2.303 * UNIVERSAL_GAS_CONSTANT * 298.15 /(alpha_c * FARADAY_CONSTANT);
   }
   eta = V - *Eeq;
   for(i = 0; i<r->n_reactants; i++)
     if( ABS( r->exp_reactant[i] ) > SMALL_S )
     {
       int ni = r->reactant[i];
       io *= pow((F_YI(f,fthread,ni)/MAX(r->yi_ref[ni],SMALL) + 1.0e-20), r->exp_reactant[i]);
     }
   for(i = 0; i<r->n_products; i++)
     if( ABS( r->exp_product[i] ) > SMALL_S )
     {
       int ni = r->product[i];
       io *= pow((F_YI(f,fthread,ni)/MAX(r->yi_ref[ni],SMALL) + 1.0e-20), r->exp_product[i]);
     }
   arg1 = FARADAY_CONSTANT / (UNIVERSAL_GAS_CONSTANT*T);
   arg2 = arg1*eta;
   *current = io*( exp( arg2*alpha_a ) - exp( -arg2*alpha_c ) );
   *didV = io*( arg1*alpha_a*exp( arg2*alpha_a ) + arg1*alpha_c*exp( -arg2*alpha_c ) );

   /* If multiple electrochemical reactions are used, you can define rate for each reaction
      using the following if-statement */
   /*
   if (STREQ(r->name, "reaction-1"))
   {
     ...
   }
   else if (STREQ(r->name, "reaction-2"))
   {
     ...
   }
 */
 } 

After the UDF that you have defined using DEFINE_EC_RATE is compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_ec_rate) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_EC_RATE UDFs for details.

In Ansys Fluent, the Eddy Dissipation Concept (EDC) model closes the species transport equations according to the terms given in The Eddy-Dissipation-Concept (EDC) Model in the Fluent Theory Guide. You can use the DEFINE_EDC_MDOT UDF to modify the reaction rate for the EDC model as shown in Equation 7–42 in the Fluent Theory Guide. Equation 7–42 can be rewritten as follows:

(2–5)

This UDF allows you to use your own formulation to calculate the term and the time scale in Equation 2–5.

DEFINE_EDC_MDOT (name, c, t, mdot, calc_tau, tau)

Argument Type	Description
symbol name	UDF name.
cell_t c	Cell or face index.
Thread *t	Pointer to the cell or face thread.
real *mdot	Pointer to parameter .
int calc_tau	Integer that indicates whether tau will be calculated (tau will be computed if calc_tau is set to a non-zero value).
real *tau	Pointer to value.

Function returns

void

There are six arguments to DEFINE_EDC_MDOT: name, c, t, mdot, calc_tau, and tau. You supply name, the name of the UDF. The variables c, t, mdot, calc_tau, and tau are passed by the Ansys Fluent solver to your UDF. The values of mdot and tau passed by the Ansys Fluent solver are those used by the solver unless they are reset by this routine. The routine may reset any or all of these values.

The calc_tau indicator is provided for efficiency purposes as DEFINE_EDC_MDOT will be called several times by the solver but will not always use the tau value. Enclosing the tau calculation with if (calc_tau) {}, as in Example, will thus maximize the efficiency of this routine.

The following example is a source code template where the DEFINE_EDC_MDOT function is used to set the term for the EDC model.

/*******************************************************************
 Example UDF that demonstrates the use of DEFINE_EDC_MDOT to set the 
term mdot in the EDC model.
 ********************************************************************/
 #include <udf.h>
 
 DEFINE_EDC_MDOT(edc_mdot, c, t, mdot, calc_tau, tau)
 {
  real ted1 = MAX(C_D(c,t), 1.0e-03);
  real ted2 = C_D(c, t);
  real c2 = 0.4083;
  real c1 = 2.1377;
  real gamma2,gamma = c1 * pow( C_MU_L(c, t) * ted2 / (C_R(c, t) * SQR(C_K(c, t))), 0.25);
  gamma = MIN( gamma, 0.754877666248);
  gamma2 = gamma * gamma;
  *mdot = gamma2 / ((1. - gamma2 * gamma));
  if (calc_tau)
     {*tau=c2*sqrt(C_MU_L(c,t)/(ted1*C_R(c,t)));
      *tau = MAX(*tau, 1.e-8);}

 } 

After you have compiled and loaded (Compiling UDFs) the DEFINE_EDC_MDOT UDF and enabled the Eddy Dissipation Concept model, the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the Options group box of the Species Model dialog box in Ansys Fluent. See Hooking DEFINE_DOM_DIFFUSE_REFLECTIVITY UDFs for details.

In Ansys Fluent, the Eddy Dissipation Concept (EDC) model closes the species transport equations according to the terms given in The Eddy-Dissipation-Concept (EDC) Model in the Fluent Theory Guide. This UDF allows you to modify the coefficients (Equation 7–44) and (Equation 7–45) and the term (Equation 7–45).

DEFINE_EDC_SCALES (name, c, t, c1, c2, calc_tau, tau)

Argument Type	Description
symbol name	UDF name.
cell_t c	Cell or face index.
Thread *t	Pointer to the cell or face thread.
real *c1	Pointer to coefficient .
real *c2	Pointer to coefficient .
int calc_tau	Integer that indicates whether tau will be calculated (tau will be computed if calc_tau is set to a non-zero value).
real *tau	Pointer to value.

Function returns

void

There are seven arguments to DEFINE_EDC_SCALES: name, c, t, c1, c2, calc_tau, and tau. You supply name, the name of the UDF. The variables c, t, c1, c2, calc_tau, and tau are passed by the Ansys Fluent solver to your UDF. The values of c1, c2 and tau passed by the Ansys Fluent solver are those used by the solver unless they are reset by this routine. The routine may reset any or all of these values.

The calc_tau indicator is provided for efficiency purposes as DEFINE_EDC_SCALES will be called several times by the solver but will not always use the tau value. Enclosing the tau calculation with if (calc_tau) {}, as in Example, will thus maximize the efficiency of this routine.

The following example is a source code template where the DEFINE_EDC_SCALES function is used to set the EDC model scales.

/*******************************************************************
 Example UDF that demonstrates the use of DEFINE_EDC_SCALES to set the 
EDC model scales.
 ********************************************************************/
 #include <udf.h>
 
 DEFINE_EDC_SCALES(edc_scales, c, t, c1, c2, calc_tau, tau)
 {
   real ted = MAX(C_D(c,t), 1.0e-03);

   *c1 = 2.1337;
   *c2 = 0.4082;

   if (calc_tau)
     *tau = (*c2)*sqrt(C_MU_L(c,t)/(ted*C_R(c,t)));
 } 

After you have compiled and loaded (Compiling UDFs) the DEFINE_EDC_SCALES UDF and enabled the Eddy Dissipation Concept model, the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the Options group box of the Species Model dialog box in Ansys Fluent. See Hooking DEFINE_EDC_SCALES UDFs for details.

In Ansys Fluent, the electrolysis model calculates the transfer currents and using the Butler-Volmer equations (Equation 20–66 and Equation 20–67 in the Fluent Theory Guide). You can use DEFINE_ELECTROLYSIS_ECHEM_RATE to modify the transfer current formulations by using an effective factor as follows:

This UDF allows you to use different values of the transfer current for the specific active surface area in different computational cells.

DEFINE_ELECTROLYSIS_ECHEM_RATE (name, c, t, f)

Function returns

void

There are four arguments to DEFINE_ELECTROLYSIS_ECHEM_RATE: name, c, t, and f. You supply name, the name of the UDF. The variables c, t, and f are passed by the Ansys Fluent solver to your UDF. Your UDF will need to set the values of f.

The following example shows how to use the DEFINE_ELECTROLYSIS_ECHEM_RATE UDF to assign a constant value to the effective factor f.

/******************************************************************************
 #include "udf.h"

DEFINE_ELECTROLYSIS_ECHEM_RATE (myrate, c, t, f)
{
  *f = 2;
  return;
}

After the UDF that you have defined using DEFINE_ELECTROLYSIS_ECHEM_RATE compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the Customization tab of the Potential/Electrochemistry dialog box in Ansys Fluent. See Hooking DEFINE_ELECTROLYSIS_ECHEM_RATE UDFs for details.

You can use DEFINE_ELECTROLYSIS_RELATIVE_PERMEABILITY to customize the relative permeability used in the transport equation of the volume fraction of liquid water (Equation 18–17). This UDF allows you to specify different relative permeabilities in different cell zones.

DEFINE_ELECTROLYSIS_RELATIVE_PERMEABILITY (name, c, t, rp, s)

Function returns

void

There are five arguments to DEFINE_ELECTROLYSIS_RELATIVE_PERMEABILITY: name, c, t, rp, and s. You supply name, the name of the UDF. The variables c, t, rp, and s are passed by the Ansys Fluent solver to your UDF. Your UDF will need to set the values of rp.

The following UDF, named myrate, models the relative permeability as a power function of the liquid saturation.

/******************************************************************************
 #include "udf.h"

DEFINE_ELECTROLYSIS_RELATIVE_PERMEABILITY (myrate, c, t, rp, s)
{
  *rp = pow(s, 3.0);
   return;
}

After the UDF that you have defined using DEFINE_ELECTROLYSIS_RELATIVE_PERMEABILITY compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the Customization tab of the Potential/Electrochemistry dialog box in Ansys Fluent. See Hooking DEFINE_ELECTROLYSIS_RELATIVE_PERMEABILITY UDFs for details.

When employing the non-gray P-1 radiation model or the non-gray discrete ordinates (DO) radiation model, you can use DEFINE_EMISSIVITY_WEIGHTING_FACTOR to modify the emissivity weighting factor . By default, the emissivity weighting factor is calculated internally by Ansys Fluent so it can be used in the emission term of the radiative transfer equation, as shown in Equation 5–64 and Equation 5–100 of the Theory Guide. This macro allows you to revise the calculated value.

DEFINE_EMISSIVITY_WEIGHTING_FACTOR (name, c, t, T, nb, emissivity_weighting_factor)

Function returns

void

There are six arguments to DEFINE_EMISSIVITY_WEIGHTING_FACTOR: name, c, t, T, nb, and emissivity_weighting_factor. You supply name, the name of the UDF. c, t, T, nb, and emissivity_weighting_factor are variables that are passed by the Ansys Fluent solver to your UDF. DEFINE_EMISSIVITY_WEIGHTING_FACTOR is called by Ansys Fluent for each cell.

In the following UDF (named em_wt), the emissivity weighting factor present in the emission term of the radiative transfer equation for the non-gray DO model is modified. The UDF is called for all of the cells. It modifies the emissivity weighting factor so that it is no longer the value calculated internally by Ansys Fluent, but is instead changed to .

/* UDF to alter the emissivity weighting factor for the non-gray DO model */
 
 #include "udf.h"
 
 DEFINE_EMISSIVITY_WEIGHTING_FACTOR(em_wt,c,t,T,nb,emissivity_weighting_factor)
 {

   /* revise the calculated emissivity_weighting_factor to be a value of 1 */

   *emissivity_weighting_factor = 1.0;
 
 } 

After the UDF that you have defined using DEFINE_EMISSIVITY_WEIGHTING_FACTOR is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, em_wt) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_EMISSIVITY_WEIGHTING_FACTOR UDFs for details.

You can use DEFINE_FLAMELET_PARAMETERS to specify a user-defined variation of scalar dissipation, mean mixture fraction grid, and mean progress variable grid for flamelet generation with non-premixed or partially premixed combustion models. The UDF is only available if either the Non-Premixed Combustion or Partially-Premixed Combustion model is enabled.

DEFINE_FLAMELET_PARAMETERS (name, Nf, Nc, Ns, xf, xc, xs)

Function returns

void

There are seven arguments to DEFINE_FLAMELET_PARAMETERS: name, Nf, Nc, Ns, xf, xc, and xs. You supply name, the name of the UDF. Nf, Nc, Ns, xf, xc, and xs are variables that are passed by the Ansys Fluent solver to your UDF. DEFINE_FLAMELET_PARAMETERS does not output a value. The specified grid discretizations or scalar dissipation variations are stored in the arrays xf, xc, and xs, respectively.

The following compiled UDF, named user_scad_fmean_grid, is used to provide the user-defined scalar dissipation variation and user-defined mean mixture fraction grid points for flamelet solution.

 #include "udf.h"
 #define fsto 0.056
 
 DEFINE_FLAMELET_PARAMETERS(user_scad_fmean_grid,nf,nc,ns,xf,xc,xs)
 {
    int i,np,np_rich ;

  /* The arrays xf,xc,xs passed by the solver contains default 
     discretization and default scalar dissipation variation*/

  /* These arrays can be over-written with user-defined grid or scalar 
     dissipation variation*/

  /* Flamelets with Scalar dissipation of
     0.01, 0.05, 0.1, 0.15, 0.2, 1, 4, 7, 10,... */


    for(i=0;i<ns;i++)
      {
       if (i < 5)
         xs[i] = 0.01*5*i;
       else
         xs[i] = 1.+(i-5)*3;
      }
 
  /* Sample UDF to provide user defined discretization for fmean grid
     for flamelet generation*/

  /* Divide fmean grid into 3 intervals: (1) f=0 to fsto, (2) fsto to 2.*fsto
     and (3) 2.*fsto to f=1.*/

  /* Place equal number of grid points in these three intervals*/

    if(nf > 0)
      {
       np = (int) nf/3;
       np_rich = 2*np;
      }
    for(i=0;i<nf;i++)
      {
       if(i <= np)
         {
          xf[i] = i*fsto/np;
         }
       else if(i <= np_rich)
         {
          xf[i] = fsto+fsto*(i-np)/(np_rich-np);
         }
       else
         {
          xf[i]= 2.*fsto + (1.-2*fsto)*(i-np_rich)/(nf-1-np_rich);
         }
      }
 } 

After the UDF that you have defined using DEFINE_FLAMELET_PARAMETERS is compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_scad_fmean_grid) will become visible and selectable in the User-Defined Function drop-down list under the Flamelet tab of the Species Model dialog box in Ansys Fluent. See Hooking DEFINE_FLAMELET_PARAMETERS UDFs for details.

You can use DEFINE_GAP_MODEL_SOURCE to specify source terms for momentum and energy equations for the cells located in a gap region. For details about using the gap model, see Controlling Flow in Narrow Gaps for Valves and Pumps in the Fluent User's Guide.

DEFINE_GAP_MODEL_SOURCE (name, c, tc, Source, dS)

Function returns

real

There are five arguments to DEFINE_GAP_MODEL_SOURCE: name, c, tc, Source, and dS. You supply name, the name of the UDF. c and tc are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF returns the real value of Source and dS.

The following compiled UDF, named gap_user_sources, is used to provide the source terms for momentum and energy equations for the cells located in a gap region.

#include "udf.h"

DEFINE_GAP_MODEL_SOURCE(gap_user_sources, c, tc, Source, dS)
{
real Vmag = ND_MAG(C_U(c,tc), C_V(c,tc), C_W(c,tc));
Source[EQ_X_MOM_GAP_SOURCE] = -0.5 * C_R(c,tc) * Vmag * C_U(c,tc);
Source[EQ_Y_MOM_GAP_SOURCE] = -0.5 * C_R(c,tc) * Vmag * C_V(c,tc);
Source[EQ_Z_MOM_GAP_SOURCE] = -0.5 * C_R(c,tc) * Vmag * C_W(c,tc);
Source[EQ_ENERGY_GAP_SOURCE] = 0.0;

dS[EQ_X_MOM_GAP_SOURCE] = -0.5 * C_R(c,tc) * Vmag ;
dS[EQ_Y_MOM_GAP_SOURCE] = -0.5 * C_R(c,tc) * Vmag ;
dS[EQ_Z_MOM_GAP_SOURCE] = -0.5 * C_R(c,tc) * Vmag ;
dS[EQ_ENERGY_GAP_SOURCE] = 0.0;

return;
} 

After the UDF that you have defined using DEFINE_GAP_MODEL_SOURCE is compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, gap_user_sources) will become visible and selectable in the Gap Source Terms drop-down list of the Edit Gap Region dialog box in Ansys Fluent. For details, see Hooking DEFINE_GAP_MODEL_SOURCE UDFs.

You can use DEFINE_GEOMETRY to define an auxiliary geometry definition, as described in Managing Auxiliary Geometry Definitions in the Fluent User's Guide. Note that UDFs that are defined using DEFINE_GEOMETRY can only be executed as compiled UDFs.

DEFINE_GEOMETRY (name, o, x)

Function returns

void

There are three arguments to DEFINE_GEOMETRY: name, o, and x. You supply the name. The return value is an integer. This return value differs based on the arguments passed into this function. When the pointer o is NULL, this signifies that the geometry is being displayed via the graphical user interface, and the UDF must return the maximum number of triangles to be displayed, with the desired triangle edge length also filled in x. When the pointer o is not NULL, it signifies that the UDF is in projection mode, and the UDF must write the projected coordinate location into x. The return integer value specifies whether the projection is on a boundary edge (1) or the interior of the surface (0).

The following UDF, named geometry_udf, is executed as a compiled UDF. Note that this example uses a sphere which has no boundaries, so it is fine to unconditionally return 0 for the integer value (to indicate that it is the interior of the surface).

#include "udf.h"

/**
 * @brief
 *   Project point to test geometry
 * @param o
 *   Pointer to geometry object
 * @param x
 *   Pointer to coordinate
 */
DEFINE_GEOMETRY(geometry_udf, o, x)
{
  if (NULLP(o))
  {
    /* Define edge-length and maximum number of facets for display */
    *x = 0.5; return 1000;
  }
  else
  {
    real radius = 2.5;
    real NV_VEC(center) = { 0 };
    real NV_VEC(r) = { 0 }, mag_r = 0, mag_d = 0;

    NV_D(center, =, 0.1, 0.2, 0.3);

    /* Vector from sphere center to coordinate */
    NV_VV(r, =, x, -, center);

    /* Normalize vector and scale by difference to radius */
    mag_r = (NV_MAG(r) + EPSILON);
    mag_d = (radius - mag_r) / mag_r;

    /* Add difference vector to original coordinate */
    NV_VS(x, +=, r, *, mag_d);
  }

  return 0;
}

After the UDF that you have defined using DEFINE_GEOMETRY is compiled (see Compiling UDFs for details), the name of the argument that you supplied as the first DEFINE macro argument will become visible in the Auxiliary Geometry Definition dialog box in Ansys Fluent. See Hooking DEFINE_GEOMETRY UDFs for details on how to hook your DEFINE_GEOMETRY UDF to Ansys Fluent.

You can use DEFINE_GRAY_BAND_ABS_COEFF to specify a UDF for the gray band absorption coefficient as a function of temperature, that can be used with a non-gray discrete ordinates model.

DEFINE_GRAY_BAND_ABS_COEFF (name, c, t, nb)

Function returns

real

There are four arguments to DEFINE_GRAY_BAND_ABS_COEFF: name, c, t, and nb. You supply name, the name of the UDF. The variables c, t, and nb are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value of the gray band coefficient to the solver.

The following UDF, named user_gray_band_abs, specifies the gray-band absorption coefficient as a function of temperature that can be used for a non-gray discrete ordinates model.

#include "udf.h"
 
 DEFINE_GRAY_BAND_ABS_COEFF(user_gray_band_abs,c,t,nb)
 {
   real abs_coeff = 0;
   real T = C_T(c,t);

    switch (nb)
    {
      case 0 : abs_coeff = 1.3+0.001*T; break;
      case 1 : abs_coeff = 2.7 + 0.005*T; break;
     }
 
 return abs_coeff;
 
 } 

After the UDF that you have defined using DEFINE_GRAY_BAND_ABS_COEFF is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_gray_band_abs) will become visible and selectable in the Create/Edit Materials dialog box for the Absorption Coefficient.

See Hooking DEFINE_GRAY_BAND_ABS_COEFF UDFs for details.

You can use DEFINE_HEAT_FLUX to modify the heat flux at a wall. Despite the name, a DEFINE_HEAT_FLUX UDF is not the means to specify the actual heat flux entering a domain from the outside. To specify this type of heat flux, you would simply use a DEFINE_PROFILE function in conjunction with a heat flux thermal boundary condition. In contrast, a DEFINE_HEAT_FLUX UDF allows you to modify the way in which the dependence between the flux entering the domain and the wall and cell temperatures is modeled.

DEFINE_HEAT_FLUX (name,f,t,c0,t0,cid,cir)

Function returns

void

There are seven arguments to DEFINE_HEAT_FLUX: name, f, t, c0, t0, cid, and cir. You supply name, the name of the UDF. f, t, c0, and t0 are variables that are passed by the Ansys Fluent solver to your UDF. Arrays cir[] and cid[] contain the linearizations of the radiative and diffusive heat fluxes, respectively, computed by Ansys Fluent based on the activated models. These arrays allow you to modify the heat flux in any way that you choose. Ansys Fluent computes the heat flux at the wall using these arrays after the call to DEFINE_HEAT_FLUX, so the total heat flux at the wall will be the currently computed heat flux (based on the activated models) with any modifications as defined by your UDF.

The diffusive heat flux (qid) and radiative heat flux (qir) are computed by Ansys Fluent according to the following equations:

qid = cid[0] + caf_fac*(cid[1]*C_T(c0,t0) - cid[2]*F_T(f,t)) - cid[3]*pow(F_T(f,t),4)
qir = cir[0] + cir[1]*C_T(c0,t0) - cir[2]*F_T(f,t) - cir[3]*pow(F_T(f,t),4) 

where caf_fac is the convective augmentation factor defined using the define/boundary-conditions/wall text command (for further details, see Augmented Heat Transfer in the User's Guide).

The sum of qid and qir defines the total heat flux from the fluid to the wall (this direction being positive flux), and, from an energy balance at the wall, equals the heat flux of the surroundings (exterior to the domain). Note that heat flux UDFs (defined using DEFINE_HEAT_FLUX) are called by Ansys Fluent from within a loop over wall faces.

Implementing Ansys Fluent’s P-1 Radiation Model Using User-Defined Scalars provides an example of the P-1 radiation model implementation through a user-defined scalar. An example of the usage of the DEFINE_HEAT_FLUX macro is included in that implementation.

After the UDF that you have defined using DEFINE_HEAT_FLUX is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, heat_flux) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_HEAT_FLUX UDFs for details.

You can use DEFINE_IGNITE_SOURCE to customize the ignition time source term in the autoignition model.

DEFINE_IGNITE_SOURCE (name, c, t, source)

Function returns

void

There are four arguments to DEFINE_IGNITE_SOURCE: name, c, t, and source. You supply name, the name of the UDF. c, t and source are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to set the value referenced by the source pointer as shown in the example below.

The following UDF, named ign_udf_src, specifies a custom source term in the ignition model. The source code must be executed as a compiled UDF in Ansys Fluent.

In the standard ignition model in Ansys Fluent, the source term for the ignition progress variable is given by a Livengood-Wu integral [7]:

(2–6)

where is the flow time step and is the correlation between spark time and knock, by Douaud and Eyzat [3]:

(2–7)

Here, is the octane number of the fuel, is the absolute pressure in atmospheres and is the temperature in Kelvin.

In the following UDF example, the Douaud and Eyzat correlation is used to calculate an induction time. See Additional Macros for Writing UDFs for details on the NNULLP, C_STORAGE_R, C_PREMIXC_T, C_P, C_R, CURRENT_TIMESTEP and C_IGNITE macros used below.

/*------------------------------------------------------------------
 This UDF produces an ignition model source in Ansys Fluent v12.0 or  
 later that uses the default parameters for the correlation of Douaud  
 and Eyzat for knock.            
 /*------------------------------------------------------------------*/
 
 #include "udf.h"
 
 real A = 0.01768;    /* Preexponential      */
 real Ea = 3800;     /* Activation temperature    */
 real O_N = 90.0;    /* Octane number      */
 real O_E = 3.402;    /* Octane number exponent    */
 real P_E = -1.7;    /* Pressure exponent     */
 
 static real A1 = 0.0;   /* Cached value of A*ON^OE   */
 static real dt = 0.0;   /* Cached time step      */
 static real p_op = 0.0;   /* Cached value of operating pressure */
 static cxboolean lit = FALSE; /* Cached burning flag    */
 
 DEFINE_IGNITE_SOURCE(ign_udf_src, c, t, source)
 {
    real rho = C_R(c,t);
    real time = 0.0;
    real prog = NNULLP(THREAD_STORAGE(t,SV_PREMIXC_M1)) ?
      C_STORAGE_R(c,t,SV_PREMIXC_M1) :
      C_STORAGE_R(c,t,SV_PREMIXC) ;
    real fuel = 1.0 - prog;
    real T = C_PREMIXC_T(c,t);
    real P = C_P(c,t);
    real ipv = C_IGNITE(c,t);

    if (c == 0)
      {
         dt = CURRENT_TIMESTEP;
         p_op = RP_Get_Real("operating-pressure");
         A1 = A * pow(O_N/100,O_E);
  }

    if (ipv > 1.0)
      lit = TRUE;
    P += p_op;
    P /= 101325.;  /* in atm */
    P = MAX(P,0.01);  /* minimum pressure for ignition */

    if (fuel > 0.99 || lit)
      time = A1 * pow(P,P_E) * exp(Ea/T);

    if (time > 0.0)
      {
         real max_source = rho*(5.0-ipv)/dt;
         real user_source = rho/time;
         *source = MIN(user_source,max_source);
      }
    else
      *source = 0.0;

    return;
 }

After the UDF that you have defined using DEFINE_IGNITE_SOURCE is compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, ign_udf_src) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_IGNITE_SOURCE UDFs for details.

You can use DEFINE_KW_GEKO_CSEP, DEFINE_KW_GEKO_CNW, and DEFINE_KW_GEKO_CMIX to specify your own recipes for the calculation of the coefficients , , and , respectively. DEFINE_KW_GEKO_BF enables you to specify a user defined blending function.

DEFINE_KW_GEKO_CSEP (name, c, t)

DEFINE_KW_GEKO_CNW (name, c, t)

DEFINE_KW_GEKO_CMIX (name, c, t)

DEFINE_KW_GEKO_BF (name, c, t)

Function returns

real

There are three arguments to these functions: name, c, and t. You specify the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF returns the real value of the GEKO coefficients or blending function to the solver.

In the following example, a zonal approach is demonstrated. Depending on the x-coordinate, the GEKO blending function is 1.0 or the built-in version is used.

#include "udf.h"
DEFINE_KW_GEKO_BF(user_geko_bf, c, t)
 {
    real bf_value;
    real xc[ND_ND];
    C_CENTROID(xc,c,t);
    if (xc[0] > 2.0)
      bf_value = Get_Geko_Blending_Function(c,t,
                 C_R(c,t),C_MU_L(c,t), C_WALL_DIST(c,t),
                 C_K(c,t),C_O(c,t));
    else
      bf_value = 1.0;
    return bf_value;
 }

After the UDF that you have defined using DEFINE_KW_GEKO_CSEP, DEFINE_KW_GEKO_CNW, DEFINE_KW_GEKO_CMIX, or DEFINE_KW_GEKO_BF is interpreted or compiled, the name of the argument that you supplied as the DEFINE macro argument (for example, user_geko_bf) will become visible and selectable in the Viscous Model dialog box in the drop-down menu of the corresponding model coefficient or blending function.

You can use DEFINE_MASS_TR_PROPERTY to change inputs (such as heat transfer coefficients, heat flux augmentation/suppression factors, reference velocity, and temperature) for the semi-mechanistic boiling model.

DEFINE_MASS_TR_PROPERTY (name, f, tf, c, tc, from_phase_index, from_species_index, to_phase_index, to_species_index, mass_transfer_index, tabular_data)

Function returns

real

There are eleven arguments to DEFINE_MASS_TR_PROPERTY: name, f, tf, c, tc, from_phase_index, from_species_index, to_phase_index, to_species_index, mass_transfer_index, and tabular_data. You supply name, the name of the UDF. The variables c, mixture_thread, from_phase_index, from_species_index, to_phase_index, to_species_index, mass_transfer_index, and tabular_data are passed by the Ansys Fluent solver to your UDF. Your UDF will return the real input to the solver for a quantity where the UDF is hooked.

The following UDF, named nuc_ht_coeff, defines a nucleate boiling heat transfer coefficient in a two-phase mixture problem.

/* UDF to define a nucleate boiling heat transfer coefficient
   The "from" phase is the liquid phase and the "to" phase is the gas phase */

#include "udf.h"
#include "sg_mphase.h"
#define Tbulk 325
#define sigma 0.07

DEFINE_MASS_TR_PROPERTY(nuc_ht_coeff,f,t,c0,t0,from_index,from_species_index,to_index,to_species_index,mt_index,tabular_data)
 {
   int liq_phase = from_index;
   int gas_phase = to_index;
   Thread *ptl    = THREAD_SUB_THREAD(t0, liq_phase);
   Thread *ptg    = THREAD_SUB_THREAD(t0, gas_phase);
   real T_sat = C_MT_SAT_TEMPERATURE(c0,t0, mt_index);
   real T0 = C_T(c0, t0); 
   real Tw = F_T(f, t);
   real dT_sup = Tw - T_sat;
   real p_abs = C_P(c0,t0) + op_pres;

   real Psat_wall = Get_Tabular_P_Given_T(tabular_data, Tw);
   real Psat = Get_Tabular_P_Given_T(tabular_data, T_sat);
   real dP = MAX(Psat_wall - Psat, 0.);
   real h_lg = Get_Tabular_L_Given_P(tabular_data, p_abs);

   real rhol = C_R(c0, ptl);
   real rhog = C_R(c0, ptg);
   real mul = C_MU_L(c0, ptl);
   real cpl  = C_CP(c0, ptl);
   real kl   = C_K_L(c0, ptl);

   real tmp1 = 0.00122 * pow(kl, 0.79) * pow(cpl, 0.45) * pow(rhol, 0.49) * pow(dT_sup, 0.24) * pow(dP, 0.75);
   real tmp2 = pow(sigma, 0.5) * pow(mul, 0.29) * pow(h_lg, 0.24) * pow(rhog, 0.24);

   return tmp1 / tmp2;
 }

After the UDF that you have defined using DEFINE_MASS_TR_PROPERTY is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, nuc_ht_coeff) will become visible and selectable in the Evaporation-Condensation Model dialog box in Ansys Fluent. See Hooking DEFINE_MASS_TR_PROPERTY UDFs for details.

You can use DEFINE_NET_REACTION_RATE to compute the homogeneous net molar reaction rates of all species. The net reaction rate of a species is the sum over all reactions of the volumetric reaction rates:

(2–8)

where is the net reaction rate of species and is the Arrhenius molar rate of creation/destruction of species in reaction .

A DEFINE_NET_REACTION_RATE UDF may be used for the laminar finite-rate (with the stiff chemistry solver), EDC, and PDF Transport models, as well as for the surface chemistry model. In contrast, the surface UDF function DEFINE_SR_RATE is used for the laminar finite-rate model when stiff chemistry is not used.

DEFINE_NET_REACTION_RATE (name, c, t, particle, pressure, temp, yi, rr, jac)

Function returns

void

There are nine arguments to DEFINE_NET_REACTION_RATE: name, c, t, particle, pressure, temp, yi, rr, and jac. You supply name, the name of the UDF. The variables c, t, particle, pressure, temp, yi, rr, and jac are passed by the Ansys Fluent solver to your UDF and have SI units. The outputs of the function are the array of net molar reaction rates, rr (with units kmol/m³-s for volumetric reactions and kmol/m²-s for the surface reactions), and the Jacobian array jac. The Jacobian is only required for surface chemistry, and is the derivative of the surface net reaction rate with respect to the species concentration.

DEFINE_NET_REACTION_RATE is called for all fluid zones (volumetric reactions as well as surface reactions in porous media) and for all wall thread zones whenever the Reaction option is enabled in the boundary conditions dialog box and the UDF is hooked to Ansys Fluent in the User-Defined Function Hooks dialog box.

The following UDF, named net_rxn, assumes that the net volumetric reaction rate is the expression,

(2–9)

where is the number of species.

/***********************************************************
    Net Reaction Rate Example UDF
 ************************************************************/
 #include "udf.h"
 
 DEFINE_NET_REACTION_RATE(net_rxn,c,t,particle,pressure,temp,yi,rr,jac)
 {
   int i;
   for(i=0;i<n_spe;i++)
      rr[i] = 1./(real)n_spe - yi[i];
 } 

Note that during the course of the ODE solution, the species mass fractions can exceed realizable bounds. For optimal ODE performance, the species mass fractions should not be clipped, but derived quantities, such as concentrations which are raised to non-integer powers, must be bounded. Also, if density is required, for instance to calculate concentrations, it should be calculated from the temperature and species passed into the UDF. Finally, double precision should be used for all local variables.

After the UDF that you have defined using DEFINE_NET_REACTION_RATE is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, net_rxn) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_NET_REACTION_RATE UDFs for details.

You can use the DEFINE_NOX_RATE to specify a custom NOx rate for thermal NOx, prompt NOx, fuel NOx, and N₂O intermediate pathways that can either replace the internally-calculated NOx rate in the source term equation, or be added to the Ansys Fluent rate. Example 1 demonstrates this use of DEFINE_NOX_RATE. By default, the Add to Ansys Fluent Rate option is enabled UDF Rate group box in each of the tabs under Formation Model Parameters, so that user-defined rates are added to the Ansys Fluent-calculated rates. You can change this default by selecting Replace Ansys Fluent Rate, so that the Ansys Fluent-calculated rate for that NOx pathway will not be used and it will instead be replaced by the NOx rate you have defined in your UDF.

DEFINE_NOX_RATE may also be used to calculate the upper limit for the integration of the temperature PDF (when temperature is accounted for in the turbulence interaction modeling). You can calculate a custom maximum limit () for each cell and then assign it to the POLLUT_CTMAX(Pollut_Par) macro (see NOx Macros for further details about data access macros). Example 2 demonstrates this use of DEFINE_NOX_RATE.

DEFINE_NOX_RATE (name, c, t, Pollut, Pollut_Par, NOx)

Function returns

void

There are six arguments to DEFINE_NOX_RATE: name, c, t, Pollut, Pollut_Par, and NOx. You will supply name, the name of the UDF. c, t, Pollut, Pollut_Par, and NOx are variables that are passed by the Ansys Fluent solver to your function. A DEFINE_NOX_RATE function does not output a value. The calculated NOx rates (or other pollutant species rates) are returned through the Pollut structure as the forward rate POLLUT_FRATE(Pollut) and reverse rate POLLUT_RRATE(Pollut), respectively.

The following compiled UDF, named user_nox, exactly reproduces the default Ansys Fluent NOx rates for the prompt NOx pathway. Note that this UDF will replace the Ansys Fluent rate only if you select Replace Ansys Fluent Rate in the UDF Rate group box in the Prompt tab. Otherwise, the rate computed in the UDF will be added to Ansys Fluent’s default rate. See Hooking DEFINE_NOX_RATE UDFs for details.

See NOx Macros for details about the NOx macros (for example, POLLUT_EQN, MOLECON, ARRH) that are used in pollutant rate calculations in this UDF.

/*****************************************************************
 UDF example of User-Defined NOx Rate for Ansys Fluent 12 or later
 If used with the "Replace with UDF" radio buttons activated,
this UDF will exactly reproduce the default Ansys Fluent NOx
 rates for prompt NOx pathway.
The flag "Pollut_Par->pollut_io_pdf == IN_PDF" should always
 be used for rates other than that from char N, so that if
 requested, the contributions will be PDF integrated. Any
 contribution from char must be included within a switch
 statement of the form "Pollut_Par->pollut_io_pdf == OUT_PDF".
 *
 * Arguments:
 *  char nox_func_name         - UDF name
 *  cell_t c                   - Cell index
 *  Thread *t                 - Pointer to cell thread on
 *                         which the NOx rate is to be applied
 *  Pollut_Cell *Pollut           - Pointer to Pollut structure
 *  Pollut_Parameter *Pollut_Par  - Pointer to Pollut_Par structure
 *  NOx_Parameter *NOx            - Pointer to NOx structure
 
 *****************************************************************/
 
 #include "udf.h"
 
 DEFINE_NOX_RATE(user_nox, c, t, Pollut, Pollut_Par, NOx)
 {
 /* NOx->prompt_nox = Flag to indicate Prompt NOx is enabled
 * NOx->prompt_udf_replace = Flag to indicate UDF replace
 * Pollut_Par->nfstreams = Number of fuel streams
 * Pollut_Par->nfspe[i] = Number of fuel species in stream "i" 
 * NOx->equiv_ratio[i] = Equivalence ratio for stream "i"
 * NOx->c_number[i] = Carbon number for stream "i"
 * Pollut_Par->fuel_idx[j][i] = Index of jth species in stream "i"
 * Pollut_Par->fuel_dup[j][i] = Fuel species duplication check
 * Pollut_Par->uni_R = Universal gas constant in SI units
 * Pollut->temp_m = Mean gas temperature (K)
 * Pollut->press = Pressure in SI units
 * Pollut->oxy_order = Oxygen order (please refer to user manual)
 */
  POLLUT_FRATE(Pollut) = 0.0;
  POLLUT_RRATE(Pollut) = 0.0;

  switch (Pollut_Par->pollut_io_pdf) {
  case IN_PDF:
    /* Included source terms other than those from char */

    if (POLLUT_EQN(Pollut_Par) == EQ_NO) {

       /* Prompt NOx */
       if (NOx->prompt_nox && NOx->prompt_udf_replace) {
         int ifstream;
         real f=0., rf;

         Rate_Const K_PM = {6.4e6, 0.0, 36483.49436};

         for(ifstream=0; ifstream<Pollut_Par->nfstreams; ifstream++) {
            int i;
            real xc_fuel=0., eqr=NOx->equiv_ratio[ifstream];
            for (i=0; i<Pollut_Par->nfspe[ifstream]; i++) {
                if(!Pollut_Par->fuel_dup[i][ifstream])
                 xc_fuel += MOLECON(Pollut, Pollut_Par->fuel_idx[i][ifstream]);
            }
            f += (4.75 + 0.0819*NOx->c_number[ifstream]
              - 23.2*eqr + 32.0*pow(eqr, 2.) - 12.2*pow(eqr, 3.))*xc_fuel;
       }
       rf = ARRH(Pollut, K_PM);
       rf *= pow((Pollut_Par->uni_R*Pollut->temp_m/Pollut->press),
          (1.+Pollut->oxy_order));   
       rf *= pow(MOLECON(Pollut, O2), Pollut->oxy_order);
       rf *= MOLECON(Pollut, N2);

       POLLUT_FRATE(Pollut) += f*rf;
     }
    }
    break;

    case OUT_PDF:
    /* Char Contributions, must be included here */
    break;

  default:
  /* Not used */
  break;
  }
 } 

The following compiled UDF, named nox_func_name, specifies a custom maximum limit () for the integration of the temperature PDF for each cell. Note that this UDF does not alter the internally-calculated NOx rate.

See NOx Macros for details about the NOx macro (POLLUT_CTMAX) used in this UDF.

/************************************************************
 UDF example of User-Defined Tmax value
 *
 * Arguments:
 *  char nox_func_name    				- UDF name
 *  cell_t c      						- Cell index
 *  Thread *t     						- Pointer to cell thread
 *         							 on which the NOx rate
 *         							 is to be applied
 *  Pollut_Cell *Pollut   				- Pointer to Pollut_Cell
 *         							 structure
 *  Pollut_Parameter *Pollut_Par 			- Pointer to Pollut_Parameter
 *         							 structure
 *  NOx_Parameter *NOx    				- Pointer to NOx_Parameter
 *         							 structure
 Ansys Fluent Version: 12.0 or later
 *************************************************************/
 
 #include "udf.h"
 
 int ud_nox_do_once=1;
 
 enum
 {
    CELL_TMAX=0,
    N_REQUIRED_UDM
 };
 
 /*Compute/assign Tmax at each cell*/
 real ud_eval_cell_tmax(cell_t c,Thread *t)
 {
    real tmax = 0.;

    /* Compute cell-based Tmax value */
    tmax = 1.1*C_T(c,t); /* This is only an example */

    return tmax;
 }
 
 DEFINE_NOX_RATE(user_nox, c, t, Pollut, Pollut_Par, NOx)
 {
    /* Assign cell-based Tmax value */
    POLLUT_CTMAX(Pollut_Par) = ud_eval_cell_tmax(c,t);
    /*POLLUT_CTMAX(Pollut_Par) = C_UDMI(c,t,CELL_TMAX);*/
 }
 
 DEFINE_ON_DEMAND(init_tmax)
 {
    Domain *domain;
    register Thread *t;
    register cell_t c;

    Message("Computing/Storing cell Tmax values\n");
    domain = Get_Domain(1);

    /* Store User-Defined Tmax at each cell */
    if(ud_nox_do_once == 1) {
      if(n_udm < N_REQUIRED_UDM)
         Error("Not enough udm allocated\n");

      thread_loop_c (t,domain)
         begin_c_loop (c,t)
           C_UDMI(c,t,CELL_TMAX) = ud_eval_cell_tmax(c,t);
         end_c_loop (c,t)
      ud_nox_do_once = 0;
    }
    Message("Computing cell Tmax values completed..\n");
 }

After the UDF that you have defined using DEFINE_NOX_RATE is compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_nox) will become visible and selectable in the NOx Model dialog box in Ansys Fluent. See Hooking DEFINE_NOX_RATE UDFs for details.

You can use the DEFINE_PERFORATED_CD to customize the formulation of the discharge coefficient , which is used in Equation 7–131 and Equation 7–132 in the Fluent User's Guide to estimate the injection mass flow rate in the perforated walls. The DEFINE_PERFORATED_CD UDF is only available for cases that involve discrete injections with the dynamic injection method.

DEFINE_PERFORATED_CD (name, t, cd, local_variables)

Function returns

void

There are four arguments to DEFINE_PERFORATED_CD: name, t, cd, and local_variables. You supply name, the name of the UDF. The variables t and local_variables are passed by the Ansys Fluent solver to your UDF. Your UDF will need to compute the variable cd, which will be used to estimate the injection mass flow rate in the perforated wall when the dynamic injection method is used.

The array local_variables contains values of several pre-defined variables calculated by Ansys Fluent and listed in Table 2.7: Variables Stored in the Array local_variables. They can be used to define your as a function of these variables. You can directly refer to the variable you want to use in your UDF by using either the integer index or the enumerator.

The below examples shows the usage of DEFINE_PERFORATED_CD, named my_cdprofile, to compute the discharge coefficient as the following function:

The first example illustrates how to use the index to refer to the variables in the local_variables array.

/*****************************************************************
#include "udf.h"
DEFINE_PERFORATED_CD(my_cdprofile, t, cd, local_variables)
{
  if(local_variables[1] / local_variables[0] <2.0 )
    *cd = 0.6 + 0.1*local_variables[1] / local_variables[0];
  else
    *cd = 0.8;
  return;
}

The second example illustrates how to use the enumerator to refer to the variables in the local_variables array.

/*****************************************************************
#include "udf.h"
#include "perforated.h"
DEFINE_PERFORATED_CD(my_cdprofile, t, cd, local_variables)
{
  if(local_variables[LEN_DC] / local_variables[DIA_DC] <2.0 )
    *cd = 0.6 + 0.1*local_variables[LEN_DC] / local_variables[DIA_DC];
  else
    *cd = 0.8;
  return;
}

After the UDF that you have defined using DEFINE_PERFORATED_CD is compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, my_cdprofile) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_PERFORATED_CD UDFs for details.

The Non-Premixed and Partially-Premixed models in Ansys Fluent employ look-up tables that store the convolution of state-relations with assumed-shape PDFs as described by Equation 8–17 to Equation 8–20, Equation 8–25 and Equation 8–26 in the Theory Guide. Ansys Fluent solves transport equations for lower moments, such as the mean mixture fraction and the mean enthalpy, and interpolates the PDF table for the required variables:

You can use DEFINE_PDF_TABLE to customize the above variables.

Your UDF can access and use the variables and functions in the default PDF table, such as boundary composition values and the adiabatic enthalpy function, listed in the header files pdf_props.h and pdf_table.h, which you would need to include in your UDF.

The UDF is called for all fluid cells and boundary faces, every iteration, and care should be taken to efficiently interpolate your table.

DEFINE_PDF_TABLE (name, m, c, t, fmean, fvar, fmean2, fvar2, cmean, cvar, h, what, prop, x)

Function returns

void

There are fourteen arguments to DEFINE_PDF_TABLE. You supply name, the name of the UDF. The variables m, c, t, fmean, fvar, fmean2, fvar2, cmean, cvar, h, what are passed by the Ansys Fluent solver to your UDF. The output of the function are the array of thermodynamic variables prop and the array of mole fractions x.

You can use macros listed in Table 2.8: Generic Macros Get_PDF to retrieve the local cell information extracted from the original PDF look-up table generated by Ansys Fluent using the Species Model dialog box. The output of these macros do not account for the customizations made by DEFINE_PDF_TABLE.

The macros use the following arguments:

An example of the usage of these macros is shown in Example.

The following example is a source code template where the DEFINE_PDF_TABLE function is used to calculate properties and mole fractions from the PDF file loaded by the user.

  #include <udf.h>
  #include "pdf_props.h"
  #include "pdf_table.h"
  #define DEN_MIN 1E-4
  DEFINE_PDF_TABLE(pdf_table, m, c, t, fmean, fvar, fmean2, fvar2, cmean, cvar, h, what, prop, x)
  {
    int i;

    if NULLP(pf)
    Error("Please generate or read a Fluent PDF file first\n");
    
    #if 1
    if (what < 0) /*special call to return the FGM flame speed source*/
    {
      prop[SCALAR_PRMX_SOURCE_UDF] = Get_Premix_Frate_Source_Term(c, t)/C_R(c,t); /*This is the value 
                                                           of progress variable source term in 1/s */
    }
    else if (what == 1) /* get all pdf values : T, rho, MW, mole fractions, cp*/
    {
      prop[TEMP_UDF] = Get_Pdf_Temperature(c, t);
      prop[CP_UDF] = Get_Pdf_Cp(c,t);
      prop[DEN_UDF]  = Get_Pdf_Density(c,t);
      prop[MOL_WT_MIX_UDF] = Get_Pdf_MolWeight(c,t);
    
      for (i = 0; i < n_spe_pdf; i++)
      x[i] = Get_Pdf_Xi(c,t,i);  /*get pdf mole fraction of species i */
    
    }
    else if (what == 3) /*TSS SCALARS RATES*/
    {
      tss_num_scalars = RP_Get_Integer("pdftss/tss-num-scalars");
      if (tss_num_scalars > 0)
      {
        real fwdrate = 0.0;
        real revrate = 0.0;
        for (i = 0; i < tss_num_scalars; i++)
        {
          if ( PdfModel.premix_flamelet && NNULLP(t) && GENERIC_CELL_THREAD_P(t) )
          fwdrate = Get_Pdf_Tss_FwdRates(c, t, i);
    
          if ( PdfModel.premix_flamelet && NNULLP(t) && GENERIC_CELL_THREAD_P(t))
          revrate = Get_Pdf_Tss_RevRates(c, t, i) ;
    
          prop[TSS_SCALAR_START_UDF +  2 * i] = fwdrate;
          prop[TSS_SCALAR_START_UDF +  2 * i + 1] = revrate;
        }
      }
    }
    else /*(what == 2 || 0)*/
    {
      prop[TEMP_UDF] = Get_Pdf_Temperature(c, t);
      prop[CP_UDF] = Get_Pdf_Cp(c,t);
      prop[DEN_UDF]  = Get_Pdf_Density(c,t);
      prop[MOL_WT_MIX_UDF] = Get_Pdf_MolWeight(c,t);
    }
    
    #endif
    
  }
  

After you have enabled the Non-Premixed or Partially-Premixed models, generated or read a valid PDF table, and compiled (Compiling UDFs) the DEFINE_PDF_TABLE UDF, the name of the argument that you supplied as the first DEFINE macro argument will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_PDF_TABLE UDFs for details.

You can use DEFINE_PR_RATE to specify a custom particle surface reaction for the multiple surface reactions particle model. During Ansys Fluent execution, the same UDF is called sequentially for all particle surface reactions, so DEFINE_PR_RATE can be used to define custom reaction rates for a single reaction, or for multiple reactions. The volumetric and wall surface reactions are not affected by the definition of this macro and will follow the designated rates. Note that a DEFINE_PR_RATE UDF is not called with the coupled solution option, so you will need to disable the Coupled Heat Mass Solution option in the Discrete Phase Model dialog box when using it. The auxiliary function, zbrent_pr_rate, which is provided below, can be used when there is no analytical solution for the overall particle reaction rate.

DEFINE_PR_RATE (name, c, t, r, mw, ci, tp, sf, dif_index, cat_index, rr)

Function returns

void

There are eleven arguments to DEFINE_PR_RATE: name, c, t, r, mw, ci, tp, sf, dif_index, cat_index, and rr. You supply name, the name of the UDF. c, t, r, mw, ci, tp, sf, dif_index, cat_index, and rr are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to set the value referenced by the real pointer rr to the particle reaction rate in kg/s.

Note that tp is an argument to many particle-specific macros defined in DPM Macros. sf is the same as the order in which the species are defined in the Selected Solid Species list in the Create/Edit Materials dialog box, which is opened from the Edit Species names option for the Mixture Material.

DEFINE_PR_RATE is called by Ansys Fluent every time step during the particle tracking calculation. The auxiliary function zbrent_pr_rate is used when there is no analytical solution for the overall particle reaction rate. It uses Brent’s method to find the root of a function known to lie between and . The root will be refined until its accuracy has reached tolerance tol. This is demonstrated in Example 2.

zbrent_pr_rate (real (*func),(real,real[],int [],cxboolean [],char *,) real ruser[],int iuser[], cxboolean buser[],char *cuser,real x1 real x2,real tol,cxboolean *ifail)

Auxiliary function returns: real

The following UDF, named user_pr_rate, specifies a particle reaction rate given by Equation 7–107 in the Theory Guide, where the effectiveness factor is defined as

where is the fractional conversion of the particle char mass. In this case, the UDF will be applied to all surface particle reactions defined in the Ansys Fluent model.

/* UDF of specifying the surface reaction rate of a particle */
 
 #include "udf.h"
 
 #define A1 0.002
 #define E1 7.9e7
 
 DEFINE_PR_RATE(user_pr_rate,c,t,r,mw,pp,tp,sf,dif_i,cat_i,rr)
 {
 /* Argument types
    cell_t c
    Thread *t
    Reaction *r (reaction structure)
    real *mw (species molecular weight)
    real *pp (gas partial pressures)
    Tracked_Particle *tp (particle structure)
    real *sf  (current mass fractions of solid species in
         particle char mass)
    int dif_i (index of diffusion controlled species)
    int cat_i (index of catalyst species)
    real *rr  (rate of reaction kg/s)
 */
 
 real ash_mass =
 TP_INIT_MASS(tp)*(1.-TP_CHAR_FRACTION(tp)-TP_VOLATILE_FRACTION(tp));
 
 real one_minus_conv =
 MAX(0.,(TP_MASS(tp) -ash_mass) / TP_INIT_MASS(tp)/ TP_CHAR_FRACTION(tp));
 
 real rate = A1*exp(-E1/UNIVERSAL_GAS_CONSTANT/TP_T(tp));
 
 *rr=-rate*TP_DIAM(tp)*TP_DIAM(tp)*M_PI*sf[0]*one_minus_conv;
 } 

The following compiled UDF, named user_rate, specifies a particle reaction rate given by Equation 7–102 and Equation 7–105 in the Theory Guide. The reaction order on the kinetic rate is and the effectiveness factor is defined as

where is the fractional conversion of the particle char mass. In this case it is necessary to obtain a numerical solution for the overall surface reaction rate.

This UDF is called only for reaction 2, which means that the default Ansys Fluent solution will be used for the rest of the particle surface reactions defined.

/* UDF of specifying the surface reaction rate of a particle,
using a numerical solution */
 
 #include "udf.h"
 
 #define c1 5e-12
 #define A1 0.002
 #define E1 7.9e7
 #define tolerance 1e-4
 #define order 0.9
 
 real reaction_rate(real rate, real ruser[], int iuser[], cxboolean buser[],
char *cuser)
 
 /* Note that all arguments in the reaction_rate function call 
 in your .c source file MUST be on the same line or a 
 compilation error will occur */
 
 {
    return (ruser[2]*pow(MAX(0.,(ruser[0]-rate/ruser[1])),order) -rate);
 }
 
 DEFINE_PR_RATE(user_rate,c,t,r,mw,pp,tp,sf,dif_i,cat_i,rr)
 {
 if (!strcmp(r->name, "reaction-2"))
    {
    cxboolean ifail=FALSE;

    real ash_mass =
    TP_INIT_MASS(tp)*(1.-TP_CHAR_FRACTION(tp)-TP_VOLATILE_FRACTION(tp));

    real one_minus_conv =
    MAX(0.,(TP_MASS(tp) -ash_mass) / TP_INIT_MASS(tp)/ TP_CHAR_FRACTION(tp));

    real ruser[3];
    int iuser[1];  cxboolean buser[1];
    char cuser[30];
    real ratemin, ratemax, root;

    ruser[0] = pp[dif_i];
    ruser[1] = MAX(1.E-15, (c1*pow(0.5*(TP_T(tp)+C_T(c,t)),0.75)/TP_DIAM(tp)));
    ruser[2] = A1*exp(-E1/UNIVERSAL_GAS_CONSTANT/TP_T(tp));
    strcpy(cuser, "reaction-2");
    ratemin=0;
    ratemax=ruser[1]*pp[dif_i];

    /* arguments for auxiliary function zbrent_pr_rate */

    root = zbrent_pr_rate(reaction_rate, ruser, iuser, buser, cuser,
           ratemin, ratemax, tolerance, &ifail);

    if (ifail) root=MAX(1.E-15,ruser[1]);

    *rr=-root*TP_DIAM(tp)*TP_DIAM(tp)*M_PI*sf[0]*one_minus_conv;

    Message("Fail status %d\n", ifail);
    Message("Reaction rate for reaction %s : %g\n", cuser, *rr);

   }
 } 

In this example, a real function named reaction_rate is defined at the top of the UDF. The arguments of reaction_rate are real rate, and the pointer arrays real ruser[], integer iuser[], cxboolean buser[], and char *cuser, which must be declared and defined in the main body of the DEFINE_PR_RATE function.

Typically, if the particle surface reaction rate is described by

  rate = f(ruser[],iuser[],rate)

then the real function (in this example reaction_rate) should return

  f(ruser[],iuser[],rate) - rate

The variables cxboolean buser[] and char *cuser can be used to control the flow of the program in cases of complicated rate definitions.

ratemin and ratemax, hold the minimum and maximum possible values of the variable rate, respectively. They define the search interval where the numerical algorithm will search for the root of the equation, as defined in the function reaction_rate. The value of reaction rate rr will be refined until an accuracy specified by the value of tolerance tol is reached.

The variable ifail will take the value TRUE if the root of the function has not been found.

After the UDF that you have defined using DEFINE_PR_RATE is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_pr_rate) will become visible and selectable in the User-Defined Function Hooks dialog box in Ansys Fluent. See Hooking DEFINE_PR_RATE UDFs for details.

You can use DEFINE_PRANDTL_D to specify Prandtl numbers for turbulent dissipation ().

DEFINE_PRANDTL_D (name, c, t)

Function returns

real

There are three arguments to DEFINE_PRANDTL_D: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value for the turbulent dissipation Prandtl number to the solver.

An example of a DEFINE_Prandtl_D UDF is provided below in the source listing for DEFINE_PRANDTL_K.

After the UDF that you have defined using DEFINE_PRANDTL_D is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_pr_d) will become visible and selectable in the Viscous Model dialog box in Ansys Fluent. See Hooking DEFINE_PRANDTL UDFs for details.

You can use DEFINE_PRANDTL_K to specify Prandtl numbers for turbulence kinetic energy ().

DEFINE_PRANDTL_K (name, c, t)

Function returns

real

There are three arguments to DEFINE_PRANDTL_K: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value for the kinetic energy Prandtl number to the solver.

The following UDF implements a high-Re version of the RNG model, using the - option that is activated in Ansys Fluent.

Three steps are required:

In the RNG model, diffusion in and equations appears as

while in the standard - model, it is given by

For the new implementation, a UDF is needed to define a Prandtl number as

in order to achieve the same implementation as the original RNG Model.

The following functions (which are concatenated into a single C source code file) demonstrate this usage. Note that the source code must be executed as a compiled UDF.

#include "udf.h"
 
 DEFINE_PRANDTL_K(user_pr_k,c,t)
 {
    real pr_k, alpha;
    real mu = C_MU_L(c,t);
    real mu_t = C_MU_T(c,t);

    alpha = rng_alpha(1., mu + mu_t, mu);

    pr_k = mu_t/((mu+mu_t)*alpha-mu);

    return pr_k;
 }
 
 DEFINE_PRANDTL_D(user_pr_d,c,t)
 {
    real pr_d, alpha;
    real mu = C_MU_L(c,t);
    real mu_t = C_MU_T(c,t);

    alpha = rng_alpha(1., mu + mu_t, mu);

    pr_d = mu_t/((mu+mu_t)*alpha-mu);

    return pr_d;
 }
 
 DEFINE_SOURCE(eps_r_source,c,t,dS,eqn)
 {
    real con, source;
    real mu = C_MU_L(c,t);
    real mu_t = C_MU_T(c,t);
    real k  = C_K(c,t);  real d  = C_D(c,t);
    real prod = C_PRODUCTION(c,t);

    real s = sqrt(prod/(mu+ mu_t)) ;
    real eta  = s*k/d;
    real eta_0 = 4.38;
    real term = mu_t*s*s*s/(1.0 + 0.012*eta*eta*eta);

    source = - term * (1. - eta/eta_0);
    dS[eqn] = - term/d;

    return source;
 } 

After the UDF that you have defined using DEFINE_PRANDTL_K is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_pr_k) will become visible and selectable in the Viscous Model dialog box in Ansys Fluent. See Hooking DEFINE_PRANDTL UDFs for details.

You can use DEFINE_PRANDTL_O to specify Prandtl numbers for specific dissipation ( in the - model).

DEFINE_PRANDTL_O (name, c, t)

Function returns

real

There are three arguments to DEFINE_PRANDTL_O: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value for the specific dissipation Prandtl number to the solver.

/* Specifying a Constant Specific Dissipation Prandtl Number */
 #include "udf.h"
 
 DEFINE_PRANDTL_O(user_pr_o,c,t)
 {
    real pr_o;
    pr_o = 2.;
    return pr_o;
 } 

After the UDF that you have defined using DEFINE_PRANDTL_O is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_pr_o) will become visible and selectable in the Viscous Model dialog box in Ansys Fluent. See Hooking DEFINE_PRANDTL UDFs for details.

You can use DEFINE_PRANDTL_T to specify Prandtl numbers that appear in the temperature equation diffusion term.

DEFINE_PRANDTL_T (name, c, t)

Function returns

real

There are three arguments to DEFINE_PRANDTL_T: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value for the temperature Prandtl number to the solver.

/* Specifying a Constant Temperature Prandtl Number */
 #include "udf.h"
 
 DEFINE_PRANDTL_T(user_pr_t,c,t)
 {
    real pr_t;
    pr_t = 0.85;
    return pr_t;
 } 

After the UDF that you have defined using DEFINE_PRANDTL_T is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_pr_t) will become visible and selectable in the Viscous Model dialog box in Ansys Fluent. See Hooking DEFINE_PRANDTL UDFs for details.

You can use DEFINE_PRANDTL_T_WALL to specify Prandtl numbers for thermal wall functions.

DEFINE_PRANDTL_T_WALL (name, c, t)

Function returns

real

There are three arguments to DEFINE_PRANDTL_T_WALL: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to return the real value for the thermal wall function Prandtl number to the solver.

/*************************************************************
  Specifying a constant thermal wall function Prandtl number
  ********************************************************* **/
 #include "udf.h"
 
 DEFINE_PRANDTL_T_WALL(user_pr_t_wall,c,t)
 {
    real pr_t_wall;
    pr_t_wall = 0.85;
    return pr_t_wall;
 } 

After the UDF that you have defined using DEFINE_PRANDTL_T_WALL is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, user_pr_t_wall) will become visible and selectable in the Viscous Model dialog box in Ansys Fluent. See Hooking DEFINE_PRANDTL UDFs for details.

You can use DEFINE_PROFILE to define a custom boundary profile or cell zone condition that varies as a function of spatial coordinates or time. Some of the variables you can customize are:

Note that DEFINE_PROFILE allows you to modify only a single value for wall heat flux. Single values are used in the explicit source term which Ansys Fluent does not linearize. If you want to linearize your source term for wall heat flux and account for conductive and radiative heat transfer separately, you will need to use DEFINE_HEAT_FLUX to specify your UDF.

Some examples of boundary profile UDFs are provided below. For an overview of the Ansys Fluent solution process which shows when a DEFINE_PROFILE UDF is called, refer to Figure 1.2: Solution Procedure for the Pressure-Based Segregated Solver, Figure 1.3: Solution Procedure for the Pressure-Based Coupled Solver, and Figure 1.4: Solution Procedure for the Density-Based Solver.

DEFINE_PROFILE (name, t, i)

Function returns

void

There are three arguments to DEFINE_PROFILE: name, t, and i. You supply name, the name of the UDF. t and i are variables that are passed by the Ansys Fluent solver to your UDF.

While DEFINE_PROFILE is usually used to specify a profile condition on a boundary face zone, it can also be used to specify, or fix, flow variables that are held constant during computation in a cell zone. See Fixing the Values of Variables in the User's Guide for more information on fixing values in a cell zone boundary condition. For these cases, the arguments of the macro will change accordingly.

Note that unlike source term and property UDFs, profile UDFs (defined using DEFINE_PROFILE) are not called by Ansys Fluent from within a loop on threads in the boundary zone. The solver passes only the pointer to the thread associated with the boundary zone to the DEFINE_PROFILE macro. Your UDF will need to do the work of looping over all of the faces in the thread, computing the face value for the boundary variable, and then storing the value in memory. Ansys Fluent has provided you with a face looping macro to loop over all faces in a thread (begin_f_loop...). See Additional Macros for Writing UDFs for details.

F_PROFILE is typically used along with DEFINE_PROFILE and is a predefined macro supplied by Ansys Fluent. F_PROFILE stores a boundary condition in memory for a given face and thread and is nested within the face loop as shown in the examples below. It is important to note that the index i that is an argument to DEFINE_PROFILE is the same argument to F_PROFILE. F_PROFILE uses the thread pointer t, face identifier f, and index i to set the appropriate boundary face value in memory. See Set Boundary Condition Value (F_PROFILE) for a description of F_PROFILE. Note that in the case of porosity profiles, you can also use C_PROFILE to define those types of functions. See the example UDFs provided below.

In multiphase cases a DEFINE_PROFILE UDF may be called more than once (particularly if the profile is used in a mixture domain thread). If this must be avoided, then add the prefix MP_ to the UDF name. The function will then be called only once even if it is used for more than one profile.

If your UDF uses solver storage, it is recommended that you include a NULL storage check; this can prevent an abnormal termination of Fluent if your UDF is called before the flow is initialized (that is, when the storages have not yet been allocated by the solver). For example, you could define the density in the following manner:

if(NNULLP(THREAD_STORAGE(thread, SV_DENSITY)))
  density = F_R(f,thread);
else
  density = 1.225; /*A reasonable value to prevent abnormal termination if flow is not initialized*/

The following UDF, named pressure_profile, generates a parabolic pressure profile according to the equation

Note that this UDF assumes that the mesh is generated such that the origin is at the geometric center of the boundary zone to which the UDF is to be applied. is 0.0 at the center of the inlet and extends to at the top and bottom of the inlet. The source code can be interpreted or compiled in Ansys Fluent.

/***********************************************************************
 UDF for specifying steady-state parabolic pressure profile boundary
 profile for a turbine vane
 ************************************************************************/
 
 #include "udf.h"
 
 DEFINE_PROFILE(pressure_profile,t,i)
 {
    real x[ND_ND];    /* this will hold the position vector */
    real y;
    face_t f;
    begin_f_loop(f,t)
      {
       F_CENTROID(x,f,t);
       y = x[1];
       F_PROFILE(f,t,i) = 1.1e5 - y*y/(.0745*.0745)*0.1e5;
      }
    end_f_loop(f,t)
 } 

The function named pressure_profile has two arguments: t and i. t is a pointer to the face’s thread, and i is an integer that is a numerical label for the variable being set within each loop.

Within the function body variable f is declared as a face. A one-dimensional array x and variable y are declared as real data types. Following the variable declarations, a looping macro is used to loop over each face in the zone to create a profile, or an array of data. Within each loop, F_CENTROID returns the value of the face centroid (array x) for the face with index f that is on the thread pointed to by t. The coordinate stored in x[1] is assigned to variable y, and is then used to calculate the pressure. This value is then assigned to F_PROFILE which uses the integer i (passed to it by the solver, based on your selection of the UDF as the boundary condition for pressure in the Pressure Inlet dialog box) to set the pressure face value in memory.

In the following example, DEFINE_PROFILE is used to generate profiles for the velocity, turbulent kinetic energy, and dissipation rate, respectively, for a 2D fully-developed duct flow. Three separate UDFs named x_velocity, k_profile, and dissip_profile are defined. These functions are concatenated in a single C source file and can be interpreted or compiled in Ansys Fluent.

The 1/7th power law is used to specify the velocity component:

A fully-developed profile occurs when is one-half the duct height. In this example, the mean velocity is prescribed and the peak (free-stream) velocity is determined by averaging across the channel.

The turbulent kinetic energy is assumed to vary linearly from a near-wall value of

to a free-stream value of

The dissipation rate is given by

where the mixing length is the minimum of and 0.085 . ( is the von Karman constant = 0.41.)

The friction velocity and wall shear take the forms:

The friction factor is estimated from the Blasius equation:

/**********************************************************************
  Concatenated UDFs for fully-developed turbulent inlet profiles
 ***********************************************************************/
 
 #include "udf.h"
 
 #define YMIN 0.0      /* constants */
 #define YMAX 0.4064
 #define UMEAN 1.0
 #define B 1./7.
 #define DELOVRH 0.5
 #define VISC 1.7894e-05
 #define CMU 0.09
 #define VKC 0.41
 
 
 /* profile for x-velocity */
 
 
 DEFINE_PROFILE(x_velocity,t,i)
 {
    real y, del, h, x[ND_ND], ufree;  /* variable declarations */
    face_t f;

    h = YMAX - YMIN;
    del = DELOVRH*h;
    ufree = UMEAN*(B+1.);

    begin_f_loop(f,t)
      {
         F_CENTROID(x,f,t);
         y = x[1];
         if (y <= del)
           F_PROFILE(f,t,i) = ufree*pow(y/del,B);
         else
           F_PROFILE(f,t,i) = ufree*pow((h-y)/del,B);
      }
    end_f_loop(f,t)
 }
 
 /* profile for kinetic energy */
 
 DEFINE_PROFILE(k_profile,t,i)
 {
    real y, del, h, ufree, x[ND_ND];
    real ff, utau, knw, kinf;
    face_t f;

    h = YMAX - YMIN;
    del = DELOVRH*h;
    ufree = UMEAN*(B+1.);
    ff = 0.045/pow(ufree*del/VISC,0.25);
    utau=sqrt(ff*pow(ufree,2.)/2.0);
    knw=pow(utau,2.)/sqrt(CMU);
    kinf=0.002*pow(ufree,2.);

    begin_f_loop(f,t)
      {
         F_CENTROID(x,f,t);
         y=x[1];

           if (y <= del)
             F_PROFILE(f,t,i)=knw+y/del*(kinf-knw);
           else
             F_PROFILE(f,t,i)=knw+(h-y)/del*(kinf-knw);
        }
      end_f_loop(f,t)
 }
 
 /* profile for dissipation rate */
 
 DEFINE_PROFILE(dissip_profile,t,i)
 {
    real y, x[ND_ND], del, h, ufree;
    real ff, utau, knw, kinf;
    real mix, kay;
    face_t f;

    h = YMAX - YMIN;
    del = DELOVRH*h;
    ufree = UMEAN*(B+1.);
    ff = 0.045/pow(ufree*del/VISC,0.25);
    utau=sqrt(ff*pow(ufree,2.)/2.0);
    knw=pow(utau,2.)/sqrt(CMU);
    kinf=0.002*pow(ufree,2.);

    begin_f_loop(f,t)
      {
         F_CENTROID(x,f,t);
         y=x[1];

         if (y <= del)
           kay=knw+y/del*(kinf-knw);
         else
           kay=knw+(h-y)/del*(kinf-knw);

         if (VKC*y < 0.085*del)
           mix = VKC*y;
         else
           mix = 0.085*del;

         F_PROFILE(f,t,i)=pow(CMU,0.75)*pow(kay,1.5)/mix;
        }
      end_f_loop(f,t)
 } 

In the following example DEFINE_PROFILE is used to fix flow variables that are held constant during computation in a cell zone. Three separate UDFs named fixed_u, fixed_v, and fixed_ke are defined in a single C source file. They specify fixed velocities that simulate the transient startup of an impeller in an impeller-driven mixing tank. The physical impeller is simulated by fixing the velocities and turbulence quantities using the fix option in Ansys Fluent. See Fixing the Values of Variables in the User’s Guide for more information on fixing variables.

/***********************************************************************
   Concatenated UDFs for simulating an impeller using fixed velocity
 ************************************************************************/
 
 #include "udf.h"
 
 #define FLUID_ID 1
 #define ua1 -7.1357e-2
 #define ua2 54.304
 #define ua3 -3.1345e3
 #define ua4 4.5578e4
 #define ua5 -1.9664e5
 
 #define va1 3.1131e-2
 #define va2 -10.313
 #define va3 9.5558e2
 #define va4 -2.0051e4
 #define va5 1.1856e5
 
 #define ka1 2.2723e-2
 #define ka2 6.7989
 #define ka3 -424.18
 #define ka4 9.4615e3
 #define ka5 -7.7251e4
 #define ka6 1.8410e5
 
 #define da1 -6.5819e-2
 #define da2 88.845
 #define da3 -5.3731e3
 #define da4 1.1643e5
 #define da5 -9.1202e5
 #define da6 1.9567e6
 
 
 DEFINE_PROFILE(fixed_u,t,i)
 {
    cell_t c;
    real x[ND_ND];
    real r;

    begin_c_loop(c,t)
      {
 /* centroid is defined to specify position dependent profiles */

         C_CENTROID(x,c,t);
         r =x[1];
         F_PROFILE(c,t,i) =
             ua1+(ua2*r)+(ua3*r*r)+(ua4*r*r*r)+(ua5*r*r*r*r);
       }
    end_c_loop(c,t)
 }
 
 
 DEFINE_PROFILE(fixed_v,t,i)
 {
    cell_t c;
    real x[ND_ND];
    real r;
    begin_c_loop(c,t)
      {
 /* centroid is defined to specify position dependent profiles*/

         C_CENTROID(x,c,t);
         r =x[1];
         F_PROFILE(c,t,i) =
         va1+(va2*r)+(va3*r*r)+(va4*r*r*r)+(va5*r*r*r*r);
       }
     end_c_loop(c,t)
 } 
 DEFINE_PROFILE(fixed_ke,t,i)
 {
    cell_t c;
    real x[ND_ND];
    real r;
    begin_c_loop(c,t)
      {
 /* centroid is defined to specify position dependent profiles*/

         C_CENTROID(x,c,t);
         r =x[1];
         F_PROFILE(c,t,i) =
         ka1+(ka2*r)+(ka3*r*r)+(ka4*r*r*r)+(ka5*r*r*r*r)+(ka6*r*r*r*r*r);
      }
    end_c_loop(c,t)
 } 

The following UDF, named wallheatgenerate, generates a heat generation rate profile for a planar conduction wall. After it has been interpreted or compiled, you can activate this UDF in the Wall boundary conditions dialog box in Ansys Fluent.

/* Wall Heat Generation Rate Profile UDF */
 
 #include "udf.h"
 
 DEFINE_PROFILE(wallheatgenerate,thread,i)
 {
    real source = 0.001;
    face_t f;
    begin_f_loop(f,thread)
        F_PROFILE(f,thread,i) = source;
    end_f_loop(f,thread)
 } 

The following UDF, named q_nx, where x is the direction vector i, j, k, specifies the beam direction normal to every face on the cylinder. After it has been interpreted or compiled, you can activate this UDF in the Wall boundary conditions dialog box in Ansys Fluent.

/* Beam Direction Profile UDF at Semi-Transparent Walls */
 
 #include "udf.h"
 
 DEFINE_PROFILE(q_ni, t, position)
 {
    real A[3], e_n[3];
    face_t f;
    real At;
    begin_f_loop(f, t)
       {
         F_AREA(A, f, t);
         At = NV_MAG(A);
         NV_VS(e_n,=,A,/,At);
         F_PROFILE(f, t, position) = -e_n[0];
       }
    end_f_loop(f, t)
 
 }
 
 
 DEFINE_PROFILE(q_nj, t, position)
 {
    real A[3], e_n[3];
    face_t f;
    real At;
    begin_f_loop(f, t)
       {
         F_AREA(A, f, t);
         At = NV_MAG(A);
         NV_VS(e_n,=,A,/,At);
         F_PROFILE(f, t, position) = -e_n[1];
       }
    end_f_loop(f, t) 
 }
 
 
 DEFINE_PROFILE(q_nk, t, position)
 {
    real A[3], e_n[3];
    face_t f;
    real At;
    begin_f_loop(f, t)
       {
         F_AREA(A, f, t);
         At = NV_MAG(A);
         NV_VS(e_n,=,A,/,At);
         F_PROFILE(f, t, position) = -e_n[2];
       }
    end_f_loop(f, t)
 
 }

You can either use F_PROFILE or C_PROFILE to define a viscous resistance profile in a porous zone. Below are two sample UDFs that demonstrate the usage of F_PROFILE and C_PROFILE, respectively. Note that porosity functions are hooked to Ansys Fluent in the Porous Zone tab in the appropriate Fluid cell zone conditions dialog box.

The following UDF, named vis_res, generates a viscous resistance profile in a porous zone. After it has been interpreted or compiled and loaded, you can activate this UDF in the Fluid cell zone condition dialog box in Ansys Fluent.

/* Viscous Resistance Profile UDF in a Porous Zone that utilizes F_PROFILE*/
 
 #include "udf.h"
 
 DEFINE_PROFILE(vis_res,t,i)
 {
    real x[ND_ND];
    real a;
    cell_t c;
    begin_c_loop(c,t)
      {
        C_CENTROID(x,c,t);
        if(x[1] < (x[0]-0.01))
           a = 1e9;
        else
           a = 1.0;
        F_PROFILE(c,t,i) = a;
      }
    end_c_loop(c,t)
 }
 
 /* Viscous Resistance Profile UDF in a Porous Zone that utilizes C_PROFILE*/
 
 #include "udf.h"
 
 DEFINE_PROFILE(porosity_function, t, nv)
 {
   cell_t c;
   begin_c_loop(c,t)
       C_PROFILE(c,t,nv) = 0.5;
   end_c_loop(c,t)
 } 

The following UDF contains profile functions for two porous resistance direction vectors that use C_PROFILE. These profiles can be hooked to corresponding direction vectors under Porous Zone in the Fluid cell zone condition dialog box.

/* Porous Resistance Direction Vector Profile that utilizes C_PROFILE*/
 
 #include "udf.h"
 
 DEFINE_PROFILE{dir1, t, nv}
 {
   cell_t c;
   begin_c_loop(c,t)
       C_PROFILE(c,t,nv) = 0.5;
   end_c_loop(c,t)
 }
 
 DEFINE_PROFILE{dir2, t, nv}
 {
   cell_t c;
   begin_c_loop(c,t)
       C_PROFILE(c,t,nv) = 0.3;
   end_c_loop(c,t)
 } 

For some unsteady problems, it is desirable that the target mass flow rate be a function of the physical flow time. This boundary condition can be applied using a DEFINE_PROFILE UDF. The following UDF, named tm_pout2, adjusts the mass flow rate from to when the physical time step is greater than seconds. After it has been interpreted or compiled, you can activate this UDF in the Pressure Outlet boundary condition dialog box in Ansys Fluent by selecting the Specify target mass-flow rate option, and then choosing the UDF name from the corresponding drop-down list.

/* UDF for setting target mass flow rate in pressure-outlet   */
 /* at t0.2 sec the target mass flow rate set to 1.00 kg/s    */
 /* when t0.2 sec the target mass flow rate will change to 1.35 kg/s */
 
 #include "udf.h"
 DEFINE_PROFILE(tm_pout2, t, nv)
 {
    face_t f ;
    real flow_time = RP_Get_Real("flow-time");
    if (flow_time < 0.2)
      {
         printf("Time   = %f sec. \n",flow_time);
         printf("Targeted mass-flow rate set at 1.0 kg/s \n");
         begin_f_loop(f,t)
          {
             F_PROFILE(f,t,nv) = 1.0 ;
          }
         end_f_loop(f,t)
      }
    else
      {
         printf("Time   = %f sec. \n",flow_time);
         printf("Targeted mass-flow rate set at 1.35 kg/s \n") ;
 
         begin_f_loop(f,t)
           {
            F_PROFILE(f,t,nv) = 1.35 ;
           }
         end_f_loop(f,t)
  } } 

This UDF is used to provide a time-varying specification of the mass flow rate. This boundary condition can be applied using a DEFINE_PROFILE UDF. The following UDF, named mass_flow, initially specifies a mass flow rate of 3.0 kg/s for the first 10 milliseconds, then increases it to 4.0 kg/s for the next 10 milliseconds, and after that specifies 5.0 kg/s. The macro CURRENT_TIME looks up the current flow time. Since this is a built-in RP variable, it is available to all nodes. It is more efficient to access it once and store the value in a local variable, rather than accessing it for every face in the face loop.

After it has been interpreted or compiled, you can activate this UDF in the Mass-Flow Inlet or Mass-Flow Outlet boundary condition dialog box in Ansys Fluent by selecting the UDF from the Mass Flow Rate drop-down list.

#include "udf.h"
 
  DEFINE_PROFILE(mass_flow,th,i)
 {
   face_t f;
   real flow_time = CURRENT_TIME;
   begin_f_loop(f,th)
     {
       if(flow_time <= 0.01)
          F_PROFILE(f,th,i) = 3.0;
       else if(flow_time <=0.02)
          F_PROFILE(f,th,i) = 4.0;
       else
          F_PROFILE(f,th,i) = 5.0;
     }
    end_f_loop(f,th);
 }

After the UDF that you have defined using DEFINE_PROFILE is interpreted (Interpreting UDFs) or compiled (Compiling UDFs), the name of the argument that you supplied as the first DEFINE macro argument (for example, vis_res) will become visible and selectable in the appropriate boundary condition dialog box (for example, the Velocity Inlet dialog box), cell zone condition dialog box, and Shell Conduction Layers dialog box in Ansys Fluent. See Hooking DEFINE_PROFILE UDFs for details.

You can use DEFINE_PROPERTY to specify a custom material property in Ansys Fluent for single-phase flows and multiphase flows. DEFINE_PROPERTY can also be used to specify a custom material property for structural materials to be used in a fluid-structure interaction (FSI) simulation. If you are writing a user-defined mixing law UDF for a mixture material, you will need to use special utilities to access species material properties. These are described below. If you want to define a custom mass diffusivity property when modeling species transport, you must use DEFINE_DIFFUSIVITY instead of DEFINE_PROPERTY. See DEFINE_DIFFUSIVITY for details on DEFINE_DIFFUSIVITY UDFs. For an overview of the Ansys Fluent solution process which shows when a DEFINE_PROPERTY UDF is called, refer to Figure 1.2: Solution Procedure for the Pressure-Based Segregated Solver, Figure 1.3: Solution Procedure for the Pressure-Based Coupled Solver, and Figure 1.4: Solution Procedure for the Density-Based Solver.

Some of the properties you can customize using DEFINE_PROPERTY are:

For Multiphase Flows

For an intrinsic FSI simulation, DEFINE_PROPERTY can be used to customize the following structural properties:

DEFINE_PROPERTY (name, c, t)

Function returns

real

There are three arguments to DEFINE_PROPERTY: name, c, and t. You supply name, the name of the UDF. c and t are variables that are passed by the Ansys Fluent solver to your UDF. Your UDF will need to compute the real property only for a single cell and return it to the solver.

Note that like source term UDFs, property UDFs (defined using DEFINE_PROPERTY) are called by Ansys Fluent from within a loop on cell threads. The solver passes all of the variables needed to allow a DEFINE_PROPERTY UDF to define a custom material, since properties are assigned on a cell basis. Consequently, your UDF will not need to loop over cells in a zone since Ansys Fluent is already doing it.

Some commonly-used auxiliary utilities for custom property UDFs are described below. They are generic_property, MATERIAL_PROPERTY, THREAD_MATERIAL, and mixture_species_loop.

generic_property is a general purpose function that returns the real value for the given property id for the given thread material. It is defined in prop.h and is used only for species properties.

The following Property_ID variables are available:

generic_property (name, c, t, prop, id, T)

Function returns

real

MATERIAL_PROPERTY is defined in materials.h and returns a real pointer to the Property array prop for the given material pointer m.

MATERIAL_PROPERTY (m)

Function returns

real

THREAD_MATERIAL is defined in threads.h and returns real pointer m to the Material that is associated with the given cell thread t.

THREAD_MATERIAL (t)

Function returns

real

mixture_species_loop is defined in materials.h and loops over all of the species for the given mixture material.

mixture_species_loop (m,sp,i)

Function returns

real

The following UDF, named cell_viscosity, generates a variable viscosity profile to simulate solidification. The function is called for every cell in the zone. The viscosity in the warm ( K) fluid has a molecular value for the liquid (5.5 kg/m-s), while the viscosity for the cooler region ( 286 K) has a much larger value (1.0 kg/m-s). In the intermediate temperature range (286 K 288 K), the viscosity follows a linear profile that extends between the two values given above:

(2–10)

This model is based on the assumption that as the liquid cools and rapidly becomes more viscous, its velocity will decrease, thereby simulating solidification. Here, no correction is made for the energy field to include the latent heat of freezing. The source code can be interpreted or compiled in Ansys Fluent.

/*********************************************************************
   UDF that simulates solidification by specifying a temperature-
   dependent viscosity property
 **********************************************************************/
 #include "udf.h"
 
 DEFINE_PROPERTY(cell_viscosity,c,t)
 {
    real mu_lam;
    real temp = C_T(c,t);
    if (temp > 288.)
      mu_lam = 5.5e-3;
    else if (temp > 286.)
      mu_lam = 143.2135 - 0.49725 * temp;
    else
      mu_lam = 1.;
    return mu_lam;
 } 

The function cell_viscosity is defined on a cell. Two real variables are introduced: temp, the value of C_T(c,t), and mu_lam, the laminar viscosity computed by the function. The value of the temperature is checked, and based upon the range into which it falls, the appropriate value of mu_lam is computed. At the end of the function the computed value for the viscosity (mu_lam) is returned to the solver.