Background

The Run-Analysis defines some Global variables that cannot be modified. These variables are listed as follow:

Variable	Description
`rank`	The processor number defined at Definitions::rank
`size`	The number of partitions defined at Definitions::size
`nDimensions`	The problem dimension (1D, 2D, 3D) defined at Definitions::nDimensions
`filePath`	The folder path where the file is loaded defined at Definitions::filePath
`fileName`	The file name to be loaded defined at Definitions::fileName
`driverFile`	Whether the driver (JSON) file is provided defined at Definitions::driverFile
`UpdateOption`	The update option for member in Mesh defined at Definitions::UpdateOption
`MassFormulation`	The element mass formulation defined at Definitions::MassFormulation
`LumpedStorage`	Maximum memory for lumped storage sparse matrix defined at Definitions::LumpedStorage
`ConsistentStorage`	Maximum memory for consistent storage sparse matrix defined at Definitions::ConsistentStorage
`numberOfFreeDofs`	Total number of free-degree-of-freedom defined at Definitions::numberOfFreeDofs
`numberOfTotalDofs`	Total number of total-degree-of-freedom defined at Definitions::numberOfTotalDofs
`numberOfConstrainedDofs`	Total number of constrained-degree-of-freedom defined at Definitions::numberOfConstrainedDofs
`PMLStorage`	Maximum memory for PML 3D storage sparse matrix defined at Definitions::PMLStorage

In particular, the UpdateOption specifies how the internal variables are going to be updated in the Run-Analysis. Currently, there are three options:

Restartable : The internal variables in Node, Material, Section, and Element are set back to zero for next analysis. If UpdateOption is the default option if not specified. This otion is useful when a totally new analysis is expected.
Progressive : The internal variables in Node, Material, Section, and Element are kept for the next analysis. This option is useful when a stage analysis is desired and boundary condition remains unchanged. Please refer to
- 03-Validations/01-Debugging/P01-ST_DY_Lin_1D_Progressive_Mass_Elastic_ZeroLength
- 03-Validations/01-Debugging/P02-ST_kin_2D_Progressive_Moment_Elastic_Frame2
Transmissive : The internal variables in Node, Material, Section, and Element are kept for the next analysis. This option is useful when modeling unbounded domains using a non-reflecting boundary. Please refer to
- 03-Validations/02-Performance/P03-DY-Lin_2D_Transmissive_Half_Space_Quad4_PointLoad_PML
- 03-Validations/02-Performance/P05-DY-Lin_2D_Transmissive_Building_Frame2_Quad4_DRM_PML

The other variables are employed in order to allocate memory to create the mass, damping, stiffness and transformation matrices (enforce restrains and constraints) in the Assembler. These variables are computed during the Pre-Analysis, specifically at 01-Pre_Process/Core/Numberer.py functions FindDefectiveNodes and PlainScheme.

REFERENCE:

Forde, B. W. R., Foschi, R. O., & Stiemer, S. F. (1990). "Object-oriented finite element analysis". Computers & Structures, 34(3), 355–374.
Mackie, R. I. (1992). "Object oriented programming of the finite element method". International Journal for Numerical Methods in Engineering, 35(2), 425–436.

Pre-Analysis

Global properties are handled by two dictionaries: Entities and Options

The Entities dictionary is defined at 01-Pre_Process/Core/Definitions.py and stores all information regarding the finite element simulation.

The Entities dictionary fields are defined below:

Nodes : Dictionary that stores all node information defined by the user. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Node.
Masses : Dictionary that stores all mass information defined by the user. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Mass.
Constraints : Dictionary that stores all constraints applied to a degree of freedom. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Constraint.
RigidLinks : Dictionary that stores rigid link information defined by the user. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Constraint.
Diaphragms : Dictionary that stores rigid diaphragm information defined by the user. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Constraint.
RigidBodies : Dictionary that stores rigid body information defined by the user. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Constraint.
Supports : Dictionary that stores all support motions applied to a certain fixed degree of freedom. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Support Motion.
Fibers : Dictionary that stores all fiber information (fiber sections). The dictionary is transformed into json format with the structure specified in linkFiber.
Materials : Dictionary that stores all material information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Material.
Sections : Dictionary that stores all section information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Section.
Elements : Dictionary that stores all element information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Element.
Surfaces : Dictionary that stores all surfaces information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Surface.
Dampings : Dictionary that stores all damping information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Damping.
Combinations : Dictionary that stores the combination information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in LoadCombo.
Recorders : Dictionary that stores the recorder information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Recorder.
Solvers : Dictionary that stores the linear system information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Solver.
Algorithms : Dictionary that stores the algorithm information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Algorithm.
Integrators : Dictionary that stores the integrator information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Integrator.
Analyses : Dictionary that stores the analyses information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified in Analysis.
Simulations : Dictionary that stores the simulation information. The dictionary is transformed into json format to be used in the Run-Analysis with the structure specified as follows:
- analysis : The analysis identifier (Tag) to be used
- algorithm : The algorithm identifier (Tag) to be used
- integrator : The integrator identifier (Tag) to be used
- solver : The solver identifier (Tag) to be used
Example

The nodes in Entities defined in SVL can be accesses as:
SVL.Entities['Nodes']

Application
Please refer to any file in 03-Validations/01-Debugging/ to see examples on how to modify the Entities fields.

Similarly, the dictionary Options is defined at 01-Pre_Process/Core/Definitions.py and stores all user's inputs or configuration.

The Options dictionary fields are defined below:

update : Specifies how the simulations are going to be executed, 'Restartable', 'Progressive', or 'Transmissive'.
numbering : The degree of freedom numbering scheme, these can be 'Plain', 'Cuthill-McKee', 'Minimum degree'
metispath : The path where the Metis program is located. Default is '/usr/bin/mpmetis' (Linux)
massform : The mass matrix formulation. These can be 'Consistent' or 'Lumped'
nparts : The number of partition to divide the finite element mesh
dimension : The model's dimension, this is 2 (2D) or 3 (3D)
nfree : The number of free degree of freedom (after restrain and constraint are applied) in the entire model.
ntotal : The total number of degree of freedom in the entire model.
nconstraint : The total number of constraint (rigid link, rigid body, diaphragm) in the entire model.
nlumped : The number of diagonal terms in the stiffness/mass matrix.
nconsistent : The number of sparse terms in the stiffness/mass matrix.

Example

The Options can be modified in SVL as:
SVL.Options['numbering'] = 'CutHill-McKee'
SVL.Options['dimension'] = 3
SVL.Options['update'] = 'Progressive'

Application
Please refer to any file located at 03-Validations/01-Debugging/ to see examples on how to modify the Options fields.

In addition, some useful functions are defined at 01-Pre_Process/Core/Utilities.py when using the Python command interface. For example,

clc():
This function clears the command line screen and prints the SVL header
cleanAll():
Sets all SVL dictionaries to its initial values. All pre-loaded data will be erased.
printAll(name):
Prints on the screen everything that is generated in a particular field (name) in Entities. See linkPythonDefinitions for some field names
saveAs(name):
This function saves in a python file all Entities defined so far in python command prompt

Example

The command line screen can be cleaned as:
SVL.clc()

Example

The nodes in Entities can be printed on the screen as:
SVL.printAll('Nodes')

Attention: The user can add or customize other functions inside these files that may find useful.
Please refer to SVL/01-Pre_Process/Core/Utilities.py for more details in declarations and implementation aspects; Please refer to SVL/01-Pre_Process/Core/Definitions.py for more details in declarations and implementation aspects; The SVLclasses dictionary stores the information of the material, section, and element classes available in SVL. The SolverOption dictionary has the available option of the solver, and ConvergeTest dictionary the available test that can be performed during the Newton-Raphson method.

Run-Analysis

The C++ 02-Run_Process/12-Utilities/Definitions.cpp file provides with the Global variable declarations. These variables are defined inside the "Global" JSON field indicating its property as follows,

{
    "Global": {
        "ndim" : int,
        "ntotal": int,
        "nfree" : int,
        "update" : str,
        "massform"  : str
    }
}

Variable	Description
`ndim`	Model's number of dimensions, for 2D `ndim=2` and for 3D `ndim=3`.
`ntotal`	Number that specifies the total number of degree of freedom in the mesh.
`nfree`	Number that specifies the free number of degree of freedom in the mesh. This is the total number of degree of freedom minus the restrained and the constrained degree of freedom.
`update`	Specifies how the internal variables in Node, Material, Section, and Element are going to be updated. currently `RESTARTABLE`, `PROGRESSIVE` , and `TRANSMISSIVE` are allowed.
`massform`	The mass matrix formulation, currently `LUMPED` , `CONSISTENT` are allowed.

Attention: Other global control parameters may be added in future for handling specific tasks.; The parameter ndim is extremely important and must be consistent with the Node, Element and Material employed in the analysis.

Example

A 3D GLOBAL environment is set with a total of 100 degree of freedom of which 80 are free as follows:
{ "Global": { "ndim" : 3, "ntotal" : 100, "nfree" : 80, "mass" : "CONSISTENT" } }