Customization Manager

The customization methods include:

1. User Defined Elements (UDEs)

   UDE’s allow for an entire element to be added. In the user interface, the UDE Designer is used to create the UDE and define all required inputs. The UDE code (Python or Fortran) must include everything required to relate the inputs and boundary conditions to the thermo-fluid behavior of the element. This is a very flexible method but requires a higher level of expertise to implement. See User Defined Element (UDE) for more information.

2. Controllers

   The controller manipulates a specific part of an element solution. For instance, the Feed-Forward controller can be used to calculate a Heat Transfer Coefficient (HTC) based on a set in the “gauge” variables. The HTC is then applied to an element as a “manipulated” variable. Controllers are very flexible and do not require as much expertise as a UDE to implement. The controller can be tedious to implement on numerous items in a model, however. See Controllers for more information.

3. Custom Correlations

   The last customization option has a limited set of items that can be manipulated but is easy to implement on many elements. The items that can be manipulated by the custom correlation option include HTC’s, friction, and seal losses. If there is an item that you would like added to the custom correlations, Contact Altair if there is an item that you would like added to the custom correlations. The user interface customization manager defines the custom correlation.

• CT=Standard Compressible Tube
• IT=Incompressible Tube
• AO=Advanced Orifice
• TP=Turbulated Passage
• Re=Reynolds Number

There are two main steps to begin using a custom correlation.

1. Create the custom item in the Customization Manager.
2. Select the custom item from the element properties editor.

Figure 1. PreProcessing Menu/Customization Manager option

Figure 2. Customization Manager dialog

1. Click New to create a new custom item.
2. Give the item a name; no spaces allowed in the name.
3. Select the programming language: Python or Fortran.
4. Select the subtype for the custom item.
5. Select English or SI units to control the units of variables passed between the custom code and the Flow Simulator solver.
6. Define the unique inputs for the custom items. These can be used to add inputs for each element that uses this custom item. These variables are added to the argument list for the Python and Fortran custom routines. No spaces are allowed in the names.

   
   
   Figure 3.

7. If Language=Python, write the Python code. Use the Restore button to update the Python code template that is supplied.
8. If Language=Fortran, a unique ID can be given so that multiple items of the same subtype can be programmed in the same Fortran subroutine. The other option is to use a unique subroutine name for each item.
9. If Language=Fortran, a unique DLL and subroutine names can be given. “Default” means the solver uses customize.dll and the subroutine names are found in the fs_custom_lib.f example file.

From the Customization Manager, use the Import and Export buttons to write the custom items to a file and read into another model, respectively.

• Use Export to write a file containing all custom items in the current model.
• Use Import in another model to read all custom items into the model.

Figure 4.

Figure 5.

Figure 6.

There are two subroutines available that can be used to retrieve more information about the model. These can be used if the argument list does not contain an input required by the correlation. The subroutines are:

• CUST_GET_SET_REFERENCE_CONDITION
• CUST_GET_FLUID_PROP

The subroutine argument lists and some parameters can be found in the files:

• <FlowSimulator_install_folder>\Resources\Customize\reference\custom_interface_mod.f90
• custom_param_mod.f90

Figure 7.

Example - Retrieve the static pressure at station IDX in the element ELEM:

CALL CUST_GET_SET_REFERENCE_CONDITION (GET_MODE, ELEMENT_TYPE, ELEM, IDX, "NONE", 0, 0, "PS", PS, ISTATUS)

Example - retrieve the area at station IDX in the element ELEM:

CALL CUST_GET_SET_REFERENCE_CONDITION (GET_MODE, ELEMENT_TYPE, ELEM, IDX, "NONE", 0, 0, "AREA", AREA, ISTATUS)

Figure 8.

Example - Retrieve fluid conductivity based on a supplied P and T:

CUST_PRP_INP(1)      = CUST_PRP_P
CUST_PRP_INP(2)              = CUST_PRP_T
CUST_PRP_VIN(1)              = PS
CUST_PRP_VIN(2)              = TS + 459.67
CUST_PRP_LOUT                = .FALSE.
CUST_PRP_LOUT(CUST_PRP_CON)  = .TRUE.
CALL CUST_GET_FLUID_PROP(CUST_PRP_INP, CUST_PRP_VIN, CUST_PRP_LOUT, CUST_PRP_VOUT, ELEM, CUST_FLOW_ELM, ISTATUS)
K                            = CUST_PRP_VOUT(CUST_PRP_CON)

Figure 9.

Example - Write the first line of your text:

USER_OUTPUT=" STATION Re Friction_Factor"
CALL CUST_FILL_OUTPUT_STRING (1, USER_OUTPUT)

This writes a table for each station of a tube:

WRITE (USER_OUTPUT, "(I5, F10.2, F10.5)") IDX, REL, FRIC_DARCY
CALL CUST_FILL_OUTPUT_STRING (IDX+1, USER_OUTPUT)

Figure 10.

Like Fortran, Python has functions that can retrieve additional model data. The functions are:

• cust.get_set_reference_condition
• cust.get_fluid_prop

cust.get_set_reference_condition is based on the Flow Simulator controllers and can be used to retrieve (gauge or GET) and manipulate (SET) many items in the model. Command format:

propval = cust.get_set_reference_condition (mode, itemtype, itemnum, prop, locat1, locat1_str, locat2, locat3)

mode       = GET (1) or SET (2)
itemtype   = CHAMBER=3, ELEMENT=4, THERMAL=7, GENERAL=1, MISSION=2, COMPONENT=8
itemnum    = Number from the .flo file of the item (chamber, element, etc..)
prop       = A property name recognized by the controller (like "PT", "PS", "TT", "MDOT_TOTAL" etc..)
locat1     = First additional index. Ex: 5 for tube station 5, 0 if not needed
locat1_str = Only needed if itemtype=7 (Thermal).  Then use "TNODE", "CDUCR", "CVECR", "RADTR", "HEAT_FLOW". "NONE" if not needed.
locat2     = Second additional index. Ex 2 for tube wall side 2, or 4 for TNODE 4, 0 if not needed
locat3     = Third additional index. Ex "2" for ?, 0 if not needed, etc..
propval    = value returned from controller for "GET" and sent to controller for "SET"

Example - Retrieve the static pressure at station IDX in the element ELEM:

pstatic = cust.get_set_reference_condition (cust.GET_MODE, cust.ELEMENT_TYPE, int(elem), "PS", int(idx), "NONE", 0, 0)

Example - Retrieve the area at station IDX in the element ELEM:

area = cust.get_set_reference_condition (cust.GET_MODE, cust.ELEMENT_TYPE, int(elem), "AREA", int(idx), "NONE", 0, 0)

CUST_GET_FLUID_PROP retrieves fluid properties based on the pressure and temperature supplied. Command format:

propval = cust.get_fluid_prop (inp_type_1, inp_val_1, inp_type_2, inp_val_2, out_type, itemnum, ec_flag)

inp_type_1   =   first independent variable type (typically pressure so use cust.PRP_P parameter)
inp_val_1    =   value of the first independent variable
inp_type_2   =   second independent variable type (typically temperature so use cust.PRP_T parameter)
inp_val_2    =   value of the second independent variable
out_type     =   the fluid property to output
itemnum      =   Number from the .flo file of the element
ec_flag      =   identifies itemnum as an element or chamber (cust.FLOW_ELM)

The parameters that can be used for inp_type_1, inp_type_2, and out_type are:

Example - Retrieve fluid conductivity based on a supplied P and T:

k = cust.get_fluid_prop (cust.PRP_P, pstatic, cust.PRP_T, tstatic, cust.PRP_CON, int(elem), cust.FLOW_ELM)

Command format:

cust.fill_output_string (line_number, text_string)

line_number

The line that this text string is written to. Start with 1 and add more if needed.

text_string

The text string to write to the .res file

Example - Write the calcuted inlet k as the first custom output line:

cust.fill_output_string(1, "inlet_k="+str(inlet_k))