Set Command's Parameters (cmdSetXXX( ) )

There are general functions written for each panel command to set the command's parameters to their default values and put the valid values in the database according to the defined path.

Below is a table of available functions:
Function AcuSolve Command Name Active
cmdSetAutoSolutionStrategy AUTO_SOLUTION_STRATEGY no no
cmdSetGravity GRAVITY yes no
cmdSetMassSpeciesSource MASS_SPECIES_SOURCE yes no
cmdSetVolumeSpeciesSource VOLUME_SPECIES_SOURCE yes no
cmdSetMassHeatSource MASS_HEAT_SOURCE yes no
cmdSetVolumeHeatSource VOLUME_HEAT_SOURCE yes no
cmdSetBodyForce BODY_FORCE yes no
cmdSetCaaElementOutput CAA_ELEMENT_OUTPUT yes no
cmdSetCaaOutput CAA_OUTPUT yes no
cmdSetCaaSurfaceOutput CAA_SURFACE_OUTPUT yes no
cmdSetContactAngleModel CONTACT_ANGLE_MODEL yes no
cmdSetConvergenceCheckParameters CONVERGENCE_CHECK_PARAMETERS no no
cmdSetElementBoundaryCondition ELEMENT_BOUNDARY_CONDITION yes yes
cmdSetElementOutputs ELEMENT_OUTPUT yes yes
cmdSetElementSets ELEMENT_SET yes yes
cmdSetEmissivityModel EMISSIVITY_MODEL yes no
cmdSetExternalCodeParameters EXTERNAL_CODE no no
cmdSetExternalCodeSurface EXTERANL_CODE_SURFACE yes yes
cmdSetFanComponents FAN_COMPONENT yes yes
cmdSetFlexibleBody FLEXIBLE_BODY yes no
cmdSetFreeSurface FREE_SURFACE yes yes
cmdSetGlobalMeshAttributes GLOBAL_MESH_ATTRIBUTES no no
cmdSetGuideSurface GUIDE_SURFACE yes yes
cmdSetHeatExchangerComponent HEAT_EXCHANGER_COMPONENT yes yes
cmdSetIntegratedBoundaryCondition SURFACE_INTEGRATED_CONDITION yes yes
cmdSetInterfaceSurface INTERFACE_SURFACE yes yes
cmdSetLinearSolverParameters LINEAR_SOLVER_PARAMETERS no no
cmdSetDensityModel DENSITY_MODEL yes no
cmdSetSpecificHeatModel SPECIFIC_HEAT_MODEL yes no
cmdSetViscosityModel VISCOSITY_MODEL yes no
cmdSetConductivityModel CONDUCTIVITY_MODEL yes no
cmdSetDiffusivityModel DIFFUSIVITY_MODEL yes no
cmdSetPorosityModel POROSITY_MODEL yes no
cmdSetMaterialModel MATERIAL_MODEL yes no
cmdSetMeshMotion MESH_MOTION yes no
cmdSetMultiplierFunction MULTIPLIER_FUNCTION yes no
cmdSetNodalBoundaryCondition NODAL_BOUNDARY_CONDITION yes yes
cmdSetNodalInitialCondition NODAL_INITIAL_CONDITION no no
cmdSetNodalOutput NODAL_OUTPUT no no
cmdSetDerivedQuantityOutput DERIVED_QUANTITY_OUTPUT no no
cmdSetRunningAverageOutout RUNNING_AVERAGE_OUTPUT no no
cmdSetTimeAverageOutput TIME_AVERAGE_OUTPUT no no
cmdSetErrorEstimatorOutput ERROR_ESTIMATOR_OUTPUT no no
cmdSetRestartOutput RESTART_OUTPUT no no
cmdSetNodalResidualOutput NODAL_RESIDUAL_OUTPUT no no
cmdSetTimeHistoryOutput TIME_HISTORY_OUTPUT yes no
cmdSetParticleSurface PARTILE_SURFACE yes yes
cmdSetPeriodicBoundaryCondition PERIODIC_BOUNDARY_CONDITION yes yes
cmdSetProblemDescription ANALYSIS & EQUATION no no
cmdSetRadiationParameters RADIATION no no
cmdSetRadiationSurface RADIATION_SURFACE yes yes
cmdSetReferenceFrame REFERENCE_FRAME yes no
cmdSetSimpleBoundaryCondition SIMPLE_BOUNDARY_CONDITION yes yes
cmdSetSolarRadiationModel SOLAR_RADIATION_MODEL yes no
cmdSetSolarRadiationParameters SOLAR_RADIATION no no
cmdSetSolarRadiationSurface SOLAR_RADIATION_SURFACE yes yes
cmdSetStagger STAGGER yes no
cmdSetSurfaceMeshAttributes SURFACE_MESH_ATTRIBUTES yes yes
cmdSetSurfaceOutput SURFACE_OUTPUT yes yes
cdmSetSurfaceTensionModel SURFACE_TENSION_MODEL yes no
cmdSetTimeIncrement TIME_INCREMENT no no
cmdSetTimeIntegration TIME_INTEGRATION no no
cmdSetTimeSequence TIME_SEQUENCE no no
cmdSetTurbulenceWall TURBULENCE_WALL yes yes
cmdSetUserGlobalData USER_GLOBAL_DATA yes no
cmdSetVolumeMeshAttributes VOLUME_MESH_ATTRIBUTES yes yes
cmdSetZoneMeshAttributes --- yes yes

where the name and active columns refer to having these in the command arguments.

The following are all of the set functions of the commands with their arguments:
  • ALGEBRAIC_MULTIGRID_PARAMETERS
    def cmdSetAlgebraicMultigridParameters(
                                             clobber = True,
                                             pressure_standard_interpolation = True,
                                             pressure_truncated_interpolation = True,
                                             pressure_negative_coupling_tolerance = 0.25,
                                             pressure_positive_coupling_tolerance = 0.5,
                                             pressure_truncation_tolerance = 0.2,
                                             max_pressure_final_matrix = 100,
                                             pressure_eigenvalue_tolerance = 1.e-6,
                                             max_pressure_eigenvalue_iterations = 100,
                                             pressure_smoothing_order = 2,
                                             pressure_chebyshev_max_min_ratio = 10,
                                             num_pressure_global_basis = 0,
                                             pressure_global_basis_tolerance = 1.e-6,
                                             max_pressure_global_basis_iterations = 1000,
                                             num_pressure_initial_givens_rotations = 0,
                                             pressure_jacobi_relaxation_factor = 0.25,
                                             pressure_relaxation_type = 'chebyshev',
                                             pressure_positive_negative_separate = False,
                                             pressure_givens_scaling = True,
                                             pressure_setup_tolerance = 0,
                                             velocity_standard_interpolation = True,
                                             velocity_truncated_interpolation = True,
                                             velocity_negative_coupling_toleranc e= 0.5,
                                             velocity_positive_coupling_tolerance = 1,
                                             velocity_truncation_tolerance = 0.1,
                                             max_velocity_final_matrix = 100,
                                             velocity_num_krylov_vectors = 30,
                                             velocity_smoothing_order = 2,
                                             velocity_chebyshev_max_min_ratio = 10,
                                             velocity_jacobi_relaxation_factor = 0.25,
                                             velocity_relaxation_type = 'chebyshev',
                                             velocity_positive_negative_separate = False,
                                             velocity_givens_scaling = False,
                                             velocity_setup_tolerance = 0,
                                             flow_standard_interpolation = True,
                                             flow_truncated_interpolation = True,
                                             flow_negative_coupling_tolerance = 0.5,
                                             flow_positive_coupling_tolerance = 1,
                                             flow_truncation_tolerance = 0.1,
                                             max_flow_final_matrix = 100,
                                             flow_num_krylov_vectors = 30,
                                             flow_smoothing_order = 2,
                                             flow_chebyshev_max_min_ratio = 10,
                                             flow_jacobi_relaxation_factor = 0.25,
                                             flow_relaxation_type = 'chebyshev',
                                             flow_positive_negative_separate = False,
                                             flow_givens_scaling = False,
                                             flow_setup_tolerance = 0,
                                             temperature_standard_interpolation = True,
                                             temperature_truncated_interpolation = True,
                                             temperature_negative_coupling_tolerance = 0.5,
                                             temperature_positive_coupling_tolerance = 1,
                                             temperature_truncation_tolerance = 0.1,
                                             max_temperature_final_matrix = 100,
                                             temperature_num_krylov_vectors = 30,
                                             temperature_smoothing_order = 2,
                                             temperature_chebyshev_max_min_ratio = 10,
                                             temperature_jacobi_relaxation_factor = 0.25,
                                             temperature_relaxation_type = 'chebyshev',
                                             temperature_positive_negative_separate = False,
                                             temperature_givens_scaling = False,
                                             temperature_setup_tolerance = 0,
                                             species_standard_interpolation = True,
                                             species_truncated_interpolation = True,
                                             species_negative_coupling_tolerance = 0.5,
                                             species_positive_coupling_tolerance = 1,
                                             species_truncation_tolerance = 0.1,
                                             max_species_final_matrix = 100,
                                             species_num_krylov_vectors = 30,
                                             species_smoothing_order = 2,
                                             species_chebyshev_max_min_ratio = 10,
                                             species_jacobi_relaxation_factor = 0.25,
                                             species_relaxation_type = 'chebyshev',
                                             species_positive_negative_separate = False,
                                             species_givens_scaling = False,
                                             species_setup_tolerance = 0,
                                             turbulence_standard_interpolation = True,
                                             turbulence_truncated_interpolation = True,
                                             turbulence_negative_coupling_tolerance = 0.5,
                                             turbulence_positive_coupling_tolerance = 1,
                                             turbulence_truncation_tolerance = 0.1,
                                             max_turbulence_final_matrix = 100,
                                             turbulence_num_krylov_vectors = 30,
                                             turbulence_smoothing_order = 2,
                                             turbulence_chebyshev_max_min_ratio = 10,
                                             turbulence_jacobi_relaxation_factor = 0.25,
                                             turbulence_relaxation_type = 'chebyshev',
                                             turbulence_positive_negative_separate = False,
                                             turbulence_givens_scaling = False,
                                             turbulence_setup_tolerance = 0,
                                             mesh_standard_interpolation = True,
                                             mesh_truncated_interpolation = True,
                                             mesh_negative_coupling_tolerance = 0.6,
                                             mesh_positive_coupling_tolerance = 1,
                                             mesh_truncation_tolerance = 0.1,
                                             max_mesh_final_matrix = 100,
                                             mesh_eigenvalue_tolerance = 1.e-2,
                                             max_mesh_eigenvalue_iterations = 20,
                                             mesh_smoothing_order = 2,
                                             mesh_chebyshev_max_min_ratio = 10,
                                             num_mesh_global_basis = 0,
                                             #------ Misc. 12/09:C3 12/07/09 SH
                                             mesh_global_basis_tolerance = 1.e-6,
                                             max_mesh_global_basis_iteration s= 1000,
                                             num_mesh_initial_givens_rotations = 0,
                                             mesh_jacobi_relaxation_factor = 0.25,
                                             mesh_relaxation_type = 'chebyshev',
                                             mesh_positive_negative_separate  = True,
                                             mesh_givens_scaling = False,
                                             mesh_setup_tolerance = 0,
                                             viscoelastic_standard_interpolation = True,
                                             viscoelastic_truncated_interpolation = True,
                                             viscoelastic_negative_coupling_tolerance = 0.5,
                                             viscoelastic_positive_coupling_tolerance = 1,
                                             viscoelastic_truncation_tolerance = 0.1,
                                             max_viscoelastic_final_matrix = 100,
                                             viscoelastic_num_krylov_vectors = 30,
                                             viscoelastic_smoothing_order = 2,
                                             viscoelastic_chebyshev_max_min_ratio = 10,
                                             viscoelastic_jacobi_relaxation_factor = 0.25,
                                             viscoelastic_relaxation_type = 'chebyshev',
                                             viscoelastic_positive_negative_separate = False,
                                             viscoelastic_givens_scaling = False,
                                             viscoelastic_setup_tolerance = 0,
                                             protect_parameters = False ):
  • AUTO_SOLUTION_STRATEGY
    def cmdSetAutoSolutionStrategy( clobber = True,
                                     max_time_steps = 100,
                                     final_time = 0,
                                     initial_time_increment = 1.e+10,
                                     auto_time_increment = False,
                                     min_time_increment = 0,
                                     max_time_increment = 0,
                                     convergence_tolerance = 1.e-3,
                                     min_stagger_iterations = 0,
                                     max_stagger_iterations = 0,
                                     num_krylov_vectors = 10,
                                     relaxation_factor = 0,
                                     flow = True,
                                     viscoelastic = True,
                                     temperature = True,
                                     temperature_flow = False,
                                     radiation = True,
                                     species_1 = True,
                                     species_2 = True,
                                     species_3 = True,
                                     species_4 = True,
                                     species_5 = True,
                                     species_6 = True,
                                     species_7 = True,
                                     species_8 = True,
                                     species_9 = True,
                                     turbulence = True,
                                     mesh= Trues,
                                     external_code = True):
  • GRAVITY
    def cmdSetGravity( name, clobber = True,
                       type = 'constant',
                       gravity = ((0,0,0),),
                       curve_fit_values = ((0,0,0,0),),
                       curve_fit_variable = 'x_coordinate',
                       user_function = '',
                       user_values = (),
                       user_strings = [],
                       multiplier_function = 'none' ):
    • type can be "none", "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "pressure", "temperature", "eddy_viscosity","species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
  • MASS_SPECIES_SOURCE
    def cmdSetMassSpeciesSource( name, srcId = None,
                                           clobber = True,
                                           type = 'constant',
                                           mass_species_source = 0,
                                           curve_fit_values = ((0,0),),
                                           curve_fit_variable = 'temperature',
                                           user_function = '',
                                           user_values = (),
                                           user_strings = (),
                                           multiplier_function = 'none' ):
    • type can be "none", "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate","x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
  • VOLUME_SPECIES_SOURCE
    def cmdSetVolumeSpeciesSource( name, srcId = None,
                                             clobber = True,
                                             type = 'constant',
                                             volume_species_source = 0,
                                             curve_fit_values = ((0,0),),
                                             curve_fit_variable = 'temperature',
                                             user_function = '',
                                             user_values = (),
                                             user_strings = (),
                                             multiplier_function = 'none' ):
    • type can be "none", "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
  • MASS_HEAT_SOURCE
    def cmdSetMassHeatSource( name,
                                        clobber = True,
                                        type = 'constant',
                                        mass_heat_source = 0,
                                        curve_fit_values = ((0,0),),
                                        curve_fit_variable = 'temperature',
                                        user_function = '',
                                        user_values = (),
                                        user_strings = (),
                                        multiplier_function = 'none' ):
    • type can be "none", "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
  • VOLUME_HEAT_SOURCE
    def cmdSetVolumeHeatSource( name,
                                         clobber = True,
                                         type = 'constant',
                                         volume_heat_source = 0,
                                         curve_fit_values = ((0,0),),
                                         curve_fit_variable = 'temperature',
                                         user_function = '',
                                         user_values = (),
                                         user_strings = (),
                                         multiplier_function = 'none' ):
    • type can be "none", "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
  • BODY_FORCE
    def cmdSetBodyForce( name,
                                  clobber = True,
                                  medium = 'fluid',
                                  type = 'constant',
                                  gravity = ((0, 0, 0),),
                                  style = 'per_unit_mass',
                                  datatree = True ):
  • CAA_ELEMENT_OUTPUT
    def cmdSetCaaElementOutput( name,
                                         clobber = True,
                                         caa_output = '',
                                         quadrature = 'full',
                                         datatree = True ):

    quadrature can be "full", "reduced"

  • CAA_OUTPUT
    def cmdSetCaaOutput( name,
                         clobber = True,
                         directions = (),
                         gap = 0,
                         output_coordinates = False,
                         output_velocity = False,
                         output_pressure = False,
                         output_momentum_stress = False,
                         output_total_stress = False,
                         output_lighthill_stress = False,
                         output_reduced_lighthill_stress = False,
                         output_div_momentum_stress = False,
                         output_div_total_stress = False,
                         output_div_lighthill_stress = False,
                         output_div_reduced_lighthill_stress = False,
                         output_normal_momentum_flux = False,
                         output_normal_momentum_flux_rate = False,
                         output_normal_div_total_stress = False,
                         output_fwh_monopole = False,
                         output_fwh_dipole = False,
                         output_ei_na = False,
                         output_ei_na_velocity = False,
                         output_ei_na_pressure = False,
                         output_ei_na_momentum_stress = False,
                         output_ei_na_total_stress = False,
                         output_ei_na_lighthill_stress = False,
                         output_ei_na_reduced_lighthill_stress = False,
                         output_ei_na_div_momentum_stress = False,
                         output_ei_na_div_total_stress = False,
                         output_ei_na_div_lighthill_stress = False,
                         output_ei_na_div_reduced_lighthill_stress=False,
                         output_ei_gna_div_momentum_stress = False,
                         output_ei_gna_div_total_stress = False,
                         output_ei_gna_div_lighthill_stress = False,
                         output_ei_gna_div_reduced_lighthill_stress=False,
                         output_si_na = False,
                         output_si_na_normal = False,
                         output_si_na_normal_pressure = False,
                         output_si_na_normal_momentum_flux = False,
                         output_si_na_normal_momentum_flux_rate = False,
                         output_si_na_normal_div_total_stress = False,
                         output_si_na_fwh_monopole = False,
                         output_si_na_fwh_dipole = False,
                         output_si_na_pressure = False,
                         reference_density = 1.225,
                         reference_pressure = 0,
                         reference_sound_speed = 330,
                         output_frequency = 1000,
                         output_time_interval = 0,
                         num_saved_states = 0,
                         datatree = True ):
  • CAA_SURFACE_OUTPUT
    def cmdSetCaaSurfaceOutput( name,
                                         clobber = True,
                                         caa_output = '',
                                         quadrature = 'full',
                                         datatree = True ):

    quadrature can be "full", "reduced"

  • CONTACT_ANGLE_MODEL
    def cmdSetContactAngleModel( name,
                                         clobber = True,
                                         type = 'free',
                                         contact_angle = 90,
                                         multiplier_function=  'none',
                                         datatree = True ):
    • type can be "constant", "free"
  • CONVERGENCE_CHECK_PARAMETERS
    def cmdSetConvergenceCheckParameters( clobber = True,
                                      pressure_residual_check = 'standard',
                                      pressure_solution_increment_check = 'looser_by_10',
                                      velocity_residual_check = 'standard',
                                      velocity_solution_increment_check = 'looser_by_10',
                                      viscoelastic_stress_residual_check  = 'looser_by_10',
                                      viscoelastic_stress_solution_increment_check   = 'looser_by_10',
                                      temperature_residual_check = 'standard',
                                      temperature_solution_increment_check= 'looser_by_10',
                                      radiation_residual_check = 'none',
                                      radiation_solution_increment_check = 'looser_by_10',
                                      species_residual_check = 'standard',
                                      species_solution_increment_check = 'looser_by_10',
                                      turbulence_residual_check = 'looser_by_10',
                                      turbulence_solution_increment_check = 'looser_by_100',
                                      mesh_displacement_residual_check = 'none',
                                      mesh_displacement_solution_increment_check = 'looser_by_100' ),
                                      protect_parameters = False ):
    • pressure_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • pressure_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • velocity_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • velocity_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • viscoelastic_stress_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • viscoelastic_stress_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • temperature_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • temperature_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • radiation_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • radiation_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • species_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • species_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • turbulence_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • turbulence_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • mesh_displacement_residual_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
    • mesh_displacement_solution_increment_check can be "none", "standard", "looser_by_10", "looser_by_100", "looser_by_1000", "tighter_by_10", "tighter_by_100", "tighter_by_1000"
  • EDGE_MESH_ATTRIBUTES
def cmdSetEdgeMeshAttributes(   name,
                                   clobber = True,
                                   active = False,
                                   MeshSizeType = 'none',
                                   AbsMeshSize = 1.0,
                                   RelMeshSize = 0.125,
                                   AbsMeshSizeExp = "value=1.0",
                                   RelMeshSizeExp = "value=0.125",
                                   AbsAnisoMeshSizeFactor = 1.0,
                                   RelAnisoMeshSizeFactor = 1.0,
                                   AbsAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1)),
                                   RelAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1)),
                                   CurvatureRefinementFlag = False,
                                   CurvatureAngle = 25,
                                   CurvatureMeshSizeFactor = 0.5,
                                   BoundaryLayerFlag = False,
                                   BoundaryLayerSpec = 'type_1',
                                   FirstLayerHeight = 0.001,
                                   HeightOfLayers = 0.004,
                                   GrowthRate = 1.3,
                                   NumberOfLayers = 3,
                                   ResolveBLAttrib = '3',
                                   BoundaryLayerBlendsFlag = False,
                                   BoundaryLayerPropagateFlag = False,
                                   BoundaryLayerElemType = 'ACUMESH_BL_TRIANGLE',
                                   SweepAngle = 45,
                                   SmallFeatureMeshingFlag = False,
                                   SmallFeatureMeshingType = 'RELATIVE_TOLERANCE',
                                   SmallFeatureMeshingTolerance = 0.0125,
                                   head = 'Model' ):
  • MeshSizeType can be "none","absolute_value", "relative_value", "absolute_expression","relative_expression", "absolute_aniso_value", "relative_aniso_value"
  • BoundaryLayerSpec can be "type_1", "type_2"
  • BoundaryLayerElemType can be "ACUMESH_BL_MIXED", "ACUMESH_BL_TRIANGLE"
  • ResolveBLAttrib can be "1", "2", "3", "4"
  • ELEMENT_BOUNDARY_CONDITION
    def cmdSetElementBoundaryCondition( name,
                         clobber = True,
                         active = False,
                         panel_type = None,
                         panel_ref = None,
                         variable = '',
                         type = 'zero',
                         constant_value = 0,
                         constant_values = ((0,0,0),),
                         surface_values = (),
                         curve_fit_values = ((0,0),),
                         curve_fit_variable = 'x_coordinate',
                         curve_fitt_values = ((0,0,0,0),),
                         curve_fitt_variable = 'x_coordinate',
                         user_function = '',
                         user_values = (),
                         user_strings = (),
                         multiplier_function = 'none',
                         reference_temperature = 273.14,
                         reference_temperature_multiplier_function = 'none',
                         reference_species = 0,
                         reference_species_multiplier_function = 'none',
                         non_reflecting_factor = 0,
                         pressure_loss_factor = 0,
                         pressure_loss_factor_multiplier_function = 'none',
                         hydrostatic_pressure = False,
                         hydrostatic_pressure_origin = ((0,0,0),),
                         active_type = 'all' ),
                         head = 'Model' ):
    • variable can be "mass_flux", "pressure", "stagnation_pressure", "tangential_traction", "heat_flux", "convective_heat_flux", "radiation_heat_flux", "species_1_flux", "convective_species_1_flux", "species_2_flux", "convective_species_2_flux", "species_3_flux", "convective_species_3_flux", "species_4_flux", "convective_species_4_flux", "species_5_flux", "convective_species_5_flux", "species_6_flux", "convective_species_6_flux", "species_7_flux", "convective_species_7_flux", "species_8_flux", "convective_species_8_flux", "species_9_flux", "convective_species_9_flux", "turbulence_flux"
    • type can be "zero", "constant", "free", "outflow", "inflow", "per_surface", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "normal_velocity pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
    • curve_fitt_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "normal_velocity pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
    • active_type can be "none", "all", "no_interface"
  • ELEMENT_OUTPUT
    def cmdSetElementOutputs( name, clobber = True,
                                        active = False,
                                        integrated_output_frequency = 1,
                                        integrated_output_time_interval=0,
                                        num_user_output = 0,
                                        user_function = '',
                                        user_values = (),
                                        user_strings = (),
                                        head = 'Model' ):
  • ELEMENT_SET
    def cmdSetElementSets( name, clobber = True,
                                     active = True,
                                     medium = 'fluid',
                                     quadrature = 'full',
                                     material_model = 'Air',
                                     body_force = 'none',
                                     reference_frame = 'none',
                                     mesh_motion = 'none',
                                     num_shell_layers = 1,
                                     shell_material_models = ('Aluminum'),
                                     shell_thickness_type = 'constant',
                                     shell_thicknesses = (1.0),
                                     viscous_heating = False,
                                     compression_heating = False,
                                     residual_control = True,
                                     oscillation_control = True,
                                     mesh_motion_precedence = 1,
                                     mesh_distortion_correction_factor = 0.0,
                                     mesh_distortion_tolerance = 0.0,
                                     auxiliary_elements = (),
                                     auxiliary_material_model = '',
                                     auxiliary_reference_frame = 'none',
                                     head = 'Model',
                                     element_volume_heat_sources = () ):
    • medium can be "none", "fluid", "solid", "shell"
    • quadrature can be "full", "reduced", "nodal", "high_1", "high_2"
    • shell_thickness_type can be "constant"
  • EMISSIVITY_MODEL
    def cmdSetEmissivityModel( name, clobber = True,
                                         type = 'constant',
                                         emissivity = 1,
                                         curve_fit_values = ((0,0),),
                                         curve_fit_variable = 'temperature',
                                         user_function = '',
                                         user_values = (),
                                         user_strings = (),
                                         multiplier_function ='none',
                                         datatree = True ):
    • type can be "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "temperature"
  • EXTERNAL_CODE_PARAMETERS
    def cmdSetExternalCodeParameters( clobber = True,
                                                communication = 'socket',
                                                launch_command = '',
                                                socket_initiate = True,
                                                socket_host = '',
                                                socket_port = 10000,
                                                fifo_send_file = '',
                                                fifo_receive_file = '',
                                                multiplier_function = 'none',
                                                filter = 'none',
                                                iir_input_coefficients = ((1),),
                                                iir_output_coefficients = () ): 
    • communication can be "pipe", "socket", "fifo"
    • filter can be "none", "iir"
  • EXTERNAL_CODE_SURFACE
    def cmdSetExternalCodeSurface( name, clobber = True,
                                             active = False,
                                             precedence = 1,
                                             coupling_type = 'structural',
                                             rigid_body_name = '',
                                             coupling_direction = 'both',
                                             velocity_type = 'wall',
                                             temperature_type = 'tied',
                                             mesh_displacement_type = 'tied',
                                             turbulence_wall_type = 'wall_function',
                                             roughness_height = 0 ,
                                             external_code_tags = ()
                                             gap_factor = 1,
                                             gap = 0,
                                             head = 'Model' ):
  • velocity_type can be "wall", "slip"
  • temperature_type can be "none", "tied"
  • mesh_displacement_type can be "tied", "slip"
  • turbulence_wall_type can be "none", "low_reynolds_number", "wall_function", "running_average_wall_function"
  • coupling_type can be "structural", "line", "surface", "rigid_body"
  • coupling_direction can be "both", "to_external_code", "from_external_code"
  • FAN_COMPONENT
    def cmdSetFanComponent( name, clobber = True,
                  active = False,
                  type = 'axial',
                  center = ((0,0,0),),
                  direction = ((1,0,0),),
                  angular_speed = 1,
                  angular_speed_multiplier_function ='none',
                  tip_radius = 1,
                  thickness = 1,
                  fluid_density = 1,
                  inlet_area = 1,
                  tip_velocity = 1,
                  pressure_flowrate_curve_fit = ((0,0),(1,1),),
                  axial_coefficient_type = 'constant',
                  axial_coefficient = 1,
                  axial_curve_fit_values = ((0,0),(0,1),),
                  axial_curve_fit_row_variable = 'normalized_radius',
                  axial_curve_fit_column_variable = 'normalized_flow_rate',
                  axial_user_function = '',
                  axial_user_values = (),
                  axial_user_strings = (),
                  axial_multiplier_function = 'none',
                  radial_coefficient_type = 'constant',
                  radial_coefficient = 1,
                  radial_curve_fit_values = ((0,0),(0,1),),
                  radial_curve_fit_row_variable = 'normalized_radius',
                  radial_curve_fit_column_variable = 'normalized_flow_rate',
                  radial_user_function = '',
                  radial_user_values = (),
                  radial_user_strings = (),
                  radial_multiplier_function = '',
                  tangential_coefficient_type = 'constant',
                  tangential_coefficient = 1,
                  tangential_curve_fit_values = ((0,0),(0,1),),
                  tangential_curve_fit_row_variable = 'normalized_radius',
                  tangential_curve_fit_column_variable= 'normalized_flow_rate',
                  tangential_user_function = '',
                  tangential_user_values = (),
                  tangential_user_strings = (),
                  tangential_multiplier_function = 'none' ,
                  head = 'Model' ,
                  model = modelSrf ):
    • type can be "axial", "radial"
    • axial_coefficient_type can be "constant", "piecewise_bilinear", "p-q_curve_fit", "user_function"
    • axial_curve_fit_row_variable can be "normalized_radius"
    • axial_curve_fit_column_variable can be "normalized_flow_rate"
    • radial_coefficient_type can be "constant", "piecewise_bilinear", "user_function"
    • radial_curve_fit_row_variable can be "normalized_radius"
    • radial_curve_fit_column_variable can be "normalized_flow_rate"
    • tangential_coefficient_type can be "constant","piecewise_bilinear", "user_function"
    • tangential_curve_fit_row_variable can be "normalized_radius"
    • tangential_curve_fit_column_variable can be "normalized_flow_rate"
  • FLEXIBLE_BODY
    def cmdSetFlexibleBody( name, clobber = True,
                                      equation = 'mesh_displacement',
                                      num_modes = 1,
                                      type = 'trapezoidal',
                                      num_sub_steps = 1,
                                      mass = (),
                                      stiffness = (),
                                      damping = (),
                                      contact_constraints = (),
                                      external_force = (),
                                      external_force_multiplier_function = 'none',
                                      initial_displacement= (),
                                      initial_velocity = (),
                                      initial_force = (),
                                      internal_force_multiplier_function = 'none',
                                      user_function = '',
                                      user_values = (),
                                      user_strings = (),
                                      surface_outputs = (),
                                      evaluation = 'once_per_solution_update',
                                      filter = 'none',
                                      iir_input_coefficients = ((1),),
                                      iir_output_coefficients= (),
                                      datatree = True ):
    • equation can be "mesh_displacement", "velocity"
    • type can be "trapezoidal", "user_function"
    • evaluation can be "once_per_solution_update", "once_per_time_step"
    • filter can be "none", "iir"
  • FREE_SURFACE
    def cmdSetFreeSurface( name, clobber = True,
                                     active = False,
                                     surface_tension_model = 'none',
                                     contact_angle_model = 'none',
                                     head = 'Model' ,
                                     model = modelSrf ):
  • GLOBAL_MESH_ATTRIBUTES
    def cmdSetGlobalMeshAttributes( clobber = True,
                                    MeshSizeType = 'relative_value',
                                    AbsMeshSize = 1.0,  
                                    RelMeshSize = 0.1,
                                    AbsMeshSizeExp = "value=1.0",
                                    RelMeshSizeExp = "value=0.125",
                                    AbsAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1) ),
                                    RelAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1) ),
                                    AbsAnisoMeshSizeFactor  = 1.0,
                                    RelAnisoMeshSizeFactor  = 1.0,
                                    CurvatureRefinementFlag = True,
                                    CurvatureAngle = 25,
                                    CurvatureMeshSizeFactor = 0.5,
                                    MeshGrowthRate = 1.0,
                                    SweepAngle = 45):
    • MeshSizeType can be "absolute_value", "relative_value", "absolute_expression", "relative_expression", "absolute_aniso_value", "relative_aniso_value"
  • GUIDE_SURFACE
    def cmdSetGuideSurface( name, clobber = True,
                                      active = False,
                                      type = 'faceted',
                                      crease_angle = 90,
                                      mesh_motion = 'none'.
                                      head = 'Model',
                                      model = modelSrf):
    • type can be "faceted"
  • HEAT_EXCHANGER_COMPONENT
    def cmdSetHeatExchangerComponent( name, clobber = True,
                 active = False,
                 type ='constant_coolant_heat_reject',
                 coolant_heat_reject = 0,
                 coolant_heat_reject_multiplier_function = 'none',
                 coolant_flow_rate = 0,
                 coolant_flow_rate_multiplier_function = 'none',
                 direction = ((1,0,0),),
                 thickness = 1,
                 upstream_distance = 0,
                 friction_type = 'constant',
                 friction = 0,
                 inlet_min_area_ratio = 1,
                 outlet_min_area_ratio = 1,
                 wet_min_area_ratio = 1,
                 core_friction_constant = 1,
                 core_friction_exponent = -1,
                 inlet_loss_coefficients = ((0.4,0.0,-0.4),),
                 outlet_loss_coefficients = ((1,-2,1),),
                 friction_curve_fit_values = ((0,1),),
                 friction_curve_fit_variable = 'axial_velocity',
                 friction_user_function = '',
                 friction_user_values = (),
                 friction_user_strings = (),
                 friction_multiplier_function = 'none',
                 transverse_friction_factor = 10,
                 effectiveness_type = 'constant',
                 effectiveness = 1,
                 effectiveness_curve_fit_values = ((0,0),(0,1),),
                 effectiveness_curve_fit_row_variable = 'coolant_flow_rate',
                 effectiveness_curve_fit_column_variable = 'axial_velocity',
                 effectiveness_user_function = '',
                 effectiveness_user_values = (),
                 effectiveness_user_strings = (),
                 effectiveness_multiplier_function = 'none',
                 head = 'Model' ,
                 model = modelSrf ):
    • type can be "constant_coolant_heat_reject"
    • friction_type can be "constant", "kays_london piecewise_linear", "cubic_spline", "user_function"
    • friction_curve_fit_variable can be "axial_velocity"
    • effectiveness_type can be "constant","piecewise_bilinear", "user_function"
    • effectiveness_curve_fit_row_variable can be "coolant_flow_rate"
    • effectiveness_curve_fit_column_variable can be "axial_velocity"
  • SURFACE_INTEGRATED_CONDITION
    def cmdSetIntegratedBoundaryCondition( name,
                                                    clobber = True,
                                                    active = False,
                                                    variable = '',
                                                    type = 'constant',
                                                    constant_value = 0,
                                                    multiplier_function = 'none',
                                                    head = 'Model' ,
                                                    model = modelSrf ):
    • variable can be "mass_flux", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
    • type can be "constant"
  • INTERFACE_SURFACE
    def cmdSetInterfaceSurface( name, clobber = True,
                                         active = False,
                                         gap_factor = 1,
                                         gap = 0,
                                         crease_angle = 90 ,
                                         head = 'Model' ,
                                         model = modelSrf ):
  • LINEAR_SOLVER_PARAMETERS
    def cmdSetLinearSolverParameters( clobber = True,
                           tab = 'basic',
                           lhs_storage = 'sparse',
                           min_num_iteration_ratio = 0.5,
                           pressure_precedence_factor = 1.0,
                           num_pressure_projection_vectors = 10,
                           num_velocity_projection_vectors = 5,
                           num_flow_projection_vectors = 5,
                           num_viscoelastic_stress_projection_vectors = 5,
                           num_temperature_projection_vectors = 10,
                           num_radiation_projection_vectors = 10,
                           num_temperature_flow_projection_vectors = 4,
                           num_species_projection_vectors = 10,
                           num_turbulence_projection_vectors = 10,
                           num_mesh_displacement_projection_vectors= 10,
                           pressure_lhs_inverse_order = 5,
                           velocity_lhs_inverse_order = 5,
                           flow_lhs_inverse_order = 5,
                           temperature_lhs_inverse_order = 5,
                           pressure_regularization_factor = 1.0,
                           velocity_regularization_factor = 0.5,
                           flow_regularization_factor = 0,
                           viscoelastic_stress_regularization_factor= 0,
                           temperature_regularization_factor = 0,
                           temperature_flow_regularization_factor = 0,
                           species_regularization_factor = 0,
                           turbulence_regularization_factor = 0,
                           mesh_displacement_regularization_factor = 0,
                           pressure_update_factor = 1.0,
                           velocity_update_factor = 1.0,
                           temperature_update_factor = 1.0,
                           species_update_factor = 1.0,
                           turbulence_update_factor = 1.0,
                           mesh_displacement_update_factor = 1.0,
                           radiation_update_factor = 1.0,
                           max_pressure_update = 0.0,
                           max_velocity_update = 0.0,
                           max_viscoelastic_stress_update = 0.0,
                           max_temperature_update = 0.0,
                           max_species_update = 0.0,
                           max_turbulence_update = 0.0,
                           max_mesh_displacement_update = 0.0,
                           max_radiation_update = 0.0,
                           max_reverse_update_factor = 0.0,
                           pressure_update_filter = 'none',
                           velocity_update_filter = 'none',
                           viscoelastic_stress_update_filter = 'none',
                           temperature_update_filter = 'none',
                           species_update_filter = 'none',
                           turbulence_update_filter = 'none',
                           mesh_displacement_update_filter = 'none',
                           radiation_update_filter = 'none',
                           protect_parameters = False ):
    • lhs_storage can be "sparse", "reduced_memory_sparse"
    • pressure_update_filter can be "none", "mic"
    • velocity_update_filter can be "none", "mic"
    • viscoelastic_stress_update_filter can be "none", "mic"
    • radiation_update_filter can be "none", "mic"
    • temperature_update_filter can be "none", "mic"
    • species_update_filter can be "none", "mic"
    • turbulence_update_filter can be "none", "mic"
    • mesh_displacement_update_filter can be "none", "mic"
  • DENSITY_MODEL
    def cmdSetDensityModel( name, clobber = True,
                                      type = 'constant',
                                      density = 1,
                                      expansivity_type = 'constant',
                                      expansivity = 1,
                                      reference_temperature = 273.14,
                                      reference_pressure = 0,
                                      specific_heat_ratio = 1.4,
                                      gas_constant = 286.6,
                                      isothermal_compressibility = 0,
                                      curve_fit_values = ((0,0),),
                                      curve_fit_variable = 'temperature',
                                      user_function = '',
                                      user_values = (),
                                      user_strings = () ):
    • type can be "constant", "boussinesq", "isentropic", "ideal_gas", "piecewise_linear", "cubic_spline", "user_function"
    • expansivity_type can be "constant"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate","pressure", "temperature", "species_1", "species_2", "species_3", "species_4', "species_5", "species_6", "species_7", "species_8", "species_9"
  • SPECIFIC_HEAT_MODEL
    def cmdSetSpecificHeatModel( name, clobber = True,
                                           type = 'constant',
                                           specific_heat = 1,
                                           curve_fit_values = ((0,1),),
                                           curve_fit_variable = 'temperature',
                                           user_function = '',
                                           user_values = (),
                                           user_strings = (),
                                           latent_heat_type = 'none',
                                           latent_heat = 0,
                                           latent_heat_temperature = 0,
                                           latent_heat_temperature_interval = 0 ):
    • type can be "constant", "piecewise_linear_enthalpy", "cubic_spline_enthalpy", "user_function_enthalpy"
    • curve_fit_variable can be "temperature"
    • latent_heat_type can be "none","constant"
  • VISCOSITY_MODEL
    def cmdSetViscosityModel( name,
                               nodePath = None,
                               clobber = True,
                               type = 'constant',
                               viscosity = 0,
                               power_law_viscosity = 0,
                               power_law_time_constant = 0,
                               power_law_index = 1,
                               power_law_lower_strain_rate = 0,
                               bingham_viscosity = 1,
                               bingham_yield_stress = 0,
                               bingham_stress_growth_exponent = 500,
                               bingham_time_constant = 1,
                               bingham_index = 1,
                               bingham_infinite_shear_viscosity= 0,
                               carreau_zero_shear_viscosity = 0,
                               carreau_infinite_shear_viscosity= 0,
                               carreau_time_constant = 0,
                               carreau_index = 1,
                               carreau_transition_index = 2,
                               curve_fit_values = ((0,0),),
                               curve_fit_variable = 'temperature',
                               user_function = '',
                               user_values = (),
                               user_strings = (),
                               multiplier_function = 'none' ):
    • type can be "constant", "ramped", "power_law", "bingham", "carreau", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
  • VISCOELASTIC_MODEL
    def cmdSetViscoelasticModel(   name,
                                   clobber = True,
                                   type = 'none',
                                   time_constant = 0.0,
                                   giesekus_mobility_factor = 0.0,
                                   phan_thien_tanner_extensibility_factor = 0.0,
                                   phan_thien_tanner_differential_ratio  = 0.0,
                                   curve_fit_values = ((0,0),),
                                   curve_fit_variable = 'temperature',
                                   user_function = '',
                                   user_values = (),
                                   user_strings = (),
                                   multiplier_function = 'none',
                                   viscosity_type = 'constant',
                                   viscosity = 0,
                                   power_law_viscosity = 0,
                                   power_law_time_constant = 0,
                                   power_law_index = 1,
                                   power_law_lower_strain_rate = 0,
                                   bingham_viscosity = 1,
                                   bingham_yield_stress = 0,
                                   bingham_stress_growth_exponent = 500,
                                   bingham_time_constant = 1,
                                   bingham_index = 1,
                                   bingham_infinite_shear_viscosity = 0,
                                   carreau_zero_shear_viscosity = 0,
                                   carreau_infinite_shear_viscosity = 0,
                                   carreau_time_constant = 0,
                                   carreau_index = 1,
                                   carreau_transition_index = 2,
                                   viscosity_curve_fit_values = ((0,0),),
                                   viscosity_curve_fit_variable = 'temperature',
                                   viscosity_user_function = '',
                                   viscosity_user_values = (),
                                   viscosity_user_strings = (),
                                   viscosity_multiplier_function = 'none'
                                   ):
    • type can be "none", "oldroyd_b", "giesekus", "phan_thien_tanner", "bingham", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
  • CONDUCTIVITY_MODEL
    def cmdSetConductivityModel( name, clobber = True,
                                            type = 'constant',
                                            conductivity = 0,
                                            prandtl_number = 0.71,
                                            curve_fit_values = ((0,0),),
                                            curve_fit_variable = 'temperature',
                                            user_function = '',
                                            user_values = (),
                                            user_strings = (),
                                            multiplier_function = 'none',
                                            turbulent_prandtl_number = 0.91,
                                            anisotropic_conductivity= ((0,0,0,0,0,0),),
                                            anisotropic_curve_fit_values  = ((0,0,0,0,0,0,0),),
                                            anisotropic_curve_fit_variable= 'temperature',
                                            anisotropic_user_function = '',
                                            anisotropic_user_values  = (),
                                            anisotropic_user_strings = () ):
    • type can be "constant", "constant_prandtl_number", "ramped", "piecewise_linear", "cubic_spline", "user_function", "constant_anisotropic", "piecewise_linear_anisotropic", "cubic_spline_anisotropic", "user_function_anisotropic"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
    • anisotropic_curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
  • DIFFUSIVITY_MODEL
    def cmdSetDiffusivityModel( name, species,
                                          clobber = True,
                                          type = 'constant',
                                          diffusivity = 0,
                                          curve_fit_values = ((0,0),),
                                          curve_fit_variable = 'temperature',
                                          user_function = '',
                                          user_values = (),
                                          user_strings = (),
                                          multiplier_function = 'none',
                                          turbulent_schmidt_number= 0.91 ):
    • type can be "constant", "ramped", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
  • POROSITY_MODEL
    def cmdSetPorosityModel( name, clobber = True,
                             type = 'none',
                             porosity = 1,
                             permeability_type = 'cartesian',
                             direction_1_permeability = 1,
                             direction_1_permeability_multiplier_function = 'none',
                             direction_2_permeability = 1,
                             direction_2_permeability_multiplier_function = 'none',
                             direction_3_permeability = 1,
                             direction_3_permeability_multiplier_function = 'none',
                             cylindrical_permeability_axis = ( (0,0,0),(1,0,0) ),
                             spherical_permeability_center = ( 0,0,0 ),
                             radial_permeability = 1,
                             radial_permeability_multiplier_function = 'none',
                             axial_permeability = 1,
                             axial_permeability_multiplier_function = 'none',
                             tangential_permeability = 1,
                             tangential_permeability_multiplier_function = 'none',
                             permeability_flow_direction = 'x',
                             permeability_flow_direction_vector = (1,0,0),
                             permeability_direction = ((1,0,0), (0,1,0), (0,0,1)),
                             data_type = 'direct',
                             velocity_pressure_drop_fit = ((0.0,0.0),(1.0,1.0)),
                             porous_thickness = 0.1,
                             darcy_coefficient = 0,
                             forchheimer_coefficient = 0,
                             darcy_multiplier_function = 'none',
                             forchheimer_multiplier_function = 'none' ):
    
    • type can be "none", "constant"
    • data_type can be "value", "pv_curve"
  • MATERIAL_MODEL
    def cmdSetMaterialModel( name,
                                       clobber = True,
                                       medium = 'fluid',
                                       datatree = True ,
                                       species = 1,
                                       sp_cut_off = 0.5,
                                       material_1 = '',
                                       material_2 = '',
                                       surface_tension = '' ):
  • MESH_EXTRUSION
def cmdSetMeshExtrusionItems( name,
                                 clobber = True,
                                 active = True,
                                 GeomType = 'surface',
                                 side1 = 'Side1',
                                 side2 = 'Side2',
                                 ExtrusionType = 'Number of layers', 
                                 NumberOfLayers = 1,
                                 HeightOfLayers = [ "1", "mm" ],
                                 ExtrusionOptions  = 'Mixed elements' ):
  • ExtrusionType can be "Number of layers", "Layer height"
  • GeomType can be "surface", "edge"
  • ExtrusionOptions can be "Mixed elements", "All tets", "Extruded surface", "All tris"
  • MESH_MOTION
    def cmdSetMeshMotion( name, clobber = True,
                          type = 'none',
                          translation_velocity = ((0,0,0),),
                          translation_variable = 'time',
                          translation_variable_multiplier_function = 'none',
                          rotation_center = ((0,0,0),),
                          angular_velocity = ((0,0,0),),
                          rotation_variable = 'time',
                          rotation_variable_multiplier_function = 'none',
                          curve_fit_values = ((0,0,0,0,1,0,0),),
                          curve_fit_variable = 'time',
                          curve_fit_variable_multiplier_function = 'none',
                          user_function = '',
                          user_values = (),
                          user_strings = (),
                          rigid_body_x_displacement = 'active',
                          rigid_body_y_displacement = 'active',
                          rigid_body_z_displacement = 'active',
                          rigid_body_x_rotation = 'active',
                          rigid_body_y_rotation = 'active',
                          rigid_body_z_rotation = 'active',
                          rigid_body_center = ((0,0,0),),
                          rigid_body_direction = ((1,0,0), (0,1,0), (0,0,1),),
                          rigid_body_mass = 1,
                          rigid_body_dyadic = ((1,1,1,0,0,0),),
                          rigid_body_stiffness = ((0,0,0,0,0,0),),
                          rigid_body_damping = ((0,0,0,0,0,0),),
                          rigid_body_rotational_stiffness = ((0,0,0,0,0,0),),
                          rigid_body_rotational_damping = ((0,0,0,0,0,0),),
                          rigid_body_external_force = ((0,0,0),),
                          rigid_body_external_force_multiplier_function = 'none',
                          rigid_body_external_moment = ((0,0,0),),
                          rigid_body_external_moment_multiplier_function = 'none',
                          rigid_body_initial_displacement = ((0,0,0),),
                          rigid_body_initial_velocity = ((0,0,0),),
                          rigid_body_initial_rotation = ((0,0,0),),
                          rigid_body_initial_angular_velocity = ((0,0,0),),
                          rigid_body_initial_force = ((0,0,0),),
                          rigid_body_internal_force_multiplier_function = 'none',
                          rigid_body_initial_moment = ((0,0,0),),
                          rigid_body_internal_moment_multiplier_function= 'none',
                          rigid_body_filter = 'none',
                          rigid_body_iir_input_coefficients = ((1),),
                          rigid_body_iir_output_coefficients = (),
                          rigid_body_surface_outputs = (),
                          interpolated_motion_surfaces = (),
                          datatree = True ):
  • type can be "none", "zero", "translation", "rotation", "piecewise_linear", "cubic_spline", "user_function", "rigid_body_dynamic"
  • translation_variable can be "time", "multiplier_function"
  • rotation_variable can be "time", "multiplier_function"
  • curve_fit_variable can be "time", "multiplier_function"
  • rigid_body_x_displacement can be "active", "zero"
  • rigid_body_y_displacement can be "active", "zero"
  • rigid_body_z_displacement can be "active", "zero"
  • rigid_body_x_rotation can be "active", "zero"
  • rigid_body_y_rotation can be "active", "zero"
  • rigid_body_z_rotation can be "active", "zero"
  • rigid_body_filter can be "none", "iir"
  • MESH_PROCESS_ATTRIBUTES
    def cmdSetMeshProcessAttributes( clobber = True,
                                     ScaleFactor = (( 1.0,1.0,1.0),),
                                     BoundaryLayerMinAspectRatioFlag = False,
                                     BoundaryLayerMinAspectRatio = 0.9,
                                     BoundaryLayerExposedRatioFlag = False,
                                     BoundaryLayerExposedRatio = 0.2,
                                     BoundaryLayerConformityAngle = 150.0,
                                     BoundaryLayer2DMinAspectRatioFlag = False,
                                     BoundaryLayer2DMinAspectRatio = 0.9,
                                     EdgeBlendSmoothFlag = False,
                                     EdgeBlendCutOffType = "RELATIVE_VALUE",
                                     EdgeBlendCutOffTarget = "First Layer",
                                     EdgeBlendCutOffValue = 0.01,
                                     EdgeBlendConstrainLayer = 0,
                                     EdgeBlendRelHeightSmoothDist= 3.0,
                                     EdgeBlendSweepAngle = 45,
                                     ReducedMeshFlag = True,
                                     EnsureInteriorVertices = "ENSURE_NONE",
                                     ShrinkMixedFlag = False,
                                     MeshType = "ACUMESH_VOL_MESH",
                                     VolOptOptimMeshFlag = True,
                                     VolOptSmoothMeshFlag = True,
                                     VolOptSmoothMeshLevel = 1,
                                     VolOptModifySurfFlag = False,
                                     VolOptStructMeshFlag = False,
                                     VolOptUnstructMeshFlag = False,
                                     VolOptEnforceMeshFlag = False,
                                     SrfOptSnapOnMatchFlag = True,
                                     SrfOptSmoothMeshFlag = True,
                                     SrfOptSmoothMeshLevel = 3,
                                     SrfOptFixIntFlag = True,
                                     SrfOptFixIntLevel = "1",
                                     SrfOptContOnErrorFlag = False,
                                     SrfOptProximitySizeLevel = 0,
                                     SrfOptFaceRotAngLim = 15,
                                     SrfMeshImproveFlag = False,
                                     SrfImpOptimFlag = True,
                                     SrfImpGradeMeshFlag = False,
                                     SrfImpGradeRate = 2.0/3,
                                     SrfImpFixIntFlag = False,
                                     SrfImpFixIntLevel = "1",
                                     SrfImpMinRefinementFlag = False,
                                     SrfImpRefType = 'ABSOLUTE_VALUE',
                                     SrfImpRefAbsSize = 0.1,
                                     SrfImpRefRelSize = 0.1,
                                     SrfImpShapeMetricType = 'MAX_ANGLE',
                                     SrfImpShapeMetricValue = 0.5,
                                     VolMeshImproveFlag = False,
                                     VolImpOptimFlag = True,
                                     VolImpGradeMeshFlag = False,
                                     VolImpGradeRate = 2.0/3,
                                     VolImpMinRefinementFlag = False,
                                     VolImpRefType = 'ABSOLUTE_VALUE',
                                     VolImpRefAbsSize = 0.1,
                                     VolImpRefRelSize = 0.1,
                                     VolImpModSrfMeshFlag = False,
                                     VolImpShapeMetricType = 'MAX_ANGLE',
                                     VolImpShapeMetricValue = 0.5,
                                     MaximumVertices = 0,
                                     MaximumEdges = 0,
                                     MaximumFaces = 0,
                                     MaximumRegions = 0,
                                     SmallFeatureMeshingFlag = False,
                                     SmallFeatureMeshingType = 'RELATIVE_TOLERANCE',
                                     SmallFeatureMeshingTolerance = 0.0125):
  • MULTIPLIER_FUNCTION
    def cmdSetMultiplierFunction( name, clobber = True,
                                           type = 'constant',
                                           constant_value = 1,
                                           sine_coefficients = (1,0,0),
                                           curve_fit_values = ((0,1),),
                                           curve_fit_variable = 'time',
                                           curve_fit_variable_multiplier_function = 'none',
                                           curve_fit_variable_user_global_data = 'none',
                                           curve_fit_variable_cyclic_period    = 1,
                                           user_function = '',
                                           user_values = (),
                                           user_strings = (),
                                           user_history_variables = (),
                                           user_global_data = '',
                                           evaluation = 'once_per_time_step',
                                           filter = 'none',
                                           iir_input_coefficients = ((1),),
                                           iir_output_coefficients = (),
                                           filter_relaxation_factor = 0.5,
                                           dependencies = (),
                                           datatree = True ):
    • type can be "constant", "sine_series", "piecewise_linear", "cubic_spline", "piecewise_log_linear", "user_function", "user_global_data", "modifiable"
    • curve_fit_variable can be "time", "cyclic_time", "time_step", "time_increment", "multiplier_function", "user_global_data"
    • evaluation can be "once_per_time_step", "once_per_solution_update"
    • filter can be "none", "relaxation", 'iir', ''mic"
  • NODAL_BOUNDARY_CONDITION
    def cmdSetNodalBoundaryCondition( name,
                      model,
                      clobber = True,
                      active = False,
                      variable = '',
                      panel_type = None,
                      panel_dir = None,
                      precedence = 1,
                      type = 'zero',
                      nodes = (),
                      constant_value = 0,
                      nodal_values = (),
                      user_nodal_values = (),
                      curve_fit_values = ((0,0),),
                      curve_fit_variable = 'x_coordinate',
                      user_function = '',
                      user_values = (),
                      user_strings = (),
                      scattered_data = (),
                      scattered_data_origin = ((0,0,0),),
                      scattered_data_axes = ((1,0,0), (0,1,0), (0,0,1)),
                      external_file = '',
                      external_file_nodal_offset = (),
                      external_file_evaluation = 'once_per_time_step',
                      auxiliary_nodes = (),
                      reference_frame = 'none',
                      multiplier_function = 'none',
                      mesh_motion = 'none',
                      flexible_body = '',
                      guide_surface = '',
                      nodal_modes = (),
                      time_series = ((0),),
                      time_series_variable = 'time',
                      time_series_cyclic_period = 1,
                      time_series_variable_multiplier_function= 'none',
                      direction_type = 'constant',
                      constant_direction = ((1,0,0),),
                      nodal_directions = (),
                      active_type = 'all',
                      active_user_function = '',
                      active_user_values = (),
                      active_user_strings = (),
                      external_code_tags = () ):
    • variable can be "x_velocity", "y_velocity", "z_velocity", "direction_velocity", "pressure", "viscoelastic_xx_stress", "viscoelastic_yy_stress", "viscoelastic_zz_stress", "viscoelastic_xy_stress", "viscoelastic_yz_stress", "viscoelastic_zx_stress", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "eddy_viscosity", "kinetic_energy", "eddy_frequency", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_direction_displacement", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_direction_velocity"
    • type can be "zero", "constant", "nodal", "nodal_time_series", "piecewise_linear", "cubic_spline", "user_function", "scattered_data", "scattered_data_time_series", "external_file", "match_mesh_velocity", "mesh_motion", "flexible_body", "external_code", "guide_surface"
    • curve_fit_variable can be "x_coordinate", "y_coordinate", "z_coordinate", "x_reference_coordinate", "y_reference_coordinate", "z_reference_coordinate", "x_velocity", "y_velocity", "z_velocity", "velocity_magnitude", "pressure", "temperature", "eddy_viscosity", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "mesh_x_displacement", "mesh_y_displacement", "mesh_z_displacement", "mesh_displacement_magnitude", "mesh_x_velocity", "mesh_y_velocity", "mesh_z_velocity", "mesh_velocity_magnitude"
    • external_file_evaluation can be "once_per_time_step"
    • time_series_variable can be "time", "cyclic_time", "multiplier_function"
    • direction_type can be "constant", "nodal", "normal"
    • active_type can be "none", "all", "inflow", "far_field", "user_function", "no_interface"
  • NODAL_INITIAL_CONDITION-Velocity
    def cmdSetVelocityNodalInitialCondition(
                                             clobber = True, 
                                              x_velocity = 0.0,
                                              y_velocity = 0.0, 
                                              z_velocity = 0.0,
                                              initType = "constant",
                                              nodal_values = (),
                                              satisfy_boundary_condition = False ):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-Pressure
    def cmdSetPressureNodalInitialCondition(
                                            clobber = True,
                                            pressure = 0.0,
                                            initType = "constant",
                                            nodal_values = (),
                                            satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-EddyViscosity
def cmdSetEddyViscosityNodalInitialCondition(
                                            clobber = True,
                                            eddy_viscosity = 0.0,
                                            initType = "constant",
                                            nodal_values = (),
                                            satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-EddyFrequency
def cmdSetEddyFrequencyNodalInitialCondition(
                                         clobber = True,
                                         eddy_frequency = 0.0,
                                         initType = "constant",
                                         nodal_values = (),
                                         satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-KineticEnergy
def cmdSetKineticEnergyNodalInitialCondition(
                                            clobber = True,
                                            kinetic_energy = 0.0,
                                            initType = "constant",
                                            nodal_values = (),
                                            satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-Temperature
def cmdSetTemperatureNodalInitialCondition(
                                         clobber = True,
                                         temperature = 0.0,
                                         initType = "constant",
                                         nodal_values = (),
                                         satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-ViscoelasticStress
def cmdSetViscoelasticStressNodalInitialCondition(
                                          clobber = True,
                                          viscoelastic_xx_stress  = 0.0,
                                          viscoelastic_yy_stress  = 0.0,
                                          viscoelastic_zz_stress  = 0.0,
                                          viscoelastic_xy_stress  = 0.0,
                                          viscoelastic_yz_stress  = 0.0,
                                          viscoelastic_zx_stress  = 0.0,
                                          initType = "constant",
                                          nodal_values = (),
                                          satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-Species
def cmdSetSpeciesNodalInitialCondition(
                                          clobber = True,
                                          species_1 = 0.0,
                                          species_2 = 0.0,
                                          species_3 = 0.0,
                                          species_4 = 0.0,
                                          species_5 = 0.0,
                                          species_6 = 0.0,
                                          species_7 = 0.0,
                                          species_8 = 0.0,
                                          species_9 = 0.0,
                                          initType  = "constant",
                                          nodal_values = (),
                                          satisfy_boundary_condition = False):
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION-MeshDisplacement
def cmdSetMeshDisplacementNodalInitialCondition(
                                                     clobber = True,
                                                     x_mesh_displacement = 0.0,
                                                     y_mesh_displacement = 0.0,
                                                     z_mesh_displacement = 0.0,
                                                     initType = "constant",
                                                     nodal_values = (),
                                                     satisfy_boundary_condition = False ): 
  • initType can be "constant", "nodal_values"
  • NODAL_INITIAL_CONDITION
    def cmdSetNodalInitialCondition( clobber = True,
                                     pressure = 0.0,
                                     x_velocity = 0.0,
                                     y_velocity = 0.0,
                                     z_velocity = 0.0,
                                     viscoelastic_xx_stress  = 0.0,
                                     viscoelastic_yy_stress  = 0.0,
                                     viscoelastic_zz_stress  = 0.0,
                                     viscoelastic_xy_stress  = 0.0,
                                     viscoelastic_yz_stress  = 0.0,
                                     viscoelastic_zx_stress  = 0.0,
                                     temperature = 0.0,
                                     species_1 = 0.0,
                                     species_2 = 0.0,
                                     species_3 = 0.0,
                                     species_4 = 0.0,
                                     species_5 = 0.0,
                                     species_6 = 0.0,
                                     species_7 = 0.0,
                                     species_8 = 0.0,
                                     species_9 = 0.0,
                                     eddy_viscosity = 0.0,
                                     kinetic_energy = 0.0,
                                     eddy_frequency = 0.0,
                                     x_mesh_displacement = 0.0,
                                     y_mesh_displacement = 0.0,
                                     z_mesh_displacement = 0.0,
                                     show_all = False,
                                     initType = "constant"
                                     nodal_values = (),
                                     satisfy_boundary_condition = False):
    • initType can be "constant", "nodal_values"
  • NODAL_OUTPUT
    def cmdSetNodalOutput( clobber = True,
                                     output_frequency = 1000,
                                     output_time_interval = 0,
                                     output_initial_condition= False,
                                     continuous_output = False,
                                     num_saved_states = 0 ):
  • DERIVED_QUANTITY_OUTPUT
    def cmdSetDerivedQuantityOutput( clobber = True,
                                               output_frequency = 0,
                                               output_time_interval = 0,
                                               num_saved_states = 0 ): 
  • RUNNING_AVERAGE_OUTPUT
    def cmdSetRunningAverageOutput( clobber = True,
                                              output_frequency = 1000,
                                              output_time_interval = 0,
                                              num_saved_states = 0 ):
  • TIME_AVERAGE_OUTPUT
    def cmdSetTimeAverageOutput( clobber = True,
                                            order = 2,
                                            output_frequency = 0,
                                            output_time_interval = 0,
                                            reset_frequency = 0,
                                            num_saved_states = 0 ):
  • ERROR_ESTIMATOR_OUTPUT
    def cmdSetErrorEstimatorOutput( clobber = True,
                                             type = "pde_residual",
                                             output_frequency = 0,
                                             output_time_interval = 0,
                                             num_saved_states = 0,
                                             time_average_output_frequency=0,
                                             time_average_output_time_interval=0,
                                             num_time_average_saved_states=0,
                                             time_average_reset_frequency= 0 ):
  • RESTART_OUTPUT
    def cmdSetRestartOutput( clobber = True,
                                      output_frequency = 1000,
                                      output_time_interval = 0,
                                      num_saved_states = 0 ):
  • NODAL_RESIDUAL_OUTPUT
    def cmdSetNodalResidualOutput( clobber = True,
                                            output_frequency = 0,
                                            output_time_interval = 0,
                                            num_saved_states = 0 ):
  • TIME_HISTORY_OUTPUT
    def cmdSetTimeHistoryOutput( name,
                                          clobber = True,
                                          type = 'nodal',
                                          nodes = ((1,),),
                                          coordinates = ((1,1,1,1),),
                                          display_points = False,
                                          output_frequency = 1,
                                          output_time_interval = 0,
                                          datatree = True ):
    • type can be "nodal", "coordinates"
  • EXTERNAL_OUTPUT
    def cmdSetExternalOutput(    name,
                                          clobber = True, 
                                          type = 'socket',
                                          launch = False,
                                          launch_command = '', 
                                          socket_host = '',
                                          socket_port = 20000,
                                          user_function = '',
                                          user_values = (),
                                          user_strings = (),
                                          output_frequency = 1,
                                          output_time_interval =0,
                                          datatree = True ):
  • type can be "socket","user"
  • PARTICLE_SURFACE
    def cmdSetParticleSurface( name, clobber = True,
                                        active = False,
                                        type = 'wall' ,
                                        head = 'Model',
                                        model = modelSrf ):
    • type can be "wall", "inflow", "outflow"
  • PERIODIC_BOUNDARY_CONDITION
def cmdSetPeriodicBoundaryCondition( name,
                                    clobber = True,
                                    active = False,
                                    panel_type = None,
                                    panel_ref = None,
                                    variable = '',
                                    type = 'periodic',
                                    precedence = 1,
                                    rotation_axis = ((0,0,0,),(0,0,1)),
                                    constant_value = 0,
                                    constant_values = ((0,0,0),),
                                    user_function = '',
                                    user_values = (),
                                    user_strings = (),
                                    multiplier_function = 'none',
                                    active_type = 'all',
                                    active_user_function = '',
                                    active_user_values = (),
                                    active_user_strings = (),
                                    nodal_pair_values = () )
  • variable can be "all", "pressure", "velocity", "viscoelastic_xx_stress", "viscoelastic_yy_stress", "viscoelastic_zz_stress", "viscoelastic_xy_stress", "viscoelastic_yz_stress", "viscoelastic_zx_stress", "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "eddy_viscosity", "kinetic_energy", "eddy_frequency", "mesh_displacement"
  • type can be 'periodic', 'axisymmetric', 'two_reference_frames', 'constant_offset', 'nodal_pair_offset', 'user_function_offset', 'constant_coefficients', 'nodal_pair_coefficients', 'user_function_coefficients', 'single_unknown_offset', ' single_unknown_ratio' active_type can be "none", "all", "user_function
  • ANALYSIS & EQUATION
    def cmdSetProblemDescription( clobber = True,
                                            title = 'AcuSolve Problem',
                                            sub_title = 'AcuSolve Problem',
                                            type = 'steady',
                                            flow = 'navier_stokes',
                                            viscoelastic = 'none',
                                            absolute_pressure_offset = 0,
                                            temperature = 'none',
                                            absolute_temperature_offset = 0,
                                            radiation = 'none',
                                            species_transport= 'none',
                                            num_species = 1,
                                            turbulence = 'none',
                                            mesh = 'eulerian',
                                            external_code = False,
                                            running_average = False,
                                            running_average_steps = 100 ):
    • type can be "steady", "transient"
    • flow can be "navier_stokes", "stokes"
    • viscoelastic can be "none", "upper_convected_maxwell, "upper_convected_maxwell_log_model"
    • temperature can be "none", "advective_diffusive"
    • radiation can be "none", "enclosure"
    • species_transport can be "none", "advective_diffusive"
    • turbulence can be "none", "spalart_allmaras", "detached_eddy_simulation", "dynamic_model", "large_eddy_simulation", "spalart_allmaras_detached_eddy_simulation", "shear_stress_transport_detached_eddy_simulation", "shear_stress_transport", "k_omega"
    • mesh can be "eulerian", "specified", "arbitrary_lagrangian_eulerian"
  • AUTO_SOLUTION_STRATEGY
    def cmdSetPtAutoSolutionStrategy(   clobber = True,
                                                 max_time  = 0,
                                                 max_segments = 10000 ):
  • FLOW_FIELD
    def cmdSetFlowField(    clobber = True,
                                     flow_field_type = 'steady',
                                     from_run = 0,
                                     from_directory = 'ACUSIM.DIR',
                                     from_problem = dbName,
                                     from_time_step = 0,
                                     time_step_type = 'all',
                                     cyclic_time_step_type = 'range',
                                     time_step_series = (),
                                     first_cyclic_time_step = 0,
                                     last_cyclic_time_step = 0,
                                     cyclic_end_time_steps = 'include_first',
                                     mesh_motion = True,
                                     pseudodynamic_mesh_update = 'max_angle',
                                     pseudodynamic_max_angle = 10,
                                     pseudodynamic_time_increment = 1,
                                     extended_flow_variables = (),
                                     coupling_socket_port = 20000):
  • flow_field_type can be "steady", "transient", "pseudotransient", "cyclic", "one_way_coupling", "two_way_coupling"
  • time_step_type can be "all", "time_step_series"
  • can be "max_angle", "time_increment"
  • TRACE_OUTPUT
    def cmdSetTraceOutput(  clobber = True,
                                      active = False,
                                      output_frequency  = 1,
                                      output_time_interval = 0,
                                      format = 'bin_rec',
                                      particle_seed = True,
                                      particle_coordinates = True,
                                      particle_time = True,
                                      particle_stretch = True,
                                      particle_stretch_magnitude = True,
                                      particle_log_stretch_magnitude  = True,
                                      particle_stretch_rate_magnitude = True,
                                      particle_velocity = True,
                                      particle_velocity_magnitude = True,
                                      particle_turbulence_random_seed = True,
                                      particle_element_id = True,
                                      particle_element_set_id = True,
                                      particle_marker = True, 
                                      particle_user_equations = True,
                                      flow_velocity = False,
                                      flow_velocity_magnitude = False,
                                      flow_pressure = False,
                                      flow_temperature = False,
                                      flow_species = False,
                                      flow_eddy_viscosity = False,
                                      flow_strain_rate_magnitude = False,
                                      flow_grad_velocity = False,
                                      flow_grad_pressure = False,
                                      flow_grad_temperature = False,
                                      flow_grad_species = False, 
                                      flow_grad_eddy_viscosity = False ):
  • format can be "bin_rec", "ascii", "binary"
  • TIME_CUT_OUTPUT
    def cmdSetTimeCutOutput(clobber = True,
                                    active = False,
                                    time_cut_type = 'none',
                                    time_cuts = (),
                                    time_cut_start_time = 0,
                                    time_cut_stop_time = 0,
                                    time_cut_interval = 0,
                                    format = 'bin_rec',
                                    particle_seed = True,
                                    particle_coordinates = True,
                                    particle_time  = True,
                                    particle_stretch  = True,
                                    particle_stretch_magnitude = True,
                                    particle_log_stretch_magnitude = True,
                                    particle_stretch_rate_magnitude = True,
                                    particle_velocity = True,
                                    particle_velocity_magnitude = True,
                                    particle_turbulence_random_seed = True,
                                    particle_element_id = True,
                                    particle_element_set_id = True,
                                    particle_marker = True,
                                    particle_user_equations = True,
                                    flow_velocity = False,
                                    flow_velocity_magnitude = False,
                                    flow_pressure = False,
                                    flow_temperature = False,
                                    flow_species = False,
                                    flow_eddy_viscosity = False,
                                    flow_strain_rate_magnitude = False,
                                    flow_grad_velocity = False,
                                    flow_grad_pressure = False,
                                    flow_grad_temperature = False,
                                    flow_grad_species = False,
                                    flow_grad_eddy_viscosity = False ):
    • time_cut_type can be "none", "time_series", "time_interval"
    • format can be "bin_rec", "ascii", "binary"
  • POINCARE_OUTPUT
    def cmdSetPoincareOutput(   clobber = True,
                                active  = False,
                                poincare_sections = (),
                                format = 'bin_rec',
                                particle_seed = True,
                                particle_coordinates = True,
                                particle_time = True,
                                particle_stretch = True,
                                particle_stretch_magnitude = True,
                                particle_log_stretch_magnitude  = True,
                                particle_stretch_rate_magnitude = True,
                                particle_velocity = True,
                                particle_velocity_magnitude = True,
                                particle_turbulence_random_seed = True,
                                particle_element_id = True,
                                particle_element_set_id = True,
                                particle_marker = True,
                                particle_user_equations = True,
                                flow_velocity = False,
                                flow_velocity_magnitude = False,
                                flow_pressure = False,
                                flow_temperature = False,
                                flow_species = False,
                                flow_eddy_viscosity = False,
                                flow_strain_rate_magnitude = False,
                                flow_grad_velocity = False,
                                flow_grad_pressure = False,
                                flow_grad_temperature = False,
                                flow_grad_species = False,
                                flow_grad_eddy_viscosity = False ):
    • format can be "bin_rec", "ascii", "binary"
  • PARTICLE_SEED_BASIC
def cmdSetParticleSeedBasic( name,
                                clobber = True,
                                marker = 0,
                                coordinates_type = 'per_seed',
                                seed_coordinates = ((1,0,0,0)),
                                particle_surface = 'none',
                                particle_surface_offset = 0,
                                element_set = 'none',
                                region_bounding_box = ((0,0,0),(1,1,1)),
                                number_of_seeds = 1,
                                density_type = 'constant',
                                constant_density = 1,
                                density_random_bounds = (0,1),
                                seed_densities = (1,),
                                radius_type = 'constant',
                                constant_radius = 1,
                                radius_random_bounds = (1,1),
                                seed_radii = (1,),
                                velocity_type = 'constant',
                                particle_velocity_multipler = 1.0,
                                constant_velocity = (0,0,0),
                                velocity_random_bounds = ((0,1),(0,1),(0,1)),
                                seed_velocities = ((0,0,0),),
                                time_type = 'zero',
                                seed_time = 0,
                                seed_times = (0,),
                                emission_time_type = 'time_series',
                                emission_times = (0,),
                                emission_start_time = 0,
                                emission_stop_time = 0,
                                emission_time_interval = 0,
                                stretch_type = 'constant',
                                constant_stretch = ( 1, 0, 0 ),
                                seed_stretch = ((1,0,0),),
                                random_stretch_length   = 1,
                                component_type = 'none',
                                constant_components = (0,),
                                seed_components = (0,),
                                component_random_bounds = (),
                                turbulence_random_seed_type = 'constant',
                                constant_turbulence_random_seed = 1,
                                turbulence_random_seeds = (1,) ):
  • coordinates_type can be "per_seed", "surface_random", "surface_uniform", "surface_flux_weighted", "volume_random", "volume_uniform", "region_random", "region_uniform"
  • time_type can be "zero", "constant", "per_seed", "emission_times"
  • stretch_type can be "constant", "random", "per_seed"
  • PARTICLE_SEED_USER
    def cmdSetParticleSeedUser(  name,
                                          clobber = True,
                                          type = 'constant',
                                          constant_values = (0,),
                                          seed_values = (0,),
                                          random_bounds = (),
                                          particle_seed = None,
                                          user_equation = None ):
    • type can be "constant", "random", "per_seed"
  • PARTICLE_SEED
    def cmdSetParticleSeed(  name,
                                      clobber = True,
                                      datatree = True ):
  • EQUATION
    def cmdSetPtProblemDescription( clobber = True,
                                              particle = 'massless',
                                              stretch = 'none',
                                              user_equations = () ):
    • particle can be "massless", "finite_mass"
    • stretch can be "none", "standard"
  • STAGGER
    def cmdSetPtStagger(    name,
                                     clobber = True, 
                                     equation = 'none', 
                                     min_stagger_iterations = 1,
                                     max_stagger_iterations = 10,
                                     convergence_tolerance = 1.e-6,
                                     lhs_update_frequency = 1,
                                     nonlinear = True,
                                     user_equation = 'none',
                                     datatree = True,
                                     staggers = () ):
  • equation can be "none", "particle", "stretch", "user_equation"
  • TIME_SEQUENCE
    def cmdSetPtTimeSequence(   clobber = True,
                                         max_time = 0,
                                         max_segments = 10000,
                                         min_stagger_iterations = 1,
                                         max_stagger_iterations = 1,
                                         lhs_update_initial_times = 1,
                                         lhs_update_frequency = 1,
                                         stagger_convergence_tolerance = 1.e-4,
                                         stagger_lhs_update_frequency = 0,
                                         staggers = (),
                                         protect_parameters = False ):
  • TRACE_PARAMETERS
def cmdSetPtTraceParameters(  clobber = True,
                                        element_crossing = False,
                                        turbulence_trace = False,
                                        max_segment_length = 0,
                                        max_segment_coordinate_increment = 0.5,
                                        max_segment_time_increment = 0.0,
                                        max_turning_angle = 15,
                                        protect_parameters = False ):
  • USER_EQUATION
def cmdSetPtUserEquation( name,
                                  clobber = True,
                                  user_function = '',
                                  num_variables = 1,
                                  user_values = (),
                                  user_strings = (),
                                  type = 'evolve',
                                  datatree = True )
  • RADIATION
    def cmdSetRadiationParameters( clobber = True,
                                            view_factor_type = 'hemicube',
                                            num_hemicube_bins = 200,
                                            max_surface_subdivision = 1,
                                            smoothing_type = 'least_squares',
                                            stefan_boltzman_constant = 5.670e-8,
                                            num_symmetry_planes = 0,
                                            symmetry_center = ((0,0,0),),
                                            symmetry_direction_1 = ((1,0,0),),
                                            symmetry_direction_2 = ((0,1,0),),
                                            symmetry_direction_3 = ((0,0,1),) ):
    • view_factor_type can be "hemicube"
    • smoothing_type can be "least_squares"
  • RADIATION_SURFACE
    def cmdSetRadiationSurface( name, clobber = True,
                       active = False,
                       type = 'wall',
                       emissivity_model = '',
                       opening_temperature = 273.14,
                       opening_temperature_multiplier_function = 'none',
                       agglomeration = True,
                       max_agglomeration_surfaces = 25,
                       max_agglomeration_angle = 10,
                       max_agglomeration_radious = .25,
                       integrated_output_frequency = 1,
                       integrated_output_time_interval = 0,
                       nodal_output_frequency = 0,
                       nodal_output_time_interval = 0,
                       head = 'Model',
                       model = modelSrf):
    • type can be
  • REFERENCE_FRAME
    def cmdSetReferenceFrame( name, clobber = True,
                                       centrifugal = True,
                                       coriolis = True,
                                       angular_acceleration = True,
                                       rotation_center = (0,0,0,),
                                       angular_velocity = (0,0,0,),
                                       multiplier_function = 'none',
                                       datatree = True ):
  • SIMPLE_BOUNDARY_CONDITION
    def cmdSetSimpleBoundaryCondition( name, clobber = True,
                    active = True,
                    type = 'wall',
                    inflow_type = 'velocity',
                    back_flow_conditions = False,
                    precedence = 1,
                    reference_frame = "none",
                    inflow_velocity_type = "cartesian",
                    wall_velocity_type = "match_mesh_velocity",
                    cylinder_axis = ( ( 0,0,0 ), (0,1,0) ),
                    sphere_center = ( 0,0,0 ),
                    x_velocity = 0.0,
                    x_velocity_multiplier_function = "none",
                    y_velocity = 0.0,
                    y_velocity_multiplier_function = "none",
                    z_velocity = 0.0,
                    z_velocity_multiplier_function = "none",
                    axial_velocity = 0.0,
                    axial_velocity_multiplier_function = "none",
                    radial_velocity = 0.0,
                    radial_velocity_multiplier_function = "none",
                    tangential_velocity = 0.0,
                    tangential_velocity_multiplier_function = "none",
                    normal_velocity = 0.0,
                    normal_velocity_multiplier_function = "none",
                    mass_flux = 1.0,
                    mass_flux_multiplier_function = "none",
                    flow_rate = 1.0,
                    flow_rate_multiplier_function = "none",
                    average_velocity = 1.0,
                    average_velocity_multiplier_function = "none",
                    pressure = 0.0,
                    pressure_multiplier_function = "none",
                    pressure_loss_factor = 0.0,
                    pressure_loss_factor_multiplier_function = "none",
                    hydrostatic_pressure = False,
                    hydrostatic_pressure_origin = ( 0, 0, 0 ),
                    stagnation_pressure = 0.0,
                    stagnation_pressure_multiplier_function = "none",
                    temperature_type = "flux",
                    temperature = 0.0,
                    temperature_multiplier_function = "none",
                    heat_flux = 0.0,
                    heat_flux_multiplier_function = "none",
                    convective_heat_coefficient = 0.0,
                    convective_heat_multiplier_function = "none",
                    convective_heat_reference_temperature = 0.0,
                    species_1_type = "flux",
                    species_1 = 0.0,
                    species_1_multiplier_function = "none",
                    species_1_flux = 0.0,
                    species_1_flux_multiplier_function = "none",
                    species_2_type = "flux",
                    species_2 = 0.0,
                    species_2_multiplier_function = "none",
                    species_2_flux = 0.0,
                    species_2_flux_multiplier_function = "none",
                    species_3_type = "flux",
                    species_3 = 0.0,
                    species_3_multiplier_function = "none",
                    species_3_flux = 0.0,
                    species_3_flux_multiplier_function = "none",
                    species_4_type = "flux",
                    species_4 = 0.0,
                    species_4_multiplier_function = "none",
                    species_4_flux = 0.0,
                    species_4_flux_multiplier_function = "none",
                    species_5_type = "flux",
                    species_5 = 0.0,
                    species_5_multiplier_function = "none",
                    species_5_flux = 0.0,
                    species_5_flux_multiplier_function = "none",
                    species_6_type = "flux",
                    species_6 = 0.0,
                    species_6_multiplier_function = "none",
                    species_6_flux = 0.0,
                    species_6_flux_multiplier_function = "none",
                    species_7_type = "flux",
                    species_7 = 0.0,
                    species_7_multiplier_function = "none",
                    species_7_flux = 0.0,
                    species_7_flux_multiplier_function = "none",
                    species_8_type = "flux",
                    species_8 = 0.0,
                    species_8_multiplier_function = "none",
                    species_8_flux = 0.0,
                    species_8_flux_multiplier_function = "none",
                    species_9_type = "flux",
                    species_9 = 0.0,
                    species_9_multiplier_function = "none",
                    species_9_flux = 0.0,
                    species_9_flux_multiplier_function = "none",
                    turbulence_input_type = 'direct',
                    turbulence_average_velocity = 1.0,
                    turbulence_intensity = 1.0,
                    turbulence_length_scale = 1.0,
                    material_model_turbulence = 'Air',
                    turbulence_viscosity_ratio = 1.0,
                    eddy_viscosity = 0.0,
                    eddy_viscosity_multiplier_function = "none",
                    kinetic_energy = 0.0,
                    kinetic_energy_multiplier_function = "none",
                    eddy_frequency = 0.0,
                    eddy_frequency_multiplier_function = "none",
                    turbulence_wall_type = "wall_function",
                    roughness_height = 0.0,
                    non_reflecting_factor = 0.0,
                    surface_tension_model = "none",
                    contact_angle_model = "none",
                    mesh_displacement_type = "fixed",
                    flexible_body = '',
                    nodal_x_modes = (),
                    nodal_y_modes = (),
                    nodal_z_modes = (),
                    guide_surface = '',
                    mesh_motion = "none",
                    active_type = "all" ,
                    show_all = False,
                    advanced_features = False,
                    head = 'Model',
                    temperature_back_flow_type = "value",
                    eddy_viscosity_back_flow_type = "value",
                    kinetic_energy_back_flow_type = "value",
                    eddy_frequency_back_flow_type = "value",
                    species_1_back_flow_type = "value",
                    species_2_back_flow_type = "value",
                    species_3_back_flow_type = "value",
                    species_4_back_flow_type = "value",
                    species_5_back_flow_type = "value",
                    species_6_back_flow_type = "value",
                    species_7_back_flow_type = "value",
                    species_8_back_flow_type = "value",
                    species_9_back_flow_type = "value",
                    viscoelastic_xx_back_flow_type = "value",
                    viscoelastic_yy_back_flow_type = "value",
                    viscoelastic_zz_back_flow_type = "value",
                    viscoelastic_xy_back_flow_type = "value",
                    viscoelastic_yz_back_flow_type = "value",
                    viscoelastic_zx_back_flow_type = "value",
                    viscoelastic_xx_stress = 0.0,
                    viscoelastic_xx_stress_multiplier_function = "none",
                    viscoelastic_yy_stress = 0.0,
                    viscoelastic_yy_stress_multiplier_function = "none",
                    viscoelastic_zz_stress = 0.0,
                    viscoelastic_zz_stress_multiplier_function = "none",
                    viscoelastic_xy_stress = 0.0,
                    viscoelastic_xy_stress_multiplier_function = "none",
                    viscoelastic_yz_stress = 0.0,
                    viscoelastic_yz_stress_multiplier_function = "none",
                    viscoelastic_zx_stress = 0.0,
                    viscoelastic_zx_stress_multiplier_function = "none" ,
                    model = modelSrf ):
    • type can be "wall", "inflow", "outflow", "slip", "symmetry", "far_field", "free_surface"
    • inflow_type can be "velocity", "pressure", "stagnation_pressure", "mass_flux","flow_rate", "average_velocity"
    • inflow_velocity_type can be "cartesian", "cylindrical", "spherical", "normal"
    • wall_velocity_type can be "zero", "match_mesh_velocity", "cartesian","cylindrical","spherical", "normal"
    • temperature_type can be "value", "flux"
    • species_1_type can be "value", "flux"
    • species_2_type can be "value", "flux"
    • species_3_type can be "value", "flux"
    • species_4_type can be "value", "flux"
    • species_5_type can be "value", "flux"
    • species_6_type can be "value", "flux"
    • species_7_type can be "value", "flux"
    • species_8_type can be "value", "flux"
    • species_9_type can be "value", "flux"

      turbulence_input_type can be "direct", "intensity_and_length_scale", "viscosity_ratio", "intensity_and_viscosity_ratio"

    • turbulence_wall_type can be "none", "low_reynolds_number", "wall_function", "running_average_wall_function "
    • mesh_displacement_type can be "none", "fixed", "slip", "flexible_body", "guide_surface"
    • temperature_back_flow_type can be "area_average", "bulk", "exiting_area_average", "exiting_bulk", "value"
    • eddy_viscosity_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • kinetic_energy_back_flow_type_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • eddy_frequency_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_1_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_2_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_3_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_4_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_5_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_6_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_7_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_8_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • species_9_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • viscoelastic_xx_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • viscoelastic_yy_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • viscoelastic_zz_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • viscoelastic_xy_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • viscoelastic_yz_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • viscoelastic_zx_back_flow_type can be "area_average", "mass_flux_average","exiting_area_average", "exiting_mass_flux_average", "value"
    • active_type can be "none", "all", "no_interface"
  • SOLAR_RADIATION_MODEL
    def cmdSetSolarRadiationModel( name, clobber = True,
                                specular_transmissivity_type = 'constant',
                                specular_transmissivity = 0,
                                specular_transmissivity_curve_fit_values = ((0,0),(90,0),),
                                specular_transmissivity_curve_fit_variable = 'incidence_angle',
                                diffuse_transmissivity_type = 'constant',
                                diffuse_transmissivity = 0,
                                diffuse_transmissivity_curve_fit_values = ((0,0),(90,0),),
                                diffuse_transmissivity_curve_fit_variable = 'incidence_angle',
                                specular_reflectivity_type = 'constant',
                                specular_reflectivity = 0,
                                specular_reflectivity_curve_fit_values = ((0,0),(90,0),),
                                specular_reflectivity_curve_fit_variable = 'incidence_angle',
                                diffuse_reflectivity_type = 'constant',
                                diffuse_reflectivity = 0,
                                diffuse_reflectivity_curve_fit_values = ((0,0),(90,0),),
                                diffuse_reflectivity_curve_fit_variable = 'incidence_angle'
                                datatree = True ):
    • specular_transmissivity_type can be "constant", "piecewise_linear", "cubic_spline"
    • specular_transmissivity_curve_fit_variable can be "incidence_angle"
    • diffuse_transmissivity_type can be "constant", "piecewise_linear", "cubic_spline"
    • diffuse_transmissivity_curve_fit_variable can be "incidence_angle"
    • specular_reflectivity_type can be "constant", "piecewise_linear", "cubic_spline"
    • specular_reflectivity_curve_fit_variable can be "incidence_angle"
    • diffuse_reflectivity_type can be "constant", "piecewise_linear", "cubic_spline"
    • diffuse_reflectivity_curve_fit_variable can be "incidence_angle"
  • SOLAR_RADIATION
    def cmdSetSolarRadiationParameters( clobber = True,
                                                type = 'piecewise_linear',
                                                curve_fit_values = ((0,0,0,-1352),),
                                                curve_fit_variable = 'time',
                                                multiplier_function = 'none',
                                                computation_type = 'ray_trace',
                                                num_rays = 1000000,
                                                num_diffuse_sub_rays = 4,
                                                max_ray_reflections = 10,
                                                min_ray_energy = 1.e-3,
                                                terminated_ray_redistribution_factor = 1,
                                                smoothing = True ):
    • type can be "piecewise_linear"
    • curve_fit_variable can be "time"
    • computation_type can be "ray_trace"
  • SOLAR_RADIATION_SURFACE
    def cmdSetSolarRadiationSurface( name, clobber = True,
                                               active = False,
                                               side = 'default',
                                               solar_radiation_model = '' ,
                                               head = 'Model',
                                               model = modelSrf ):
    • side can be "default", "inward","outward","both"
  • STAGGER
    def cmdSetStagger( name, clobber = True,
                          equation = 'none',
                          explicit_type = 'none',
                          min_stagger_iterations = 1,
                          max_stagger_iterations = 1,
                          convergence_tolerance = 1.e-4,
                          lhs_update_frequency = 1,
                          linear_solver = 'gmres',
                          min_linear_solver_iterations = 1,
                          max_linear_solver_iterations = 1000,
                          num_krylov_vectors = 10,
                          linear_solver_tolerance = 1.e-1,
                          pressure_projection_tolerance = 1.e-1,
                          velocity_projection_tolerance = 1.e-1,
                          temperature_projection_tolerance= 1.e-1,
                          projection = True,
                          pressure_projection = True,
                          velocity_projection = False,
                          pressure_algebraic_multigrid = False,
                          pressure_algebraic_multigrid_update_frequency = 0,
                          temperature_projection = False,
                          pressure_algebraic_multigrid_update_frequency = 1,
                          velocity_algebraic_multigrid = False,
                          velocity_algebraic_multigrid_update_frequency = 1,
                          temperature_algebraic_multigrid = False,
                          temperature_algebraic_multigrid_update_frequency = 1,
                          algebraic_multigrid = False,
                          algebraic_multigrid_update_frequency = 1,
                          staggers = (),
                          datatree = True ,
                          protect_parameters = False ):
    • equation can be "none", "pressure", "velocity", "flow", "viscoelastic", "temperature", "radiation", "temperature_flow", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9", "turbulence", "mesh_displacement", "external_code", "kinetic_energy", "eddy_frequency"
    • explicit_type can be "none", "advection"
    • linear_solver can be "gmres", "bicgstab","conjugate_gradient"
  • SURFACE_MESH_ATTRIBUTES
    def cmdSetSurfaceMeshAttributes( name, clobber = True,
                 active = False,
                 MeshSizeType = 'absolute_value',
                 AbsMeshSize = 1.0,
                 RelMeshSize = 0.125,
                 AbsMeshSizeExp = "value=1.0",
                 RelMeshSizeExp = "value=0.125",
                 AbsAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1) ),
                 RelAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1) ),
                 AbsAnisoMeshSizeFactor = 1.0,
                 RelAnisoMeshSizeFactor  = 1.0,
                 CurvatureRefinementFlag = False,
                 CurvatureAngle = 25,
                 CurvatureMeshSizeFactor  = 0.5,
                 RegionOfInfluenceFlag = False,
                 InfluenceType = "SIMPLE",
                 InfluenceSizeFactor = 1.0,
                 InfluenceDistance  = 0.1,
                 InfluenceDirection = ( (1,0,0), ),
                 UpstreamInfluenceDistance  = 0.1,
                 DownstreamInfluenceDistance= 0.1,
                 InfluenceStartAngle = 15,
                 BoundaryLayerFlag = False,
                 BoundaryLayerSpec = 'type_1',
                 FirstLayerHeight = 0.001,
                 HeightOfLayers = 0.004,
                 GrowthRate = 1.3,
                 NumberOfLayers = 3 ,
                 ResolveBLAttrib = '3',
                 BoundaryLayerBlendsFlag = False,
                 BoundaryLayerPropagateFlag = False,
                 BoundaryLayerElemType = 'ACUMESH_BL_TETRAHEDRON',
                 SweepAngle = 45,
                 estimate_yp = 'none',
                 material_model_yp = 'Water',
                 vel_scale = 1.0,
                 len_scale = 1.0,
                 coeff = 1.0,
                 power = 1.0,
                 SmallFeatureMeshingFlag = False,
                 SmallFeatureMeshingType ='RELATIVE_TOLERANCE',
                 SmallFeatureMeshingTolerance = 0.0125,
                 head = 'Model'
                 model = modelSrf ):
    • MeshSizeType can be "none", "absolute_value", "relative_value", "absolute_expression", "relative_expression", "absolute_aniso_value", "relative_aniso_value"
    • InfluenceType can be "SIMPLE","DIRECTIONAL"
    • BoundaryLayerSpec can be "type_1","type_2", "type_4"
    • BoundaryLayerElemType can be "ACUMESH_BL_MIXED", "ACUMESH_BL_TETRAHEDRON"
    • ResolveBLAttrib can be "1","2","3","4"
  • SURFACE_OUTPUT
    def cmdSetSurfaceOutput( name, clobber = True,
                                      active = False,
                                      integrated_output_frequency = 1,
                                      integrated_output_time_interval = 0,
                                      nodal_output_frequency = 0,
                                      nodal_output_time_interval = 0 ,
                                      num_saved_states = 0,
                                      head = 'Model',
                                      model = modelSrf ):
  • SURFACE_TENSION_MODEL
    def cmdSetSurfaceTensionModel( name, clobber = True,
                                            type = 'constant',
                                            surface_tension = 0,
                                            curve_fit_values = ((0,0),),
                                            curve_fit_variable = 'temperature',
                                            user_function = '',
                                            user_values = (),
                                            user_strings = (),
                                            multiplier_function = 'none',
                                            datatree = True ):
    • type can be "constant", "piecewise_linear", "cubic_spline", "user_function"
    • curve_fit_variable can be "temperature", "species_1", "species_2", "species_3", "species_4", "species_5", "species_6", "species_7", "species_8", "species_9"
  • TIME_INCREMENT
    def cmdSetTimeIncrement( clobber = True,
                                      initial_time_increment = 0,
                                      previous_time_increment = 0,
                                      flow_time_increment = 0,
                                      auto_time_increment = True,
                                      local_time_increment = False,
                                      min_time_increment = 0,
                                      max_time_increment = 0,
                                      cfl_control = True,
                                      cfl_number = 100,
                                      min_cfl_number = 0,
                                      initial_cfl_number = 1,
                                      time_increment_decrease_factor = 0.25,
                                      time_increment_increase_factor = 1.25,
                                      time_increment_increase_delay = 4,
                                      min_time_increment_ratio = 0.1,
                                      multiplier_function = 'none' ,
                                      protect_parameters = False ):
  • TIME_INTEGRATION
    def cmdSetTimeIntegration( clobber = True,
                                         predictor = 'same_v',
                                         time_integration_order = 'first',
                                         high_frequency_damping_factor = 1.0,
                                         pressure_damping_type = 'max',
                                         lumped_mass_factor = 1.0,
                                         initialize_acceleration = False ,
                                         initialize_stokes = False,
                                         initialize_turbulence = False,
                                         protect_parameters = False ):
    • predictor can be "same_v", "zero_a"
    • time_integration_order can be "first", "second"
  • TIME_SEQUENCE
    def cmdSetTimeSequence( clobber = True,
                                     final_time = 0,
                                     min_time_steps = 1,
                                     max_time_steps = 1,
                                     convergence_tolerance = 1.e-4,
                                     termination_delay = 0,
                                     lhs_update_initial_times = 1,
                                     lhs_update_frequency = 1,
                                     min_stagger_iterations = 1,
                                     max_stagger_iterations = 1,
                                     stagger_convergence_tolerance = 1.e-4,
                                     stagger_lhs_update_frequency = 0,
                                     staggers = ('flow',) ,
                                     protect_parameters = False ):
  • TURBULENCE_WALL
    def cmdSetTurbulenceWall( name, clobber = True,
                                        active = False,
                                        type = 'low_reynolds_number',
                                        roughness_height = 0,
                                        active_type = 'all' ,
                                        head = 'Model'
                                        model = modelSrf ): 
    • type can be "low_reynolds_number", "wall_function", "running_average_wall_function"
    • active_type can be "none", "all", "no_interface"
  • USER_GLOBAL_DATA
    def cmdSetUserGlobalData( name, clobber = True,
                                        value = 0,
                                        datatree = True ):
  • VOLUME_MESH_ATTRIBUTES
    def cmdSetVolumeMeshAttributes( name, clobber = True,
                                             active = False,
                                             MeshSizeType = 'absolute_value',
                                             AbsMeshSize = 1.0,
                                             RelMeshSize = 0.125 ,
                                             AbsMeshSizeExp = "value=1.0",
                                             RelMeshSizeExp = "value=0.125",
                                             AbsAnisoMeshSize = ( (1,0,0),(0,1,0),(0,0,1)),
                                             RelAnisoMeshSize  = ( (1,0,0),(0,1,0),(0,0,1)),
                                             AbsAnisoMeshSizeFactor = 1.0,
                                             RelAnisoMeshSizeFactor = 1.0,
                                             CurvatureRefinementFlag = False,
                                             CurvatureAngle = 25,
                                             CurvatureMeshSizeFactor = 0.1,
                                             SmallFeatureMeshingFlag = False,
                                             SmallFeatureMeshingType = 'RELATIVE_TOLERANCE',
                                             SmallFeatureMeshingTolerance = 0.0125,
                                             head = 'Model' ):
    • MeshSizeType can be "absolute_value", "relative_value", "absolute_expression", "relative_expression", "absolute_aniso_value", "relative_aniso_value", "none", "no_mesh"
  • ZONE_MESH_ATTRIBUTES
    def cmdSetZoneMeshAttributes( name, clobber = True,
                                           active = True,
                                           type = 'sphere',
                                           centerArray = ( 0, 0, 0 ),
                                           radius = 1,
                                           BoxCenter = ( 0, 0, 0 ),
                                           BoxLengthX = 1.0,
                                           BoxLengthY = 1.0,
                                           BoxLengthZ = 1.0,
                                           BoxXRot = 0.0,
                                           BoxYRot = 0.0,
                                           BoxZRot = 0.0,
                                           baseCentersArray= (( 0.0, 0.0, 0.0 ),
                                           ( 1.0, 1.0, 1.0 )),
                                           meshSize = 1.,
                                           datatree = True ):