Make a local copy of the fiber directory by copying it from the path below to your working directory.

path/ansys_inc/v242/fluent/fluent24.2.0/addons/fiber/

where path is the directory in which you have installed Ansys Fluent.

Below is an example of a heat transfer coefficient UDF that is defined in fiber_fluent_interface.c. The function is taken from Kase and Matsuo 291 and is implemented as the kase-matsuo-1 option in the fiber model. The function name user_heat_transfer_coefficient must not, under any circumstances, be altered because it is called by other functions in the continuous fiber model.

There are two arguments to the user_heat_transfer_coefficient UDF: Fiber and Local_Fiber_Data_Type. Fiber *f is a pointer to the fiber structure that contains information about the fiber and Local_Fiber_Data_Type *fd accesses temporary variables that are needed during the calculation of the fiber.

In the sample UDF below, a loop is performed over all fiber grid cells using the macro FIB_N(f) which represents the number of grid cells for the fiber f. The Reynolds number is computed based on the relative velocity, (ABS(FIB_C_U(f,i)-fd->up[i])); the fiber diameter, FIB_C_D(f,i); the density of the surrounding fluid, fd->rho[i] and the viscosity of the surrounding fluid, fd->vis[i]. The heat transfer coefficient is computed from the Nusselt number using the thermal conductivity of the surrounding fluid, , (fd->k[i]) and is stored in fd->alpha[i].

 void 
 user_heat_transfer_coefficient(Fiber *f, Local_Fiber_Data_Type *fd)
 {
  int i;
  real Red, Nud;

  /* model from Kase/Matsuo (1967) */
  for (i=0; iFIB_N(f); i++)
  {
    /* compute Reynolds number based on relative velocity */
    Red = ABS(FIB_C_U(f,i)-fd->up[i])*FIB_C_D(f,i)*fd->rho[i]/fd->vis[i];
    Nud = 0.42*pow(Red, 0.334);
    /* store heat transfer coefficient for latter use */
    fd->alpha[i] = Nud*fd->k[i]/FIB_C_D(f,i);
   }
 } 

All variables and macros that are used in user_heat_transfer_coefficient are defined in header files provided with the continuous fiber model. For example, you will find the type definition Fiber and the macros that are used to access variables of a single fiber in the header file fiber.h. Temporary variables used in the type definition of Local_Fiber_Data_Type can be found in the header file fib-mem.h.

You can also calculate fiber material properties using UDFs. Ansys Fluent provides a UDF template for every fiber property. You can modify the UDF templates for your specific case.

The template for the fiber density is as follows:

real User_Fiber_Specific_Heat(Fiber *f, real temp, real liq, int i) 
{ 
  real yi[MAX_SPE_EQNS];
  real cp_p; 
/* compute cp based on FLUENT's standard procedure selected in materials panel */
  cp_p = Specific_Heat(FIB_MATERIAL_POLYMER(f), temp, 0., yi);
  if (FIB_DRY_SPINNING(f)) 
  { 
    real cp_s;
    cp_s = Specific_Heat(FIB_MATERIAL_SOLVENT(f), temp, 0., yi);
    return cp_p*(1.-liq)+cp_s*liq;
   }
  return cp_p; 
}

All variables and macros defined in the header files are provided with the continuous fiber model. For example, you will find the type definition Fiber and the macros to access variables of a single fiber in the header file fiber.h. The temporary variables used in the type definition of Local_Fiber_Data_Type can be found in the header file fib-mem.h.

In the /fiber in your working directory, run the make command that will compile your fiber mode UDF and build a shared library for the architecture you are running. To do this, type the following command at the prompt:

 make -f Makefile-client FLUENT_ARCH=your_arch 

where your_arch is replaced by the architecture of the machine you are running (for example, lnx86).

For example, if your computer architecture is lnx86 type the following command in a terminal session:

 make -f Makefile-client FLUENT_ARCH=lnx86 

To identify the architecture of the machine you are running on, scroll up the Ansys Fluent console window to the message that begins with “Starting”.

When you run the make process, the source code (fluent_fiber_interface.c) will be compiled into object code and a shared library will be built for the computer architecture and version of Ansys Fluent you are running. Messages about the compile/build process will be displayed on the console window. You can view the compilation history in the log file that is saved in your working directory. Below is an example of console messages for a lnx86 architecture running a 2D version of Ansys Fluent.

 Working...
 for d in lnx86[23]*; do \
    ( \
       cd $d; \
       for f in ../../src*.[ch] ../../src/makefile; do \
          if [ ! -f ’basename $f’ ]; then \
            echo "# linking to " $f "in" $d; \
            ln -s $f .; \
         fi; \
       done; \
       echo ""; \
       echo "# building library in" $d; \
       make -kmakelog 2&1; \
       cat makelog; \
   ) \
 done
 # linking to ...  myudf.c in lnx86/2d

 # building library in lnx86/2d
 make[1]: Entering directory ..../udf_names.c
 # Generating udf_names
 make[2]: Entering directory ..../fluent_fiber_interface.c
 make libudf.so ...
 # Compiling udf_names.o ...
 # Compiling profile.o ...
 # Linking libudf.so ...
 make[2]: Leaving directory ..../udf_names.c
 make[1]: Leaving directory ..../fluent_fiber_interface.c

 You can also see the ’log’-file in
 the working directory for compilation history

 Done.