| ►NXC | ================================================================================ |
| CActor | |
| CActorMethod | |
| CActorPetscSOE | ?? |
| CActorSubdomain | |
| CAdkZhangMeritFunctionCheck | |
| CAggregatorAdditions | Pointers to UniaxialMaterial with the degree of freedom associated to each of them (used in SectionAggregator) |
| CAlgorithmIncrements | AlgorithmIncrements will display the X and B in the SOE associated with the algorithm on a record |
| CAlphaBaseMachineBroker | DEC Alpha machine broker? |
| CAlphaMachineBroker | |
| CAlphaOS | AlphaOS is an algorithmic class for performing a transient analysis using the Alpha-Operator-Splitting integration scheme. The parameter alpha corresponds to 1+alpha_{HHT} |
| CAlphaOSBase | AlphaOSBase is an algorithmic class for performing a transient analysis using the Alpha-Operator-Splitting integration scheme. The parameter alpha corresponds to 1+alpha_{HHT} |
| CAlphaOSGeneralized | AlphaOSGeneralized is an algorithmic class for performing a transient analysis using the generalized Alpha-Operator-Splitting integration scheme. The parameters alpha correspond to 1+alpha_{HHT} |
| CAnalysis | Clase Base para los objetos que realizan the analysis |
| CAnalysisModel | Los objetos de esta clase, dan acceso a los objetos FE_Element y DOF_Group creados por el Constraint Handler |
| CArcLength | ArcLength is an algorithmic class for perfroming a static analysis using the arc length scheme |
| CArcLength1 | ArcLength1 is an algorithmic class for perfroming a static analysis using the arc length scheme |
| CArcLengthBase | Base class for the arc-length integrators family |
| CArcoCircunf | Circumference arc |
| CArmijoStepSizeRule | |
| CArpackSOE | Arpack++ based system of equations |
| CArrayCommMetaData | Data about the position, size, ... of the array to transmit |
| CArrayGraph | Array de grafos |
| CArrayOfTaggedObjects | ArrayOfTaggedObjects is a storage class. The class is responsible for holding and providing access to objects of type TaggedObject. The data structure used to hold the objects is a simple array of pointers. As a one dimensional array is used certain ideas are tried to improve performance: (1) if the array needs to be larger to hold more components, the array size is doubled and (2) when adding/retrieving components, the array location given by the components tag is first checked |
| CArrayOfTaggedObjectsIter | |
| CArrayVertexIter | ArrayVertexIter is an iter for returning the vertices of an object of class ArrayGraph. ArrayVertexIter must be written for each subclass of ArrayGraph: wherin the vertices are stored differently to that in ArrayGraph |
| CAttalla2D | Atalla 2D yield surface |
| CAuxMatrix | |
| CBandArpackppSOE | Arpack++ based band matrix eigenvalue SOE solver |
| CBandArpackppSolver | Arpack++ based band matrix eigenproblem solver |
| CBandArpackSOE | BandArpackSOE is a subclass of ArpackSOE. It uses the LAPACK storage scheme to store the components of the K, M matrix, which is a full matrix. It uses the Arpack to do eigenvalue analysis |
| CBandArpackSolver | Arpack solver for banded matrices. The ARnoldi PACKage, is a numerical software library written in FORTRAN 77 for solving large scale eigenvalue problems |
| CBandGenLinLapackSolver | Lapack based band general matrix SOE solver |
| CBandGenLinSOE | Uses the LAPACK storage scheme to store the components of the A matrix, which is a banded unsymmetric matrix |
| CBandGenLinSolver | Base class for band general linear SOE solvers |
| CBandSPDLinLapackSolver | Lapack based band matrix linear SOE solver |
| CBandSPDLinSOE | Base class for band matrix system of equations |
| CBandSPDLinSolver | Solver for band matrix linear systems of equations |
| CBandSPDLinThreadSolver | Solves the BandSPDLinSOE in parallel using solaris threads |
| CBarSlipMaterial | The file generates the 4 point envelope for both positive and negative loading and is basically a wrapper for the Pinching4 material at it's outset |
| CBaseControl | Base class for load and displacement control static integrators |
| CBaseElasticSection | Base class for cross sections with linear elastic material |
| CBaseElasticSection2d | Base class for cross sections with linear elastic material on a bi-dimensional problem (3 DOFs on each section) |
| CBaseElasticSection3d | Base class for cross sections with linear elastic material on a three-dimensional problem (6 DOFs on each section) |
| CBaseNumberer | Base class for DOF numberers |
| CBasicGFunEvaluator | |
| CBbarBrick | Hexaedro |
| Cbeam2d | 2D beam element |
| Cbeam2d02 | 2D beam 02 element |
| Cbeam2d03 | 2D 03 beam element |
| Cbeam2d04 | 2D beam element 04 |
| CBeam2dPointLoad | Punctual load over 2D beam elements |
| CBeam2dUniformLoad | Uniform load over 2D beam elements |
| Cbeam3d01 | 01 3D beam element |
| Cbeam3d02 | 02 3D bar element |
| Cbeam3dBase | Base class for 3D beam elements |
| CBeam3dPointLoad | Punctual load over 3D beams |
| CBeam3dUniformLoad | Uniform load over 3D beams |
| CBeamColumnJoint2d | 2D beam column joint |
| CBeamColumnJoint3d | 3D beam-column joint element |
| CBeamColumnJointPhysicalProperties | Physical properties for shells |
| CBeamColumnWithSectionFD | Beam-column element with SeccionBarraPrismatica material |
| CBeamColumnWithSectionFDTrf2d | 2D beam element with SectionForceDeformation type material |
| CBeamColumnWithSectionFDTrf3d | 3D beam colun element with SeccionBarraPrismatica material type |
| CBeamFiberMaterial | BeamFiberMaterial class is a wrapper class that performs static condensation on a three-dimensional material model to give the 11, 12, and 13 stress components which can then be integrated over an area to model a shear flexible 3D beam |
| CBeamIntegration | Base class for integration on beam elements |
| CBeamIntegratorLoader | Beam integrators handler |
| CBeamLoad | Load over beam elements |
| CBeamMecLoad | Mechanical loads (forces) over beam elements |
| CBeamPointLoad | Punctual load over beam elements |
| CBeamStrainLoad | Load due to restricted material expansion or contraction on beam elements |
| CBeamUniformLoad | Uniform load over beam elements |
| CBeamWithHinges2d | 2D beam with hinges in both ends |
| CBeamWithHinges3d | 3D beam with hinges in both ends |
| CBerkeleyDbDatastore | |
| CBetaRV | |
| CBFBRoydenBase | ?? |
| CBFGS | ?? |
| CBidimLoad | Load over bidimensional elements |
| CBidimMecLoad | Mechanical load (forces) over bidimensional elements |
| CBidimStrainLoad | Load due to restricted material expansion or contraction on bidimensional elements |
| CBidirectional | ?? |
| CBilinear | ?? |
| CBilinearCyclic | ?? |
| CBisectionLineSearch | Bisection line search solution algorithm |
| CBJmatrix | |
| CBJtensor | |
| CBJvector | |
| CBkStressLimSurface2D | ?? |
| CBlock | Six-faced body |
| ►CBody | Six-faced solid |
| CBodyFace | Surface that limits the body (face as seen by the body) |
| CBodyForces | Body forces over an element |
| CBodyForces2D | Body forces over an element |
| CBodyForces3D | Body forces over an element |
| CBoucWenMaterial | ?? |
| CBoundingSurface2D | Bounding 2D yield surface |
| CBrick | Hexaedro de ocho nodos |
| CBrickBase | Base class for hexahedra |
| CBrickSelfWeight | Hexahedron self weight |
| CBrickUP | Hexaedro de ocho nodos |
| CBrokedPtrCommMetaData | Data to transmit for a pointer «broked» |
| CBroyden | Algoritmo de Broyden |
| CCableMaterial | CableMaterial provides the abstraction of an elastic uniaxial material, the input parameters are the Prestress, E, Effective Self Weight (gravity component of Weight per volume transverse to the cable), and Length of the cable |
| CCad | Model geometry manager. Management of geometry entities: points, lines, surfaces, bodies, etc |
| CCAMPotentialSurface | ?? |
| CCAMYieldSurface | ?? |
| CCell | Base class for cells (cross-section discretization) |
| CCentralDifference | CentralDifference is an algorithmic class for performing a transient analysis using the central difference integration scheme |
| CCentralDifferenceAlternative | CentralDifferenceAlternative is an algorithmic class for performing a transient analysis using the alternative form of the Central Differenceintegration scheme, which is an explicit direct integration scheme as outlined in the book 'Concepts and Applications of Finite Element Analysis' by Cook, Malkus & Plesha |
| CCentralDifferenceBase | Approximates velocity and acceleration by centered finite differences of displacement |
| CCentralDifferenceNoDamping | CentralDifferenceNoDamping is an algorithmic class for performing a transient analysis using the Central Difference Scheme as implemented in Dyna |
| CCFactorSeries | Base class for constant factor time series |
| CChannel | Channel is an abstract base class which defines the channel interface. A channel is a point of communication in a program, a mailbox to/from which data enters/leaves a program |
| CChannelAddress | |
| CChannelQueue | Data about the postion, size,... of the object to transmit |
| CChiSquareRV | |
| CCircReinfLayer | Capa de armaduras en forma de arco de circulo |
| CClosedTriangleMesh | @ingroup MATSCCDiagInt |
| CClough | ?? |
| CCloughDamage | ?? |
| ►CCmbEdge | Compound line |
| CLado | Component of a compound line |
| CCollocation | Collocation is an algorithmic class for performing a transient analysis using the Collocation integration scheme |
| CCollocationHybridSimulation | CollocationHybridSimulation is an algorithmic class for performing a transient analysis using the CollocationHybridSimulation integration scheme |
| CCombinedIsoKin2D01 | ?? |
| CCombinedIsoKin2D02 | Kinematic model is based on back-stress Isotropic model on plastic-deformations This one is also deformable |
| CCommMetaData | Data about the index, size,,... of the object to transmit |
| CCommParameters | Communication parameters between processes |
| CCompositeSimpsonBeamIntegration | Composite Simpson integration scheme |
| CComputePivots | Given a bending plane, computes the "pivots" position on the section |
| CConc02HistoryVars | Concrete02 history variables |
| CConcrete01 | Uniaxial Kent-Scott-Park concrete model with linear unloading/reloading according to the work of Karsan-Jirsa and no strength in tension. The model contains a compressive strength of fpc, a strain at the compressive strength of epsc0, a crushing strength of fpcu, and a strain at the crushing strength of epscu. Compressive concrete parameters should be input as negative numeric values for this model to behave properly. Specification of minimum and maximum failure strains through the -min and -max switches is optional. The argument matTag is used to uniquely identify the material object among material objects in the BasicBuilder object |
| CConcrete02 | Uniaxial model for concrete with tensile strength and tension softenint. Reference: Mohd Hisham Mohd Yassin, "Nonlinear Analysis of Prestressed Concrete Structures under Monotonic and Cycling Loads", PhD dissertation, University of California, Berkeley, 1994 |
| CConcrete04 | Uniaxial Popovics concrete material object with degraded linear unloading/reloading stiffness according to the work of Karsan-Jirsa and tensile strength with exponential decay |
| CConcreteBase | Base class for concrete materials |
| CConjugateGradientSolver | Base class for conjugate gradient linear SOE solvers |
| CConnectedMaterial | Connected uniaxial materials (parallel or serial) |
| CConsoleErrorHandler | |
| CConstantModulatingFunction | |
| CConstantPressureVolumeQuad | ?? |
| CConstantSeries | Constant function over time |
| CConstraint | Base class for model constraints |
| CConstraintHandler | ConstraintHandlers enforce the single and multi freedom constraints that exist in the domain by creating the appropriate FE_Element and DOF_Group objects |
| CConstraintLoader | Constraint cration tools |
| CConstrContainer | Constraint (essential and natural boundary conditions) container |
| CContinuaReprComponent | Base class for components used to represent the material (continuum) |
| CConvergenceTest | Convergence test |
| CConvergenceTestNorm | Convergence test that uses vector norm value (solution vector,...) |
| CConvergenceTestTol | Convergence test with tolerance threshold |
| CCorotCrdTransf2d | Coordinate transformation corrotacional en 3d |
| CCorotCrdTransf3d | Coordinate transformation corrotacional en 3d |
| CCorotShellMITC4 | MIT C4 shell element |
| CCorotTruss | Truss element with corotational formulation. A small strain, large displacement corotational space truss element, as described by Crisfield in "Nonlinear Finite Element Analysis of
Solids and Structures", Vol. 1, 1991, J.T. Wiley |
| CCorotTrussBase | Base class for corotational truss elements |
| CCorotTrussSection | Truss element with corotatinal formulation and material of type SectionForceDeformation. Small strain, large displacement corotational space truss element, as described by Crisfield in "Nonlinear Finite Element Analysis of
Solids and Structures", Vol. 1, 1991, J.T. Wiley |
| CCorrelationCoefficient | |
| CCosseratstraintensor | |
| CCosseratstresstensor | |
| CCoulombFriction | |
| CCrdTransf | CrdTransf provides the abstraction of a frame coordinate transformation. It is an abstract base class and thus no objects of it's type can be instatiated. It has pure virtual functions which must be implemented in it's derived classes |
| CCrdTransf2d | Base class for 2D coordinate transformation |
| CCrdTransf3d | Base class for 3D coordinate transformation |
| CCriteriaReductionMeritFunctionCheck | |
| CCrossSectionProperties2d | Mechanical properties of a cross section (area, moments of inertia,...) for a bi-dimensional problem (three DOB for each section) |
| CCrossSectionProperties3d | Mechanical properties of a section (area, moments of inertia,...) in a three-dimensional problem (six degrees of freedom on each section) |
| CCStdLibRandGenerator | |
| CCTestEnergyIncr | Specifies a tolerance for the product of unbalanced load vector and 0.5 times the displacement increment vector (energy increment) to be used as convergence criterion on each iteration |
| CCTestFixedNumIter | This object performs a fixed number of iterations without testing for convergence. This test is useful for hybrid simulation where the residual error is corrected for |
| CCTestNormDispIncr | Specifies a tolerace for the displacement increment norm to be used on each iteration |
| CCTestNormUnbalance | Specifies a tolerance for the norm of the unbalanced load vector on each iteration |
| CCTestRelativeEnergyIncr | Tests for convergence using the ratio of the current norm to the initial norm (the norm when start is invoked) of the which is 0.5 times the absolute value of the product of the rhs and the solution vector of the LinearSOE |
| CCTestRelativeNormDispIncr | Tests for convergence using the ratio of the current norm to the initial norm (the norm when start is invoked) of the solution vector of the LinearSOE object passed in the constructor and a tolerance, set in the constructor |
| CCTestRelativeNormUnbalance | Convergence test tests for convergence using the ratio of the current norm to the initial norm (the norm when start is invoked) of the right hand side vector of the LinearSOE object passed in the constructor and a tolerance, set in the constructor |
| CCTestRelativeTotalNormDispIncr | Convergence test thats uses the quotient of current and initial norms of the solution vector |
| CCurvaturesBySearchAlgorithm | |
| CCyclicModel | ?? |
| CDamageModel | |
| CDamageModelVector | Vector de pointers to damage models. se emplea en Joint2D |
| CDamageRecorder | Used to obtain a response from an element section/material during the analysis and apply the information to the damage model and record the damage index |
| CDamageResponse | |
| CDampingFactorsIntegrator | ?? |
| CDataOutputDatabaseHandler | |
| CDataOutputFileHandler | |
| CDataOutputHandler | |
| CDataOutputStreamHandler | |
| CDatastoreRecorder | |
| CDBDatastore | |
| CDbTagData | Vector que almacena los dbTags de los miembros de la clase |
| CDecMachineBroker | Broker for DEC machines |
| CDefaultTag | Default tag |
| CDeformationPlane | Deformation plane for a cross-section |
| CDiagonalDirectSolver | Direct solver for diagonal matrix SOE |
| CDiagonalSOE | Diagonal matrix system of equations |
| CDiagonalSolver | Base class for diagonal matrix linear SOE solvers |
| CDirectIntegrationAnalysis | Direct integration dynamic analysis |
| CDiscretBase | Base class for cross-section discretization |
| CDiscretizedRandomProcessSeries | ?? |
| CDispBase | ?? |
| CDispBeamColumn2d | Displacement based 2D beam element with SeccionBarraPrismatica type material |
| CDispBeamColumn3d | 3D beam element with SeccionBarraPrismatica type material |
| CDisplacementControl | DisplacementControl is an algorithmic class for perfroming a static analysis using the arc length scheme, that is within a load step the follwing constraint is enforced: i=1 delta U^T delta U + alpha^2 delta lambda^2 = delta s^2 i>1 dU^T delta U + alpha^2 dLambda delta lambda = 0 where dU is change in nodal displacements for step, dLambda is change in applied load and DisplacementControl is a control parameter |
| CDistHingeIntegration | ?? |
| CDistributedBandGenLinSOE | Base class for band general matrix distributed systems of equations |
| CDistributedBandLinSOE | Base class for band matrix distributed systems of equations |
| CDistributedBandSPDLinSOE | Base class for band matrix distributed systems of equations |
| CDistributedBase | Base class for distributed processing |
| CDistributedDiagonalSOE | Diagonal matrix distributed systems of equations |
| CDistributedDiagonalSolver | Base class for distributed (many processors) diagonal matrix linear SOE solvers |
| CDistributedDisplacementControl | ?? |
| CDistributedLinSOE | Base class for distributed systems of equations |
| CDistributedObj | Object distributed on many processes |
| CDistributedProfileSPDLinSOE | Profile matrix distributed systems of equations |
| CDistributedSparseGenColLinSOE | Sparse nonsymmetric matrix distributed system of equations |
| CDistributedSparseGenRowLinSOE | Sparse nonsymmetric matrix distributed systems of equations |
| CDistributedSparseGenRowLinSolver | Base class for distributed (many processors) sparse general matrix linear based SOE solver |
| CDistributedSuperLU | SuperLU based solver for distributed sparse matrix linear systems of equations. It uses Gaussian elimination with partial pivoting (GEPP). The columns of A may be preordered before factorization; the preordering for sparsity is completely separate from the factorization and a number of ordering schemes are provided |
| CDividedLine | Line segment between two points |
| CDOF_Graph | Degrees of freedom graph |
| CDOF_Group | A DOF_Group object is instantiated by the ConstraintHandler for every unconstrained node in the domain. The constrained nodes require specialised types of DOF_Group; which deal with the constraints. DOF_Group objects can handle 0 boundary constraints; if the eqn number of a DOF is less than START_EQN_NUM a value of 0.0 is set for disp, vel and accel when a setNode*(Vector &) is invoked |
| CDOF_GroupGraph | Degrees of freedom group |
| CDOF_GrpConstIter | Iterator over DEF groups |
| CDOF_GrpIter | Iterator over DOF groups |
| CDOF_Numberer | Base class for DOF numbererers |
| CDomain | Domain (mesh and boundary conditions) of the finite element model |
| CDomainComponent | Objeto que forma parte de un domain |
| CDomainDecompAlgo | Solution algorithm for domain decomposition |
| CDomainDecompositionAnalysis | Used when performing a domain decomposition analysis. It provides methods which can be invoked by a subdomain to perform the numerical computations required |
| CDomainPartitioner | |
| CDomainRecorderBase | Recording of domain information |
| CDomainSolver | Used to solve a system of equations and to do static condensation operations on the linear system of equations |
| CDomainUser | ?? |
| CdoubleData | |
| CDPPotentialSurface | ?? |
| CDPYieldSurface | ?? |
| CDPYieldSurface01 | ?? |
| CDqFibras | Contenedor de fibras |
| CDqGroundMotions | Contenedor de definiciones de sismo |
| CDqMatrices | |
| CDqMeshRegion | Vector de celdas |
| CDqPtrs | Pointer to (nodes, elements, points, lines,...) container |
| CDqPtrsConstraint | Constraint pointers deque |
| CDqPtrsElem | Pointer to element container |
| CDqPtrsNmb | |
| CDqPtrsNode | Contenedor de pointers to nodes |
| CDqUniaxialMaterial | Contenedor de pointers to UniaxialMaterial |
| CDqVectors | |
| CDrainBilinearMaterial | ?? |
| CDrainClough1Material | ?? |
| CDrainClough2Material | ?? |
| CDrainHardeningMaterial | ?? |
| CDrainMaterial | ?? |
| CDrainPinch1Material | ?? |
| CDriftRecorder | Records relative displacement between nodes. The drift is taken as the ratio between the prescribed relative displacement and the specified distance between the nodes |
| CDruckerPrager | Drucker-Prager material |
| CDruckerPrager3D | Drucker-Prager 3D material |
| CDruckerPragerPlaneStrain | Drucker-Prager plane strain material |
| CDummyNode | DummyNodes are a type of node created and used by Subdomains for their exterior nodes. They reference a real node and most methods invoked on them are in turn invoked by the dummy node on the real node. The calls asking the real node to change its current state are ignored. The calls involving DOF_Group are handled by the dummy node |
| CEarthquakePattern | Earthquake load pattern |
| CEdge | Base class for one-dimensional geometry objects |
| CEigenAlgorithm | Solution algorithm for eigenproblem |
| CEigenAnalysis | Eigenproblem analysis |
| CEigenIntegrator | Base class for eigenproblem integrators |
| CEigenSOE | Base class for eigenproblem systems of equations |
| CEigenSolver | Eigenvalue SOE solver |
| CEightNodeBrick | Hexaedro de ocho nodos |
| CEightNodeBrick_u_p_U | Hexaedro de ocho nodos |
| CEje | Base class for 1D entities in section definition |
| CElastic2dGNL | Elastic2dGNL is a subclass of UpdatedLagrangianBeam2D, that can be |
| CElasticBaseMaterial | Base class for uniaxial elastic materials |
| CElasticBeam2d | 2D elastic beam element |
| CElasticBeam3d | 3D elastic beam element |
| CElasticCrossAnisotropic | Base class for elastic anisotropic materials |
| CElasticIsotropic2D | Isotropic elastic material for plane problems |
| CElasticIsotropic3D | Elastic isotropic material for 3D elements |
| CElasticIsotropicAxiSymm | Base class for elastic isotropic axisymmetric materials |
| CElasticIsotropicBeamFiber | Elastic isotropic material for beam fibers |
| CElasticIsotropicMaterial | Base class for elastic isotropic materials |
| CElasticIsotropicPlaneStrain2D | Elastic isotropic material for plane deformation problems |
| CElasticIsotropicPlaneStress2D | Elastic isotropic material for plane stress problems |
| CElasticIsotropicPlateFiber | Elastic isotropic material for plate elements |
| CElasticMaterial | Linear elastic uniaxial material |
| CElasticMembranePlateSection | Elastic section for membrane/plate materials |
| CElasticPlateBase | Base class for elastic plate materials |
| CElasticPlateProto | ?? |
| CElasticPlateSection | Bidimensional elastic section for plate modellings |
| CElasticPPMaterial | Elastic perfectly plastic material |
| CElasticSection2d | Cross section with linear elastic material for bi-dimensional problesm (3 degrees of freedom in each section) |
| CElasticSection3d | Cross section with linear elastic material in three-dimensional problems (6 degrees of freedom in each section) |
| CElasticShearSection2d | Base clas for cross sections with linear elastic material with shear stiffness on a bi-dimensional space (3 DOF on each section) |
| CElasticShearSection3d | Base class for cross sections with linear elastic material and shear stiffness on a three-dimensional space (6 degrees of freedom in each section) |
| CElement | Base calass for the finite elements |
| ►CElement0D | Element of dimension 0 (both nodes have the same position) |
| CVxy | |
| CElement1D | Base class for one-dimensional elements (beam,truss,...) |
| CElementalLoad | Base class for loads over elements |
| CElementalLoadIter | Iterador sobre las elemental loads |
| CElementBase | Base class for finite element with pointer to nodes container |
| CElementBodyLoad | Base class for body loads over elements |
| CElementEdge | Element edge (TO DEPRECATE?? LP 7.02.2017) |
| CElementEdges | Element edge container |
| CElementIter | Iterator over an element container |
| ►CElementLoader | Element creation manager |
| CSeedElemLoader | |
| CElementPropRecorder | Objects to record element data at each commit |
| CElementPtrs | Pointers to the elements affected by the load |
| CElementRecorder | Recording of element response |
| CElementRecorderBase | Base class for the finite element response recorders |
| CElementResponse | |
| CElemFriccionBase | |
| CElemPlano | Base class for plane elements |
| CElemPos | Element position for KDTree building |
| CElemWithMaterial | Element with material |
| CElTawil2D | El Tawil 2D yield surface |
| CElTawil2DUnSym | Unsymmetric 2D El Tawil yield surface |
| CEncapsulatedMaterial | ?? |
| CEnhancedQuad | Four-node quadrilateral element, which uses a bilinear isoparametric formulation with enhanced strain modes |
| CEntGeomSection | Base class of section geometry representation classes |
| CENTMaterial | Elastic no traction material. ENTMaterial provides the abstraction of an elastic uniaxial material under compression i.e. stress = E*strain under tension however it exhbits the following stress = a*(tanh(strain*b)) tangent = a*(1-tanh(strain*b)*tanh(strain*b)); |
| CEntMdlr | Multiblock topology object (point, line, face, block,...) |
| CEntMdlrBase | Base class of the preprocessor objects |
| CEnvelopeData | |
| CEnvelopeElementRecorder | |
| CEnvelopeNodeRecorder | A EnvelopeRecorder is used to record the envelop of specified DOF responses at a collection of nodes over an analysis. (between commitTag of 0 and last commitTag) |
| CEPPBaseMaterial | Base class for elastic perfectly plastic materials |
| CEPPGapMaterial | Elastic perfectly plastic material with initial "gap". provides the abstraction of an elastic perfectly plastic (tension only) path dependent uniaxial material, with an initial gap offset (force-displacement units) For compression only behavior, enter negative gap and ep Damage can accumulate through specification of damage = 1 switch, otherwise damage = 0 |
| CEPState | 3 |
| CEQBasePattern | Earthquake load pattern |
| CEqualDOF | Impose the values of many degrees of freedom to be the same |
| CEquiSolnAlgo | EquiSolnAlgo is an abstract base class, i.e. no objects of it's type can be created. Its subclasses deifine the sequence of operations to be performed in the analysis by static equilibrium of a finite element model |
| CEquiSolnConvAlgo | EquiSolnConvAlgo is a class which performs a Newton-Raphson solution algorihm in solving the equations. No member functions are declared as virtual as it is not expected that this class will be subclassed |
| CErrorHandler | |
| CEsfBeamColumn3d | 3D beam column internal forces |
| CEvolutionLaw_L_Eeq | ?? |
| CEvolutionLaw_L_Eij | ?? |
| CEvolutionLaw_NL_Eeq | ?? |
| CEvolutionLaw_NL_Eij | ?? |
| CEvolutionLaw_NL_EijMD | ?? |
| CEvolutionLaw_NL_Ep | This is a nonlinear evolution law for the evoltion of a scalar variable po which depends on plastic volumetric strain i.e. dpo = (1+eo)po/(lamda-kappa)*de_p |
| CEvolutionLaw_S | ?? |
| CEvolutionLaw_T | ?? |
| CExponentialRV | |
| CExponReducing | XXX?? |
| CFace | Surface |
| CFactoredSOEBase | Base class for factored systems of equations |
| CFactorsConstraintHandler | Base class for penalty and Lagrange constraints handlers |
| CFatigueMaterial | FatigueMaterial wraps a UniaxialMaterial and imposes fatigue limits |
| CFDdecoupledElastic3D | ?? |
| CFDEPState | ?? |
| CfdEvolution_S | ?? |
| CfdEvolution_SLS | ?? |
| CfdEvolution_T | ?? |
| CfdEvolution_TL | ?? |
| CfdFlow | ?? |
| CfdFlowDP | ?? |
| CfdFlowVM | ?? |
| CfdYield | ?? |
| CfdYieldDP | ?? |
| CfdYieldVM | ?? |
| CFE_Datastore | |
| CFE_EleConstIter | Const iterator over the finite elements of the model |
| CFE_EleIter | Iterator over the finite element of the model |
| CFE_Element | Finite element as seen by analysis |
| CFE_VertexIter | Iterador over the vertices of the graph |
| CFeapMaterial | Base class for 2D and 3D FEAP materials |
| CFeapMaterial01 | Material FEAP 01 |
| CFeapMaterial02 | Material FEAP 02 |
| CFeapMaterial03 | Material FEAP 03 |
| CFedeasBond1Material | FedeasBond1Material wraps the FEDEAS 1d material subroutine Bond_1 |
| CFedeasBond2Material | FedeasBond2Material wraps the FEDEAS 1d material subroutine Bond_2 |
| CFedeasBondMaterial | FedeasBondMaterial wraps the FEDEAS 1d material subroutine Bond_1 |
| CFedeasConcr1Material | FedeasConcr1Material wraps the FEDEAS 1d material subroutine Concr_1 |
| CFedeasConcr2Material | FedeasConcr2Material wraps the FEDEAS 1d material subroutine Concr_2 |
| CFedeasConcr3Material | FedeasConcr3Material wraps the FEDEAS 1d material subroutine Concr_3 |
| CFedeasConcrMaterial | FedeasConcrMaterial wraps the FEDEAS 1d material subroutine Concr_1 |
| CFedeasHardeningMaterial | FedeasHardeningMaterial wraps the FEDEAS 1d material subroutine Hard_1 |
| CFedeasHyster1Material | FedeasConcr2Material wraps the FEDEAS 1d material subroutine Concr_2 |
| CFedeasHyster2Material | FedeasHyster2Material wraps the FEDEAS 1d material subroutine Hyster_2 |
| CFedeasMaterial | FedeasMaterial provides a FORTRAN interface for programming uniaxial material models, using the subroutine interface from the FEDEAS ML1D library, developed by F.C. Filippou |
| CFedeasSteel1Material | FedeasSteel1Material wraps the FEDEAS 1d material subroutine Steel_1 |
| CFedeasSteel2Material | FedeasSteel2Material wraps the FEDEAS 1d material subroutine Steel_2 |
| CfElement | Wrapper used to call fortran element subroutines from FEAP |
| CfElmt02 | Interface with FEAP elements |
| CfElmt05 | Interface with FEAP elements |
| CFEM_ObjectBroker | FEM_ObjectBroker is is an object broker class for the finite element method. All methods are virtual to allow for subclasses; which can be used by programmers when introducing new subclasses of the main objects |
| CFEM_ObjectBrokerAllClasses | The same as FEM_ObjectBroker? |
| CFiber | Section fiber |
| CFiberData | Fiber data |
| CFiberResponse | Recorder for fiber response |
| CFiberSection2d | Fiber section model in a bi-dimensional space. Sections stiffness and internal forces are obtained by addition of the fibers contribution |
| CFiberSection3d | Fiber section model in a three-dimensional space. Sections stiffness and internal forces are obtained by addition of the fibers contribution |
| CFiberSection3dBase | Base class for fiber sections on three-dimensional problems |
| CFiberSectionBase | Base class for fiber sections |
| CFiberSectionGJ | Fiber section with torsional stiffness |
| CFiberSectionRepr | Fiber section representation |
| CFiberSectionShear3d | FiberSectionShear3d decorates an MP section (couple bending and axial) with an uncoupled shear relation |
| CFiberSets | Fiber sets container |
| CFieldInfo | Information about a field defined over a set |
| CFileDatastore | |
| CfileDatastoreOutputFile | |
| CFilePlotter | A FilePlotter will create a line graph using xy points found in a file. Probably to deprecate |
| CFileStream | |
| CFilter | |
| CFindCurvatures | |
| CFindDesignPointAlgorithm | |
| CFiniteDeformationElastic3D | 3D finite deformation elastic material |
| CFiniteDeformationEP3D | Finite deformation elasto-plastic 3D material |
| CFiniteDifferenceGradGEvaluator | |
| CFirstPrincipalCurvature | |
| CFixedLocationBeamIntegration | Integration points at fixed locations |
| CFixedStepSizeRule | |
| CFlatSliderSimple2d | |
| CFlatSliderSimple3d | |
| CFluidSolidPorousMaterial | ?? |
| CForceBeamColumn2d | Force based 2D beam column element with SeccionBarraPrismatica type nonlinear material |
| CForceBeamColumn3d | 3D force based beam column element with nonlinear SeccionBarraPrismatica type material |
| CForceReprComponent | Base class for components that represent forces |
| CFORMAnalysis | |
| CFOSMAnalysis | |
| CFourNodeQuad | Four node quad |
| CFourNodeQuadUP | Four-node plane-strain element using bilinear isoparametric formulation. This element is implemented for simulating dynamic response of solid-fluid fully coupled material, based on Biot's theory of porous medium. Each element node has 3 degrees-of-freedom (DOF): DOF 1 and 2 for solid displacement (u) and DOF 3 for fluid pressure (p) |
| CFragilityAnalysis | |
| CFrequencyAlgo | Algortihm to obtain the natural frequencies of the model |
| CFrictionModel | |
| CFrictionResponse | |
| CFullGenEigenSOE | Dense matrix eigenproblem system of equations |
| CFullGenEigenSolver | Base class for full (dense) matrix eigenvalue SOE solvers |
| CFullGenLinLapackSolver | Lapack based full (dense) general matrix SOE solver |
| CFullGenLinSOE | Base class for dense unsymmetric matrix systems of equations |
| CFullGenLinSolver | Base class for full (dense) general linear SOE solvers |
| CFVector | Element internal forces |
| CFVectorBeamColumn2d | Internal forces for a beam-column 2D element |
| CFVectorBeamColumn3d | Internal forces for a beam column 3D element |
| CFVectorData | Auxiliary class for the internal forces in a beam-column element |
| CFVectorShell | Ingernal forces for a shell element |
| CGammaModulatingFunction | |
| CGammaRV | |
| CGaussLobattoQuadRule1d01 | One-dimensional Gauss-Lobatto quadrature |
| CGaussModel | Base class for Gauss integration models |
| CGaussPoint | 3D position of Gauss points |
| CGaussQuadRule1d | One-dimensional Gauss quadrature |
| CGaussQuadRule1d01 | One-dimensional Gauss quadrature |
| CGenericSection1d | ?? |
| CGenericSectionNd | ?? |
| CGeomSection | Cross section geometry |
| CGFunEvaluator | |
| CGFunVisualizationAnalysis | |
| CGlueNodeToElement | Glue a node to an element |
| CGradGEvaluator | |
| CGradientProjectionSearchDirection | |
| CGraph | Abstraction of a graph, a collection of vertices and edges. The Graph class is a container class which stores and provides access to Vertex objects. The Vertices contain information about the edges in this design |
| CGraphNumberer | Numberer for problem's degrees of freedom |
| CGraphPartitioner | GraphPartitioner is an abstract base class. Its subtypes are responsible for partioning the vertices of a graph. The partitioning is done in the method partition which sets the colors of the vertices of the graph to colors 1 through numParrtitions |
| CGroundMotion | Base class for ground motions |
| CGroundMotionRecord | Data from a real earthquake |
| CGSA_Recorder | GSA_Recorder is used to create an o/p file which can be read by the Ove Arup's GSA program for postprocessing |
| CGumbelRV | |
| CHajjar2D | XXX?? |
| CHandlerRecorder | Base class for recorders that get the response of one or more nodes during the analysis |
| CHardeningMaterial | HardeningMaterial provides the abstraction for a one-dimensional rate-independent plasticity model with combined isotropic and kinematic hardening |
| CHessianApproximation | |
| CHHT | HHT is an algorithmic class for performing a transient analysis using the HHT integration scheme |
| CHHT1 | The three parameter Hilbert-Hughes-Taylor time-stepping method |
| CHHTBase | HHTBase is an algorithmic class for performing a transient analysis using the HHTBase integration scheme |
| CHHTExplicit | HHTExplicit is an algorithmic class for performing a transient analysis using the HHTExplicit integration scheme (beta = 0) |
| CHHTGeneralized | HHTGeneralized is an algorithmic class for performing a transient analysis using the HHTGeneralized integration scheme |
| CHHTGeneralizedExplicit | HHTGeneralizedExplicit is an algorithmic class for performing a transient analysis using the HHTGeneralizedExplicit integration scheme |
| CHHTHybridSimulation | HHTHybridSimulation is an algorithmic class for performing a transient analysis using the HHTHybridSimulation integration scheme |
| CHHTRayleighBase | HHTRayleighBase is an algorithmic class for performing a transient analysis using the HHTRayleighBase integration scheme |
| CHingeBeamIntegration2d | ?? |
| CHingeBeamIntegration3d | ?? |
| CHingeEndpointBeamIntegration | ?? |
| CHingeMidpointBeamIntegration | ?? |
| CHingeMidpointBeamIntegration2d | ?? |
| CHingeMidpointBeamIntegration3d | ?? |
| CHingeRadauBeamIntegration | Base class for Radau integration on beam with hinges |
| CHingeRadauBeamIntegration2d | Radau integration on beam elements |
| CHingeRadauBeamIntegration3d | Radau integration on 3D beams |
| CHingeRadauTwoBeamIntegration | Radau integration |
| CHingeRadauTwoBeamIntegration2d | ?? |
| CHingeRadauTwoBeamIntegration3d | ?? |
| CHLRFSearchDirection | |
| CHSConstraint | ?? |
| CHystereticEnergy | |
| CHystereticMaterial | HystereticMaterial provides the implementation of a one-dimensional hysteretic model with pinching of both force and deformation, damage due to deformation and energy, and degraded unloading stiffness based on maximum ductility. This is a modified implementation of Hyster2.f90 by Filippou |
| CID | |
| CIDVarSize | |
| CImposedMotionBase | Base class for prescribed displacements at the nodes |
| CImposedMotionSP | Prescribed value for a single degree of freedom |
| CImposedMotionSP1 | Prescribed value over a single degree of freedom |
| CIncrementalIntegrator | IncrementalIntegrator is an algorithmic class for setting up the finite element equations in an incremental analysis and for updating the nodal response quantities based on the values in the soln vector |
| CInelastic2DYS01 | ?? |
| CInelastic2DYS02 | ?? |
| CInelastic2DYS03 | ?? |
| CInelasticYS2DGNL | Inelastic Element - concentrated hinge model, Fi - Fj interaction at each ends using yield surfaces
|
| CInformation | Information about an element |
| CInitialInterpolatedLineSearch | This performs the search by using a form of linear interpolation to find the best solution |
| CintData | |
| CIntegrationPointsCoords | Stores the coordinates of the integration points |
| CIntegrator | Base class for the object that performs the integration of physical properties over the domain to form the system stiffness matrix |
| CIntegratorVectors | Vectores empleados en varios integrators |
| CInteractionDiagram | @ingroup MATSCCDiagInt |
| CInteractionDiagram2d | @ingroup MATSCCDiagInt |
| CInteractionDiagramData | @ingroup MATSCCDiagInt |
| CInternalParamsA | Internal parameters for a p-y material |
| CInternalParamsIn | Internal parameters for a p-y material |
| CInternalParamsLR | Internal parameters for a p-y material |
| CInternalParamsLRIn | Internal parameters for a p-y material |
| CInterpolatedGroundMotion | ?? |
| CIntPtrWrapper | |
| CIsolator2spring | "two-spring isolator" material. This material is based on the two-spring model originally developed by Koh and Kelly to represent the buckling behavior of an elastomeric bearing. The material model has been modified to include material nonlinearity and optional strength degradation |
| CIsotropic2D01 | ?? |
| CItpackLinSOE | ITPACK based systems of equations |
| CItpackLinSolver | ITPACK based linear SOE solver |
| CJ2AxiSymm | J2 Isotropic hardening material class para axysimmetric problems |
| CJ2PlaneStrain | J2 Isotropic hardening material class for plane strain problems |
| CJ2PlaneStress | J2 Isotropic hardening material class for plane stress problems |
| CJ2Plasticity | J2 Isotropic hardening material class |
| CJ2PlateFiber | J2 Isotropic hardening material class for plate problems |
| CJ2ThreeDimensional | J2 Isotropic hardening material class for 3D problems |
| CJoint2D | 2D joint element |
| CJoint2DPhysicalProperties | Physical properties for shells |
| CJoint3D | Joint element for three-dimensional problems |
| CJoint3DPhysicalProperties | Physical properties for shells |
| CJonswapSpectrum | |
| CKDTreeElements | |
| CKDTreeNodes | |
| CKEigenIntegrator | Integrator used to obtain the eigenvalues and eigenvectors of the stiffness matrix |
| CKinematic2D01 | 2D kinematic yield surface |
| CKinematic2D02 | ?? |
| CKooFilter | |
| CKooModulatingFunction | |
| CKratzig | |
| CKRSeccion | Stiffness matrix and resultant vector for a section |
| CKrylovNewton | KrylovNewton is a class which uses a Krylov subspace accelerator on the modified Newton method. The accelerator is described by Carlson and Miller in "Design and Application of a 1D GWMFE Code" from SIAM Journal of Scientific Computing (Vol. 19, No. 3, pp. 728-765, May 1998) |
| CLagrange_FE | Lagrange_FE is a subclass of FE_Element which handles _Constraints using the Lagrange method |
| CLagrangeConstraintHandler | Constraint handler for handling constraints using the Lagrange multipliers method |
| CLagrangeDOF_Group | A LagrangeDOF_Group object is instantiated by a LagrangeConstraintHandler for every constrained node in the domain |
| CLagrangeMFreedom_FE | LagrangeMFreedom_FE is a subclass of FE_Element which handles MFreedom_Constraints using the Lagrange method |
| CLagrangeMRMFreedom_FE | LagrangeMRMFreedom_FE is a subclass of FE_Element which handles MRMFreedom_Constraints using the Lagrange method |
| CLagrangeSFreedom_FE | LagrangeSFreedom_FE is a subclass of SFreedom_FE which handles SFreedom_Constraints using the Lagrange method |
| CLaplaceRV | |
| CLegendreBeamIntegration | Cuadratura Gauss-Legendre |
| CLimitStateFunction | |
| CLinea | Segmento de recta entre dos puntos |
| CLineaBase | Base class for 1D entities |
| CLinear | Performs a linear solution algorihm to solve the equations |
| CLinearBucklingAlgo | Algorithm for linear buckling analysis |
| CLinearBucklingAnalysis | Linear buckling analysis |
| CLinearBucklingEigenAnalysis | Linear buckling analysis (used inside an StaticAnalysis) |
| CLinearBucklingIntegrator | LinearBucklingIntegrator is an algorithmic class for setting up the finite element equations for a linear buckling analysis |
| CLinearCrdTransf2d | LinearCrdTransf2d provides the abstraction of a linear transformation for a spatial frame between the global and basic coordinate systems |
| CLinearCrdTransf3d | Linear coordinate transformation. Performs a linear transformation of element stiffness and responses between local and global reference systems |
| CLinearCyclic | ?? |
| CLinearSeries | Linear function over time |
| CLinearSOE | Linea system of equations. This is the class definition for LinearSOE. LinearSOE is an abstract base class and thus no objects of it's type can be instantiated. It has pure virtual functions which must be implemented in it's derived classes. LinearSystemOfEqn is an abstraction of the linear system of equation given by : [A]{X} = {B} - {C}, where A is a matrix and B,C and X are vectors. To solve the equation means given A, B and C to find the unknown X such that the equation is satisfied |
| CLinearSOEData | Data (size, arrays,...) for linear system of equations |
| CLinearSOESolver | Solution of the linear system of equations |
| CLineSearch | LineSearch is an abstract base class, i.e. no objects of it's type can be created. Its subclasses seek to find a better solution to R(U)=0 than the solution Ui-1 + delta Ui would give, typically Ui = Ui-1 + factor * delta Ui |
| CListRegiones | Lista de regiones |
| CListReinfLayer | Contenedor (lista) de capas de armadura |
| CLoad | Base class for loads over nodes or elements |
| CLoadBalancer | |
| CLoadCaseIter | ?? |
| CLoadCombination | Load pattern combination (1.5*PP+1.0*CP+1.6*SC ...) |
| CLoadCombinationGroup | Load combination container |
| CLoadControl | Sets the incremental factor to apply on the loads for each analysis step |
| CLoader | Base class for the preprocessor objects that create model entities: nodes, elements, loads, etc |
| CLoadIter | Iterator over loads |
| CLoadLoader | Lee load patterns desde archivo. Load definition manager |
| CLoadLoaderMember | ?? |
| CLoadPath | LoadPath is an algorithmic class for performing a static analysis using a user defined load path (a user specified lambda path) |
| CLoadPattern | A LoadPattern object is used to to store reference loads and single point constraints and a TimeSeries function which is used to determine the load factor given the pseudo-time to the model |
| CLoadPatternIter | Load pattern iterator |
| CLobattoBeamIntegration | Base class for Lobatto integration on beams |
| CLognormalRV | |
| CLogWEnergy | ?? |
| CLowOrderBeamIntegration | |
| CMachineBroker | A MachineBroker is responsible for getting an actor process running on the parallel machine |
| CMapCadMember | Container for model entities |
| CMapCadMemberBase | Base class for entity containers of the model |
| CMapCasosActivos | |
| CMapCuerpos | Body contaainer |
| CMapEnt | Geometric entities container (points, lines, surfaces,...) |
| CMapEsquemas2d | Bidimensional scheme container |
| CMapEsquemas3d | Three dimensional scheme container |
| CMapFields | Container of field definitions |
| CMapLineas | Contenedor de puntos del modelo |
| CMapLoadPatterns | Load pattern container |
| CMapModelWrapper | Finite element model wrappers container |
| CMapOfTaggedObjects | The class is responsible for holding and providing access to objects of type TaggedObject. A map template of the standard template class is used to store the pointers to these objects |
| CMapOfTaggedObjectsIter | MapOfTaggedObjectsIter is an iter for returning the TaggedObjects of a storage objects of type MapOfTaggedComponents |
| CMapPuntos | Point container |
| CMapSet | Sets container |
| CMapSisRef | Reference systems container |
| CMapSoluMethod | Solution methods container |
| CMapSurfaces | Contenedor de puntos del modelo |
| CMapTrfGeom | Contenedor de puntos del modelo |
| CMapUniformGrids | Uniform grid container |
| CMaterial | Base class for materials |
| CMaterialLoader | Material handler (definition, searching,...) |
| CMaterialResponse | Recorder for material response |
| CMaterialVector | Material pointer container. It's used by elements to store materials for each integration point |
| CMatParameter | |
| CMatPoint3D | Integration point on three-dimensional space |
| CMatrix | |
| CMatrixCommMetaData | Data about the position, size,... of the object to transmit |
| CMatrixOperations | |
| CMatrizPtrBase | Base class for matrices of pointers to nodes, elements and points |
| CMatrizPtrElem | Matrix of pointers to elements |
| CMatrizPtrNod | Matriz de pointers to nodes |
| CMatrizPtrPnt | Matriz de pointers to puntos |
| CMaxNodeDispRecorder | A MaxNodeDispRecorder is used to determine the max nodal displacement at a collection of nodes over an analysis. (between commitTag of 0 and last commitTag) |
| CMDEvolutionLaw | ?? |
| CMDPotentialSurface | ?? |
| CMDPotentialSurface01 | ?? |
| CMDYieldSurface | ?? |
| CMEDBaseInfo | Base class for infomation objects |
| CMEDCellBaseInfo | Basic information about mesh cells |
| CMEDCellInfo | Information about mesh cells (conectivity,...) |
| CMEDDblFieldInfo | Information about an scalar field defined on a mesh subset |
| CMEDFieldInfo | Information about a field defined over a mesh subset |
| CMEDGaussModel | Information about Gauss model |
| CMEDGroupInfo | Information about node and element sets |
| CMEDIntFieldInfo | Information about field defined over a mesh subset |
| CMEDMapConectividad | Information about mesh cells connectivity |
| CMEDMapIndices | Map between the indexes in XC and in MEDMEM |
| CMEDMapNumCeldasPorTipo | Number of cells de cada tipo |
| CMEDMesh | Envoltorio para el objeto MESHING de MED |
| CMEDMeshing | Envoltorio para el objeto MESHING de MED |
| CMEDObject | Base class for MED objects |
| CMEDTFieldInfo | Iformation about a field defined over a mesh subset |
| CMEDVertexInfo | Information about mesh vertex |
| CMehanny | |
| CMembranePlateFiberSection | Fiber model for plate/membrane materials |
| CMeritFunctionCheck | |
| CMesh | Finite element mesh |
| CMeshComponent | Base class for nodes and elements (mesh components) |
| CMeshComponentContainer | Base class for the element and constraint containers |
| CMeshCompRecorder | Base class for mesh components recorders |
| CMeshEdge | Mesh edge |
| CMeshEdges | Element edge container |
| CMeshRegion | |
| CMessage | Message between processes |
| CMetis | Type of GraphPartitioner which uses 'METIS - Unstructured Graph Partitioning And Sparse Matrix Ordering System', developed by G. Karypis and V. Kumar at the University of Minnesota. The metis files are found in metis-2.0 which were downloaded |
| CMFreedom_Constraint | Multi-freedom constraint. Objectt of this class store the information for a multifreedom constraint. A multifreedom constraint relates certain dof at a constrained node to be related to certain dof at a retained node: {Uc} = [Ccr] {Ur} |
| CMFreedom_ConstraintBase | Base class for mult-freedom constraints |
| CMFreedom_ConstraintIter | Iterator over multi-freedom constraints |
| CMFreedom_FE | ?? |
| CMFreedom_Joint | Base class for joint constraints |
| CMFreedom_Joint2D | ?? |
| CMFreedom_Joint3D | ?? |
| CMidDistanceBeamIntegration | |
| CMillMachineBroker | |
| CMinMaxMaterial | Stores max and min strain values |
| CMinUnbalDispNorm | Specifies the incremental load factor such that the residual displacement norm in minimized |
| CModalAnalysis | Modal analysis |
| CModelBuilder | |
| CModelGraph | Base class for model graph |
| CModelWrapper | Wrapper for the finite element model "seen" from the solver. The model wrapper is definied by: |
| CModifiedNewton | Uses the tangent stiffness matrix computed in the first iteration until convergence is achieved |
| CModNewtonRootFinding | |
| CModulatingFunction | |
| CMooneyRivlinSimoWEnergy | ?? |
| CMooneyRivlinWEnergy | ?? |
| CMotionHistory | Data that define acceleration, velocities and displacements due to a earthquake |
| CMovableBJTensor | BJTensor that can move between processes |
| CMovableContainer | Container that can move between processes |
| CMovableID | ID that can move between processes |
| CMovableMap | Template class for maps that can move between processes |
| CMovableMatrices | Matrices that can move between objects |
| CMovableMatrix | Matrix that can move between processes |
| CMovableObject | Object that can move between processes |
| CMovableString | String that can move between processes |
| CMovableStrings | Strings that can move between processes |
| CMovableVector | Vector that can move between processes |
| CMovableVectors | Vector can move between processes |
| CMPBase_FE | ?? |
| CMPI_Channel | MPI_Channel is a sub-class of channel. It is implemented with Berkeley stream sockets using the TCP protocol. Messages delivery is garaunteed. Communication is full-duplex between a pair of connected sockets |
| CMPI_ChannelAddress | It is used to encapsulate the addresses used to send/recv messages using the MPI library |
| CMPI_MachineBroker | MPI_MachineBroker is the broker responsible for monitoring the usage of the processes in an mpi run |
| CMPSPBaseFE | Base class for MFreedom_FE y SFreedom_FE |
| CMRMFreedom_Constraint | Multiple retained nodes constraint |
| CMRMFreedom_ConstraintIter | Iterador over multiple retained nodal constraints |
| CMRMFreedom_FE | ?? |
| CMultiaxialCyclicPlasticity | ?? |
| CMultiaxialCyclicPlasticity3D | ?? |
| CMultiaxialCyclicPlasticityAxiSymm | ?? |
| CMultiaxialCyclicPlasticityPlaneStrain | ?? |
| CMultiLinearKp | XXX?? |
| CMultiSupportPattern | The Multi-Support pattern allows similar or different prescribed ground motions to be input at various supports in the structure |
| CMultiYieldSurface | ?? |
| CMVFOSMAnalysis | |
| CMyRCM | Class which performs the Reverse Cuthill-McKee numbering scheme on the vertices of a graph. This is done by invoking the number() method with the Graph to be numbered |
| CMySqlDatastore | |
| CNarrowBandSpectrum | |
| CNatafProbabilityTransformation | |
| CNDAdaptorMaterial | ?? |
| CnDarray | |
| CnDarray_rep | |
| CNDMaterial | Base class for 2D and 3D materials |
| CNDMaterialPhysicalProperties | Physical properties for solid mechanics |
| CNEES_table | |
| CNEESData | |
| CNeoHookeanCompressible3D | ?? |
| CNeoHookeanWEnergy | ?? |
| CNewElement | Element prototype |
| CNewmark | The two parameter time-stepping method developed by Newmark |
| CNewmark1 | Newmark1 is an algorithmic class for performing a transient analysis using the Newmark1 integration scheme |
| CNewmarkBase | The two parameter time-stepping method developed by NewmarkBase |
| CNewmarkBase2 | ?? |
| CNewmarkExplicit | NewmarkExplicit is an algorithmic class for performing a transient analysis using the explicit Newmark integration scheme (beta = 0) |
| CNewmarkHybridSimulation | NewmarkHybridSimulation is an algorithmic class for performing a transient analysis using the Newmark integration scheme |
| CNewmarkSensitivityIntegrator | |
| CNewtonBased | Uses the tangent stiffness matrix on each iteration (with or without updating) until convergence is achieved |
| CNewtonCotesBeamIntegration | Newton-Cotes integration on beam elements |
| CNewtonLineSearch | Performs a Newton-Raphson with line search solution algorithm in solving the equations as outline in Crissfields book |
| CNewtonRaphson | Uses the tangent stiffness matrix on each iteration until convergence is achieved |
| CNewUniaxialMaterial | ?? |
| CNineFourNodeQuadUP | 9-4-node (9 node for solid and 4 node for fluid) plane strain element for solid-fluid fully coupled analysis. This implementation is a simplified u-p formulation of Biot theory (u - solid displacement, p - fluid pressure). Each element node has two DOFs for u and 1 DOF for p |
| CNineNodeMixedQuad | Nine node quad |
| CNLBeamColumn2d | Nonlinear beam-column bidimensional elements |
| CNLBeamColumn3d | 3D materially nonlinear flexibility based frame element |
| CNLForceBeamColumn2dBase | |
| CNLForceBeamColumn3dBase | Base clas for 3D force beam column elements with SeccionBarraPrismatica type material |
| CNMPointCloud | (N,M) point set |
| CNMPointCloudBase | (N,M) point set base |
| CNMyMzPointCloud | (N,My,Mz) point set |
| CNodalLoad | Load over a node |
| CNodalLoadIter | Iterador sobre las nodal loads |
| CNode | Mesh node |
| CNodeAccelVectors | Vectors that store trial and commited values of the node acceleration |
| CNodeDispVectors | Vectores to store trial and commited values («commited») on node displacements |
| CNodeIter | Iterador sobre el conteedor de nodos |
| CNodeLoader | Node creation manager |
| CNodeLocations | |
| CNodeLocker | Single freedom constraints that make part of a load pattern |
| CNodeLockerIter | Iterador sobre los objetos de tipo NodeLocker |
| CNodeLockers | NodeLocker container |
| CNodePos | Node position for its use in the KDTree |
| CNodePropRecorder | |
| CNodePtrs | Pointers to nodes |
| CNodePtrsWithIDs | Node pointer container for elements |
| CNodeRecorder | Recording of specified nodal DOF responses for the specified nodes |
| CNodeRecorderBase | Base class for the node recorders |
| CNodeVectors | Vectores to store trial and commited values of node displacement, velocity, etc |
| CNodeVelVectors | Vectores to store trial and commited values of node velocity |
| CNormalizedPeak | |
| CNormalRV | |
| CNullEvolution | Useful for declaring inner-surfaces or pinching surfaces or just plain elastic-perfectly plastic surfaces that do not evolve |
| CNullPlasticMaterial | |
| CNullYS2D | Null 2D yield surface |
| CObjectBroker | Base class for brokers |
| CObjWithRecorders | Objeto capaz de gestionar Recorders |
| COgdenSimoWEnergy | ?? |
| COgdenWEnergy | ?? |
| COgdenWEnergyBase | ?? |
| COpenSeesGFunEvaluator | |
| COpenSeesGradGEvaluator | |
| COPS_Stream | |
| COptimalityConditionReliabilityConvergenceCheck | |
| COptimizationAnalysis | |
| COracleDatastore | |
| COrbison2D | Orbison 2D yield surface |
| COutCrossingAnalysis | |
| CParallelMaterial | Parallel connected materials |
| CParallelNumberer | The ParallelNumberer numbers the dof of a partitioned domain, where the partitions are on different processors and each processor has a ParallelNumberer. The ParalellNumberer sitting on P0, collects each partition graph from P1 through Pn-1, merges them into 1 large graph, & then numbers this graph. The ParallelNumberers sitting on P1 through Pn-1 then receive the mapping info for the dof tag and dof numbering from P0 |
| CParamAgotTN | Parameter that define the ultimate limit states of a RC section under normal stresses |
| CParameter | |
| CParameterIDBeamIntegration | Integration points at fixed locations |
| CParameterPositioner | |
| CParametricReliabilityAnalysis | |
| CParetoRV | |
| CParkAng | |
| CParticlePos3d | Natural coordinates of an element's particle |
| CPartitionedDomain | Partitioned domain |
| CPartitionedDomainEleIter | |
| CPartitionedDomainSubIter | |
| CPartitionedModelBuilder | |
| CPathIndependentMaterial | PathIndependentMaterial uses a UniaxialMaterial object to represent a path-independent uniaxial material. Since it is path-independent, no state information is stored by PathIndependentMaterial |
| CPathSeries | Time-dependent function that linear interpolates the load factor using user specified control points provided in a vector object. the points in the vector are given at regular time increments pathTimeIncr apart |
| CPathSeriesBase | Base class for time-dependent functions defined by a series of points (ti,fi) |
| CPathTimeSeries | Time-dependent function that linear interpolates the load factor using user specified control points provided in a vector object. the points in the vector are given at time points specified in another vector |
| CPatternRecorder | A PatternRecorder records loads values from a LoadPattern |
| CPBowlLoading | ?? |
| CPDeltaCrdTransf2d | PDeltaCrdTransf2d provides the abstraction of a linear transformation for a spatial frame between the global and basic coordinate systems |
| CPDeltaCrdTransf3d | PDeltaCrdTransf3d provides the abstraction of a linear transformation for a spatial frame between the global and basic coordinate systems |
| CPeakOriented2D01 | ?? |
| CPeakOriented2D02 | Grows/shrinks one side while keeping the diametrically opposite end the same. Kp_isoXPos = Kp_isoXNeg = (should be) Kp_kinX Since kinematic is function of back-stress and isotropic is a function of plastic-strains - calibration will be difficult |
| CPenaltyConstraintHandler | PenaltyConstraintHandler is a constraint handler deals with both single and multi point constraints using the penalty method. for each element and degree-of-freedom at a node it constructs regular FE_Element and DOF_Groups; for each SFreedom_Constraint and MFreedom_Constraint PenaltySFreedom_FE and PenaltyMFreedom_FE elements are created |
| CPenaltyMFreedom_FE | PenaltyMFreedom_FE is a subclass of FE_Element which handles MFreedom_Constraints using the penalty method |
| CPenaltyMRMFreedom_FE | PenaltyMRMFreedom_FE is a subclass of FE_Element which handles MRMFreedom_Constraints using the penalty method |
| CPenaltySFreedom_FE | PenaltySFreedom_FE is a subclass of SFreedom_FE which handles SFreedom_Constraints using the penalty method |
| CPeriodicNewton | PeriodicNewton is a class which performs a Periodic Newton-Raphson solution algorihm in solving the equations |
| CPeriodSeries | Periodic function over time |
| CPetscSOE | PETSC based system of equations |
| CPetscSolver | PETSC library based SOE solver |
| CPetscSparseSeqSolver | PETSC based sparse general matrix SOE solver |
| CPhysicalProperties | Base class for element's physical properties |
| CPinching | ?? |
| CPinching4Material | ?? |
| CPinchingDamage | ?? |
| CPivots | Pivot positions computed for a bending plane |
| CPivotsUltimateStrains | Definition of ultimate strains for the pivots |
| CPlainHandler | Trivial constraint handler |
| CPlainNumberer | Trivial DOF numberer |
| CPlaneStressMaterial | Material for plane stress problems |
| CPlasticHardening2D | ?? |
| CPlasticHardeningMaterial | Plastic material with strain hardening |
| CPlasticLengthsBeamIntegration | ?? |
| CPlateBase | Base class for bidimensional membrane/plate/shell materials |
| CPlateFiberMaterial | Builds a material that can be used in a plate fiber from its definition as three-dimensional material |
| CPnt | Punto (KPoint) |
| CPointsSpectrum | |
| CPolakHeSearchDirectionAndMeritFunction | |
| CPositioner | |
| CPotentialSurface | The goal is to create a platform for efficient and easy implemetation of any elasto-plastic constitutive model |
| CPQyzBase | Base class for PySimple1 y QzSimple1 |
| CPreprocessor | Finite element model generation tools |
| CPressureDependentElastic3D | ?? |
| CPressureDependMultiYield | ?? |
| CPressureDependMultiYield02 | ?? |
| CPressureDependMultiYieldBase | ?? |
| CPressureIndependMultiYield | ?? |
| CPressureMultiYieldBase | ?? |
| CProbabilityTransformation | |
| CProblemaEF | Finite element problem |
| CProcSolu | Solution procedure for the finite element problem |
| CProcSoluControl | Container for the objects that control the solution procedure |
| Cprofilematrix | |
| Cprofilematrix_rep | |
| CProfileSPDLinDirectBase | Base class for profile matris linear SOE solvers |
| CProfileSPDLinDirectBlockSolver | Solves a ProfileSPDLinSOE object using the LDL^t factorization |
| CProfileSPDLinDirectSkypackSolver | Skypakc based linear SOE solver |
| CProfileSPDLinDirectSolver | It solves a ProfileSPDLinSOE object using the LDL^t factorization |
| CProfileSPDLinDirectThreadSolver | Solves a ProfileSPDLinSOE object using the LDL^t factorization (threaded version) |
| CProfileSPDLinSOE | Profile matrix system of equations |
| CProfileSPDLinSolver | Base class for profile matrix linear SOE solvers |
| CProfileSPDLinSubstrSolver | Some kind of profile matrix linear SOE solver |
| CPropRecorder | |
| CProtoArcLength | Base class for arc length integrators |
| CProtoBeam2d | Base class for 2D beam elements |
| CProtoBeam3d | Base class for 3D beams |
| CProtoElementLoader | Finite element creation |
| CProtoTruss | Base class for truss elements |
| CPseudoTimeTracker | Registro del tiempo |
| CPtrCommMetaData | Data about the position, size,... of the pointer to transmit |
| CPulseBaseSeries | Base class for pulse type time series |
| CPulseSeries | Pulse type function |
| CPYBase | Material que representa una curva p-y |
| CPyLiq1 | ?? |
| CPySimple1 | Material que representa una curva p-y |
| CPySimple1Gen | ?? |
| CQuadBase4N | Base class for 4 node quads |
| CQuadBase9N | Base class for nine node quads |
| CQuadCell | Quadrilateral cell |
| CQuadraticCyclic | ?? |
| CQuadRule | Integration rule (quadrature) |
| CQuadRule1d | Base class for one-dimesional integrations rules (quadratures) |
| CQuadRule1d01 | One-dimensional quadrature |
| CQuadSurface | Quadrangle defined by its four vertices |
| CQzSimple1 | Material que representa la resistencia por fuste de un pilote |
| CRadauBeamIntegration | Base class for Radau integration on beam elements |
| CRandomNumberGenerator | |
| CRandomVariable | |
| CRandomVariablePositioner | |
| CRawConcrete | Base class for concrete materials |
| CRayleighBase | Base class for Rayleigh integrators |
| CRayleighDampingFactors | Rayleigh damping factors |
| CRayleighRV | |
| CRCM | Class designed to perform the Reverse Cuthill-McKee numbering scheme on the vertices of a graph. This is done by invoking the number() method with the Graph to be numbered |
| CRecorder | An Recorder object is used in the program to store/restore information at each commit() |
| CRectangularSeries | Pulso rectangular |
| CReflection | Reflection transformation |
| CRegionSecc | Region of a section that corresponds with a material |
| CRegulaFalsiLineSearch | Performs the search for U(i+1) = U(i) + eta * deltaU(i) by regula falsi method to find the best solution |
| CReinfBar | Reinforcing bar |
| CReinfLayer | Rebar layer |
| CReinforcingSteel | ?? |
| CReleaseHeavierToLighterNeighbours | |
| CReliabilityAnalysis | |
| CReliabilityConvergenceCheck | |
| CReliabilityDomain | |
| CReliabilityDomainComponent | |
| CRespFiberSectionShear3d | |
| CRespMembraneMaterial | |
| CResponse | |
| CResponseId | Stiffness material contribution response identifiers |
| CResponseQuantities | Response quantities |
| CRespPlateMaterial | |
| CRespPMz | |
| CRespPMzMy | |
| CRespPMzMyT | |
| CRespPMzV | |
| CRespPMzVyMyVzT | |
| CRespPVyMz | |
| CRespShellMaterial | |
| CRespVyP | |
| CRgQuadCell | Region of a section that creates quadrilateral cells |
| CRgSccCirc | Circular shaped patch |
| CRgSccPoligono | |
| CRgSccQuad | Quad that discretizes in quad cells |
| CRigidBase | Base class for the "rigid body motion" conditions |
| CRigidBeam | Imposes a rigid body motion to the nodes of the rigid beam |
| CRigidDiaphragm | Imposes a rigid body motion to the nodes on included in the diaphragm |
| CRigidRod | Constructs MFreedom_Constraint objects for a rigid rod, all translational dof are constrained to be equal at the retained and constarined nodes |
| CRMC01PotentialSurface | Functions for rounded Mohr-Coulomb potential function |
| CRMC01YieldSurface | Functions for rounded Mohr-Coulomb yield function |
| CRootFinding | |
| CRotation | Rotation transformation |
| CSamplingAnalysis | |
| CScaling | Scale transformation |
| CSearchDirection | |
| CSearchWithStepSizeAndStepDirection | |
| CSecantLineSearch | Performs the search for U(i+1) = U(i) + eta * deltaU(i) by using the secant method to find the best solution |
| CSecantRootFinding | |
| CSeccionBarraPrismatica | Base class for beam-column cross sections. Constitutive equations of the section |
| CSeccionInerte | Cross-section representation able to return mechanical propertis a area, moments of inertia,.. |
| CSectionAggregator | SectionAggregator decorates an MP section (couple bending and axial) with an uncoupled shear relation |
| CSectionFDPhysicalProperties | Physical properties for shells |
| CSectionForceDeformation | Base class for force deformation section models. Constitutive equations of the section |
| CSectionMatrices | Matrices for each section (used in BeamColumnWithSectionFD) |
| CSectionRepres | Material distribution on a cross section |
| CSecuenciaLados | Order in edges of an hexaedron face |
| CSegment | Segment de recta entre dos puntos |
| CSensitivityAlgorithm | |
| CSensitivityIntegrator | |
| CSeriesMaterial | Serially connected uniaxial materials |
| CSet | Object set |
| CSetBase | Base de las clases Set y SetEstruct |
| CSetEstruct | Structured set, i. e. a set that can return a pointer a to a node or an element from its indices i,j and k |
| CSetFila | Set of objects in a row |
| CSetFilaI | Set of objecst in a row |
| CSetFilaJ | Objects in a row |
| CSetFilaK | Set of objects in a row |
| CSetMeshComp | Set of mesh components (nodes, elements and constraints) |
| CSFreedom_Constraint | Single freedom constraint |
| CSFreedom_ConstraintIter | Iterator over single freedom constraints |
| CSFreedom_FE | ?? |
| CShadow | |
| CShadowPetscSOE | ?? |
| CShadowSubdomain | |
| CShedHeaviest | |
| CShellBData | Auxiliary data for shell elements |
| CShellCorotCrdTransf3d | Base class for 3D coordinate transformation |
| CShellCrdTransf3dBase | Base class for 3D coordinate transformations |
| CShellLinearCrdTransf3d | Base class for small displacement 3D coordinate transformations |
| CShellMecLoad | Mechanical load (forces) over shell elements |
| CShellMITC4 | MIT C4 shell elements |
| CShellMITC4Base | Base class for MIT C4 shell elements |
| CShellNL | Lagrangian shell element with membrane and drill |
| CShellStrainLoad | Load due to restricted material expansion or contraction on Shell elements |
| CShellUniformLoad | Uniform load over shell elements |
| CShiftedExponentialRV | |
| CShiftedRayleighRV | |
| CSimoPisterWEnergy | ?? |
| CSimple1GenBase | ?? |
| CSimpleDOF_Iter | Iterator over the degrees of freedom of the analysis model |
| CSimpleFE_Iter | Iterator over the model finite elements |
| CSimpleNumberer | Triviel DOF numberer |
| CSimulatedRandomProcessSeries | ?? |
| CSingleBar | Single rebar (not included in a reinforcement layer) |
| CSingleDomAllSFreedom_Iter | |
| CSingleDomEleIter | |
| CSingleDomLC_Iter | |
| CSingleDomMFreedom_Iter | |
| CSingleDomMRMFreedom_Iter | |
| CSingleDomNodIter | |
| CSingleDomSFreedom_Iter | |
| CSingleDomTIter | |
| CSingleFPSimple2d | |
| CSingleFPSimple3d | |
| CSisRef | Reference system to be used for simpliflying the definition of point positions |
| CSisRefCartesianas3d | Three-dimensional reference system |
| CSisRefScc | Reference system used for make easier definining point positions |
| CSisRefSccCartesianas2d | Bidimensional reference system for a section |
| Cskymatrix | |
| CSmallDispCrdTransf2d | Base class for small displacements 2D coordinate transformations |
| CSmallDispCrdTransf3d | Base class for small displacements 3D coordinate transformations |
| CSocketAddress | It is used to encapsulate the addresses used to send/recv messages using Berkeley sockets. SocketAddress is needed as a friend by UDP_Socket & TCP_Socket |
| CSolidMech2D | Physical properties for solid mechanics |
| CSoluMethod | Solution procedure for the finite element problem. The solution procedure is definde by specifiying: |
| CSolutionAlgorithm | Base class for solution algorithms |
| CSolver | Equation solver |
| CSORMAnalysis | |
| CSparseGenColLinSOE | Sparse nonsymmetric matrix linear system of equations |
| CSparseGenColLinSolver | Base class for sparse general matrix linear SOE solver |
| CSparseGenRowLinSOE | Sparse nonsymmetric matrix linear system of equations |
| CSparseGenRowLinSolver | Base class for sparse general matrix linear SOE solvers |
| CSparseGenSOEBase | Sparse unsymmetric matris system of equations |
| CSparseSOEBase | Base class for sparse matrix systems of equations |
| CSpectrum | |
| CSpot | Point object for section geometry definition |
| CSpring | |
| CSQLiteDatastore | |
| CSQPsearchDirectionMeritFunctionAndHessian | |
| CStandardEigenAlgo | Standard eigenvalues algorithm |
| CStandardLinearOscillatorAccelerationFilter | |
| CStandardLinearOscillatorDisplacementFilter | |
| CStandardLinearOscillatorVelocityFilter | |
| CStandardReliabilityConvergenceCheck | |
| CStandardStream | |
| CStaticAnalysis | Performs a static analysis on the FE_Model |
| CStaticDomainDecompositionAnalysis | StaticDomainDecompositionAnalysis is a subclass of DomainDecompositionAnalysis used to perform a static analysis step on a subdomain |
| CStaticIntegrator | Base class for static integrators |
| CStaticSensitivityIntegrator | |
| CSteel01 | Uniaxial material model for steel |
| CSteel02 | Uniaxial material for steel. Menegotto-Pinto steel model with Filippou isotropic hardening |
| CSteel03 | Steel 03 uniaxial material |
| CSteelBase | Base class for steel uniaxial materials |
| CSteelBase0103 | Base class for Steel01 and Steel03 |
| CStepSizeRule | |
| CStoFibras | Contenedor de fibras |
| CStraightReinfLayer | Set of rebars distributed along a segment |
| Cstraintensor | Strain tensor |
| Cstresstensor | |
| CSubdomain | |
| CSubdomainAnalysis | SubdomainAnalysis is a subclass of AnalysisAnalysis, it is used when performing a domain decomposition analysis. It provides methods which can be invoked by a subdomain to perform the numerical computations required |
| CSubdomainIter | |
| CSubdomainNodIter | |
| CSubstructuringAnalysis | SubstructuringAnalysis is a subclass of Analysis, it is used when performing a domain decomposition analysis. It provides methods which can be invoked by a subdomain to perform the numerical computations required |
| CSuperLU | SuperLU based sparse general matrix linear SOE solver |
| CSwapHeavierToLighterNeighbours | |
| CSymArpackSOE | Arpack system of equations for symmetric matrices |
| CSymArpackSolver | Arpack based symmetric matrix eigenvalue SOE solver |
| CSymBandEigenSOE | Band symmetric matrix eigenvaules system of equations |
| CSymBandEigenSolver | Base class for symmetric band matrix eigenvalue SOE solvers |
| CSymSparseLinSOE | Sparse symmetric matrix systems of equations |
| CSymSparseLinSolver | Solver for symmetric sparse linear SOE |
| CSystemAnalysis | |
| CSystemOfEqn | System of equations base class |
| CT2Vector | Tensor de segundo orden |
| CTaggedObject | Object idenfied by an integer (tag) |
| CTaggedObjectIter | An TaggedObjectIter is an iter for returning the Components of an object of class TaggedObjectStorage. It must be written for each subclass of TaggedObjectStorage (this is done for efficiency reasons), hence the abstract base class |
| CTaggedObjectStorage | TaggedObjectStorage. A TaggedObjectStorage object a container object used to hold objects of type TaggedObject; each object of which has some UNIQUE identifier |
| CTclGFunEvaluator | |
| CTclMatlabGFunEvaluator | |
| CTCP_Socket | TCP_Socket is a sub-class of channel. It is implemented with Berkeley stream sockets using the TCP protocol. Messages delivery is garaunteed. Communication is full-duplex between a pair of connected sockets |
| CTCP_SocketNoDelay | TCP_SocketNoDelay is a sub-class of channel. It is implemented with Berkeley stream sockets using the TCP protocol. Messages delivery is garaunteed. Communication is full-duplex between a pair of connected sockets |
| CTemplate3Dep | 3 |
| CTensorCommMetaData | Data about the address, size,... of the tensor to transmit |
| CThreadedSuperLU | Threaded SuperLU based sparse general matrix linear SOE solver |
| CTimer | |
| CTimeSeries | Time variation of loads.A TimeSeries object is used to determine the load factor to be applied to the loads in a pettern. to the model |
| CTimeSeriesIntegrator | Time integration of time series. A TimeSeriesIntegrator describes the numerical integration of a ground motion record used in a dynamic analysis |
| CTotalLagrangianFD20NodeBrick | Twenty node hexahedron with lagrangian formulation |
| CTransfCooLoader | Manager for the creation/deletion of coordinate transformations |
| CTransformationConstraintHandler | TransformationConstraintHandler is a constraint handler for handling constraints using the Transformation method. For each element and degree-of-freedom at a node it constructs regular FE_Element and DOF_Groups if there is no SFreedom_Constraint or MFreedom_Constraint constraining an elements node or the node; otherwise a TransformationFE element and a TransformationDOF_Group are created |
| CTransformationDOF_Group | A TransformationDOF_Group object is instantiated by the TransformationConstraintHandler for every node in the domain which is constrained by an MFreedom_Constraint or an SFreedom_Constrant |
| CTransformationFE | TransformationFE objects handle MFreedom_Constraints using the transformation method T^t K T. SFreedom_Constraints are handled by the TransformationConstraintHandler |
| CTransientAnalysis | Analysis of the time-dependent response of the model |
| CTransientDomainDecompositionAnalysis | Transient analysis witn domain decomposition |
| CTransientIntegrator | Base class for dynamic equations of motion integrators |
| CTranslation | Translation transformation |
| CTrapezoidalBeamIntegration | Trapezoidal integration scheme |
| CTrapezoidalModulatingFunction | |
| CTrapezoidalTimeSeriesIntegrator | Integrates a ground motion TimeSeries using the trapezoidal rule |
| CTrfGeom | |
| CTri31 | 3 node triangle |
| CTriangCell | Triangle shaped cell for section discretization |
| CTriangleSeries | Serie de ondas triangulares |
| CTriBase3N | Base class for 3 node triangles |
| CTriFCYieldSurface | Yield surface is based on article by Menetrey, P. and William, K.J. published in 1995 in ACI Structural Journal pp 311-318. Purpose of the Yield surface is to model triaxial strenght of concrete |
| CTrigSeries | Trigonometric functions over time. A TrigSeries object provides a sine time series. the factor is given by the pseudoTime (x), pulse period (T), phase shift (phi), i.e. by sin(2*PI*(x-xo)/T + phi), and a constant factor provided in the constructor, the duration by tStart and tFinal; |
| CTritrizPtrBase | "Tritriz" de pointers to objetos |
| CTritrizPtrElem | "Tritriz" of pointers to elements |
| CTritrizPtrNod | "Tritriz" of pointers to elements |
| CTritrizPtrPnt | "Tritriz" of elment pointers |
| CTruss | Barra articulada |
| CTrussBase | Base class for truss elements |
| CTrussSection | Truss element with SectionForceDeformation material |
| CTrussStrainLoad | Load due to restricted material expansion or contraction on truss elements |
| CTwenty_Node_Brick | Hexaedro de veinte nodos |
| CTwentyEightNodeBrickUP | Hexaedro de veintiocho nodos |
| CTwentyNodeBrick | Hexaedro de veinte nodos |
| CTwentyNodeBrick_u_p_U | Hexaedro de veinte nodos |
| CTwentySevenNodeBrick | Twenty seven node hexahedron with lagrangian formulation |
| CType1LargestValueRV | |
| CType1SmallestValueRV | |
| CType2LargestValueRV | |
| CType3SmallestValueRV | |
| CTzLiq1 | ?? |
| CTzSimple1 | Material que representa una curva t-z |
| CTzSimple1Gen | ?? |
| CUDP_Socket | DP_Socket is a sub-class of channel. It is implemented with Berkeley datagram sockets using the UDP protocol. Messages delivery is thus unreliable |
| CUmfpackGenLinSOE | UMFPACK (see SuiteSparse) based systems of equations |
| CUmfpackGenLinSolver | UMFPACK based sparse matrix linear SOE solver |
| CUnbalAndTangent | Vector de fuerza desequilibrada y tangent stiffness matrix |
| CUnbalAndTangentStorage | Vector de fuerza desequilibrada y tangent stiffness matrix |
| CUniaxialFiber | Representa una fibra de material uniaxial |
| CUniaxialFiber2d | Uniaxial fiber on a bi-dimensional space |
| CUniaxialFiber3d | Uniaxial fiber on a three-dimensional space |
| CUniaxialHistoryVars | UniaxialHistoryVars stores values for strain and stiffness |
| CUniaxialMaterial | Base class for uniaxial materials |
| CUniaxialMatPhysicalProperties | Physical properties for shells |
| CUniaxialStateVars | UniaxialStateVars stores values for material strain, stress and stiffness |
| CUniformExcitation | Load pattern for a earthquake with a similar excitation for all supports |
| CUniformGrid | Uniform mesh. Uniform node distributionn on x, y and z |
| CUniformRV | |
| CUpdatedLagrangianBeam2D | Lagrangian 2D beam element |
| CUserDefinedBeamIntegration | User defined integration over the beam |
| CUserDefinedBeamIntegrationBase | Base class for user defined integration on beam elements |
| CUserDefinedHingeIntegration | Base class for user defined integration on beam with hinges |
| CUserDefinedHingeIntegration2d | User defined integration |
| CUserDefinedHingeIntegration3d | 3D hinge user defined integration |
| CUserDefinedHingeIntegrationBase | Base class for hinge user defined integration |
| CUserDefinedRV | |
| CVariableTimeStepDirectIntegrationAnalysis | Perform a dynamic analysis on the FE_Model using a direct integration scheme |
| CVDependentFriction | |
| CVector | |
| CVectorCells | Cells vector |
| CVectorReinfBar | Vector de barras de armadura |
| CVectorSeccionesBarraPrismatica | Vector of pointers to SeccionBarraPrismaticaes. used to store the sections for each integration point |
| CVertex | Vertex of a graph |
| CVertexIter | Iterator over the vertices of the graph |
| CViscousMaterial | Material de tipo viscoso |
| CVMPotentialSurface | Von Mises potential surface |
| CVMYieldSurface | Von Mises yield surface |
| CVPDependentFriction | |
| CWeibullRV | |
| CWEnergy | ?? |
| CWilsonTheta | WilsonTheta is an algorithmic class for performing a transient analysis using the WilsonTheta integration scheme |
| CYieldSurface | The goal is to create a platform for efficient and easy implemetation of any elasto-plastic constitutive model |
| CYieldSurface_BC | Yield surface |
| CYieldSurface_BC2D | BC 2D yield surface |
| CYieldSurfaceSection2d | Base class for cross sections with yield surface on a bi-dimensional space (three DOFs for each section) |
| CYS_Evolution | Yield surface evolution |
| CYS_Evolution2D | 2D yield surface evolution |
| CYS_Section2D01 | Cross section with yield surface on a bi-dimensional problem (three DOFs for each section) |
| CYS_Section2D02 | Cross section with yield surface fro bi-dimensional problem (three degrees of freedom in each section) |
| CYsVisual | |
| CZeroLength | Zero length material |
| CZeroLengthContact | Zero length contact element |
| CZeroLengthContact2D | Zero length element for 2D contact problems |
| CZeroLengthContact3D | Zero lenght element for 3D problems |
| CZeroLengthMaterials | A ZeroLengthElement is defined by two nodes with the same coordinate. One or more material objects may be associated with the nodes to provide a force displacement relationship. ZeroLengthMaterials will work with 1d, 2d, or 3d material models |
| CZeroLengthSection | Zero length element with SectionForceDeformation material |
| CBranch | |
| Ccp_panel_t | |
| Cdesc_eft_t | |
| Ce_node | |
| CGlobalLU_t | |
| CGstat_t | |
| Coffdblk | |
| Cpanstat_t | |
| Cpdgstrf_options_t | |
| Cpdgstrf_threadarg_t | |
| Cprocstat_t | |
| Cpxgstrf_relax_t | |
| Cpxgstrf_shared_t | |
| Cstat_col_t | |
| Cstat_relax_t | |
| Cstat_snode_t | |
| Csuperlu_memusage_t | |
| Cthread_control_block | |
| CuniaxialPackage | |
1.8.11
