See section 10 of fluent user manual for user-defined functions and

examples
1. Steady velocity function
A UDF is used to introduce this parabolic profile at the inlet. The C source code ( vprofile.c) is shown
below. The function makes use of Fluent-provided solver
functions that are described in Section 5.3.
/***********************************************************************/
/* vprofile.c
*/
/* UDF for specifying steady-state velocity profile boundary condition */
/***********************************************************************/
#include "udf.h"
DEFINE_PROFILE(inlet_x_velocity, thread, position)
{
real x[ND_ND];
/* this will hold the position vector */
real y;
face_t f;
begin_f_loop(f, thread)
{
F_CENTROID(x,f,thread);
y = x[1];
F_PROFILE(f, thread, position) = 20. - y*y/(.0745*.0745)*20.;
}
end_f_loop(f, thread)
}
The function, named inlet_x_velocity, is defined using DEFINE_PROFILE and has two arguments: thread
and position. Thread is a pointer to the face's
thread, and position is an integer that is a numerical label for the variable being set within each loop.
The function begins by declaring variable f as a face_t data type. A one-dimensional array x and variable y
are declared as real data types. A looping macro is
then used to loop over each face in the zone to create a profile, or an array of data. Within each loop,
F_CENTROID outputs the value of the face centroid (array x)
for the face with index f that is on the thread pointed to by thread. The y coordinate stored in x[1] is
assigned to variable y, and is then used to calculate the x
velocity. This value is then assigned to F_PROFILE, which uses the integer position (passed to it by the
solver based on your selection of the UDF as the
boundary condition for x velocity in the Velocity Inlet panel) to set the x velocity face value in memory.
To make use of this interpreted UDF in FLUENT, you must first compile it.
Define User-Defined Functions Interpreted...

In the Interpreted UDFs panel, name your function in the Source File Name field. If necessary, enter your C
preprocessor type in the CPP Command Name

field and the size of the stack under Stack Size. Turn on Display Assembly Listing to see an assembly
listing in your console window as the function compiles.
Click on Compile and then Close the panel.
To select this user-defined function as the velocity boundary condition for the zone of choice, open the
Velocity Inlet panel.

In the X-Velocity drop-down list, select udf inlet_x_velocity, the name that was given to the function
above. This function will now be used, rather than the value
of (in this example) 0 that appears in the X-Velocity field. Click on OK to accept the new boundary
condition and close the panel.
In this example, a temporally periodic velocity boundary condition will be applied to the inlet of a tube
using a UDF. The velocity has the form

(10.1.1)
The tube is 1 m long with a radius of 0.2 m. It is assumed to be filled with air with a density of 1 kg/m 3and
a viscosity of 2 kg/m-s. The velocity of the air
fluctuates about an equilibrium value, v 0, of 20 m/s, with an amplitude of 5 m/s and at a frequency of 10
rad/s.

2. Unsteady Velocity specification :

The source code for the velocity profile UDF ( unsteady.c) is shown below.
/**********************************************************************/
/* unsteady.c
*/
/* UDF for specifying a transient velocity profile boundary condition */
/**********************************************************************/
#include "udf.h"
DEFINE_PROFILE(unsteady_velocity, thread, position)
{
face_t f;
begin_f_loop(f, thread)
{
real t = RP_Get_Real("flow-time");
F_PROFILE(f, thread, position) = 20. + 5.0*sin(10.*t);
}
end_f_loop(f, thread)
}
The function, named unsteady_velocity, is defined using the DEFINE_PROFILE macro. The utility
RP_Get_Real("flow-time") is used to look up the real
flow time, which is assigned to the variable t. (See Section 6.9 for details on RP_Get_Real.)

Before you can compile this UDF, you must specify an unsteady flow calculation in the Solver panel.
Define Models Solver...
Next you can open the Interpreted UDFs panel. Enter the name of the function in the text entry box under
Source File Name and, if necessary, the name of your
C preprocessor. Turn on Display Assembly Listing. Click on Compile and then Close the panel.
Define User-Defined Functions Interpreted...

The sinusoidal velocity boundary condition defined by the UDF can now be selected for the X-Velocity in
the inlet zone. In the Velocity Inlet panel, simply select
udf unsteady_velocity in the drop-down list to the right of the X-Velocity field, and click on OK.

3. Momentum Source :
/******************************************************************/
/* UDF that adds momentum source term and derivative to duct flow */
/******************************************************************/
#include "udf.h"
#define CON

20.0

DEFINE_SOURCE(cell_x_source, cell, thread, dS, eqn)

{
real source;
if (C_T(cell,thread) <= 288.)
{
/* source term */
source = -CON*C_U(cell,thread);
/* derivative of source term w.r.t. x-velocity. */
dS[eqn] = -CON;
}
else
source = dS[eqn] = 0.;
return source;
}
The function, named cell_x_source, is defined on a cell using DEFINE_SOURCE. The constant C in
Equation 10.2-1 is called CON in the function, and it is given a
numerical value of 20 kg/m 3-s, which will result in the desired units of N/m 3 for the source. The
temperature at the cell is returned by C_T(cell,thread). The
function checks to see if the temperature is below (or equal to) 288 K. If it is, the source is computed
according to Equation 10.2-1 ( C_U returns the value of the x
velocity of the cell). If it is not, the source is set to 0.0. At the end of the function, the appropriate value for
the source is returned to the FLUENT solver. The UDF

is executed as interpreted (see Section 7.2).

4. Solidification via a Temperature-Dependent Viscosity

UDFs for properties (as well as sources) are called from within a loop on cells. For this reason, functions
that specify properties are only required to compute the
property for a single cell, and return the value to the FLUENT solver.
The UDF in this example generates a variable viscosity profile to simulate solidification, and is applied to
the same problem that was presented in Section 10.2.1.
The viscosity in the warm ( T > 288 K) fluid has a molecular value for the liquid (5.5 kg/m-s), while the
viscosity for the cooler region ( T < 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:

(10.3.1)
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 C source code for the
UDF is shown below.
/*********************************************************************/
/* UDF for specifying a temperature-dependent viscosity property */
/*********************************************************************/
#include "udf.h"
DEFINE_PROPERTY(cell_viscosity, cell, thread)
{
real mu_lam;
real temp = C_T(cell, thread);
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, named cell_viscosity, is defined on a cell using DEFINE_PROPERTY. Two real variables are
introduced: temp, the value of
C_T(cell,thread), 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
mu_lam is returned to the solver.

To make use of a user-defined property, you will use the Materials panel. In the drop-down list for
Viscosity, select the user-defined option.

Once you select this option, the User-Defined Functions panel opens, from which you can select the
appropriate function name. In this example, only one is
available, but in another example, you might have several functions from which to choose. (Recall that if
you need to compile more than one interpreted UDF, the
functions can be concatenated prior to compiling. See Section 7.2.1 for details.)

5. Wall Heat Flux

The wall heat flux function ( DEFINE_HEAT_FLUX) can be used to modify
the way that the solver computes the heat flux between
a wall and the neighboring fluid cells. For example, you can customize
the heat transfer coefficient or the law-of-the-wall for
temperature. The UDF presented below uses an internal heat transfer
coefficient to specify the wall heat flux. It is another example
of a UDF that utilizes the ADJUST function to adjust a computed value,
and it is executed as a compiled UDF.
The diffusive heat flux coefficients ( cid) are specified in this UDF.
The diffusive heat flux ( qid) will then be computed by
FLUENT using the following equation:
qid = cid[0] + cid[1]*C_T(c0,t0) - cid[2]*F_T(f,t) cid[3]*pow(F_T(f,t),4)
/
***********************************************************************/
/* UDF for specifying the diffusive heat flux between a wall and
*/
/* neighboring cells
*/
/
***********************************************************************/
#include "udf.h"
static real h = 0.;
*/

/* heat transfer coefficient (W/m^2 C)

DEFINE_ADJUST(htc_adjust, domain)
{
/* Define the heat transfer coefficient. */
h = 120;
}
DEFINE_HEAT_FLUX(heat_flux, f, t, c0, t0, cid, cir)
{
cid[0] = 0.;
cid[1] = h;

cid[2] = h;
cid[3] = 0.;
}