3. Design Analysis Solver - ProSolve

The ProSolve module is a design analysis finite element solver. It is built upon the finite element technologies available in VfeTools and VfsTools and its feature set reflects those currently available in these underlying toolkits. The feature set may be summarized as follows:

  • Analysis types include 2D and 3D structural and thermal analysis.

  • Solution types include statics, vibration, buckling, stress recovery output and superelement generation, and nonlinear contact and heat transfer.

  • Element types include linear and parabolic solid, shell, membrane, beam, truss and interface elements. In addition, rigid elements, gaps, concentrated mass, spot weld and springs are supported.

  • Property types include general shell laminates and beam cross sections.

  • Material types include linear, temperature dependent, isotropic, orthotropic, anisotropic materials.

  • Loading types include concentrated, distributed and body forces.

The methods associated with a ProSolve object are the following.

Instance a ProSolve object using vfx_ProSolveBegin(). Use vfx_ProSolveSetObject() to register the current Model object. This gives ProSolve access to the complete model definition. A TextFun object should also be registered using vfx_ProSolveSetObject(). This abstract text interface is used to output solution progress (the log file). The functions vfx_ProSolveSetParami() and vfx_ProSolveSetParamc() are used to specify overall solution controls such as level of printout, type of results file, path names for output and results files, etc. Destroy an instance of a ProSolve object using vfx_ProSolveEnd().

Use the function vfx_ProSolveInit() to initialize a solution process. This function must be called whenever a new Model object is registered or the existing Model object is changed in any way. For example, if ProSolve is used to perform an H-adaptive analysis, the function vfx_ProSolveInit() must be called whenever the Model object is changed to reflect the changes in the adapting finite element mesh.

The finite element solution is performed using the vfx_ProSolveExec() function. This function is computationally expensive for large models. During the solution, specified output and results files are generated and a text stream describing the solution progress is directed to the registered TextFun object. By default, the vfx_ProSolveExec() function will process all solution property objects, List of SProp objects, contained in the registered Model object. A range of the solution property identifiers may be specified using vfx_ProSolveRange(). The solution of each individual solution property object is called a case. During the execution of a particular SProp object, the solution case may contain a number of steps each of which pass through several phases to be completed. Usually a solution case will contain a single step unless a nonlinear or transient analysis is being performed. A solution case will always require several phases for completion. Examples of phases are stiffness matrix formation, stiffness matrix factorization, results computation, etc. The progress of the solution sequence in terms of case, steps and phases is reflected in the text directed to the registered TextFun.

Use vfx_ProSolveGetInteger() and vfx_ProSolveGetDouble() to query for detailed information about the solution process, such as the current case identifier, step and phase. vfx_ProSolveGetInteger() function with PROSOLVE_NUMRES will return the number of State and RedMat results computed, the parameter PROSOLVE_NUMHIST will return the number of History results computed. Use the function vfx_ProSolveFillRResProp() to return the output object type (State or RedMat) and fill an RProp object with the result type, etc. The RProp object is required to access output using the following two functions. The function vfx_ProSolveState() is used to directly place computed results quantities in a user provided State object. The function vfx_ProSolveRedMat() is used to obtain computed reduced system stiffness and mass matrices and load vectors in a user provided RedMat object. Alternatively, the function vfx_ProSolveSysMatrix() can be used to return the reduced system matrices in a user provided SysMatrix object. This option is useful if additional matrix operations such as eigensolution are to be performed on the reduced system. Use the function vfx_ProSolveFillRHistProp() to fill an RProp object with the result type, etc. for a history result. The RProp object is required to access the output using vfx_ProSolveHistory().

The ProSolve module provides for a callback function to be specified which is called intermittently during the solution process in vfx_ProSolveExec(). The primary purpose of this function is to allow the user to interrupt or interrogate the on-going solution process for any reason and to obtain solution results while vfx_ProSolveExec() is executing. If the solution is to be terminated, call vfx_ProSolveAbort(). This call will set an internal flag which will cause vfx_ProSolveExec() to terminate the solution process and return. Set callback functions using vfx_ProSolveSetFunction().

Use the function vfx_ProSolveSetNumThreads() to specify serial or parallel execution of ProSolve functions. Currently the following operations are parallelized.

  • ProSolve using vfx_ProSolveSetNumThreads()

    • Degree of freedom reordering.

    • Lanczos eigensolution

    • Matrix reduction

    • Factorization if Intel’s threaded MKL is enabled

    • Back-substitution if Intel’s threaded MKL is enabled

    • Coarse-grain back-substitution for multiple rhs vectors

3.1. Solution Sequence, Case, Step, Phase

Every time vfx_ProSolveExec() is called a sequence of solution property identifiers is executed. As mentioned above, each solution property identifier is associated with a SProp solution property object in the List of SProp objects, contained in the registered Model object. A case identifier is attached to each SProp object. By default the case identifier is the solution property identifier unless a non-zero SPROP_CASEID has been specified in the SProp object using vis_SPropSetValuei.

The number of steps and phases required to solve a particular case depends primarily upon the solution type defined in SProp using vis_SPropDef() and whether or not the solution is non-linear in some respect. For example, a linear static solution will consist of a single step with several phases required, such as element matrix formation, system matrix factorization, output calculation, etc. A nonlinear static solution will generally require several steps, each step corresponding to an incrementation of the total load.

Each step will contain an output phase. This is the phase which will be of the most importance to the user as far as obtaining the results of the solution step are concerned. When the vfx_ProSolveExec() function returns only the last computed solution may be accessed. Therefore, in general, the use of the monitor function is the only way to access all the solution results while the ProSolve module is computing them. The monitor function is installed using vfx_ProSolveSetFunction(). When the monitor function is called, the user must use the vfx_ProSolveGetInteger() function with PROSOLVE_PHASE to query for the current phase.

If the current phase is SYS_PHASE_OUTPUT, then the user must query for the current step or mode with PROSOLVE_STEP to determine the current step or mode being output. During the output phase, the monitor function will be called exactly once for each step or mode to be output.

The interpretation of the PROSOLVE_STEP query as a mode number or actual step number depends upon the solution type. For solution types for which there is only a single solution for each step, such as static or steady state solutions, the output phase will consist of a single call to the monitor function for each step. The returned step number will be the same as the solution step number. For solution types which consist of an eigenvalue extraction in a single step, such as buckling, vibration and superelement generation, the output phase consists of a series of calls to the monitor function, one for each computed mode. In this case the returned step number will be the mode number.

3.2. Static or Steady State Solution

If the SProp object for a particular solution case has been defined as SYS_SOL_STATIC in the function vis_SPropDef(), then a static structural or steady state thermal solution is performed depending upon the value of the SPROP_ANALYSIS property.

The addition of balancing inertial forces may be enabled by setting the SPROP_INERTIARELIEF solution property. If enabled, the total load is the sum of the applied loads plus the balancing inertial forces. Inertia forces are computed using the mass matrix to exactly balance the applied loads.

A prestress effect may be included in the static solution by preceding the solution by a static solution step which computes the desired prestress. Use the SPROP_PRESTRESS solution property in the current solution to enable the use of the previous solution case as a prestress.

If the SPROP_NONLINEAR property is enabled then the load will be incremented depending upon the SPROP_TIME_INIT, SPROP_TIME_STEP and SPROP_TIME_TERM parameters. Equilibrium is ensured using a Newton-Raphson solution technique at each load step.

3.3. Buckling Solution

A buckling solution requires two successive solution procedures represented by two separate SProp objects. The first is a static solution to compute the pre-stress condition. This solution should consist of a single load case. The second is a buckling eigenvalue solution, SYS_SOL_BUCKLING to compute the buckling load factors and modes.

Usually only a single, or very few, lowest buckling modes are required. A subspace eigenvalue solution procedure is used in all cases.

3.4. Vibration Solution

A vibration eigenvalue solution can be very computationally expensive depending upon the number of eigenvalues requested. The solution property parameters which control vibration mode extraction are the following. The SPROP_EIGEN_NUM property specifies the number of vibration modes The SPROP_EIGEN_TYPE property specifies the eigenvalue interval type. Possible interval types are SPROP_EIGEN_ALL, SPROP_EIGEN_LOWEST and SPROP_EIGEN_NEAREST. The SPROP_EIGEN_LOWER, SPROP_EIGEN_UPPER and SPROP_EIGEN_SHIFT define the interval limits or center. These parameters together form the following distinct possibilities.

SPROP_EIGEN_LOWEST

SPROP_EIGEN_LOWER

SPROP_EIGEN_UPPER

SPROP_EIGEN_NUM

Description

L

U

N

Lowest N or all in range, whichever is smaller

L

U

Lowest single eigenvalue in range

L

N

Lowest N above L

L

Lowest single eigenvalue above L

N

Lowest N

Lowest single eigenvalue

U

N

Lowest N below U

U

Lowest single eigenvalue below U

SPROP_EIGEN_ALL

SPROP_EIGEN_LOWER

SPROP_EIGEN_UPPER

Description

L

U

All in range

U

All below U

SPROP_EIGEN_NEAREST

SPROP_EIGEN_SHIFT

SPROP_EIGEN_NUM

Description

S

N

N nearest to S

S

Nearest single eigenvalue to S

A Lanczos eigenvalue solution procedure is used by default.

3.5. Superelement Solution

If the SProp object for a particular solution case has been defined as SYS_SOL_SUPERELEMENT in the function vis_SPropDef(), then a superelement solution is performed. The SPROP_ANALYSIS property may be SYS_ANALYSIS_STRUCTURAL or SYS_ANALYSIS_THERMAL.

In the case of structural analysis, superelement solution consists of generating a reduced stiffness and mass representation of a full system finite element model. The reduced system consists of a set of generalized degrees of freedom each of which is represented by a corresponding mode shape.

The generalized freedoms may be of three types 1) retained full system degrees of freedom (static modes), 2) vibration modes and 3) residual load modes. The SPROP_RCASE property specifies the RCase object to be used to define the static modes. Each applied restraint using the function vis_RCaseSetSPC() with type RCASE_APPLIED will be treated as a static mode. Note that each fixed restraint using type RCASE_FIXED will be treated as a permanent fixity.

The SPROP_EIGEN_TYPE property specifies whether vibration modes are to be included. If this value is SPROP_EIGEN_NONE then no vibration modes are assumed otherwise the vibration modes are specified exactly as in a vibration solution.

The SPROP_LCASE_NUM property determines the number of residual load modes to include. The SPROP_LCASE property specifies the set of LCase objects to describe each load distribution for which a residual load mode is to be computed.

A prestress effect may be included in the superelement stiffness by preceding the superelement solution by a static solution step which computes the desired prestress. Use the SPROP_PRESTRESS solution property in the superelement solution to enable the use of the previous solution case as a prestress.

The superelement solution consists of a single step with phases for stiffness matrix formation, mass matrix formation, vibration mode extraction, output, etc. The output phase consists of the processing each of the superelement modes. The interpretation of the PROSOLVE_STEP query will be the mode number.

The final reduced stiffness and mass matrices or reduced load vectors may be obtained by using vfx_ProSolveRedMat() to copy the reduced matrices and vectors to a user supplied RedMat object.

In the case of thermal analysis, a superelement solution consists of generating a reduced conductivity and optionally capacitance representation of a full system finite element model. The generalized degrees of freedom may only consist of steady state and residual load modes. These modes are specified in a manner similar to static modes and residual load modes in structural analysis.

Use vfx_ProSolveRedMat() to copy the reduced conductivity and capacitance matrices to a user supplied RedMat object.

3.6. Frequency Response Solution

If the SProp object for a particular solution case has been defined as SYS_SOL_FREQRESPONSE in the function vis_SPropDef(), then a frequency response solution is performed.

3.7. Output Solution

If the SProp object for a particular solution case has been defined as SYS_SOL_OUTPUT in the function vis_SPropDef(), then an output computation is performed. An output computation is designed to compute element related results quantities given an input degree of freedom (DoF) solution such as displacement, velocity or temperature. The input degree of freedom solution vectors are specified using the ICase object as initial conditions. All output requests appropriate for the analysis type are supported. This solution type is useful in the case of results computation after an analysis using superelements or if element based results are needed “on demand” given previously computed DoF solution vectors.

Note that no system stiffness or mass matrices are computed or factored.

3.8. Singular Mode Solution

If the SProp object for a particular solution case has been defined as SYS_SOL_SINGULAR in the function vis_SPropDef(), then a singular mode solution is performed. This solution procedure generates a singularity equivalent model of the full model which typically has a very small number of degrees of freedom. This equivalent model is used to compute the number of singularities and a desired number of singular modes. The number of singularities are computed by a factorization procedure performed on the equivalent model system matrix. A set of singular modes may be requested and are computed using an eigenvalue analysis of the equivalent system. For structural analysis the singular modes are rigid body modes. Query for the number of singularities using vfx_ProSolveGetInteger().

The solution property parameters which control singular mode extraction are the following. The SPROP_EIGEN_TYPE property specifies the eigenvalue mode type. Possible types are SPROP_EIGEN_NONE, SPROP_EIGEN_ALL and SPROP_EIGEN_LOWEST. If type is SPROP_EIGEN_NONE, no singular modes are computed. If type is SPROP_EIGEN_ALL, all singular modes are computed. If type is SPROP_EIGEN_LOWEST, then a specified number of modes are computed as follows.

SPROP_EIGEN_LOWEST

SPROP_EIGEN_NUM

Description

N

Lowest N or all singular modes whichever is smaller

Lowest single singular mode

3.9. Direct Sparse Solver vs. Iterative Solver

Each solution procedure, except stress output recovery, requires the solution of a linear system. By default, a direct sparse solver is used. However depending upon model size and predominant element type used, an iterative solver may be recommended. This option is specified using vfx_ProSolveSetParami() with parameter PROSOLVE_SOLVER. The symmetric in-core direct sparse solver is PROSOLVE_SYMM_SPARSE, the symmetric in-core iterative solver is PROSOLVE_SYMM_ITER_CONJGRAD. The iterative solver is particularly effective when 2nd order element formulations are used, specifically isoparametric 10 node parabolic tetrahedra. For small problems, ie less than 500,000 DoF, the direct sparse solver is generally fastest while requiring a moderate amount of memory. For larger problems the iterative solver is generally faster requiring a much smaller amount of memory than the direct sparse solver. It is generally recommended that the out-of-core versions of either the direct sparse or iterative solver be avoided unless required due to central memory restrictions.

3.10. Solution Output Files

The ProSolve object potentially produces four types of files during an execution.

  • Log file. The log file is generated as a consequence of the continuous text stream produced by ProSolve during an execution. This text stream is directed to the TextFun object registered using vfx_ProSolveSetObject(). This text stream is normally formatted in turn to a file as simple text strings using the CEETRON SAM PlainText module or to an HTML formatted file using the CEETRON SAM LCase module.

  • Output file. The output file is printout text file of model and results summaries and listings. The amount of printout generated, if any, is specified as a parameter using vfx_ProSolveSetParami(). The path name of the output file is specified using vfx_ProSolveSetParamc().

  • Results file. The results file is designed to be a repository for model information and/or computed results quantities. It may, in general, contain a considerable amount of data for large finite element models. Use vfx_ProSolveSetParami() to identify the results file type and specify whether model data, results data or both are to be saved on the results file. The path name of the results file is specified using vfx_ProSolveSetParamc().

  • Out of core file. The out of core file is generated by the linear equation solver if requested. It will only be generated if the out of core direct or iterative solver is specified using vfx_ProSolveSetParami().

The detailed control of the specific results to be written to the output and/or results files is controlled by solution properties specified in the current SProp object being executed. The results printed to the output file depend upon the SPROP_RESPRINT_NUM and SPROP_RESPRINT properties. The results and histories written to the results file depend upon the SPROP_RESFILE_NUM, SPROP_RESFILE, SPROP_HISTFILE_NUM and SPROP_HISTFILE properties.

3.11. Function Descriptions

The currently available ProSolve functions are described in detail in this section.

vfx_ProSolve *vfx_ProSolveBegin(void)

create an instance of a ProSolve object

Create an instance of a ProSolve object. Memory is allocated for the object private data and the pointer to the object is returned.

Destroy an instance of a ProSolve object using

void vfx_ProSolveEnd (vfx_ProSolve *prosolve)

Return the current value of a ProSolve object error flag using

Vint vfx_ProSolveError (vfx_ProSolve *prosolve)

Returns

The function returns a pointer to the newly created ProSolve object. If the object creation fails, NULL is returned.

void vfx_ProSolveEnd(vfx_ProSolve *p)

destroy an instance of a ProSolve object

See vfx_ProSolveBegin()

Vint vfx_ProSolveError(vfx_ProSolve *p)

return the current value of a ProSolve object error flag

See vfx_ProSolveBegin()

void vfx_ProSolveSetObject(vfx_ProSolve *p, Vint objecttype, Vobject *object)

set attribute objects

Set a pointer to an attribute object. The Model object must be registered. The TextFun object is optional and is used to direct solution progress output.

Get object as an output argument using

void vfx_ProSolveGetObject (vfx_ProSolve *prosolve,
                            Vint objecttype,
                            Vobject **object)

Errors

SYS_ERROR_OBJECTTYPE is generated if an improper objecttype is specified.

Parameters
  • p – Pointer to ProSolve object.

  • objecttype – The object type identifier

    x=VIS_MODEL              Model object
     =VSY_TEXTFUN            TextFun object
    

  • object – Pointer to the object to be set.

void vfx_ProSolveGetObject(vfx_ProSolve *p, Vint objtype, Vobject **obj)

get attribute objects

See vfx_ProSolveSetObject()

void vfx_ProSolveSetParami(vfx_ProSolve *p, Vint ptype, Vint iparam)

set integer paramters

Specify integer parameters to control solution.

The parameter PROSOLVE_PRINTLEVEL controls the level of printout to the output file. A print level of 0 specifies that no output file is written. A print level of 1 writes summary tables of the model and results to the output file. A print level of 2 writes complete listings of the model and results to the output file. By default PROSOLVE_PRINTLEVEL is 1.

The parameter PROSOLVE_CHECKTOTALVOL toggles of Jacobian checking performed during solid element volume integrations. If this parameter is not enabled, then an error is generated if the Jacobian contribution of any integration point is non-positive. If this parameter is enabled then an error is generated only if the total Jacobian contribution over all integration points is non-positive. By default PROSOLVE_CHECKTOTALVOL is set to SYS_OFF.

The parameter PROSOLVE_CHECKCORNNORM toggles a comparison between computed normals at integration points in shells and a computed normal interpolated from corner node values. If this parameter is enabled then the dot product of these two normals is computed and, if negative, an error is flagged. By default PROSOLVE_CHECKCORNNORM is set to SYS_ON.

The parameter PROSOLVE_FREEBLASBUFFERS toggles the freeing of external BLAS library buffers. By default PROSOLVE_FREEBLASBUFFERS is set to SYS_OFF.

The parameter PROSOLVE_MPCTYPE specifies the type of method to be used to enforce multi-point contraints. Multi-point contraints arise from MPC cases, contraint and rigid elements. A type of VFX_MPCTYPE_PENALTY uses the penalty function method. Two other types use variations of the Lagrange multiplier method, VFX_MPCTYPE_LAGMULT and VFX_MPCTYPE_AUGMENT. The later uses an augmented Lagrange multiplier method. A fourth option, VFX_MPCTYPE_TRANSFORM uses matrix transformations to eliminate dependent degress of freedom from the system. This method is the preferred alternative to the penalty function method. By default PROSOLVE_MPCTYPE is set to VFX_MPCTYPE_TRANSFORM.

The parameter PROSOLVE_OOCMEM_FACTOR is used to specifiy, in megabytes, the block size used for the out of core factor. By default PROSOLVE_OOCMEM_FACTOR is set to 256.

The parameter PROSOLVE_RESTYPE specifies the type of results file to be generated. By default PROSOLVE_RESTYPE is set to SYS_NATIVE.

The parameters PROSOLVE_SAVEMODEL and PROSOLVE_SAVERES toggle the saving of model data and computed results data to the results file. By default PROSOLVE_SAVEMODEL and PROSOLVE_SAVERES are enabled.

The parameter PROSOLVE_SOLVER is used to control the linear equation solver to be used. The basic choices are symmetric and non-symmetric direct and iterative solvers. Set PROSOLVE_SOLVER to PROSOLVE_SYMM_SPARSE for a sparse, symmetric, direct solver; to PROSOLVE_NSYMM_SPARSE for a sparse, non-symmetric direct solver; to PROSOLVE_SYMM_ITER_CONJGRAD for a conjugrade gradient-driven iterative solution of a symmetric system; to PROSOLVE_SYMM_ITER_GMRES for a GMRES-driven iterative solution of a symmetric system; and to PROSOLVE_NSYMM_ITER for a GMRES-driver solution of a non-symmetric system.

The parameter PROSOLVE_EIGEN_METHOD is used to select the eigenmethod used for vibration or superelement analysis. It can be set to either SYS_EIGEN_SUBSPACE, SYS_EIGEN_LANCZOS and SYS_EIGEN_AMLS. Defaults to SYS_EIGEN_LANCZOS.

Use PROSOLVE_LANCZOS_BLOCKSIZE to select the block size used by the Lanczos eigensolver. If running in serial mode it is suggested to use a block size of 1. If running in parallel mode it is suggested to make the block size the minimum of the number of threads and 7. If set to 0, a simplified unblocked Lanczos algorithm is used which avoids the full use of BLAS/LAPACK functions. By default, if VKI_LIBAPI_BLASMKL_SEQUENTIAL or VKI_LIBAPI_BLASMKL_THREAD is defined, then PROSOLVE_LANCZOS_BLOCKSIZE defaults to 7, else it defaults to 0. An error will be issued if the block size is set to a value greater than zero and some version of the MKL BLAS has not been defined.

Use PROSOLVE_SOLVERTYPE to set the specific direct sparse equation solver package to be used. Set SYS_SOLVERTYPE_LL, SYS_SOLVERTYPE_MF or SYS_SOLVERTYPE_MFP to use the native left-looking, serial multi-frontal or parallel, high performance multi-frontal solver. Use SYS_SOLVERTYPE_PARDISO to use Intel’s MKL Pardiso solver. Pardiso selection requires that DevTools be compiled with the flag VKI_LIBAPI_PARDISO. Set SYS_SOLVERTYPE_MUMPS to use the NUMPS solver. MUMPS selection requires that DevTools be compiled with VKI_LIBAPI_MUMPS. Currently only the sequential version of MUNPS is advised. Defaults to SYS_SOLVERTYPE_MFP.

Use PROSOLVE_EIGEN_OOC to enable out of core storage of eigenvectors. The default PROSOLVE_EIGEN_OOC is off.

Use PROSOLVE_FACTOR_OOC to enable the out-of-core linear equation solver. The default PROSOLVE_FACTOR_OOC is off.

Get iparam as an output argument using

void vfx_ProSolveGetParami (vfx_ProSolve *prosolve,
                            Vint ptype,
                            Vint *iparam)

Errors

VIS_ERROR_ENUM is generated if an improper ptype is specified.

Parameters
  • p – Pointer to ProSolve object.

  • ptype – Type of solution parameter to set

    x=PROSOLVE_EIGEN_METHOD        Eigensolver method for vibration
     =PROSOLVE_CHECKTOTALVOL       Total element Jacobian checking
     =PROSOLVE_CHECKCORNNORM       Corner normal checking
     =PROSOLVE_FREEBLASBUFFERS     Free external BLAS library buffers
     =PROSOLVE_LANCZOS_BLOCKSIZE   Lanczos block size
     =PROSOLVE_MPCTYPE             MPC application method
     =PROSOLVE_OOCMEM_FACTOR       Memory used for out-of-core factor
     =PROSOLVE_PRINTLEVEL          Level of printout to output file
     =PROSOLVE_RESTYPE             Type of result file to produce
     =PROSOLVE_SAVEMODEL           Save model on result file flag
     =PROSOLVE_SAVERES             Save results on result file flag
     =PROSOLVE_SOLVER              Linear equation solver method
     =PROSOLVE_SOLVERTYPE          Linear equation solver type
     =PROSOLVE_EIGEN_OOC           Eigenvector out-of-core flag
     =PROSOLVE_FACTOR_OOC          Factor out-of-core flag
    

  • iparam – Specifies the integer value that ptype will be set to.

    x=SYS_OFF                     Disable
     =SYS_ON                      Enable
     =SYS_NATIVE                  VdmTools Native result file
     =SYS_NATIVE_HDF              VdmTools Native HDF5 result file
     =SYS_NASTRAN_OUTPUT2         NASTRAN .op2 file
     =SYS_ENSIGHT                 ENSIGHT file
     =PROSOLVE_SYMM_SPARSE        Symmetric sparse solver
     =PROSOLVE_NSYMM_SPARSE       Non-symmetric sparse solver
     =PROSOLVE_SYMM_ITER_CONJGRAD Symmetric conjugate gradient iterative solver
     =PROSOLVE_SYMM_ITER_GMRES    Symmetric GMRES iterative solver
     =PROSOLVE_NSYMM_ITER         Non-symmetric GMRES iterative solver
     =SYS_EIGEN_SUBSPACE          Subspace eigensolver vibration
     =SYS_EIGEN_LANCZOS           Lanczos eigensolver vibration
     =SYS_EIGEN_AMLS              AMLS eigensolver vibration
     =SYS_SOLVERTYPE_LL           Left-looking solver
     =SYS_SOLVERTYPE_MF           Multi-frontal solver
     =SYS_SOLVERTYPE_MFP          Multi-frontal parallelized solver
     =SYS_SOLVERTYPE_PARDISO      Intel Pardiso equation solver
     =SYS_SOLVERTYPE_MUMPS        MUMPS equation solver
     =VFX_MPCTYPE_PENALTY         Penalty function method
     =VFX_MPCTYPE_LAGMULT         Lagrange multipier method
     =VFX_MPCTYPE_AUGMENT         Augmented Lagrange multipier method
     =VFX_MPCTYPE_TRANSFORM       Matrix transformation method.
    

void vfx_ProSolveGetParami(vfx_ProSolve *p, Vint type, Vint *iparam)

get integer paramters

See vfx_ProSolveSetParami()

void vfx_ProSolveSetParamd(vfx_ProSolve *p, Vint ptype, Vdouble dparam)

set double precision paramters

Specify double precision parameters to control solution.

The parameter PROSOLVE_ITER_FTOL provides a tolerance to be used against the residual norm during an iterative solution. Defaults to 5.E-3.

The parameter PROSOLVE_ITER_UTOL provides a tolerance to be used against the solution increment norm during an iterative solution. Defaults to 5.E-7.

The parameter PROSOLVE_ITER_ETOL provides a tolerance to be used against the energy norm during an iterative solution. Defaults to 5.E-7.

Specify an overall cutoff factor at substructure levels using PROSOLVE_AMLS_CUTFACT1. The frequencies at each substructure level are truncated at this factor times the upper frequency limit of requested spectrum. This value will affect the accuracy of all modes. Suggest specified values be no larger than 10. By default PROSOLVE_AMLS_CUTFACT1 is 5.

Specify a reduced cutoff factor using PROSOLVE_AMLS_CUTFACT2. Higher values will have a tendency to increase the accuracy of higher modes. By default PROSOLVE_AMLS_CUTFACT2 is 1.7 Suggest specified values be no larger than 2.5. Note that 1. < PROSOLVE_AMLS_CUTFACT2 < PROSOLVE_AMLS_CUTFACT1.

Specify a factorization singularity tolerance using PROSOLVE_FACTOR_SINGTOL. If automatic singularity detection is enabled, and a singularity is encountered then the reduced pivot is replaced by the value given by the parameter PROSOLVE_FACTOR_SINGPEN multiplied by the pivot’s value before reduction. This procedure is equivalent to introducing a penalty parameter that multiplies the matrix diagonal in order to enforce a constraint. Users should exert care in using this procedure, especially if there is a load applied in the direction of the singularity, or if the system is indefinite. By default PROSOLVE_FACTOR_SINGTOL is 1.E-14 and PROSOLVE_FACTOR_SINGPEN is 1.e+5.

Get dparam as an output argument using

void vfx_ProSolveGetParamd (vfx_ProSolve *prosolve,
                            Vint ptype,
                            Vdouble *dparam)

Errors

VIS_ERROR_ENUM is generated if an improper ptype is specified.

Parameters
  • p – Pointer to ProSolve object.

  • ptype – Type of solution parameter to set

    x=PROSOLVE_ITER_FTOL      Iterative solver force tolerance 
     =PROSOLVE_ITER_UTOL      Iterative solver solution tolerance
     =PROSOLVE_ITER_ETOL      Iterative solver energy tolerance
     =PROSOLVE_AMLS_CUTFACT1  Overall frequency cutoff factor
     =PROSOLVE_AMLS_CUTFACT2  Reduced frequency cutoff factor
     =PROSOLVE_FACTOR_SINGPEN Factor singularity penalty
     =PROSOLVE_FACTOR_SINGTOL Factor singularity tolerance
    

  • dparam – Specifies the double precision value that ptype will be set to.

void vfx_ProSolveGetParamd(vfx_ProSolve *p, Vint type, Vdouble *dparam)

get double precision paramters

See vfx_ProSolveSetParamd()

void vfx_ProSolveSetParamc(vfx_ProSolve *p, Vint ptype, Vchar *cparam)

set character paramters

Specify character parameters to control solution.

The parameter PROSOLVE_OUTFILE specifies the pathname for the output file. By default PROSOLVE_OUTFILE is vki.out.

The parameter PROSOLVE_ORIGCODE specifies the solver name to be used for output etc. By default PROSOLVE_ORIGCODE is VKI ProSolve().

The parameter PROSOLVE_VERSION specifies the solver version to be used for output etc. By default PROSOLVE_ORIGVERSION is the current DevTools release number.

The parameter PROSOLVE_EIGEN_FILE specifies the pathname for the out of core eigenvector file. By default PROSOLVE_EIGEN_FILE is vki.eoc.

The parameters PROSOLVE_KFACTOR_FILE and PROSOLVE_MFACTOR_FILE specify the pathnames for the out of core stiffness and mass factorization files respectively. These files are created only if the out of core direct or iterative solver or AMLS eigensolver are used. By default PROSOLVE_KFACTOR_FILE is vki.foc and PROSOLVE_MFACTOR_FILE is vki.moc. The out of core mass factor is only generated by AMLS.

The parameter PROSOLVE_RESFILE specifies the pathname for the results file. By default PROSOLVE_RESFILE is vki.vdm.

Get cparam as an output argument using

void vfx_ProSolveGetParamc (vfx_ProSolve *prosolve,
                            Vint ptype,
                            Vchar *cparam)

Errors

VIS_ERROR_ENUM is generated if an improper ptype is specified.

Parameters
  • p – Pointer to ProSolve object.

  • ptype – Type of solution parameter to set

    x=PROSOLVE_OUTFILE       Pathname for output file
     =PROSOLVE_ORIGCODE      Originating solver name
     =PROSOLVE_ORIGVERSION   Originating solver version
     =PROSOLVE_EIGEN_FILE    Pathname out of core eigenvector file
     =PROSOLVE_KFACTOR_FILE  Pathname out of core stiffness factor file
     =PROSOLVE_MFACTOR_FILE  Pathname out of core mass factor file
     =PROSOLVE_RESFILE       Pathname result file
    

  • cparam – Specifies the character value that ptype will be set to.

void vfx_ProSolveGetParamc(vfx_ProSolve *p, Vint type, Vchar cparam[])

get character paramters

See vfx_ProSolveSetParamc()

void vfx_ProSolveSetFunction(vfx_ProSolve *p, Vint funtype, VProSolvefunc *function, Vobject *object)

set callback functions

Set callback functions. By default the display callback is NULL. A callback is not invoked if it is NULL. The callback function is called with two arguments, the first is the ProSolve object, p, and the second is the user defined object, object.

Parameters
  • p – Pointer to ProSolve object.

  • funtype – Type of callback function to set

    x=PROSOLVE_FUN_MONITOR     Monitor callback
    

  • function – Pointer to callback function

  • object – Pointer to the object to be returned as function argument

void vfx_ProSolveGetInteger(vfx_ProSolve *p, Vint type, Vint *iparam)

get integer solution information

Query for integer solution information. This function may be called during (from within a monitor function) or after a call to vfx_ProSolveExec(). It is useful for determining where errors in the solution procedure occurred or information pertaining to the current state of the solution process.

Possible returned phase values are:

SYS_PHASE_MASS        Mass matrix formation
SYS_PHASE_SYMFACTOR   Symbolic factorization
SYS_PHASE_INITCOND    Initial conditions
SYS_PHASE_PREDICTOR   Solution predictor
SYS_PHASE_STIFF       Stiffness matrix formation
SYS_PHASE_FACTOR      Stiffness matrix factorization
SYS_PHASE_UPDATE      Solution vector update
SYS_PHASE_REACT       Reaction vector formation
SYS_PHASE_REACTSTIFF  Reaction vector and stiffness matrix formation
SYS_PHASE_SOLVE       Solution vector solve
SYS_PHASE_GEOMSTIFF   Geometric stiffness matrix formation
SYS_PHASE_BUCKLING    Buckling eigenvalue extraction
SYS_PHASE_VIBRATION   Vibration eigenvalue extraction
SYS_PHASE_OUTPUT      Results computation
The query type PROSOLVE_NUMMODES returns the number of computed modes for buckling, vibration, superelement and singularity analysis. For superelement analysis this includes all static, vibration and residual load modes.

The query type PROSOLVE_NUMSINGULAR returns the number of singularities in a singularity analysis.

Errors

VIS_ERROR_ENUM is generated if an improper type is specified.

Parameters
  • p – Pointer to ProSolve object.

  • type – Type of integer information to query

    x=PROSOLVE_ANALYSIS      Current analysis type
     =PROSOLVE_SOLUTION      Current solution type
     =PROSOLVE_PHASE         Current solution phase
     =PROSOLVE_CASE          Current solution case
     =PROSOLVE_NUMHIST       Number histories SPROP_HISTFILE_NUM
     =PROSOLVE_NUMRES        Number results SPROP_RESFILE_NUM.
     =PROSOLVE_NUMMODES      Number of modes computed.
     =PROSOLVE_STEP          Current solution step
     =PROSOLVE_PERCENTDONE   Current percent of solution completed
     =PROSOLVE_NUMSINGULAR   Number of singularities
    

  • iparam[out] Returned integer information

void vfx_ProSolveGetLong(vfx_ProSolve *p, Vint type, Vlong *lparam)

get long integer solution information

Query for long integer solution information. This function may be called during (from within a monitor function) or after a call to vfx_ProSolveExec().

Errors

VIS_ERROR_ENUM is generated if an improper type is specified.

Parameters
  • p – Pointer to ProSolve object.

  • type – Type of integer information to query

    x=PROSOLVE_ASSEM_NONZ    Number non-zeros in assembled matrix
     =PROSOLVE_FACTOR_NONZ   Number non-zeros in factored matrix
    

  • lparam[out] Returned long integer information

void vfx_ProSolveGetDouble(vfx_ProSolve *p, Vint type, Vdouble *dparam)

get double precision solution information

Query for double precision solution information. This function may be called during (from within a monitor function) or after a call to vfx_ProSolveExec().

Errors

VIS_ERROR_ENUM is generated if an improper type is specified.

Parameters
  • p – Pointer to ProSolve object.

  • type – Type of integer information to query

    x=PROSOLVE_FACTOROPS     Number of FLOPS for factorization
     =PROSOLVE_SOLVEOPS      Number of FLOPS for solve
    

  • dparam[out] Returned double precision information

void vfx_ProSolveExec(vfx_ProSolve *p)

execute solution procedure

Execute the prescribed solution procedure. This function performs the finite element analysis defined by currently registered model object and is generally a computationally intensive operation. A subset of the solution procedures, List of SProp objects, contained in the Model object may be executed. A range of solution identifiers may be specified using vfx_ProSolveRange(). If a range of solution identifiers has not been defined using vfx_ProSolveRange() then all solution procedures are executed. Use vfx_ProSolveGetInteger() and vfx_ProSolveGetDouble() to query for detailed information about the solution process.

Parameters

p – Pointer to ProSolve object.

void vfx_ProSolveExecSProp(vfx_ProSolve *p, vis_SProp *sprop)

execute single solution

Execute the single prescribed solution procedure in the input sprop object. The list of solution procedures contained in the Model object are ignored.

Parameters
  • p – Pointer to ProSolve object.

  • sprop – Pointer to SProp object.

void vfx_ProSolveInit(vfx_ProSolve *p)

initialize solution procedure

Initialize solution procedure.

Parameters

p – Pointer to ProSolve object.

void vfx_ProSolveRange(vfx_ProSolve *p, Vint sid1, Vint sid2)

specify solution sequence range

Specify a solution sequence range to execute when vfx_ProSolveExec() is called. The solution sequence identifiers are the indices into the List of SProp objects registered in the Model object. A value of zero for sid1 and sid2 implies executing all SProp objects. By default sid1 = sid2 = 0.

Errors

SYS_ERROR_VALUE is generated if improper sid1 or sid2 are specified.

Parameters
  • p – Pointer to ProSolve object.

  • sid1 – Beginning solution sequence id

  • sid2 – Ending solution sequence id

void vfx_ProSolveAbort(vfx_ProSolve *p)

set abort flag

Set solution abort flag. During the solution process in vfx_ProSolveExec() this flag is intermittently checked. If it has been set, the solution process terminates and returns. The abort flag is usually set in the user defined callback function specified by vfx_ProSolveAbort().

Parameters

p – Pointer to ProSolve object.

void vfx_ProSolveRedMat(vfx_ProSolve *p, vis_RProp *rprop, vis_RedMat *redmat)

get reduced matrices

Request computed reduced matrix and vector data to be loaded into a RedMat object. The reduced stiffness and mass matrix will be available for query as a result of a superelement generation. Any specified load vectors are reduced and are also available. They should be queried during or after the output phase. If superelement generation is the last solution case processed by a call to vfx_ProSolveExec(), then the matrices and vectors may be queried after the call to vfx_ProSolveExec() returns. Possible output result types are the following:

Reduced Matrix

SYS_RES_K_MAT
SYS_RES_M_MAT
SYS_RES_L_VEC
SYS_RES_COND_MAT
SYS_RES_CAP_MAT
Whole Model
SYS_RES_X, SYS_QUA_CG

Errors

SYS_ERROR_OPERATION is generated if an improper rprop is input.

Parameters
  • p – Pointer to ProSolve object.

  • rprop – Pointer to RProp object specifying result information

  • redmat – Pointer to RedMat solution object.

void vfx_ProSolveSysMatrix(vfx_ProSolve *p, vis_RProp *rprop, vfs_SysMatrix *sysmatrix)

get reduced matrices in SysMatrix.

Request computed reduced matrix data to be loaded into a SysMatrix object. The reduced stiffness and mass matrix will be available for query as a result of a superelement generation. They should be queried during or after the output phase. If superelement generation is the last solution case processed by a call to vfx_ProSolveExec(), then the matrices and vectors may be queried after the call to vfx_ProSolveExec() returns. Possible output result types are the following:

SYS_RES_K_MAT
SYS_RES_M_MAT
Errors

SYS_ERROR_OPERATION is generated if an improper rprop is input.

Parameters
  • p – Pointer to ProSolve object.

  • rprop – Pointer to RProp object specifying result information

  • sysmatrix – Pointer to SysMatrix object.

void vfx_ProSolveState(vfx_ProSolve *p, vis_RProp *rprop, vis_State *state)

get solution states

Request computed results data to be loaded into a state object. The type of results requested is specified by the rprop object. The input rprop object should contain the entity type and child type specified using vis_RPropDef(), and the result type specified using vis_RPropSetType(). If specific shell or beam element results at a section point are required, then the section point number must be specified using vis_RPropSetSect(). The input state object should have a GridFun object registered. Possible output result types are the following:

Node, degree of freedom based

SYS_RES_D
SYS_RES_V
SYS_RES_A
SYS_RES_TEMP
SYS_RES_XF
SYS_RES_XF_HEAT_FLOW
SYS_RES_R
SYS_RES_R_HEAT_FLOW
SYS_RES_MASS
Element based
SYS_RES_S
SYS_RES_E
SYS_RES_SD
SYS_RES_SE
SYS_RES_SE_DENSITY
SYS_RES_SE_ERROR 
SYS_RES_SF
SYS_RES_TE
SYS_RES_TE_DENSITY
SYS_RES_TE_ERROR
SYS_RES_TEMP_GRAD
SYS_RES_HEAT_FLOW
Mode based
SYS_RES_FACTOR, SYS_QUA_PARTICIPATION
SYS_RES_FREQ
Upon return, the rprop object will have the result identifiers and mode set. Any global variables such as Contents, DataType, Frequency, Time, etc will also be set. The state object will have the result entity type and child types defined and the requested results data set. It will also have the system set.

Errors

SYS_ERROR_ENUM is generated if rprop contains improper result information.

Parameters
  • p – Pointer to ProSolve object.

  • rprop – Pointer to RProp object specifying result information

  • state – Pointer to State object to receive result data

void vfx_ProSolveFillResRProp(vfx_ProSolve *p, Vint index, vis_RProp *rprop, Vint *objecttype, Vint *flag)

fill result RProp

Query for objecttype and fill RProp object given a result index. The result index ranges from 1 to the number of results requested in the input SProp object and also returned by the parameter PROSOLVE_NUMRES in the call to vfx_ProSolveGetInteger(). The returned flag is used to indicate whether the requested result is available at this point in the results output processing. Use the returned objecttype to determine whether the result is to be returned in a State object using vfx_ProSolveState() or a RedMat object using vfx_ProSolveRedMat(). Alternatively, a reduced matrix result may be returned as a SysMatrix using vfx_ProSolveSysMatrix().

Errors

VIS_ERROR_VALUE is generated if an improper index is specified.

Parameters
  • p – Pointer to ProSolve object.

  • index – Result index >= 1

  • rprop[out] The RProp object to fill

  • objecttype[out] The object type identifier

    x=VIS_STATE              State object
     =VIS_REDMAT             RedMat object
    

  • flag[out] Result available flag

    x=SYS_ON                 Available
     =SYS_OFF                Not available
    

void vfx_ProSolveFillHistRProp(vfx_ProSolve *p, Vint index, vis_RProp *rprop, Vint *flag)

fill history RProp

Fill RProp object given a history index. The history index ranges from 1 to the number of histories requested in the input SProp object and also returned by the parameter PROSOLVE_NUMHIST in the call to vfx_ProSolveGetInteger(). The returned flag is used to indicate whether the requested history is available at this point in the output processing. A History object is returned using vfx_ProSolveHistory().

Errors

VIS_ERROR_VALUE is generated if an improper index is specified.

Parameters
  • p – Pointer to ProSolve object.

  • index – History index >= 1

  • rprop[out] The RProp object to fill

  • flag[out] History available flag

    x=SYS_ON                 Available
     =SYS_OFF                Not available
    

void vfx_ProSolveSetNumThreads(vfx_ProSolve *p, Vint num)

set number of threads

Set the number of threads used for parallel execution of ProSolve functions. If num is 0, then ProSolve functions are run serially. If num is greater than or equal to 1 then num threads are used for parallel execution.

Errors

SYS_ERROR_VALUE is generated if num is less than 0.

Parameters
  • p – Pointer to ProSolve object.

  • num – Number of threads

    x=0                   Default, serial execution.
     >=1                  Number of threads for parallel execution