Loading [MathJax]/extensions/tex2jax.js
KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 1234567891011]
 Cempire_wrapper.EmpireWrapper.__EmpireWrapper
 CMappingApplication._DeprecatedMapper
 CMappingApplication._DeprecatedMapperFactory
 ►Cabc.ABC
 CKratos::AbsMaxReduction< TDataType, TReturnType >
 CKratos::AbsMinReduction< TDataType, TReturnType >
 CKratos::AccelerationLimitationUtilities
 ►CKratos::AccessorThis class defines the way a certain property is accessed
 CKratos::AccessorInterpolativeMapperBase< TMapperBackend >Definition of an accessor auxiliary class
 CKratos::AccumReduction< TDataType, TReturnType >
 CKratos::ActivationUtilitiesTool to evaluate the normals on nodes based on the normals of a set of surface conditions
 CKratos::AddFixedPressureCondition2D
 CKratos::AddFixedPressureCondition3D
 CKratos::AddFixedVelocityCondition2D
 CKratos::AddFixedVelocityCondition3D
 CKratos::BinaryOperations::Addition
 CKratos::Testing::Internals::AddThisTestToTestSuite
 CKratos::AddWaterFixedVelocityCondition2D
 CKratos::AdjointExtensionsInterface extensions for adjoint elements and conditions
 ►CKratos::AdjointResponseFunctionA base class for adjoint response functions
 CKratos::AdvancedConstitutiveLawUtilities< TVoigtSize >This class includes several utilities necessaries for the computation of the constitutive law
 ►CKratos::AffineTransformClass for applying affine transformations
 CKratos::AitkenRelaxationFEMDEMUtilityAitken relaxation technique for FSI PFEM-FEM-DEM coupling
 Cdem_fem_coupling_algorithm.Algorithm
 CKratos::FluxLimiter< TLocalVectorType >::AllowableIncrements
 CKratos::AmgclCSRConversionUtilities
 CKratos::AmgclCSRSpMMUtilities
 CKratos::AmgclDistributedCSRConversionUtilities
 ►CKratos.analysis_stage.AnalysisStage
 CKratos::AnalyticFaceWatcher
 CKratos::AnalyticModelPartFiller
 CKratos::AnalyticParticleWatcher
 ►CKratos::AnalyticWatcher
 ►Canalyzers.analyzer_base.AnalyzerBaseClass
 CKratos::ApplyFunctionToNodesUtilityThis function applies a givn function to its nodes calling GenericFunctionUtility
 ►CApplyMultipointConstraintsProcess
 CKratos::ApplyProxy< TPointerDataType, TValueDataType, TApplyFunctor >Proxy class to update local and non-local data
 CKratos::Python::Array1DModifier< TContainerType >
 CKratos::PetrovGalerkinROMBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::AssemblyTLS
 CKratos::ROMBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::AssemblyTLS
 CKratos::AssignMasterSlaveConstraintsToNeighboursUtilityAssing Master-Slave Constraints to Neighbouring Nodes
 CKratos::AssignPointNeumannConditions
 CKratos::AssignScalarInputToEntitiesProcessSettingsThis struct is used in order to identify when using the hitorical and non historical variables
 ►Casvtep.AssignScalarVariableToEntitiesProcess
 CKratos::AssignUniqueModelPartCollectionTagUtilityGet the collection of submodelparts each node, condition and element belongs to
 ►CBaseProcess.AssignVectorComponentsToNodesProcess
 CKratos::AutomaticDifferentiationTangentUtilities< TYieldSurfaceType, TSofteningType >
 Ccheck_scalar_base_process.aux_object_cpp_callback
 Ccheck_scalar_on_nodes_process.aux_object_cpp_callback
 CKratos::NonAssociativeExplicitPlasticFlowRule::AuxiliarDerivativesStructure
 CKratos::AuxiliarHessianComputationVariablesThis is an auxiliar struct to store remeshing variables
 CKratos::AuxiliarModelPartUtilitiesThis utility includes auxiliar methods not included in the model part to avoid increase more than necessary the API
 ►CKratos::AuxiliarVariableVectorRetrieverThis struct is an auxiliar base class of the VariableVectorRetriever
 CKratos::AuxiliaryMatrixWrapperAuxiliarty Trilinos matrix pointer wrapper class
 CKratos::AuxiliaryUtilities
 CKratos::AuxiliaryVectorWrapperAuxiliarty Trilinos vector pointer wrapper class
 CPID.average_field.Averager
 Cswimming_DEM_procedures.Averager
 CKratos::Base64EncodedOutputEncodes given iterator data to base 64 string representation
 ►CBaseAnalysis
 ►CBaseClass
 ►Ccoupling_interface_data.BaseCouplingInterfaceDataThis class serves as interface to the data structure (Model and ModelPart) that holds the data used during CoSimulation
 ►CBaseExplicitStrategy
 ►CBaseIO
 CKratos::ContactDomainUtilities::BaseLengths
 ►CBaseLoader
 ►CBaseSolver
 ►CBaseStrategy
 ►CKratos::BasicGenericFunctionUtilityThis function allows to call a function method of type f(x, y, z, t) implemented in python style
 CKratos::BassetForceTools
 Cutils.io.bcolors
 ►CKratos::TimeDiscretization::BDF
 CKratos::BeamMathUtils< TDataType >
 CDEM_benchmarks_class.Benchmark1
 CChung_Ooi_class.Benchmark10
 CDEM_benchmarks_class.Benchmark10LINEAR THORNTON
 CDEM_benchmarks_class.Benchmark11HERTZIAN THORNTON
 CDEM_benchmarks_class.Benchmark12ROLLING FRICTION
 CDEM_benchmarks_class.Benchmark13DEM-FEM Facet
 CDEM_benchmarks_class.Benchmark14DEM-FEM Edge
 CDEM_benchmarks_class.Benchmark15DEM-FEM Vertex
 CDEM_benchmarks_class.Benchmark16DEM-FEM Grid
 CDEM_benchmarks_class.Benchmark17DEM-FEM Rolling
 CDEM_benchmarks_class.Benchmark2
 CDEM_benchmarks_class.Benchmark20
 CDEM_benchmarks_class.Benchmark21
 CDEM_benchmarks_class.Benchmark22
 CDEM_benchmarks_class.Benchmark23
 CDEM_benchmarks_class.Benchmark24
 CDEM_benchmarks_class.Benchmark25
 CDEM_benchmarks_class.Benchmark26
 CDEM_benchmarks_class.Benchmark27
 CDEM_benchmarks_class.Benchmark28
 CDEM_benchmarks_class.Benchmark3
 CDEM_benchmarks_class.Benchmark30Cylinder with imposed angular velocity (Velocity Verlet + Zhao)
 CDEM_benchmarks_class.Benchmark31Cylinder with imposed angular velocity (Symplectic Euler + Runge-Kutta)
 CDEM_benchmarks_class.Benchmark32Fiber cluster bouncing without any damping (Velocity Verlet + Zhao scheme)
 CDEM_benchmarks_class.Benchmark33Fiber cluster bouncing without any damping (Velocity Verlet + Runge-Kutta scheme)
 CDEM_benchmarks_class.Benchmark4
 CDEM_benchmarks_class.Benchmark40
 CChung_Ooi_class.Benchmark5
 CDEM_benchmarks_class.Benchmark5
 CChung_Ooi_class.Benchmark6
 CDEM_benchmarks_class.Benchmark6
 CChung_Ooi_class.Benchmark7
 CDEM_benchmarks_class.Benchmark7
 CChung_Ooi_class.Benchmark8
 CDEM_benchmarks_class.Benchmark8
 CChung_Ooi_class.Benchmark9
 CDEM_benchmarks_class.Benchmark9
 CKratos::BFECCConvection< TDim >
 CKratos::BFECCLimiterConvection< TDim >
 CKratos::FracturePropagation2DUtilities::Bifurcation
 CKratos::FracturePropagation3DUtilities::Bifurcation
 CKratos::BinBasedDEMFluidCoupledMapping< TDim, TBaseTypeOfSwimmingParticle >
 CKratos::BinBasedFastPointLocator< TDim, TConfigureType >This class is designed to allow the fast location of MANY points on the top of a 3D mesh
 CKratos::BinBasedFastPointLocator< 2 >
 ►CKratos::BinBasedFastPointLocator< TDim, SpatialContainersConfigure< TDim, Condition > >
 CKratos::BinBasedMeshTransfer< TDim >This class allows the interpolation between non-matching meshes in 2D and 3D
 CKratos::BinBasedNodesInElementLocator< TDim >REMARK: the location function is threadsafe, and can be used in OpenMP loops
 ►CKratos::BinsObjectDynamic< TConfigure >Short class definition
 CKratos::BinsObjectDynamic< Kratos::SpatialContainersConfigure >
 CKratos::BinsObjectStatic< TConfigure >Short class definition
 CKratos::BlockPartition< TIterator, MaxThreads >
 CKratos::BodyDistanceCalculationUtils
 CKratos::BodyNormalCalculationUtils
 ►CBondCL
 CKratos::TimeDiscretization::Bossak
 CKratos::ResidualBasedBossakDisplacementScheme< TSparseSpace, TDenseSpace >::BossakAlphaMethodBossak Alpha parameters
 CKratos::ResidualBasedAdjointBossakScheme< TSparseSpace, TDenseSpace >::BossakConstants
 Cnice_names::boundary
 CKratos::ApplyCompressibleNavierStokesBoundaryConditionsProcess::BoundaryConditionUtilityThis class validates and manages a variable to fix and the value to fix it to
 CKratos::BoundaryNormalsCalculationUtilities
 CKratos::MeshDataTransferUtilities::BoundaryVariableArrays
 CKratos::MeshDataTransferUtilities::BoundaryVariables
 CKratos::BoundingBox< TPointType >Representing a bounding box by storing the min and max points
 CKratos::BoundingBox< Kratos::Point >
 CKratos::BoundingBox< PointType >
 CKratos::SpatialBoundingBox::BoundingBoxParameters
 CKratos::SpatialBoundingBox::BoundingBoxVariables
 ►CKratos::BoundingVolumePartitioner
 CKratos::BoundingVolumeTree
 CKratos::CompoundNosesBoundingBox::BoxNoseVariables
 CKratos::BrentIteration
 CKratos::BrepTrimmingUtilities
 CKratos::BruteForcePointLocatorUtility class to find an entity of a mesh based on a location
 CKratos::MPIInternals::BufferAllocation< TDatabaseAccess, IsFixedSize >
 CKratos::MPIInternals::BufferAllocation< TDatabaseAccess, false >
 CKratos::MPIInternals::BufferAllocation< TDatabaseAccess, true >
 Cbuffered_dict.BufferedDictBuffered dict container with buffered data ability
 ►CKratos::BuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >Current class provides an implementation for the base builder and solving operations
 CKratos::BuilderAndSolverFactory< TSparseSpace, TDenseSpace, TLinearSolver >
 CKratos::BuiltinTimer
 CKratos::ButcherTableau< Derived, TOrder, TSubstepCount >Butcher tableau for Runge-Kutta method
 ►CKratos::ButcherTableau< ButcherTableauForwardEuler, 1, 1 >
 ►CKratos::ButcherTableau< ButcherTableauMidPointMethod, 2, 2 >
 ►CKratos::ButcherTableau< ButcherTableauRK3TVD, 3, 3 >
 ►CKratos::ButcherTableau< ButcherTableauRK4, 4, 4 >
 CKratos::Base64EncodedOutput::ByteIterator< TIteratorType >A forward iterator that iterates over bytes in a sequence
 CKratos::CadJsonOutput
 CKratos::CalculateDiscontinuousDistanceToSkinProcessFlags
 CKratos::CalculateDistanceToPathSettingsThis struct is used in order to identify when using the hitorical and non historical variables
 CKratos::CalculateNodalAreaSettingsThis struct is used in order to identify when using the hitorical and non historical variables
 Csensitivity_builder_cpp::CalculateNodalSolutionStepSensitivityFunctor< TDataType >
 Csensitivity_builder_cpp::CalculateNonHistoricalSensitivitiesFunctor< TDataType >
 CKratos::CalculateWaterFraction< TDim >
 CKratos::CalculateWaveHeightUtilityThis function computes the wave height at a given point
 CKratos::CalculationContainerTraits< TCombinedElementDataContainer, TCombinedCalculationContainers >This is traits clas sto hold combined data containers and calculation containers
 CKratos::DamageDPlusDMinusMasonry2DLaw::CalculationData
 CKratos::KratosExecute::CallBackFunctions
 CKratos::CArrayExpressionIO
 CKratos::SolidShellElementSprism3D6N::CartesianDerivativesHere the cartesian derivatives are defined
 Ccase_runner.CaseRunner
 CKratos::Cell< TConfigure >
 CKratos::DistanceSpatialContainersConditionConfigure::CellNodeData
 CKratos::DistanceSpatialContainersConfigure::CellNodeData
 CKratos::Internals::DistanceSpatialContainersConfigure::CellNodeDataThis class contains the cell node data
 CKratos::CellularFlowPartialDerivatives
 ►Cpfem_check_and_prepare_model_process_fluid.CheckAndPrepareModelProcess
 CKratos::ChimeraDistanceCalculationUtility< TDim >Utility for calculating the Distance on a given modelpart
 CKratos::ChimeraHoleCuttingUtilityShort class definition
 CKratos::ChunkChunk is the smallest building block of Kratos memory management
 CKratos::ClosestPointsContainer
 CKratos::ClusterInformation
 CKratos::CodeLocation
 CDerivatives.Codina2007
 CDerivatives.CodinaVelocityField
 Ckratos_collada.ColladaImporter
 CKratos::CollectiveExpressionConstruct a new CollectiveExpression instance
 CKratos::CollectiveExpressionIO
 CKratos::CombinedReduction< Reducer >
 Ctesting.utilities.Commander
 CKratos::SolidShellElementSprism3D6N::CommonComponentsCommon Components defined in order to compute the Cauchy tensor and the deformation matrix
 Ccommunicator_factory.Communicator
 ►CKratos::CommunicatorThe Commmunicator class manages communication for distributed ModelPart instances
 CKratos::CompareElementsAndConditionsUtility
 Cmodels_solver.compiled_space_time_function
 Cassign_modulus_and_direction_to_conditions_process.compiled_time_spatial_function
 Cassign_scalar_to_nodes_process.compiled_time_spatial_function
 Ccomponent_data_view.ComponentDataViewA viewer to view component's data in optimization problem
 Csymbolic_generation.compressible_navier_stokes.src.defines.CompressibleNavierStokesDefines
 Csymbolic_generation.compressible_navier_stokes.compressible_navier_stokes_symbolic_generator.CompressibleNavierStokesSymbolicGeneratorThis class is in charge of generating a element to solve the compressible Navier-Stokes using the conservative magnitudes (density, momentum, energy) as solution
 CKratos::ComputeDEMFaceLoadUtility
 CKratos::ComputeNeighbourListFunctor< TContainerType, TVariableType >Short class definition
 CKratos::ComputeNodalDivergenceProcessSettingsThis struct is used in order to identify when using the hitorical and non historical variables
 CKratos::ComputeNodalGradientProcessSettingsThis struct is used in order to identify when using the hitorical and non historical variables
 CKratos::ComputeWingSectionVariableProcessSettings
 CKratos::WaveCondition< TNumNodes >::ConditionData
 CKratos::EmbeddedAusasNavierStokesWallCondition< TDim, TNumNodes >::ConditionDataStruct
 CKratos::NavierStokesWallCondition< TDim, TNumNodes, TWallModel >::ConditionDataStruct
 CKratos::ThermalFace::ConditionDataStructGauss pt. data structure Auxiliar data structure to pass the Gauss pt. data
 CKratos::ConditionNumberUtilityUtility to compute the condition number
 CKratos::ConditionUtilities
 CKratos::BeamPointRigidContactCondition::ConditionVariables
 CKratos::BoundaryCondition::ConditionVariables
 CKratos::ContactDomainCondition::ConditionVariables
 CKratos::GeneralUPwDiffOrderCondition::ConditionVariables
 CKratos::PointRigidContactCondition::ConditionVariables
 CKratos::UPCondition< TDim, TNumNodes >::ConditionVariables
 CConformant_OneSideMap.Conformant_OneSideMap
 CKratos::HDF5::Internals::ConnectivitiesDataRepresents connectivities information of a single element or condition type in a mesh
 CKratos::SparseContiguousRowGraph< TIndexType >::const_iterator_adaptor
 CKratos::SparseGraph< TIndexType >::const_iterator_adaptor
 CKratos::HelmholtzSolidDataContainer< TDim, TNumNodes, TDataDimension >::ConstantDataContainer
 CKratos::HelmholtzSolidShapeDataContainer< TDim, TNumNodes >::ConstantDataContainer
 CKratos::HelmholtzSurfaceDataContainer< TDim, TNumNodes, TDataDimension >::ConstantDataContainer
 CKratos::ConstitutiveModelData::ConstitutiveLawData
 CKratos::ConstitutiveLawUtilities< TVoigtSize >This class includes several utilities necessaries for the computation of the constitutive law
 Cconstitutive_law_python_utility.ConstitutiveLawUtility
 CKratos::BilinearCohesive3DLaw::ConstitutiveLawVariables
 CKratos::ElasticCohesive3DLaw::ConstitutiveLawVariables
 CKratos::ElastoPlasticModMohrCoulombCohesive3DLaw::ConstitutiveLawVariables
 CKratos::ElastoPlasticMohrCoulombCohesive3DLaw::ConstitutiveLawVariables
 CKratos::IsotropicDamageCohesive3DLaw::ConstitutiveLawVariables
 ►CKratos::ConstitutiveModelShort class definition
 CKratos::ConstitutiveModelDataShort class definition
 CKratos::ConstitutiveModelUtilitiesShort class definition
 CKratos::BaseSolidElement::ConstitutiveVariables
 CKratos::CouplingNitscheCondition::ConstitutiveVariables
 CKratos::EPPointRigidContactPenalty3DCondition::ConstitutiveVariables
 CKratos::IgaMembraneElement::ConstitutiveVariables
 CKratos::Shell3pElement::ConstitutiveVariables
 CKratos::Shell5pElement::ConstitutiveVariables
 CKratos::SmallDisplacementMixedVolumetricStrainElement::ConstitutiveVariables
 CKratos::SupportNitscheCondition::ConstitutiveVariables
 CKratos::TotalLagrangianMixedVolumetricStrainElement< TDim >::ConstitutiveVariables
 CKratos::ConstructionUtility
 ►Copt_line_search.ConstStep
 Ccontact_convergence_criteria_factory.ContactConvergenceCriteriaFactory
 CKratos::ContactDomainUtilitiesShort class definition
 CKratos::ContactDomainCondition::ContactParameters
 CKratos::ThermalSphericParticle::ContactParams
 CKratos::ContactDomainCondition::ContactSurfaceParameters
 CKratos::ContactDomainCondition::ContactTangentParameters
 CKratos::ContactDomainCondition::ContactTangentVariables
 CKratos::ContactUtilitiesThis class includes some utilities used for contact computations
 CKratos::ContactDomain2DMesher::ContactVariables
 CKratos::ContactDomain3DMesher::ContactVariables
 CKratos::ContactDomainCondition::ContactVariables
 CKratos::ThermalContactDomainCondition::ContactVariables
 ►Ccontainer_const_reference
 ►Ccontainer_reference
 CKratos::HDF5::ContainerComponentIO< TContainerType, TContainerItemType, TComponents >A class for IO of element data in HDF5
 ►CKratos::HDF5::ContainerComponentIO< ConditionsContainerType, ConditionType, Flags >
 ►CKratos::HDF5::ContainerComponentIO< ConditionsContainerType, ConditionType, Variable< array_1d< double, 3 > >, Variable< double >, Variable< int >, Variable< Vector< double > >, Variable< Matrix< double > > >
 ►CKratos::HDF5::ContainerComponentIO< Detail::VertexContainerType, Detail::Vertex, Variable< array_1d< double, 3 > >, Variable< double >, Variable< int >, Variable< Vector< double > >, Variable< Matrix< double > > >
 ►CKratos::HDF5::ContainerComponentIO< ElementsContainerType, ElementType, Flags >
 ►CKratos::HDF5::ContainerComponentIO< ElementsContainerType, ElementType, Variable< array_1d< double, 3 > >, Variable< double >, Variable< int >, Variable< Vector< double > >, Variable< Matrix< double > > >
 ►CKratos::HDF5::ContainerComponentIO< NodesContainerType, NodeType, Flags >
 ►CKratos::HDF5::ContainerComponentIO< NodesContainerType, NodeType, Variable< array_1d< double, 3 > >, Variable< double >, Variable< int >, Variable< Vector< double > >, Variable< Matrix< double > > >
 CKratos::ContainerDataIO< TContainerDataIOTags >
 CKratos::ContainerDataIO< ContainerDataIOTags::Historical >
 CKratos::ContainerDataIO< ContainerDataIOTags::NonHistorical >
 CKratos::ContainerDataIO< ContainerDataIOTags::Properties >
 CKratos::ModelPartHelperUtils::ContainerEntityMapReduction< TEntityType, TMapValueType >
 CKratos::ContainerExpression< TContainerType, TMeshType >Container variable data holder
 CKratos::ContainerExpressionUtils
 CKratos::HDF5::ContainerGaussPointOutput< TContainerType, TComponents >A class for IO of element data in HDF5
 ►CKratos::HDF5::ContainerGaussPointOutput< ConditionsContainerType, Variable< array_1d< double, 3 > >, Variable< double >, Variable< int >, Variable< Vector< double > >, Variable< Matrix< double > > >
 ►CKratos::HDF5::ContainerGaussPointOutput< ElementsContainerType, Variable< array_1d< double, 3 > >, Variable< double >, Variable< int >, Variable< Vector< double > >, Variable< Matrix< double > > >
 CKratos::Python::ContainerInterface< TContainerType >
 CKratos::ContainerProxy< TEntityProxy >A view with a uniform interface for ModelPart::NodesContainerType, ModelPart::ElementsContainerType, or ModelPart::ConditionsContainerType
 CKratos::SpatialMethods::ContainerSpatialMethods< TContainerType, TContainerItemType, TDataRetrievalFunctor >
 ►CKratos::SpatialMethods::ContainerSpatialMethods< ConditionsContainerType, ConditionType, MethodUtilities::NonHistoricalDataValueRetrievalFunctor >
 ►CKratos::SpatialMethods::ContainerSpatialMethods< ElementsContainerType, ElementType, MethodUtilities::NonHistoricalDataValueRetrievalFunctor >
 ►CKratos::SpatialMethods::ContainerSpatialMethods< NodesContainerType, NodeType, MethodUtilities::HistoricalDataValueRetrievalFunctor >
 ►CKratos::SpatialMethods::ContainerSpatialMethods< NodesContainerType, NodeType, MethodUtilities::NonHistoricalDataValueRetrievalFunctor >
 ►CKratos::TemporalMethods::ContainerTemporalMethods< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 ►CKratos::TemporalMethods::ContainerTemporalMethods< ConditionsContainerType, ConditionType, MethodUtilities::NonHistoricalDataValueRetrievalFunctor, MethodUtilities::NonHistoricalDataValueRetrievalFunctor >
 ►CKratos::TemporalMethods::ContainerTemporalMethods< ElementsContainerType, ElementType, MethodUtilities::NonHistoricalDataValueRetrievalFunctor, MethodUtilities::NonHistoricalDataValueRetrievalFunctor >
 ►CKratos::TemporalMethods::ContainerTemporalMethods< NodesContainerType, NodeType, MethodUtilities::HistoricalDataValueRetrievalFunctor, TDataStorageFunctor >
 ►CKratos::TemporalMethods::ContainerTemporalMethods< NodesContainerType, NodeType, MethodUtilities::NonHistoricalDataValueRetrievalFunctor, MethodUtilities::NonHistoricalDataValueRetrievalFunctor >
 ►CKratos::ControllerThe base class for all Controllers in Kratos
 Ctopology_optimizer_factory.Controller
 CKratos::ControlModuleFemDem2DUtilities
 CKratos::ControlModuleFemDemUtilities
 Ccontrol_module_fem_dem_utility.ControlModuleFemDemUtility
 ►CKratos::ConvectionDiffusionReactionElementData< TDim >Base class to hold Convection-Diffusion-Reaction transport equation data
 CKratos::ConvectionDiffusionSettingsConvection diffusion settings. This class contains information to be used by the convection diffusion solver, all the variables that will be needed by the solver
 CProjectParameters.ConvectionSolverSettings
 Cconvergence_criteria_factory.convergence_criterion
 Cconvergence_criteria_factory_fem_dem.convergence_criterion
 Ctrilinos_convergence_criteria_factory.convergence_criterion
 ►CKratos::ConvergenceAccelerator< TSparseSpace, TDenseSpace >Base class for convergence accelerators This class is intended to be the base of any convergence accelerator in Kratos
 Cconvergence_accelerators.convergence_accelerator_wrapper.ConvergenceAcceleratorWrapperThis class wraps the convergence accelerators such that they can be used "automized" => this class stores the residual and updates the solutions, such that the convergence accelerator can be configured through json In case of distributed data, it is checked whether the convergence accelerator supports it
 ►CKratos::ConvergenceCriteria< TSparseSpace, TDenseSpace >This is the base class to define the different convergence criterion considered
 CKratos::ConvergenceCriteriaFactory< TSparseSpace, TDenseSpace >
 Cconvergence_criteria.convergence_criteria_wrapper.ConvergenceCriteriaWrapperThis class wraps the convergence criteria such that they can be used "automated"
 Cconvergence_criteria_factory.ConvergenceCriterion
 CKratos::ConversionUtilitiesShort class definition
 ►CKratos::CoordinateTransformationUtils< TLocalMatrixType, TLocalVectorType, TValueType >
 CKratos::CoordinateTransformationUtils< Kratos::Internals::Matrix, Kratos::Internals::Matrix, double >
 ►CKratos::CoordinateTransformationUtils< LocalSystemMatrixType, LocalSystemVectorType, double >
 ►CKratos::CoordinateTransformationUtils< TLocalMatrixType, TLocalVectorType, double >
 CKratos::SearchUtils::CopyRange< TIteratorType, TSizeType, TResultIteratorType >
 CKratos::CoSimIOConversionUtilitiesShort class definition
 Cbase_classes.co_simulation_convergence_accelerator.CoSimulationConvergenceAcceleratorBaseclass for the convergence acceleratos used for CoSimulation Relaxes the solution to increase the speed of convergence in a (strongly) coupled simulation
 Cbase_classes.co_simulation_convergence_criteria.CoSimulationConvergenceCriteriaBaseclass for the convergence criteria used for CoSimulation Checks if convergence was achieved in a (strongly) coupled simulation
 Cbase_classes.co_simulation_coupling_operation.CoSimulationCouplingOperationBaseclass for the coupling operations used for CoSimulation This class can be used to customize the behavior of the CoSimulation, by providing a large interface and access to the solvers/models
 Cbase_classes.co_simulation_io.CoSimulationIOBaseclass defining the interface for the input and output methods for the communication with external solvers
 Cbase_classes.co_simulation_predictor.CoSimulationPredictorBaseclass for the predictors used for CoSimulation It predicts the solution of the next step at the beginning of a step
 Cbase_classes.co_simulation_solver_wrapper.CoSimulationSolverWrapperBaseclass for the solver wrappers used for CoSimulation It wraps solvers used in the CoSimulation
 CKratos::Counter< TCountedType >Short class definition
 Cswimming_DEM_procedures.Counter
 ►CCovarianceKernels.CovarianceGeneric Covariance class
 CKratos::CreateQuadraturePointsUtility< TPointType >A Class for the creation of integration points
 CKratos::CriterionLocalFlagsSolver local flags class definition
 CKratos::KratosExecute::CriticalHeadInfo
 CKratos::AnalyticFaceWatcher::CrossingsTimeStepDataBase
 CKratos::CsrMatrix< TDataType, TIndexType >This class implements "serial" CSR matrix, including capabilities for FEM assembly
 CKratos::CsrMatrix< double, std::size_t >
 Ccellular_flow_derivative_recovery_errors.Curve
 CKratos::CurveAxisIntersection< TNodeType >
 CKratos::CurveTessellation< TContainerPointType >
 Cedge_cable_element_process.custom_node
 CKratos::CustomFunctionsCalculator< TDim >
 CKratos::CustomWorkflowFactory
 CKratos::ReorderAndOptimizeModelPartProcess::CuthillMcKee< reverse >
 CKratos::Cutting_Isosurface_ApplicationCUTTING ISOSURFACE APPLICATION
 CKratos::CuttingUtilityCUTTING UTILITY
 CKratos::DamageDPlusDMinusMasonry3DLaw::DamageParameters
 CKratos::GenericSmallStrainDplusDminusDamage< TConstLawIntegratorTensionType, TConstLawIntegratorCompressionType >::DamageParameters
 Cdam_construction_utility.DamConstructionUtility
 Cdam_eigen_solver.DamEigenSolver
 CKratos::DampingFunctionShort class definition
 CKratos::DampingUtilitiesShort class definition
 Cdam_P_solver.DamUPSolver
 CKratos::LiteralFlatExpression< TRawDataType >::DataThis class is used represent the flattened data array
 CKratos::Python::CoSimIO_Wrappers::DataBuffers
 ►CKratos::DataCommunicatorSerial (do-nothing) version of a wrapper class for MPI communication
 Cloggers.data_logger_factory.DataLogger
 CKratos::DataTypeTraits< TDataType >Generic data type traits class for arithmetic types
 CKratos::DataTypeTraits< array_1d< TDataType, TSize > >Data type traits for array_1d data types
 CKratos::DataTypeTraits< DenseMatrix< TDataType > >
 CKratos::DataTypeTraits< DenseVector< TDataType > >Data type traits for DenseVector data types
 CKratos::DataTypeTraits< std::string >
 CKratos::DataTypeTraits< std::vector< TDataType > >
 ►CKratos::DataValueContainerContainer for storing data values associated with variables
 CKratos::DeflationUtils
 CKratos::ExplicitCentralDifferencesScheme< TSparseSpace, TDenseSpace >::DeltaTimeParametersThis struct contains the information related with the increment od time step
 CKratos::ExplicitHamiltonScheme< TSparseSpace, TDenseSpace >::DeltaTimeParameters
 CKratos::ExplicitMultiStageKimScheme< TSparseSpace, TDenseSpace >::DeltaTimeParametersThis struct contains the information related with the increment od time step
 ►CKratos::DEM_Inlet
 CDEM_inlet_process.DEM_Inlet_Process
 ►CMainDEM.DEMAnalysisStage
 CKratos::DemContact
 ►CDEM_procedures.DEMEnergyCalculator
 ►CDEM_procedures.DEMFEMProcedures
 CKratos::DEMFEMUtilities
 CKratos::DEMFlags
 ►CKratos::DEMIntegrationScheme
 ►CDEM_procedures.DEMIo
 ►CKratos::DEMRollingFrictionModel
 CKratos::DemSearchUtilities
 CKratos::DemStructuresCouplingFlags
 CKratos::DemStructuresCouplingUtilities
 CKratos::DEMThermalFlags
 ►CKratos::DenseQRDecomposition< TDenseSpaceType >
 ►CKratos::DenseQRDecomposition< TDenseSpace >
 CKratos::DenseSingularValueDecomposition< TDenseSpaceType >
 ►CKratos::DenseSingularValueDecomposition< TDenseSpace >
 ►CKratos::DensityFunction< TDim >
 Cdeprecation_management.DeprecationManagerThis class is intended to encapsulate common operations that may be needed when dealing with deprecated input variable names
 ►CBaseProcess.DepthIntegrationOutputProcess
 CKratos::QSVMSDerivativeUtilities< TDim >::Derivative< TComponentIndex >Base class for Derivatives
 ►CKratos::QSVMSDerivativeUtilities< TDim >::Derivative< 0 >
 ►CKratos::QSVMSDerivativeUtilities< TDim >::Derivative< TComponentIndex >
 CKratos::DerivativeData< TDim, TNumNodes, TNumNodesMaster >This data will be used to compute the derivatives
 ►CKratos::DerivativeData< TDim, TNumNodes, TNumNodes >
 CKratos::DerivativeRecovery< TDim >This class constructs nodal approximations of the derivatives of a field given a Lagrangian linear FEM approximation of it
 CKratos::DerivativeRecoveryMeshingTools< TDim >This class performs simple meshing tools related to the derivative recovery algorithms
 Cderivative_recovery.derivative_recovery_strategy.DerivativeRecoveryStrategy
 ►Cderivative_recovery.recoverer.DerivativesRecoverer
 CKratos::DerivativesRecoveryUtility< TDim >Superconvergent patch recovery for linear meshes using quadratic polynomials
 CKratos::DerivativesUtilities< TDim, TNumNodes, TFrictional, TNormalVariation, TNumNodesMaster >This utilities are used in order to compute the directional derivatives during mortar contact
 Cloggers.design_logger_base.DesignLogger
 Ctensors::det
 Ctensors::dev
 CKratos::DeviatoricPlaneShapeUtilities
 CKratos::BrepTrimmingUtilities::Diagonal
 CKratos::MPIInternals::DirectCopyTransfer< ValueType >
 ►CKratos::MPIInternals::DirectCopyTransfer< array_1d< double, TDim > >
 ►CKratos::MPIInternals::DirectCopyTransfer< bool >
 ►CKratos::MPIInternals::DirectCopyTransfer< double >
 ►CKratos::MPIInternals::DirectCopyTransfer< int >
 ►CKratos::MPIInternals::DirectCopyTransfer< Kratos::Flags >
 CKratos::DirectionDampingUtilitiesClass for direction damping of the shape update
 CKratos::BeamElement::DirectorsVariables
 CKratos::DirectorUtilities
 CKratos::DiscontinuousShapeFunctionsUtilities
 CKratos::DiscontinuousShapeFunctionsUtilities_2DThis utility can be used to calculate the enriched shape function for tetrahedra element
 CKratos::DiscreteParticleConfigure< TDimension >
 CKratos::DistanceCalculator< T, dim >
 CKratos::DistanceCalculator1< T, dim >
 Cread_distance_from_file.DistanceImportUtilityDistance import utility class definition
 CKratos::DistanceSpatialContainersConditionConfigure
 CKratos::DistanceSpatialContainersConfigure
 CKratos::Internals::DistanceSpatialContainersConfigureThis class contains the tools related with the distance spatial container cell data
 CKratos::DistributedAmgclCSRSpMMUtilities
 CKratos::DistributedCsrMatrix< TDataType, TIndexType >This class implements "serial" CSR matrix, including capabilities for FEM assembly
 CKratos::LoggerMessage::DistributedFilter
 Cdistributed_import_model_part_utility.DistributedImportModelPartUtility
 CKratos::DistributedModelPartInitializerInitialize a distributed ModelPart from a serial one
 CKratos::DistributedNumbering< TIndexType >This function provides essential capabilities for mapping between local and global ids in a distributed vector
 CKratos::DistributedNumbering< IndexType >
 CKratos::DistributedNumbering< std::size_t >
 CKratos::DistributedSearchInformationThis struct provides information related with distributed search
 CKratos::DistributedSparseGraph< TIndexType >Short class definition
 CKratos::DistributedSystemVector< TDataType, TIndexType >Provides a DistributedSystemVector which implements FEM assemble capabilities
 CKratos::DistributedVectorExporter< TIndexType >Provides a DistributedVectorExporter which implements FEM assemble capabilities
 CKratos::DistributedVectorExporter< std::size_t >
 CKratos::DistributedVectorImporter< TDataType, TIndexType >Provides a DistributedVectorImporter which implements FEM assemble capabilities
 ►CKratos::DivideGeometry< TPointType >
 CKratos::BinaryOperations::Division
 CKratos::Dof< TDataType >Dof represents a degree of freedom (DoF)
 CKratos::BlockBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::dof_iterator_equal
 CKratos::ReductionBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::dof_iterator_equal
 CKratos::BlockBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::dof_iterator_hash
 CKratos::ReductionBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::dof_iterator_hash
 CKratos::MeshTyingMortarCondition< TDim, TNumNodes, TNumNodesMaster >::DofData
 CKratos::DofPointerComparorThis is a key comparer between two dof pointers
 CKratos::DofPointerHasherThis is a hasher for a dof pointers
 CKratos::DofTrait< TDataType, TVariableType >
 ►CKratos::DofUpdater< TSparseSpace >Utility class to update the values of degree of freedom (Dof) variables after solving the system
 CKratos::MortonDivideInputToPartitionsProcess::DomainEntitiesIdContainer
 Cprojection_utilities.DomainPanel2D
 Cprojection_utilities.DomainPanel3D
 CKratos::DomainSizeExpressionIOUtility class for domain size IO
 CKratos::BrepTrimmingUtilities::DPState
 CKratos::DragAndMomentUtilitiesAuxiliary utility to compute the drag force and the moment around a given point
 CKratos::DragUtilitiesAuxiliary utility to compute the drag force
 CKratos::DruckerPragerPlasticPotential< TVoigtSize >This class defines a plastic potential following the theory of Drucker-Prager
 CKratos::DruckerPragerYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Drucker-Prager theory
 CKratos::DualLagrangeMultiplierOperators< TNumNodes, TNumNodesMaster >This is the definition dual lagrange multiplier operators according to the work of Alexander Popp: https://www.lnm.mw.tum.de/staff/alexander-popp/
 ►CKratos::DualLagrangeMultiplierOperators< TNumNodes, TNumNodes >
 CKratos::MPIInternals::DynamicArrayTypeTransfer< ValueType >
 ►CKratos::MPIInternals::DynamicArrayTypeTransfer< Matrix >
 ►CKratos::MPIInternals::DynamicArrayTypeTransfer< Vector >
 Cdynamic_smagorinsky_utilities.DynamicSmagorinsky
 CKratos::DynamicSmagorinskyUtilsHelper class to dynamically determine a value for the Smagorinsly parameter
 CKratos::SolidShellElementSprism3D6N::EASComponentsEAS Components
 CKratos::ShellThickElement3D4N< TKinematics >::EASOperatorEASOperator
 CKratos::ShellThickElement3D4N< TKinematics >::EASOperatorStorageEASOperatorStorage
 CKratos::EdgeBasedDataStructure< TDim >
 CKratos::EdgeBasedLevelSet< TDim, MatrixContainer, TSparseSpace, TLinearSolver >
 CKratos::EdgebasedLevelsetAuxiliaryUtils< TDim >
 CKratos::EdgeBasedLevelSetSubstep< TDim, MatrixContainer, TSparseSpace, TLinearSolver >
 CKratos::EdgeBasedDataStructure< TDim >::EdgeData
 CKratos::EdgesStructureType< TDim >
 CKratos::EdgesStructureTypeC2C< TDim >
 CKratos::EffectiveStressesCommunicatorUtility
 CKratos::EICREICR Element Independent CoRotational formulation
 CKratos::EigenDenseColPivHouseholderQRSolver< TScalar >
 CKratos::EigenDenseHouseholderQRSolver< TScalar >
 CKratos::EigenDenseLLTSolver< TScalar >
 CKratos::EigenDensePartialPivLUSolver< TScalar >
 CKratos::EigenfrequencyResponseFunctionUtilityShort class definition
 CKratos::EigenPardisoLDLTSolver< TScalar >
 CKratos::EigenPardisoLLTSolver< TScalar >
 CKratos::EigenPardisoLUSolver< TScalar >
 CKratos::EigenSparseCGSolver< TScalar >
 CKratos::EigenSparseLUSolver< TScalar >
 CKratos::EigenSparseQRSolver< TScalar >
 CKratos::EigenvectorToSolutionStepVariableTransferUtilityTransfer eigenvectors to solution step variables for GiD output or solution initialization
 CKratos::HypoElasticModel::ElasticModelData
 CKratos::LinearElasticModel::ElasticModelData
 CKratos::ElastoPlasticMohrCoulombCohesive3DLaw::ElastoPlasticConstitutiveLawVariables
 Celement
 Cnice_names::element
 CKratos::Stokes3D::element_data< TNumNodes, TDim >
 ►CKratos::MPIInternals::ElementalContainerAccess
 CKratos::CompressiblePerturbationPotentialFlowElement< Dim, NumNodes >::ElementalData< TNumNodes, TDim >
 CKratos::CompressiblePotentialFlowElement< Dim, NumNodes >::ElementalData< TNumNodes, TDim >
 CKratos::IncompressiblePerturbationPotentialFlowElement< Dim, NumNodes >::ElementalData< TNumNodes, TDim >
 CKratos::IncompressiblePotentialFlowElement< Dim, NumNodes >::ElementalData< TNumNodes, TDim >
 CKratos::PotentialFlowUtilities::ElementalData< TNumNodes, TDim >
 CKratos::SmallStrainUPwDiffOrderElement::ElementalVariables
 CKratos::UpdatedLagrangianElement< TDim >::ElementalVariables
 CKratos::BeamElement::ElementData
 CKratos::FluidElement< TElementData >::ElementData
 CKratos::QSConvectionDiffusionExplicit< TDim, TNumNodes >::ElementData
 CKratos::SolidElement::ElementData
 CKratos::WaveElement< TNumNodes >::ElementData
 CKratos::CompressibleNavierStokesExplicit< TDim, TNumNodes >::ElementDataStruct
 ►CKratos::NavierStokes< TDim, TNumNodes >::ElementDataStruct
 CKratos::ElementSizeCalculator< TDim, TNumNodes >A collection of functions to compute element size, to be used as the h parameter in stabilized CFD formulations
 CKratos::ElementUtilities
 CKratos::EulerianConvectionDiffusionElement< TDim, TNumNodes >::ElementVariables
 CKratos::GeoStructuralBaseElement< TDim, TNumNodes >::ElementVariablesMember Variables
 CKratos::RigidBodyElement::ElementVariables
 CKratos::ShellCrossSection::ElementVariables
 CKratos::SmallDisplacementInterfaceElement< TDim, TNumNodes >::ElementVariables
 CKratos::SmallStrainUPwDiffOrderElement::ElementVariables
 CKratos::SteadyConvectionDiffusionFICElement< TDim, TNumNodes >::ElementVariables
 CKratos::UPwSmallStrainElement< TDim, TNumNodes >::ElementVariables
 Cnice_names::elementvariables
 Cnice_names::elset
 CKratos::EmbeddedAusasNavierStokes< TDim, TNumNodes >::EmbeddedAusasElementDataStruct
 CKratos::EmbeddedLaplacianInternals::EmbeddedElementData< TDim >
 CKratos::EmbeddedNodalVariableFromSkinTypeHelperClass< TVarType >
 CKratos::EmbeddedSkinUtility< TDim >Utility to compute the skin representation from a distance function
 CKratos::EmbeddedVolumeTool< TDim >
 CKratos::EmcStepMethod< TVariableType, TValueType >::EmcParameters
 Cempire_wrapper.EmpireWrapper
 Cempirical_cubature_method.EmpiricalCubatureMethodThis class selects a subset of elements and corresponding positive weights necessary for the construction of a hyper-reduced order model Reference: Hernandez 2020
 CEmpiricalSpringElementProcessThis process creates a spring element w.r.t. to given displacement/load data points
 CKratos::endl
 CKratos::EnergyUtilitiesShort class definition
 CKratos::EnrichmentUtilities
 CKratos::EnrichmentUtilities_2DThis utility can be used to calculate the enriched shape function for tetrahedra element
 CKratos::EnrichmentUtilitiesDuplicateDofs
 CKratos::EnrichmentUtilitiesforPFEM2
 CKratos::EntitiesEraseProcessFlags
 CKratos::EntitiesUtilities::EntitityIdentifier< TEntity >Template struct for entity identifier
 CKratos::EntitiesUtilities::EntitityIdentifier< Kratos::Condition >
 CKratos::EntitiesUtilities::EntitityIdentifier< Kratos::Element >
 CKratos::EntityCalculationUtils
 CKratos::EntityDatabaseThis class stores the results of a entity
 CKratos::EntityProxy< TLocation, TMutable >Wrapper class providing a uniform interface for historical/non-historical Node, Element, and Condition
 ►CKratos::EnvironmentManager
 CKratos::EstimateDtUtilityEstimate the time step in a fluid problem to obtain a given Courant number
 CKratos::EstimateTimeStepUtilityUtility to estimate the time step in terms of the courant number
 CKratos::ExactMortarIntegrationUtility< TDim, TNumNodes, TBelong, TNumNodesMaster >This utility calculates the exact integration necessary for the Mortar Conditions
 CKratos::ExactMortarIntegrationUtility< TDim, TNumNodes, false, TNumNodesMaster >
 CKratos::ExcavatorUtility
 ►Cstd::exception
 CKratos::ExplicitBuilder< TSparseSpace, TDenseSpace >Current class provides an implementation for the base explicit builder and solving operations
 CKratos::ExplicitFilter< TContainerType >
 CKratos::ExplicitSolverSettings
 ►CKratos::ExplicitSolverStrategy
 Csphere_strategy.ExplicitStrategy
 CKratos::NonAssociativeExplicitPlasticFlowRule::ExplicitStressUpdateInformation
 ►CKratos::ExpressionBase class or all the expression types
 ►CKratos::ExpressionInput
 CKratos::ExpressionIOUtils
 CKratos::Expression::ExpressionIterator
 ►CKratos::ExpressionOutput
 CKratos::ExpressionUtils
 Coptimization_problem_vtu_output_process.ExpressionVtuOutput
 CCSharpKratosWrapper::face
 CKratos::FaceAngleResponseFunctionUtilityShort class definition
 CKratos::RigidFace3D::FaceDataBuffer
 CKratos::FaceHeatUtilities
 CKratos::AnalyticFaceWatcher::FaceHistoryDatabase
 CKratos::AnalyticParticleWatcher::FaceParticleImpactDataOfAllParticlesSingleTimeStep
 CKratos::AnalyticParticleWatcher::FaceParticleImpactDataOfAllTimeStepsSingleParticle
 ►CKratos::FactoryBaseHere we define some common methods
 CKratos::HCFDataContainer::FatigueVariables
 Cfde_solve.fde_solveSolves (1+\mathcal{L})^{\alpha}\mathcal{L}^{\beta}\psi = f in [0,H] \psi = 0 at z=0 d\psi/dz = 0 at z=H
 CKratos::FEASTConditionNumberUtility< TSparseSpace, TDenseSpace >This utility uses the FEAST solver to obtain (estimate) the the condition number of a regular matrix
 CKratos::ConstitutiveLaw::Features
 CKratos::ShellCrossSection::Features
 Code_solve.FEM_coefficient_matrix_generator
 Code_solve.FEM_load_vector_generator
 CKratos::FEMDEMCouplingUtilitiesThis class includes several utilities necessaries for the coupling between the FEM and the DEM
 ►CBaseSolver.FemDemMechanicalSolver
 CFEMDEMParticleCreatorDestructor.FemDemParticleCreatorDestructor
 CKratos::FetiDynamicCouplingUtilities< TSparseSpace, TDenseSpace >
 CKratos::UPwSmallStrainFICElement< TDim, TNumNodes >::FICElementVariables
 CKratos::Internals::FICSpecializedAddTimeIntegratedSystem< TElementData, TDataKnowsAboutTimeIntegration >
 CKratos::Internals::FICSpecializedAddTimeIntegratedSystem< TElementData, false >
 CKratos::Internals::FICSpecializedAddTimeIntegratedSystem< TElementData, true >
 Ccellular_flow_derivative_recovery_errors.Field
 ►CKratos::FieldUtility
 Ccellular_flow_derivative_recovery_errors.Figure
 CKratos::HDF5::FileA base class for reading and writing an HDF5 file
 Clogger_utilities.FileLoggerA context responsible for managing the lifetime of logger files
 CKratos::FileNameDataCollector::FileNameData
 CKratos::FileNameDataCollector
 CKratos::FilesystemExtensions
 ►CKratos::FillCommunicatorBase class defining the API for the fill communicator utilities
 CKratos::FilterFunctionShort class definition
 CKratos::FindNodalHSettingsThis struct is used in order to identify when using the hitorical and non historical variables
 Cfinite_difference_sensitivity_utilities.FiniteDifferenceBodyFittedDragShapeSensitivityAnalysis
 CKratos::FiniteDifferenceUtilityFiniteDifferenceUtility
 Cfinite_difference_sensitivity_utilities.FiniteDifferenceVelocityPressureNormSquareShapeSensitivityAnalysis
 CKratos::FirstOrderScalarVariable
 CKratos::FixedMeshALEUtilitiesUtility to perform the FM-ALE algorithm operations This utility implements the Fixed Mesh - Arbitrary Lagrangian Eulerian (FM-ALE) algorithm operations. After setting a virtual mesh, which is a copy of the problem background element mesh, it is moved in accordante to the immersed object movement. The virtual mesh movement is solved using a common ALE mesh solver (in this case the Laplacian mesh solver is used). Once the mesh movement, including the mesh velocity, have been computed, the origin mesh historical values (velocity and pressure), as well as the mesh velocity, are computed as a projection from the virtual mesh. This is required to consistently initialize the historical values when nodes change its topological status
 ►CKratos::Flags
 ►CKratos::FlowRuleShort class definition
 CKratos::FlowStationarityCheckThis defines a class to assess whether stationarity has been reached in the fluid
 CKratos::FluidAdjointSlipUtilities
 CKratos::FluidAdjointTestUtilities
 CKratos::FluidAdjointUtilities< TDim >
 CKratos::FluidAuxiliaryUtilities
 CKratos::FluidCalculationUtilities
 CKratos::FluidCharacteristicNumbersUtilitiesFluid characteristic numbers calculation utility This class provides static methods to calculate the common adimensional magnitudes that characterize any fluid flow
 ►CKratos::FluidElementData< TDim, TNumNodes, TElementIntegratesInTime >Base class for data containers used within FluidElement and derived types
 ►CKratos::FluidElementData< TDim, TNumNodes, false >
 ►CKratos::FluidElementData< TDim, TNumNodes, true >
 CKratos::Internals::FluidElementTimeIntegrationDetail< TElementData, TDataKnowsAboutTimeIntegration >
 CKratos::Internals::FluidElementTimeIntegrationDetail< TElementData, false >
 CKratos::Internals::FluidElementTimeIntegrationDetail< TElementData, true >
 CKratos::FluidElementUtilities< TNumNodes >Auxiliary and specialized functions for elements derived from FluidElement
 Cswimming_DEM_procedures.FluidFractionFieldUtility
 Chdf5_io_tools.FluidHDF5Loader
 CProjectParameters.FluidSolverConfiguration
 CKratos::FluidTestUtilities
 CKratos::FluxLimiter< TLocalVectorType >This is a helper class to separate the physics from the flux corrected scheme
 CKratos::FluxLimiter< LocalSystemVectorType >
 CKratos::FNV1a32HashA constexpr version of FNV hash function. (32 bit version)
 CKratos::FNV1a64HashA constexpr version of FNV hash function. (64 bit version)
 CKratos::ForceAndTorqueUtils
 Csymbolic_generation.compressible_navier_stokes.src.symbolic_parameters.FormulationParameters
 Cfrac_step_solverQ.FracStepSolver
 CKratos::FracturePropagation2DUtilities::FracturePointStructs for fracture propagation check ---------------------------------------------------------------------------------------------------------------------------------—
 CKratos::FracturePropagation3DUtilities::FracturePointStructs for fracture propagation check ---------------------------------------------------------------------------------------------------------------------------------—
 CKratos::FracturePropagation2DUtilities
 CKratos::FracturePropagation3DUtilities
 ►CKratos::FrictionalLawThis class defines the base class for frictional laws
 ►CKratos::FrictionLawShort class definition
 CKratos::FrictionLawsFactoryThe base class for the bottom and surface friction laws
 CKratos::FrictionLaw::FrictionLawVariables
 Cfsi_coupling_interface.FSICouplingInterface
 CKratos::FSIUtils
 Chinsberg_optimization.Functional
 Chinsberg_optimization_3.Functional
 Chinsberg_optimization_4.Functional
 CKratos::FunctionParserGenericFunctionUtility
 CGatherModelPartUtilityThis function gathers a model part from a given rank to the master rank
 CKratos::GatherModelPartUtility
 Canalytics.Gauge
 ►CGaussianRandomField.GaussianRandomFieldGaussian Random Field generator class
 CKratos::DamUpliftConditionLoadProcess::GaussPointStructs for mapping model parts ----------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::NonlocalDamageUtilities::GaussPoint
 CKratos::NonLocalPlasticityProcess::GaussPoint
 CKratos::FracturePropagation2DUtilities::GaussPointOldStructs for mapping model parts ----------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::FracturePropagation3DUtilities::GaussPointOldStructs for mapping model parts ----------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::ResidualBasedBossakDisplacementRotationScheme< TSparseSpace, TDenseSpace >::GeneralAlphaMethod
 CKratos::ResidualBasedBossakScheme< TSparseSpace, TDenseSpace >::GeneralAlphaMethod
 CKratos::TimeDiscretization::GeneralizedAlpha
 CKratos::DynamicScheme< TSparseSpace, TDenseSpace >::GeneralMatrices
 CKratos::ExplicitHamiltonScheme< TSparseSpace, TDenseSpace >::GeneralMatrices
 CKratos::ResidualBasedBossakDisplacementRotationScheme< TSparseSpace, TDenseSpace >::GeneralMatrices
 CKratos::ResidualBasedBossakScheme< TSparseSpace, TDenseSpace >::GeneralMatrices
 CKratos::ResidualBasedImplicitTimeScheme< TSparseSpace, TDenseSpace >::GeneralMatrices
 CKratos::MPMParticleBaseCondition::GeneralVariables
 CKratos::MPMUpdatedLagrangian::GeneralVariables
 CKratos::RigidBodyPointLinkCondition::GeneralVariables
 CKratos::ShellCrossSection::GeneralVariables
 CKratos::SolidShellElementSprism3D6N::GeneralVariables
 CKratos::ThermalContactDomainCondition::GeneralVariables
 CKratos::ThermalElement::GeneralVariables
 CKratos::DynamicScheme< TSparseSpace, TDenseSpace >::GeneralVectors
 CKratos::ExplicitHamiltonScheme< TSparseSpace, TDenseSpace >::GeneralVectors
 CKratos::ResidualBasedBDFScheme< TSparseSpace, TDenseSpace >::GeneralVectors
 CKratos::ResidualBasedBossakDisplacementRotationScheme< TSparseSpace, TDenseSpace >::GeneralVectors
 CKratos::ResidualBasedBossakDisplacementScheme< TSparseSpace, TDenseSpace >::GeneralVectorsVelocities and accelerations used for integration
 CKratos::ResidualBasedBossakScheme< TSparseSpace, TDenseSpace >::GeneralVectors
 CGenerateCN.GenerateCN
 CGenerateWind.GenerateWind
 CKratos::GenericCompressionConstitutiveLawIntegratorDplusDminusDamage< TYieldSurfaceType >: This object integrates the predictive stress using the isotropic the d+d- damage theory
 CGenericConstitutiveLawIntegrator
 CKratos::GenericConstitutiveLawIntegratorDamage< TYieldSurfaceType >: This object integrates the predictive stress using the isotropic damage theory by means of linear/exponential softening
 CKratos::GenericConstitutiveLawIntegratorKinematicPlasticity< TYieldSurfaceType >This object integrates the predictive stress using the plasticity theory by means of linear/exponential softening or hardening + softening evolution laws
 CKratos::GenericConstitutiveLawIntegratorPlasticity< TYieldSurfaceType >This object integrates the predictive stress using the plasticity theory by means of linear/exponential softening or hardening + softening evolution laws
 CKratos::GenericPlasticPotential< TVoigtSize >If the plastic potential is of the same type as the yield surface we talk about associated flow rules, if a different function is used, it is non-associated. For metals associated flow rules work great, while frictional materials typically need non-associated flow rules
 CKratos::GenericTensionConstitutiveLawIntegratorDplusDminusDamage< TYieldSurfaceType >: This object integrates the predictive stress using the isotropic the d+d- damage theory
 CKratos::GenericYieldSurface< TPlasticPotentialType >This class defines a generic yield surface
 CKratos::GeoElementUtilities
 CKratos::GeoMechanicsMathUtilities< TDataType >
 CKratos::GeometricalConfigure< TDimension >
 CKratos::EPPointRigidContactPenalty3DCondition::GeometricalInformation
 CKratos::GeometricalObjectsBinsA bins container for 3 dimensional GeometricalObject entities
 CKratos::GeometricalProjectionUtilitiesThis is a class that provides auxiliar utilities for projections
 CKratos::GeometricalSensitivityUtility
 ►CKratos::Geometry< TPointType >Geometry base class
 ►CKratos::Geometry< Kratos::Node >
 ►CKratos::Geometry< TContainerPointType::value_type >
 ►CKratos::Geometry< TSurfaceContainerPointType::value_type >
 ►CKratos::Geometry< TVolumeContainerPointType::value_type >
 CKratos::GeometryContainer< TGeometryType >
 CKratos::GeometryContainer< GeometryType >
 CKratos::GeometryData
 ►Csymbolic_generation.compressible_navier_stokes.src.symbolic_geometry.GeometryData
 CKratos::GeometryDimension
 CKratos::GeometryMetricCalculator< TDim, TNumNodes >
 CKratos::GeometryShapeFunctionContainer< TIntegrationMethodType >
 CKratos::GeometryShapeFunctionContainer< IntegrationMethod >
 CKratos::GeometryTesterUtilityThis utility tests the geometries
 CKratos::GeometryUtilitiesShort class definition
 CKratos::GeometryUtilsThis function provides basic routines for working with simplicial meshes
 CKratos::GeoOutputWriter
 ►CGeoSolver
 CKratos::GeoStaticCondensationUtilityThis utilitiy condenses given degrees of freedom from any element stiffness matrix to model e.g. hinges
 CKratos::GeoStructuralMechanicsElementUtilities
 CKratos::FluidTestUtilities::GetContainer< TContainerType >
 CKratos::BinsDynamic< TDimension, TPointType, TContainerType, TPointerType, TIteratorType, TDistanceIteratorType, TDistanceFunction >::GetObjectType< T, typename >
 CKratos::Tree< TPartitionType >::GetObjectType< T, typename >
 CKratos::BinsDynamic< TDimension, TPointType, TContainerType, TPointerType, TIteratorType, TDistanceIteratorType, TDistanceFunction >::GetObjectType< T, std::void_t< typename T::ObjectType > >
 CKratos::Tree< TPartitionType >::GetObjectType< T, std::void_t< typename T::ObjectType > >
 CKratos::GetValueFunctor< TVariableType >Short class definition
 CKratos::GidGaussPointsContainer
 CKratos::GidMeshContainer
 Cgid_mesh_to_mdpa.GidMeshConverterVery simple function to parse a Gid mesh file and extract nodal coordinates and tetrahedra connectivity
 Cglobal_joint_stress_utility.GlobalJoinStressUtility
 CKratos::GlobalJointStressUtility
 CKratos::GlobalPointer< TDataType >This class is a wrapper for a pointer to a data that is located in a different rank
 CKratos::GlobalPointer< Kratos::Element >
 CKratos::GlobalPointer< TObjectType >
 CKratos::GlobalPointerCommunicator< TPointerDataType >A template class for handling communication related to global pointers
 CKratos::GlobalPointerCompare< TDataType >This is a key compare between two pointers to the object object
 CKratos::GlobalPointerComparor< TDataType >This is a key comparer between two dof pointers checking for equal keys
 CKratos::GlobalPointerHasher< TDataType >Template struct for hashing GlobalPointer instances
 CKratos::GlobalPointerMapCommunicator< TPointerDataType, TValueDataType >Short class definition
 CKratos::GlobalPointersVector< TDataType >This class is a vector which stores global pointers
 CKratos::GlobalPointersVector< Element >
 CKratos::GlobalPointersVector< Kratos::Condition >
 CKratos::GlobalPointersVector< Kratos::Element >
 CKratos::GlobalPointersVector< Kratos::Node >
 CKratos::GlobalPointerUtilitiesThis class is used to manage global pointers. Overall, the GlobalPointerUtilities class provides a useful utility for retrieving global pointers to entities in a distributed Kratos simulation
 CKratos::GradualVariableInterpolationUtility
 CDEM_procedures.GranulometryUtils
 CKratos::GraphUtilities
 Code_solve.Grid1D
 Ccubic_law.h_and_phi_function
 ►CKratos::HardeningLawShort class definition
 ►CKratos::HardeningRuleShort class definition
 CKratos::EmbeddedSkinVisualizationProcess::Hash
 Cstd::hash< Kratos::array_1d< T, N > >
 Cstd::hash< std::pair< T1, T2 > >This is a hasher for pairs
 CKratos::HCFDataContainerDefining all the methods and variables required in fatigue simulations
 Chdf5_output_tool.Hdf5OutputTool
 Coptimization_problem_ascii_output_process.Header
 ►CKratos::HeatExchangeMechanism
 ►CKratos::HeatGenerationMechanism
 CKratos::HeatMapUtilities
 CKratos::HelmholtzSolidDataContainer< TDim, TNumNodes, TDataDimension >
 CKratos::HelmholtzSolidShapeDataContainer< TDim, TNumNodes >
 CKratos::HelmholtzSurfaceDataContainer< TDim, TNumNodes, TDataDimension >
 CKratos::HelmholtzVariableData< TDataDimension >
 CKratos::HelmholtzVariableData< 1 >
 CKratos::HelmholtzVariableData< 2 >
 CKratos::HelmholtzVariableData< 3 >
 CKratos::HexahedronGaussLegendreIntegrationPoints1
 CKratos::HexahedronGaussLegendreIntegrationPoints2
 CKratos::HexahedronGaussLegendreIntegrationPoints3
 CKratos::HexahedronGaussLegendreIntegrationPoints4
 CKratos::HexahedronGaussLegendreIntegrationPoints5
 CKratos::HexahedronGaussLobattoIntegrationPoints1
 CKratos::HexahedronGaussLobattoIntegrationPoints2
 CKratos::HighCycleFatigueLawIntegrator< TVoigtSize >: This object computes all the required information for the high cycle fatigue constitutive law
 Call_t_win_vs_m_fixed_error.HinsbergPointsSetGivenNorm
 Cexact_hinsberg_test.HinsbergPointsSetGivenNorm
 Cinitial_time_bounds.HinsbergPointsSetGivenNorm
 Cnormed_exact_hinsberg_test.HinsbergPointsSetGivenNorm
 Ct_win_vs_m_fixed_error.HinsbergPointsSetGivenNorm
 CKratos::ContainerDataIOTags::Historical
 CKratos::MethodUtilities::HistoricalDataValueRetrievalFunctor< TContainerItemType >
 CKratos::CollectiveExpressionIO::HistoricalVariable
 Ccubic_law.HorizontalDistributionMinusObjective
 Ctensors::hs1
 CKratos::HydraulicFluidAuxiliaryUtilities
 CKratos::WaterPressureUtilities::HydroMechanicalVariables
 CDerivatives.HyperbolicTangentFluidFractionSolution
 CKratos::HyperElasticModel::HyperElasticFactors
 CKratos::HyperElasticModel::HyperElasticModelData
 CCSharpKratosWrapper::IdTranslator
 CKratos::IgaFlagsFlags needed used in the IGAApplication
 CKratos::ImplementationDerivativesUtilitiesAuxiliary implementation for DerivativesUtilities
 CKratos::ImplicitFilterUtils
 ►CBaseSolver.ImplicitMonolithicSolver
 ►Conthefly_kratos_inlet_process.ImposeWindInletProcess
 Csteady_wind_kratos_inlet_process.ImposeWindInletProcess
 ►CKratos::IndexDatabaseBase class to derive common methods
 ►CKratos::IndexedObjectThis object defines an indexed object
 CKratos::IndexedObjectComparator< TIndexedObject >This is a key comparer between two indexed objects
 CKratos::IndexedObjectHasher< TIndexedObject >This is a hasher for indexed objects
 CKratos::IndexedObjectPointerComparator< TpIndexedObject >This is a key comparer between two indexed objects (pointer)
 CKratos::IndexedObjectPointerHasher< TpIndexedObject >This is a hasher for indexed objects (pointer)
 CKratos::IndexPartition< TIndexType, TMaxThreads >This class is useful for index iteration over containers
 CKratos::IndirectScalar< T, S >Wrapper for a function which behaves like an arithmetic type
 CKratos::ShockCapturingEntropyViscosityProcess::InfNormData
 CKratos::InitialStateDefine the initial state of the material in terms of initial stress/strain/F
 CKratos::InitialStress2DUtilities
 CKratos::InitialStress3DUtilities
 Conthefly_kratos_inlet_process.InletPanel3D
 Cmapping.in_plane_vertex_morphing_mapper.InPlaneVertexMorphingMapperThe InPlaneVertexMorphingMapper extends the standard Vertex Morphing approach by restricting the shape update of nodes to an in-plane motion only
 ►CKratos::InputUtility
 ►Cstd::integral_constant
 CKratos::NumericalIntegrationMethod::IntegrandParams
 CKratos::ExplicitFilterHelperUtilities::IntegratedWeight
 CKratos::FluxConditionInternals::IntegrationData< TNodeNumber >
 CKratos::ShellCrossSection::IntegrationPoint
 CKratos::IntegrationPointExpressionIO
 CKratos::IntegrationPointToNodeTransformationUtility< TDim, TNumNodes >A utility for transforming values on integration points to nodes
 CKratos::IntegrationPointUtilities
 CKratos::IntegrationUtilitiesUtilities to integrate in different cases
 Cnice_names::integrationvariables
 ►Cenum.IntEnum
 ►CKratos::InterfaceCommunicatorObject for exchanging data on the Interface
 CKratos::InterfaceElementUtilities
 CKratos::UPwSmallStrainInterfaceElement< TDim, TNumNodes >::InterfaceElementVariables
 CKratos::InterfaceObjectConfigure
 CKratos::InterfacePreprocessConditionCreates Model Parts containing the interface
 CKratos::InterfaceVectorContainer< TSparseSpace, TDenseSpace >Short class definition
 CKratos::FlowRule::InternalVariables
 CKratos::HardeningRule::InternalVariables< TVarSize >
 CKratos::ParticleFlowRule::InternalVariables
 CKratos::AnalyticParticleWatcher::InterParticleImpactDataOfAllParticlesSingleTimeStep
 CKratos::AnalyticParticleWatcher::InterParticleImpactDataOfAllTimeStepsSingleParticle
 CKratos::InterpolateStructuralSolutionForDEM
 CKratos::InterpolateSwToPfemUtility
 CKratos::CalculateSignedDistanceTo3DConditionSkinProcess::IntersectionNodeStruct
 CKratos::CalculateSignedDistanceTo3DSkinProcess::IntersectionNodeStruct
 CKratos::IntersectionUtilitiesUtilities to compute intersections between different geometries
 CKratos::IntervalUtility
 Ctensors::inverse
 ►CKratos::IOIO provides different implementation of input output procedures which can be used to read and write with different formats and characteristics
 Cswimming_DEM_procedures.IOTools
 CKratos::IOUtilitiesSolution utility to filter results
 CKratos::IsosurfacePrinterApplication
 CKratos::IsotropicDamageUtilities
 Canalyzers.analyzer_internal.IterationScope
 ►Cboost::iterator_adaptor
 CKratos::JacobianEmulator< TSpace >Jacobian emulator
 CKratos::JacobianEmulator< TDenseSpace >
 CKratos::ShellThickElement3D4N< TKinematics >::JacobianOperatorJacobianOperator
 CKratos::ShellUtilities::JacobianOperatorJacobianOperator
 Cwrite_json_input.JsonWriter
 Chinsberg_optimization.K_B
 Chinsberg_optimization_3.K_B
 Chinsberg_optimization_4.K_B
 Chinsberg_optimization.K_component
 Chinsberg_optimization_3.K_component
 Chinsberg_optimization_4.K_component
 Chinsberg_optimization.K_sum
 Chinsberg_optimization_3.K_sum
 Chinsberg_optimization_4.K_sum
 ►CKratos::kDOP
 CKratos::KernelKernel is in charge of synchronization the whole system of Kratos itself and its application
 CKratos::KeyComparorRange< TClassType >This is a key comparer of general pourpose between two classes
 CKratos::EmbeddedSkinVisualizationProcess::KeyEqual
 CKratos::KeyHasherRange< TClassType >This is a hasher of general pourpose
 CKratos::RegistryItem::KeyReturnConstIteratorCustom iterator with key as return type to be used in the Python export
 ►CKratos::BaseSolidElement::KinematicVariables
 CKratos::CouplingNitscheCondition::KinematicVariablesInternal variables used for metric transformation
 CKratos::IgaMembraneElement::KinematicVariablesInternal variables used for metric transformation
 CKratos::Shell3pElement::KinematicVariablesInternal variables used for metric transformation
 CKratos::Shell5pElement::KinematicVariablesInternal variables used for metric transformation
 CKratos::SmallDisplacementMixedVolumetricStrainElement::KinematicVariables
 CKratos::SupportNitscheCondition::KinematicVariablesInternal variables used for metric transformation
 CKratos::TotalLagrangianMixedVolumetricStrainElement< TDim >::KinematicVariables
 ►CKratos::KratosApplicationThis class defines the interface with kernel for all applications in Kratos
 CKratos::KratosComponents< TComponentType >KratosComponents class encapsulates a lookup table for a family of classes in a generic way
 CKratos::KratosComponents< Kratos::Condition >
 CKratos::KratosComponents< Kratos::Element >
 CKratos::KratosComponents< Kratos::Geometry< Kratos::Node > >
 CKratos::KratosComponents< Kratos::MasterSlaveConstraint >
 CKratos::KratosComponents< Kratos::Modeler >
 CKratos::KratosComponents< Kratos::Variable< double > >
 CKratos::KratosComponents< Kratos::Variable< int > >
 CKratos::KratosComponents< Kratos::Variable< Kratos::array_1d< double, 3 > > >
 CKratos::KratosComponents< Kratos::Variable< Kratos::array_1d< double, 4 > > >
 CKratos::KratosComponents< Kratos::Variable< Kratos::array_1d< double, 6 > > >
 CKratos::KratosComponents< Kratos::Variable< Kratos::array_1d< double, 9 > > >
 CKratos::KratosComponents< Kratos::Variable< Kratos::Internals::Matrix > >
 CKratos::KratosComponents< Kratos::Variable< Kratos::Quaternion< double > > >
 CKratos::KratosComponents< Kratos::Variable< unsigned int > >
 CKratos::KratosComponents< Kratos::VariableData >
 CKratos::KratosComponents< VariableData >
 CKratos::KratosExecute
 CKratos::KratosGeoSettlement
 CCSharpKratosWrapper::KratosInternals
 CKratosMonitor.KratosMonitor
 CKratos::KratosSpace< TDataType, TMatrixType, TVectorType >Short class definition
 CCSharpKratosWrapper::KratosWrapper
 Copt_convergence.L2ConvCriterion
 CL2_error_calculator_utility.L2ErrorCalculatorUtility
 CKratos::L2ErrorNormCalculator
 CKratos::LaplacianSmoothingShort class definition
 CKratos::LegacyPartitioningUtilitiesThis class contains legacy versions of utilities used by the metis partitioners
 CKratos::ExplicitSolverStrategy::LessX
 CKratos::ExplicitSolverStrategy::LessY
 CKratos::ExplicitSolverStrategy::LessZ
 Capply_wall_law_process.ApplyWallLawProcess.linear_log_monolithic_helper
 CProjectParameters.FluidSolverConfiguration.linear_solver_config
 CProjectParameters.SolverSettings1.linear_solver_config
 CProjectParameters.SolverSettings2.linear_solver_config
 CProjectParameters.SolverSettings.linear_solver_config
 Clinear_elastic_constitutive_law.LinearElasticLaw
 Cswimming_DEM_procedures.FluidFractionFieldUtility.LinearField
 CLinearIsotropicDamagePlaneStrain2DDefines a damage with hardening/softening constitutive law in 2D (Plane Strain)
 CLinearIsotropicDamageTractionOnly3DDefines a damage with hardening/softening constitutive law in 3D
 CLinearJ2Plasticity3DDefines a Simo J2 plasticity constitutive law in 3D
 CLinearJ2PlasticityPlaneStrain2DDefines a Simo J2 plasticity constitutive law in 2D (Plane Strain)
 CKratos::LinearLogWallLaw< TDim, TNumNodes >Linear-log law LHS and RHS contribution implementation This class implements the LHS and RHS Gauss point contributions of the linear-log wall model This class should be used in combination with an incompressible Navier-Stokes (or Stokes) condition implementing the remaining terms (see @NavierStokesWallCondition)
 ►CKratos::LinearSolver< TSparseSpaceType, TDenseSpaceType, TReordererType >Base class for all the linear solvers in Kratos
 ►CKratos::LinearSolver< TSparseSpaceType, TDenseSpaceType, Reorderer< TSparseSpaceType, TDenseSpaceType > >
 ►CKratos::LinearSolver< TUblasDenseSpace< double >, TUblasDenseSpace< double > >
 ►CKratos::LinearSolver< TUblasSparseSpace< TScalarIn >, TUblasDenseSpace< TScalarOut > >
 ►CKratos::LinearSolverFactory< TSparseSpace, TLocalSpace >Here we add the functions needed for the registration of linear solvers
 ►CKratos::LinearSolverFactory< TGlobalSpace, TLocalSpace >
 CKratos::LinearStrainEnergyResponseUtils
 CKratos::LineCollocationIntegrationPoints1
 CKratos::LineCollocationIntegrationPoints2
 CKratos::LineCollocationIntegrationPoints3
 CKratos::LineCollocationIntegrationPoints4
 CKratos::LineCollocationIntegrationPoints5
 CKratos::LineGaussLegendreIntegrationPoints1
 CKratos::LineGaussLegendreIntegrationPoints10
 CKratos::LineGaussLegendreIntegrationPoints2
 CKratos::LineGaussLegendreIntegrationPoints3
 CKratos::LineGaussLegendreIntegrationPoints4
 CKratos::LineGaussLegendreIntegrationPoints5
 CKratos::LineGaussLegendreIntegrationPoints6
 CKratos::LineGaussLegendreIntegrationPoints7
 CKratos::LineGaussLegendreIntegrationPoints8
 CKratos::LineGaussLegendreIntegrationPoints9
 CKratos::LineGaussLobattoIntegrationPoints1
 CKratos::LineGaussLobattoIntegrationPoints10
 CKratos::LineGaussLobattoIntegrationPoints2
 CKratos::LineGaussLobattoIntegrationPoints3
 CKratos::LineGaussLobattoIntegrationPoints4
 CKratos::LineGaussLobattoIntegrationPoints5
 CKratos::LineGaussLobattoIntegrationPoints6
 CKratos::LineGaussLobattoIntegrationPoints7
 CKratos::LineGaussLobattoIntegrationPoints8
 CKratos::LineGaussLobattoIntegrationPoints9
 CKratos::LineSensitivityUtility
 CKratos::LiteralExpressionIO
 Cnice_names::loaddef
 ►CKratos::LocalRefineGeometryMesh
 CKratos::BeamElement::LocalSystemComponents
 CKratos::BeamPointRigidContactCondition::LocalSystemComponents
 CKratos::BoundaryCondition::LocalSystemComponents
 CKratos::ContactDomainCondition::LocalSystemComponents
 CKratos::FluidElement< TElementData >::LocalSystemComponents
 CKratos::PointRigidContactCondition::LocalSystemComponents
 CKratos::RigidBodyElement::LocalSystemComponents
 CKratos::RigidBodyPointLinkCondition::LocalSystemComponents
 CKratos::SmallDisplacementBeamElement3D2N::LocalSystemComponents
 CKratos::SolidElement::LocalSystemComponents
 CKratos::SolidShellElementSprism3D6N::LocalSystemComponents
 CKratos::WriteFromSwAtInterfaceProcess< TDim >::locator_tls
 ►CKratos::LockObjectThis class defines and stores a lock and gives an interface to it
 CKratos::LoggerLogger is in charge of writing the messages to output streams
 CKratos::LoggerMessageLoggerMessage class holdes message and the properties of the message
 ►CKratos::LoggerOutputLoggerOutput is the base class for all logger outputs
 Conthefly_kratos_inlet_process.LogMeanProfile
 Csteady_wind_kratos_inlet_process.LogMeanProfile
 Clsdyna_mesh_to_mdpa.LsDynaMeshConverterVery simple function to parse a Gid mesh file and extract nodal coordinates and tetrahedra connectivity
 Clsdyna_mesh_to_mdpa.LsDynaSet
 CKratos::LUSkylineFactorization< TSparseSpaceType, TDenseSpaceType >
 ►CMainCL
 ►CMainCouplingFemDem.MainCoupledFemDem_Solution
 ►CMainCouplingPfemFemDem.MainCouplingPfemFemDem_Solution
 CKratos::Internals::MakeSamplerAtLocalCoordinate
 ►Cmalla
 Cmanufactured_solution.ManufacturedSolution
 CKratos::Python::MapInterface< TContainerType >
 ►CKratos::Mapper< TSparseSpace, TDenseSpace >Base Class for all Mappers
 CKratos::MapperBackend< TSparseSpace, TDenseSpace >
 CKratos::MapperFactory< TSparseSpace, TDenseSpace >Python Interface of the MappingApplication
 CKratos::MapperFlagsFlags needed used in the MappingApplication
 ►CKratos::MapperInterfaceInfoObject for storing data that is needed to construct the local-mapping-system
 CKratos::MapperUtilities::MapperInterfaceInfoSerializerHelper class to serialize/deserialize a vector containing MapperInterfaceInfos
 ►CKratos::MapperLocalSystemThis is the "Condition" of the mappers
 CKratos::MapperMPIBackend< TSparseSpace, TDenseSpace >
 CKratos::MappingMatrixUtilities< TSparseSpace, TDenseSpace >
 CKratos::MappingVariables2DUtilities
 CKratos::MappingVariables3DUtilities
 Cdam_mapping_variables_utility.MappingVariablesUtility
 CKratos::MapReduction< MapType >
 CKratos::MassResponseFunctionUtilityShort class definition
 CKratos::MassResponseUtils
 Cmaster_control.MasterControlMaster control class
 Cnice_names::materialconstants
 CKratos::ConstitutiveModelData::MaterialData
 CKratos::BorjaCamClayPlasticFlowRule::MaterialParameters
 CKratos::MCPlasticFlowRule::MaterialParameters
 CKratos::MPMUpdatedLagrangian::MaterialPointVariables
 CKratos::DispNewtonianFluid3DLaw::MaterialResponseVariables
 CKratos::HyperElastic3DLaw::MaterialResponseVariables
 Cmaterials_assignation_utility.MaterialsAssignationUtility
 ►CDem.DEM_material_test_script.MaterialTest
 ►CDEM_material_test_script.MaterialTest
 ►CDEM_procedures.MaterialTest
 CKratos::MathUtils< TDataType >Various mathematical utilitiy functions
 CKratos::MatrixContainer< TDim, TSparseSpace >
 CKratos::MatrixContainerC2C< TDim, TSparseSpace >
 ►CAMatrix::MatrixExpression
 CKratos::HenckyElasticPlastic3DLaw::MatrixSplit
 CKratos::HyperElasticPlastic3DLaw::MatrixSplit
 CKratos::HyperElasticUP3DLaw::MatrixSplit
 ►CAMatrix::MatrixStorage
 CKratos::UnaryStatisticOperations::Max
 Copt_convergence.MaxIterConvCriterion
 CKratos::MaxOverhangAngleResponseUtils
 CKratos::MaxReduction< TDataType, TReturnType >
 Ctensors::mb
 ►CDEM_procedures.MdpaCreator
 CKratos::MedModelPartIO::MedFileHandler
 CKratos::MedTestingUtilitiesShort class definition
 CKratos::MemoryInfoMemoryInfo gives the OS information about the memory usage by Kratos
 CKratos::MemoryPoolMemoryPool is the smallest building block of Kratos memory management
 CKratos::MergeVariableListsUtilityMerges the variable lists of the input modelparts
 Ccellular_flow_derivative_recovery_errors.Mesh
 Crefine_embedded_object.MeshAdaptor
 CKratos::MesherUtilities::MeshContainer
 ►Cmesh_controllers.mesh_controller_base.MeshController
 CKratos::MeshControllerUtilitiesShort class definition
 CCSharpKratosWrapper::MeshConverter
 CKratos::MeshDataTransferUtilitiesShort class definition
 ►CKratos::MesherShort class definition
 CKratos::MeshErrorCalculationUtilitiesShort class definition
 CKratos::MesherUtilitiesShort class definition
 CKratos::MeshingFlagsFlags needed used in the MeshingApplication
 CKratos::MesherUtilities::MeshingInfoParameters
 CKratos::MesherUtilities::MeshingParameters
 CKratos::MeshRotationUtility
 CKratos::MeshTransfer< TDim >This class allows the interpolation between non-matching meshes in 2D and 3D
 Crun_ethier_benchmark.MeshType
 CKratos::LoggerMessage::MessageSource
 ►Cmetaclass
 CKratos::MetisPartitioningUtilitiesThis class contains utilities used by the metis partitioners
 CKratos::MetricsMathUtils< TDim >This class is used to compute some mathematical operations needed for the metrics computing
 CKratos::UnaryStatisticOperations::Min
 CKratos::MinReduction< TDataType, TReturnType >
 CKratos::ShellThickElement3D4N< TKinematics >::MITC4ParamsMITC4Params
 CKratos::MLSShapeFunctionsUtilityMoving Least-Squares utility to calculate shape function values This class uses a linear polynomial basis and an exponential kernel to calculate the shape function values and gradients in a given point using a Moving Least-Squares minimization
 CKratos::MMGMeshInfo< TMMGLibrary >Stores the Mmg mesh information
 ►CKratos::MMGMeshInfo< MMGLibrary::MMG3D >
 CKratos::MmgUtilities< TMMGLibrary >Provides the Kratos interface to the MMG library API
 ►CKratos::MmgUtilities< MMGLibrary::MMG3D >
 CKratos::ModelThis class aims to manage different model parts across multi-physics simulations
 CKratos::ConstitutiveModelData::ModelData
 ►CKM.Modeler
 ►CKratos::ModelerModeler to interact with ModelParts
 ►CKratosMultiphysics.Modeler
 CKratos::ModelPartCombinationUtilitiesThis utility helps combine different ModelParts into one single ModelPart, with the corresponding sub ModelParts
 CKratos::ModelPartCommunicatorUtilitiesUtilitiy class for ModelPart::Comunicator management in an MPI context
 Cmodel_part_controller_factory.ModelPartController
 CKratos::ModelPartGraphUtilitiesThis file computes the graph representing the connectivity of a modelpart
 CKratos::ModelPartIntersectionOperator
 Cmodel_part_utilities.ModelPartOperation
 CKratos::ModelPartOperationUtilities
 CKratos::ModelPartSubstractionOperator
 CKratos::ModelPartUnionOperator
 Cmodel_part_utilities.ModelPartUtilities
 CKratos::ModelPartUtilsClass collecting a set of free-floating utility functions for querying and mutating ModelPart s
 CCSharpKratosWrapper::ModelPartWrapper
 CKratos::Wind::ModelSubdivisionUtilitiesUtility for populating sub model parts
 CKratos::ModifiedMohrCoulombPlasticPotential< TVoigtSize >This class defines a plastic potential following the theory of Mohr-Coulomb (modified)
 CKratos::ModifiedMohrCoulombYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Modified Mohr-Coulumb theory
 ►CKratos::ModifiedShapeFunctions
 CKratos::MohrCoulombPlasticPotential< TVoigtSize >This class defines a plastic potential following the theory of Mohr-Coulomb
 CKratos::MohrCoulombYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Von-Mises theory
 ►CBaseSolver.MonolithicSolver
 CKratos::MortarExplicitContributionUtilities< TDim, TNumNodes, TFrictional, TNormalVariation, TNumNodesMaster >This namespace includes several utilities necessaries for the computation of the explicit contribution of the mortar conditions
 CKratos::MortarKinematicVariables< TNumNodes, TNumNodesMaster >MortarKinematicVariables
 ►CKratos::MortarKinematicVariables< TNumNodes, TNumNodes >
 CKratos::MortarKinematicVariables< TNumNodes, TNumNodesMaster >
 CKratos::MortarOperator< TNumNodes, TNumNodesMaster >This is the definition of the mortar operator according to the work of Alexander Popp: https://www.lnm.mw.tum.de/staff/alexander-popp/
 ►CKratos::MortarOperator< TNumNodes, TNumNodes >
 CKratos::MortarOperator< TNumNodes, TNumNodesMaster >
 CKratos::MortarUtilitiesSettingsThis struct is used in order to identify when using the historical and non historical variables
 Cset_mesh_motion_and_get_forces_process.SetMeshMotionAndGetForcesProcess.Motion
 CKratos::MoveMeshUtilityThis utilitiy moves the nodes of a dem wall used especially in the fem-dem coupling
 CKratos::MoveParticleUtilityDiffFluidOnly< TDim >
 CKratos::MoveParticleUtilityPFEM2< TDim >
 CKratos::MoveParticleUtilityScalarTransport< TDim >
 CKratos::MoveShallowMeshUtilityTools for lagrangian computations
 CKratos::MPIColoringUtilitiesThis class provides elementary function for computing the recv list and to define a coloring for communications
 CKratos::Internals::MPIDataType< TDataType >
 CKratos::Internals::MPIDataType< bool >
 CKratos::Internals::MPIDataType< char >
 CKratos::Internals::MPIDataType< double >
 CKratos::Internals::MPIDataType< int >
 CKratos::Internals::MPIDataType< int64_t >
 CKratos::Internals::MPIDataType< long unsigned int >
 CKratos::Internals::MPIDataType< std::pair< char, int > >
 CKratos::Internals::MPIDataType< std::pair< double, int > >
 CKratos::Internals::MPIDataType< std::pair< int, int > >
 CKratos::Internals::MPIDataType< std::pair< long unsigned int, int > >
 CKratos::Internals::MPIDataType< std::pair< unsigned int, int > >
 CKratos::Internals::MPIDataType< unsigned int >
 CKratos::MpiDebugUtilities
 CKratos::MpiDiscreteParticleConfigure< TDimension >
 CMPIer.MPIerClass
 CKratos::MPIMessage< TDataType >
 CKratos::MPINormalCalculationUtilsSome tools to calculate face and nodal normals on an MPI partitioned environment
 CKratos::MPM_MPI_UtilitiesProvides place to add mpi related utility functions
 CKratos::MPMStressPrincipalInvariantsUtility
 CKratos::MSuitePFEMModelerShort class definition
 ►CKratos::MultiaxialControlModuleGeneralized2DUtilities
 Cmultiaxial_control_module_generalized_2d_utility.MultiaxialControlModuleGeneralized2DUtility
 ►CDEM_procedures.MultifileList
 CDEM_procedures_mpi.MultifileList
 CKratos::BinaryOperations::Multiplication
 Capply_wall_law_process.ApplyWallLawProcess.navier_slip_monolithic_helper
 CKratos::NavierSlipWallLaw< TDim, TNumNodes >Navier-slip law LHS and RHS contribution implementation This class implements the LHS and RHS contributions of the Navier-slip wall model This class should be used in combination with an incompressible Navier-Stokes (or Stokes) condition implementing the remaining terms (see @NavierStokesWallCondition). More information about can be found in https://onlinelibrary.wiley.com/doi/abs/10.1002/fld.663
 ►CNavierMonolithic.NavierStokesSolverMonolithic
 CKratos::NearestElementOptionsOptions for configuring the behavior of the Mapper
 CKratos::NearestPointUtilitiesTools to calculate the nearest point in different geometries
 CKratos::Neighbours< TNodeType, TElementType >Short class definition
 ►CNeighbours_Calculator
 CKratos::TimeDiscretization::Newmark
 CKratos::ResidualBasedBossakDisplacementRotationScheme< TSparseSpace, TDenseSpace >::NewmarkMethod
 CKratos::ResidualBasedBossakDisplacementScheme< TSparseSpace, TDenseSpace >::NewmarkMethodNewmark parameters used for integration
 CKratos::ResidualBasedBossakScheme< TSparseSpace, TDenseSpace >::NewmarkMethod
 CKratos::NewmarkMethod< TVariableType, TValueType >::NewmarkParameters
 CKratos::NistUtils
 ►CKratos::MPIInternals::NodalContainerAccess
 CKratos::NodalDataStores all data and dofs which are stored in each elements
 CKratos::SelectElementsMesherProcess::NodalFlags
 CKratos::NodalPositionExpressionIO
 ►CKratos::HDF5::NodalSolutionStepDataIOA class for IO of nodal solution step data in HDF5
 ►CKratos::NodalUpdateBaseClass< TDim >
 ►CKratos::HDF5::NodalVariableGetter
 Cnode
 CKratos::NodeConfigure< TDimension >Configuration file for Nodes
 CKratos::NodeConfigureForNodeSearchConfiguration file for nodes
 CKratos::NodeSearchUtilityNode Search
 CKratos::ContainerDataIOTags::NonHistorical
 CKratos::MethodUtilities::NonHistoricalDataValueRetrievalFunctor< TContainerItemType >
 CKratos::CollectiveExpressionIO::NonHistoricalVariable
 CKratos::ExplicitFilterHelperUtilities::NonIntegratedWeight
 ►CKratos::NonlocalDamageUtilities
 CKratos::PetrovGalerkinROMBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::NonTrivialSumReduction< T >
 CKratos::ROMBuilderAndSolver< TSparseSpace, TDenseSpace, TLinearSolver >::NonTrivialSumReduction< T >
 Ctensors::norm
 CKratos::NormalCalculationUtils
 CKratos::UPwNormalFaceLoadCondition< TDim, TNumNodes >::NormalFaceLoadVariables
 CKratos::UPwNormalFluxFICCondition< TDim, TNumNodes >::NormalFluxFICVariables
 CKratos::PwNormalFluxCondition< TDim, TNumNodes >::NormalFluxVariables
 CKratos::UPwNormalFluxCondition< TDim, TNumNodes >::NormalFluxVariables
 CKratos::UPwLysmerAbsorbingCondition< TDim, TNumNodes >::NormalLysmerAbsorbingVariables
 Cnice_names::nset
 CKratos::Internals::NullInitialized< TObjectType >Helper class for null-initializiation
 CKratos::Internals::NullInitialized< array_1d< TValueType, ArraySize > >
 ►CKratos::NumericalIntegrationMethod
 CKratos::NurbsCurveShapeFunctionNurbsCurveShapeFunction
 CKratos::NurbsIntervalClass for optimized use of intervals
 CKratos::NurbsSurfaceRefinementUtilities
 CKratos::NurbsSurfaceShapeFunction
 CKratos::NurbsVolumeRefinementUtilities
 CKratos::NurbsVolumeShapeFunction
 CNurbsVolumeShapeFunctionsProvides the shape functions and evaluation methods for trivariant BSpline volumes
 ►Cobject
 CKratos::ObjectCounter< TCountedType >Short class definition
 CKratos::OcTreeAverageSplit< Dimension, PointType, IteratorType, CoordinateType >
 CKratos::OctreeBinary< TCellType >Short class definition
 CKratos::OctreeBinary< CellType >
 CKratos::OctreeBinaryCell< TConfiguration >This class represents a cell in an octree to be used with Octree class
 CKratos::OcTreeMidPointSplit< Dimension, PointType, IteratorType, CoordinateType >
 Code_solve.ode_solve
 CKratos::OpenMPUtilsImplements basic tasks for OpenMP parallelism and suitable scalar alternatives
 ►CKratos::OperationThe base class for all operations in Kratos
 ►CKratosMultiphysics.Operation
 Ctensors::operator(.dot.)
 Ctensors::operator(.double.)
 Ctensors::operator(.dyad.)
 ►Calgorithms.algorithm_base.OptimizationAlgorithm
 Clogger_utilities.OptimizationAlgorithmTimeLoggerA context responsible for outputting execution times
 Coptimization_analysis.OptimizationAnalysis
 Clogger_utilities.OptimizationAnalysisTimeLogger
 Coptimization_problem.OptimizationProblemThis is the main data holder for optimization problems
 CKratos::OptimizationUtilitiesShort class definition
 CKratos::OptimizationUtils
 Coptimizer_factory.Optimizer
 CKratos::CompressibleNavierStokesExplicitSolvingStrategyBFECC< TSparseSpace, TDenseSpace >::optional< T >
 CKratos::CompressibleNavierStokesExplicitSolvingStrategyBFECC< TSparseSpace, TDenseSpace >::optional< double >
 CKratos::OrientedBoundingBox< TDim >This class defines the Oriented bounding box class
 CKratos::SolidShellElementSprism3D6N::OrthogonalBaseOrthogonalBase
 ►Cline_graph_output_process.OutputControl
 ►CKM.OutputProcess
 ►CKratosMultiphysics.OutputProcess
 CKratos::PairComparor< TType1, TType2 >This is a key comparer between two indexes pairs
 CKratos::PairHasher< TType1, TType2 >This is a hasher for pairs
 CKratos::ParabolicProfileUtilitiesA set of functions to compute the Wall Shear Stress (WSS)
 CKratos::ParallelBondUtilities
 CKratos::ParallelEnvironmentHolder for general data related to MPI (or suitable serial equivalents for non-MPI runs)
 Cmeshing.meshing_utilities.ParallelepipedRegularMesher
 CKratos::ParallelUtilitiesShared memory parallelism related helper class
 ►CDEM_procedures.ParallelUtils
 Cuser_defined_parameter_field_base.ParameterFieldBaseBase class of a user defined parameter field
 CKratos::ConstitutiveLaw::Parameters
 CKratos::HardeningLaw::Parameters
 CKratos::ParametersThis class provides to Kratos a data structure for I/O based on the standard of JSON
 CKratos::ParticleHardeningLaw::Parameters
 CKratos::ParticleYieldCriterion::Parameters
 CKratos::RetentionLaw::Parameters
 CKratos::ShellCrossSection::Parameters
 CKratos::YieldCriterion::Parameters
 CKratos::ParametersUtilities
 CKratos::Particle_Data
 CKratos::ParticleConvectUtily< TDim >
 CKratos::ParticleCreatorDestructor
 ►CKratos::SphericParticle::ParticleDataBuffer
 ►CKratos::ParticleFlowRuleShort class definition
 ►CKratos::ParticleHardeningLawShort class definition
 Chdf5_io_tools.ParticleHistoryLoader
 CKratos::ParticleMechanicsMathUtilities< TDataType >
 Canalytic_tools.analytic_data_procedures.ParticlesAnalyzerClass
 CKratos::ParticlesUtilitiesCollection of utilities to compute statistic of particles
 CKratos::ParticleUtils< TDim >
 ►CKratos::ParticleYieldCriterionShort class definition
 CKratos::partitioned_vector< TVectorType >Short class definition
 ►CKratos::PartitionedFSIUtilities< TSpace, TValueType, TDim >
 CKratos::IO::PartitioningInfo
 CKratos::Tree< TPartitionType >::PartitionsClass to represent partitions for the tree
 CKratos::PeriodicConditionUtilitiesAuxiliary utilitiy to define periodic boundary conditions for flow problems
 CKratos::PeriodicVariablesContainerA container of Kratos variables used to define a periodic boundary condition
 CKratos::PermeabilityTensorCommunicatorUtility
 ►CKratos::PerturbGeometryBaseUtilityBase class for geometry perturbation utilities
 Cperturb_geometry_sparse_utility.PerturbGeometrySparseUtilityAn utility to perturb the initial geometry of a structure based on a sparse correlation matrix
 Cperturb_geometry_subgrid_utility.PerturbGeometrySubgridUtilityAn utility to perturb the initial geometry of a structure based on a reduced correlation matrix
 Cpetsc_conversion_tools.PetscCSRWrapper
 Cpfem_2_solver_fractional_step_fluid.PFEM2Solver
 Cpfem_2_solver_fsi.PFEM2Solver
 Cpfem_2_solver_fsi_2resolutions.PFEM2Solver
 Cpfem_2_solver_monolithic.PFEM2Solver
 Cpfem_2_solver_monolithic_autoslip_fluid.PFEM2Solver
 Cpfem_2_solver_monolithic_fluid.PFEM2Solver
 Cpfem_2_solver_monolithic_fluid_2scales.PFEM2Solver
 Cpfem_2_solver_monolithic_fluid_prashanth.PFEM2Solver
 CKratos::Pfem2Utils
 CKratos::PFEMFlags
 ►CPfemFluidDynamicsAnalysis.PfemFluidDynamicsAnalysis
 ►CBaseSolver.PfemFluidSolver
 CKratos::PfemGidGaussPointsContainer
 CKratos::PfemGidMeshContainer
 CKratos::PFEMMoveMeshUtilityThis utility resets the nodes of a PFEM fluid ModelPart, used especially in the PFEM-FEM coupling
 CKratos::PhaseFunctionThis class is a wrapper of useful utilities for shallow water computations
 CKratos::Plane
 CKratos::Wind::ModelSubdivisionUtilities::Slab::Plane
 CKratos::Plane3D
 CKratos::PlaneApproximationUtility< TDim >Utility to compute an approximation plane for a set of points
 CKratos::SymmetryUtility::PlaneSymmetryData
 CKratos::PlaneBoundingBox::PlaneVariables
 CKratos::AssociativePlasticDamageModel< TYieldSurfaceType >::PlasticDamageParameters
 CKratos::GenericSmallStrainPlasticDamageModel< TPlasticityIntegratorType, TDamageIntegratorType >::PlasticDamageParameters
 CKratos::FlowRule::PlasticFactors
 CKratos::NonLinearAssociativePlasticityModel< TElasticityModel, TYieldSurface >::PlasticFactors
 CKratos::ParticleFlowRule::PlasticFactors
 CKratos::HenckyElasticPlastic3DLaw::PlasticMaterialResponseVariables
 CKratos::HardeningRule::PlasticModelData< TVarSize >
 Ccellular_flow_derivative_recovery_errors.Plotter
 CKratos::ShellCrossSection::Ply
 CKratos::PointConfigure< TDimension >
 CKratos::PointDistance2< dim, T >Short class definition
 CKratos::PointerHashMapSet< TDataType, THashType, TGetKeyType, TPointerType >PointerHashMapSet is a hash implemenetation of the PointerVectorSet
 CKratos::PointerHashMapSet< GeometryType, std::hash< std::size_t >, GetGeometryId, GeometryPointerType >
 CKratos::PointerHashMapSet< ModelPart, std::hash< std::string >, GetModelPartName, Kratos::shared_ptr< ModelPart > >
 CKratos::PointerHashMapSet< TGeometryType, std::hash< std::size_t >, GetGeometryId, GeometryPointerType >
 CKratos::PointerVector< TDataType, TPointerType, TContainerType >PointerVector is a container like stl vector but using a vector to store pointers to its data
 CKratos::PointerVector< Kratos::Node >
 CKratos::PointerVector< Kratos::StatisticsSampler >
 CKratos::PointerVector< MeshType >
 CKratos::PointerVector< TPointType >
 CKratos::PointerVectorMap< TKeyType, TDataType, TCompareType, TPointerType, TContainerType >PointerVectorMap is a sorted associative container like stl map but using a vector to store pointers to its data
 CKratos::PointerVectorMap< SizeType, TableType >
 CKratos::Python::PointerVectorPythonInterface< TContainerType >
 CKratos::PointerVectorSet< TDataType, TGetKeyType, TCompareType, TEqualType, TPointerType, TContainerType >A sorted associative container similar to an STL set, but uses a vector to store pointers to its data
 CKratos::PointerVectorSet< ConditionType, IndexedObject >
 CKratos::PointerVectorSet< Dof< double >, IndexedObject >
 CKratos::PointerVectorSet< IndexedPointType, IndexedObject >
 CKratos::PointerVectorSet< Properties, IndexedObject >
 CKratos::Python::PointerVectorSetPythonInterface< TContainerType >
 ►CKratos::HDF5::PointLocatorAdaptor
 CKratos::HDF5::Internals::PointsDataA class representing points in a mesh
 Croot_finder.pol
 CKratos::PoolObjectThis redefines the new and delete operators of derived class to be allocated in pool
 CKratos::PorePressureCommunicatorUtility
 CKratos::PoroConditionUtilities
 CKratos::PoroElementUtilities
 Cfield_utilities.PorosityField
 CKratos::PorosityUtils
 CDerivatives.PorousCodina2007
 CDerivatives.PorousSinusoidalFluidFractionSolution
 CKratos::PostProcessUtilities
 CKratos::PostUtilities
 ►CDEM_procedures.PostUtils
 Cswimming_DEM_procedures.PostUtils
 Cderivative_recovery.pouliot_2012_recovery_tools.PouliotRecoveryTools
 CKratos::Pow< TOrder >
 CKratos::Pow< 1 >
 CKratos::BinaryOperations::Power
 CKratos::PQMPMPartitionUtilitiesThis class includes several utilities necessaries for the PQMPM
 CKratos::PragmaticAdaptor
 ►CKratos::Preconditioner< TSparseSpaceType, TDenseSpaceType >Preconditioner class
 ►CKratos::PreconditionerFactory< TSparseSpace, TLocalSpace >Here we add the functions needed for the registration of preconditioners
 CKratos::PreUtilities
 CDEM_material_test_script.PreUtils
 CDEM_procedures.PreUtils
 ►CPrimalElement
 CKratos::PrimeNumbersGives a prime number before or after given number
 CKratos::PrismGaussLegendreIntegrationPoints1
 CKratos::PrismGaussLegendreIntegrationPoints2
 CKratos::PrismGaussLegendreIntegrationPoints3
 CKratos::PrismGaussLegendreIntegrationPoints4
 CKratos::PrismGaussLegendreIntegrationPoints5
 CKratos::PrismGaussLegendreIntegrationPointsExt1
 CKratos::PrismGaussLegendreIntegrationPointsExt2
 CKratos::PrismGaussLegendreIntegrationPointsExt3
 CKratos::PrismGaussLegendreIntegrationPointsExt4
 CKratos::PrismGaussLegendreIntegrationPointsExt5
 CKratos::PrismGaussLobattoIntegrationPoints1
 CKratos::PrismGaussLobattoIntegrationPoints2
 Call_t_win_vs_m_fixed_error.ProblemParameters
 Ccubic_law.ProblemParameters
 Cexact_hinsberg_test.ProblemParameters
 Cinitial_time_bounds.ProblemParameters
 Cnormed_exact_hinsberg_test.ProblemParameters
 Ct_win_vs_m_fixed_error.ProblemParameters
 ►CDEM_procedures.Procedures
 ►CKM.Process
 ►CKratosMultiphysics.Process
 CKratos::ProcessFactory
 CKratos::ProcessFactoryUtilityThis is a experimental process factory utility
 ►CKratos::ProcessInfoParser
 CKratos::ProcessParameters
 CKratos::Internals::Profiler< TTimeUnit >
 CKratos::Internals::ProfilerSingleton< TTimeUnit >
 Cproject.ProjectKratos Multiphysics multistage project container
 Cswimming_DEM_procedures.ProjectionDebugUtils
 CCFD_DEM_coupling.ProjectionModule
 CKratos::ProjectionNurbsGeometryUtilities
 Calgorithms.algorithm_trust_region.Projector
 CKratos::ProjectVectorOnSurfaceUtilityShort class definition
 CKratos::FracturePropagation2DUtilities::Propagation
 CKratos::FracturePropagation3DUtilities::Propagation
 CKratos::FracturePropagation2DUtilities::PropagationGlobalVariables
 CKratos::FracturePropagation3DUtilities::PropagationGlobalVariables
 CKratos::FracturePropagation2DUtilities::PropagationLocalVariables
 CKratos::FracturePropagation3DUtilities::PropagationLocalVariables
 CKratos::ContainerDataIOTags::Properties
 CKratos::PropertiesLayoutPropertiesLayout
 CKratos::PropertiesProxiesManager
 CKratos::PropertiesProxy
 CKratos::CollectiveExpressionIO::PropertiesVariable
 CKratos::PropertiesVariableExpressionIO
 CKratos::PureConvectionCrankNUtilities< TDim, TSparseSpace, TLinearSolver >
 CKratos::PureConvectionUtilities< TDim, TSparseSpace, TLinearSolver >
 CKratos::pVariableComparatorThis is a key comparer between two variables pointers
 CKratos::pVariableHasherThis is a hasher for variables pointers
 CKratos::PyramidGaussLegendreIntegrationPoints1
 CKratos::PyramidGaussLegendreIntegrationPoints2
 CKratos::PyramidGaussLegendreIntegrationPoints3
 CKratos::PyramidGaussLegendreIntegrationPoints4
 CKratos::PyramidGaussLegendreIntegrationPoints5
 Cswimming_DEM_analysis.python_parameters
 Cpython_interface.python_registry.PythonRegistryIteratorPythonRegistry iterator class
 Cpython_solver.PythonSolverThe base class for the Python Solvers in the applications Changes to this BaseClass have to be discussed first!
 CKratos::QSVMSAdjointElementData< TDim, TNumNodes >Traits class to hold QSVMS adjoint element data
 CKratos::QSVMSDerivativeUtilities< TDim >These are helper classes to define derivatives of coefficients of Navier-Stokes
 CKratos::QSVMSResidualDerivatives< TDim, TNumNodes >::QSVMSResidualData
 CKratos::QSVMSResidualDerivatives< TDim, TNumNodes >Computes the QSVMS residual derivatives
 CKratos::QuadraticErrorFunctionUtilities to compute the minimum error point in a 3D voxel intersected by a triangle mesh This implementation is based on the algorithm explained here: https://www.mattkeeter.com/projects/qef/
 CKratos::Quadrature< TQuadraturePointsType, TDimension, TIntegrationPointType >Short class definition
 CKratos::QuadrilateralCollocationIntegrationPoints1
 CKratos::QuadrilateralCollocationIntegrationPoints2
 CKratos::QuadrilateralCollocationIntegrationPoints3
 CKratos::QuadrilateralCollocationIntegrationPoints4
 CKratos::QuadrilateralCollocationIntegrationPoints5
 CKratos::QuadrilateralGaussLegendreIntegrationPoints1
 CKratos::QuadrilateralGaussLegendreIntegrationPoints2
 CKratos::QuadrilateralGaussLegendreIntegrationPoints3
 CKratos::QuadrilateralGaussLegendreIntegrationPoints4
 CKratos::QuadrilateralGaussLegendreIntegrationPoints5
 CKratos::QuadrilateralGaussLobattoIntegrationPoints1
 CKratos::QuadrilateralGaussLobattoIntegrationPoints2
 CKratos::Quaternion< T >Quaternion A simple class that implements the main features of quaternion algebra
 CKratos::Quaternion< double >
 CKratos::Quaternion< RealType >
 CKratos::FlowRule::RadialReturnVariables
 CKratos::ParticleFlowRule::RadialReturnVariables
 CKratos::RadiationSettingsShort class definition
 CKratos::RadiusPoint< Dimension >
 Cset_mesh_motion_and_get_forces_process.SetMeshMotionAndGetForcesProcess.Motion.RampedSin
 ►Crandom_access_iterator_base
 CKratos::RandomInitializeUtility< TDataType >Utility to initialize a random vector
 Crandomized_singular_value_decomposition.RandomizedSingularValueDecompositionThis class calculates the singular value decomposition of a matrix A (A = U@np..nosp@m.diag(S)@V.T + Error(truncation_tolerance)) using a randomized algorithm Reference: Halko et al 2009
 CRandomMaterial.RandomMaterialRandom material generator class
 ►CKratos::RandomVariable
 CKratos::RankinePlasticPotential< TVoigtSize >This class defines a plastic potential following the theory of Rankine
 CKratos::RankineYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Rankine theory
 Cformulations.rans_formulation.RansFormulation
 ►CKratosRANS.RansFormulationProcess
 CKratos::RansVariableDifferenceNormsCalculationUtility< TDataType >This class is used to calculate difference norms of a given variable
 CKratos::RBFShapeFunctionsUtilityRadial Basis Functions utility to calculate shape function values This class uses Gaussian raidal basis functions to calculate the shape function values for a given value (i.e. norm of a point) with partition of unity
 CKratos::ReadAndSetAccessorsUtilities
 Cread_csv_table_utility.ReadCsvTableUtilityThis class is used to retrieve a table from the specified parameters
 CKratos::ReadMaterialsUtilityProcess to read constitutive law and material properties from a json file
 CKratos::ReadVariableFunctor< TVariable >
 ►CKratos::RealContactModel
 ►CKratos::RealField
 ►CKratos::RealFunction
 Ccellular_flow_derivative_recovery_errors.RecoveryCase
 CKratos::MesherUtilities::RefineBodyInfo
 CKratos::MesherUtilities::RefineBoundaryInfo
 CKratos::RefineConditionsInContactMesherProcess::RefineCounters
 CKratos::MesherUtilities::RefiningInfoParameters
 CKratos::MesherUtilities::RefiningParameters
 CKratos::RegisteredComponentLookup< TVariables >A class for calling a functor on a variable specified by it's registered name
 ►CKratos::Internals::RegisteredPrototypeBase< TBaseCategoryType >
 CKratos::Testing::Internals::RegisterThisTest< TestType >
 CKratos::RegistryKratos base registry This class is intended to act as global registry Each time the AddItem method is called a pair of name and prototype is called
 CKratos::RegistryAuxiliariesKratos registry auxiliaries This static class collect all the auxiliary functions to be used to register c++ items
 CKratos::RegistryItemThe registry item to be stored by Registry class. It is the base class for some more specific ones
 Conthefly_kratos_inlet_process.RegularGrid1D
 Cprojection_utilities.RegularGrid1D
 CKratos::RenumberingNodesUtility
 CKratos::Reorderer< TSparseSpaceType, TDenseSpaceType >Base class for all reorderer objects in Kratos used in linear solvers
 ►CDEM_procedures.Report
 CKratos::QSVMSResidualDerivatives< TDim, TNumNodes >::ResidualsContributionsComputes residual contributions
 Cresponse_routine.ResponseRoutineA class which adds optimization-specific utilities to simplify routines and synchronization between the control field from algorithms and analysis models
 Crestart_utility.RestartUtilityThis class collects the common functionalities needed for saving / loading restart files
 CKratos::ResultDatabaseThis class stores the results of a simulation for a later comparison
 Cswimming_DEM_procedures.ResultsFileCreator
 CKratos::ResultsProxy< TPointerDataType, TFunctorType >A template class to proxy results, whether they are locally or remotely owned
 ►CKratos::RetentionLaw
 CKratos::RetentionLawFactory
 CKratos::RetrieveGlobalPointersByIndex< TContainerType >Short class definition
 CKratos::RigidBodyElementCreationUtilityRigid body element build processes in Kratos
 CKratos::RigidBodyElement::RigidBodyProperties
 CKratos::RigidBodyUtilitiesShort class definition
 CKratos::RigidFaceGeometricalObjectConfigure< TDimension >
 CKratos::RomAuxiliaryUtilities
 CKratos::RomResidualsUtility
 CKratos::SymmetryUtility::RotationalSymmetryData
 CPID.average_field.Rotator
 Crunge_kutta_frac_step_solver.RungeKuttaFracStepSolver
 CKratos::RVEPeriodicityUtilityThis defines a class to define periodic BC to a RVE
 ►CSampling_Methods.Sampling_method_base
 CKratos::SamplingTool
 Csand_production_post_process_tool.SandProductionPostProcessTool
 CKratos::SandProductionUtilities
 Csave_variables_utility.SaveVariablesUtility
 CKratos::ContactDomainUtilities::ScalarBaseType
 ►CKratos::ScalarWallFluxConditionData
 Cspreader.scanner
 ►CKratos::Scheme< TSparseSpace, TDenseSpace >This class provides the implementation of the basic tasks that are needed by the solution strategy
 CKratos::SchemeFactory< TSparseSpace, TDenseSpace >
 CKratos::Internals::Profiler< TTimeUnit >::ScopeRAII wrapper for updating an Item
 ►CKratos::Testing::ScopedEntry
 CKratos::ScopedOutputFileAccess
 Cswimming_DEM_analysis.SDEMLogger
 CKratos::SearchBasedFunctionsShort class definition
 CKratos::SearchUtils::SearchBoxInRange< TPointType, TIteratorType, TSizeType, TDimension, TResultIteratorType >
 Cembedded.SearchEmbeddedDEMTools
 CKratos::SearchUtils::SearchNearestInRange< TPointType, TPointerType, TIteratorType, TDistanceFunction, TCoordinateType >
 CKratos::SearchUtils::SearchRadiusInRange< TPointType, TIteratorType, TDistanceIteratorType, TDistanceFunction, TSizeType, TCoordinateType, TResultIteratorType >
 CKratos::SearchStructure< IndexType, SizeType, CoordinateType, IteratorType, IteratorIteratorType, Dimension >
 CKratos::SearchStructurePeriodic< IndexType, SizeType, CoordinateType, IteratorType, IteratorIteratorType, Dimension >
 CKratos::SearchUtilitiesMPI utilities for searching geometrical objects
 CKratos::QSVMSResidualDerivatives< TDim, TNumNodes >::SecondDerivatives< TComponentIndex >Computes second derivatives of the QS VMS residual
 CKratos::SecondOrderVectorVariable
 CKratos::IgaMembraneElement::SecondVariations
 CKratos::Shell3pElement::SecondVariations
 CKratos::ShellCrossSection::SectionParametersSectionParameters
 CKratos::BeamElement::SectionProperties
 CKratos::SmallDisplacementBeamElement3D2N::SectionProperties
 ►CBaseSolver.SegregatedSolver
 CKratos::MPIInternals::SendTools< TValue >
 CKratos::MPIInternals::SendTools< DenseVector< TVectorValue > >
 CKratos::MPIInternals::SendTools< Kratos::VariablesListDataValueContainer >
 CKratos::MPIInternals::SendTools< Node::DofsContainerType >
 CKratos::MPIInternals::SendTools< Quaternion< double > >
 CKratos::MPIInternals::SendTraits< ValueType >
 CKratos::MPIInternals::SendTraits< array_1d< double, TDim > >
 CKratos::MPIInternals::SendTraits< bool >
 CKratos::MPIInternals::SendTraits< DenseVector< TVectorValue > >
 CKratos::MPIInternals::SendTraits< double >
 CKratos::MPIInternals::SendTraits< int >
 CKratos::MPIInternals::SendTraits< Kratos::Flags >
 CKratos::MPIInternals::SendTraits< Kratos::VariablesListDataValueContainer >
 CKratos::MPIInternals::SendTraits< Matrix >
 CKratos::MPIInternals::SendTraits< Node::DofsContainerType >
 CKratos::MPIInternals::SendTraits< Quaternion< double > >
 CKratos::MPIInternals::SendTraits< Vector >
 CKratos::SensitivityBuilder
 ►CKratos::SensitivityBuilderSchemeScheme used in the Sensitivity Builder
 ►Cloggers.sensitivity_heatmap_logger.SensitivityHeatmapLoggerBase
 CKratos::SensitivityUtilities
 CKratos::SensitivityBuilder::SensitivityVariables< TDataType >Contains the sensitivity design and output variables
 CKratos::ShapeParameter::Sequence
 ►CKratos::SerializerThe serialization consists in storing the state of an object into a storage format like data file or memory buffer and also retrieving the object from such a media
 Csensitivity_builder_cpp::SetHistoricalValueToZeroFunctor< TDataType >
 CKratos::SetIdentityFunction< TDataType >A functor that serves as the identity function
 Csensitivity_builder_cpp::SetNonHistoricalValueToZeroFunctor< TDataType >
 ►CDEM_procedures.SetOfModelParts
 CKratos::ModelPartHelperUtils::SetReduction< TDataType >
 CKratos::SetThermalDataUtilities
 CKratos::UPwSmallStrainInterfaceElement< TDim, TNumNodes >::SFGradAuxVariables
 CKratos::ShallowWaterUtilitiesThis class is a wrapper of useful utilities for shallow water computations
 Ccustom_ios.wrl_reader.Shape
 CKratos::ShapeAtDeviatoricPlaneMCCUtility
 CKratos::ShapeParameter
 CKratos::SharedPointerComparator< TSharedPointer >This is a key comparer between two shared pointers
 CKratos::SharedPointerHasher< TSharedPointer >This is a hasher for shared pointers
 CKratos::SharedPointsMapperShort class definition
 ►CKratos::ShellQ4_CoordinateTransformationShellQ4_CoordinateTransformation
 CKratos::ShellQ4_LocalCoordinateSystemShellQ4_LocalCoordinateSystem
 ►CKratos::ShellT3_CoordinateTransformationShellT3_CoordinateTransformation
 CKratos::ShellT3_LocalCoordinateSystemShellT3_LocalCoordinateSystem
 CKratos::ShiftedBoundaryMeshlessInterfaceUtilityUtilities for the SBM-WTE extension operator calculation This class encapsulates several utilities for the calculation of the extension operator in the Shifted Boundary Method Without Taylor Expansions
 Csymbolic_generation.compressible_navier_stokes.src.symbolic_parameters.ShockCapturingNodalParameters
 Csymbolic_generation.compressible_navier_stokes.src.symbolic_parameters.ShockCapturingParameters
 CKratos::ShockCapturingPhysicsBasedProcess::ShockCapturingTLSContainer2D3NType for the 2D (linear triangle) TLS geometry data
 CKratos::ShockCapturingPhysicsBasedProcess::ShockCapturingTLSContainer3D4NType for the 3D (linear tetrahedra) TLS geometry data
 CKratos::SigmoidalProjectionUtils
 Ctensors::sign1
 CKratos::SignedDistanceCalculationUtils< TDim >
 Ctopology_optimizer_factory.SIMPMethod
 CKratos::SingleImportModelPart
 ►CKratos::Wind::ModelSubdivisionUtilities::SlabA subset of R^3 between two parallel planes
 Cmapping.sliding_vertex_morphing_mapper.SlidingVertexMorphingMapperThe SlidingVertexMorphingMapper extends the standard Vertex Morphing approach by restricting the nodal shape update of a specified model part
 CKratos::SolidMechanicsMathUtilities< TDataType >
 ►Csolitary_wave_utilities.SolitaryWaveSolutionBase class for analytical solutions of a solitary wave
 CKratosSwimmingDEMPFEM.Solution
 ►Cmain_script.Solution
 ►CMainSolid.Solution
 ►CMainSolidFEM.Solution
 Cschemes_factory.SolutionScheme
 CKratos::SolverLocalFlagsSolver local flags class definition
 ►CKratos::SolverSettings< TSparseSpace, TDenseSpace, TLinearSolver >Helper class to define solution strategies for FS_Strategy
 CProjectParameters.SolverSettings
 CProjectParameters.SolverSettings1
 CProjectParameters.SolverSettings2
 ►CKratos::SolvingStrategy< TSparseSpace, TDenseSpace >Solving strategy base class This is the base class from which we will derive all the strategies (implicit and explicit)
 CKratos::SolvingStrategyFactory< TSparseSpace, TDenseSpace, TLinearSolver >
 Cstrategy_python.SolvingStrategyPython
 Cstrategy_python_nonlinear.SolvingStrategyPython
 ►CKratos::SpaceTimeRule
 CKratos::SpaceTimeSet
 CKratos::SpaceType< Scalar >
 CKratos::SpaceType< double >
 CKratos::SpaceType< std::complex< double > >
 CKratos::SparseContiguousRowGraph< TIndexType >Short class definition
 CKratos::SparseContiguousRowGraph< IndexType >
 CKratos::SparseGraph< TIndexType >Short class definition
 CKratos::SparseMatrixMultiplicationUtilityAn utility to multiply sparse matrix in Ublas
 ►CKratos::SpatialBoundingBoxShort class definition
 CKratos::SpatialContainersConfigure< TDimension, TEntity >Thhis class is a container for spatial search
 ►Cspatial_utilities.SpatialMethodOutput
 ►CKratos::SpatialSearchThis class is used to search for elements, conditions and nodes in a given model part
 CKratos::SpatialSearchResult< TObjectType >This class is the result of the spatial searches
 CKratos::ExplicitSolverStrategy::SpatialSortingTraits
 CKratos::SpecificationsUtilitiesThis namespace includes several utilities necessaries for evaluate specifications
 CKratos::SphericElementGlobalPhysicsCalculator
 CKratos::SplineCurveUtilitiesShort class definition
 CKratos::SplineCurveUtilities::SplineType
 CKratos::SplitTetrahedraUtilities
 CKratos::SearchUtils::SquaredDistanceFunction< TDimension, TPointType >
 ►CNavierMonolithic.StabilizedFormulation
 CKratos::StationarityChecker
 CKratos::StatisticsDataInternal container for integration point statistitcs on a given element
 CKratos::StatisticsRecordMain class for online statistics calculation
 ►CKratos::StatisticsSamplerBase class for statistical measurements
 CSurfaceTension_monolithic_solver.STMonolithicSolver
 CKratos::HyperElasticModel::StrainData
 CKratos::HyperElasticModel::StrainEigenData
 CKratos::StrainEnergyResponseFunctionUtilityShort class definition
 CKratos::HyperElasticModel::StrainInvariants
 CKratos::Internals::StrainRateSpecialization< TElementData, TDim >
 CKratos::Internals::StrainRateSpecialization< TElementData, 2 >
 CKratos::Internals::StrainRateSpecialization< TElementData, 3 >
 ►CKratos::StrategyWrapper
 CKratos::StreamlinesOutput3DUtilities
 Cstreamlines_output_utility.StreamlinesOutputUtility
 CKratos::StressCalculationStressCalculation
 CKratos::StressFailureCheckUtilitiesNote: For the moment this only works for cylindrical probes with its axis oriented in Z direction
 Cstress_failure_check_utility.StressFailureCheckUtility
 CKratos::SolidShellElementSprism3D6N::StressIntegratedComponentsStress integrated Components used during the integration
 CKratos::StressInvariantsUtilities
 CKratos::StressStrainUtilities
 CKratos::StructuralMechanicsMathUtilities
 CKratos::StructureResponseFunctionUtilitiesSolution utility to compute structural analysis responses
 Ccollect_stages.Sub_model_part
 CKratos::SubBinAxis< IndexType, SizeType >TOOLS UTILS ///
 CKratos::SubBinAxisPeriodic< IndexType, SizeType >TOOLS UTILS ///
 ►Cdl.SubDomain
 Conthefly_kratos_inlet_process.SubGrid1D
 CKratos::SubModelPartEntitiesBooleanOperationUtility< TEntityType, TContainerType >Wrapper of boolean operations: union, intersection and difference
 CKratos::SubReduction< TDataType, TReturnType >
 CKratos::ExplicitSolvingStrategyBFECC< TSparseSpace, TDenseSpace >::SubstepData
 CKratos::BinaryOperations::Substraction
 CKratos::UnaryStatisticOperations::Sum
 CKratos::SumReduction< TDataType, TReturnType >Utility function to do a sum reduction
 Canalytic_tools.analytic_data_procedures.SurfaceAnalyzer
 CKratos::ContactDomainUtilities::SurfaceBase
 Canalytic_tools.analytic_data_procedures.SurfacesAnalyzerClass
 CKratos::BeamPointRigidContactCondition::SurfaceScalar
 CKratos::ContactDomainUtilities::SurfaceScalar
 CKratos::PointRigidContactCondition::SurfaceScalar
 CKratos::BeamPointRigidContactCondition::SurfaceVector
 CKratos::ContactDomainUtilities::SurfaceVector
 CKratos::PointRigidContactCondition::SurfaceVector
 CKratos::SVDUtils< TDataType >Various mathematical utilities to compute SVD and the condition number of a matrix
 CKratos::SwimmingDemInPfemUtils
 ►CKratos::SymmetryBase
 CKratos::SymmetryUtilityShort class definition
 CKratos::SystemVector< TDataType, TIndexType >Provides a SystemVector which implements FEM assemble capabilities, as well as some vector operations
 CKratos::Table< TArgumentType, TResultType, TResultsColumns >This class represents the value of its variable depending to other variable
 CKratos::Table< double >
 CKratos::Table< double, double >
 CKratos::TableKeyVariables< TArgumentType, TResultType >TableKeyVariables
 CKratos::TableKeyVariables< double, double >
 CKratos::TableStreamThis is a fancy table to stream data in a fancy way
 CKratos::TableStreamUtility
 Cplot_variables.tangential_force_plotter
 CKratos::BeamPointRigidContactLM3DCondition::TangentialContactVariables
 CKratos::BeamPointRigidContactPenalty3DCondition::TangentialContactVariables
 CKratos::PointRigidContactPenalty2DCondition::TangentialContactVariables
 CKratos::TangentOperatorCalculatorUtilityAn algorithm that derives numerically the constitutive tangent tensor at one GP
 Ctaylor_green_cell.taylor_green_vector_field
 ►CTBaseElement
 ►CTBaseExplicitStrategy
 ►CTBaseStrategy
 ►CTBaseVertexMorphingMapper
 ►CTElasticBehaviourLaw
 ►Cutils.templateRule.TemplateRule
 CTemporalA temporal controller to control behavior based on temporal values
 CKratos::TemporalMethods::TemporalMaxMethod< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 CKratos::TemporalMethods::TemporalMeanMethod< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 ►CKratos::TemporalMethods::TemporalMethod
 CKratos::TemporalMethods::TemporalMinMethod< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 CKratos::TemporalMethods::TemporalRootMeanSquareMethod< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 CKratos::TemporalMethods::TemporalSumMethod< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 CKratos::TemporalMethods::TemporalVarianceMethod< TContainerType, TContainerItemType, TDataRetrievalFunctor, TDataStorageFunctor >
 CKratos::TesselationUtilities2D
 CKratos::TesselationUtilities3D
 ►CKratos::Testing::TestCaseThe test case base class
 ►CKratosUnittest.TestCase
 ►CUnitTest.TestCase
 CKratos::Testing::TestCaseResultThe test case base class
 CKratos::Testing::TesterTester class manages all tests and provide interface to run them
 CKratosUnittest.TestLoader
 ►CUnitTest.TestSuite
 CKratos::CalculateSignedDistanceTo3DConditionSkinProcess::TetEdgeStruct
 CKratos::CalculateSignedDistanceTo3DSkinProcess::TetEdgeStruct
 CKratos::TetGenCDTShort class definition
 CKratos::TetGenPfemContactShort class definition
 ►CKratos::TetGenPfemModelerShort class definition
 CKratos::TetGenPfemRefineFaceShort class definition
 CKratos::TetgenVolumeMesherThis class performs the (constrained) Delaunay meshing of the internal volume given a surface discretized in terms of triangular conditions
 CKratos::TetrahedraBallStores a ball of tetrahedra sourronding a node of mesh
 CKratos::TetrahedraEdgeShellThis class defines an edge shell for a mesh of tetrahedra
 CKratos::TetrahedraReconnectUtilityShort class definition
 CKratos::TetrahedraSplitThis class performs the splitting of a tetrahedra. It contains three helper functions to ease the splitting: TetrahedraSplitMode, Split_Tetrahedra, and TetrahedraGetNewConnectivityGID
 CKratos::TetrahedronGaussLegendreIntegrationPoints1
 CKratos::TetrahedronGaussLegendreIntegrationPoints2
 CKratos::TetrahedronGaussLegendreIntegrationPoints3
 CKratos::TetrahedronGaussLegendreIntegrationPoints4
 CKratos::TetrahedronGaussLegendreIntegrationPoints5
 ►CTextTestResult
 ►CTFluidData
 ►CKratos::ThermalDEMIntegrationScheme
 CKratos::ThermalDruckerPragerYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Drucker-Prager theory
 CKratos::ThermalModifiedMohrCoulombYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Modified Mohr-Coulumb theory
 CKratos::ThermalMohrCoulombYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Von-Mises theory
 CKratos::ThermalRankineYieldSurface< TPlasticPotentialType >
 CKratos::ThermalSimoJuYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Simo-Ju theory
 CKratos::ThermalTrescaYieldSurface< TPlasticPotentialType >
 CKratos::FlowRule::ThermalVariables
 CKratos::NonLinearAssociativePlasticityModel< TElasticityModel, TYieldSurface >::ThermalVariables
 CKratos::ParticleFlowRule::ThermalVariables
 CKratos::ThermalVonMisesYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Von-Mises theory
 CKratos::UpdatedLagrangianUPressureElement::ThisElementData
 CKratos::ThreadFixedSizeMemoryPoolThreadFixedSizeMemoryPool holds chunks belong to a certain thread and operate over them
 Csolver_wrappers.kratos.kratos_base_wrapper.ThreadManagerClass for setting and ressting the number of threads a context should use
 CKratos::Wind::ModelSubdivisionUtilities::ThreadSafeIndexSet
 Ctime_based_ascii_file_writer_utility.TimeBasedAsciiFileWriterUtilityThis utility handles a file to which results are to be written
 CDerivatives.TimeDependantFluidFractionSolution
 ►CKratos::TimeIncrementor
 CKratos::TimeIntegrationLocalFlagsSolver local flags class definition
 CKratos::TimeIntegrationMethodsContainer< TVariableType, TValueType >
 Clogger_utilities.TimeLoggerA context responsible for outputting execution times
 ►CKratos::TimeLoopExecutorInterface
 CKratos::TimeDiscretizationProcessTimeDiscretizationProcess::TimeParameters
 CKratos::TimerThis utility can be used to compute the time employed on computations
 Ctimer.Timer
 Cutilities.custom_timer.Timer
 CKratos::TimeStepEndState
 CKratos::TimeStepExecutor
 Ctime_step_testing_stage.TimeStepTester
 CKratos::ExplicitCentralDifferencesScheme< TSparseSpace, TDenseSpace >::TimeVariablesThis struct contains the details of the time variables
 CKratos::ExplicitHamiltonScheme< TSparseSpace, TDenseSpace >::TimeVariables
 CKratos::ExplicitMultiStageKimScheme< TSparseSpace, TDenseSpace >::TimeVariablesThis struct contains the details of the time variables
 CKratos::SimpleMortarMapperProcess< TDim, TNumNodes, TVarType, TNumNodesMaster >::TLSAuxiliar struct for mapping
 Ccore.xdmf.TopologyCellTypeA helper class for identifying the cell/element topology type
 CKratos::TopologyFilteringUtilitiesSolution utility to filter results
 CKratos::TopologyUpdatingUtilitiesSolution utility that updates response values for next iteration
 CKratos::ShockCapturingEntropyViscosityProcess::TotalDerivativeUtilSmall utility to compute the total derivative of a magnitude
 Ctensors::tr
 CKratos::MeshDataTransferUtilities::TransferParameters
 Ctransfer_selfweight_stress_utility.TransferSelfweightStressToMainModelPartUtility
 CKratos::TransferSelfweightStressUtility
 CKratos::SolidShellElementSprism3D6N::TransverseGradientTransverseGradient
 CKratos::SolidShellElementSprism3D6N::TransverseGradientIsoParametricTransverseGradientIsoParametric
 CKratos::Tree< TPartitionType >A generic tree data structure for spatial partitioning
 CKratos::TreeNode< TDimension, TPointType, TPointerType, TIteratorType, TDistanceIteratorType, TIteratorIteratorType >Short class definition
 ►CKratos::TreeNode< TDimension, TPointType, typename TContainerType::value_type, typename TContainerType::iterator, typename std::vector< double >::iterator >
 ►CKratos::TreeNode< TDimension, TPointType, typename TContainerType::value_type, typename TContainerType::iterator, typename std::vector< double >::iterator, std::vector< typename TContainerType::value_type >::iterator >
 ►CKratos::TreeNode< TLeafType::Dimension, TLeafType::PointType, TLeafType::PointerType, TLeafType::IteratorType, TLeafType::DistanceIteratorType >
 CKratos::TrescaPlasticPotential< TVoigtSize >This class defines a plastic potential following the theory of Tresca
 CKratos::TrescaStressInvariants
 CKratos::TrescaYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Tresca theory
 CKratos::TriangleCollocationIntegrationPoints1
 CKratos::TriangleCollocationIntegrationPoints2
 CKratos::TriangleCollocationIntegrationPoints3
 CKratos::TriangleCollocationIntegrationPoints4
 CKratos::TriangleCollocationIntegrationPoints5
 CKratos::TriangleGaussLegendreIntegrationPoints1
 CKratos::TriangleGaussLegendreIntegrationPoints2
 CKratos::TriangleGaussLegendreIntegrationPoints3
 CKratos::TriangleGaussLegendreIntegrationPoints4
 CKratos::TriangleGaussLegendreIntegrationPoints5
 CKratos::TriangleGaussRadauIntegrationPoints1
 CKratos::TriangleGaussRadauIntegrationPoints2
 CKratos::TriangleGaussRadauIntegrationPoints3
 CKratos::TriangleGaussRadauIntegrationPoints4
 CKratos::TriangleGaussRadauIntegrationPoints5
 CKratos::TriangleGaussRadauIntegrationPoints6
 CKratos::TriangleSplit
 CKratos::TriGenCDTShort class definition
 CKratos::TriGenDropletModelerShort class definition
 CKratos::TriGenGLASSModelerShort class definition
 CKratos::TriGenModelerShort class definition
 ►CKratos::TriGenPFEMModelerShort class definition
 CKratos::TriGenPFEMRefineSegmentShort class definition
 CKratos::TrilinosAssemblingUtilitiesThe Trilinos assembling utilities
 CKratos::TrilinosCuttingApplicationTRILINOS CUTTING APPLICATION
 CKratos::TrilinosCuttingIsosurfaceApplication
 CKratos::TrilinosJacobianEmulator< TSpace >Jacobian emulator
 CKratos::TrilinosJacobianEmulator< TSparseSpace >
 CKratos::TrilinosRefineMesh
 CKratos::TrilinosSpace< TMatrixType, TVectorType >The space adapted for Trilinos vectors and matrices
 ►CTSubAssemblyType
 CKratos::Tvector< T, TDimension >Short class definition
 CKratos::Tvector< CoordinateType, Dimension >
 CKratos::Tvector< SizeType, Dimension >
 ►CKratos::TwoStepVPSolverSettings< TSparseSpace, TDenseSpace, TLinearSolver >Helper class to define solution strategies for TwoStepVPStrategy
 ►Cstd::conditional::type
 ►Cstd::conditional::type
 ►Cstd::conditional::type
 ►Cstd::conditional::type
 CKratos::UblasSpace< TDataType, TMatrixType, TVectorType >A class template for handling data types, matrices, and vectors in a Ublas space
 CKratos::UblasWrapper< TScalar, TEigenSparseMatrix >
 CKratos::UblasWrapper< typename TSolverType::Scalar >
 Cnice_names::ueldef
 CKratos::UpdatedLagrangianUJPElement::UJPElementData
 Culf_frac.ULF_FSISolver
 Culf_fsi.ULF_FSISolver
 Culf_fsi_inc.ULF_FSISolver
 Culf_PGLASS.ULF_FSISolverTHIS FUNCTION STORES THE NODES OF THE SECOND MOULD IN A SEPARATE SUBPART (THAT WILL BE DISACTIVATED IN THE STEPS OF THE FIRST BLOW) THE NODES OF THE SECOND MOULD ARE DISTINGUISHED BY THE FLAG def CreateSubModelPartsFirstSecondBlow(total_model_part, second_mould_flag_value): init_domain_model_part=total_model_part.CreateSubModelPart("InitialDomain"); second_mould_model_part=total_model_part.CreateSubModelPart("SecondMould"); for node in total_model_part.Nodes: if (node.GetSolutionStepValue(FLAG_VARIABLE)==second_mould_flag_value): second_mould_model_part.AddNode(node, 0 ); else: init_domain_model_part.AddNode(node, 0 );
 Culf_frac_strategy.ULFFracStrategyPython
 Culf_strategy_PGLASS.ULFStrategyPython
 Culf_strategy_python.ULFStrategyPython
 Culf_strategy_python_inc.ULFStrategyPythonInc
 Culf_strategy_python_inc_rigid.ULFStrategyPythonInc
 CKratos::UlfUtils
 CKratos::SmallStrainUmatModel::UmatModelData
 Cbase_classes.co_simulation_coupled_solver.UndefinedSolver
 CKratos::UniformRefinementUtilityThis class splits all the elements until NUMBER_OF_DIVISIONS reaches the desired value @detail A node is added on the middle of each edge (and an extra node is added inside the quadrilaterals and tetrahedrons) and the nodal values are interpolated Once the element is split, the NUMBER_OF_DIVISIONS variable in increased by one Each division will create the following entities and delete the origin entity: Lines: 2 new lines Triangles: 4 new triangles (mesh quality is conserved) Quadrilaterals: 4 new quadrilaterals (mesh quality is conserved) Tetrahedrons: 8 new tetrahedrons (mesh quality is not conserved) Hexahedrons: 8 new hexahedrons (mesh quality is conserved) It only works with linear elements The splitting keeps the sub model parts
 Ctensors::unit
 CKratos::UniversalFileIOShort class definition
 ►Cstd::unordered_map
 ►Cstd::unordered_set
 CKratos::UnvOutputProvides a tool to write UNV files
 CKratos::FracturePropagation2DUtilities::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::FracturePropagation3DUtilities::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::InitialStress2DUtilities::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::InitialStress3DUtilities::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::InterpolateSwToPfemUtility::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::MappingVariables2DUtilities::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::MappingVariables3DUtilities::UtilityVariablesBasic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------—
 CKratos::SparseMatrixMultiplicationUtility::value_type< T, Enable >Metafunction that returns value type of a matrix or a vector type
 ►Cloggers.value_logger_base.ValueLogger
 Cplot_variables.variable_plotter
 CKratos::Python::VariableChecker
 CKratos::VariableComparatorThis is a key comparer between two variables
 ►CKratos::VariableDataThis class is the base of variables and variable's components which contains their common data
 CKratos::VariableDatabaseThis class stores the results of a variable
 CKratos::LineOutputProcessUtilities::VariableDataCollector< TDataType >Class to get variable information
 CKratos::QSVMSResidualDerivatives< TDim, TNumNodes >::VariableDerivatives< TDerivativesType >Computes QS VMS residual derivative residuals for given variable
 CKratos::VariableExpressionDataIO< TDataType >Construct class to read into expressions from templated data values and write in to templated data values
 CKratos::VariableExpressionIO
 CKratos::VariableHasherThis is a hasher for variables
 CKratos::Python::VariableIndexingPython< TContainerType, TVariableType >Short class definition
 CKratos::VariableRedistributionUtilityHelper utility to transform between point-wise nodal variables and distributed values
 CKratos::VariablesListHolds a list of variables and their position in VariablesListDataValueContainer
 CKratos::VariablesListDataValueContainerA shared variable list gives the position of each variable in the containers sharing it
 Cvariables_management.VariablesManager
 CKratos::VariablesUtilities
 CKratos::VariableUtilsThis class implements a set of auxiliar, already parallelized, methods to perform some common tasks related with the variable values and fixity
 CKratos::ConstitutiveModelData::VariableValue< T >
 CKratos::ConstitutiveModelData::VariableValue< double >
 CKratos::ConstitutiveModelData::VariableValue< int >
 CKratos::ConstitutiveModelData::VariableValue< Kratos::array_1d< double, 3 > >
 CKratos::ConstitutiveModelData::VariableValue< Kratos::array_1d< double, 6 > >
 CKratos::ConstitutiveModelData::VariableValue< Kratos::Internals::Matrix >
 CKratos::ConstitutiveModelData::VariableValueData
 CKratos::Shell5pElement::VariationVariables
 CCSharpKratosWrapper::Vector3
 ►Cboost::numeric::ublas::vector_expression
 CKratos::VectorField< TDim >
 ►CKratos::VectorField< 3 >
 CKratos::VectorIndexComparor< TVectorIndex >This is a key comparer between two vectors of indexes
 CKratos::VectorIndexHasher< TVectorIndex >This is a hasher between two vectors of indexes
 CKratos::HenckyElasticPlastic3DLaw::VectorSplit
 CKratos::HyperElasticPlastic3DLaw::VectorSplit
 CKratos::HyperElasticUP3DLaw::VectorSplit
 CKratos::VisualizationUtilities
 CKratos::VolumeAveragingTool< TDim >This class is designed to manage the volume averaging of DEM properties and their projection onto a mesh
 CKratos::VonMisesPlasticPotential< TVoigtSize >This class defines a plastic potential following the theory of Von Mises
 CKratos::VonMisesYieldSurface< TPlasticPotentialType >This class defines a yield surface according to Von-Mises theory
 CKratos::VorticityUtilities< TDim >A set of functions to compute quantities of interest for turbulent flows
 CKratos::VtkDefinitions
 Cdem_vtk_output.VtkOutput
 CKratos::WaterFluxes
 ►CKratos::WaterPressureUtilities
 ►Cwave_theory_utilities.WaveTheoryBase class for waves calculations
 CKratos::WeakPointerVector< TDataType, TPointerType, TContainerType >WeakPointerVector is a container like stl vector but using a vector to store pointers to its data
 CKratosUnittest.WorkFolderScopeHelper-class to execute test in a specific target path
 CKratos::HDF5::WriteInfoStores information about a dataset written to HDF5
 CKratos::WriteVariableFunctor< TVariable >
 Ccustom_ios.wrl_io.WrlIO
 CKratos::WssStatisticsUtilitiesA set of functions to compute the Wall Shear Stress (WSS)
 CKratos::XmlExpressionElement
 ►CKratos::XmlOStreamWriter
 ►CKratos::YieldCriterionShort class definition
 ►CKratos::YieldSurface< THardeningRule >Short class definition
 CKratos::ZeroDerivatives< TNumNodes, TBlockSize >This provides zero derivatives for given any variable
 CKratos::HDF5::Detail::ZeroInitialized< TValue >
 CKratos::HDF5::Detail::ZeroInitialized< array_1d< TValue, ArraySize > >
 CKratos::HDF5::Detail::ZeroInitialized< Matrix< TValue > >
 ►CABC
 ►CABCMeta
 ►CAdjointFluidSolver
 ►CAdjointMonolithicSolver
 ►CAleFluidSolver
 ►CAlgorithm
 ►CAlgorithm
 ►CAnalysisStage
 ►CAnalyzerBaseClass
 ►CApplyMPMParticleDirichletConditionProcess
 ►CApplyMPMParticleNeumannConditionProcess
 ►CAssignMasterSlaveConstraintsToNeighboursProcess
 ►CAssignModulusAndDirectionToConditionsProcess
 ►CAssignScalarToNodesProcess
 ►CAssignScalarToNodesProcess
 ►CAssignVectorComponentsToNodesProcess
 ►CAssignVectorComponentsToNodesProcess
 ►CBaseBenchmarkProcess
 ►CCheckScalarBaseProcess
 ►CComputeDragAndMomentProcess
 ►CComputeDragProcess
 ►CComputeLiftProcess
 ►CControl
 ►CConvectionDiffusionAnalysis
 ►CConvectionDiffusionStationarySolver
 ►CConvectionDiffusionTransientSolver
 ►CCoSimulationConvergenceAccelerator
 ►CCoSimulationConvergenceCriteria
 ►CCoSimulationCoupledSolver
 ►CCoSimulationCouplingOperation
 ►CCoSimulationDataTransferOperator
 ►CCoSimulationIO
 ►CCoSimulationPredictor
 ►CCoSimulationSolverWrapper
 ►CCoupledFluidThermalSolver
 ►CDEMAnalysisStage
 ►CDesignLogger
 ►CEnum
 ►CExecutionPolicy
 ►CFluidDEMSolver
 ►CFluidDynamicsAnalysis
 ►CFluidSolver
 ►CFluidTransportAnalysis
 ►CFluidTransportSolver
 ►CGiDOutputProcess
 ►CHelmholtzSolverBase
 ►CImplicitMechanicalSolver
 ►CJsonOutputProcess
 ►CLineGraphOutputProcess
 ►CMacDonaldShockBenchmark
 ►CManufacturedSolution
 ►CMapping
 ►CMapping
 ►CMechanicalSolver
 ►CMeshController
 ►CMeshSolverBase
 ►CMmgProcess
 ►CModelPartController
 ►CMoveParticleUtilityProcess
 ►CMPMImplicitDynamicSolver
 ►CMPMSolver
 ►CMultiaxialControlModuleGeneralized2DUtility
 ►CMultiplePointsOutputProcess
 ►CNavierStokesSolverFractionalStep
 ►CNavierStokesSolverMonolithic
 ►CNavierStokesTwoFluidsSolver
 ►COptimizationAlgorithm
 ►COrchestrator
 ►CParameterFieldBase
 ►CParticleVtkOutputProcess
 ►CPartitionedFSIBaseSolver
 ►CPFEM2BaseSolver
 ►CPfemFluidDynamicsAnalysis
 ►CPfemFluidSolver
 ►CPotentialFlowFormulation
 ►CPotentialFlowSolver
 ►CPythonMapper
 ►CPythonSolver
 ►CRansFormulation
 ►CResponseFunction
 ►CResponseFunctionInterface
 ►CResponseRoutine
 ►CRestartUtility
 ►CSaveRestartProcess
 ►CScalarTurbulenceModelRansFormulation
 ►CShallowWaterBaseSolver
 ►CStabilizedFormulation
 ►CStaticMechanicalSolver
 ►CStructuralMechanicsAnalysis
 ►CSwimmingDEMAnalysis
 ►CThermalDEMAnalysis
 ►CTrilinosMechanicalSolver
 ►CTrilinosMeshSolverBase
 ►CTwoEquationTurbulenceModelRansFormulation
 ►CUPwSolver
 ►CValueLogger
 ►CWaveSolver
Generated on Sat Feb 3 2024 03:37:01 for KratosMultiphysics by doxygen 1.9.1