| ►CVolumeElementForcesAndSourcesCoreOnContactPrismSide:: UserDataOperator | |
| CMetaSpringBC::OpCalculateDeformation | Operator for computing deformation gradients in side volumes |
| C__CLPK_complex | |
| C__CLPK_doublecomplex | |
| CMoFEM::AddEssentialToLhsPipelineImpl< T, A, I, OpBase > | Function (factory) for setting operators for lhs pipeline |
| CMoFEM::AddEssentialToLhsPipelineImpl< OpEssentialLhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddEssentialToLhsPipelineImpl< OpEssentialLhsImpl< HeatFluxCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddEssentialToRhsPipelineImpl< T, A, I, OpBase > | Function (factory) for setting operators for rhs pipeline |
| CMoFEM::AddEssentialToRhsPipelineImpl< OpEssentialRhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddEssentialToRhsPipelineImpl< OpEssentialRhsImpl< HeatFluxCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddFluxToLhsPipelineImpl< T, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< BoundaryBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< ContactOps::BoundaryBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< ElasticExample::SpringBcType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< PlasticOps::BoundaryBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< ThermoElasticOps::ConvectionBcType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< ThermoElasticOps::RadiationBcType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToLhsPipelineImpl< OpFluxLhsImpl< ThermoElasticOps::SetTargetTemperature, 1, 1, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddFluxToRhsPipelineImpl< T, A, I, OpBase > | |
| CMoFEM::AddFluxToRhsPipelineImpl< MoFEM::OpFluxRhsImpl< ThermoElasticOps::SetTargetTemperature, 1, 1, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< BoundaryBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< ContactOps::BoundaryBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< ContactOps::DomainBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< DomainBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< ElasticExample::FluidLevelType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< ElasticExample::SpringBcType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalForceMeshsets, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalMeshsetType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalMeshsetTypeVectorScaling< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CMoFEM::AddFluxToRhsPipelineImpl< OpFluxRhsImpl< NaturalTemperatureMeshsets, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< PlasticOps::BoundaryBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< PlasticOps::DomainBCs, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< ThermoElasticOps::ConvectionBcType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddFluxToRhsPipelineImpl< OpFluxRhsImpl< ThermoElasticOps::RadiationBcType< BCTYPE >, BASE_DIM, FIELD_DIM, A, I, OpBase >, A, I, OpBase > | |
| CAddHOOps< FE_DIM, PROBLEM_DIM, SPACE_DIM > | |
| CEshelbianPlasticity::AddHOOps< FE_DIM, PROBLEM_DIM, SPACE_DIM > | |
| CMoFEM::AddHOOps< FE_DIM, PROBLEM_DIM, SPACE_DIM > | Add operators pushing bases from local to physical configuration |
| CPlasticOps::AddHOOps< FE_DIM, PROBLEM_DIM, SPACE_DIM > | |
| CMoFEM::AddHOOps< 1, 2, 2 > | |
| CPlasticOps::AddHOOps< 1, 2, 2 > | |
| CMoFEM::AddHOOps< 1, 3, 3 > | |
| CMoFEM::AddHOOps< 2, 2, 2 > | |
| CPlasticOps::AddHOOps< 2, 2, 2 > | |
| CAddHOOps< 2, 2, 3 > | |
| CEshelbianPlasticity::AddHOOps< 2, 2, 3 > | |
| CMoFEM::AddHOOps< 2, 2, 3 > | |
| CAddHOOps< 2, 3, 3 > | |
| CEshelbianPlasticity::AddHOOps< 2, 3, 3 > | |
| CMoFEM::AddHOOps< 2, 3, 3 > | |
| CPlasticOps::AddHOOps< 2, 3, 3 > | |
| CAddHOOps< 3, 3, 3 > | |
| CEshelbianPlasticity::AddHOOps< 3, 3, 3 > | |
| CMoFEM::AddHOOps< 3, 3, 3 > | |
| CPlasticOps::AddHOOps< 3, 3, 3 > | |
| CMoFEM::AdJoint< EleOp > | |
| CADOLCPlasticity::ADOLCPlasticityIntegrators< DomainEleOp > | |
| CMoFEM::AinsworthOrderHooks | Broken base Ainsworth subentries order change hooks |
| CAnalyticalDirichletBC | Analytical Dirichlet boundary conditions |
| CEshelbianPlasticity::AnalyticalDisplacementBc | |
| CAnalyticalFunction | |
| CEshelbianPlasticity::AnalyticalTractionBc | |
| CAnalyticalDirichletBC::ApproxField | Finite element to approximate analytical solution on surface |
| CApproxFieldFunction< FIELD_DIM > | |
| CApproxFieldFunction< 1 > | Third order polynomial used for testing |
| CApproxFieldFunctionDerivative< FIELD_DIM > | |
| CApproxFieldFunctionDerivative< 1 > | Third order polynomial used for testing |
| CApproxFunction | |
| CApproxFunctions | |
| CApproxFunctionsImpl< DIM > | |
| CApproxFunctionsImpl< 2 > | |
| CApproxFunctionsImpl< 3 > | |
| CApproxSphere | |
| CArcLengthCtx | Store variables for ArcLength analysis |
| CArcLengthMatShell | Shell matrix for arc-length method |
| CADOLCPlasticity::ADOLCPlasticityIntegrators< DomainEleOp >::Assembly< A > | |
| CContactOps::ContactIntegrators< BoundaryEleOp >::Assembly< A > | |
| CMoFEM::EssentialBC< EleOp >::Assembly< A > | Assembly methods |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A > | Assembly methods |
| CMoFEM::NaturalBC< EleOp >::Assembly< A > | Assembly methods |
| CPlasticOps::PlasticityIntegrators< DomainEleOp >::Assembly< A > | |
| ►CAssemblyBoundaryEleOp | |
| CContactOps::OpConstrainBoundaryLhs_dTractionImpl< DIM, GAUSS, AssemblyBoundaryEleOp > | |
| CContactOps::OpConstrainBoundaryLhs_dUImpl< DIM, GAUSS, AssemblyBoundaryEleOp > | |
| CContactOps::OpConstrainBoundaryRhsImpl< DIM, GAUSS, AssemblyBoundaryEleOp > | |
| CFreeSurfaceOps::OpNormalConstrainLhs | |
| CFreeSurfaceOps::OpNormalConstrainRhs | |
| CFreeSurfaceOps::OpNormalForceRhs | |
| CFreeSurfaceOps::OpWettingAngleRhs | |
| ►CContactOps::AssemblyBoundaryEleOp | |
| CEshelbianPlasticity::OpConstrainBoundaryL2Lhs_dU | |
| CEshelbianPlasticity::OpConstrainBoundaryL2Rhs | |
| ►CAssemblyDomainEleOp | |
| CADOLCPlasticity::OpLhsImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CADOLCPlasticity::OpRhsImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CFiniteThermalOps::OpCalculateQdotQLhs_dQ< DIM, GAUSS, AssemblyDomainEleOp > | |
| CFiniteThermalOps::OpCalculateQdotQLhs_dU< DIM, GAUSS, AssemblyDomainEleOp, false > | |
| CFiniteThermalOps::OpCalculateQdotQLhs_dU< DIM, GAUSS, AssemblyDomainEleOp, true > | |
| CFreeSurfaceOps::OpLhsG_dG | Lhs for H dH |
| CFreeSurfaceOps::OpLhsG_dH< I > | Lhs for H dH |
| CFreeSurfaceOps::OpLhsH_dG< I > | Lhs for H dH |
| CFreeSurfaceOps::OpLhsH_dH< I > | Lhs for H dH |
| CFreeSurfaceOps::OpLhsH_dU | Lhs for H dU |
| CFreeSurfaceOps::OpLhsU_dG | Lhs for G dH |
| CFreeSurfaceOps::OpLhsU_dH | Lhs for U dH |
| CFreeSurfaceOps::OpLhsU_dU | Lhs for U dU |
| CFreeSurfaceOps::OpRhsG< I > | |
| CFreeSurfaceOps::OpRhsH< I > | |
| CFreeSurfaceOps::OpRhsU | Rhs for U |
| CHenckyOps::OpCalculateHenckyThermalStressdTImpl< DIM, GAUSS, AssemblyDomainEleOp, S > | |
| CMoFEM::AssemblyTypeSelector< A > | |
| CAtomTest | |
| CPoissonExample::AuxFunctions | |
| CTetBaseCache::BaseCacheItem | |
| CMoFEM::BasicEntityData | PipelineManager data. like access to moab interface and basic tag handlers |
| CMoFEM::BasicMethodPtr | |
| CMoFEM::BcAnalyticalDisplacementMeshsetType< BC > | |
| CMoFEM::BcAnalyticalTractionMeshsetType< BC > | |
| CMixTransport::UnsaturatedFlowElement::BcData | Class storing information about boundary condition |
| CEshelbianPlasticity::BcDisp | |
| CMoFEM::BcDisplacementMeshsetType< BC > | |
| CBcFluxData | |
| CMoFEM::BcFluxMeshsetType< BC > | |
| CEdgeForce::bCForce | |
| CNeumannForcesSurface::bCForce | |
| CNeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE::bCForce | |
| CNodalForce::bCForce | |
| CMoFEM::BcForceMeshsetType< BC > | |
| CMoFEM::BcMeshsetType< BC > | |
| CMoFEM::BcNormalDisplacementMeshsetType< BC > | |
| CNeumannForcesSurface::bCPressure | |
| CNeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE::bCPressure | |
| CMoFEM::BcPressureMeshsetType< BC > | |
| CEshelbianPlasticity::BcRot | |
| CMoFEM::BcScalarMeshsetType< BC > | |
| CMoFEM::BernsteinBezier | Evaluating BB polynomial |
| ►CBiLinearForm | |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A > | Bilinear integrator form |
| CMoFEM::EssentialBC< EleOp >::Assembly< A >::BiLinearForm< I > | |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A >::BiLinearForm< I > | Bi linear form |
| CMoFEM::NaturalBC< EleOp >::Assembly< A >::BiLinearForm< I > | |
| CMoFEM::BitFEId_mi_tag | |
| CMoFEM::BitFieldId_mi_tag | |
| CMoFEM::BitFieldId_space_mi_tag | |
| CMoFEM::BitProblemId_mi_tag | |
| CBlockData | |
| CConvectiveMassElement::BlockData | Data for calculation inertia forces |
| CEshelbianPlasticity::HMHHencky::BlockData | |
| CEshelbianPlasticity::HMHNeohookean::BlockData | |
| CMagneticElement::BlockData | Data structure storing material constants, model parameters, matrices, etc |
| CMixTransport::MixTransportElement::BlockData | Data for evaluation of het conductivity and heat capacity elements |
| CMoFEM::BlockData | |
| CNavierStokesElement::BlockData | |
| CNonlinearElasticElement::BlockData | Data for calculation heat conductivity and heat capacity elements |
| CThermalElement::BlockData | Data for calculation heat conductivity and heat capacity elements |
| CThermalStressElement::BlockData | |
| CKelvinVoigtDamper::BlockMaterialData | Dumper material parameters |
| CBlockOptionData | |
| CElasticMaterials::BlockOptionData | |
| CBlockOptionDataSimpleRods | |
| CMetaSpringBC::BlockOptionDataSprings | |
| CBodyForceConstantField | Body forces elements |
| CBoundaryBCs | |
| ►CBoundaryEleOp | |
| CAtomTest::OpErrorSkel< 1 > | |
| CContactOps::OpAssembleTotalContactAreaImpl< DIM, GAUSS, BoundaryEleOp > | |
| CContactOps::OpAssembleTotalContactTractionImpl< DIM, GAUSS, BoundaryEleOp > | |
| CContactOps::OpEvaluateSDFImpl< DIM, GAUSS, BoundaryEleOp > | |
| CElasticExample::OpCalculateTraction | |
| CFreeSurfaceOps::OpCalculateLift | |
| CFreeSurfaceOps::OpWettingAngleLhs | |
| CLevelSet::OpLhsSkeleton | |
| CLevelSet::OpRhsSkeleton | |
| COpH1LhsSkeleton | Operator the left hand side matrix |
| CPhotonDiffusion::OpCameraInteg | |
| CPhotonDiffusion::OpGetScalarFieldGradientValuesOnSkin | |
| CPoisson2DiscontGalerkinOperators::OpL2BoundaryRhs | Operator to evaluate Dirichlet boundary conditions using DG |
| CPoisson2DiscontGalerkinOperators::OpL2LhsPenalty | Operator the left hand side matrix |
| CMoFEM::BrokenBaseSideData | |
| CCalcJacobian | |
| CEdgeSlidingConstrains::CalculateEdgeBase | |
| CFTensor::Christof< T, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Christof< A, Tensor_Dim0, Tensor_Dim12 > | |
| ►CFTensor::Christof< T *, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Christof< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Christof_constructor< T, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Christof_constructor< T, 2, 2 > | |
| CFTensor::Christof_constructor< T, 3, 3 > | |
| CFTensor::Christof_constructor< T, 3, 4 > | |
| CFTensor::Christof_constructor< T, 4, 4 > | |
| CFTensor::Christof_Expr< A, T, Dim0, Dim12, i, j, k > | |
| CFTensor::Christof_number_0< A, T, N > | |
| CFTensor::Christof_numeral_0< A, T > | |
| CFTensor::Christof_numeral_1< A, T > | |
| ►CADOLCPlasticity::ClosestPointProjection | Closest point projection algorithm |
| ►CADOLCPlasticity::J2Plasticity< 3 > | J2 (Von Misses) plasticity |
| CADOLCPlasticity::J2Plasticity< 2 > | [J2 2D] |
| ►CADOLCPlasticity::ParaboloidalPlasticity | [J2 2D] |
| CADOLCPlasticity::HeterogeneousParaboloidalPlasticity | |
| ►CCMakePackage | |
| Cpackage.MofemAdolcPlasticityModule | |
| Cpackage.MofemBasicFiniteElements | |
| Cpackage.MofemBoneRemodelling | |
| Cpackage.MofemCephas | |
| Cpackage.MofemMixedFractureModule | |
| CCohesiveElement::CohesiveInterfaceElement | Cohesive element implementation |
| CMoFEM::SchurElemMats::col_mi_tag | |
| CAtomTest::CommonData | Collected data use d by operator to evaluate errors for the test |
| CBoneRemodeling::CommonData | Data structure for storing global and local matrix K and vector f |
| CBoneRemodeling::Remodeling::CommonData | |
| CCohesiveElement::CohesiveInterfaceElement::CommonData | |
| CCommonData | |
| CConvectiveMassElement::CommonData | Common data used by volume elements |
| CKelvinVoigtDamper::CommonData | Common data for nonlinear_elastic_elem model |
| CMinimalSurfaceEquation::MinimalSurfaceElement::CommonData | Keep date between operators |
| CMixedPoisson::CommonData | |
| CNavierStokesElement::CommonData | |
| CNonlinearElasticElement::CommonData | Common data used by volume elements |
| CPhotonDiffusion::CommonData | |
| ►CPostProcCommonOnRefMesh::CommonData | |
| ►CPostProcCommonOnRefMesh::CommonDataForVolume | |
| CPostProcFatPrismOnRefinedMesh::CommonData | |
| CPostProcEdgeOnRefinedMesh::CommonData | |
| CPostProcFaceOnRefinedMesh::CommonData | |
| CReactionDiffusionEquation::CommonData | Common data |
| CStandardPoisson::CommonData | [Source function] |
| CThermalElement::CommonData | Common data used by volume elements |
| CThermalStressElement::CommonData | |
| ►CConvectiveMassElement::CommonFunctions | |
| CConvectiveMassElement::OpEnergy | |
| CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian | |
| CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumRhs | |
| CConvectiveMassElement::OpMassJacobian | |
| ►CConvectiveMassElement::OpMassLhs_dM_dv | |
| ►CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumLhs_dv | |
| CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumLhs_dX | |
| CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumLhs_dx | |
| CConvectiveMassElement::OpMassLhs_dM_dX | |
| CConvectiveMassElement::OpMassLhs_dM_dx | |
| ►CConvectiveMassElement::OpVelocityLhs_dV_dv | |
| CConvectiveMassElement::OpVelocityLhs_dV_dX | |
| CConvectiveMassElement::OpVelocityLhs_dV_dx | |
| CConvectiveMassElement::OpMassRhs | |
| CConvectiveMassElement::OpVelocityJacobian | |
| CConvectiveMassElement::OpVelocityRhs | |
| CMoFEM::ComposedProblemsData | |
| CMoFEM::Composite_Cubit_msId_And_MeshsetType_mi_tag | |
| CMoFEM::Composite_Ent_And_EntDofIdx_mi_tag | |
| CMoFEM::Composite_Ent_and_ShortId_mi_tag | |
| CMoFEM::Composite_Ent_Order_And_CoeffIdx_mi_tag | |
| CMoFEM::Composite_EntType_and_ParentEntType_mi_tag | |
| CMoFEM::Composite_EntType_and_Space_mi_tag | |
| CMoFEM::Composite_mi_tag | |
| CMoFEM::Composite_Name_And_Ent_And_EntDofIdx_mi_tag | |
| CMoFEM::Composite_Name_And_Ent_mi_tag | |
| CMoFEM::Composite_Name_And_Part_mi_tag | |
| CMoFEM::Composite_Name_Ent_And_Part_mi_tag | |
| CMoFEM::Composite_Name_Ent_Order_And_CoeffIdx_mi_tag | |
| CMoFEM::Composite_ParentEnt_And_BitsOfRefinedEdges_mi_tag | |
| CMoFEM::Composite_ParentEnt_And_EntType_mi_tag | |
| CMoFEM::Composite_Part_And_Order_mi_tag | |
| CMoFEM::Composite_SeriesID_And_Step_mi_tag | |
| CMoFEM::Composite_SeriesName_And_Step_mi_tag | |
| CMoFEM::Composite_SeriesName_And_Time_mi_tag | |
| CMoFEM::Composite_Unique_mi_tag | |
| CFTensor::conj_Tensor2< A, T, Dim0, Dim1, i, j > | |
| CKelvinVoigtDamper::ConstitutiveEquation< TYPE > | Constitutive model functions |
| CKelvinVoigtDamper::ConstitutiveEquation< adouble > | |
| CMoFEM::ConstrainMatrixCtx | Structure for projection matrices |
| CContact | |
| CContactOps::ContactIntegrators< BoundaryEleOp > | |
| CThermoElasticOps::ConvectionBcType< BC > | |
| CThermalElement::ConvectionData | Data for convection |
| CConvectiveMassElement | Structure grouping operators and data used for calculation of mass (convective) element \ nonlinear_elastic_elem |
| CCoordsAndHandle | |
| CMoFEM::CoreTmp< N > | |
| CMoFEM::CoreValue< V > | |
| CPoissonExample::CreateFiniteElements | Create finite elements instances |
| CMoFEM::CubitMeshsetMaskedType_mi_tag | |
| CMoFEM::CubitMeshSets | This struct keeps basic methods for moab meshset about material and boundary conditions |
| CMoFEM::CubitMeshSets_change_add_bit_to_cubit_bc_type | Change meshset type |
| CMoFEM::CubitMeshSets_change_attributes | |
| CMoFEM::CubitMeshSets_change_attributes_data_structure | |
| CMoFEM::CubitMeshSets_change_bc_data_structure | |
| CMoFEM::CubitMeshSets_change_name | Change meshset name |
| CMoFEM::CubitMeshsets_name | |
| CMoFEM::CubitMeshsetType_mi_tag | MultiIndex Tag for field id |
| Csdf.CylinderZ | |
| Csdf_ydirection.CylinderZ | |
| CEigenMatrix::d2MCoefficients< E, C > | |
| CEigenMatrix::d2MImpl< E, C, G > | |
| CEigenMatrix::d2MImpl< E, C, EigenMatrix::d2MCoefficients< E, C > > | |
| CFTensor::d_boundary_Tensor0< T, Dim, i > | |
| CFTensor::d_boundary_Tensor2_symmetric< T, Dim01, Dim2, i, j, k > | |
| CFTensor::d_one_sided_Tensor1< T, Dim, i, axis > | |
| CFTensor::d_one_sided_Tensor2_symmetric< T, Dim, i, j, axis > | |
| CDataAtIntegrationPts | |
| CDataAtIntegrationPtsSimpleRods | |
| CBoneRemodeling::Remodeling::CommonData::DataContainers | |
| CDataFromBc | Data from Cubit blocksets |
| CBoneRemodeling::DataFromMetaIO | Load data from MetaImage file, translate grayscale values to densities |
| ►CMoFEM::DataOperator | Base operator to do operations at Gauss Pt. level |
| ►CMoFEM::ForcesAndSourcesCore::UserDataOperator | |
| ►CMoFEM::OpCalculateScalarFieldValues_General< double, DoubleAllocator > | |
| CMoFEM::OpCalculateScalarFieldValues | Get value at integration points for scalar field |
| CGenericSliding::OpAssembleLhs< SizeLambda, SizePositions > | |
| CGenericSliding::OpAssembleLhs< SizeLambda, SizePositions > | |
| CGenericSliding::OpAssembleRhs< SizeLambda, SizePositions > | |
| CGenericSliding::OpAssembleRhs< SizeLambda, SizePositions > | |
| CGenericSliding::OpGetActiveDofsLambda | |
| CGenericSliding::OpGetActiveDofsLambda | |
| CGenericSliding::OpGetActiveDofsPositions< SizeLambda > | |
| CGenericSliding::OpGetActiveDofsPositions< SizeLambda > | |
| ►CMoFEM::ContactPrismElementForcesAndSourcesCore::UserDataOperator | Default operator for Contact Prism element |
| CMyOp< OP > | Operator used to check consistency between local coordinates and global cooridnates for integrated points and evaluated points |
| ►CMoFEM::EdgeElementForcesAndSourcesCore::UserDataOperator | Default operator for EDGE element |
| CEdgeForce::OpEdgeForce | |
| CEdgeSlidingConstrains::OpJacobian | |
| CEdgeSlidingConstrains::OpJacobian | |
| CExample::BoundaryOp | |
| CExample::OpCalcSurfaceAverageTemperature | |
| CMoFEM::OpGetHOTangentsOnEdge< FIELD_DIM > | Calculate tangent vector on edge form HO geometry approximation |
| CMoFEM::OpHOSetContravariantPiolaTransformOnEdge3D | Transform Hcurl base fluxes from reference element to physical edge |
| CMoFEM::OpSetContravariantPiolaTransformOnEdge2D | |
| ►CMoFEM::OpSetHOWeightsOnEdge | Modify integration weights on face to take in account higher-order geometry |
| CMoFEM::OpSetHOWeightsOnSubDim< 2 > | |
| COpFlux | |
| COpFlux | |
| COpSimpleRodK | Assemble contribution of SimpleRod element to LHS * |
| COpSimpleRodPreStress | Add ROD pre-stress to the RHS * |
| CPoisson2DLagrangeMultiplierOperators::OpBoundaryLhsC | |
| CPoisson2DLagrangeMultiplierOperators::OpBoundaryRhsG | |
| CPoisson2DNonhomogeneousOperators::OpBoundaryLhs | [OpDomainRhs] |
| CPoisson2DNonhomogeneousOperators::OpBoundaryRhs | [OpBoundaryLhs] |
| CSkeletonFE | |
| CSkeletonFE | |
| CSkeletonFE | |
| ►CMoFEM::FaceElementForcesAndSourcesCore::UserDataOperator | Default operator for TRI element |
| ►CThermalElement::OpGetFieldAtGaussPts< MoFEM::FaceElementForcesAndSourcesCore > | |
| CThermalElement::OpGetTriTemperatureAtGaussPts | Operator to calculate temperature at Gauss pts |
| CAnalyticalDirichletBC::ApproxField::OpLhs | Lhs operator used to build matrix |
| CAnalyticalDirichletBC::ApproxField::OpRhs< FUNEVAL > | Rhs operator used to build matrix |
| CFluidPressure::OpCalculatePressure | |
| CMagneticElement::OpNaturalBC | Calculate essential boundary conditions |
| CMetaSpringBC::OpGetNormalSpEle | Computes, for material configuration, normal to face that lies on a surface with springs |
| CMetaSpringBC::OpGetTangentSpEle | Computes, for material configuration, tangent vectors to face that lie on a surface with springs |
| ►CMetaSpringBC::OpSpringALEMaterialLhs | Base class for LHS-operators for pressure element (material configuration) |
| CMetaSpringBC::OpSpringALEMaterialLhs_dX_dX | LHS-operator for the pressure element (material configuration) |
| CMetaSpringBC::OpSpringALEMaterialLhs_dX_dx | LHS-operator for the pressure element (material configuration) |
| CMetaSpringBC::OpSpringFs | RHS-operator for the spring boundary condition element |
| CMetaSpringBC::OpSpringFsMaterial | RHS-operator for the spring boundary condition element for ALE formulation |
| CMetaSpringBC::OpSpringKs | LHS-operator for the springs element |
| CMetaSpringBC::OpSpringKs_dX | |
| CMixTransport::MixTransportElement::OpEvaluateBcOnFluxes | Evaluate boundary conditions on fluxes |
| CMixTransport::MixTransportElement::OpRhsBcOnValues | Calculate \( \int_\mathcal{S} {\boldsymbol\tau} \cdot \mathbf{n}u
\textrm{d}\mathcal{S} \) |
| CMixTransport::MixTransportElement::OpSkeleton | Calculate jump on entities |
| CMixTransport::UnsaturatedFlowElement::OpIntegrateFluxes | |
| CMixTransport::UnsaturatedFlowElement::OpRhsBcOnValues | Evaluate boundary condition at the boundary |
| ►CMoFEM::FaceElementForcesAndSourcesCoreOnSide::UserDataOperator | Default operator for Face element |
| CSkeletonFE::OpFaceSide | |
| CSkeletonFE::OpFaceSide | |
| CSkeletonFE::OpFaceSide | |
| ►CMoFEM::OpCalculateHOJacForFaceImpl< 2 > | |
| CMoFEM::OpCalculateHOJac< 2 > | |
| CMoFEM::OpCalculateHOJacForFaceImpl< 3 > | |
| CMoFEM::OpCalculateHcurlVectorCurl< 1, 3 > | Calculate curl of vector field |
| CMoFEM::OpCopyGeomDataToE< 2 > | Copy geometry-related data from one element to other |
| CMoFEM::OpGetHONormalsOnFace< FIELD_DIM > | Calculate normals at Gauss points of triangle element |
| CMoFEM::OpHOSetContravariantPiolaTransformOnFace3D | Transform Hdiv base fluxes from reference element to physical triangle |
| CMoFEM::OpHOSetCovariantPiolaTransformOnFace3D | Transform Hcurl base fluxes from reference element to physical triangle |
| CMoFEM::OpMakeHdivFromHcurl | Make Hdiv space from Hcurl space in 2d |
| ►CMoFEM::OpSetContravariantPiolaTransformOnFace2DImpl< 2 > | |
| CMoFEM::OpSetContravariantPiolaTransformOnFace2DImpl< 3 > | |
| CMoFEM::OpSetCovariantPiolaTransformOnFace2DImpl< 2 > | Apply contravariant (Piola) transfer to Hdiv space on face |
| ►CMoFEM::OpSetHOWeightsOnFace | Modify integration weights on face to take in account higher-order geometry |
| CMoFEM::OpSetHOWeightsOnSubDim< 3 > | |
| ►CMoFEM::OpSetInvJacHcurlFaceImpl< 2 > | |
| CMoFEM::OpSetInvJacHcurlFaceImpl< 3 > | |
| CNavierStokesElement::OpCalcDragForce | Calculate drag force on the fluid-solid interface |
| CNavierStokesElement::OpCalcDragTraction | Calculate drag traction on the fluid-solid interface |
| CNavierStokesElement::OpPostProcDrag | Post processing output of drag traction on the fluid-solid interface |
| CNeumannForcesSurface::OpGetTangent | Operator for computing tangent vectors |
| CNeumannForcesSurface::OpNeumannFlux | Operator for flux element |
| CNeumannForcesSurface::OpNeumannForce | Operator for force element |
| CNeumannForcesSurface::OpNeumannForceAnalytical | Operator for force element |
| CNeumannForcesSurface::OpNeumannPressure | RHS-operator for pressure element (spatial configuration) |
| CNeumannForcesSurface::OpNeumannPressureLhs_dx_dX | LHS-operator for pressure element (spatial configuration) |
| ►CNeumannForcesSurface::OpNeumannPressureMaterialLhs | Base class for LHS-operators for pressure element (material configuration) |
| CNeumannForcesSurface::OpNeumannPressureMaterialLhs_dX_dX | LHS-operator for the pressure element (material configuration) |
| CNeumannForcesSurface::OpNeumannPressureMaterialLhs_dX_dx | LHS-operator for the pressure element (material configuration) |
| CNeumannForcesSurface::OpNeumannPressureMaterialRhs_dX | RHS-operator for the pressure element (material configuration) |
| CNeumannForcesSurface::OpNeumannSurfaceForceLhs_dx_dX | LHS-operator for surface force element (spatial configuration) |
| ►CNeumannForcesSurface::OpNeumannSurfaceForceMaterialLhs | Base class for LHS-operators for pressure element (material configuration) |
| CNeumannForcesSurface::OpNeumannSurfaceForceMaterialLhs_dX_dX | LHS-operator for the surface force element (material configuration) |
| CNeumannForcesSurface::OpNeumannSurfaceForceMaterialLhs_dX_dx | LHS-operator for the surface force element (material configuration) |
| CNeumannForcesSurface::OpNeumannSurfaceForceMaterialRhs_dX | RHS-operator for the surface force element (material configuration) |
| CNeumannForcesSurfaceComplexForLazy::AuxMethodMaterial | |
| CNeumannForcesSurfaceComplexForLazy::AuxMethodSpatial | |
| COpCheckValsDiffVals | |
| COpDivergence | |
| COpDivergence | |
| COpFace | |
| COpPressure | |
| CPoisson2DLagrangeMultiplierOperators::OpDomainLhsK | |
| CPoisson2DLagrangeMultiplierOperators::OpDomainRhsF | |
| CPoisson2DNonhomogeneousOperators::OpDomainLhs | [OpDomainLhs] |
| CPoisson2DNonhomogeneousOperators::OpDomainRhs | [OpDomainLhs] |
| CQuadOpCheck | |
| CQuadOpLhs | |
| CQuadOpRhs | |
| CReactionDiffusionEquation::OpAssembleMass | Assemble mass matrix |
| CReactionDiffusionEquation::OpAssembleSlowRhs | Assemble slow part |
| CReactionDiffusionEquation::OpAssembleStiffLhs< DIM > | Assemble stiff part tangent |
| CReactionDiffusionEquation::OpAssembleStiffRhs< DIM > | Assemble stiff part |
| CSurfaceSlidingConstrains::OpJacobian | |
| CSurfaceSlidingConstrains::OpJacobian | |
| CThermalElement::OpConvectionLhs | |
| CThermalElement::OpConvectionRhs | Operator to calculate convection therms on body surface and assemble to rhs of equations |
| CThermalElement::OpHeatFlux | Operator for calculate heat flux and assemble to right hand side |
| CThermalElement::OpRadiationLhs | |
| CThermalElement::OpRadiationRhs | Operator to calculate radiation therms on body surface and assemble to rhs of transient equations(Residual Vector) |
| ►CMoFEM::FlatPrismElementForcesAndSourcesCore::UserDataOperator | Default operator for Flat Prism element |
| CMoFEM::OpCalculateInvJacForFlatPrism | Calculate inverse of jacobian for face element |
| CMoFEM::OpSetInvJacH1ForFlatPrism | Transform local reference derivatives of shape functions to global derivatives |
| CMoFEM::OpAddParentEntData | Operator to project base functions from parent entity to child |
| ►CMoFEM::OpBaseDerivativesBase | |
| ►CMoFEM::OpBaseDerivativesMass< 1 > | |
| CMoFEM::OpBaseDerivativesMass< 3 > | |
| ►CMoFEM::OpBaseDerivativesNext< 1 > | Specialisation for calculate derivatives for scalar base functions |
| CMoFEM::OpBaseDerivativesNext< 3 > | Specialisation for calculate derivatives for scalar base functions |
| ►CMoFEM::OpDGProjectionCoefficients | |
| CMoFEM::OpDGProjectionEvaluation | |
| CMoFEM::OpDGProjectionMassMatrix | |
| CMoFEM::OpCalcNormL2Tensor0 | Get norm of input VectorDouble for Tensor0 |
| CMoFEM::OpCalcNormL2Tensor1< DIM > | Get norm of input MatrixDouble for Tensor1 |
| CMoFEM::OpCalcNormL2Tensor2< DIM_1, DIM_2 > | Get norm of input MatrixDouble for Tensor2 |
| CMoFEM::OpCalculateBrokenHVecTensorDivergence< Tensor_Dim0, Tensor_Dim1, CoordSys > | Calculate divergence of tonsorial field using vectorial base |
| CMoFEM::OpCalculateBrokenHVecTensorField< Tensor_Dim0, Tensor_Dim1 > | Get tensor field for H-div approximation |
| CMoFEM::OpCalculateDivergenceVectorFieldValues< Tensor_Dim, COORDINATE_SYSTEM > | Calculate field values (template specialization) for tensor field rank 1, i.e. vector field |
| CMoFEM::OpCalculateHOCoords< FIELD_DIM > | Calculate HO coordinates at gauss points |
| CMoFEM::OpCalculateHTensorTensorField< Tensor_Dim0, Tensor_Dim1 > | Calculate tenor field using tensor base, i.e. Hdiv/Hcurl |
| CMoFEM::OpCalculateHVecTensorDivergence< Tensor_Dim0, Tensor_Dim1, CoordSys > | Calculate divergence of tonsorial field using vectorial base |
| CMoFEM::OpCalculateHVecTensorField< Tensor_Dim0, Tensor_Dim1 > | Calculate tenor field using vectorial base, i.e. Hdiv/Hcurl |
| CMoFEM::OpCalculateHVecVectorFieldDot< 3, Field_Dim > | |
| CMoFEM::OpCalculateHVecVectorField_General< 3, Field_Dim, double, ublas::row_major, DoubleAllocator > | Get vector field for H-div approximation |
| CMoFEM::OpCalculateHVecVectorGradient< BASE_DIM, SPACE_DIM > | Calculate gradient of vector field |
| CMoFEM::OpCalculateHVecVectorHessian< BASE_DIM, SPACE_DIM > | Calculate gradient of vector field |
| CMoFEM::OpCalculateHcurlVectorCurl< 1, 2 > | Calculate curl of vector field |
| CMoFEM::OpCalculateHcurlVectorCurl< 3, 3 > | Calculate curl of vector field |
| CMoFEM::OpCalculateHdivVectorDivergence< BASE_DIM, SPACE_DIM > | Calculate divergence of vector field |
| CMoFEM::OpCalculateHdivVectorDivergenceDot< Tensor_Dim1, Tensor_Dim2 > | Calculate divergence of vector field dot |
| CMoFEM::OpCalculateScalarFieldValuesFromPetscVecImpl< CTX > | Get rate of scalar field at integration points |
| CMoFEM::OpCalculateScalarFieldValues_General< T, A > | Scalar field values at integration points |
| CMoFEM::OpCalculateTensor2FieldValuesDot< Tensor_Dim0, Tensor_Dim1 > | Get time direvarive values at integration pts for tensor field rank 2, i.e. matrix field |
| ►CMoFEM::OpCalculateTensor2FieldValues_General< Tensor_Dim0, Tensor_Dim1, T, L, A > | Calculate field values for tenor field rank 2 |
| CMoFEM::OpCalculateTensor2SymmetricFieldGradient_General< Tensor_Dim0, Tensor_Dim1, T, L, A > | Evaluate field gradient values for symmetric 2nd order tensor field, i.e. gradient is tensor rank 3 |
| CMoFEM::OpCalculateVectorFieldGradient_General< Tensor_Dim0, Tensor_Dim1, S, T, L, A > | Evaluate field gradient values for vector field, i.e. gradient is tensor rank 2 |
| ►CMoFEM::OpCalculateTensor2FieldValues_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, DoubleAllocator > | |
| ►CMoFEM::OpCalculateVectorFieldGradient_General< Tensor_Dim0, Tensor_Dim1, Tensor_Dim0, double, ublas::row_major, DoubleAllocator > | |
| CMoFEM::OpCalculateVectorFieldGradient< Tensor_Dim0, Tensor_Dim1, S > | Get field gradients at integration pts for scalar field rank 0, i.e. vector field |
| CMoFEM::OpCalculateTensor2FieldValues< Tensor_Dim0, Tensor_Dim1 > | Get values at integration pts for tensor field rank 2, i.e. matrix field |
| ►CMoFEM::OpCalculateTensor2SymmetricFieldGradient_General< Tensor_Dim0, Tensor_Dim1, double, ublas::row_major, DoubleAllocator > | |
| CMoFEM::OpCalculateTensor2SymmetricFieldGradient< Tensor_Dim0, Tensor_Dim1 > | Get field gradients at integration pts for symmetric tensorial field rank 2 |
| CMoFEM::OpCalculateVectorFieldGradient_General< Tensor_Dim0, Tensor_Dim1, S, double, ublas::row_major, DoubleAllocator > | |
| CMoFEM::OpCalculateVectorFieldHessian< Tensor_Dim0, Tensor_Dim1 > | |
| CMoFEM::OpCalculateTensor2SymmetricFieldValues< Tensor_Dim > | Calculate symmetric tensor field values at integration pts |
| CMoFEM::OpCalculateTensor2SymmetricFieldValuesDot< Tensor_Dim > | Calculate symmetric tensor field rates ant integratio pts |
| CMoFEM::OpCalculateTraceFromMat< DIM > | Calculates the trace of an input matrix |
| CMoFEM::OpCalculateTraceFromSymmMat< DIM > | Calculates the trace of an input matrix |
| CMoFEM::OpCalculateVectorFieldGradientDot< Tensor_Dim0, Tensor_Dim1 > | Get field gradients time derivative at integration pts for scalar field rank 0, i.e. vector field |
| CMoFEM::OpCalculateVectorFieldValuesFromPetscVecImpl< Tensor_Dim, CTX > | Approximate field values for given petsc vector |
| ►CMoFEM::OpCalculateVectorFieldValues_General< Tensor_Dim, T, L, A > | Calculate field values for tenor field rank 1, i.e. vector field |
| CMoFEM::OpCalculateScalarFieldGradient_General< Tensor_Dim, T, L, A > | Evaluate field gradient values for scalar field, i.e. gradient is tensor rank 1 (vector) |
| ►CMoFEM::OpCalculateVectorFieldValues_General< Tensor_Dim, double, ublas::row_major, DoubleAllocator > | Calculate field values (template specialization) for tensor field rank 1, i.e. vector field |
| ►CMoFEM::OpCalculateScalarFieldGradient_General< Tensor_Dim, double, ublas::row_major, DoubleAllocator > | Evaluate field gradient values for scalar field, i.e. gradient is tensor rank 1 (vector), specialization |
| CMoFEM::OpCalculateScalarFieldGradient< Tensor_Dim > | Get field gradients at integration pts for scalar field rank 0, i.e. vector field |
| CMoFEM::OpCalculateScalarFieldHessian< Tensor_Dim > | Evaluate field gradient values for scalar field, i.e. gradient is tensor rank 1 (vector), specialization |
| CMoFEM::OpCalculateVectorFieldValues< Tensor_Dim > | Get values at integration pts for tensor field rank 1, i.e. vector field |
| CMoFEM::OpGetTensor0fromFunc | Get values from scalar function at integration points and save them to VectorDouble for Tensor0 |
| CMoFEM::OpGetTensor1fromFunc< SPACE_DIM, BASE_DIM > | |
| CMoFEM::OpInvertMatrix< DIM > | |
| CMoFEM::OpLoopRange< E > | Iterate over range of (sub)elements |
| ►CMoFEM::OpLoopSide< E > | Element used to execute operators on side of the element |
| CMoFEM::OpBrokenLoopSide< E > | Operator for broken loop side |
| CMoFEM::OpLoopThis< E > | Execute "this" element in the operator |
| CMoFEM::OpPostProcMapInMoab< DIM1, DIM2, O > | Post post-proc data at points from hash maps |
| CMoFEM::OpRunParent | Operator to execute finite element instance on parent element. This operator is typically used to project field from parent to child, or vice versa. It enables to evaluate field data of parent entity on chile entity integration points |
| CMoFEM::OpScaleBaseBySpaceInverseOfMeasure | Scale base functions by inverses of measure of element |
| CMoFEM::OpScaleMatrix | |
| ►CMoFEM::OpSchurAssembleBase | |
| ►CMoFEM::OpSchurAssembleBaseImpl | |
| ►CMoFEM::OpSchurAssembleEndImpl< OpSchurAssembleBaseImpl > | |
| CMoFEM::OpSchurAssembleEnd< SchurDGESV > | |
| CMoFEM::OpSchurAssembleEnd< SchurDSYSV > | |
| CMoFEM::OpSchurAssembleBegin | Clear Schur complement internal data |
| CMoFEM::OpSchurZeroRowsAndCols | |
| CMoFEM::OpSetBc | Set indices on entities on finite element |
| CMoFEM::OpSetHOContravariantPiolaTransform | Apply contravariant (Piola) transfer to Hdiv space for HO geometry |
| CMoFEM::OpSetHOCovariantPiolaTransform | Apply covariant (Piola) transfer to Hcurl space for HO geometry |
| CMoFEM::OpSetHOInvJacVectorBase | Transform local reference derivatives of shape function to global derivatives if higher order geometry is given |
| CMoFEM::OpSetHOWeights | Set inverse jacobian to base functions |
| ►CMoFEM::OpSetInvJacToScalarBasesBasic | |
| ►CMoFEM::OpSetHOInvJacToScalarBasesImpl | |
| CMoFEM::OpSetHOInvJacToScalarBases< DIM > | Set inverse jacobian to base functions |
| ►CMoFEM::OpSetInvJacSpaceForFaceImpl< 2, 1 > | |
| CMoFEM::OpBaseDerivativesSetHOInvJacobian< 2 > | |
| CMoFEM::OpSetHOInvJacToScalarBases< 2 > | |
| CMoFEM::OpSetInvJacH1ForFace< DERIVARIVE > | |
| CMoFEM::OpSetInvJacL2ForFace< DERIVARIVE > | |
| CMoFEM::OpSetInvJacSpaceForFaceImpl< 2, 2 > | |
| ►CMoFEM::OpSetInvJacSpaceForFaceImpl< 3, 1 > | |
| CMoFEM::OpSetInvJacH1ForFaceEmbeddedIn3DSpace< DERIVARIVE > | |
| CMoFEM::OpSetInvJacL2ForFaceEmbeddedIn3DSpace< DERIVARIVE > | |
| CMoFEM::OpSymmetrizeTensor< DIM > | |
| CMoFEM::OpTensorTimesSymmetricTensor< DIM_01, DIM_23, S > | Calculate \( \pmb\sigma_{ij} = \mathbf{D}_{ijkl} \pmb\varepsilon_{kl}
\) |
| CMoFEM::OpUnSetBc | |
| ►CMoFEM::VertexElementForcesAndSourcesCore::UserDataOperator | Default operator for VERTEX element |
| CNodalForce::OpNodalForce | Operator to assemble nodal force into right hand side vector |
| ►CMoFEM::VolumeElementForcesAndSourcesCore::UserDataOperator | |
| ►CEshelbianPlasticity::OpAssembleBasic< VolUserDataOperator > | |
| ►CEshelbianPlasticity::OpAssembleVolume | |
| CEshelbianPlasticity::HMHHencky::OpSpatialPhysical | |
| CEshelbianPlasticity::HMHHencky::OpSpatialPhysicalExternalStrain | |
| CEshelbianPlasticity::HMHHencky::OpSpatialPhysical_du_du | |
| CEshelbianPlasticity::HMHNeohookean::OpSpatialPhysical | |
| CEshelbianPlasticity::HMHNeohookean::OpSpatialPhysicalExternalStrain | |
| ►CEshelbianPlasticity::OpAssembleVolumePositiveDefine | |
| CEshelbianPlasticity::HMHNeohookean::OpSpatialPhysical_du_du | |
| CEshelbianPlasticity::OpAssembleVolumeStabilize | |
| CEshelbianPlasticity::OpSpatialConsistencyBubble | |
| CEshelbianPlasticity::OpSpatialConsistencyDivTerm | |
| CEshelbianPlasticity::OpSpatialConsistencyP | |
| CEshelbianPlasticity::OpSpatialConsistency_dBubble_dBubble | |
| CEshelbianPlasticity::OpSpatialConsistency_dBubble_dP | |
| CEshelbianPlasticity::OpSpatialConsistency_dBubble_domega | |
| CEshelbianPlasticity::OpSpatialConsistency_dP_dP | |
| CEshelbianPlasticity::OpSpatialConsistency_dP_domega | |
| CEshelbianPlasticity::OpSpatialEquilibrium | |
| CEshelbianPlasticity::OpSpatialEquilibrium_dw_dP | |
| CEshelbianPlasticity::OpSpatialEquilibrium_dw_dw | |
| CEshelbianPlasticity::OpSpatialPhysical | |
| CEshelbianPlasticity::OpSpatialPhysicalInternalStress< VOIGT > | |
| CEshelbianPlasticity::OpSpatialPhysical_du_dBubble | |
| CEshelbianPlasticity::OpSpatialPhysical_du_dP | |
| CEshelbianPlasticity::OpSpatialPhysical_du_domega | |
| CEshelbianPlasticity::OpSpatialPhysical_du_du | |
| CEshelbianPlasticity::OpSpatialPrj | |
| CEshelbianPlasticity::OpSpatialPrj_dx_dw | |
| CEshelbianPlasticity::OpSpatialPrj_dx_dx | |
| CEshelbianPlasticity::OpSpatialRotation | |
| CEshelbianPlasticity::OpSpatialRotation_domega_dBubble | |
| CEshelbianPlasticity::OpSpatialRotation_domega_dP | |
| CEshelbianPlasticity::OpSpatialRotation_domega_domega | |
| CEshelbianPlasticity::OpSpatialRotation_domega_du | |
| ►COpAssembleBasic< VolUserDataOperator > | |
| ►COpAssembleVolume | |
| COpAssembleVolumePositiveDefine | |
| COpAssembleVolumeStabilize | |
| COpSpatialConsistencyBubble | |
| COpSpatialConsistencyDivTerm | |
| COpSpatialConsistencyP | |
| COpSpatialConsistency_dBubble_dBubble | |
| COpSpatialConsistency_dBubble_dP | |
| COpSpatialConsistency_dBubble_domega | |
| COpSpatialConsistency_dP_dP | |
| COpSpatialConsistency_dP_domega | |
| COpSpatialEquilibrium | |
| COpSpatialEquilibrium_dw_dP | |
| COpSpatialEquilibrium_dw_dw | |
| COpSpatialPhysicalInternalStress< VOIGT > | |
| COpSpatialPhysical_du_dBubble | |
| COpSpatialPhysical_du_dP | |
| COpSpatialPhysical_du_domega | |
| COpSpatialPrj | |
| COpSpatialPrj_dx_dw | |
| COpSpatialPrj_dx_dx | |
| COpSpatialRotation | |
| COpSpatialRotation_domega_dBubble | |
| COpSpatialRotation_domega_dP | |
| COpSpatialRotation_domega_domega | |
| COpSpatialRotation_domega_du | |
| ►CThermalElement::OpGetFieldAtGaussPts< MoFEM::VolumeElementForcesAndSourcesCore > | |
| CThermalElement::OpGetTetRateAtGaussPts | Operator to calculate temperature rate at Gauss pts |
| CThermalElement::OpGetTetTemperatureAtGaussPts | Operator to calculate temperature at Gauss pts |
| CBodyForceConstantField::OpBodyForce | |
| CBoneRemodeling::OpAssmbleRhoLhs_dF | Off diagonal block of tangent matrix \(K_{\rho u}\) |
| CBoneRemodeling::OpAssmbleRhoLhs_dRho | Diagonal block of tangent matrix \(K_{\rho\rho}\) |
| CBoneRemodeling::OpAssmbleRhoRhs | Assemble residual for conservation of mass (density) |
| CBoneRemodeling::OpAssmbleRhs | Assemble RHS vector f |
| CBoneRemodeling::OpAssmbleStressLhs_dF< ADOLC > | Off diagonal block of tangent matrix \(K_{u u}\) |
| CBoneRemodeling::OpAssmbleStressLhs_dRho | Off diagonal block of tangent matrix \(K_{u \rho}\) /f[ K_{u \rho}=\intop_{V} \left[\frac{n}{\rho_{0}}\right] \left[\frac{\rho_{0}}{\rho_{0}^{\ast}}\right]^{n} \nabla N_j P_{ij} N_i \,dV /f] |
| CBoneRemodeling::OpAssmbleStressRhs | Assemble residual for conservation of momentum (stresses) |
| CBoneRemodeling::OpCalculateLhs | Assemble LHS matrix K |
| CBoneRemodeling::OpCalculateStress | Evaluate physical equations at integration points |
| CBoneRemodeling::OpCalculateStressTangent | |
| CBoneRemodeling::OpCalculateStressTangentWithAdolc | |
| CBoneRemodeling::OpCalulatefRhoAtGaussPts | Assemble local vector containing density data |
| CBoneRemodeling::OpGetRhoTimeDirevative | Evaluate density derivative with respect to time in case of Backward Euler Method |
| CBoneRemodeling::OpMassAndEnergyCalculation | |
| CBoneRemodeling::OpMassCalculation | Calculate mass before approximation |
| CBoneRemodeling::OpMassCalculationFromApprox | Calculate mass after approximation |
| CBoneRemodeling::OpPostProcStress | Used to post proc stresses, energy, source term |
| CBoneRemodeling::OpVolumeCalculation | Calculate volume of the model |
| CEshelbianPlasticity::OpGetScale | |
| CExample::OpFirst | |
| CExample::OpSecond | [Operator] |
| CExample::OpZero | [Common data] |
| CFieldApproximationH1::OpApproxVolume< FUNEVAL > | Gauss point operators to calculate matrices and vectors |
| ►CKelvinVoigtDamper::AssembleMatrix | |
| CKelvinVoigtDamper::OpLhsdxdot | Assemble matrix |
| CKelvinVoigtDamper::OpLhsdxdx | Assemble matrix |
| ►CKelvinVoigtDamper::AssembleVector | |
| CKelvinVoigtDamper::OpRhsStress | Assemble internal force vector |
| CKelvinVoigtDamper::OpGetDataAtGaussPts | |
| CKelvinVoigtDamper::OpJacobian | |
| CMagneticElement::OpCurlCurl | Calculate and assemble CurlCurl matrix |
| CMagneticElement::OpPostProcessCurl | Calculate and assemble CurlCurl matrix |
| CMagneticElement::OpStab | Calculate and assemble stabilization matrix |
| CMixTransport::MixTransportElement::OpDivTauU_HdivL2 | Assemble \( \int_\mathcal{T} u \textrm{div}[\boldsymbol\tau]
\textrm{d}\mathcal{T} \) |
| CMixTransport::MixTransportElement::OpError | Calculate error evaluator |
| CMixTransport::MixTransportElement::OpFluxDivergenceAtGaussPts | Calculate flux at integration point |
| CMixTransport::MixTransportElement::OpL2Source | Calculate source therms, i.e. \(\int_\mathcal{T} f v
\textrm{d}\mathcal{T}\) |
| CMixTransport::MixTransportElement::OpPostProc | |
| CMixTransport::MixTransportElement::OpTauDotSigma_HdivHdiv | Assemble \(\int_\mathcal{T} \mathbf{A} \boldsymbol\sigma \cdot
\boldsymbol\tau \textrm{d}\mathcal{T}\) |
| CMixTransport::MixTransportElement::OpVDivSigma_L2Hdiv | \( \int_\mathcal{T} \textrm{div}[\boldsymbol\sigma] v
\textrm{d}\mathcal{T} \) |
| CMixTransport::MixTransportElement::OpValuesAtGaussPts | Calculate values at integration points |
| CMixTransport::MixTransportElement::OpValuesGradientAtGaussPts | Calculate gradients of values at integration points |
| CMixTransport::UnsaturatedFlowElement::OpDivTauU_HdivL2 | |
| CMixTransport::UnsaturatedFlowElement::OpEvaluateInitiallHead | |
| CMixTransport::UnsaturatedFlowElement::OpPostProcMaterial | |
| CMixTransport::UnsaturatedFlowElement::OpResidualFlux | Assemble flux residual |
| CMixTransport::UnsaturatedFlowElement::OpResidualMass | |
| CMixTransport::UnsaturatedFlowElement::OpTauDotSigma_HdivHdiv | |
| CMixTransport::UnsaturatedFlowElement::OpVDivSigma_L2Hdiv | |
| CMixTransport::UnsaturatedFlowElement::OpVU_L2L2 | |
| ►CMoFEM::FatPrismElementForcesAndSourcesCore::UserDataOperator | Default operator for Flat Prism element |
| CMoFEM::OpCalculateInvJacForFatPrism | Calculate inverse of jacobian for face element |
| CMoFEM::OpMultiplyDeterminantOfJacobianAndWeightsForFatPrisms | Operator for fat prism element updating integration weights in the volume |
| CMoFEM::OpSetInvJacH1ForFatPrism | Transform local reference derivatives of shape functions to global derivatives |
| CPrismOp | |
| CPrismOpCheck | |
| CPrismOpLhs | |
| CPrismOpRhs | |
| ►CMoFEM::OpCalculateHOJacForVolume | Calculate jacobian on Hex or other volume which is not simplex |
| CMoFEM::OpCalculateHOJac< 3 > | |
| CMoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide::UserDataOperator | Default operator for TET element |
| ►CMoFEM::VolumeElementForcesAndSourcesCoreOnSide::UserDataOperator | Default operator for TET element |
| ►CMetaSpringBC::SpringALEMaterialVolOnSideLhs | Base class for LHS-operators (material) on side volumes |
| CMetaSpringBC::SpringALEMaterialVolOnSideLhs_dX_dX | LHS-operator (material configuration) on the side volume |
| CMetaSpringBC::SpringALEMaterialVolOnSideLhs_dX_dx | LHS-operator (material configuration) on the side volume for spring element |
| CNeumannForcesSurface::OpCalculateDeformation | Operator for computing deformation gradients in side volumes |
| ►CNeumannForcesSurface::OpNeumannPressureMaterialVolOnSideLhs | Base class for LHS-operators (material) on side volumes |
| CNeumannForcesSurface::OpNeumannPressureMaterialVolOnSideLhs_dX_dX | LHS-operator (material configuration) on the side volume |
| CNeumannForcesSurface::OpNeumannPressureMaterialVolOnSideLhs_dX_dx | LHS-operator (material configuration) on the side volume |
| ►CNeumannForcesSurface::OpNeumannSurfaceForceMaterialVolOnSideLhs | Base class for LHS-operators (material) on side volumes |
| CNeumannForcesSurface::OpNeumannSurfaceForceMaterialVolOnSideLhs_dX_dX | LHS-operator (material configuration) on the side volume |
| CNeumannForcesSurface::OpNeumannSurfaceForceMaterialVolOnSideLhs_dX_dx | LHS-operator (material configuration) on the side volume |
| ►CNavierStokesElement::OpAssembleLhs | Base class for operators assembling LHS |
| CNavierStokesElement::OpAssembleLhsDiagLin | Assemble linear (symmetric) part of the diagonal block of the LHS Operator for assembling linear (symmetric) part of the diagonal block of the LHS |
| CNavierStokesElement::OpAssembleLhsDiagNonLin | Assemble non-linear (non-symmetric) part of the diagonal block of the LHS Operator for assembling non-linear (non-symmetric) part of the diagonal block of the LHS |
| CNavierStokesElement::OpAssembleLhsOffDiag | Assemble off-diagonal block of the LHS Operator for assembling off-diagonal block of the LHS |
| ►CNavierStokesElement::OpAssembleRhs | Base class for operators assembling RHS |
| CNavierStokesElement::OpAssembleRhsPressure | Assemble the pressure component of the RHS vector |
| CNavierStokesElement::OpAssembleRhsVelocityLin | Assemble linear part of the velocity component of the RHS vector |
| CNavierStokesElement::OpAssembleRhsVelocityNonLin | Assemble non-linear part of the velocity component of the RHS vector |
| CNavierStokesElement::OpCalcVolumeFlux | Calculating volumetric flux |
| CNavierStokesElement::OpPostProcVorticity | Post processing output of the vorticity criterion levels |
| CNonlinearElasticElement::OpEnergy | |
| ►CNonlinearElasticElement::OpGetDataAtGaussPts | |
| CNonlinearElasticElement::OpGetCommonDataAtGaussPts | |
| CNonlinearElasticElement::OpJacobianEnergy | Calculate explicit derivative of free energy |
| ►CNonlinearElasticElement::OpJacobianPiolaKirchhoffStress | Operator performs automatic differentiation |
| CNonlinearElasticElement::OpJacobianEshelbyStress | |
| CSmoother::OpJacobianSmoother | |
| CSmoother::OpJacobianSmoother | |
| ►CNonlinearElasticElement::OpLhsPiolaKirchhoff_dx | |
| CNonlinearElasticElement::OpLhsEshelby_dX | |
| ►CNonlinearElasticElement::OpLhsPiolaKirchhoff_dX | |
| CNonlinearElasticElement::OpLhsEshelby_dx | |
| CSmoother::OpLhsSmoother | |
| CSmoother::OpLhsSmoother | |
| ►CNonlinearElasticElement::OpRhsPiolaKirchhoff | |
| CNonlinearElasticElement::OpRhsEshelbyStress | |
| CSmoother::OpRhsSmoother | |
| CSmoother::OpRhsSmoother | |
| COpAleLhsPre_dX_dx< S > | |
| ►COpAssemble | |
| COpAleLhsWithDensity_dX_dX | |
| COpAleLhsWithDensity_dx_dX | |
| COpAleLhs_dX_dX< S > | |
| COpAleLhs_dX_dx | |
| COpAleLhs_dx_dX< S > | |
| COpAleLhs_dx_dx< S > | |
| COpAleRhs_dX | |
| COpAleRhs_dx | |
| COpAnalyticalInternalAleStrain_dX< S > | |
| COpAnalyticalInternalAleStrain_dx< S > | |
| COpAnalyticalInternalStrain_dx< S > | |
| COpLhs_dx_dx< S > | |
| COpRhs_dx | |
| COpCalculateEnergy | |
| COpCalculateEshelbyStress | |
| COpCalculateHomogeneousStiffness< S > | |
| COpCalculateRotationAndSpatialGradient | |
| COpCalculateStiffnessScaledByDensityField | |
| COpCalculateStrain< D > | |
| COpCalculateStrainAle | |
| COpCalculateStress< S > | |
| COpCheck | |
| COpPostProcStress | |
| COpVolumeAssemble | |
| COpVolumeCalculation | |
| COpVolumeSet | Operator set cache stored data, in this example, global indices, but it can be any structure |
| COpVolumeTest | Test if cached data can be accessed, and check consistency of data |
| CPostProcHookStress | Operator post-procesing stresses for Hook isotropic material |
| CPostProcStress | |
| CThermalElement::OpGetGradAtGaussPts | Operator to calculate temperature gradient at Gauss points |
| CThermalElement::OpHeatCapacityLhs | Operator to calculate left hand side of heat capacity terms |
| CThermalElement::OpHeatCapacityRhs | Operator to calculate right hand side of heat capacity terms |
| CThermalElement::OpThermalLhs | |
| CThermalElement::OpThermalRhs | |
| CThermalStressElement::OpGetTemperatureAtGaussPts | |
| CThermalStressElement::OpThermalStressRhs | |
| CVolumeCalculation | Calculate volume |
| CPostProcCommonOnRefMesh::OpGetFieldGradientValues | Operator to post-process (save gradients on refined post-processing mesh) field gradient |
| CPostProcCommonOnRefMesh::OpGetFieldValues | Operator to post-process (save gradients on refined post-processing mesh) field gradient |
| CMoFEM::OpGetCoordsAndNormalsOnPrism | Calculate normals at Gauss points of triangle element |
| CMoFEM::OpGetDataAndGradient< RANK, DIM > | Get field values and gradients at Gauss points |
| CMoFEM::OpGetHOTangentOnEdge | Calculate tangent vector on edge form HO geometry approximation |
| CMoFEM::OpSetContravariantPiolaTransform | Apply contravariant (Piola) transfer to Hdiv space |
| CMoFEM::OpSetContravariantPiolaTransformOnFace | Transform Hdiv base fluxes from reference element to physical triangle |
| CMoFEM::OpSetCovariantPiolaTransform | Apply covariant transfer to Hcurl space |
| CMoFEM::OpSetCovariantPiolaTransformOnEdge | Transform Hcurl base fluxes from reference element to physical edge |
| CMoFEM::OpSetCovariantPiolaTransformOnFace | Transform Hcurl base fluxes from reference element to physical triangle |
| CMoFEM::OpSetInvJacH1 | Transform local reference derivatives of shape function to global derivatives |
| CMoFEM::OpSetInvJacHdivAndHcurl | Brief Transform local reference derivatives of shape function to global derivatives |
| CFTensor::dd_boundary_Tensor0< T, Dim, i, j > | |
| CFTensor::dd_boundary_Tensor2_symmetric< T, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg< T, Tensor_Dim01, Tensor_Dim23 > | |
| CFTensor::Ddg< A, Dim01, Dim23 > | |
| CFTensor::Ddg< A, Tensor_Dim01, Tensor_Dim23 > | |
| CFTensor::Ddg< double, 3, 3 > | |
| CFTensor::Ddg< double, Dim, Dim > | |
| ►CFTensor::Ddg< T *, Tensor_Dim01, Tensor_Dim23 > | |
| CFTensor::Ddg< PackPtr< T *, I >, Tensor_Dim01, Tensor_Dim23 > | |
| CFTensor::Ddg_and_Ddg0213< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_and_Ddg0321< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_and_Tensor2_symmetric< A, B, T, U, Dim01_0, Dim23_0, Dim_1, i0, j0, k0, l0, i1, j1 > | |
| CFTensor::Ddg_and_Tensor2_symmetric< A, B, T, U, Dim01, Dim23, Dim01, i, j, k, l, i, j > | |
| CFTensor::Ddg_and_Tensor2_symmetric< A, B, T, U, Dim01, Dim23, Dim23, i, j, k, l, k, l > | |
| CFTensor::Ddg_carat_Ddg_13< A, B, T, U, Dim, Dim23, i, j, k, l, m, n > | |
| CFTensor::Ddg_carat_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_Expr< A, T, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_Expr< A, T, Dim, Dim, i, j, k, l > | |
| CFTensor::Ddg_Expr< A, T, Dim, Dim, i, k, j, l > | |
| CFTensor::Ddg_Expr< A, T, Dim, Dim, i, k, l, j > | |
| CFTensor::Ddg_Expr< A, T, Dim01, Dim23, i, j, m, n > | |
| CFTensor::Ddg_Expr< A, T, Dim01, Dim23, m, n, k, l > | |
| CFTensor::Ddg_Expr< A, T, Dim45, Dim01, i, j, m, n > | |
| CFTensor::Ddg_Expr< A, T, Dim45, Dim01, m, n, i, j > | |
| CFTensor::Ddg_Expr< B, U, Dim, Dim, i, l, k, j > | |
| CFTensor::Ddg_Expr< B, U, Dim, Dim23, j, l, m, n > | |
| CFTensor::Ddg_Expr< B, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_Expr< B, U, Dim23, Dim01, k, l, i, j > | |
| CFTensor::Ddg_Expr< B, U, Dim23, Dim45, k, l, m, n > | |
| CFTensor::Ddg_Expr< B, U, Dim45, Dim23, m, n, k, l > | |
| CFTensor::Ddg_Expr< Ddg< A, Tensor_Dim01, Tensor_Dim23 >, T, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_minus_Ddg< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_mod_Ddg< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_mod_Tensor2_symmetric< A, B, T, U, Dim01_0, Dim23_0, Dim_1, i0, j0, k0, l0, i1, j1 > | |
| CFTensor::Ddg_mod_Tensor2_symmetric< A, B, T, U, Dim01, Dim23, Dim01, i, j, k, l, i, j > | |
| CFTensor::Ddg_mod_Tensor2_symmetric< A, B, T, U, Dim01, Dim23, Dim23, i, j, k, l, k, l > | |
| CFTensor::Ddg_number_0< A, T, N1 > | |
| CFTensor::Ddg_number_01< A, T, N1, N2 > | |
| CFTensor::Ddg_number_rhs_0< A, T, N0 > | |
| CFTensor::Ddg_number_rhs_01< A, T, N0, N1 > | |
| CFTensor::Ddg_numeral_0< A, T > | |
| CFTensor::Ddg_numeral_01< A, T > | |
| CFTensor::Ddg_numeral_02< A, T > | |
| CFTensor::Ddg_numeral_123< A, T > | |
| CFTensor::Ddg_numeral_23< A, T > | |
| CFTensor::Ddg_or_Ddg< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_or_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_plus_Ddg< A, B, T, U, Dim01_0, Dim23_0, Dim01_1, Dim23_1, i0, j0, k0, l0, i1, j1, k1, l1 > | |
| CFTensor::Ddg_plus_Ddg< A, B, T, U, Dim01, Dim23, Dim01, Dim23, i, j, k, l, i, j, k, l > | |
| CFTensor::Ddg_plus_Ddg< A, B, T, U, Dim01, Dim23, Dim23, Dim01, i, j, k, l, k, l, i, j > | |
| CFTensor::Ddg_times_Ddg_0101< A, B, T, U, Dim01, Dim23, Dim45, i, j, k, l, m, n > | |
| CFTensor::Ddg_times_Ddg_0123< A, B, T, U, Dim01, Dim23, Dim45, i, j, k, l, m, n > | |
| CFTensor::Ddg_times_Ddg_2301< A, B, T, U, Dim01, Dim23, Dim45, i, j, k, l, m, n > | |
| CFTensor::Ddg_times_Ddg_2323< A, B, T, U, Dim01, Dim23, Dim45, i, j, k, l, m, n > | |
| CFTensor::Ddg_times_Dg_01< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m > | |
| CFTensor::Ddg_times_Dg_23< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor1_0< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor1_1< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor1_2< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor1_3< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_01< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_0_0< A, B, T, U, Dim01, Dim23, Dim1, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_0_1< A, B, T, U, Dim01, Dim23, Dim1, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_13< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_1_0< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_1_1< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_23< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_2_0< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_2_1< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_32< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_3_0< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_3_1< A, B, T, U, Dim01, Dim23, Dim4, i, j, k, l, m > | |
| CFTensor::Ddg_times_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_symmetric_13< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor2_symmetric_23< A, B, T, U, Dim01, Dim23, i, j, k, l > | |
| CFTensor::Ddg_times_Tensor4_2301_ijkl< A, B, T, U, Dim01, Dim23, Dim2, Dim3, i, j, k, l, m, n > | |
| CFTensor::Ddg_times_Tensor4_2323_klij< A, B, T, U, Dim01, Dim23, Dim0, Dim1, i, j, k, l, m, n > | |
| CFTensor::ddTensor0< T, Dim, i, j > | |
| CFTensor::ddTensor1< T, Dim0, Dim12, i, j, k > | |
| CFTensor::ddTensor2_symmetric< T, Dim01, Dim23, i, j, k, l > | |
| CMoFEM::DefaultElementAdjacency | Default adjacency map |
| Cderivative_delta< Dim > | |
| CMoFEM::DeterminantTensorImpl< T, DIM > | |
| CMoFEM::DeterminantTensorImpl< T, 2 > | |
| CMoFEM::DeterminantTensorImpl< T, 3 > | |
| CFTensor::Dg< T, Tensor_Dim01, Tensor_Dim2 > | |
| CFTensor::Dg< A, Tensor_Dim01, Tensor_Dim2 > | |
| ►CFTensor::Dg< T *, Tensor_Dim01, Tensor_Dim2 > | |
| CFTensor::Dg< PackPtr< T *, I >, Tensor_Dim01, Tensor_Dim2 > | |
| CFTensor::Dg_and_Dg_02< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_and_Dg_12< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_and_Tensor1< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_and_Tensor2_symmetric< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_constructor< T, Tensor_Dim01, Tensor_Dim2 > | |
| CFTensor::Dg_constructor< T, 2, 2 > | |
| CFTensor::Dg_constructor< T, 3, 3 > | |
| CFTensor::Dg_constructor< T, 4, 3 > | |
| CFTensor::Dg_constructor< T, 4, 4 > | |
| CFTensor::Dg_divide_generic< A, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_Expr< A, T, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_Expr< A, T, Dim, Dim, i, j, k > | |
| CFTensor::Dg_Expr< A, T, Dim, Dim, j, i, k > | |
| CFTensor::Dg_Expr< A, T, Dim, Dim, k, i, j > | |
| CFTensor::Dg_Expr< A, T, Dim01, Dim01, i, j, k > | |
| CFTensor::Dg_Expr< A, T, Dim01, Dim2, i, k, j > | |
| CFTensor::Dg_Expr< A, T, Dim01, Dim2, j, i, k > | |
| CFTensor::Dg_Expr< A, T, Dim01, Dim2, j, k, i > | |
| CFTensor::Dg_Expr< A, T, Dim01, Dim2, k, i, j > | |
| CFTensor::Dg_Expr< B, U, Dim, Dim, i, k, j > | |
| CFTensor::Dg_Expr< B, U, Dim, Dim, k, i, j > | |
| CFTensor::Dg_Expr< B, U, Dim, Dim, k, j, i > | |
| CFTensor::Dg_Expr< B, U, Dim, Dim2, l, k, m > | |
| CFTensor::Dg_Expr< B, U, Dim0, Dim4, i, j, m > | |
| CFTensor::Dg_Expr< B, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_Expr< B, U, Dim01, Dim2, j, i, k > | |
| CFTensor::Dg_Expr< B, U, Dim01, Dim2, j, k, l > | |
| CFTensor::Dg_Expr< B, U, Dim01, Dim2, k, l, j > | |
| CFTensor::Dg_Expr< B, U, Dim01, Dim3, i, j, l > | |
| CFTensor::Dg_Expr< B, U, Dim01, Dim4, i, j, m > | |
| CFTensor::Dg_Expr< B, U, Dim03, Dim5, i, j, l > | |
| CFTensor::Dg_Expr< B, U, Dim2, Dim01, k, l, j > | |
| CFTensor::Dg_Expr< B, U, Dim2, Dim4, k, l, m > | |
| CFTensor::Dg_Expr< B, U, Dim23, Dim2, l, m, k > | |
| CFTensor::Dg_Expr< B, U, Dim23, Dim4, k, l, m > | |
| CFTensor::Dg_Expr< Christof< A, Tensor_Dim0, Tensor_Dim12 >, T, Dim12, Dim0, i, j, k > | |
| CFTensor::Dg_Expr< const Christof< A, Tensor_Dim0, Tensor_Dim12 >, T, Dim12, Dim0, i, j, k > | |
| CFTensor::Dg_Expr< Ddg_number_rhs_0< A, T, N0 >, T, Dim23, Dim1, i, j, k > | |
| CFTensor::Dg_Expr< Dg< A, Tensor_Dim01, Tensor_Dim2 >, T, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_minus_Dg< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_minus_Dg_02< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_number_0< A, T, N > | |
| CFTensor::Dg_number_01< A, T, N1, N2 > | |
| CFTensor::Dg_number_12< A, T, N1, N2 > | |
| CFTensor::Dg_number_2< A, T, N > | |
| CFTensor::Dg_number_rhs_0< A, T, N > | |
| CFTensor::Dg_number_rhs_01< A, T, N1, N2 > | |
| CFTensor::Dg_number_rhs_12< A, T, N1, N2 > | |
| CFTensor::Dg_number_rhs_2< A, T, N > | |
| CFTensor::Dg_numeral_0< A, T > | |
| CFTensor::Dg_numeral_01< A, T > | |
| CFTensor::Dg_numeral_12< A, T > | |
| CFTensor::Dg_numeral_2< A, T > | |
| CFTensor::Dg_or_Dg_02< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_or_Dg_12< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_plus_Dg< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_plus_Dg_10< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_plus_Dg_210< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_times_Dg_01_01< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Dg_times_Dg_12_01< A, B, T, U, Dim01, Dim2, i, j, k, l > | |
| CFTensor::Dg_times_Dg_12_20< A, B, T, U, Dim01, Dim2, i, j, k, l > | |
| CFTensor::Dg_times_Dg_2< A, B, T, U, Dim01, Dim23, Dim2, i, j, k, l, m > | |
| CFTensor::Dg_times_generic< A, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor1_0< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor1_1< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor1_2< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_0< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_01< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_02< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_1< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_10< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_12< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_1_0< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_1_1< A, B, T, U, Dim01, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_20< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_21< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_symmetric_0< A, B, T, U, Dim01, Dim2, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_symmetric_01< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_symmetric_02< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_times_Tensor2_symmetric_1< A, B, T, U, Dim01, Dim2, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_symmetric_10< A, B, T, U, Dim01, Dim2, i, j, k > | |
| CFTensor::Dg_times_Tensor2_symmetric_12< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_times_Tensor2_symmetric_1_0< A, B, T, U, Dim01, Dim2, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_symmetric_1_1< A, B, T, U, Dim01, Dim2, i, j, k, l > | |
| CFTensor::Dg_times_Tensor2_symmetric_20< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Dg_times_Tensor2_symmetric_21< A, B, T, U, Dim, i, j, k > | |
| ►CMoFEM::DiagBlockIndex | |
| CMoFEM::BlockStructure | |
| CDiffFunA | |
| CFTensor::diffusion_Tensor1< T, Dim, i > | |
| CFTensor::diffusion_Tensor2_symmetric< T, Dim, i, j > | |
| CMoFEM::DOF_Unique_mi_tag | |
| CMoFEM::DofEntity_active_change | |
| CMoFEM::BaseFunction::DofsSideMapData | |
| CDomainBCs | [Define entities] |
| ►CDomainEleOp | |
| CAtomTest::OpError< FIELD_DIM > | Operator to evaluate errors |
| CAtomTest::OpError< FIELD_DIM > | Operator to evaluate errors |
| CAtomTest::OpError< 1 > | |
| CAtomTest::OpError< 1 > | |
| CDomainEleOpStab | Element used to specialise assembly |
| CExample::OpError< 1 > | |
| CExample::OpRhs | |
| CFiniteThermalOps::OpCalculateQdotQRhs< DIM, GAUSS, DomainEleOp > | |
| CHenckyOps::OpCalculateEigenValsImpl< DIM, GAUSS, DomainEleOp > | |
| CHenckyOps::OpCalculateHenckyPlasticStressImpl< DIM, GAUSS, DomainEleOp, S > | |
| CHenckyOps::OpCalculateHenckyStressImpl< DIM, GAUSS, DomainEleOp, S > | |
| CHenckyOps::OpCalculateHenckyThermalStressImpl< DIM, GAUSS, DomainEleOp, S > | |
| CHenckyOps::OpCalculateLogCImpl< DIM, GAUSS, DomainEleOp > | |
| CHenckyOps::OpCalculateLogC_dCImpl< DIM, GAUSS, DomainEleOp > | |
| CHenckyOps::OpCalculatePiolaStressImpl< DIM, GAUSS, DomainEleOp, S > | |
| CHenckyOps::OpHenckyTangentImpl< DIM, GAUSS, DomainEleOp, S > | |
| CMixedPoisson::OpError | |
| COpBlockPermittivity | |
| COpCheckValsDiffVals | |
| COpEnergyDensity | |
| COpError | |
| COpError | |
| COpGradTimesPerm | |
| COpTotalEnergy | |
| COpValsDiffVals | |
| CPlasticOps::OpCalculatePlasticSurfaceImpl< DIM, GAUSS, DomainEleOp > | [Auxiliary functions functions |
| CPlasticOps::OpCalculatePlasticityImpl< DIM, GAUSS, DomainEleOp > | |
| CPlasticOps::OpPlasticStressImpl< DIM, GAUSS, DomainEleOp > | |
| CStandardPoisson::OpError | |
| CThermoElasticOps::OpStressThermal | |
| CSurfaceSlidingConstrains::DriverElementOrientation | Class implemented by user to detect face orientation |
| CFTensor::dTensor0< T, Dim, i > | |
| CFTensor::dTensor1< T, Dim0, Dim1, i, j > | |
| CFTensor::dTensor2_symmetric< T, Dim01, Dim2, i, j, k > | |
| ►CE | |
| ►CMoFEM::PostProcBrokenMeshInMoabBase< E > | |
| CMoFEM::PostProcBrokenMeshInMoabBaseBeginImpl< E > | |
| CMoFEM::PostProcBrokenMeshInMoabBaseContImpl< E > | |
| CMoFEM::PostProcBrokenMeshInMoabBaseEndImpl< E > | |
| ►CEdgeElementForcesAndSourcesCore | |
| CMinimalSurfaceEquation::MinimalSurfaceElement::EdgeElement | Bondary problem |
| CEdgeForce | Force on edges and lines |
| CEigenMatrix::EigenMatrixImp< T1, T2, NB, Dim > | |
| CElasticMaterials | Manage setting parameters and constitutive equations for nonlinear/linear elastic materials |
| ►CELE_OP | |
| COpCheckGaussCoords< ELE_OP, PARENT_ELE > | |
| CElectrostatics | |
| ►CELEMENT | |
| CPostProcTemplateOnRefineMesh< ELEMENT > | Generic post-processing class |
| CElementsAndOps< DIM > | |
| CMoFEM::PipelineManager::ElementsAndOpsByDim< DIM > | |
| ►CMoFEM::PipelineManager::ElementsAndOpsByDim< 2 > | |
| CElementsAndOps< 2 > | |
| CElementsAndOps< 2 > | |
| ►CMoFEM::PipelineManager::ElementsAndOpsByDim< 3 > | |
| CElementsAndOps< 3 > | |
| CElementsAndOps< 3 > | |
| ►CEleOp | |
| ►CMoFEM::OpBaseImpl< A, EleOp > | |
| CExample::OpFluxRhs | |
| CExample::OpRadiationLhs | |
| CExample::OpRadiationRhs | |
| CMoFEM::OpBaseTimesScalarImpl< 1, S, GAUSS, OpBase > | |
| CMoFEM::OpBaseTimesVectorImpl< 1, FIELD_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpBaseTimesVectorImpl< 3, FIELD_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpBrokenBaseImpl< OpBase > | |
| CMoFEM::OpBrokenSpaceConstrainDHybridImpl< FIELD_DIM, GAUSS, OpBase > | |
| CMoFEM::OpCalculateHVecTensorTrace< Tensor_Dim, OpBase > | Calculate trace of vector (Hdiv/Hcurl) space |
| CMoFEM::OpConvectiveTermLhsDuImpl< 1, 1, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpConvectiveTermLhsDuImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpConvectiveTermLhsDyImpl< 1, 1, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpConvectiveTermLhsDyImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpConvectiveTermRhsImpl< 1, 1, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpConvectiveTermRhsImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpGetBrokenBaseSideData< OpBase > | |
| CMoFEM::OpGetCoFactorImpl< SPACE_DIM, IntegrationType::GAUSS, OpBase > | [declarations of templates] |
| CMoFEM::OpGradGradImpl< 1, 1, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpGradGradImpl< 1, FIELD_DIM, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpGradGradSymTensorGradGradImpl< 1, 1, SPACE_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpGradSymTensorGradImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpGradTensorGradImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpGradTimesSymTensorImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpGradTimesTensorImpl< 1, 1, SPACE_DIM, S, GAUSS, OpBase > | |
| CMoFEM::OpGradTimesTensorImpl< 1, SPACE_DIM, SPACE_DIM, S, GAUSS, OpBase > | |
| ►CMoFEM::OpMassImpl< 1, 1, GAUSS, OpBase > | |
| CMoFEM::OpMassImpl< 1, FIELD_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMassImpl< 3, 4, GAUSS, OpBase > | |
| CMoFEM::OpMassImpl< 3, 9, GAUSS, OpBase > | |
| CMoFEM::OpMassImpl< 3, FIELD_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMixDivTimesScalarImpl< SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMixDivTimesUImpl< 1, FIELD_DIM, FIELD_DIM, GAUSS, OpBase, CoordSys > | |
| CMoFEM::OpMixDivTimesUImpl< 3, 1, SPACE_DIM, GAUSS, OpBase, CoordSys > | |
| CMoFEM::OpMixDivTimesUImpl< 3, FIELD_DIM, SPACE_DIM, GAUSS, OpBase, CoordSys > | |
| CMoFEM::OpMixDivTimesVecImpl< SPACE_DIM, GAUSS, OpBase, CoordSys > | |
| CMoFEM::OpMixScalarTimesDivImpl< SPACE_DIM, GAUSS, OpBase, COORDINATE_SYSTEM > | |
| CMoFEM::OpMixTensorTimesGradImpl< SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMixTensorTimesGradUImpl< SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMixVecTimesDivLambdaImpl< SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMixVectorTimesGradImpl< 1, SPACE_DIM, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpMixVectorTimesGradImpl< 3, SPACE_DIM, SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpNormalMixVecTimesScalarImpl< 2, GAUSS, OpBase > | |
| CMoFEM::OpNormalMixVecTimesScalarImpl< 3, GAUSS, OpBase > | |
| CMoFEM::OpNormalMixVecTimesVectorFieldImpl< SPACE_DIM, GAUSS, OpBase > | |
| CMoFEM::OpSetFlux< OpBase > | |
| CMoFEM::OpSourceImpl< 1, 1, GAUSS, SourceFunctionSpecialization::S< OpBase > > | Integrate source |
| CMoFEM::OpSourceImpl< 1, FIELD_DIM, GAUSS, SourceFunctionSpecialization::S< OpBase > > | |
| CMoFEM::OpSourceImpl< 3, FIELD_DIM, GAUSS, SourceFunctionSpecialization::S< OpBase > > | |
| COpCheckValsDiffVals | |
| Cstd::enable_if< Condition, T > | |
| Cstd::enable_if< true, T > | |
| ►Cboost::enable_shared_from_this | |
| CADOLCPlasticity::CommonData | Common data used by volume elements |
| CContactOps::CommonData | [Common data] |
| CEshelbianPlasticity::DataAtIntegrationPts | |
| CExample::CommonData | [Example] |
| CFiniteThermalOps::CommonData | |
| CHenckyOps::CommonData | |
| CHookeOps::CommonData | |
| CMetaSpringBC::DataAtIntegrationPtsSprings | |
| CMoFEM::BcManager::BCs | Data structure storing bc markers and atributes |
| CMoFEM::LogManager::InternalData | |
| ►CMoFEM::SchurElemMats | Schur complement data storage |
| CMoFEM::SchurElemMatsBlock | |
| CMoFEM::SchurElemMatsPreconditionedBlock | |
| CNeumannForcesSurface::DataAtIntegrationPts | |
| CPlasticOps::CommonData | [Common data] |
| CSeepage::BlockedParameters | |
| CThermoElasticProblem::BlockedThermalParameters | |
| CThermoElasticProblem::BlockedThermoElasticParameters | |
| CMoFEM::Ent_Ent_mi_tag | |
| CMoFEM::Ent_FiniteElement_mi_tag | |
| CMoFEM::Ent_mi_tag | |
| CMoFEM::Ent_Owner_mi_tag | |
| CMoFEM::Ent_ParallelStatus | |
| ►CMoFEM::EntitiesFieldData::EntData | Data on single entity (This is passed as argument to DataOperator::doWork) |
| CMoFEM::DerivedEntitiesFieldData::DerivedEntData | Derived ata on single entity (This is passed as argument to DataOperator::doWork) |
| CMoFEM::EntDofIdx_mi_tag | |
| ►CMoFEM::EntitiesFieldData | Data structure for finite element entity |
| CMoFEM::DerivedEntitiesFieldData | This class derive data form other data structure |
| CMoFEM::EntityCacheDofs | |
| CMoFEM::EntityCacheNumeredDofs | |
| ►CMoFEM::EntityStorage | |
| CMoFEM::EssentialBcStorage | [Storage and set boundary conditions] |
| CMyStorage | |
| CMoFEM::EntType_mi_tag | |
| CMoFEM::EqBit< id_type > | |
| CMoFEM::Exceptions::ErrorChecker< LINE > | Error check for inline function check |
| CMoFEM::EssentialBC< EleOp > | Essential boundary conditions |
| CMoFEM::EssentialPostProcLhs< T > | Class (Function) to enforce essential constrains on the left hand side diagonal |
| CMoFEM::EssentialPostProcLhs< DisplacementCubitBcData > | Specialization for DisplacementCubitBcData |
| CMoFEM::EssentialPostProcRhs< T > | Class (Function) to enforce essential constrains on the right hand side diagonal |
| CMoFEM::EssentialPostProcRhs< DisplacementCubitBcData > | Specialization for DisplacementCubitBcData |
| CMoFEM::EssentialPreProc< T > | Class (Function) to enforce essential constrains |
| CMoFEM::EssentialPreProc< DisplacementCubitBcData > | Specialization for DisplacementCubitBcData |
| CMoFEM::EssentialPreProc< TemperatureCubitBcData > | Specialization for TemperatureCubitBcData |
| CMoFEM::EssentialPreProcReaction< T > | Class (Function) to calculate residual side diagonal |
| CMoFEM::EssentialPreProcReaction< DisplacementCubitBcData > | Specialization for DisplacementCubitBcData |
| CExactFunction | Function |
| CExactFunctionGrad | Exact gradient |
| CExactLaplacianFunction | Laplacian of function |
| CExample | [Example] |
| ►CExampleNonlinearElastic | |
| CExampleArcLength | |
| ►Cstd::exception | |
| ►CMoFEM::Exceptions::MoFEMException | Exception to catch |
| ►CMoFEM::Exceptions::MoFEMExceptionRepeat | |
| CMoFEM::Exceptions::MoFEMExceptionInitial | |
| CEshelbianPlasticity::ExternalStrain | |
| CEshelbianPlasticity::ContactTree::FaceData | |
| ►CFaceElementForcesAndSourcesCore | |
| CMinimalSurfaceEquation::MinimalSurfaceElement::SurfaceElement | |
| CMoFEM::NodeMergerInterface::FaceMap | |
| CEshelbianPlasticity::FaceRule | |
| CFaceRule | Set integration rule to boundary elements |
| CMixTransport::UnsaturatedFlowElement::FaceRule | Set integration rule to boundary elements |
| CNavierStokesElement::FaceRule | |
| CPoissonExample::FaceRule | Set integration rule to boundary elements |
| ►CFaceSideOp | |
| COpCalculateSideData | Operator tp collect data from elements on the side of Edge/Face |
| CPoisson2DiscontGalerkinOperators::OpCalculateSideData | Operator tp collect data from elements on the side of Edge/Face |
| ►CFaceUserDataOperator | |
| ►CEshelbianPlasticity::OpAssembleBasic< FaceUserDataOperator > | |
| CEshelbianPlasticity::OpAssembleFace | |
| ►COpAssembleBasic< FaceUserDataOperator > | |
| COpAssembleFace | |
| CEshelbianPlasticity::OpCalculateReactionForces | |
| COpCalculateReactionForces | |
| CEigenMatrix::Fdd4MImpl< E, C > | |
| CMoFEM::FE_Unique_mi_tag | |
| CMoFEM::FEEnt_mi_tag | |
| ►CFEMethod | |
| CBoneRemodeling::MonitorPostProc | |
| CBoneRemodeling::Remodeling::FePrePostProcessLhs | Not used at this stage. Could be used to do some calculations, before assembly of local elements |
| CBoneRemodeling::Remodeling::FePrePostProcessRhs | Not used at this stage. Could be used to do some calculations, before assembly of local elements |
| ►CCohesiveElement::ArcLengthIntElemFEMethod | |
| CCohesiveElement::ArcLengthElement | |
| CContactOps::Monitor | |
| CEshelbianMonitor | |
| CPlasticOps::Monitor< DIM > | |
| CSimpleArcLengthControl | |
| CSphericalArcLengthControl | Implementation of spherical arc-length method |
| CThermalElement::TimeSeriesMonitor | TS monitore it records temperature at time steps |
| CThermalElement::UpdateAndControl | This calass is to control time stepping |
| CZeroFLmabda | Zero F_lambda |
| CMoFEM::Field | Provide data structure for (tensor) field approximation |
| CFieldApproximationH1 | Finite element for approximating analytical filed on the mesh |
| CMoFEM::MedInterface::FieldData | |
| CMoFEM::FieldEntity_change_order | Structure to change FieldEntity order |
| CMoFEM::FieldEntityEntFiniteElementAdjacencyMap | FieldEntityEntFiniteElementAdjacencyMap of mofem finite element and entities |
| CMoFEM::FieldEntityEntFiniteElementAdjacencyMap_change_ByWhat | |
| CMoFEM::FieldName_mi_tag | MultiIndex Tag for field name |
| CMoFEM::FieldSeries | Structure for recording (time) series |
| CMoFEM::FiniteElement | Finite element definition |
| CMoFEM::FiniteElement_change_bit_add | Add field to data |
| CMoFEM::FiniteElement_change_bit_off | Unset field from data |
| CMoFEM::FiniteElement_change_bit_reset | Reset field from data |
| CMoFEM::FiniteElement_col_change_bit_add | Add field to column |
| CMoFEM::FiniteElement_col_change_bit_off | Unset field from column |
| CMoFEM::FiniteElement_col_change_bit_reset | Reset field from column |
| CMoFEM::FiniteElement_Meshset_mi_tag | |
| CMoFEM::FiniteElement_name_mi_tag | |
| CMoFEM::FiniteElement_row_change_bit_add | Add field to row |
| CMoFEM::FiniteElement_row_change_bit_off | Unset field from row |
| CMoFEM::FiniteElement_row_change_bit_reset | Reset field from row |
| CEigenMatrix::FirstMatrixDirectiveImpl< E, C > | |
| CFluidPressure::FluidData | |
| CElasticExample::FluidLevelType< BC > | |
| CFluidPressure | Fluid pressure forces |
| CThermalElement::FluxData | Data for calculation heat flux |
| CMoFEM::FluxOpType< OP > | Wrapper to generate natural b.c. specialisation based on operator type |
| CMoFEM::FormsIntegrators< EleOp > | Integrator forms |
| CFreeSurface | |
| CFunA | |
| ►CNonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< TYPE > | Implementation of elastic (non-linear) St. Kirchhoff equation |
| CHooke< TYPE > | Hook equation |
| ►CMyMat_double< TYPE > | |
| CMyMat< TYPE > | |
| CNeoHookean< TYPE > | NeoHookan equation |
| CSmallStrainTranverslyIsotropic< TYPE > | Hook equation |
| CVolumeLengthQuality< TYPE > | Volume Length Quality |
| CVolumeLengthQuality< TYPE > | Volume Length Quality |
| ►CNonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< adouble > | |
| ►CSmallStrainTranverslyIsotropic< adouble > | |
| CSmallStrainTranverslyIsotropicADouble | |
| ►CNonlinearElasticElement::FunctionsToCalculatePiolaKirchhoffI< double > | |
| ►CSmallStrainTranverslyIsotropic< double > | |
| CSmallStrainTranverslyIsotropicDouble | |
| CFTensor::generic_minus_Tensor1< A, T, U, Dim, i > | |
| CFTensor::generic_minus_Tensor2_symmetric< A, T, U, Dim, i, j > | |
| ►CMoFEM::GenericAttributeData | Generic attribute data structure |
| CMoFEM::BlockSetAttributes | Arbitrary block attributes data structure |
| CMoFEM::Block_BodyForces | Body force data structure |
| CMoFEM::Mat_Elastic | Elastic material data structure |
| CMoFEM::Mat_Elastic_EberleinHolzapfel1 | Mat_Elastic with Fibres |
| CMoFEM::Mat_Elastic_TransIso | Transverse Isotropic material data structure |
| CMoFEM::Mat_Interf | Linear interface data structure |
| CMoFEM::Mat_Moisture | Moisture transport material data structure |
| CMoFEM::Mat_Thermal | Thermal material data structure |
| ►CMoFEM::GenericCubitBcData | Generic bc data structure |
| CMoFEM::AccelerationCubitBcData | Definition of the acceleration bc data structure |
| CMoFEM::CfgCubitBcData | Definition of the cfd_bc data structure |
| ►CMoFEM::DisplacementCubitBcData | Definition of the displacement bc data structure |
| CMoFEM::DisplacementCubitBcDataWithRotation | A specialized version of DisplacementCubitBcData that includes an additional rotation offset |
| CMoFEM::ForceCubitBcData | Definition of the force bc data structure |
| CMoFEM::HeatFluxCubitBcData | Definition of the heat flux bc data structure |
| CMoFEM::PressureCubitBcData | Definition of the pressure bc data structure |
| CMoFEM::TemperatureCubitBcData | Definition of the temperature bc data structure |
| CMoFEM::VelocityCubitBcData | Definition of the velocity bc data structure |
| ►CGenericElementInterface | Set of functions declaring elements and setting operators for generic element interface |
| CBasicBoundaryConditionsInterface | Set of functions declaring elements and setting operators for basic boundary conditions interface |
| CNonlinearElasticElementInterface | Set of functions declaring elements and setting operators for generic element interface |
| ►CMixTransport::GenericMaterial | Generic material model for unsaturated water transport |
| ►CMixTransport::CommonMaterialData | |
| CMixTransport::MaterialDarcy | |
| ►CMixTransport::MaterialWithAutomaticDifferentiation | |
| CMixTransport::MaterialVanGenuchten | |
| ►CGenericSliding | Implementation of surface sliding constrains |
| CEdgeSlidingConstrains | |
| CEdgeSlidingConstrains | |
| CSurfaceSlidingConstrains | Shape preserving constrains, i.e. nodes sliding on body surface |
| CSurfaceSlidingConstrains | Shape preserving constrains, i.e. nodes sliding on body surface |
| CMoFEM::GetBlockScalingMethod< TS > | Get time scaling method |
| CThermoElasticOps::GetConvectionParameters< BC > | |
| CThermoElasticOps::GetConvectionParameters< BLOCKSET > | |
| CEigenMatrix::GetDiffDiffMatImpl< E, C, T1, T2 > | |
| CEigenMatrix::GetDiffDiffMatImpl< E, C, T1, FTensor::Tensor2_symmetric< VT2, DimT2 > > | |
| CEigenMatrix::GetDiffMatImpl< E, C, T > | |
| CElasticExample::GetFluidLevel< BC > | |
| CElasticExample::GetFluidLevel< BLOCKSET > | |
| CMoFEM::GetFTensor0FromVecImpl< S, T, A > | |
| CMoFEM::GetFTensor1FromArray< DIM, S > | |
| CMoFEM::GetFTensor1FromArray< 1, S > | |
| CMoFEM::GetFTensor1FromArray< 2, S > | |
| CMoFEM::GetFTensor1FromArray< 3, S > | |
| CMoFEM::GetFTensor1FromArray< 4, S > | |
| CMoFEM::GetFTensor1FromArray< 6, S > | |
| CMoFEM::GetFTensor1FromArray< 9, S > | |
| CMoFEM::GetFTensor1FromMatImpl< Tensor_Dim, S, T, L, A > | |
| CMoFEM::GetFTensor1FromMatImpl< 1, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor1FromMatImpl< 2, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor1FromMatImpl< 3, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor1FromMatImpl< 4, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor1FromMatImpl< 6, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor1FromMatImpl< 9, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor1FromPtrImpl< DIM, S, T > | |
| CMoFEM::GetFTensor1FromPtrImpl< 1, S, T > | |
| CMoFEM::GetFTensor1FromPtrImpl< 2, S, T > | |
| CMoFEM::GetFTensor1FromPtrImpl< 3, S, T > | |
| CMoFEM::GetFTensor1FromPtrImpl< 4, S, T > | |
| CMoFEM::GetFTensor1FromPtrImpl< 6, S, T > | |
| CMoFEM::GetFTensor2FromArrayImpl< DIM1, DIM2, S, T, L, A > | Get FTensor2 from array |
| CMoFEM::GetFTensor2FromArrayImpl< 2, 2, S, T, L, A > | |
| CMoFEM::GetFTensor2FromArrayImpl< 3, 3, S, T, L, A > | |
| CMoFEM::GetFTensor2FromArrayRawPtrImpl< DIM1, DIM2, T, L, A > | |
| CMoFEM::GetFTensor2FromArrayRawPtrImpl< 2, 2, T, L, A > | |
| CMoFEM::GetFTensor2FromArrayRawPtrImpl< 3, 3, T, L, A > | |
| CMoFEM::GetFTensor2FromMatImpl< Tensor_Dim1, Tensor_Dim2, S, T, L, A > | |
| CMoFEM::GetFTensor2FromPtr< DIM1, DIM2, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 1, 1, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 1, 2, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 1, 3, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 2, 2, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 3, 2, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 3, 3, S, T > | |
| CMoFEM::GetFTensor2FromPtr< 6, 6, S, T > | |
| CMoFEM::GetFTensor2SymmetricFromMatImpl< Tensor_Dim, S, T, L, A > | |
| CMoFEM::GetFTensor2SymmetricFromMatImpl< 2, S, T, L, A > | |
| CMoFEM::GetFTensor2SymmetricFromMatImpl< 3, S, T, L, A > | |
| CMoFEM::GetFTensor3DgFromMatImpl< Tensor_Dim01, Tensor_Dim2, S, T, L, A > | |
| CMoFEM::GetFTensor3DgFromMatImpl< 1, 1, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3DgFromMatImpl< 2, 2, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3DgFromMatImpl< 3, 3, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, S, T, L, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 1, 1, 1, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 2, 2, 2, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 2, 2, 3, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 3, 2, 2, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 3, 3, 3, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 3, 3, 6, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor3FromMatImpl< 6, 3, 3, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor4DdgFromMatImpl< Tensor_Dim01, Tensor_Dim23, S, T, L, A > | |
| CMoFEM::GetFTensor4DdgFromMatImpl< 1, 1, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor4DdgFromMatImpl< 2, 2, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor4DdgFromMatImpl< 3, 3, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor4DdgFromPtrImpl< Tensor_Dim01, Tensor_Dim23, S, T > | |
| CMoFEM::GetFTensor4DdgFromPtrImpl< 3, 3, S, T > | |
| CMoFEM::GetFTensor4FromMatImpl< Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3, S, T, L, A > | |
| CMoFEM::GetFTensor4FromMatImpl< 1, 1, 1, 1, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor4FromMatImpl< 2, 2, 2, 2, S, T, ublas::row_major, A > | |
| CMoFEM::GetFTensor4FromMatImpl< 3, 3, 3, 3, S, T, ublas::row_major, A > | |
| CEigenMatrix::GetMatImpl< E, C, T > | |
| CThermoElasticOps::GetRadiationParameters< BC > | |
| CThermoElasticOps::GetRadiationParameters< BLOCKSET > | |
| CElasticExample::GetSpringStiffness< BC > | |
| CElasticExample::GetSpringStiffness< BLOCKSET > | |
| CMoFEM::HashBit< id_type > | |
| CHcurlEdgeBase | |
| CHcurlFaceBase | |
| CTetBaseCache::HDivBaseCacheItem | |
| CHeatEquation | |
| CHenckyOps::HenckyIntegrators< DomainEleOp > | |
| CMoFEM::Idx_mi_tag | |
| CMoFEM::IdxDataType | |
| CMoFEM::IdxDataTypePtr | |
| CIncompressible | |
| CFTensor::Index< i, Dim > | |
| CIndex< i > | |
| CFTensor::Index< 'i', 2 > | |
| CFTensor::Index< 'i', 3 > | |
| CFTensor::Index< 'i', DIM > | |
| CFTensor::Index< 'i', DIM_01 > | |
| CFTensor::Index< 'i', FIELD_DIM > | |
| CFTensor::Index< 'i', SPACE_DIM > | |
| CFTensor::Index< 'i', Tensor_Dim > | |
| CFTensor::Index< 'j', 2 > | |
| CFTensor::Index< 'j', 3 > | |
| CFTensor::Index< 'j', DIM > | |
| CFTensor::Index< 'j', DIM_01 > | |
| CFTensor::Index< 'j', SPACE_DIM > | |
| CFTensor::Index< 'j', Tensor_Dim > | |
| CFTensor::Index< 'k', 2 > | |
| CFTensor::Index< 'k', 3 > | |
| CFTensor::Index< 'k', DIM_23 > | |
| CFTensor::Index< 'l', DIM_23 > | |
| CFTensor::Index< 'Z', 6 > | |
| CMoFEM::DiagBlockIndex::Indexes | Block data indexes |
| CMoFEM::AdJoint< EleOp >::Integration< I > | |
| ►CIntEleOp | |
| COpBlockChargeDensity | |
| COpElectrodeCharge< SPACE_DIM > | |
| CMoFEM::interface_FieldSeries< T > | |
| ►CMoFEM::interface_FieldSeries< FieldSeries > | |
| CMoFEM::FieldSeriesStep | Structure for keeping time and step |
| ►CMoFEM::interface_RefEntity< T > | Interface to RefEntity |
| ►CMoFEM::interface_FieldImpl< T, T > | |
| ►CMoFEM::interface_Field< T, T > | |
| ►CMoFEM::interface_FieldEntity< T > | Interface to FieldEntity |
| CMoFEM::interface_DofEntity< T > | Interface to DofEntity |
| ►CMoFEM::interface_RefElement< T > | Intrface to RefElement |
| ►CMoFEM::interface_FiniteElementImpl< T, T > | |
| ►CMoFEM::interface_FiniteElement< T, T > | |
| CMoFEM::interface_EntFiniteElement< T > | Interface to EntFiniteElement |
| ►CMoFEM::interface_RefEntity< DofEntity > | |
| ►CMoFEM::interface_FieldImpl< DofEntity, DofEntity > | |
| ►CMoFEM::interface_Field< DofEntity, DofEntity > | |
| ►CMoFEM::interface_FieldEntity< DofEntity > | |
| ►CMoFEM::interface_DofEntity< DofEntity > | |
| ►CMoFEM::NumeredDofEntity | Keeps information about indexed dofs for the problem |
| CMoFEM::FENumeredDofEntity | Keeps information about indexed dofs for the finite element |
| ►CMoFEM::interface_RefEntity< EntFiniteElement > | |
| ►CMoFEM::interface_RefElement< EntFiniteElement > | |
| ►CMoFEM::interface_FiniteElement< EntFiniteElement, EntFiniteElement > | |
| ►CMoFEM::interface_EntFiniteElement< EntFiniteElement > | |
| CMoFEM::NumeredEntFiniteElement | Partitioned (Indexed) Finite Element in Problem |
| ►CMoFEM::interface_RefEntity< FieldEntity > | |
| ►CMoFEM::interface_FieldImpl< FieldEntity, FieldEntity > | |
| ►CMoFEM::interface_Field< FieldEntity, FieldEntity > | |
| ►CMoFEM::interface_FieldEntity< FieldEntity > | |
| ►CMoFEM::DofEntity | Keeps information about DOF on the entity |
| CMoFEM::FEDofEntity | Keeps information about indexed dofs for the finite element |
| ►CMoFEM::interface_RefEntity< RefElement > | |
| ►CMoFEM::interface_RefElement< RefElement > | |
| ►CMoFEM::interface_FiniteElement< FiniteElement, RefElement > | |
| CMoFEM::EntFiniteElement | Finite element data for entity |
| ►CMoFEM::interface_RefEntity< REFENT > | |
| ►CMoFEM::interface_RefElement< REFENT > | |
| CMoFEM::interface_FiniteElement< FE, REFENT > | |
| CMoFEM::interface_FiniteElementImpl< FE, REFENT > | Inetface for FE |
| ►CMoFEM::interface_FieldImpl< FIELD, REFENT > | Pointer interface for MoFEM::Field |
| CMoFEM::interface_Field< FIELD, REFENT > | |
| ►CMoFEM::interface_RefEntity< RefEntity > | |
| ►CMoFEM::interface_FieldImpl< Field, RefEntity > | |
| ►CMoFEM::interface_Field< Field, RefEntity > | |
| CMoFEM::FieldEntity | Struct keeps handle to entity in the field |
| ►CMoFEM::RefElement | Keeps data about abstract refined finite element |
| CMoFEM::RefElementFace | Keeps data about abstract TRI finite element |
| CMoFEM::RefElementVolume | Keeps data about abstract TET finite element |
| CMoFEM::RefElement_EDGE | Keeps data about abstract EDGE finite element |
| CMoFEM::RefElement_MESHSET | Keeps data about abstract MESHSET finite element |
| CMoFEM::RefElement_PRISM | Keeps data about abstract PRISM finite element |
| CMoFEM::RefElement_VERTEX | Keeps data about abstract VERTEX finite element |
| CFTensor::interpolate_Tensor1< T, Dim, i > | |
| CFTensor::interpolate_Tensor2_symmetric< T, Dim, i, j > | |
| CintPostProc< SPACE_DIM > | |
| CintPostProc< 2 > | |
| CintPostProc< 3 > | |
| ►Cboost::intrusive_ptr | |
| CMoFEM::SmartPetscObj< Vec > | |
| CMoFEM::SmartPetscObj< AO > | |
| CMoFEM::SmartPetscObj< Mat > | |
| CMoFEM::SmartPetscObj< SNES > | |
| CMoFEM::SmartPetscObj< KSP > | |
| CMoFEM::SmartPetscObj< DM > | |
| CMoFEM::SmartPetscObj< PC > | |
| CMoFEM::SmartPetscObj< EPS > | |
| CMoFEM::SmartPetscObj< IS > | |
| CMoFEM::SmartPetscObj< VecScatter > | |
| CMoFEM::SmartPetscObj< OBJ > | Intrusive_ptr for managing petsc objects |
| CMoFEM::InvertTensorImpl< T1, T2, T3, DIM > | |
| CMoFEM::InvertTensorImpl< T1, T2, T3, 2 > | |
| CMoFEM::InvertTensorImpl< T1, T2, T3, 3 > | |
| CEshelbianPlasticity::isEq | |
| CHenckyOps::isEq | |
| CADOLCPlasticity::J2Plasticity< DIM > | J2 plasticity (Kinematic Isotropic (Linear) Hardening) |
| CKelvinVoigtDamper | Implementation of Kelvin Voigt Damper |
| CMoFEM::KeyFromKey< KeyExtractor1, KeyExtractor2 > | |
| CFTensor::Kronecker_Delta< T > | Kronecker Delta class |
| CFTensor::Kronecker_Delta_symmetric< T > | Kronecker Delta class symmetric |
| CMoFEM::KspCtx | Interface for linear (KSP) solver |
| CMoFEM::KspCtx::KspCtx::KspCtxImpl | |
| CMoFEM::CutMeshInterface::LengthMapData | |
| CLevelSet | |
| CFTensor::Levi_Civita< T > | Levi_Civita Classes |
| ►CLinearForm | |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A > | Bilinear integrator form |
| CMoFEM::EssentialBC< EleOp >::Assembly< A >::LinearForm< I > | |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A >::LinearForm< I > | Linear form |
| CMoFEM::NaturalBC< EleOp >::Assembly< A >::LinearForm< I > | |
| CMoFEM::LtBit< id_type > | |
| CMagneticElement | Implementation of magneto-static problem (basic Implementation) |
| CADOLCPlasticity::MakeB | Calculate tensorial base functions. Apply bBar method when needed |
| CConvectiveMassElement::MatShellCtx | |
| CMoFEM::Meshset_mi_tag | |
| CMetaEdgeForces | |
| CMetaNeumannForces | Set of high-level function declaring elements and setting operators to apply forces/fluxes |
| CMetaNodalForces | |
| CMetaSimpleRodElement | Set of functions declaring elements and setting operators for simple rod element |
| CMetaSpringBC | Set of functions declaring elements and setting operators to apply spring boundary condition |
| ►CNeumannForcesSurface::MethodForAnalyticalForce | Analytical force method |
| CNeumannForcesSurface::LinearVaringPresssure | |
| ►CMethodForForceScaling | Class used to scale loads, f.e. in arc-length control |
| CBasicBoundaryConditionsInterface::LoadScale | |
| CMetaNodalForces::DofForceScale | Scale force based on some DOF value |
| CMetaNodalForces::TagForceScale | Scale force based on tag value "_LoadFactor_Scale_" |
| CNavierStokesElement::LoadScale | |
| CTimeAccelerogram | |
| CTimeAccelerogram | |
| CTimeForceScale | Force scale operator for reading two columns |
| CTimeForceScale | Force scale operator for reading two columns |
| CMinimalSurfaceEquation::MinimalSurfaceElement | Implementation of minimal area element |
| CMinimalSurfaceEqn | |
| CFTensor::minus_Ddg< A, T, Dim01, Dim23, i, j, k, l > | |
| CFTensor::minus_Dg< A, T, Dim01, Dim2, i, j, k > | |
| CFTensor::minus_Tensor1< A, T, Dim, i > | |
| CFTensor::minus_Tensor2< A, T, Dim0, Dim1, i, j > | |
| CFTensor::minus_Tensor2_symmetric< A, T, Dim, i, j > | |
| CFTensor::minus_Tensor3< A, T, Dim0, Dim1, Dim2, i, j, k > | |
| CMixedPoisson | |
| ►CMixTransport::MixTransportElement | Mix transport problem |
| CMixTransport::UnsaturatedFlowElement | Implementation of operators, problem and finite elements for unsaturated flow |
| CMyTransport | Application of mix transport data structure |
| CMyTransport | Application of mix transport data structure |
| CMoFEM::Modify_change_nothing | Do nothing, used to rebuild database |
| CMoFEM::Exceptions::MoFEMErrorCodeGeneric< TYPE > | |
| CMoFEM::Exceptions::MoFEMErrorCodeGeneric< moab::ErrorCode > | |
| CMoFEM::Exceptions::MoFEMErrorCodeGeneric< PetscErrorCode > | |
| CMyFunApprox | Example approx. function |
| CMoFEM::NaturalBC< EleOp > | Natural boundary conditions |
| CMoFEM::NaturalForceMeshsets | Type generating specialisation for force meshsets |
| CMoFEM::NaturalMeshsetType< BCTYP > | Type generating natural b.c. specialisations for meshsets |
| CMoFEM::NaturalMeshsetTypeVectorScaling< BCTYP > | |
| CMoFEM::NaturalTemperatureMeshsets | Type generating specialisation for temperature meshsets |
| CNavierStokesElement | Element for simulating viscous fluid flow |
| CNavierStokesExample | [Example Navier Stokes] |
| CNeumannForcesSurface | Finite element and operators to apply force/pressures applied to surfaces |
| CNeumannForcesSurfaceComplexForLazy | NonLinear surface pressure element (obsolete implementation) |
| CNodalForce | Force applied to nodes |
| Csdf.NoIndenter | |
| CNonlinearElasticElement | Structure grouping operators and data used for calculation of nonlinear elastic element |
| CNonlinearPoisson | |
| CEshelbianPlasticity::NormalDisplacementBc | |
| CMoFEM::UnknownInterface::NotKnownClass | |
| CFTensor::Number< N > | |
| CFTensor::Number< 0 > | |
| CFTensor::Number< 1 > | |
| CFTensor::Number< 2 > | |
| CMoFEM::NumeredDofEntity_local_idx_change | |
| CMoFEM::NumeredDofEntity_mofem_index_change | |
| CMoFEM::NumeredDofEntity_part_and_all_indices_change | |
| CMoFEM::NumeredDofEntity_part_and_glob_idx_change | |
| CMoFEM::NumeredDofEntity_part_and_indices_change | |
| CMoFEM::NumeredDofEntity_part_and_mofem_glob_idx_change | |
| CMoFEM::NumeredEntFiniteElement_change_part | Change finite element part |
| ►CObjectiveFunctionData | |
| CObjectiveFunctionDataImpl | |
| ►COP | |
| CMyOp< OP > | Operator used to check consistency between local coordinates and global cooridnates for integrated points and evaluated points |
| COp< OP > | |
| ►COP_SCHUR_ASSEMBLE_BASE | |
| CMoFEM::OpSchurAssembleEndImpl< OP_SCHUR_ASSEMBLE_BASE > | Assemble Schur complement (Implementation) |
| COpAdJointGradTimesSymTensor< SPACE_DIM, I, OpBase > | |
| COpAdJointTestOp< SPACE_DIM, I, OpBase > | |
| CEshelbianPlasticity::OpAnalyticalDispBcImpl< A, I > | |
| COpAnalyticalDispBcImpl< A, I > | |
| ►CEshelbianPlasticity::OpAnalyticalDispBcImpl< PETSC, GAUSS > | |
| CEshelbianPlasticity::OpAnalyticalDispBc | |
| ►COpAnalyticalDispBcImpl< PETSC, GAUSS > | |
| COpAnalyticalDispBc | |
| CContactOps::OpAssembleTotalContactAreaImpl< DIM, I, BoundaryEleOp > | |
| CContactOps::OpAssembleTotalContactTractionImpl< DIM, I, BoundaryEleOp > | |
| ►COPBASE | |
| CPoissonExample::OpBaseRhs< OPBASE > | Template class for integration oh the right hand side |
| ►CFormsIntegrators::Assembly::OpBase | |
| CEshelbianPlasticity::OpBrokenAnalyticalTractionBc | |
| CEshelbianPlasticity::OpBrokenPressureBc | |
| ►CEshelbianPlasticity::OpBrokenPressureBcLhsImpl_dU< A, GAUSS > | |
| CEshelbianPlasticity::OpBrokenPressureBcLhs_dU | |
| CEshelbianPlasticity::OpBrokenTractionBc | |
| ►CEshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, GAUSS > | |
| CEshelbianPlasticity::OpNormalDispLhsBc_dU | |
| CEshelbianPlasticity::OpNormalDispBcRhsImpl< A, GAUSS > | |
| CLevelSet::OpLhsDomain | |
| CLevelSet::OpRhsDomain | |
| CNonlinearPoissonOps::OpDomainLhs | |
| CNonlinearPoissonOps::OpDomainRhs | |
| COpAdJointGradTimesSymTensor< SPACE_DIM, IntegrationType::GAUSS, DomainBaseOp > | |
| COpAdJointTestOp< SPACE_DIM, IntegrationType::GAUSS, DomainBaseOp > | |
| COpBrokenAnalyticalTractionBc | |
| COpBrokenPressureBc | |
| ►COpBrokenPressureBcLhsImpl_dU< A, GAUSS > | |
| COpBrokenPressureBcLhs_dU | |
| COpBrokenTractionBc | |
| COpDomainResidualVector | Integrate the domain residual vector (RHS) |
| COpDomainTangentMatrix | Integrate the domain tangent matrix (LHS) |
| COpLhs | |
| ►COpNormalDispBcLhsImpl_dU< A, GAUSS > | |
| COpNormalDispLhsBc_dU | |
| COpNormalDispBcRhsImpl< A, GAUSS > | |
| COpRhs | |
| COpULhs_dH | |
| COpULhs_dU | |
| COpURhs | |
| CPlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsLhs_dEPImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsLhs_dTAUImpl< GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsLhs_dUImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsRhsImpl< GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_LogStrain_dUImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_dEPImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_dTAUImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_dUImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowRhsImpl< DIM, GAUSS, AssemblyDomainEleOp > | [Calculate stress] |
| CPlasticOps::OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticInternalForceLhs_dEPImpl< DIM, GAUSS, AssemblyDomainEleOp > | |
| CPoisson2DHomogeneousOperators::OpDomainLhsMatrixK | |
| CPoisson2DHomogeneousOperators::OpDomainRhsVectorF | |
| CSeepageOps::OpDomainRhsHydrostaticStress< DIM > | |
| CThermoElasticOps::OpKCauchyThermoElasticity | |
| ►CFormsIntegrators::template Assembly::OpBase | |
| ►CMoFEM::OpEssentialRhsImpl< HeatFluxCubitBcData, 3, 3, A, GAUSS, OpBase > | |
| CMoFEM::OpEssentialRhsImpl< HeatFluxCubitBcData, 3, 2, A, GAUSS, OpBase > | |
| CMoFEM::OpBaseDerivativesMass< BASE_DIM > | |
| CMoFEM::OpBaseDerivativesNext< BASE_DIM > | |
| CMoFEM::OpBaseDerivativesSetHOInvJacobian< DIM > | |
| ►COpBaseImpl | |
| COpFluxLhsImpl< ElasticExample::SpringBcType< BLOCKSET >, 1, FIELD_DIM, A, GAUSS, EleOp > | |
| COpFluxLhsImpl< ThermoElasticOps::ConvectionBcType< BLOCKSET >, 1, 1, A, GAUSS, EleOp > | |
| COpFluxLhsImpl< ThermoElasticOps::RadiationBcType< BLOCKSET >, 1, 1, A, GAUSS, EleOp > | |
| COpFluxRhsImpl< ElasticExample::FluidLevelType< BLOCKSET >, 1, FIELD_DIM, A, GAUSS, EleOp > | |
| COpFluxRhsImpl< ElasticExample::SpringBcType< BLOCKSET >, 1, FIELD_DIM, A, GAUSS, EleOp > | |
| COpFluxRhsImpl< ThermoElasticOps::ConvectionBcType< BLOCKSET >, 1, 1, A, GAUSS, EleOp > | |
| COpFluxRhsImpl< ThermoElasticOps::RadiationBcType< BLOCKSET >, 1, 1, A, GAUSS, EleOp > | |
| CMoFEM::OpBaseTimesScalarImpl< BASE_DIM, S, I, OpBase > | |
| ►CFormsIntegrators::Assembly::LinearForm::OpBaseTimesVector | |
| CThermalOps::OpHdivFluxImpl< SPACE_DIM, false > | |
| CMoFEM::OpBaseTimesVectorImpl< BASE_DIM, FIELD_DIM, S, I, OpBase > | |
| ►CFormsIntegrators::Assembly::OpBrokenBase | |
| CEshelbianPlasticity::OpAnalyticalDispBcImpl< A, GAUSS > | |
| CEshelbianPlasticity::OpConstrainBoundaryHDivLhs_dU< A, IntegrationType::GAUSS > | |
| CEshelbianPlasticity::OpConstrainBoundaryHDivRhs< A, IntegrationType::GAUSS > | |
| CEshelbianPlasticity::OpConstrainBoundaryL2Lhs_dP< A, IntegrationType::GAUSS > | |
| CEshelbianPlasticity::OpDispBcImpl< A, GAUSS > | |
| ►CEshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, GAUSS > | |
| CEshelbianPlasticity::OpNormalDispLhsBc_dP | |
| CEshelbianPlasticity::OpRotationBcImpl< A, GAUSS > | |
| COpAnalyticalDispBcImpl< A, GAUSS > | |
| COpDispBcImpl< A, GAUSS > | |
| ►COpNormalDispBcLhsImpl_dP< A, GAUSS > | |
| COpNormalDispLhsBc_dP | |
| COpRotationBcImpl< A, GAUSS > | |
| ►COpBrokenBase | |
| CMoFEM::OpBrokenSpaceConstrainDFluxImpl< FIELD_DIM, GAUSS, OpBrokenBase > | |
| CMoFEM::OpBrokenSpaceConstrainImpl< FIELD_DIM, GAUSS, OpBrokenBase > | |
| CEshelbianPlasticity::OpBrokenPressureBcLhsImpl_dU< A, I > | |
| COpBrokenPressureBcLhsImpl_dU< A, I > | |
| CMoFEM::OpBrokenSpaceConstrainDFluxImpl< FIELD_DIM, I, OpBase > | |
| CMoFEM::OpBrokenSpaceConstrainDHybridImpl< FIELD_DIM, I, OpBase > | |
| CMoFEM::OpBrokenSpaceConstrainImpl< FIELD_DIM, I, OpBrokenBase > | |
| CPlasticOps::OpCalculateConstraintsLhs_dEPImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsLhs_dTAUImpl< I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsLhs_dUImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsLhs_LogStrain_dUImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculateConstraintsRhsImpl< I, AssemblyDomainEleOp > | |
| CHenckyOps::OpCalculateEigenValsImpl< DIM, I, DomainEleOp > | |
| CMoFEM::OpCalculateHcurlVectorCurl< Base_Dim, Space_Dim > | Calculate curl of vector field |
| CHenckyOps::OpCalculateHenckyPlasticStressImpl< DIM, I, DomainEleOp, S > | |
| CHenckyOps::OpCalculateHenckyStressImpl< DIM, I, DomainEleOp, S > | |
| CHenckyOps::OpCalculateHenckyThermalStressdTImpl< DIM, I, DomainEleOp, S > | |
| CHenckyOps::OpCalculateHenckyThermalStressImpl< DIM, I, DomainEleOp, S > | |
| CMoFEM::OpCalculateHOJac< DIM > | |
| CMoFEM::OpCalculateHOJacForFaceImpl< DIM > | Calculate jacobian for face element |
| CMoFEM::OpCalculateHVecVectorField_General< Base_Dim, Field_Dim, T, L, A > | Get vector field for H-div approximation |
| ►CMoFEM::OpCalculateHVecVectorField_General< Base_Dim, Base_Dim, double, ublas::row_major, DoubleAllocator > | |
| CMoFEM::OpCalculateHVecVectorField< Base_Dim, Field_Dim > | Get vector field for H-div approximation |
| CMoFEM::OpCalculateHVecVectorFieldDot< Base_Dim, Field_Dim > | Get vector field for H-div approximation |
| CHenckyOps::OpCalculateLogC_dCImpl< DIM, I, DomainEleOp > | |
| CHenckyOps::OpCalculateLogCImpl< DIM, I, DomainEleOp > | |
| CHenckyOps::OpCalculatePiolaStressImpl< DIM, I, DomainEleOp, S > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_dEPImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_dTAUImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_dUImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowLhs_LogStrain_dUImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticFlowRhsImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticInternalForceLhs_dEPImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticInternalForceLhs_LogStrain_dEPImpl< DIM, I, AssemblyDomainEleOp > | |
| CPlasticOps::OpCalculatePlasticityImpl< DIM, I, DomainEleOp > | |
| CPlasticOps::OpCalculatePlasticSurfaceImpl< DIM, I, DomainEleOp > | |
| CFiniteThermalOps::OpCalculateQdotQLhs_dQ< DIM, I, AssemblyDomainEleOp > | |
| ►COpCalculateQdotQLhs_dQ | |
| CThermalOps::OpHdivHdivImpl< SPACE_DIM, true > | |
| CFiniteThermalOps::OpCalculateQdotQLhs_dU< DIM, I, AssemblyDomainEleOp, IS_LARGE_STRAINS > | |
| CFiniteThermalOps::OpCalculateQdotQRhs< DIM, I, DomainEleOp > | |
| ►COpCalculateQdotQRhs | |
| CThermalOps::OpHdivFluxImpl< SPACE_DIM, true > | |
| CEshelbianPlasticity::OpConstrainBoundaryHDivLhs_dU< A, I > | |
| CEshelbianPlasticity::OpConstrainBoundaryHDivRhs< A, I > | |
| CEshelbianPlasticity::OpConstrainBoundaryL2Lhs_dP< A, I > | |
| CContactOps::OpConstrainBoundaryLhs_dTractionImpl< DIM, I, AssemblyBoundaryEleOp > | |
| CContactOps::OpConstrainBoundaryLhs_dUImpl< DIM, I, AssemblyBoundaryEleOp > | |
| CContactOps::OpConstrainBoundaryRhsImpl< DIM, I, AssemblyBoundaryEleOp > | |
| CMoFEM::OpConvectiveTermLhsDuImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase > | |
| CMoFEM::OpConvectiveTermLhsDyImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase > | |
| CMoFEM::OpConvectiveTermRhsImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase > | |
| CMoFEM::OpCopyGeomDataToE< DIM > | Copy geometry-related data from one element to other |
| CEshelbianPlasticity::OpDispBcImpl< A, I > | |
| COpDispBcImpl< A, I > | |
| ►CEshelbianPlasticity::OpDispBcImpl< PETSC, GAUSS > | |
| CEshelbianPlasticity::OpDispBc | |
| ►COpDispBcImpl< PETSC, GAUSS > | |
| COpDispBc | |
| CExample::OpError< FIELD_DIM > | |
| CAtomTest::OpErrorSkel< FIELD_DIM > | |
| CMoFEM::OpEssentialLhsImpl< T, BASE_DIM, FIELD_DIM, A, I, OpBase > | Enforce essential constrains on lhs |
| CMoFEM::OpEssentialRhsImpl< T, BASE_DIM, FIELD_DIM, A, I, OpBase > | Enforce essential constrains on rhs |
| CContactOps::OpEvaluateSDFImpl< DIM, I, BoundaryEleOp > | |
| CMoFEM::OpFluxLhsImpl< T, BASE_DIM, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< T, BASE_DIM, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpGetCoFactorImpl< SPACE_DIM, I, OpBase > | [declarations of templates] |
| CMoFEM::OpGradGradImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase > | |
| CMoFEM::OpGradGradSymTensorGradGradImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase > | |
| CMoFEM::OpGradSymTensorGradImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase > | |
| CMoFEM::OpGradTensorGradImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase > | |
| CMoFEM::OpGradTimesSymTensorImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase > | |
| CMoFEM::OpGradTimesTensorImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, S, I, OpBase > | |
| CThermalOps::OpHdivFluxImpl< SPACE_DIM, IS_LARGE_STRAINS > | Integrating Rhs flux base (1/k) flux (FLUX) |
| CThermalOps::OpHdivHdivImpl< SPACE_DIM, IS_LARGE_STRAINS > | Integrate Lhs base of flux (1/k) base of flux (FLUX x FLUX) |
| CHenckyOps::OpHenckyTangentImpl< DIM, I, DomainEleOp, S > | |
| CADOLCPlasticity::OpLhsImpl< DIM, I, AssemblyDomainEleOp > | Assemble left hand side |
| ►CFormsIntegrators::Assembly::BiLinearForm::OpMass | |
| CThermalOps::OpHdivHdivImpl< SPACE_DIM, false > | |
| CMoFEM::OpMassCacheImpl< BASE_DIM, FIELD_DIM, I, OpBase > | |
| CMoFEM::OpMassImpl< BASE_DIM, FIELD_DIM, I, OpBase > | |
| ►CMoFEM::OpMassImpl< 1, FIELD_DIM, I, OpBase > | |
| CMoFEM::OpMassCacheImpl< 1, FIELD_DIM, I, OpBase > | |
| CMoFEM::OpMixDivTimesScalarImpl< SPACE_DIM, I, OpBase > | |
| CMoFEM::OpMixDivTimesUImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase, CoordSys > | |
| CMoFEM::OpMixDivTimesVecImpl< SPACE_DIM, I, OpBase, CoordSys > | |
| ►COpMixLhs | |
| CContactOps::OpMixLhsSide< OpMixLhs > | |
| CMoFEM::OpMixScalarTimesDivImpl< SPACE_DIM, I, OpBase, COORDINATE_SYSTEM > | |
| CMoFEM::OpMixTensorTimesGradImpl< SPACE_DIM, I, OpBase > | |
| CMoFEM::OpMixTensorTimesGradUImpl< SPACE_DIM, I, OpBase > | Tensor field time gradient of vector field |
| CMoFEM::OpMixVecTimesDivLambdaImpl< SPACE_DIM, I, OpBase > | Vector field time divergence of tensor |
| CMoFEM::OpMixVectorTimesGradImpl< BASE_DIM, FIELD_DIM, SPACE_DIM, I, OpBase > | |
| CEshelbianPlasticity::OpNormalDispBcLhsImpl_dP< A, I > | |
| COpNormalDispBcLhsImpl_dP< A, I > | |
| CEshelbianPlasticity::OpNormalDispBcLhsImpl_dU< A, I > | |
| COpNormalDispBcLhsImpl_dU< A, I > | |
| CEshelbianPlasticity::OpNormalDispBcRhsImpl< A, I > | |
| COpNormalDispBcRhsImpl< A, I > | |
| ►CEshelbianPlasticity::OpNormalDispBcRhsImpl< PETSC, GAUSS > | |
| CEshelbianPlasticity::OpNormalDispRhsBc | |
| ►COpNormalDispBcRhsImpl< PETSC, GAUSS > | |
| COpNormalDispRhsBc | |
| CMoFEM::OpNormalMixVecTimesScalarImpl< SPACE_DIM, I, OpBase > | Multiply vector times normal on the face times scalar function |
| ►CMoFEM::OpNormalMixVecTimesScalarImpl< FIELD_DIM, I, OpBase > | |
| CMoFEM::OpSourceImpl< 3, FIELD_DIM, I, SourceBoundaryNormalSpecialization::S< OpBase > > | This is specialisation for sources on boundary which depends on normal |
| CMoFEM::OpNormalMixVecTimesVectorFieldImpl< SPACE_DIM, I, OpBase > | Multiply vector times normal on the face times vector field |
| CPlasticOps::OpPlasticStressImpl< DIM, I, DomainEleOp > | |
| CADOLCPlasticity::OpRhsImpl< DIM, I, AssemblyDomainEleOp > | Assemble right hand side |
| CEshelbianPlasticity::OpRotationBcImpl< A, I > | |
| COpRotationBcImpl< A, I > | |
| ►CEshelbianPlasticity::OpRotationBcImpl< PETSC, GAUSS > | |
| CEshelbianPlasticity::OpRotationBc | Apply rotation boundary condition |
| ►COpRotationBcImpl< PETSC, GAUSS > | |
| COpRotationBc | Apply rotation boundary condition |
| CMoFEM::OpSchurAssembleEnd< I > | Assemble Schur complement |
| CMoFEM::OpSetContravariantPiolaTransformOnFace2DImpl< DIM > | Apply contravariant (Piola) transfer to Hdiv space on face |
| CMoFEM::OpSetCovariantPiolaTransformOnFace2DImpl< DIM > | Transform Hcurl base fluxes from reference element to physical triangle |
| CMoFEM::OpSetHOWeightsOnSubDim< SPACE_DIM > | |
| CMoFEM::OpSetInvJacHcurlFaceImpl< DIM > | Transform local reference derivatives of shape function to global derivatives for face |
| CMoFEM::OpSetInvJacSpaceForFaceImpl< DIM, DERIVATIVE > | Transform local reference derivatives of shape functions to global derivatives |
| CMoFEM::OpSourceImpl< BASE_DIM, FIELD_DIM, I, OpBase > | |
| CMoFEM::Order_mi_tag | MultiIndex Tag for field order |
| ►Cstd::ostream | |
| CMoFEM::LogManager::InternalData::NulOStream | |
| CEshelbianPlasticity::SetUpSchurImpl::P_MultiGridData | |
| CSetUpSchurImpl::P_MultiGridData | |
| CFTensor::PackPtr< T, I > | |
| CFTensor::PackPtr< adouble *, 0 > | |
| CFTensor::PackPtr< double *, 0 > | |
| CFTensor::PackPtr< TYPE *, 0 > | |
| ►Cstd::pair | |
| CMoFEM::PairNameFEMethodPtr | |
| CMoFEM::NodeMergerInterface::ParentChild | |
| ►CMoFEM::ParentFiniteElementAdjacencyFunction< DIM > | Create adjacency to parent elements |
| CMoFEM::ParentFiniteElementAdjacencyFunctionSkeleton< DIM > | Create adjacency to parent skeleton elements |
| CMoFEM::Part_mi_tag | |
| CPCArcLengthCtx | Structure for Arc Length pre-conditioner |
| CMoFEM::PCMGSetUpViaApproxOrdersCtx | |
| CMoFEM::PCMGSubMatrixCtx | |
| CConvectiveMassElement::PCShellCtx | |
| CFTensor::Permutation2< Dim0, Dim1, i, j > | |
| CFTensor::Permutation3< Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Permutation4< Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CMoFEM::PetscGlobalIdx_mi_tag | |
| CMoFEM::PetscLocalIdx_mi_tag | |
| CPhotonDiffusion | |
| CCohesiveElement::CohesiveInterfaceElement::PhysicalEquation | Constitutive (physical) equation for interface |
| ►CEshelbianPlasticity::PhysicalEquations | |
| CEshelbianPlasticity::HMHHencky | |
| CEshelbianPlasticity::HMHNeohookean | |
| CEshelbianPlasticity::HMHPMooneyRivlinWriggersEq63 | |
| CEshelbianPlasticity::HMHStVenantKirchhoff | |
| CPlasticOps::PlasticityIntegrators< DomainEleOp > | |
| CPlasticProblem | |
| CPlate | |
| CPostProcFatPrismOnRefinedMesh::PointsMap3D | |
| CPoisson2DHomogeneous | |
| CPoisson2DiscontGalerkin | |
| CPoisson2DLagrangeMultiplier | |
| CPoisson2DNonhomogeneous | |
| ►CMoFEM::PostProcBrokenMeshInMoab< E > | |
| CMyPostProc | |
| ►CPostProcBrokenMeshInMoabBase | |
| CEshelbianPlasticity::ContactTree | |
| CPostProcCommonOnRefMesh | Set of operators and data structures used for post-processing |
| CContactOps::PostProcEleByDim< DIM > | |
| CPostProcEleByDim< DIM > | |
| CContactOps::PostProcEleByDim< 2 > | |
| CPostProcEleByDim< 2 > | |
| CContactOps::PostProcEleByDim< 3 > | |
| CPostProcEleByDim< 3 > | |
| CMixTransport::UnsaturatedFlowElement::postProcessVol | Post proces method for volume element Assemble vectors and matrices and apply essential boundary conditions |
| CMoFEM::PostProcGenerateRefMesh< T > | Element for postprocessing. Uses MoAB to generate post-processing mesh |
| ►CMoFEM::PostProcGenerateRefMeshBase | |
| CMoFEM::PostProcGenerateRefMesh< MBEDGE > | |
| CMoFEM::PostProcGenerateRefMesh< MBHEX > | |
| CMoFEM::PostProcGenerateRefMesh< MBQUAD > | |
| CMoFEM::PostProcGenerateRefMesh< MBTET > | |
| CMoFEM::PostProcGenerateRefMesh< MBTRI > | |
| CMixTransport::UnsaturatedFlowElement::preProcessVol | Pre-peprocessing Set head pressure rate and get inital essential boundary conditions |
| CEshelbianPlasticity::PressureBc | |
| CMoFEM::Problem | Keeps basic data about problem |
| CMoFEM::Problem_mi_tag | |
| CMoFEM::ProblemChangeRefLevelBitAdd | Add ref level to problem |
| CMoFEM::ProblemChangeRefLevelBitDofMaskAdd | Set prof dof bit ref mask |
| CMoFEM::ProblemChangeRefLevelBitDofMaskSet | Set prof dof bit ref mask |
| CMoFEM::ProblemChangeRefLevelBitSet | Set ref level to problem |
| CMoFEM::ProblemClearComposedProblemData | Clear composed problem data structure |
| CMoFEM::ProblemClearNumeredFiniteElementsChange | Clear problem finite elements |
| CMoFEM::ProblemClearSubProblemData | Clear sub-problem data structure |
| CMoFEM::ProblemFiniteElementChangeBitAdd | Add finite element to problem |
| CMoFEM::ProblemFiniteElementChangeBitUnSet | Remove finite element from problem |
| CMoFEM::ProblemZeroNbColsChange | Zero nb. of DOFs in col |
| CMoFEM::ProblemZeroNbRowsChange | Zero nb. of DOFs in row |
| CMoFEM::Proc_mi_tag | |
| CFTensor::promote< T1, T2 > | |
| CFTensor::promote< adouble, double > | |
| CFTensor::promote< adouble, int > | |
| CFTensor::promote< adtl::adouble, double > | |
| CFTensor::promote< adtl::adouble, int > | |
| CFTensor::promote< adub, double > | |
| CFTensor::promote< adub, int > | |
| CFTensor::promote< const double, const std::complex< double > > | |
| CFTensor::promote< const double, std::complex< double > > | |
| CFTensor::promote< const std::complex< double >, const double > | |
| CFTensor::promote< const std::complex< double >, double > | |
| CFTensor::promote< double, adouble > | |
| CFTensor::promote< double, adtl::adouble > | |
| CFTensor::promote< double, adub > | |
| CFTensor::promote< double, const std::complex< double > > | |
| CFTensor::promote< double, int > | |
| CFTensor::promote< double, std::complex< double > > | |
| CFTensor::promote< int, adouble > | |
| CFTensor::promote< int, adtl::adouble > | |
| CFTensor::promote< int, adub > | |
| CFTensor::promote< int, double > | |
| CFTensor::promote< int, std::complex< double > > | |
| CFTensor::promote< std::complex< double >, const double > | |
| CFTensor::promote< std::complex< double >, double > | |
| CFTensor::promote< std::complex< double >, int > | |
| CQUAD_ | |
| CThermoElasticOps::RadiationBcType< BC > | |
| CThermalElement::RadiationData | Data for radiation |
| CReactions | Calculate reactions from vector of internal forces on meshsets |
| CEigenMatrix::ReconstructMatImpl< E, C > | |
| CMoFEM::RefEntExtractor | Extract entity handle form multi-index container |
| CMoFEM::RefEntity_change_left_shift | Ref mofem entity, left shift |
| CMoFEM::RefEntity_change_parent | Change parent |
| CMoFEM::RefEntity_change_right_shift | Ref mofem entity, right shift |
| CMoFEM::RefEntityTmp< N > | |
| ►CMoFEM::RefEntityTmp< 0 > | Struct keeps handle to refined handle |
| CMoFEM::RefEntityTmp<-1 > | |
| CMixTransport::RegisterMaterials | |
| CBoneRemodeling::Remodeling | Implementation of bone remodeling finite element |
| CFTensor::Riemann< T, Dim > | |
| CFTensor::Riemann< A, Dim > | |
| CFTensor::Riemann< T, 3 > | |
| CFTensor::Riemann_Expr< A, T, Dim, i, j, k, l > | |
| CFTensor::Riemann_Expr< B, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_Expr< Riemann< A, Dim >, T, Dim, i, j, k, l > | |
| CFTensor::Riemann_minus_Riemann< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_plus_Riemann< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_times_Tensor1_0< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_times_Tensor1_1< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_times_Tensor1_2< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_times_Tensor1_3< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Riemann_times_Tensor2_symmetric_0< A, B, T, U, Dim, i, j, k, l > | |
| CMoFEM::SourceBoundaryNormalSpecialization::S< OpBase > | |
| CMoFEM::SourceFunctionSpecialization::S< OpBase > | |
| CMoFEM::CutMeshInterface::SaveData | |
| ►CMoFEM::ScalingMethod | |
| ►CMoFEM::TimeScale | Force scale operator for reading two columns |
| CArcTimeScale | |
| CContact::ScaledTimeScale | |
| CExample::DynamicFirstOrderConsConstantTimeScale | |
| CExample::DynamicFirstOrderConsSinusTimeScale | |
| CExample::ScaledTimeScale | |
| CLinMomTimeScale | |
| ►CMoFEM::TimeScaleVector< SPACE_DIM > | Force scale operator for reading four columns (time and vector) |
| CBasicBoundaryConditionsInterface::BasicBCVectorConst | |
| CBasicBoundaryConditionsInterface::BasicBCVectorScale | |
| CMoFEM::SchurBackendMatSetValuesPtr | |
| CMoFEM::SchurDGESV | |
| CMoFEM::SchurDSYSV | |
| CMoFEM::SchurEvents | Structure to register events for Schur block assembly and solver |
| CEigenMatrix::SecondMatrixDirectiveImpl< E, C > | |
| CSeepage | |
| CMoFEM::SeriesID_mi_tag | |
| CMoFEM::SeriesName_mi_tag | |
| CMoFEM::SetBitRefLevelTool | Tool class with methods used more than twp times |
| CEshelbianPlasticity::SetIntegrationAtFrontFace | |
| CEshelbianPlasticity::SetIntegrationAtFrontVolume | |
| CMoFEM::SetOtherGlobalGhostVector< MODE > | |
| CMoFEM::SetOtherLocalGhostVector< MODE > | |
| CMoFEM::MeshRefinement::SetParent | |
| CMoFEM::FieldEvaluatorInterface::SetPts | Default evaluator for setting integration points |
| CMoFEM::FieldEvaluatorInterface::SetPtsData | |
| ►CEshelbianCore::SetUpSchur | |
| CSetUpSchurImpl | |
| ►CEshelbianPlasticity::EshelbianCore::SetUpSchur | |
| CEshelbianPlasticity::SetUpSchurImpl | |
| ►CSetUpSchur | [Push operators to pipeline] |
| CSetUpSchurImpl | |
| CSetUpSchurImpl | |
| CSetUpSchurImpl | |
| CSetUpSchurImpl | |
| CSetUpSchurImpl | |
| CLevelSet::SideData | Data structure carrying information on skeleton on both sides |
| ►CSideEleOp | |
| CEshelbianPlasticity::OpCalculateTractionFromSideEl | |
| COpCalculateTractionFromSideEl | |
| COpElectricDispJump< SPACE_DIM > | |
| CMoFEM::SideNumber | Keeps information about side number for the finite element |
| CMoFEM::SideNumber_mi_tag | |
| CFTensor::Sign_of_T3dg_plus_equals_T3dg< S > | |
| CFTensor::Sign_of_T3dg_plus_equals_T3dg< false > | |
| CFTensor::Sign_of_T3dg_plus_equals_T3dg< true > | |
| CFTensor::Sign_of_T4ddg_plus_equals_T4ddg< S > | |
| CFTensor::Sign_of_T4ddg_plus_equals_T4ddg< false > | |
| CFTensor::Sign_of_T4ddg_plus_equals_T4ddg< true > | |
| CSmoother | |
| CSmoother::SmootherBlockData | |
| CMoFEM::SnesCtx | Interface for nonlinear (SNES) solver |
| CMoFEM::SnesCtx::SnesCtxImpl | |
| CLieGroups::SO3 | |
| CEshelbianPlasticity::solve_elastic_setup | |
| CMoFEM::SourceBoundaryNormalSpecialization | |
| CMoFEM::SourceFunctionSpecialization | |
| CMoFEM::Space_mi_tag | |
| Csdf.Sphere | |
| Csdf_flat.Sphere | |
| Csdf_hertz_2d_axisymm_sphere.Sphere | |
| Csdf_hertz_3d.Sphere | |
| Csdf_sphere.Sphere | |
| Csdf_ydirection.Sphere | |
| CElasticExample::SpringBcType< BC > | |
| CStandardPoisson | |
| ►Cstd::streambuf | |
| ►CMoFEM::LogManager::InternalData::NulStreambuf | |
| CMoFEM::LogManager::InternalData::NulOStream | |
| ►Cstd::stringbuf | |
| CMoFEM::LogManager::InternalData::SelfStreamBuf | |
| CMoFEM::LogManager::InternalData::SynchronizedStreamBuf | |
| CMoFEM::LogManager::InternalData::WorldStreamBuf | |
| CMoFEM::Problem::SubProblemData | Subproblem problem data |
| CBoneRemodeling::SurfaceKDTree | Create KDTree on surface of the mesh and calculate distance |
| CFTensor::T3ch_equals_T3dg_Op< I > | |
| CFTensor::T3ch_equals_T3dg_Op< 0 > | |
| CFTensor::T3ch_equals_T3dg_Op< 1 > | |
| CFTensor::T3ch_equals_T3dg_Op< 2 > | |
| CFTensor::T4Ddg_equals_generic< A, T, U, Dim01, Dim23 > | |
| CFTensor::T4Ddg_times_equals_generic< A, T, U, Dim01, Dim23 > | |
| CMoFEM::TaoCtx | Interface for TAO solvers |
| ►CFormsIntegrators::template Assembly::template BiLinearForm::template OpMass | |
| ►CMoFEM::OpEssentialLhsImpl< DisplacementCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpEssentialLhsImpl< HeatFluxCubitBcData, BASE_DIM, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpEssentialLhsImpl< TemperatureCubitBcData, 1, 1, A, I, OpBase > | |
| ►CFormsIntegrators::template Assembly::template LinearForm::template OpNormalMixVecTimesScalar | |
| ►CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< UNKNOWNSET >, 3, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< BLOCKSET >, 3, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< TEMPERATURESET >, 3, FIELD_DIM, A, I, OpBase > | |
| ►CFormsIntegrators::template Assembly::template LinearForm::template OpSource | |
| CMoFEM::OpEssentialRhsImpl< DisplacementCubitBcData, 1, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpEssentialRhsImpl< TemperatureCubitBcData, 1, 1, A, I, OpBase > | |
| ►CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< UNKNOWNSET >, 1, 1, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< BLOCKSET >, 1, 1, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< HEATFLUXSET >, 1, 1, A, I, OpBase > | |
| ►CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< UNKNOWNSET >, 1, FIELD_DIM, A, I, OpBase > | Base class for OpFluxRhsImpl<NaturalMeshsetType<T>, 1, FIELD_DIM, A, I, OpBase> |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< BLOCKSET >, 1, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< FORCESET >, 1, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetType< PRESSURESET >, 1, FIELD_DIM, A, I, OpBase > | |
| ►CMoFEM::OpFluxRhsImpl< NaturalMeshsetTypeVectorScaling< UNKNOWNSET >, 1, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::OpFluxRhsImpl< NaturalMeshsetTypeVectorScaling< BLOCKSET >, 1, FIELD_DIM, A, I, OpBase > | |
| CMoFEM::TempMeshset | |
| CFTensor::Tensor0< T > | |
| ►CFTensor::Tensor0< T * > | |
| CFTensor::Tensor0< PackPtr< T *, I > > | |
| CFTensor::Tensor1< T, Tensor_Dim > | |
| CTensor1 | |
| CFTensor::Tensor1< A, Tensor_Dim > | |
| CFTensor::Tensor1< double, 3 > | |
| CFTensor::Tensor1< double, Dim > | |
| CTensor1< double, Dim > | |
| CFTensor::Tensor1< double, Dim1 > | |
| CFTensor::Tensor1< double, Dim12 > | |
| CFTensor::Tensor1< double, Dim2 > | |
| CFTensor::Tensor1< double, Dim23 > | |
| CFTensor::Tensor1< double, FIELD_DIM > | |
| CFTensor::Tensor1< int, Dim > | |
| CTensor1< int, Dim > | |
| CFTensor::Tensor1< int, Dim1 > | |
| CFTensor::Tensor1< int, Dim12 > | |
| CFTensor::Tensor1< int, Dim2 > | |
| CFTensor::Tensor1< int, Dim23 > | |
| CFTensor::Tensor1< T *, Dim > | |
| CFTensor::Tensor1< T *, Dim0 > | |
| ►CFTensor::Tensor1< T *, Tensor_Dim > | |
| CFTensor::Tensor1< PackPtr< T *, I >, Tensor_Dim > | |
| CFTensor::Tensor1_and_Tensor1< A, B, T, U, Dim, i > | |
| CFTensor::Tensor1_carat_Tensor1< A, B, T, U, Dim, i, j > | |
| CFTensor::Tensor1_constructor< T, Tensor_Dim > | |
| CFTensor::Tensor1_constructor< T, 1 > | |
| CFTensor::Tensor1_constructor< T, 2 > | |
| CFTensor::Tensor1_constructor< T, 3 > | |
| CFTensor::Tensor1_constructor< T, 4 > | |
| CFTensor::Tensor1_constructor< T, 6 > | |
| CFTensor::Tensor1_constructor< T, 8 > | |
| CFTensor::Tensor1_constructor< T, 9 > | |
| CFTensor::Tensor1_divide_generic< A, T, U, Dim, i > | |
| CFTensor::Tensor1_Expr< A, T, Dim, i > | |
| CTensor1_Expr< A, i > | |
| CFTensor::Tensor1_Expr< A, T, Dim0, i > | |
| CFTensor::Tensor1_Expr< B, U, Dim, i > | |
| CFTensor::Tensor1_Expr< B, U, Dim, j > | |
| CFTensor::Tensor1_Expr< B, U, Dim, k > | |
| CFTensor::Tensor1_Expr< B, U, Dim, l > | |
| CFTensor::Tensor1_Expr< B, U, Dim0, i > | |
| CFTensor::Tensor1_Expr< B, U, Dim01, i > | |
| CFTensor::Tensor1_Expr< B, U, Dim01, j > | |
| CFTensor::Tensor1_Expr< B, U, Dim01, k > | |
| CFTensor::Tensor1_Expr< B, U, Dim1, j > | |
| CFTensor::Tensor1_Expr< B, U, Dim2, k > | |
| CFTensor::Tensor1_Expr< B, U, Dim23, k > | |
| CFTensor::Tensor1_Expr< B, U, Dim23, l > | |
| CFTensor::Tensor1_Expr< B, U, Dim3, l > | |
| CFTensor::Tensor1_Expr< Dg_number_rhs_01< A, T, N1, N2 >, T, Dim, i > | |
| CFTensor::Tensor1_Expr< Dg_number_rhs_12< A, T, N1, N2 >, T, Dim, i > | |
| CFTensor::Tensor1_Expr< Tensor1< A, Tensor_Dim >, T, Dim, i > | |
| CFTensor::Tensor1_Expr< Tensor2_number_rhs_0< A, T, N >, T, Dim1, i > | |
| CFTensor::Tensor1_Expr< Tensor2_number_rhs_1< A, T, N >, T, Dim1, i > | |
| CFTensor::Tensor1_minus_generic< A, T, U, Dim, i > | |
| CFTensor::Tensor1_minus_Tensor1< A, B, T, U, Dim, i > | |
| CFTensor::Tensor1_or_Tensor1< A, B, T, U, Dim, i, j > | |
| CFTensor::Tensor1_plus_generic< A, T, U, Dim, i > | |
| CFTensor::Tensor1_plus_Tensor1< A, B, T, U, Dim, i > | |
| CFTensor::Tensor1_times_generic< A, T, U, Dim, i > | |
| CFTensor::Tensor1_times_Tensor1< A, B, T, U, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2< T, Tensor_Dim0, Tensor_Dim1 > | |
| CFTensor::Tensor2< A, Tensor_Dim0, Tensor_Dim1 > | |
| CFTensor::Tensor2< bool, Dim, 2 > | |
| CFTensor::Tensor2< bool, Dim2, 2 > | |
| CFTensor::Tensor2< bool, Dim23, 2 > | |
| CFTensor::Tensor2< double *, 3, 3 > | |
| CFTensor::Tensor2< double, 3, 3 > | |
| CFTensor::Tensor2< double, Dim, Dim > | |
| CFTensor::Tensor2< FTensor::PackPtr< adouble *, 0 >, 3, 3 > | |
| CFTensor::Tensor2< FTensor::PackPtr< double *, 0 >, 3, 3 > | |
| CFTensor::Tensor2< FTensor::PackPtr< TYPE *, 0 >, 3, 3 > | |
| ►CFTensor::Tensor2< T *, Tensor_Dim0, Tensor_Dim1 > | |
| CFTensor::Tensor2< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1 > | |
| CFTensor::Tensor2_and_Tensor1< A, B, T, U, Dim0_0, Dim1_0, Dim0_1, i0, j0, i1 > | |
| CFTensor::Tensor2_and_Tensor1< A, B, T, U, Dim0, Dim1, Dim0, i, j, i > | |
| CFTensor::Tensor2_and_Tensor1< A, B, T, U, Dim0, Dim1, Dim1, i, j, j > | |
| CFTensor::Tensor2_antisymmetric< T, Tensor_Dim > | |
| CFTensor::Tensor2_antisymmetric< A, Tensor_Dim > | |
| CFTensor::Tensor2_antisymmetric_constructor< T, Tensor_Dim > | |
| CFTensor::Tensor2_antisymmetric_constructor< T, 2 > | |
| CFTensor::Tensor2_antisymmetric_constructor< T, 3 > | |
| CFTensor::Tensor2_antisymmetric_constructor< T, 4 > | |
| CFTensor::Tensor2_antisymmetric_Expr< A, T, Dim, i, j > | |
| CFTensor::Tensor2_antisymmetric_Expr< Tensor2_antisymmetric< A, Tensor_Dim >, T, Dim, i, j > | |
| CFTensor::Tensor2_carat_Tensor2< A, B, T, U, Dim0_0, Dim1_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_carat_Tensor2< A, B, T, U, Dim, Dim1, Dim, Dim1, i, j, k, j > | |
| CFTensor::Tensor2_carat_Tensor2< A, B, T, U, Dim, Dim1, Dim1, Dim, i, j, j, k > | |
| CFTensor::Tensor2_carat_Tensor2< A, B, T, U, Dim1, Dim, Dim, Dim1, j, i, k, j > | |
| CFTensor::Tensor2_carat_Tensor2< A, B, T, U, Dim1, Dim, Dim1, Dim, j, i, j, k > | |
| CFTensor::Tensor2_constructor< T, Tensor_Dim0, Tensor_Dim1, layout > | |
| CFTensor::Tensor2_constructor< T, 1, 2, column_major > | |
| CFTensor::Tensor2_constructor< T, 1, 2, row_major > | |
| CFTensor::Tensor2_constructor< T, 2, 1, column_major > | |
| CFTensor::Tensor2_constructor< T, 2, 1, row_major > | |
| CFTensor::Tensor2_constructor< T, 2, 2, column_major > | |
| CFTensor::Tensor2_constructor< T, 2, 2, row_major > | |
| CFTensor::Tensor2_constructor< T, 3, 2, column_major > | |
| CFTensor::Tensor2_constructor< T, 3, 2, row_major > | |
| CFTensor::Tensor2_constructor< T, 3, 3, column_major > | |
| CFTensor::Tensor2_constructor< T, 3, 3, row_major > | |
| CFTensor::Tensor2_constructor< T, 4, 4, column_major > | |
| CFTensor::Tensor2_constructor< T, 4, 4, row_major > | |
| CFTensor::Tensor2_divide_generic< A, T, U, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2_Expr< A, T, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2_Expr< A, T, Dim, Dim, i, j > | |
| CFTensor::Tensor2_Expr< A, T, Dim, Dim1, i, j > | |
| CFTensor::Tensor2_Expr< A, T, Dim1, Dim, j, i > | |
| CFTensor::Tensor2_Expr< A, T, Dim1, Dim0, j, i > | |
| CFTensor::Tensor2_Expr< B, U, Dim, Dim, i, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim, Dim, j, i > | |
| CFTensor::Tensor2_Expr< B, U, Dim, Dim, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim, Dim, k, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim, Dim1, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim, Dim1, k, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim0, Dim3, i, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim0, Dim4, i, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim01, i, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim01, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim01, k, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim1, i, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim1, m, i > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim2, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim2, j, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim2, m, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim23, j, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim01, Dim3, j, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim1, Dim, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim1, Dim, k, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim1, Dim0, j, i > | |
| CFTensor::Tensor2_Expr< B, U, Dim1, Dim2, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim1, Dim4, j, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim2, Dim01, j, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim2, Dim01, k, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim2, Dim1, k, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim2, Dim3, j, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim2, Dim3, k, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim2, Dim4, k, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim23, Dim23, k, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim23, Dim23, l, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim23, Dim4, l, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim3, Dim0, l, i > | |
| CFTensor::Tensor2_Expr< B, U, Dim3, Dim01, l, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim3, Dim2, l, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim3, Dim4, l, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim0, m, i > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim1, m, j > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim2, m, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim23, k, m > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim23, m, k > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim23, m, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim3, m, l > | |
| CFTensor::Tensor2_Expr< B, U, Dim4, Dim5, m, n > | |
| CFTensor::Tensor2_Expr< Dg_number_rhs_0< A, T, N >, T, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2_Expr< Tensor2< A, Tensor_Dim0, Tensor_Dim1 >, T, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2_minus_Tensor2< A, B, T, U, Dim0_0, Dim1_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_minus_Tensor2< A, B, T, U, Dim0, Dim1, Dim0, Dim1, i, j, i, j > | |
| CFTensor::Tensor2_minus_Tensor2< A, B, T, U, Dim0, Dim1, Dim1, Dim0, i, j, j, i > | |
| CFTensor::Tensor2_minus_Tensor2_symmetric< A, B, T, U, Dim0_0, Dim1_0, Dim_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_minus_Tensor2_symmetric< A, B, T, U, Dim, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_minus_Tensor2_symmetric< A, B, T, U, Dim, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_number_0< A, T, N > | |
| CFTensor::Tensor2_number_1< A, T, N > | |
| CFTensor::Tensor2_number_rhs_0< A, T, N > | |
| CFTensor::Tensor2_number_rhs_1< A, T, N > | |
| CFTensor::Tensor2_numeral_0< A, T > | |
| CFTensor::Tensor2_numeral_1< A, T > | |
| CFTensor::Tensor2_or_Tensor2< A, B, T, U, Dim0_0, Dim1_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_or_Tensor2< A, B, T, U, Dim, Dim, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_or_Tensor2< A, B, T, U, Dim, Dim, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_plus_Tensor2< A, B, T, U, Dim0_0, Dim1_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_plus_Tensor2< A, B, T, U, Dim0, Dim1, Dim0, Dim1, i, j, i, j > | |
| CFTensor::Tensor2_plus_Tensor2< A, B, T, U, Dim0, Dim1, Dim1, Dim0, i, j, j, i > | |
| CFTensor::Tensor2_symmetric< T, Tensor_Dim > | |
| CFTensor::Tensor2_symmetric< A, Tensor_Dim > | |
| CFTensor::Tensor2_symmetric< adouble, 3 > | |
| CFTensor::Tensor2_symmetric< double, Dim > | |
| CFTensor::Tensor2_symmetric< T *, Dim > | |
| CFTensor::Tensor2_symmetric< T *, Dim01 > | |
| ►CFTensor::Tensor2_symmetric< T *, Tensor_Dim > | |
| CFTensor::Tensor2_symmetric< PackPtr< T *, I >, Tensor_Dim > | |
| CFTensor::Tensor2_symmetric< VT2, DimT2 > | |
| CFTensor::Tensor2_symmetric_and_Tensor2_symmetric< A, B, T, U, Dim_0, Dim_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_and_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_symmetric_and_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_symmetric_carat_Tensor2< A, B, T, U, Dim_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_carat_Tensor2< A, B, T, U, Dim, Dim, Dim, i, j, j, k > | |
| CFTensor::Tensor2_symmetric_carat_Tensor2< A, B, T, U, Dim, Dim, Dim, i, j, k, j > | |
| CFTensor::Tensor2_symmetric_carat_Tensor2< A, B, T, U, Dim, Dim, Dim, j, i, j, k > | |
| CFTensor::Tensor2_symmetric_carat_Tensor2< A, B, T, U, Dim, Dim, Dim, j, i, k, j > | |
| CFTensor::Tensor2_symmetric_carat_Tensor2_symmetric< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Tensor2_symmetric_constructor< T, Tensor_Dim > | |
| CFTensor::Tensor2_symmetric_constructor< T, 1 > | |
| CFTensor::Tensor2_symmetric_constructor< T, 2 > | |
| CFTensor::Tensor2_symmetric_constructor< T, 3 > | |
| CFTensor::Tensor2_symmetric_constructor< T, 4 > | |
| CFTensor::Tensor2_symmetric_divide_generic< A, T, U, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< A, T, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< A, T, Dim, i, k > | |
| CFTensor::Tensor2_symmetric_Expr< A, T, Dim, j, i > | |
| CFTensor::Tensor2_symmetric_Expr< A, T, Dim0, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< B, T, Dim, j, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, i, k > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, i, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, j, i > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, j, k > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, j, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, k, j > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, k, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, l, i > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim, l, k > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim01, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim01, j, k > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim01, j, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim01, k, j > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim01, l, j > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim1, k, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim2, k, l > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim2, l, k > | |
| CFTensor::Tensor2_symmetric_Expr< B, U, Dim23, k, l > | |
| CFTensor::Tensor2_symmetric_Expr< Ddg_number_rhs_01< A, T, N0, N1 >, T, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< Dg_number_rhs_2< A, T, N >, T, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_Expr< Tensor2_symmetric< A, Tensor_Dim >, T, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_minus_generic< A, T, U, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_minus_Tensor2< A, B, T, U, Dim_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_minus_Tensor2< A, B, T, U, Dim, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_symmetric_minus_Tensor2< A, B, T, U, Dim, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_symmetric_minus_Tensor2_symmetric< A, B, T, U, Dim_0, Dim_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_minus_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_symmetric_minus_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_symmetric_mod_Tensor2_symmetric< A, B, T, U, Dim_0, Dim_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_mod_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_symmetric_mod_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_symmetric_plus_Tensor2< A, B, T, U, Dim_0, Dim0_1, Dim1_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_plus_Tensor2< A, B, T, U, Dim, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_symmetric_plus_Tensor2< A, B, T, U, Dim, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_symmetric_plus_Tensor2_symmetric< A, B, T, U, Dim_0, Dim_1, i0, j0, i1, j1 > | |
| CFTensor::Tensor2_symmetric_plus_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, i, j > | |
| CFTensor::Tensor2_symmetric_plus_Tensor2_symmetric< A, B, T, U, Dim, Dim, i, j, j, i > | |
| CFTensor::Tensor2_symmetric_times_Tensor1< A, B, T, U, Dim, Dim2, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor1_0< A, B, T, U, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_times_Tensor1_1< A, B, T, U, Dim, i, j > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_00< A, B, T, U, Dim, Dim1, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_01< A, B, T, U, Dim, Dim1, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_10< A, B, T, U, Dim, Dim1, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_11< A, B, T, U, Dim, Dim1, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_symmetric< A, B, T, U, Dim0, Dim1, i, j, k, l > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_symmetric_00< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_symmetric_01< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_symmetric_10< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Tensor2_symmetric_times_Tensor2_symmetric_11< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Tensor2_times_generic< A, T, U, Dim0, Dim1, i, j > | |
| CFTensor::Tensor2_times_Tensor1< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor2_times_Tensor1_single< A, B, T, U, Dim0, Dim1, Dim2, i, j, k, DimA, DimX, a, x > | |
| CFTensor::Tensor2_times_Tensor2< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor2_times_Tensor2_00< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor2_times_Tensor2_01< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor2_times_Tensor2_10< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor2_times_Tensor2_11< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > | |
| CFTensor::Tensor3< A, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > | |
| ►CFTensor::Tensor3< T *, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > | |
| CFTensor::Tensor3< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > | |
| CFTensor::Tensor3_antisymmetric< T, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Tensor3_antisymmetric< A, Dim0, Dim12 > | |
| CFTensor::Tensor3_antisymmetric< T *, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Tensor3_antisymmetric_constructor< T, Tensor_Dim0, Tensor_Dim12 > | |
| CFTensor::Tensor3_antisymmetric_constructor< T, 2, 2 > | |
| CFTensor::Tensor3_antisymmetric_constructor< T, 3, 3 > | |
| CFTensor::Tensor3_antisymmetric_constructor< T, 4, 4 > | |
| CFTensor::Tensor3_antisymmetric_Expr< A, T, Dim0, Dim12, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_Expr< A, T, Dim, Dim, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_Expr< A, T, Dim, Dim, j, k, l > | |
| CFTensor::Tensor3_antisymmetric_Expr< B, U, Dim, Dim, k, j, i > | |
| CFTensor::Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_Expr< B, U, Dim0, Dim12, i, k, j > | |
| CFTensor::Tensor3_antisymmetric_Expr< Tensor3_antisymmetric< A, Dim0, Dim12 >, T, Dim0, Dim12, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_mod_Tensor1< A, B, T, U, Dim, i, j, k, l > | |
| CFTensor::Tensor3_antisymmetric_or_Tensor3_antisymmetric< A, B, T, U, Dim, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_plus_Tensor3_antisymmetric< A, B, T, U, Dim0, Dim12, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_plus_Tensor3_antisymmetric_12< A, B, T, U, Dim0, Dim12, i, j, k > | |
| CFTensor::Tensor3_antisymmetric_times_generic< A, T, U, Dim0, Dim12, i, j, k > | |
| CFTensor::Tensor3_constructor< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 > | |
| CFTensor::Tensor3_constructor< T, 2, 2, 2 > | |
| CFTensor::Tensor3_constructor< T, 3, 3, 3 > | |
| CFTensor::Tensor3_constructor< T, 4, 4, 4 > | |
| CFTensor::Tensor3_contracted_01< A, T, Dim > | |
| CFTensor::Tensor3_contracted_02< A, T, Dim > | |
| CFTensor::Tensor3_contracted_12< A, T, Dim > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim, Dim, Dim2, j, k, i > | |
| CFTensor::Tensor3_Expr< A, T, Dim, Dim1, Dim, j, i, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim, Dim, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim1, Dim, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim1, Dim22, i, j, m > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim1, Dim23, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim1, Dim3, i, j, l > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim10, Dim2, i, m, j > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim12, Dim12, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim14, Dim25, k, i, j > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim15, Dim24, i, k, l > | |
| CFTensor::Tensor3_Expr< A, T, Dim0, Dim2, Dim3, i, k, l > | |
| CFTensor::Tensor3_Expr< A, T, Dim02, Dim1, Dim02, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim03, Dim14, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim04, Dim13, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< A, T, Dim2, Dim1, Dim01, j, i, k > | |
| CFTensor::Tensor3_Expr< B, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< B, U, Dim0, Dim12, Dim12, i, k, j > | |
| CFTensor::Tensor3_Expr< B, U, Dim0, Dim2, Dim1, i, k, j > | |
| CFTensor::Tensor3_Expr< B, U, Dim02, Dim1, Dim02, j, i, k > | |
| CFTensor::Tensor3_Expr< B, U, Dim02, Dim1, Dim02, k, j, i > | |
| CFTensor::Tensor3_Expr< B, U, Dim03, Dim14, Dim5, i, j, l > | |
| CFTensor::Tensor3_Expr< B, U, Dim1, Dim0, Dim2, j, i, k > | |
| CFTensor::Tensor3_Expr< B, U, Dim1, Dim2, Dim0, j, k, i > | |
| CFTensor::Tensor3_Expr< B, U, Dim10, Dim3, Dim4, m, k, l > | |
| CFTensor::Tensor3_Expr< B, U, Dim13, Dim04, Dim5, j, i, l > | |
| CFTensor::Tensor3_Expr< B, U, Dim2, Dim0, Dim1, k, i, j > | |
| CFTensor::Tensor3_Expr< B, U, Dim2, Dim1, Dim0, k, j, i > | |
| CFTensor::Tensor3_Expr< B, U, Dim2, Dim3, Dim22, k, l, m > | |
| CFTensor::Tensor3_Expr< B, U, Dim2, Dim3, Dim4, k, l, m > | |
| CFTensor::Tensor3_Expr< B, U, Dim23, Dim4, Dim5, k, l, m > | |
| CFTensor::Tensor3_Expr< B, U, Dim3, Dim14, Dim25, l, i, j > | |
| CFTensor::Tensor3_Expr< B, U, Dim3, Dim24, Dim15, j, l, k > | |
| CFTensor::Tensor3_Expr< B, U, Dim4, Dim2, Dim1, m, k, j > | |
| CFTensor::Tensor3_Expr< B, U, Dim4, Dim5, Dim6, m, n, o > | |
| CFTensor::Tensor3_Expr< Tensor3< A, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2 >, T, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< Tensor4_number_rhs_2< A, T, N >, T, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_Expr< Tensor4_number_rhs_3< A, T, N >, T, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0_0, Dim1_0, Dim2_0, Dim0_1, Dim1_1, Dim2_1, i0, j0, k0, i1, j1, k1 > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim0, Dim1, Dim2, i, j, k, i, j, k > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim0, Dim2, Dim1, i, j, k, i, k, j > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim1, Dim0, Dim2, i, j, k, j, i, k > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim1, Dim2, Dim0, i, j, k, j, k, i > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim2, Dim0, Dim1, i, j, k, k, i, j > | |
| CFTensor::Tensor3_minus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim2, Dim1, Dim0, i, j, k, k, j, i > | |
| CFTensor::Tensor3_number_0< A, T, N > | |
| CFTensor::Tensor3_number_01< A, T, N1, N2 > | |
| CFTensor::Tensor3_number_02< A, T, N1, N2 > | |
| CFTensor::Tensor3_number_1< A, T, N > | |
| CFTensor::Tensor3_number_12< A, T, N1, N2 > | |
| CFTensor::Tensor3_number_2< A, T, N > | |
| CFTensor::Tensor3_number_rhs_0< A, T, N > | |
| CFTensor::Tensor3_number_rhs_01< A, T, N1, N2 > | |
| CFTensor::Tensor3_number_rhs_02< A, T, N1, N2 > | |
| CFTensor::Tensor3_number_rhs_1< A, T, N > | |
| CFTensor::Tensor3_number_rhs_12< A, T, N1, N2 > | |
| CFTensor::Tensor3_number_rhs_2< A, T, N > | |
| CFTensor::Tensor3_numeral_0< A, T > | |
| CFTensor::Tensor3_numeral_01< A, T > | |
| CFTensor::Tensor3_numeral_12< A, T > | |
| CFTensor::Tensor3_numeral_2< A, T > | |
| CFTensor::Tensor3_or_Tensor3< A, B, T, U, Dim0_0, Dim1_0, Dim2_0, Dim0_1, Dim1_1, Dim2_1, i0, j0, k0, i1, j1, k1 > | |
| CFTensor::Tensor3_or_Tensor3< A, B, T, U, Dim0, Dim12, Dim12, Dim0, Dim12, Dim12, i, j, k, i, k, j > | |
| CFTensor::Tensor3_or_Tensor3< A, B, T, U, Dim02, Dim1, Dim02, Dim02, Dim1, Dim02, i, j, k, j, i, k > | |
| CFTensor::Tensor3_or_Tensor3< A, B, T, U, Dim02, Dim1, Dim02, Dim02, Dim1, Dim02, i, j, k, k, j, i > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0_0, Dim1_0, Dim2_0, Dim0_1, Dim1_1, Dim2_1, i0, j0, k0, i1, j1, k1 > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim0, Dim1, Dim2, i, j, k, i, j, k > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim0, Dim2, Dim1, i, j, k, i, k, j > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim1, Dim0, Dim2, i, j, k, j, i, k > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim1, Dim2, Dim0, i, j, k, j, k, i > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim2, Dim0, Dim1, i, j, k, k, i, j > | |
| CFTensor::Tensor3_plus_Tensor3< A, B, T, U, Dim0, Dim1, Dim2, Dim2, Dim1, Dim0, i, j, k, k, j, i > | |
| CFTensor::Tensor3_times_Dg< A, B, T, U, Dim0, Dim1, Dim2, Dim, i, j, k, l, m > | |
| CFTensor::Tensor3_times_Dg_02_20< A, B, T, U, Dim2, Dim1, Dim01, i, j, k, l > | |
| CFTensor::Tensor3_times_Dg_12_12< A, B, T, U, Dim03, Dim14, Dim2, Dim5, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor1_0< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_times_Tensor1_1< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_times_Tensor1_2< A, B, T, U, Dim0, Dim1, Dim2, i, j, k > | |
| CFTensor::Tensor3_times_Tensor1_34< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_0_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_0_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_1_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_1_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_2_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_2_10< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_double< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m, DimA, DimX, DimY, a, x, y > | |
| CFTensor::Tensor3_times_Tensor2_symmetric_0< A, B, T, U, Dim, Dim1, Dim2, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_symmetric_01< A, B, T, U, Dim2, Dim, i, j, k > | |
| CFTensor::Tensor3_times_Tensor2_symmetric_02< A, B, T, U, Dim1, Dim, i, j, k > | |
| CFTensor::Tensor3_times_Tensor2_symmetric_1< A, B, T, U, Dim0, Dim, Dim2, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor2_symmetric_12< A, B, T, U, Dim0, Dim, i, j, k > | |
| CFTensor::Tensor3_times_Tensor3_10< A, B, T, U, Dim0, Dim10, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor3_times_Tensor3_12_12< A, B, T, U, Dim03, Dim14, Dim2, Dim5, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor3_12_21< A, B, T, U, Dim04, Dim13, Dim2, Dim5, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor3_21< A, B, T, U, Dim0, Dim1, Dim23, Dim4, Dim5, i, j, k, l, m > | |
| CFTensor::Tensor3_times_Tensor3_22< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim22, i, j, k, l, m > | |
| CFTensor::Tensor3_times_Tensor3_23_23< A, B, T, U, Dim14, Dim25, Dim0, Dim3, i, j, k, l > | |
| CFTensor::Tensor3_times_Tensor3_23_32< A, B, T, U, Dim15, Dim24, Dim0, Dim3, i, j, k, l > | |
| CFTensor::Tensor4< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > | |
| CFTensor::Tensor4< A, Dim0, Dim1, Dim2, Dim3 > | |
| ►CFTensor::Tensor4< T *, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > | |
| CFTensor::Tensor4< PackPtr< T *, I >, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > | |
| CFTensor::Tensor4_constructor< T, Tensor_Dim0, Tensor_Dim1, Tensor_Dim2, Tensor_Dim3 > | |
| CFTensor::Tensor4_constructor< T, 2, 2, 2, 2 > | |
| CFTensor::Tensor4_constructor< T, 3, 3, 3, 3 > | |
| CFTensor::Tensor4_contracted_01< A, T, Dim > | |
| CFTensor::Tensor4_contracted_02< A, T, Dim > | |
| CFTensor::Tensor4_contracted_03< A, T, Dim > | |
| CFTensor::Tensor4_contracted_12< A, T, Dim > | |
| CFTensor::Tensor4_contracted_13< A, T, Dim > | |
| CFTensor::Tensor4_contracted_23< A, T, Dim > | |
| CFTensor::Tensor4_Expr< A, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_Expr< A, T, Dim, Dim, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_Expr< A, T, Dim, Dim1, Dim2, Dim, i, j, k, l > | |
| CFTensor::Tensor4_Expr< A, T, Dim0, Dim1, Dim, Dim, i, j, k, l > | |
| CFTensor::Tensor4_Expr< A, T, Dim01, Dim01, Dim23, Dim23, i, j, k, l > | |
| CFTensor::Tensor4_Expr< A, T, Dim0_0, Dim1_0, Dim2_0, Dim3_0, i0, j0, k0, l0 > | |
| CFTensor::Tensor4_Expr< B, U, Dim0, Dim1, Dim23, Dim23, i, j, m, n > | |
| CFTensor::Tensor4_Expr< B, U, Dim0, Dim1, Dim4, Dim5, i, j, m, n > | |
| CFTensor::Tensor4_Expr< B, U, Dim01, Dim01, Dim23, Dim23, j, i, l, k > | |
| CFTensor::Tensor4_Expr< B, U, Dim0_1, Dim1_1, Dim2_1, Dim3_1, i1, j1, k1, l1 > | |
| CFTensor::Tensor4_Expr< B, U, Dim2, Dim3, Dim4, Dim5, k, l, m, n > | |
| CFTensor::Tensor4_Expr< B, U, Dim23, Dim23, Dim2, Dim3, m, n, k, l > | |
| CFTensor::Tensor4_Expr< Tensor4< A, Dim0, Dim1, Dim2, Dim3 >, T, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_minus_Tensor4< A, B, T, U, Dim0_0, Dim1_0, Dim2_0, Dim3_0, Dim0_1, Dim1_1, Dim2_1, Dim3_1, i0, j0, k0, l0, i1, j1, k1, l1 > | |
| CFTensor::Tensor4_number_2< A, T, N > | |
| CFTensor::Tensor4_number_3< A, T, N > | |
| CFTensor::Tensor4_number_rhs_2< A, T, N > | |
| CFTensor::Tensor4_number_rhs_3< A, T, N > | |
| CFTensor::Tensor4_numeral_2< A, T > | |
| CFTensor::Tensor4_numeral_3< A, T > | |
| CFTensor::Tensor4_or_Tensor4< A, B, T, U, Dim0_0, Dim1_0, Dim2_0, Dim3_0, Dim0_1, Dim1_1, Dim2_1, Dim3_1, i0, j0, k0, l0, i1, j1, k1, l1 > | |
| CFTensor::Tensor4_or_Tensor4< A, B, T, U, Dim01, Dim01, Dim23, Dim23, Dim01, Dim01, Dim23, Dim23, i, j, k, l, j, i, l, k > | |
| CFTensor::Tensor4_plus_Tensor4< A, B, T, U, Dim0_0, Dim1_0, Dim2_0, Dim3_0, Dim0_1, Dim1_1, Dim2_1, Dim3_1, i0, j0, k0, l0, i1, j1, k1, l1 > | |
| CFTensor::Tensor4_times_Dg_01< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Dg_23< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor1_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor1_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor1_2< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor1_3< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_03< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_0_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_0_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_13< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_1_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_1_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_23< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_2_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_2_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_30< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_32< A, B, T, U, Dim0, Dim1, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_3_0< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_3_1< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor2_double< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, Dim5, i, j, k, l, m, n, DimA, DimB, DimX, DimY, a, b, x, y > | |
| CFTensor::Tensor4_times_Tensor2_single< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, Dim5, i, j, k, l, m, n, DimA, DimB, DimC, DimX, DimY, a, b, c, x, y > | |
| CFTensor::Tensor4_times_Tensor2_symmetric_01< A, B, T, U, Dim, Dim2, Dim3, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_symmetric_02< A, B, T, U, Dim, Dim1, Dim2, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_symmetric_03< A, B, T, U, Dim, Dim1, Dim2, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_symmetric_23< A, B, T, U, Dim0, Dim1, Dim, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_symmetric_30< A, B, T, U, Dim, Dim1, Dim2, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor2_symmetric_32< A, B, T, U, Dim0, Dim1, Dim, i, j, k, l > | |
| CFTensor::Tensor4_times_Tensor3_12_21< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor3_23< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, i, j, k, l, m > | |
| CFTensor::Tensor4_times_Tensor3_triple< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, Dim5, Dim6, i, j, k, l, m, n, o, DimA, DimX, DimY, DimZ, a, x, y, z > | |
| CFTensor::Tensor4_times_Tensor4_0145< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, Dim5, i, j, k, l, m, n > | |
| CFTensor::Tensor4_times_Tensor4_2345< A, B, T, U, Dim0, Dim1, Dim2, Dim3, Dim4, Dim5, i, j, k, l, m, n > | |
| CEshelbianPlasticity::TensorTypeExtractor< T > | |
| CLieGroups::TensorTypeExtractor< T > | |
| CEshelbianPlasticity::TensorTypeExtractor< FTensor::PackPtr< T, I > > | |
| CLieGroups::TensorTypeExtractor< FTensor::PackPtr< T, I > > | |
| CTestBitLevel | |
| CTetBaseCache | |
| ►CTetPolynomialBase | |
| CEshelbianPlasticity::CGGUserPolynomialBase | |
| CThermalElement | Structure grouping operators and data used for thermal problems |
| CThermalStressElement | Implentation of thermal stress element |
| CThermoElasticProblem | |
| ►CTimeScale | |
| CEshelbianCore::DynamicRelaxationTimeScale | |
| CEshelbianPlasticity::EshelbianCore::DynamicRelaxationTimeScale | |
| CEshelbianPlasticity::TractionBc | |
| CFTensor::transform_Tensor2< A, B, T, Dim0, Dim1, i, j > | |
| CMoFEM::CutMeshInterface::TreeData | |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A >::TriLinearForm< I > | Tri linear form |
| ►CTriLinearForm | |
| CMoFEM::FormsIntegrators< EleOp >::Assembly< A > | Bilinear integrator form |
| CMoFEM::TSAdaptMoFEM | Custom TSAdaptivity in MoFEM |
| CMoFEM::TsCtx | Interface for Time Stepping (TS) solver |
| CEshelbianPlasticity::TSElasticPostStep | |
| CTSElasticPostStep | |
| CTSPrePostProc | Set of functions called by PETSc solver used to refine and update mesh |
| ►CADOLCPlasticity::TSUpdate | Update internal fluxes (update history variables) |
| CADOLCPlasticity::TSUpdateImpl | [TSUpdateImpl] |
| CMoFEM::TypeSide_mi_tag | |
| CMoFEM::SchurElemMats::uid_mi_tag | |
| CMoFEM::UnknownInterface::UIdTypeMap | |
| CMoFEM::Unique_Ent_mi_tag | |
| CMoFEM::Unique_FiniteElement_mi_tag | |
| CMoFEM::Unique_mi_tag | |
| ►CMoFEM::UnknownInterface | Base class for all interface classes |
| CEshelbianCore | |
| CEshelbianPlasticity::EshelbianCore | |
| ►CMoFEM::BaseFunctionUnknownInterface | |
| ►CMoFEM::BaseFunction | Base class if inherited used to calculate base functions |
| CMoFEM::EdgePolynomialBase | Calculate base functions on tetrahedral |
| CMoFEM::FatPrismPolynomialBase | Calculate base functions on tetrahedralFIXME: Need moab and mofem finite element structure to work (that not perfect) |
| CMoFEM::FlatPrismPolynomialBase | Calculate base functions on tetrahedralFIXME: Need moab and mofem finite element structure to work (that not perfect) |
| CMoFEM::HexPolynomialBase | Calculate base functions on tetrahedral |
| ►CMoFEM::JacobiPolynomial | Calculating Legendre base functions |
| CMoFEM::IntegratedJacobiPolynomial | |
| ►CMoFEM::LegendrePolynomial | Calculating Legendre base functions |
| CMoFEM::KernelLobattoPolynomial | Calculating Lobatto base functions |
| CMoFEM::LobattoPolynomial | Calculating Lobatto base functions |
| CMoFEM::QuadPolynomialBase | Calculate base functions on triangle |
| CMoFEM::TetPolynomialBase | Calculate base functions on tetrahedral |
| CMoFEM::TriPolynomialBase | Calculate base functions on triangle |
| CSomeUserPolynomialBase | Class used to calculate base functions at integration points |
| ►CMoFEM::BaseFunctionCtx | Base class used to exchange data between element data structures and class calculating base functions |
| ►CMoFEM::EntPolynomialBaseCtx | Class used to pass element data to calculate base functions on tet,triangle,edge |
| CMoFEM::FatPrismPolynomialBaseCtx | Class used to pass element data to calculate base functions on fat prism |
| CMoFEM::FlatPrismPolynomialBaseCtx | Class used to pass element data to calculate base functions on flat prism |
| ►CMoFEM::JacobiPolynomialCtx | Class used to give arguments to Legendre base functions |
| CMoFEM::IntegratedJacobiPolynomialCtx | |
| ►CMoFEM::LegendrePolynomialCtx | Class used to give arguments to Legendre base functions |
| CMoFEM::KernelLobattoPolynomialCtx | Class used to give arguments to Kernel Lobatto base functions |
| CMoFEM::LobattoPolynomialCtx | Class used to give arguments to Lobatto base functions |
| CMoFEM::BcManager | Simple interface for fast problem set-up |
| CMoFEM::BitRefManager | Managing BitRefLevels |
| CMoFEM::CommInterface | Managing BitRefLevels |
| ►CMoFEM::CoreInterface | Interface |
| ►CMoFEM::DeprecatedCoreInterface | Deprecated interface functions |
| ►CMoFEM::CoreTmp< 0 > | Core (interface) class |
| CMoFEM::CoreTmp<-1 > | |
| CMoFEM::CreateRowCompressedADJMatrix | Create compressed matrix |
| CMoFEM::CutMeshInterface | Interface to cut meshes |
| ►CMoFEM::DMCtx | PETSc Discrete Manager data structure |
| ►CMoFEM::DMCtxImpl | |
| CMoFEM::DMMGViaApproxOrdersCtx | Structure for DM for multi-grid via approximation orders |
| CMoFEM::FieldBlas | Basic algebra on fields |
| CMoFEM::FieldEvaluatorInterface | Field evaluator interface |
| CMoFEM::ISManager | Section manager is used to create indexes and sections |
| CMoFEM::LogManager | Log manager is used to build and partition problems |
| CMoFEM::MatrixManager | Matrix manager is used to build and partition problems |
| CMoFEM::MedInterface | Interface for load MED files |
| CMoFEM::MeshRefinement | Mesh refinement interface |
| CMoFEM::MeshsetsManager | Interface for managing meshsets containing materials and boundary conditions |
| CMoFEM::NodeMergerInterface | Merge node by collapsing edge between them |
| CMoFEM::OperatorsTester | Calculate directional derivative of the right hand side and compare it with tangent matrix derivative |
| ►CMoFEM::PetscData | |
| ►CMoFEM::KspMethod | Data structure for ksp (linear solver) context |
| ►CMoFEM::BasicMethod | Data structure to exchange data between mofem and User Loop Methods |
| ►CMoFEM::DofMethod | Data structure to exchange data between mofem and User Loop Methods on entities |
| CBasicFiniteElements::SaveVertexDofOnTag | Save field DOFS on vertices/tags |
| CBasicFiniteElements::SaveVertexDofOnTag | Save field DOFS on vertices/tags |
| ►CMoFEM::Projection10NodeCoordsOnField | Projection of edge entities with one mid-node on hierarchical basis |
| CMoFEM::ProjectionFieldOn10NodeTet | |
| ►CMoFEM::EntityMethod | Data structure to exchange data between mofem and User Loop Methods on entities |
| CBcEntMethodDisp | |
| CBcEntMethodSpatial | |
| CTestEntityMethod | |
| ►CMoFEM::FEMethod | Structure for User Loop Methods on finite elements |
| CApplyDirichletBc | |
| CCohesiveElement::AssembleRhsVectors | |
| CConvectiveMassElement::ShellResidualElement | |
| CConvectiveMassElement::UpdateAndControl | Set fields DOT_ |
| CCountDown | |
| CCountUp | |
| ►CDirichletDisplacementBc | Set Dirichlet boundary conditions on displacements |
| CAnalyticalDirichletBC::DirichletBC | Structure used to enforce analytical boundary conditions |
| ►CDirichletDisplacementRemoveDofsBc | Set Dirichlet boundary conditions on displacements by removing dofs |
| CDirichletSpatialRemoveDofsBc | Set Dirichlet boundary conditions on spatial positions by removing dofs |
| CDirichletFixFieldAtEntitiesBc | Fix dofs on entities |
| CDirichletSetFieldFromBlockWithFlags | Add boundary conditions form block set having 6 attributes |
| CDirichletSpatialPositionsBc | Set Dirichlet boundary conditions on spatial displacements |
| CDirichletTemperatureBc | |
| CEshelbianPlasticity::EshelbianMonitor | |
| CMixTransport::UnsaturatedFlowElement::MonitorPostProc | |
| ►CMoFEM::ForcesAndSourcesCore | Structure to get information form mofem into EntitiesFieldData |
| CEshelbianPlasticity::SetIntegrationAtFrontFace::Fe | |
| CEshelbianPlasticity::SetIntegrationAtFrontVolume::Fe | |
| CMoFEM::ContactPrismElementForcesAndSourcesCore | ContactPrism finite element |
| ►CMoFEM::EdgeElementForcesAndSourcesCore | Edge finite element |
| ►CMoFEM::PostProcBrokenMeshInMoabBase< EdgeElementForcesAndSourcesCore > | |
| CMoFEM::PostProcBrokenMeshInMoab< EdgeElementForcesAndSourcesCore > | |
| ►CPostProcTemplateOnRefineMesh< EdgeEleBasePostProc > | |
| CPostProcEdgeOnRefinedMesh | Postprocess on edge |
| CEdgeFE | |
| CEdgeForce::MyFE | |
| CEdgeSlidingConstrains::MyEdgeFE | |
| CEdgeSlidingConstrains::MyEdgeFE | |
| CMoFEM::EdgeElementForcesAndSourcesCoreOnChildParent | Base face element used to integrate on skeleton |
| ►CMoFEM::FaceElementForcesAndSourcesCore | Face finite element |
| ►CMoFEM::PostProcBrokenMeshInMoabBase< FaceElementForcesAndSourcesCore > | |
| CMoFEM::PostProcBrokenMeshInMoab< FaceElementForcesAndSourcesCore > | |
| ►CPostProcTemplateOnRefineMesh< MoFEM::FaceElementForcesAndSourcesCore > | |
| ►CPostProcFaceOnRefinedMesh | Postprocess on face |
| CPostProcFaceOnRefinedMeshFor2D | Postprocess 2d face elements |
| CAnalyticalDirichletBC::ApproxField::MyTriFE | |
| CFluidPressure::MyTriangleFE | |
| CMagneticElement::TriFE | Define surface element |
| CMixTransport::MixTransportElement::MyTriFE | Definition of surface element |
| ►CMoFEM::FaceElementForcesAndSourcesCoreOnChildParent | Base face element used to integrate on skeleton |
| CMoFEM::FaceElementForcesAndSourcesCoreOnChildParentSwitch< SWITCH > | |
| ►CMoFEM::FaceElementForcesAndSourcesCoreOnSide | Base face element used to integrate on skeleton |
| CMoFEM::FaceElementForcesAndSourcesCoreOnSideSwitch< SWITCH > | |
| CNeumannForcesSurface::MyTriangleFE | |
| CNeumannForcesSurfaceComplexForLazy::MyTriangleSpatialFE | |
| CQuadFE | |
| CSurfaceSlidingConstrains::MyTriangleFE | |
| CSurfaceSlidingConstrains::MyTriangleFE | |
| CThermalElement::MyTriFE | Define surface element |
| CTriFE | |
| ►CMoFEM::FlatPrismElementForcesAndSourcesCore | FlatPrism finite element |
| CCohesiveElement::CohesiveInterfaceElement::MyPrism | |
| CMoFEM::PipelineManager::MeshsetFE | |
| ►CMoFEM::VertexElementForcesAndSourcesCore | Vertex finite element |
| CNodalForce::MyFE | |
| ►CMoFEM::VolumeElementForcesAndSourcesCore | Volume finite element base |
| ►CMoFEM::PostProcBrokenMeshInMoabBase< VolumeElementForcesAndSourcesCore > | |
| CMoFEM::PostProcBrokenMeshInMoab< VolumeElementForcesAndSourcesCore > | |
| ►CPostProcTemplateOnRefineMesh< MoFEM::VolumeElementForcesAndSourcesCore > | |
| ►CPostProcTemplateVolumeOnRefinedMesh< MoFEM::VolumeElementForcesAndSourcesCore > | |
| CPostProcVolumeOnRefinedMesh | Post processing |
| CBodyForceConstantField::MyVolumeFE | |
| CBoneRemodeling::DensityMapFe | |
| CBoneRemodeling::Remodeling::Fe | Volume finite element |
| CConvectiveMassElement::MyVolumeFE | Definition of volume element |
| CKelvinVoigtDamper::DamperFE | Definition of volume element |
| CMagneticElement::VolumeFE | Definition of volume element |
| CMixTransport::MixTransportElement::MyVolumeFE | Definition of volume element |
| ►CMoFEM::FatPrismElementForcesAndSourcesCore | FatPrism finite element |
| ►CPostProcTemplateOnRefineMesh< MoFEM::FatPrismElementForcesAndSourcesCore > | |
| CPostProcFatPrismOnRefinedMesh | Postprocess on prism |
| CPrismFE | |
| CPrismFE | |
| CPrismFE | |
| ►CMoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSide | Base volume element used to integrate on contact surface (could be extended to other volume elements) mofem_forces_and_sources_volume_element |
| CMoFEM::VolumeElementForcesAndSourcesCoreOnContactPrismSideSwitch< SWITCH > | |
| ►CMoFEM::VolumeElementForcesAndSourcesCoreOnSide | Base volume element used to integrate on skeleton |
| CMoFEM::VolumeElementForcesAndSourcesCoreOnSideSwitch< SWITCH > | |
| CMoFEM::VolumeElementForcesAndSourcesCoreSwitch< SWITCH > | |
| ►CNonlinearElasticElement::MyVolumeFE | Definition of volume element |
| CSmoother::MyVolumeFE | |
| CSmoother::MyVolumeFE | |
| CThermalElement::MyVolumeFE | Definition of volume element |
| CThermalStressElement::MyVolumeFE | |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitor | [Push operators to pipeline] |
| CMonitorIncompressible | |
| CMonitorPostProc | |
| CMonitorPostProc | |
| CMonitorRestart | |
| CPhotonDiffusion::Monitor | |
| CReactionDiffusionEquation::Monitor | Monitor solution |
| ►CMoFEM::SnesMethod | Data structure for snes (nonlinear solver) context |
| CMoFEM::BasicMethod | Data structure to exchange data between mofem and User Loop Methods |
| ►CMoFEM::TSMethod | Data structure for TS (time stepping) context |
| CMoFEM::BasicMethod | Data structure to exchange data between mofem and User Loop Methods |
| ►CMoFEM::TaoMethod | |
| CMoFEM::BasicMethod | Data structure to exchange data between mofem and User Loop Methods |
| CMoFEM::PipelineManager | PipelineManager interface |
| CMoFEM::PrismInterface | Create interface from given surface and insert flat prisms in-between |
| CMoFEM::PrismsFromSurfaceInterface | Merge node from two bit levels |
| CMoFEM::ProblemsManager | Problem manager is used to build and partition problems |
| CMoFEM::SeriesRecorder | |
| CMoFEM::Simple | Simple interface for fast problem set-up |
| CMoFEM::TetGenInterface | TetGen interface |
| CMoFEM::Tools | Auxiliary tools |
| CMoFEM::VecManager | Vector manager is used to create vectors \mofem_vectors |
| ►CEdgeElementForcesAndSourcesCore::UserDataOperator | |
| CMinimalSurfaceEquation::MinimalSurfaceElement::OpAssmebleBcLhs | Integrate vector on lhs, |
| CMinimalSurfaceEquation::MinimalSurfaceElement::OpAssmebleBcRhs | Integrate vector on rhs, |
| ►CELEMENT::UserDataOperator | |
| COpPostProcHookeElement< ELEMENT > | |
| ►CFaceElementForcesAndSourcesCore::UserDataOperator | |
| ►CPoissonExample::OpBaseRhs< FaceElementForcesAndSourcesCore::UserDataOperator > | |
| ►CPoissonExample::Op_g | Assemble constrains vector |
| CPoissonExample::OpResF_Boundary | |
| CPoissonExample::OpRes_g | |
| CEshelbianPlasticity::FaceUserDataOperatorStabAssembly | |
| CEshelbianPlasticity::OpFaceMaterialForce | |
| CEshelbianPlasticity::OpMoveNode | |
| CEshelbianPlasticity::OpTreeSearch | |
| CFieldApproximationH1::OpApproxFace< FUNEVAL > | Gauss point operators to calculate matrices and vectors |
| CMinimalSurfaceEquation::MinimalSurfaceElement::OpAssembleResidaul | Assemble residual |
| CMinimalSurfaceEquation::MinimalSurfaceElement::OpAssembleTangent | Assemble tangent matrix |
| CMinimalSurfaceEquation::MinimalSurfaceElement::OpCalculateCoefficientsAtGaussPts | Evaluate function values and gradients at Gauss Pts |
| CMinimalSurfaceEquation::MinimalSurfaceElement::OpGetDataAtGaussPts | Evaluate function values and gradients at Gauss Pts |
| COpFace | |
| COpFace | |
| COpFaceMaterialForce | |
| COpFaceSide | |
| COpFacesFluxes | |
| COpFacesRot | |
| COpS | |
| CPoissonExample::OpC | Calculate constrains matrix |
| CPostProcFaceOnRefinedMesh::OpGetFieldValuesOnSkinImpl< RANK > | |
| ►CFlatPrismElementForcesAndSourcesCore::UserDataOperator | |
| CCohesiveElement::CohesiveInterfaceElement::OpCalculateGapGlobal | Operator calculate gap, normal vector and rotation matrix |
| CCohesiveElement::CohesiveInterfaceElement::OpCalculateGapLocal | Operator calculate gap in local coordinate system |
| CCohesiveElement::CohesiveInterfaceElement::OpHistory | Operator update history variables |
| CCohesiveElement::CohesiveInterfaceElement::OpLhs | Operator calculate element stiffens matrix |
| CCohesiveElement::CohesiveInterfaceElement::OpRhs | Operator calculate right hand side vector |
| CCohesiveElement::CohesiveInterfaceElement::OpSetSignToShapeFunctions | Set negative sign to shape functions on face 4 |
| ►CForcesAndSourcesCore::UserDataOperator | |
| ►CADOLCPlasticity::OpCalculateStressImpl< DIM, LARGE_STRAIN > | |
| CADOLCPlasticity::OpCalculateStress< DIM, LARGE_STRAIN > | |
| ►CADOLCPlasticity::OpCalculateStressImpl< DIM, SMALL_STRAIN > | |
| CADOLCPlasticity::OpCalculateStress< DIM, SMALL_STRAIN > | |
| ►CADOLCPlasticity::OpCalculateStressImpl< DIM, STRAIN > | |
| CADOLCPlasticity::OpCalculateStress< DIM, STRAIN > | |
| CADOLCPlasticity::OpTransferCommonData | |
| CADOLCPlasticity::OpUpdate | |
| CCallingOp | |
| CEshelbianPlasticity::OpCalculateEshelbyStress | |
| CFreeSurfaceOps::OpLoopSideGetDataForSideEle | |
| COpAdJointObjective | |
| COpCalculateDeformationGradient< DIM_0, DIM_1 > | |
| COpCalculateDisplacement< DIM > | |
| COpCalculateEshelbyStress | |
| COpCalculateFStab< DIM_0, DIM_1 > | |
| COpCalculateLameStress< DIM > | |
| COpCalculatePiola< DIM_0, DIM_1 > | |
| COpCalculatePiolaIncompressibleNH< DIM_0, DIM_1 > | |
| COpElectricField | |
| COpPostProcMap< DIM1, DIM2 > | Post post-proc data at points from hash maps |
| COpRow | |
| COpRowCol | |
| ►COP::UserDataOperator | |
| CThermalElement::OpGetFieldAtGaussPts< OP > | Operator to calculate temperature and rate of temperature at Gauss points |
| ►CUserDataOperator | |
| CEshelbianPlasticity::OpGetInternalStress< INTERP_ORDER > | |
| ►CEshelbianPlasticity::OpJacobian | |
| CEshelbianPlasticity::HMHHencky::OpHenckyJacobian | |
| CEshelbianPlasticity::HMHNeohookean::OpJacobian | |
| CEshelbianPlasticity::OpHMHH | |
| COpGetInternalStress< INTERP_ORDER > | |
| COpJacobian | |
| ►CVOLUME_ELEMENT::UserDataOperator | |
| CPostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT >::OpHdivFunctions | |
| ►CVolumeElementForcesAndSourcesCore::UserDataOperator | |
| ►CPoissonExample::OpBaseRhs< VolumeElementForcesAndSourcesCore::UserDataOperator > | |
| CPoissonExample::OpError | Evaluate error |
| ►CPoissonExample::OpF | Operator calculate source term, |
| CPoissonExample::OpResF_Domain | |
| CConvectiveMassElement::OpEnergy | |
| CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumJacobian | |
| CConvectiveMassElement::OpEshelbyDynamicMaterialMomentumRhs | |
| ►CConvectiveMassElement::OpGetDataAtGaussPts | |
| CConvectiveMassElement::OpGetCommonDataAtGaussPts | |
| CConvectiveMassElement::OpMassJacobian | |
| CConvectiveMassElement::OpMassLhs_dM_dv | |
| CConvectiveMassElement::OpMassRhs | |
| CConvectiveMassElement::OpVelocityJacobian | |
| CConvectiveMassElement::OpVelocityRhs | |
| CEshelbianPlasticity::VolUserDataOperatorStabAssembly | |
| COpAssembleG | Assemble G * |
| COpAssembleK | Assemble K * |
| COpAssembleP | Assemble P * |
| COpCalculateMassMatrix | Assemble mass matrix for elastic element TODO: CHANGE FORMULA * |
| COpK | |
| COpVolCurl | |
| COpVolDivergence | |
| COpVolume | |
| COpVolume | |
| ►CPoissonExample::OpK | Calculate the grad-grad operator and assemble matrix |
| CPoissonExample::OpKt | |
| ►CVolumeElementForcesAndSourcesCoreOnSide::UserDataOperator | |
| CEshelbianPlasticity::OpFaceSideMaterialForce | |
| CEshelbianPlasticity::OpPostProcDataStructure | |
| CMixTransport::MixTransportElement::OpSkeleton::OpVolSide | Calculate values on adjacent tetrahedra to face |
| COpFaceSideMaterialForce | |
| COpPostProcDataStructure | |
| COpVolumeSide | |
| CMoFEM::Version | |
| CEshelbianPlasticity::VolRule | Set integration rule on element |
| CMixTransport::UnsaturatedFlowElement::VolRule | Set integration rule to volume elements |
| CNavierStokesElement::VolRule | Set integration rule to volume elements |
| CPoissonExample::VolRule | Set integration rule to volume elements |
| CVolRule | Set integration rule to volume elements |
| CVolRuleNonlinear | |
| ►CVOLUME_ELEMENT | |
| ►CPostProcTemplateOnRefineMesh< VOLUME_ELEMENT > | |
| CPostProcTemplateVolumeOnRefinedMesh< VOLUME_ELEMENT > | |
| ►CHookeElement::VolUserDataOperator | |
| COpGetDensityField< ALE > | |
| ►CVolUserDataOperator | |
| CEshelbianPlasticity::HMHHencky::OpCalculateEnergy | Calculate energy density for Hencky material model |
| CEshelbianPlasticity::HMHHencky::OpCalculateStretchFromStress | |
| CEshelbianPlasticity::HMHNeohookean::OpGetScale | |
| CEshelbianPlasticity::OpCalculateRotationAndSpatialGradient | |
| CVtkInterface | |
| CWaveEquation | |
| Csdf_wavy_2d.WavySurface | |
| CMoFEM::WrapMPIComm | Wrap MPI communicator such that is destroyed when is out of scope |
| ►CLevelSet::WrapperClass | Wrapper executing stages while mesh refinement |
| CLevelSet::WrapperClassErrorProjection | Use peculated errors on all levels while mesh projection |
| CLevelSet::WrapperClassInitalSolution | Used to execute inital mesh approximation while mesh refinement |
| Csdf.yPlane | |
| Csdf_hertz_2d_axisymm_plane.yPlane | |
| Csdf_hertz_2d_plane.yPlane | |
| Csdf_plane_2d.yPlane | |
| Csdf_ydirection.yPlane | |
| Csdf_flat.zPlane | |
| Csdf_plane_3d.zPlane | |
| Cadouble | |
| CB | |
| Cbool | |
| Cconst EntityHandle | |
| Cd2MCoefficients< E, C > | |
| Cdouble | |
| CEntityHandle | |
| Cmatrix< adouble > | |
| Cmatrix< double > | |
| CMatrixBoundedArray< adouble, 9 > | |
| CMatrixBoundedArray< double, 9 > | |
| CRange | |
| Cshared_ptr< EntFiniteElement > | |
| Cshared_ptr< Field > | |
| Cshared_ptr< FieldEntity > | |
| Cshared_ptr< FiniteElement > | |
| Cshared_ptr< RefElement > | |
| Cshared_ptr< REFENT > | |
| Cshared_ptr< RefEntity > | |
| Cshared_ptr< ublas::vector< double, DoubleAllocator > > | |
| Csymmetric_matrix< adouble, ublas::upper > | |
| Csymmetric_matrix< double, ublas::upper > | |
| ►CT | |
| CEshelbianPlasticity::OpAssembleBasic< T > | |
| COpAssembleBasic< T > | |
| CTag | |
| CUBlasMatrix< double > | |
| CUBlasVector< double > | |
| Cvector< double > | |
| CVT2 | |
