 |
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.
|
| ►Nadaptative_remeshing_contact_structural_mechanics_analysis | |
| CAdaptativeRemeshingContactStructuralMechanicsAnalysis | This class is the main-script of the ContactStructuralMechanicsApplication when using adaptative remeshing put in a class |
| ►Nadaptative_remeshing_contact_structural_mechanics_implicit_dynamic_solver | |
| CAdaptativeRemeshingContactImplicitMechanicalSolver | The contact structural mechanics implicit dynamic solver |
| ►Nadaptative_remeshing_contact_structural_mechanics_static_solver | |
| CAdaptativeRemeshingContactStaticMechanicalSolver | The structural mechanics static solver |
| ►Nadaptative_remeshing_contact_structural_mechanics_utilities | |
| CAdaptativeRemeshingContactMechanicalUtilities | These are common utilities for adaptative remeshing (for contact) |
| ►Nadaptative_remeshing_structural_mechanics_analysis | |
| CAdaptativeRemeshingStructuralMechanicsAnalysis | This class is the main-script of the StructuralMechanicsApplication when using adaptative remeshing put in a class |
| ►Nadaptative_remeshing_structural_mechanics_implicit_dynamic_solver | |
| CAdaptativeRemeshingImplicitMechanicalSolver | The structural mechanics implicit dynamic solver |
| ►Nadaptative_remeshing_structural_mechanics_static_solver | |
| CAdaptativeRemeshingStaticMechanicalSolver | The structural mechanics static solver |
| ►Nadaptative_remeshing_structural_mechanics_utilities | |
| CAdaptativeRemeshingMechanicalUtilities | These are common utilities for adaptative remeshing |
| ►Nadjoint_diffusion_solver | |
| CAdjointDiffusionSolver | |
| ►Nadjoint_fluid_analysis | |
| CAdjointFluidAnalysis | Main script for adjoint sensitivity optimization in fluid dynamics simulations |
| ►Nadjoint_fluid_solver | |
| CAdjointFluidSolver | |
| ►Nadjoint_monolithic_solver | |
| CStabilizedAdjointFormulation | Helper class to define stabilization-dependent parameters |
| CAdjointMonolithicSolver | |
| ►Nale_fluid_solver | |
| CAleFluidSolver | |
| ►Nale_potential_flow_solver | |
| CAlePotentialFlowSolver | |
| ►Nalgorithm | |
| CAlgorithm | |
| ►Nalgorithm_gradient_projection | |
| CAlgorithmGradientProjection | A classical steepest descent algorithm to solve unconstrainted optimization problems |
| ►Nalgorithm_steepest_descent | |
| CAlgorithmSteepestDescent | A classical steepest descent algorithm to solve unconstrainted optimization problems |
| ►Nalgorithms | |
| ►Nalgorithm_base | |
| COptimizationAlgorithm | |
| ►Nalgorithm_bead_optimization | |
| CAlgorithmBeadOptimization | |
| ►Nalgorithm_gradient_projection | |
| CAlgorithmGradientProjection | |
| ►Nalgorithm_penalized_projection | |
| CAlgorithmPenalizedProjection | |
| ►Nalgorithm_relaxed_gradient_projection | |
| CAlgorithmRelaxedGradientProjection | |
| ►Nalgorithm_shape_fraction_optimization | |
| CAlgorithmShapeFractionOptimization | |
| ►Nalgorithm_steepest_descent | |
| CAlgorithmSteepestDescent | |
| ►Nalgorithm_trust_region | |
| CAlgorithmTrustRegion | |
| CProjector | |
| ►Nall_t_win_vs_m_fixed_error | |
| CProblemParameters | |
| CHinsbergPointsSetGivenNorm | |
| ►Nalm_contact_process | |
| CALMContactProcess | This class is used in order to compute the contact using a mortar ALM formulation |
| ►Naltair_cube_mesher | |
| Caltair_box_data | |
| ►Nanalysis_stage | |
| CAnalysisStage | The base class for the AnalysisStage-classes in the applications Changes to this BaseClass have to be discussed first! |
| ►Nanalytic_tools | |
| ►Nanalytic_data_procedures | |
| CSurfaceAnalyzer | |
| CParticlesAnalyzerClass | |
| CSurfacesAnalyzerClass | |
| ►Nanalytics | |
| CGauge | |
| ►Nanalyzers | |
| ►Nanalyzer_base | |
| CAnalyzerBaseClass | |
| ►Nanalyzer_empty | |
| CEmptyAnalyzer | |
| ►Nanalyzer_factory | |
| CAnalyzer | |
| CAnalyzerWithDependencies | |
| ►Nanalyzer_internal | |
| CIterationScope | |
| CKratosInternalAnalyzer | |
| ►NapplicationGenerator | |
| CApplicationGenerator | |
| ►Napply_absorbing_boundary_process | |
| CApplyAbsorbingBoundaryProcess | ApplyAbsorbingBoundaryProcess |
| ►Napply_boussinesq_force_process | |
| CApplyBoussinesqForceProcess | |
| ►Napply_constraint_vector_dam_table_process | |
| CApplyConstraintVectorDamTableProcess | All the processes python should be derived from "Process" |
| ►Napply_custom_body_force_process | |
| CApplyCustomBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_distance_modification_process | |
| CApplyDistanceModificationProcess | |
| ►Napply_embedded_nodes_initialization_process | |
| CApplyEmbeddedNodesInitializationProcess | |
| ►Napply_embedded_postprocess_process | |
| CApplyEmbeddedPostprocessProcess | |
| ►Napply_far_field_process | |
| CApplyFarFieldProcess | All the processes python should be derived from "Process" |
| ►Napply_hydraulic_inlet_process | |
| CApplyHydraulicInletProcess | Class to compute hydraulic inlet profile |
| ►Napply_hyperbolic_tangential_porosity_solution_and_body_force_process | |
| CApplyHyperbolicTangentialPorositySolutionAndBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_hyperbolic_tangential_porosity_solution_transient_body_force_process | |
| CApplyHyperbolicTangentialPorositySolutionTransientBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_inlet_process | |
| CApplyInletProcess | |
| ►Napply_load_vector_dam_process | |
| CApplyLoadVectorDamProcess | All the processes python should be derived from "Process" |
| ►Napply_load_vector_dam_table_process | |
| CApplyLoadVectorDamTableProcess | All the processes python should be derived from "Process" |
| ►Napply_mass_conservation_check_process | |
| CApplyMassConservationCheckProcess | |
| ►Napply_mpm_3d_rotating_dirichlet_condition_process | |
| CApplyMPM3DRotatingDirichletConditionProcess | All the processes python should be derived from "Process" |
| ►Napply_mpm_coupling_interface_dirichlet_condition_process | |
| CApplyMPMCouplingInterfaceDirichletConditionProcess | All the processes python should be derived from "Process" |
| ►Napply_mpm_coupling_interface_neumann_condition_process | |
| CApplyMPMCouplingInterfaceNeumannConditionProcess | All the processes python should be derived from "Process" |
| ►Napply_mpm_particle_dirichlet_condition_process | |
| CApplyMPMParticleDirichletConditionProcess | All the processes python should be derived from "Process" |
| ►Napply_mpm_particle_neumann_condition_process | |
| CApplyMPMParticleNeumannConditionProcess | All the processes python should be derived from "Process" |
| ►Napply_mpm_slip_boundary_process | |
| CApplyMPMSlipBoundaryProcess | All the processes python should be derived from "Process" |
| ►Napply_normal_load_table_process | |
| CApplyNormalLoadTableProcess | All the processes python should be derived from "Process" |
| ►Napply_noslip_process | |
| CApplyNoSlipProcess | |
| ►Napply_outlet_process | |
| CApplyOutletProcess | |
| ►Napply_parabolic_inlet_process | |
| CApplyParabolicInletProcess | Class to compute parabolic inlet profile |
| ►Napply_periodic_condition_process | |
| CApplyPeriodicConditionProcessPythonWrapper | All the processes python should be derived from "Process" |
| ►Napply_porosity_solution_and_body_force_process | |
| CApplyPorositySolutionAndBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_porosity_solution_body_force_process | |
| CApplyPorositySolutionTransientBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_porosity_solution_transient_body_force_process | |
| CApplyPorositySolutionTransientBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_potential_flow_hessian_remeshing_process | |
| CApplyPotentialFlowHessianRemeshingProcess | All the processes python should be derived from "Process" |
| ►Napply_pre_stressing_imposed_strain_process | |
| CApplyPreStressingImposedStrainProcess | This process sets the pre-stressing imposed strain according to a load factor (can depend on time) inside a defined Interval |
| ►Napply_scalar_constraint_function_process | |
| CApplyScalarConstraintFunctionProcess | All the python processes should be derived from "python_process" |
| ►Napply_scalar_constraint_table_process | |
| CApplyScalarConstraintTableProcess | All the processes python should be derived from "Process" |
| ►Napply_sinusoidal_porosity_solution_and_body_force_process | |
| CApplySinusoidalPorositySolutionAndBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_slip_process | |
| CApplySlipProcess | All the processes python should be derived from "Process" |
| ►Napply_thermal_face_process | |
| CApplyThermalFaceProcess | |
| ►Napply_transient_porosity_solution_body_force_process | |
| CApplyTransientPorositySolutionBodyForceProcess | All the processes python should be derived from "Process" |
| ►Napply_two_fluids_inlet_process | |
| CApplyTwoFluidsInletProcess | |
| ►Napply_two_fluids_inlet_process_mpi | |
| CApplyTwoFluidsInletProcessMPI | |
| ►Napply_vector_constraint_function_process | |
| CApplyVectorConstraintFunctionProcess | All the python processes should be derived from "python_process" |
| ►Napply_vector_constraint_table_process | |
| CApplyVectorConstraintTableProcess | All the processes python should be derived from "Process" |
| ►Napply_wall_function_process | |
| CApplyWallFunctionProcess | |
| ►Napply_wall_law_process | |
| ►CApplyWallLawProcess | |
| Clinear_log_monolithic_helper | |
| Cnavier_slip_monolithic_helper | |
| ►Napply_weak_sliding_process | |
| CApplyWeakSlidingProcess | |
| ►Napply_write_result_vector_process | |
| CApplyWriteVectorProcess | All the python processes should be derived from "python_process" |
| ►Nassign_average_master_slave_constraints_process | |
| CAssignAverageMasterSlaveConstraintsProcess | This class defines a process to assign averaged multi-point constraints (MPC) between a slave and a master model part in a computing model part |
| ►Nassign_eulerian_inlet_process | |
| CAssignEulerianInletProcess | All the processes python should be derived from "Process" |
| ►Nassign_exact_variable_to_a_dof_process | |
| CAssignExactVariableToADOFProcess | All the processes python should be derived from "Process" |
| ►Nassign_flag_process | |
| CAssignFlagProcess | This process sets a given value for a certain flag in all the nodes of a submodelpart |
| ►Nassign_gravity_to_particle_process | |
| CAssignGravityToParticleProcess | All the processes python should be derived from "Process" |
| ►Nassign_initial_HM_state_process | |
| CSetMechanicalInitialStateProcess | All the processes python processes should be derived from "python_process" |
| ►Nassign_initial_velocity_to_particle_process | |
| CAssignInitialVelocityToParticleProcess | All the processes python should be derived from "Process" |
| ►Nassign_inlet_process | |
| CAssignInletProcess | All the processes python should be derived from "Process" |
| ►Nassign_lagrangian_inlet_process | |
| CAssignLagrangianInletProcess | All the processes python should be derived from "Process" |
| ►Nassign_master_slave_constraints_to_neighbours_process | |
| CAssignMasterSlaveConstraintsToNeighboursProcess | All the processes python should be derived from "Process" |
| ►Nassign_materials_process | |
| CAssignMaterialsProcess | |
| ►Nassign_modulus_and_direction_to_conditions_process | |
| Ccompiled_time_spatial_function | |
| CAssignModulusAndDirectionToConditionsProcess | All the processes python should be derived from "Process" |
| ►Nassign_modulus_and_direction_to_nodes_process | |
| CAssignModulusAndDirectionToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_mpcs_to_neighbours_process | |
| CAssignMPCsToNeighboursProcess | |
| ►Nassign_properties_to_nodes_process | |
| CAssignPropertiesToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_rigid_body_rotation_to_nodes_process | |
| CAssignRigidBodyRotationToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_input_to_conditions_process | |
| CAssignScalarInputToConditionsProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_input_to_elements_process | |
| CAssignScalarInputToElementsProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_input_to_entities_process | |
| CAssignScalarInputToEntitiesProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_input_to_nodes_process | |
| CAssignScalarInputToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_to_conditions_process | |
| CAssignScalarToConditionsProcess | |
| ►Nassign_scalar_to_elements_process | |
| CAssignScalarToElementsProcess | |
| ►Nassign_scalar_to_nodes_process | |
| Ccompiled_time_spatial_function | |
| CAssignScalarToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_variable_process | |
| CAssignScalarVariableProcess | This process sets a given scalar value for a certain variable in all the nodes of a submodelpart |
| ►Nassign_scalar_variable_to_conditions_process | |
| CAssignScalarVariableToConditionsProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_variable_to_constraints_process | |
| CAssignScalarVariableToConstraintsProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_variable_to_elements_process | |
| CAssignScalarVariableToElementsProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_variable_to_entities_process | |
| CAssignScalarVariableToEntitiesProcess | All the processes python should be derived from "Process" |
| ►Nassign_scalar_variable_to_nodes_process | |
| CAssignScalarVariableToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_sections_process | |
| CAssignSectionsProcess | |
| ►Nassign_time_derivative_process | |
| CAssignTimeDerivativeProcess | All the processes python should be derived from "Process" |
| ►Nassign_torque_to_conditions_process | |
| CAssignTorqueToConditionsProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_by_direction_process | |
| CAssignVectorByDirectionProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_by_direction_to_condition_process | |
| CAssignVectorByDirectionToConditionProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_by_direction_to_element_process | |
| CAssignVectorByDirectionToElementProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_by_direction_to_entity_process | |
| CAssignVectorByDirectionToEntityProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_by_direction_to_node_process | |
| CAssignVectorByDirectionToNodeProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_components_to_nodes_process | |
| CAssignVectorComponentsToNodesProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_to_conditions_process | |
| CAssignVectorToConditionsProcess | |
| ►Nassign_vector_variable_and_constraints_to_conditions_process | |
| CAssignVectorVariableAndConstraintsToConditionProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_variable_process | |
| CAssignVectorVariableProcess | This process assigns a given value (vector) to the nodes belonging a certain submodelpart |
| ►Nassign_vector_variable_to_conditions_process | |
| CAssignVectorVariableToConditionProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_variable_to_constraints_process | |
| CAssignVectorVariableToConstraintProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_variable_to_elements_process | |
| CAssignVectorVariableToElementProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_variable_to_entities_process | |
| CAssignVectorVariableToEntitiesProcess | All the processes python should be derived from "Process" |
| ►Nassign_vector_variable_to_nodes_process | |
| CAssignVectorVariableToNodeProcess | All the processes python should be derived from "Process" |
| ►Nautomatic_dirichlet_conditions_process | |
| CAutomaticDirichletConditionsProcess | This process fix the variables at the skin |
| ►Nautomatic_dt_process | |
| CAutomaticDTProcess | All the processes python should be derived from "Process" |
| ►Nautomatic_rayleigh_parameters_computation_process | |
| CAutomaticRayleighComputationProcess | This class is used in order to compute automatically the Rayleigh damping parameters computing in first place the eigenvalues of the system |
| ►Nauxiliary_nodes_visualization_process | |
| CAuxiliaryNodesVisualizationProcess | This class creates some auxiliary nodes |
| ►Nbase_benchmark_process | |
| CBaseBenchmarkProcess | The base class for the benchmarks |
| ►Nbase_classes | |
| ►Nco_simulation_convergence_accelerator | |
| CCoSimulationConvergenceAccelerator | Baseclass for the convergence acceleratos used for CoSimulation Relaxes the solution to increase the speed of convergence in a (strongly) coupled simulation |
| ►Nco_simulation_convergence_criteria | |
| CCoSimulationConvergenceCriteria | Baseclass for the convergence criteria used for CoSimulation Checks if convergence was achieved in a (strongly) coupled simulation |
| ►Nco_simulation_coupled_solver | |
| CUndefinedSolver | |
| CCoSimulationCoupledSolver | Baseclass for the coupled solvers used for CoSimulation Performs basic operations that are common among coupled solvers: |
| CModelAccessor | Intermediate class for redirecting the access to the Models to the solvers of the CoupledSolver |
| ►Nco_simulation_coupling_operation | |
| CCoSimulationCouplingOperation | Baseclass 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 |
| ►Nco_simulation_data_transfer_operator | |
| CCoSimulationDataTransferOperator | Baseclass for the data transfer operators used for CoSimulation It transfers data from one interface to another |
| ►Nco_simulation_io | |
| CCoSimulationIO | Baseclass defining the interface for the input and output methods for the communication with external solvers |
| ►Nco_simulation_predictor | |
| CCoSimulationPredictor | Baseclass for the predictors used for CoSimulation It predicts the solution of the next step at the beginning of a step |
| ►Nco_simulation_solver_wrapper | |
| CCoSimulationSolverWrapper | Baseclass for the solver wrappers used for CoSimulation It wraps solvers used in the CoSimulation |
| ►Nbase_convergence_criteria_factory | |
| CConvergenceCriteriaFactory | |
| ►Nbasic_mapping_process | |
| CBasicMappingProcess | This process allows to do a simple mapping using the SimpleMortarMapperProcess |
| ►Nboussinesq_solver | |
| CBoussinesqSolver | |
| ►Nbuffered_dict | |
| CBufferedDict | Buffered dict container with buffered data ability |
| ►Nbuild_beam_skin_process | |
| CBeamBuildSkinProcess | |
| ►Ncalculate_nodal_area_process | |
| CCalculateNodalAreaProcess | |
| CCalculateNodalAreaWithRemeshingProcess | |
| ►Ncalculate_rom_basis_output_process | |
| CCalculateRomBasisOutputProcess | A process to set the snapshots matrix and calculate the ROM basis from it |
| ►Ncase_runner | |
| CCaseRunner | |
| ►Ncavity_process | |
| CCavityProcess | |
| ►Ncellular_flow_derivative_recovery_errors | |
| CField | |
| CMesh | |
| CRecoveryCase | |
| CPlotter | |
| CFigure | |
| CCurve | |
| ►NCFD_DEM_coupling | |
| CProjectionModule | |
| ►Ncheck_and_prepare_model_process | |
| CCheckAndPrepareModelProcess | All the processes python processes should be derived from "python_process" |
| ►Ncheck_and_prepare_model_process_convection_diffusion | |
| CCheckAndPrepareModelProcess | All the processes python processes should be derived from "python_process" |
| ►Ncheck_and_prepare_model_process_dam_mechanical | |
| CCheckAndPrepareModelProcessDamMechanical | All the processes python should be derived from "Process" |
| ►Ncheck_and_prepare_model_process_dam_thermal | |
| CCheckAndPrepareModelProcessDamThermal | All the processes python should be derived from "Process" |
| ►Ncheck_and_prepare_model_process_fluid | |
| CCheckAndPrepareModelProcess | All the processes python should be derived from "Process" |
| ►Ncheck_and_prepare_model_process_fluid_transport | |
| CCheckAndPrepareModelProcess | All the processes python should be derived from "Process" |
| ►Ncheck_and_prepare_model_process_geo | |
| CCheckAndPrepareModelProcess | All the processes python should be derived from "Process" |
| ►Ncheck_and_prepare_model_process_poro | |
| CCheckAndPrepareModelProcess | All the processes python should be derived from "Process" |
| ►Ncheck_and_prepare_selfweight_model_process_dam | |
| CCheckAndPrepareSelfweightModelProcess | All the processes python should be derived from "Process" |
| ►Ncheck_eigenvalues_process | |
| CCheckEigenvaluesProcess | |
| ►Ncheck_same_model_part_using_skin_process | |
| CCheckSameModelPartUsingSkinDistanceProcess | This process checks that the model part is the same using the skin distance |
| ►Ncheck_scalar_base_process | |
| Caux_object_cpp_callback | |
| CCheckScalarBaseProcess | This process is the base class to check analytically from a function the solution (scalar) in a certain entity belonging a certain submodelpart |
| ►Ncheck_scalar_from_process_info_process | |
| CCheckScalarFromProcessInfoProcess | This process checks analytically from a function the solution (scalar) in the process info belonging a certain submodelpart |
| ►Ncheck_scalar_on_elements_process | |
| CCheckScalarOnElementsProcess | All the processes python should be derived from "Process" |
| ►Ncheck_scalar_on_nodes_process | |
| Caux_object_cpp_callback | |
| CCheckScalarOnNodesProcess | All the processes python should be derived from "Process" |
| ►Ncheck_scalar_to_nodes_process | |
| CCheckScalarToNodesProcess | This process checks analytically from a function the solution (scalar) in a set of nodes belonging a certain submodelpart |
| ►Ncheck_vector_components_to_nodes_process | |
| CCheckVectorComponentsToNodesProcess | All the processes python should be derived from "Process" |
| ►NChrono | |
| CChrono | |
| ►NChung_Ooi_class | |
| CBenchmark5 | |
| CBenchmark6 | |
| CBenchmark7 | |
| CBenchmark8 | |
| CBenchmark9 | |
| CBenchmark10 | |
| ►Nclasses | |
| ►NclassCreator | |
| CClassCreator | |
| ►NclassMemberCreator | |
| CClassMemberCreator | |
| ►NconditionCreator | |
| CConditionCreator | Extends KratosClassCreator for a Kratos Condition |
| ►NelementCreator | |
| CElementCreator | Extends KratosClassCreator for a Kratos Element |
| ►NprocessCreator | |
| CProcessCreator | TO BE IMPLEMENTED |
| ►NvariableCreator | |
| CVariableCreator | |
| CVariableCreator3D | |
| ►Nco_simulation_analysis | |
| CCoSimulationAnalysis | AnalysisStage of the CoSimulationApplication |
| ►Ncollect_stages | |
| CSub_model_part | |
| ►Ncolloids_analysis | |
| CColloidsAnalysis | |
| ►Ncommunicator_factory | |
| CCommunicator | |
| ►Ncompare_two_files_check_process | |
| CCompareTwoFilesCheckProcess | This process compares files that are written during a simulation against reference files |
| ►Ncomponent_data_view | |
| CComponentDataView | A viewer to view component's data in optimization problem |
| ►Ncompressible_slip_wall_process | |
| CCompressibleSlipWallProcess | This process helps with convergence by slowly transforming an outlet into a wall |
| ►Ncompute_body_fitted_drag_and_moment_process | |
| CComputeBodyFittedDragAndMomentProcess | The specific implementation for the output of body fitted drag forces over obstacles in fluid dynamics problems |
| ►Ncompute_body_fitted_drag_process | |
| CComputeBodyFittedDragProcess | The specific implementation for the output of body fitted drag forces over obstacles in fluid dynamics problems |
| ►Ncompute_boundary_force_process | |
| CComputeBoundaryForceProcess | Get the external accelerations and computes the hydrostatic forces |
| ►Ncompute_cfl_process | |
| CComputeCFLProcess | |
| ►Ncompute_drag_and_moment_process | |
| CComputeDragAndMomentProcess | Auxiliary base class to output total flow forces over obstacles in fluid dynamics problems |
| ►Ncompute_drag_process | |
| CComputeDragProcess | Auxiliary base class to output total flow forces over obstacles in fluid dynamics problems |
| ►Ncompute_embedded_drag_process | |
| CComputeEmbeddedDragProcess | The specific implementation for the output of embedded drag forces over obstacles in fluid dynamics problems |
| ►Ncompute_embedded_lift_process | |
| CComputeEmbeddedLiftProcess | All the processes python processes should be derived from "python_process" |
| ►Ncompute_forces_on_nodes_process | |
| CComputeForcesOnNodesProcess | |
| ►Ncompute_froude_process | |
| CComputeFroudeProcess | Compute the Froude number before the output step |
| ►Ncompute_level_force_process | |
| CComputeLevelForceProcess | |
| ►Ncompute_lift_process | |
| CComputeLiftProcess | |
| ►Ncompute_nodal_value_process | |
| CComputeNodalValueProcess | |
| ►Ncompute_wss_statistics_process | |
| CComputeWssStatisticsProcess | Auxiliary base class to output total WSS forces A derived class needs to be implemented to be able to use this functionality, as calling the base class alone is not enough |
| ►Nconcentric_element_size_coarsener | |
| CElementSizeModifier | |
| ►Ncone_penetration_utility | |
| CConePenetrationUtility | |
| ►NConformant_OneSideMap | |
| CConformant_OneSideMap | |
| ►Nconjugate_heat_transfer_solver | |
| CConjugateHeatTransferSolver | |
| ►Nconstant_rotation_process | |
| CConstantRotationProcess | |
| ►Nconstitutive_law_python_utility | |
| CConstitutiveLawUtility | |
| ►Ncontact_convergence_criteria_factory | |
| CContactConvergenceCriteriaFactory | |
| ►Ncontact_domain | |
| CContactDomain | |
| ►Ncontact_domain_process | |
| CContactDomainProcess | |
| ►Ncontact_mesher | |
| CContactMesher | |
| ►Ncontact_meshing_strategy | |
| CContactMeshingStrategy | |
| ►Ncontact_remesh_mmg_process | |
| CContactRemeshMmgProcess | This process remeshes using MMG library |
| ►Ncontact_structural_mechanics_explicit_dynamic_solver | |
| CContactExplicitMechanicalSolver | The structural mechanics contact explicit dynamic solver |
| ►Ncontact_structural_mechanics_implicit_dynamic_solver | |
| CContactImplicitMechanicalSolver | The structural mechanics contact implicit dynamic solver |
| ►Ncontact_structural_mechanics_static_solver | |
| CContactStaticMechanicalSolver | The structural mechanics contact static solver |
| ►Ncontinuum_sphere_strategy | |
| CExplicitStrategy | |
| ►Ncontrol | |
| CControl | Base abstract control class |
| ►Ncontrol_module_2d_process | |
| CControlModule2DProcess | All the processes python should be derived from "Process" |
| ►Ncontrol_module_fem_dem_utility | |
| CControlModuleFemDemUtility | |
| ►Ncontrol_module_process | |
| CControlModuleProcess | All the processes python should be derived from "Process" |
| ►Nconvection_diffusion_analysis | |
| CConvectionDiffusionAnalysis | This class is the main-script of the ConvectionDiffusionApplication put in a class |
| ►Nconvection_diffusion_analysis_rom | |
| CConvectionDiffusionAnalysisROM | |
| ►Nconvection_diffusion_explicit_solver | |
| CConvectionDiffusionExplicitSolver | The explicit class for convection-diffusion solvers |
| ►Nconvection_diffusion_semi_eulerian_solver | |
| CConvectionDiffusionSemiImplicitSolver | The semi-eulerian class for convection-diffusion solvers |
| ►Nconvection_diffusion_solver | |
| CConvectionDiffusionSolver | The base class for convection-diffusion solvers |
| ►Nconvection_diffusion_stationary_embedded_solver | |
| CConvectionDiffusionStationaryEmbeddedSolver | The embedded class for a stationary convection-diffusion solvers |
| ►Nconvection_diffusion_stationary_matrix_solver | |
| CConvectionDiffusionStationaryMatrixSolver | Variant of the stationary convection diffusion solver that extracts: |
| ►Nconvection_diffusion_stationary_rom_solver | |
| CROMSolver | The stationary class for ROM convection-diffusion solvers |
| ►Nconvection_diffusion_stationary_solver | |
| CConvectionDiffusionStationarySolver | The stationary class for convection-diffusion solvers |
| ►Nconvection_diffusion_transient_rom_solver | |
| CROMSolver | The transient class for ROM convection-diffusion solvers |
| ►Nconvection_diffusion_transient_solver | |
| CConvectionDiffusionTransientSolver | The transient class for convection-diffusion solvers |
| ►Nconvergence_accelerators | |
| ►Naitken | |
| CAitkenConvergenceAccelerator | Class AitkenConvergenceAccelerator |
| ►Nanderson | |
| CAndersonConvergenceAccelerator | |
| ►Nconstant_relaxation | |
| CConstantRelaxationConvergenceAccelerator | |
| ►Nconvergence_accelerator_wrapper | |
| CConvergenceAcceleratorWrapper | This 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 |
| CConvergenceAcceleratorResidual | |
| CDataDifferenceResidual | |
| CDifferentDataDifferenceResidual | |
| ►Niqnils | |
| CIQNILSConvergenceAccelerator | Class IQNILSConvergenceAccelerator |
| ►Nmvqn | |
| CMVQNConvergenceAccelerator | Class MVQNConvergenceAccelerator |
| ►Nconvergence_criteria | |
| ►Nabsolute_norm_energy_conjugate | |
| CAbsoluteNormResidualConvergenceCriteria | |
| ►Nconvergence_criteria_wrapper | |
| CConvergenceCriteriaWrapper | This class wraps the convergence criteria such that they can be used "automated" |
| ►Nrelative_norm_initial_residual | |
| CRelativeNormInitialResidualConvergenceCriteria | |
| ►Nrelative_norm_previous_residual | |
| CRelativeNormPreviousResidualConvergenceCriteria | |
| ►Nconvergence_criteria_factory | |
| CConvergenceCriterion | |
| Cconvergence_criterion | |
| ►Nconvergence_criteria_factory_fem_dem | |
| Cconvergence_criterion | |
| ►Nconvergence_output_process | |
| CConvergenceOutputProcess | |
| ►Ncore | |
| ►Ncontrollers | |
| CController | |
| CDefaultController | Simple pass through controller |
| CTemporalController | Frequency-based controller |
| ►Nfile_io | HDF5 file IO |
| C_FileIO | |
| C_HDF5SerialFileIO | |
| C_HDF5ParallelFileIO | |
| ►C_HDF5MockFileIO | |
| CMockFile | |
| C_FilenameGetter | |
| C_FilenameGetterWithDirectoryInitialization | |
| COpenHDF5File | A context responsible for managing the lifetime of HDF5 files |
| ►Noperations | HDF5 IO operations |
| ►Nmodel_part | HDF5 model part operations |
| CIOOperation | Base class for HDF5 IO operations |
| CModelPartIOOperation | Base class for HDF5 IO operations on ModelPart s |
| CModelPartInput | Reads a ModelPart from a file |
| CModelPartOutput | Writes a ModelPart to a file |
| CPartitionedModelPartOutput | Writes a partitioned model part to a file |
| CProcessInfoIOOperation | |
| CProcessInfoOutput | Writes a ProcessInfo to a file |
| CProcessInfoInput | Reads a ProcessInfo from a file |
| CVariableIOOperation | Generates json settings for variable data IO |
| CElementDataValueOutput | Writes non-historical element data values to a file |
| CElementDataValueInput | Reads non-historical element data values from a file |
| CElementFlagValueOutput | Writes non-historical element flag values to a file |
| CElementFlagValueInput | Reads non-historical element flag values from a file |
| CElementGaussPointOutput | Write element integration point values to a file |
| CConditionDataValueOutput | Writes non-historical element data values to a file |
| CConditionDataValueInput | Reads non-historical element data values from a file |
| CConditionFlagValueOutput | Writes non-historical element flag values to a file |
| CConditionFlagValueInput | Reads non-historical element flag values from a file |
| CConditionGaussPointOutput | Write condition integration point values to a file |
| CNodalSolutionStepDataOutput | Writes nodal solution step data to a file |
| CNodalSolutionStepDataInput | Reads nodal solution step data from a file |
| CNodalDataValueOutput | Writes non-historical nodal data values to a file |
| CNodalDataValueInput | Reads non-historical nodal data values from a file |
| CNodalFlagValueOutput | Writes non-historical nodal flag values to a file |
| CNodalFlagValueInput | Reads non-historical nodal flag values from a file |
| CPrimalBossakOutput | Writes nodal solution step data to a file for Bossak time schemes |
| CPrimalBossakInput | Reads nodal solution step data from a file |
| CMoveMesh | Perform a mesh move operation on a model part |
| CAggregateOperation | Class for aggregating HDF5 IO operations on the same file |
| ►Nsystem | HDF5 operating system operations |
| CDeleteOldH5Files | Delete h5-files from previous simulations |
| ►Nxdmf | HDF5 Xdmf operations |
| CXdmfOutput | Output that creates the xdmf-file for the given h5-files |
| ►Nprocesses | |
| COrderedOperationProcess | A process for grouping operations |
| COrderedOutputOperationProcess | |
| ►Nutils | HDF5 core utils |
| CParametersWrapper | A pythonic wrapper to KratosMultiphysics.Parameters |
| ►Nxdmf | A set of classes for constructing XDMF hierarchies |
| CXdmfItem | The base class for all XDMF XML elements |
| CDataItem | An abc for an XDMF DataItem (HDF5 data set) |
| CAttribute | An abc for an XDMF Attribute (e.g., nodal or gauss point results) |
| CTopology | An abc for an XDMF Topology |
| CGrid | An abc for an XDMF Grid (a mesh with results data) |
| CTime | An XDMF Time (a single time step value) |
| CGeometry | An XDMF Geometry (nodal coordinates) |
| CTopologyCellType | A helper class for identifying the cell/element topology type |
| CUniformMeshTopology | An XDMF Topology for a single element or condition type |
| CHDF5UniformDataItem | An XDMF DataItem for an HDF5 data set |
| CNodalData | An XDMF Attribute for nodal solution step or data value container data |
| CGeometrycalObjectData | An XDMF Attribute for element data value container data |
| CElementData | An XDMF Attribute for element data value container data |
| CConditionData | |
| CSpatialGrid | A collection of uniform XDMF Grid objects with results data |
| CTemporalGrid | A collection of XDMF Grid objects associated with time steps |
| CUniformGrid | An XDMF Grid for a single element or condition |
| CDomain | An XDMF Domain (computational domain) |
| CXdmf | The XML root element of the XDMF model |
| ►Ncoupled_fluid_thermal_solver | |
| CCoupledFluidThermalSolver | |
| ►Ncoupled_fluid_transport_solver | |
| CCoupledFluidTransportSolver | |
| ►Ncoupled_rans_solver | |
| CCoupledRANSSolver | |
| ►Ncoupled_solvers | |
| ►Nfeti_dynamic_coupled_solver | |
| CFetiDynamicCoupledSolver | |
| ►Ngauss_seidel_strong | |
| CGaussSeidelStrongCoupledSolver | |
| ►Ngauss_seidel_weak | |
| CGaussSeidelWeakCoupledSolver | |
| ►Njacobi_strong | |
| CJacobiStrongCoupledSolver | |
| ►Njacobi_weak | |
| CJacobiWeakCoupledSolver | |
| ►Ncoupled_structural_thermal_solver | |
| CCoupledThermoMechanicalSolver | |
| ►Ncoupling_interface_data | |
| CBaseCouplingInterfaceData | This class serves as interface to the data structure (Model and ModelPart) that holds the data used during CoSimulation |
| CCouplingInterfaceData | This class serves as interface to the data structure (Model and ModelPart) that holds the data used during CoSimulation |
| ►Ncoupling_operations | |
| ►Ncompute_boundary_force | |
| CComputeBoundaryForce | This operation is used to compute forces in a boundary, based on the pressure |
| ►Ncompute_normals | |
| CComputeNormalsOperation | This operation computes the Normals (NORMAL) on a given ModelPart |
| ►Nconvert_distributed_values_to_point | |
| CConvertDistributedValuesToPoint | This operation converts distributed quantities (such as tractions) into concentrated nodal values (such as nodal loads) It is the inverse operation of the "DistributePointValuesOperation" operation |
| ►Ncoupling_output | |
| CCouplingOutput | This operation is used to output at different points in the coupling |
| ►Ncreate_point_load_model_part | |
| CCreatePointLoadModelPart | This operation creates a submodelpart containing PointLoad Conidtions for transferring loads |
| ►Ndistribute_point_values | |
| CDistributePointValuesOperation | This operation converts concentrated nodal values (such as nodal loads) into distributed quantities (such as tractions) It is the inverse operation of the "ConvertDistributedValuesToPoint" operation |
| ►Nelemental_data_to_nodal_data | |
| CElementalToNodalData | This operation maps the Elemental Data to Nodal Data for a given ModelPart |
| ►Nprint_iteration_number | |
| CPrintIterationNumberOperation | This operation is used to print the number of iterations on the strong coupling schemes TODO: |
| ►Nreset_pfem_kinematics | |
| CResetPfemKinematics | This operation is used to reset the PFEM kinematic values on a given model part |
| ►Nscaling | |
| CScalingOperation | This operation performs scaling of values on an InterfaceData The value can be given directly as a value or as a string containing an evaluable function |
| ►NCovarianceKernels | |
| CCovariance | Generic Covariance class |
| CVonKarmanCovariance | |
| CMannCovariance | |
| ►Ncpp_process_factory | |
| CRansCheckScalarBoundsProcess | Checks bounds of a scalar variable for given model part |
| ►NCSharpKratosWrapper | |
| CIdTranslator | |
| CKratosInternals | |
| CKratosWrapper | |
| Cface | |
| CMeshConverter | |
| CModelPartWrapper | |
| CVector3 | |
| ►Ncube_mesher | |
| Cbox_data | |
| ►Ncubic_law | |
| CProblemParameters | |
| CHorizontalDistributionMinusObjective | |
| Ch_and_phi_function | |
| ►Ncustom_ios | |
| ►Nwrl_io | |
| CWrlIO | |
| ►Nwrl_reader | |
| CShape | |
| ►Ndam_analysis | |
| CDamAnalysis | Main-script of the DamApplication put in a class |
| ►Ndam_break_benchmark | |
| CDamBreakBenchmark | Dam break benchark |
| ►Ndam_break_modeler | |
| CDamBreakModeler | |
| ►Ndam_construction_utility | |
| CDamConstructionUtility | |
| ►Ndam_eigen_solver | |
| CDamEigenSolver | |
| ►Ndam_mapping_variables_utility | |
| CMappingVariablesUtility | |
| ►Ndam_mechanical_solver | |
| CDamMechanicalSolver | |
| ►Ndam_P_solver | |
| CDamUPSolver | |
| ►Ndam_selfweight_solver | |
| CDamSelfweightSolver | |
| ►Ndam_thermo_mechanic_solver | |
| CDamThermoMechanicSolver | |
| ►Ndam_UP_mechanical_solver | |
| CDamUPMechanicalSolver | |
| ►Ndam_UP_thermo_mechanic_solver | |
| CDamUPThermoMechanicSolver | |
| ►Ndata_transfer_operators | |
| ►Ncopy | |
| CCopyDataTransferOperator | DataTransferOperator that copies values from one interface to another, without any checks |
| ►Nkratos_mapping | |
| CKratosMappingDataTransferOperator | DataTransferOperator that maps values from one interface (ModelPart) to another |
| ►Nsum_distributed_to_single | |
| CSumDistributedToSingle | DataTransferOperator to sum values on one interface and put it to another interface |
| ►Nsum_many_to_many | |
| CSumManyToMany | DataTransferOperator to sum values on one interface and put it to another interface, if desired equally distributed |
| ►Ntransfer_one_to_many | |
| CTransferOneToMany | DataTransferOperator to take one single value and set it to all values on another interface |
| ►Ndecompressed_material_bts_test | |
| CDecompressedMaterialBTSTest | |
| ►Ndecompressed_material_triaxial_test | |
| CDecompressedMaterialTriaxialTest | |
| ►Ndecompressed_material_triaxials_and_bts_tests | |
| CDecompressedMaterialTriaxialTest | |
| CDecompressedMaterialBTSTest | |
| ►Ndefine_embedded_wake_process_2d | |
| CDefineEmbeddedWakeProcess | |
| ►Ndefine_wake_process | |
| CDefineWakeProcess | |
| ►Ndefine_wake_process_2d | |
| CDefineWakeProcess2D | |
| ►Ndefine_wake_process_3d | |
| CDefineWakeProcess3D | |
| ►Ndelete_model_parts_modeler | |
| CDeleteModelPartsModeler | |
| ►NDEM_analysis_stage | |
| CDEMAnalysisStage | |
| ►NDEM_benchmarks | |
| CSolution | |
| ►NDEM_benchmarks_analysis | |
| CDEMBenchmarksAnalysisStage | |
| ►NDEM_benchmarks_class | |
| CBenchmark1 | |
| CBenchmark2 | |
| CBenchmark3 | |
| CBenchmark4 | |
| CBenchmark5 | |
| CBenchmark6 | |
| CBenchmark7 | |
| CBenchmark8 | |
| CBenchmark9 | |
| CBenchmark10 | LINEAR THORNTON |
| CBenchmark11 | HERTZIAN THORNTON |
| CBenchmark12 | ROLLING FRICTION |
| CBenchmark13 | DEM-FEM Facet |
| CBenchmark14 | DEM-FEM Edge |
| CBenchmark15 | DEM-FEM Vertex |
| CBenchmark16 | DEM-FEM Grid |
| CBenchmark17 | DEM-FEM Rolling |
| CBenchmark20 | |
| CBenchmark21 | |
| CBenchmark22 | |
| CBenchmark23 | |
| CBenchmark24 | |
| CBenchmark25 | |
| CBenchmark26 | |
| CBenchmark27 | |
| CBenchmark28 | |
| CBenchmark30 | Cylinder with imposed angular velocity (Velocity Verlet + Zhao) |
| CBenchmark31 | Cylinder with imposed angular velocity (Symplectic Euler + Runge-Kutta) |
| CBenchmark32 | Fiber cluster bouncing without any damping (Velocity Verlet + Zhao scheme) |
| CBenchmark33 | Fiber cluster bouncing without any damping (Velocity Verlet + Runge-Kutta scheme) |
| CBenchmark40 | |
| ►NDEM_coupled_fluid_dynamics_analysis | |
| CDEMCoupledFluidDynamicsAnalysis | |
| ►NDEM_coupled_pfem_fluid_dynamics_analysis | |
| CDEMCoupledPFEMFluidDynamicsAnalysis | |
| ►Ndem_fem_coupling_algorithm | |
| CAlgorithm | |
| ►NDEM_inlet_process | |
| CDEM_Inlet_Process | |
| ►Ndem_main_script_ready_for_coupling_with_fem | |
| CStructuresCoupledDEMAnalysisStage | |
| ►NDEM_material_test_script | |
| CMaterialTest | |
| CPreUtils | |
| ►NDEM_material_test_script_mpi | |
| CMaterialTest | |
| ►Ndem_poromechanics_coupling_analysis_stage | |
| CPoroMechanicsCouplingWithDemRadialMultiDofsControlModuleAnalysisStage | |
| CDemPoroMechanicsCouplingSolver | |
| ►NDEM_procedures | |
| CMdpaCreator | |
| CSetOfModelParts | |
| CGranulometryUtils | |
| CPostUtils | |
| CDEMEnergyCalculator | |
| CProcedures | |
| CDEMFEMProcedures | |
| CReport | |
| CPreUtils | |
| CMultifileList | |
| CDEMIo | |
| CParallelUtils | |
| ►NDEM_procedures_mpi | |
| CMdpaCreator | |
| CPostUtils | |
| CProcedures | |
| CDEMFEMProcedures | |
| CReport | |
| CMaterialTest | |
| CMultifileList | |
| CDEMIo | |
| CParallelUtils | |
| CSetOfModelParts | |
| CDEMEnergyCalculator | |
| ►NDEM_procedures_mpi_no_partitions | |
| CProcedures | |
| CMultifileList | |
| CDEMIo | |
| ►NDEM_restart_utility | |
| CDEMRestartUtility | This class collects the common functionalities needed for saving / loading restart files |
| ►NDEM_save_restart_process | |
| CDEMSaveRestartProcess | This process compares saves restart files It works both in OpenMP and MPI see the "default_settings" for available options |
| ►Ndem_structures_coupling_gid_output | |
| CDemStructuresCouplingGiDOutput | |
| ►Ndem_vtk_output | |
| CVtkOutput | |
| ►Ndeprecation_management | |
| CDeprecationManager | This class is intended to encapsulate common operations that may be needed when dealing with deprecated input variable names |
| ►Ndepth_integration_input_process | |
| CDepthIntegrationInputProcess | DepthIntegrationInputProcess |
| ►Ndepth_integration_output_process | |
| CDepthIntegrationOutputProcess | DepthIntegrationOutputProcess |
| ►Nderivative_recovery | |
| ►Nderivative_recovery_strategy | |
| CDerivativeRecoveryStrategy | |
| ►NL2_projection_recoverer | |
| CL2ProjectionDerivativesRecoverer | |
| CL2ProjectionGradientRecoverer | |
| CL2ProjectionMaterialAccelerationRecoverer | |
| CL2ProjectionDirectMaterialAccelerationRecoverer | |
| CL2ProjectionLaplacianRecoverer | |
| ►Nlagrangian_recoverer | |
| CLagrangianMaterialAccelerationRecoverer | |
| ►Npost_process_gradient_recoverer | |
| CPostProcessGradientMaterialAccelerationRecoverer | |
| ►Npouliot_2012_edge_recoverer | |
| CPouliot2012EdgeDerivativesRecoverer | |
| CPouliot2012EdgeGradientRecoverer | |
| CPouliot2012EdgeMaterialAccelerationRecoverer | |
| CPouliot2012EdgeLaplacianRecoverer | |
| ►Npouliot_2012_recoverer | |
| CPouliot2012GradientRecoverer | |
| CPouliot2012MaterialAccelerationRecoverer | |
| CPouliot2012LaplacianRecoverer | |
| ►Npouliot_2012_recovery_tools | |
| CPouliotRecoveryTools | |
| ►Nrecoverer | |
| CDerivativesRecoverer | |
| CEmptyGradientRecoverer | |
| CEmptyMaterialAccelerationRecoverer | |
| CEmptyVorticityRecoverer | |
| CEmptyLaplacianRecoverer | |
| CGradientRecoverer | |
| CMaterialAccelerationRecoverer | |
| CVorticityRecoverer | |
| CLaplacianRecoverer | |
| ►Nstandard_recoverer | |
| CStandardGradientRecoverer | |
| CStandardMaterialAccelerationRecoverer | |
| CStandardLaplacianRecoverer | |
| ►Nzhang_guo_recoverer | |
| CZhangGuoGradientRecoverer | |
| CZhangGuoMaterialAccelerationRecoverer | |
| CZhangGuoDirectLaplacianRecoverer | |
| CZhangGuoMaterialAccelerationAndLaplacianRecoverer | |
| ►NDerivatives | |
| CTimeDependantFluidFractionSolution | |
| CPorousCodina2007 | |
| CCodina2007 | |
| CCodinaVelocityField | |
| CPorousSinusoidalFluidFractionSolution | |
| CHyperbolicTangentFluidFractionSolution | |
| ►Nderivatives_recovery_process | |
| ►CDerivativesRecoveryProcess | |
| CDifferentialOperator | Auxiliary class to execute the derivatives recovery |
| ►Ndisplacement_control_with_direction_process | |
| CAssignDisplacementControlProcess | All the processes python should be derived from "Process" |
| ►Ndistributed_gid_output_process | |
| CDistributedGiDOutputProcess | |
| ►Ndistributed_import_model_part_utility | |
| CDistributedImportModelPartUtility | |
| ►Ndistributed_restart_utility | |
| CDistributedRestartUtility | This class overwrites the methods that are different in MPI parallel execution |
| ►Ndivergencefree_refinement_process | |
| CDivergenceFreeRefinementProcess | All the processes python should be derived from "Process" |
| ►Ndomain_utilities | |
| CDomainUtilities | |
| ►Ndroplet_dynamics_analysis | |
| CDropletDynamicsAnalysis | |
| ►Ndroplet_dynamics_solver | |
| CDropletDynamicsSolver | |
| ►Ndynamic_smagorinsky_utilities | |
| CDynamicSmagorinsky | |
| ►Nedge_cable_element_process | |
| Ccustom_node | |
| CEdgeCableElementProcess | |
| ►Nedgebased_levelset_solver | |
| ►CEdgeBasedLevelSetSolver | |
| CPorousResistanceComputation | |
| ►Neigen_solution_input_process | |
| CEigenSolutionInputProcess | A process for reading eigenvalue and eigenvector results |
| ►Neigen_solution_output_process | |
| CEigenSolutionOutputProcess | A process for writing eigenvalue and eigenvector results |
| ►Nelement_deactivation_process | |
| CElementDeactivationProcess | This process deactivates elements according to a defined integration point variable threshold |
| ►Nelement_sensitivity_domain_integration_process | |
| CElementSensitivityDomainIntegrationProcess | This class integrates scalar element sensitivities (material and cross-section properties like CROSS_AREA or YOUNGS_MODULUS) within defined domains |
| ►Nelementary_tests_GENS_NOVA | |
| CTestModifiedCamClayModel | |
| ►Nembedded | |
| CSearchEmbeddedDEMTools | |
| ►Nempire_mortar_mapper | |
| CEmpireMortarMapper | Wrapper for the Mortar mapper of EMPIRE |
| ►Nempire_wrapper | |
| ►CEmpireWrapper | |
| C__EmpireWrapper | |
| ►Nempirical_cubature_method | |
| CEmpiricalCubatureMethod | This class selects a subset of elements and corresponding positive weights necessary for the construction of a hyper-reduced order model Reference: Hernandez 2020 |
| ►Nempirical_spring_element_process | |
| CEmpiricalSpringElementProcess | |
| ►Nempty_output_process | |
| CEmptyOutputProcess | |
| ►Nempty_solver_for_testing | |
| CEmptySolverForTesting | |
| ►Nethier_benchmark_analysis | |
| CEthierBenchmarkAnalysis | |
| ►Nexact_hinsberg_test | |
| CProblemParameters | |
| CHinsbergPointsSetGivenNorm | |
| ►Nexecution_policy | |
| CExecutionPolicy | |
| ►Nexecution_policy_decorator | |
| CExecutionPolicyDecorator | |
| ►Nexplicit_penalty_contact_process | |
| CExplicitPenaltyContactProcess | This class is used in order to compute the contact using a mortar penalty formulation in explicit integration schemes |
| ►Nfde_solve | |
| Cfde_solve | Solves (1+\mathcal{L})^{\alpha}\mathcal{L}^{\beta}\psi = f in [0,H] \psi = 0 at z=0 d\psi/dz = 0 at z=H |
| ►Nfem_dem_coupled_gid_output | |
| CFemDemCoupledGiDOutput | The constructor of the FemDemCoupledGiDOutput-Object |
| ►NFemDemDynamicSolver | |
| CImplicitMechanicalSolver | |
| ►NFemDemMechanicalSolver | |
| CFemDemMechanicalSolver | The base class for solid mechanics solvers |
| ►NFEMDEMParticleCreatorDestructor | |
| CFemDemParticleCreatorDestructor | |
| ►NFemDemStaticSolver | |
| CStaticMechanicalSolver | The solid mechanics static solver |
| ►Nfield_utilities | |
| CPorosityField | |
| ►Nfinite_difference_sensitivity_utilities | |
| CFiniteDifferenceBodyFittedDragShapeSensitivityAnalysis | |
| CFiniteDifferenceVelocityPressureNormSquareShapeSensitivityAnalysis | |
| ►Nfix_scalar_variable_process | |
| CFixScalarVariableProcess | This process fixes a scalar variable without modifying the value of the variable |
| ►Nfix_vector_variable_process | |
| CFixVectorVariableProcess | This process fixes the selected components of a given vector variable without modifying the value of the variable |
| ►Nflow_output_process | |
| CFlowOutputProcess | This process calculates(using c++ utilities) and writes the flow through a given list of (sub)model parts |
| ►Nfluid_chimera_analysis | |
| CFluidChimeraAnalysis | Main script for fluid chimera simulations using the navier stokes family of python solvers |
| ►Nfluid_coupled_DEM_analysis | |
| CFluidCoupledDEMAnalysisStage | |
| ►Nfluid_DEM_coupling_solver | |
| CFluidDEMSolver | |
| ►Nfluid_dynamics_analysis | |
| CFluidDynamicsAnalysis | Main script for fluid dynamics simulations using the navier_stokes family of python solvers |
| ►Nfluid_dynamics_analysis_rom | |
| CFluidDynamicsAnalysisROM | |
| ►Nfluid_dynamics_analysis_rve | |
| CFluidDynamicsAnalysisRve | |
| CFluidDynamicsAnalysisRVE | |
| ►Nfluid_dynamics_hydraulic_analysis | |
| CFluidDynamicsHydraulicsAnalysis | Main script for fluid dynamics simulations using the navier_stokes family of python solvers |
| ►Nfluid_fraction_test_analysis | |
| CFluidFractionTestAnalysis | |
| ►Nfluid_fraction_test_solver | |
| CFluidFractionTestSolver | |
| ►Nfluid_mesher | |
| CFluidMesher | |
| ►Nfluid_meshing_domain | |
| CFluidMeshingDomain | |
| ►Nfluid_meshing_strategy | |
| CFluidMeshingStrategy | |
| ►Nfluid_refining_mesher | |
| CFluidRefiningMesher | |
| ►Nfluid_solver | |
| CFluidSolver | The base class for fluid dynamics solvers |
| ►Nfluid_transport_analysis | |
| CFluidTransportAnalysis | Main script for fluid + fluid transport simulations |
| ►Nfluid_transport_coupling_analysis | |
| CFluidTransportCouplingAnalysis | Main script for fluid + fluid transport simulations |
| ►Nfluid_transport_replace_solver | |
| CFluidTransportReplaceSolver | |
| ►Nfluid_transport_solver | |
| CFluidTransportSolver | |
| ►Nfooting_problem_process | |
| CFootingProblemProcess | |
| ►Nformulations | |
| ►Nincompressible_potential_flow | |
| CIncompressiblePotentialFlowRansFormulation | |
| ►Nrans_formulation | |
| CRansFormulation | |
| ►Nfrac_step_solverQ | |
| CFracStepSolver | |
| ►Nfractional_step_k_epsilon_rans_formulation | |
| CFractionalStepKEpsilonRansFormulation | |
| ►Nfractional_step_k_omega_rans_formulation | |
| CFractionalStepKOmegaRansFormulation | |
| ►Nfractional_step_k_omega_sst_rans_formulation | |
| CFractionalStepKOmegaSSTRansFormulation | |
| ►Nfractional_step_velocity_pressure_rans_formulation | |
| CFractionalStepVelocityPressureRansFormulation | |
| ►Nfree_surface_analysis | |
| CFreeSurfaceAnalysis | Main script for free surface application |
| ►Nfrom_json_check_result_process | |
| CFromJsonCheckResultProcess | This class is used in order to check results using a json file containing the solution a given model part with a certain frequency |
| ►Nfsi_analysis | |
| CFsiAnalysis | Main script for FSI simulations using the FSI family of python solvers |
| CFSIAnalysis | |
| ►Nfsi_coupling_interface | |
| CFSICouplingInterface | |
| ►Ngap_closure_interface_activation_process | |
| CGapClosureInterfaceActivationProcess | All the python processes should be derived from "python_process" |
| ►Ngauss_point_utility | |
| CGaussPointUtility | |
| ►NGaussianRandomField | |
| CGaussianRandomField | Gaussian Random Field generator class |
| CVectorGaussianRandomField | |
| ►NGenerateCN | |
| CGenerateCN | |
| ►NGenerateWind | |
| CGenerateWind | |
| ►Ngeo_mechanics_analysis | |
| CGeoMechanicsAnalysis | |
| ►Ngeomechanics_analysis | |
| CGeoMechanicsAnalysisBase | Main script for geomechanics simulations |
| CGeoMechanicsAnalysis | |
| ►Ngeomechanics_Pw_solver | |
| CPwSolver | Solver for the solution of displacement-pore pressure coupled problems |
| ►Ngeomechanics_solver | |
| CGeoMechanicalSolver | The base class for geomechanics solvers |
| ►Ngeomechanics_T_solver | |
| CTSolver | Solver for the solution of thermal problems |
| ►Ngeomechanics_U_Pw_solver | |
| CUPwSolver | Solver for the solution of displacement-pore pressure coupled problems |
| ►Ngeometric_centroid_deviation_response_function | |
| CGeometricCentroidDeviationResponseFunction | |
| ►Ngid_dam_output_process | |
| CGiDDamOutputProcess | |
| CMultifileList | |
| ►Ngid_mesh_to_mdpa | |
| CGidMeshConverter | Very simple function to parse a Gid mesh file and extract nodal coordinates and tetrahedra connectivity |
| ►Ngid_output | |
| CGiDOutput | |
| ►Ngid_output_process | |
| CGiDOutputProcess | |
| ►Nglobal_joint_stress_utility | |
| CGlobalJoinStressUtility | |
| ►Ngradual_variable_interpolation_process | |
| CGradualVariableInterpolationProcess | This class defines a process for gradually interpolating nodal values from one model part to another, called the origin and destination model parts respectively |
| ►Nhdf5_io_tools | |
| CFluidHDF5Loader | |
| CParticleHistoryLoader | |
| ►Nhdf5_output_tool | |
| CHdf5OutputTool | |
| ►Nhdf5_script | |
| CErrorProjectionPostProcessTool | |
| CParticleDragForcePostProcessTool | |
| ►Nhelmholtz_analysis | |
| CHelmholtzAnalysis | This class is the main-script of the implicit filtering analysis It can be imported and used as "black-box" |
| ►Nhelmholtz_scalar_solver | |
| CHelmholtzScalarSolver | |
| ►Nhelmholtz_solver_base | |
| CHelmholtzSolverBase | The base class for Helmholtz-based solvers |
| ►Nhelmholtz_vector_solver | |
| CHelmholtzVectorSolver | |
| ►Nhelpers | |
| ►Ndummy_solver_wrapper | |
| CDummySolverWrapper | This class serves as dummy for testing, it does not solve anything It only imports a mesh that can be used in the testing workflow |
| ►Nhigh_cycle_fatigue_analysis | |
| CHighCycleFatigueAnalysis | This class is used to complement the structurea_mechanics_analysis when using the HCF constitutive law |
| ►Nhinsberg_optimization | |
| CK_B | |
| CK_component | |
| CK_sum | |
| CFunctional | |
| ►Nhinsberg_optimization_3 | |
| CK_B | |
| CK_component | |
| CK_sum | |
| CFunctional | |
| ►Nhinsberg_optimization_4 | |
| CK_B | |
| CK_component | |
| CK_sum | |
| CFunctional | |
| ►Nhrom_training_utility | |
| CHRomTrainingUtility | Auxiliary utility for the HROM training |
| ►Nice_continuum_sphere_strategy | |
| CExplicitStrategy | |
| ►Niga_output_process | |
| CIgaOutputProcess | |
| ►Nimport_mdpa_modeler | |
| CImportMDPAModeler | |
| ►Nimport_med_modeler | |
| CImportMedModeler | |
| ►Nimpose_2d_random_fields_variable_process | |
| CImpose2dRandomFieldsVariableProcess | |
| ►Nimpose_3d_random_fields_variable_process | |
| CImpose3dRandomFieldsVariableProcess | |
| ►Nimpose_chemo_mechanical_aging_process | |
| CImposeChemoMechanicalAgingProcess | |
| ►Nimpose_face_heat_flux_process | |
| CImposeFaceHeatFluxProcess | |
| ►Nimpose_grouting_reference_temperature_process | |
| CImposeGroutingReferenceTemperatureProcess | |
| ►Nimpose_heat_source_process | |
| CImposeHeatSourceProcess | All the processes python should be derived from "Process" |
| ►Nimpose_input_table_nodal_young_modulus_process | |
| CImposeInputTableNodalYoungModulusProcess | |
| ►Nimpose_mesh_motion_process | |
| CImposeMeshMotionProcess | Impose a rotation followed by translation on a ModelPart |
| ►Nimpose_nodal_reference_temperature_process | |
| CImposeNodalReferenceTemperatureProcess | |
| ►Nimpose_nodal_young_modulus_process | |
| CImposeNodalYoungModulusProcess | |
| ►Nimpose_reservoir_temperature_condition_process | |
| CImposeReservoirTemperatureConditionProcess | |
| ►Nimpose_rigid_movement_process | |
| CImposeRigidMovementProcess | All the processes python should be derived from "Process" |
| ►Nimpose_temperature_by_device_process | |
| CImposeTemperaturebyDeviceProcess | |
| ►Nimpose_thermal_parameters_scalar_value_process | |
| CImposeThemalParametersScalarValueProcess | All the processes python should be derived from "Process" |
| ►Nimpose_uniform_temperature_process | |
| CImposeUniformTemperatureProcess | |
| ►Nimpose_water_loads_condition_process | |
| CImposeWaterLoadsConditionProcess | All the processes python should be derived from "Process" |
| ►Nindependent_analysis_execution_policy | |
| CIndependentAnalysisExecutionPolicy | |
| ►Ninitial_time_bounds | |
| CProblemParameters | |
| CHinsbergPointsSetGivenNorm | |
| ►Ninput_manager | |
| CInputManager | The base class for solid mechanic input parameters and materials |
| ►Nintegration_values_extrapolation_to_nodes_process | |
| CIntegrationValuesExtrapolationToNodesProcess | All the processes python should be derived from "Process" |
| ►Njson_output_process | |
| CJsonOutputProcess | This class is used in order to create a json file containing the solution a given model part with a certain frequency |
| ►Njson_settings_utility | |
| CJsonSettingsUtility | |
| ►Nk_epsilon_rans_formulation | |
| CKEpsilonKRansFormulation | |
| CKEpsilonEpsilonRansFormulation | |
| CKEpsilonRansFormulation | |
| ►Nk_omega_rans_formulation | |
| CKOmegaKRansFormulation | |
| CKOmegaOmegaRansFormulation | |
| CKOmegaRansFormulation | |
| ►Nk_omega_sst_rans_formulation | |
| CKOmegaSSTKRansFormulation | |
| CKOmegaSSTOmegaRansFormulation | |
| CKOmegaSSTRansFormulation | |
| ►NKratos | REF: G. R. Cowper, GAUSSIAN QUADRATURE FORMULAS FOR TRIANGLES |
| ►NBinaryOperations | |
| CAddition | |
| CSubstraction | |
| CMultiplication | |
| CDivision | |
| CPower | |
| ►NContainerDataIOTags | |
| CHistorical | |
| CNonHistorical | |
| CProperties | |
| ►NEmbeddedLaplacianInternals | |
| CEmbeddedElementData | |
| ►NEntitiesUtilities | |
| CEntitityIdentifier | Template struct for entity identifier |
| ►NExplicitFilterHelperUtilities | |
| CNonIntegratedWeight | |
| CIntegratedWeight | |
| ►NFluxConditionInternals | |
| CIntegrationData | |
| ►NHDF5 | |
| ►NDetail | |
| CVertex | |
| CZeroInitialized | |
| CZeroInitialized< array_1d< TValue, ArraySize > > | |
| CZeroInitialized< Matrix< TValue > > | |
| ►NInternals | |
| CConnectivitiesData | Represents connectivities information of a single element or condition type in a mesh |
| CPointsData | A class representing points in a mesh |
| CConditionDataValueIO | A class for IO of element data in HDF5 |
| CConditionFlagValueIO | A class for IO of element data in HDF5 |
| CConditionGaussPointOutput | A class for IO of element data in HDF5 |
| CContainerComponentIO | A class for IO of element data in HDF5 |
| CContainerGaussPointOutput | A class for IO of element data in HDF5 |
| CElementDataValueIO | A class for IO of element data in HDF5 |
| CElementFlagValueIO | A class for IO of element data in HDF5 |
| CElementGaussPointOutput | A class for IO of element data in HDF5 |
| CWriteInfo | Stores information about a dataset written to HDF5 |
| CFile | A base class for reading and writing an HDF5 file |
| CModelPartIO | A class for serial IO of a model part in HDF5 |
| CNodalDataValueIO | A class for IO of non-historical nodal values in HDF5 |
| CNodalFlagValueIO | A class for IO of non-historical nodal values in HDF5 |
| CNodalSolutionStepBossakIO | A class for IO of nodal solution step data in HDF5 with weighted Bossak acceleration |
| CNodalSolutionStepDataIO | A class for IO of nodal solution step data in HDF5 |
| CPartitionedModelPartIO | A class for partitioned IO of a model part in HDF5 |
| CVertexContainerIO | |
| CVertexContainerCoordinateIO | |
| CVertexContainerVariableIO | |
| CXdmfConnectivitiesWriterProcess | Writes Xdmf connectivities |
| CNodalVariableGetter | |
| CHistoricalVariableGetter | |
| CNonHistoricalVariableGetter | |
| CPointLocatorAdaptor | |
| CBruteForcePointLocatorAdaptor | BruteForcePointLocator with configuration and tolerance persistence |
| ►NInternals | |
| CRegisteredPrototypeBase | |
| CRegisteredPrototype | |
| CMatrix | |
| CMPIDataType | |
| CMPIDataType< int > | |
| CMPIDataType< unsigned int > | |
| CMPIDataType< long unsigned int > | |
| CMPIDataType< double > | |
| CMPIDataType< bool > | |
| CMPIDataType< char > | |
| CMPIDataType< int64_t > | |
| CMPIDataType< std::pair< char, int > > | |
| CMPIDataType< std::pair< int, int > > | |
| CMPIDataType< std::pair< unsigned int, int > > | |
| CMPIDataType< std::pair< long unsigned int, int > > | |
| CMPIDataType< std::pair< double, int > > | |
| ►CDistanceSpatialContainersConfigure | This class contains the tools related with the distance spatial container cell data |
| CCellNodeData | This class contains the cell node data |
| ►CProfiler | |
| CScope | RAII wrapper for updating an Item |
| CProfilerSingleton | |
| CNullInitialized | Helper class for null-initializiation |
| CNullInitialized< array_1d< TValueType, ArraySize > > | |
| CFICSpecializedAddTimeIntegratedSystem | |
| CFICSpecializedAddTimeIntegratedSystem< TElementData, true > | |
| CFICSpecializedAddTimeIntegratedSystem< TElementData, false > | |
| CFluidElementTimeIntegrationDetail | |
| CStrainRateSpecialization | |
| CStrainRateSpecialization< TElementData, 2 > | |
| CStrainRateSpecialization< TElementData, 3 > | |
| CFluidElementTimeIntegrationDetail< TElementData, false > | |
| CFluidElementTimeIntegrationDetail< TElementData, true > | |
| CMakeSamplerAtLocalCoordinate | |
| ►NKEpsilonElementData | |
| CEpsilonElementData | |
| CKElementData | |
| ►NKEpsilonWallConditionData | |
| CEpsilonKBasedWallConditionData | |
| CEpsilonUBasedWallConditionData | |
| ►NKOmegaElementData | |
| CKElementData | |
| COmegaElementData | |
| ►NKOmegaSSTElementData | |
| CKElementData | |
| COmegaElementData | |
| ►NKOmegaWallConditionData | |
| COmegaKBasedWallConditionData | |
| COmegaUBasedWallConditionData | |
| ►NLineOutputProcessUtilities | |
| CVariableDataCollector | Class to get variable information |
| ►NMapperUtilities | |
| CMapperInterfaceInfoSerializer | Helper class to serialize/deserialize a vector containing MapperInterfaceInfos |
| ►NMethodUtilities | |
| CNonHistoricalDataValueRetrievalFunctor | |
| CHistoricalDataValueRetrievalFunctor | |
| ►NModelPartHelperUtils | |
| CSetReduction | |
| CContainerEntityMapReduction | |
| ►NMPIInternals | |
| CSendTraits | |
| CSendTraits< int > | |
| CSendTraits< bool > | |
| CSendTraits< double > | |
| CSendTraits< array_1d< double, TDim > > | |
| CSendTraits< Kratos::Flags > | |
| CSendTraits< Vector > | |
| CSendTraits< Matrix > | |
| CSendTraits< Quaternion< double > > | |
| CSendTraits< DenseVector< TVectorValue > > | |
| CSendTraits< Kratos::VariablesListDataValueContainer > | |
| CSendTraits< Node::DofsContainerType > | |
| CDirectCopyTransfer | |
| CDynamicArrayTypeTransfer | |
| CSendTools | |
| CSendTools< int > | |
| CSendTools< double > | |
| CSendTools< bool > | |
| CSendTools< array_1d< double, TDim > > | |
| CSendTools< Kratos::Flags > | |
| CSendTools< Vector > | |
| CSendTools< Matrix > | |
| CSendTools< Quaternion< double > > | |
| CSendTools< DenseVector< TVectorValue > > | |
| CSendTools< Kratos::VariablesListDataValueContainer > | |
| CSendTools< Node::DofsContainerType > | |
| CBufferAllocation | |
| CBufferAllocation< TDatabaseAccess, true > | |
| CBufferAllocation< TDatabaseAccess, false > | |
| CNodalContainerAccess | |
| CElementalContainerAccess | |
| CNodalSolutionStepValueAccess | |
| CNodalDataAccess | |
| CNodalFlagsAccess | |
| CNodalSolutionStepDataAccess | |
| CDofIdAccess | |
| CElementalDataAccess | |
| CElementalFlagsAccess | |
| ►NPotentialFlowUtilities | |
| CElementalData | |
| ►NPython | |
| ►NCoSimIO_Wrappers | |
| CDataBuffers | |
| ►NDetail | |
| CExpressionTrampoline | |
| CExpressionInputTrampoline | |
| CExpressionOutputTrampoline | |
| CArray1DModifier | |
| CControllerTrampoline | |
| CPyAdjointResponseFunction | |
| CContainerInterface | |
| CMapInterface | |
| CPointerVectorPythonInterface | |
| CPointerVectorSetPythonInterface | |
| CVariableIndexingPython | Short class definition |
| CVertexContainerIOTrampoline | |
| CPointLocatorAdaptorTrampoline | |
| CVariableChecker | |
| ►NSearchUtils | SEARCH UTILS //// |
| CSquaredDistanceFunction | |
| CCopyRange | |
| CSearchBoxInRange | |
| CSearchNearestInRange | |
| CSearchRadiusInRange | |
| ►NShellUtilities | |
| CJacobianOperator | JacobianOperator |
| ►NSpatialMethods | |
| CContainerSpatialMethods | |
| CHistoricalSpatialMethods | |
| CNodalNonHistoricalSpatialMethods | |
| CConditionNonHistoricalSpatialMethods | |
| CElementNonHistoricalSpatialMethods | |
| ►NTemporalMethods | |
| ►CTemporalMaxMethod | |
| CNormMethod | |
| ►CTemporalMeanMethod | |
| CNormMethod | |
| CValueMethod | |
| CTemporalMethod | |
| CContainerTemporalMethods | |
| CHistoricalTemporalMethods | |
| CHistoricalInputHistoricalOutputTemporalMethods | |
| CHistoricalInputNonHistoricalOutputTemporalMethods | |
| CNodalNonHistoricalTemporalMethods | |
| CConditionNonHistoricalTemporalMethods | |
| CElementNonHistoricalTemporalMethods | |
| ►CTemporalMinMethod | |
| CNormMethod | |
| ►CTemporalRootMeanSquareMethod | |
| CNormMethod | |
| CValueMethod | |
| ►CTemporalSumMethod | |
| CNormMethod | |
| CValueMethod | |
| ►CTemporalVarianceMethod | |
| CNormMethod | |
| CValueMethod | |
| ►NTesting | |
| ►NInternals | |
| CRegisterThisTest | |
| CAddThisTestToTestSuite | |
| CDistributedTestCase | Base class for distributed tests |
| CScopedEntry | |
| CScopedDirectory | Class representing a directory that follows RAII |
| CScopedFile | Class representing a file that follows RAII |
| CScopedSymlink | Class representing a symlink that follows RAII |
| CTestCase | The test case base class |
| CTestCaseResult | The test case base class |
| CTestSuite | This class holds an array of test cases and run them one by one in its Run method |
| CTester | Tester class manages all tests and provide interface to run them |
| ►NTimeDiscretization | |
| CBDF | |
| CBDF1 | |
| CBDF2 | |
| CBDF3 | |
| CBDF4 | |
| CBDF5 | |
| CBDF6 | |
| CNewmark | |
| CBossak | |
| CGeneralizedAlpha | |
| ►NUnaryStatisticOperations | |
| CMin | |
| CMax | |
| CSum | |
| ►NWind | |
| ►CModelSubdivisionUtilities | Utility for populating sub model parts |
| ►CSlab | A subset of R^3 between two parallel planes |
| CPlane | |
| CSlabStack | |
| CThreadSafeIndexSet | |
| CMeshCondition | This is pure geometric condition. The only purpose for this definition is to create dummy conditions |
| CLinearMasterSlaveConstraint | This class allows to add a master-slave constraint which is of the form SlaveDofVector = T * MasterDofVector + ConstantVector |
| CSlipConstraint | This constructs a constraint which imposes that v * n = 0 where: v is a variable n is the unit normal to the node |
| ►Carray_1d | Short class definition |
| Cconst_iterator | |
| Citerator | |
| CCsrMatrix | This class implements "serial" CSR matrix, including capabilities for FEM assembly |
| CDataValueContainer | Container for storing data values associated with variables |
| CDistributedCsrMatrix | This class implements "serial" CSR matrix, including capabilities for FEM assembly |
| CDistributedNumbering | This function provides essential capabilities for mapping between local and global ids in a distributed vector |
| CDistributedSparseGraph | Short class definition |
| CDistributedSystemVector | Provides a DistributedSystemVector which implements FEM assemble capabilities |
| CDistributedVectorExporter | Provides a DistributedVectorExporter which implements FEM assemble capabilities |
| CDistributedVectorImporter | Provides a DistributedVectorImporter which implements FEM assemble capabilities |
| ►CEdgeBasedDataStructure | |
| CEdgeData | |
| CFlags | |
| CGeometryContainer | |
| CGlobalPointersUnorderedMap | Short class definition |
| CGlobalPointersVector | This class is a vector which stores global pointers |
| CModel | This class aims to manage different model parts across multi-physics simulations |
| CNodalData | Stores all data and dofs which are stored in each elements |
| Cpartitioned_vector | Short class definition |
| CPeriodicVariablesContainer | A container of Kratos variables used to define a periodic boundary condition |
| CPointerHashMapSet | PointerHashMapSet is a hash implemenetation of the PointerVectorSet |
| CPointerVector | PointerVector is a container like stl vector but using a vector to store pointers to its data |
| CPointerVectorMap | PointerVectorMap is a sorted associative container like stl map but using a vector to store pointers to its data |
| CPointerVectorMapIterator | Short class definition |
| CPointerVectorSet | A sorted associative container similar to an STL set, but uses a vector to store pointers to its data |
| CSetIdentityFunction | A functor that serves as the identity function |
| ►CSparseContiguousRowGraph | Short class definition |
| Cconst_iterator_adaptor | |
| ►CSparseGraph | Short class definition |
| Cconst_iterator_adaptor | |
| CSystemVector | Provides a SystemVector which implements FEM assemble capabilities, as well as some vector operations |
| CVariable | Variable class contains all information needed to store and retrive data from a data container |
| CVariableData | This class is the base of variables and variable's components which contains their common data |
| CVariablesList | Holds a list of variables and their position in VariablesListDataValueContainer |
| CVariablesListDataValueContainer | A shared variable list gives the position of each variable in the containers sharing it |
| CWeakPointerVector | WeakPointerVector is a container like stl vector but using a vector to store pointers to its data |
| CWeakPointerVectorIterator | Short class definition |
| CController | The base class for all Controllers in Kratos |
| COutputController | |
| CDistanceCalculationElementSimplex | A stabilized element for the incompressible Navier-Stokes equations |
| CEdgeBasedGradientRecoveryElement | An element to compute the a nodal variable from an embedded skin |
| CEmbeddedNodalVariableCalculationElementSimplex | An element to compute the a nodal variable from an embedded skin |
| CLevelSetConvectionElementSimplex | Formulation described in https://docs.google.com/document/d/13a_zGLj6xORDuLgoOG5LwHI6BwShvfO166opZ815zLY/edit?usp=sharing |
| CLevelSetConvectionElementSimplexAlgebraicStabilization | |
| CMeshElement | This is pure geometric element. The only purpose for this definition is to create dummy elements |
| CBinaryExpression | |
| ►CCArrayExpressionIO | |
| CInput | |
| CMoveInput | |
| COutput | |
| CContainerDataIO | |
| CContainerDataIO< ContainerDataIOTags::Historical > | |
| CContainerDataIO< ContainerDataIOTags::NonHistorical > | |
| CContainerExpression | Container variable data holder |
| ►CDomainSizeExpressionIO | Utility class for domain size IO |
| CInput | Construct a new domain expression input |
| ►CExpression | Base class or all the expression types |
| CExpressionIterator | |
| CExpressionInput | |
| CExpressionOutput | |
| CExpressionIOUtils | |
| CExpressionUtils | |
| ►CIntegrationPointExpressionIO | |
| CInput | |
| COutput | |
| CLiteralExpression | Expression to hold a literal value |
| ►CLiteralExpressionIO | |
| CInput | |
| ►CLiteralFlatExpression | Expression to hold a literal with a flattened data structure |
| CData | This class is used represent the flattened data array |
| CLiteralScalarFlatExpression | |
| CLiteralNonScalarFlatExpression | |
| ►CNodalPositionExpressionIO | |
| CInput | |
| COutput | |
| CUnaryAbsExpression | Unary abs expression used to get the absolute values of a given input expression |
| CUnaryCombineExpression | Use to create an expression which combines given input expressions list in the order given |
| CUnaryReshapeExpression | Used to create lazy expression to reshape given expression to a new shape |
| CUnarySliceExpression | Unary slice expression used to represent a slicing lazy expression of a given input expression |
| CUnaryStatisticsExpression | Used to create lazy expression to get statistical quantities of entity values |
| CVariableExpressionDataIO | Construct class to read into expressions from templated data values and write in to templated data values |
| ►CVariableExpressionIO | |
| CInput | |
| COutput | |
| CFactoryBase | Here we define some common methods |
| CFactory | Here we add the functions needed for the registration of class |
| CLinearSolverFactory | Here we add the functions needed for the registration of linear solvers |
| CMapperFactory | Python Interface of the MappingApplication |
| CPreconditionerFactory | Here we add the functions needed for the registration of preconditioners |
| CStandardLinearSolverFactory | Here we add the functions needed for the registration of linear solvers |
| CStandardPreconditionerFactory | Here we add the functions needed for the registration of preconditioners |
| CBoundingBox | Representing a bounding box by storing the min and max points |
| CBrepCurve | The BrepCurve acts as topology for curves. Those can be enclosed by a certain set of points |
| CBrepCurveOnSurface | The BrepCurveOnSurface acts as topology for curves on surfaces |
| CBrepSurface | The BrepSurface acts as topology for faces. Those can be enclosed by a certain set of brep face curves |
| CCouplingGeometry | The CouplingGeometry connects two or more geometries of different types and entities |
| CGeometry | Geometry base class |
| CGeometryData | |
| CGeometryDimension | |
| CGeometryShapeFunctionContainer | |
| CHexahedra3D20 | A twenty node hexahedra geometry with serendipity shape functions |
| CHexahedra3D27 | A twenty-seven node hexahedra geometry with second order shape functions |
| CHexahedra3D8 | An eight node hexahedra geometry with linear shape functions |
| CHexahedraInterface3D8 | |
| CLine2D2 | An two node 2D line geometry with linear shape functions |
| CLine2D3 | An three node 2D line geometry with quadratic shape functions |
| CLine2D4 | An three node 2D line geometry with cubic shape functions |
| CLine2D5 | An five node 2D line geometry with quartic shape functions |
| CLine3D2 | An two node 3D line geometry with linear shape functions |
| CLine3D3 | An three node 3D line geometry with quadratic shape functions |
| CLineGaussLobatto3D2 | |
| CNurbsCurveGeometry | |
| CNurbsCurveOnSurfaceGeometry | |
| CNurbsCurveShapeFunction | NurbsCurveShapeFunction |
| CNurbsInterval | Class for optimized use of intervals |
| CNurbsSurfaceRefinementUtilities | |
| CNurbsSurfaceShapeFunction | |
| CNurbsVolumeRefinementUtilities | |
| CNurbsVolumeShapeFunction | |
| CNurbsSurfaceGeometry | |
| CNurbsVolumeGeometry | A volume geometry based on a full 3-dimensional BSpline tensor product |
| COrientedBoundingBox | This class defines the Oriented bounding box class |
| CPlane | |
| CPlane3D | |
| CPoint | Point class |
| CPoint2D | |
| CPoint3D | |
| CPointOnGeometry | |
| CPrism3D15 | A fifteen node prism geometry with quadratic shape functions |
| CPrism3D6 | A six node prism geometry with linear shape functions |
| CPrismInterface3D6 | |
| CPyramid3D13 | A 13 node pyramid geometry with quadratic shape functions |
| CPyramid3D5 | A five node pyramid geometry with linear shape functions |
| CQuadraturePointCurveOnSurfaceGeometry | |
| CQuadraturePointGeometry | A sinlge quadrature point, that can be used for geometries without a predefined integration scheme, i.e. they can handle material point elements, isogeometric analysis elements or standard finite elements which are defined at a single quadrature point. This point defines a line segment described on a underlying surface. Shape functions and integration types have to be precomputed and are set from from outside. The parent pointer can provide the adress to the owner of this quadrature point |
| CQuadraturePointSurfaceInVolumeGeometry | A sinlge quadrature point, that can be used for geometries without a predefined integration scheme, i.e. they can handle material point elements, isogeometric analysis elements or standard finite elements which are defined at a single quadrature point. This point defines a surface segment described in a underlying volume. Shape functions and integration types have to be precomputed and are set from outside. The parent pointer can provide the adress to the owner of this quadrature point |
| CQuadrilateral2D4 | A four node 2D quadrilateral geometry with bi-linear shape functions |
| CQuadrilateral2D8 | A eight node 2D quadrilateral geometry with quadratic shape functions |
| CQuadrilateral2D9 | A nine node 2D quadrilateral geometry with quadratic shape functions |
| CQuadrilateral3D4 | A four node 3D quadrilateral geometry with bi-linear shape functions |
| CQuadrilateral3D8 | A eight node 3D quadrilateral geometry with quadratic shape functions |
| CQuadrilateral3D9 | A nine node 3D quadrilateral geometry with quadratic shape functions |
| CQuadrilateralInterface2D4 | |
| CQuadrilateralInterface3D4 | |
| CSphere3D1 | |
| CSurfaceInNurbsVolumeGeometry | |
| CTetrahedra3D10 | A ten node tetrahedra geometry with quadratic shape functions |
| CTetrahedra3D4 | A four node tetrahedra geometry with linear shape functions |
| CTriangle2D10 | A ten node 2D triangular geometry with cubic shape functions |
| CTriangle2D15 | A fifteen node 2D triangular geometry with quartic shape functions |
| CTriangle2D3 | A three node 2D triangle geometry with linear shape functions |
| CTriangle2D6 | A six node 2D triangular geometry with quadratic shape functions |
| CTriangle3D3 | A three node 3D triangle geometry with linear shape functions |
| CTriangle3D6 | A six node 3D triangular geometry with quadratic shape functions |
| CAccessor | This class defines the way a certain property is accessed |
| CKratosZeroMatrix | |
| CKratosZeroVector | |
| Cscalar_matrix | |
| CPermutationMatrix | |
| CChunk | Chunk is the smallest building block of Kratos memory management |
| CCodeLocation | |
| CCommunicator | The Commmunicator class manages communication for distributed ModelPart instances |
| CCondition | Base class for all Conditions |
| ►CConstitutiveLaw | |
| CFeatures | |
| CParameters | |
| CConvectionDiffusionSettings | Convection diffusion settings. This class contains information to be used by the convection diffusion solver, all the variables that will be needed by the solver |
| CDataCommunicator | Serial (do-nothing) version of a wrapper class for MPI communication |
| CDofTrait | |
| CDof | Dof represents a degree of freedom (DoF) |
| CElement | Base class for all Elements |
| CException | Extends the std::exception class with more information about error location |
| CFileSerializer | |
| CFillCommunicator | Base class defining the API for the fill communicator utilities |
| CFixedSizeMemoryPool | FixedSizeMemoryPool is the multi-thread manager of Kratos memory management |
| CFNV1a32Hash | A constexpr version of FNV hash function. (32 bit version) |
| CFNV1a64Hash | A constexpr version of FNV hash function. (64 bit version) |
| CGeometricalObject | This defines the geometrical object, base definition of the element and condition entities |
| CGidGaussPointsContainer | |
| CGidIOBase | Base class for GidIO |
| CGidIO | This class defines an interface to the GiDPost library in order to provide GiD compliant I/O functionality |
| CGidMeshContainer | |
| CGlobalPointer | This class is a wrapper for a pointer to a data that is located in a different rank |
| CGlobalPointerHasher | Template struct for hashing GlobalPointer instances |
| CGlobalPointerComparor | This is a key comparer between two dof pointers checking for equal keys |
| CGlobalPointerCompare | This is a key compare between two pointers to the object object |
| CIndexedObject | This object defines an indexed object |
| CInitialState | Define the initial state of the material in terms of initial stress/strain/F |
| ►CIO | IO provides different implementation of input output procedures which can be used to read and write with different formats and characteristics |
| CPartitioningInfo | |
| CKratosJsonIO | An IO class for reading and writing a modelpart |
| CKernel | Kernel is in charge of synchronization the whole system of Kratos itself and its application |
| CKeyComparorRange | This is a key comparer of general pourpose between two classes |
| CKeyHasherRange | This is a hasher of general pourpose |
| CVariableHasher | This is a hasher for variables |
| CVariableComparator | This is a key comparer between two variables |
| CpVariableHasher | This is a hasher for variables pointers |
| CpVariableComparator | This is a key comparer between two variables pointers |
| CIndexedObjectHasher | This is a hasher for indexed objects |
| CIndexedObjectComparator | This is a key comparer between two indexed objects |
| CIndexedObjectPointerHasher | This is a hasher for indexed objects (pointer) |
| CIndexedObjectPointerComparator | This is a key comparer between two indexed objects (pointer) |
| CSharedPointerHasher | This is a hasher for shared pointers |
| CSharedPointerComparator | This is a key comparer between two shared pointers |
| CVectorIndexHasher | This is a hasher between two vectors of indexes |
| CVectorIndexComparor | This is a key comparer between two vectors of indexes |
| CDofPointerHasher | This is a hasher for a dof pointers |
| CDofPointerComparor | This is a key comparer between two dof pointers |
| CPairHasher | This is a hasher for pairs |
| CPairComparor | This is a key comparer between two indexes pairs |
| CKratosApplication | This class defines the interface with kernel for all applications in Kratos |
| CKratosComponents | KratosComponents class encapsulates a lookup table for a family of classes in a generic way |
| CKratosComponents< VariableData > | |
| CFilesystemExtensions | |
| CParameters | This class provides to Kratos a data structure for I/O based on the standard of JSON |
| CLockObject | This class defines and stores a lock and gives an interface to it |
| CIndexDatabase | Base class to derive common methods |
| CIndexSet | Custom unordered set container to be used by the mapper |
| CIndexMap | Custom unordered map container to be used by the mapper |
| CMasterSlaveConstraint | A class that implements the interface for different master-slave constraints to be applied on a system |
| CMemoryInfo | MemoryInfo gives the OS information about the memory usage by Kratos |
| CMemoryPool | MemoryPool is the smallest building block of Kratos memory management |
| CMesh | Mesh is the second level of abstraction in the data structure which hold Nodes, Elements and Conditions and their Properties |
| CModelPart | This class aims to manage meshes for multi-physics simulations |
| CModelPartIO | An IO class for reading and writing a modelpart |
| CMortarKinematicVariables | MortarKinematicVariables |
| CMortarKinematicVariablesWithDerivatives | MortarKinematicVariablesWithDerivatives |
| CDerivativeData | This data will be used to compute the derivatives |
| CDerivativeDataFrictional | This class is a derived class of DerivativeData |
| CMortarOperator | This is the definition of the mortar operator according to the work of Alexander Popp: https://www.lnm.mw.tum.de/staff/alexander-popp/ |
| CMortarOperatorWithDerivatives | This class derives from the MortarOperator class and it includes the derived operators |
| CDualLagrangeMultiplierOperators | This is the definition dual lagrange multiplier operators according to the work of Alexander Popp: https://www.lnm.mw.tum.de/staff/alexander-popp/ |
| CDualLagrangeMultiplierOperatorsWithDerivatives | This is the definition dual lagrange multiplier operators including the derivatives |
| CPointBelong | Custom Point container to be used by the mapper |
| CMpiSerializer | |
| CNeighbours | Short class definition |
| CNode | This class defines the node |
| CEnvironmentManager | |
| CParallelEnvironment | Holder for general data related to MPI (or suitable serial equivalents for non-MPI runs) |
| CPeriodicCondition | Condition used to assign periodic boundary conditions |
| CTable | This class represents the value of its variable depending to other variable |
| CPoolObject | This redefines the new and delete operators of derived class to be allocated in pool |
| CPrimeNumbers | Gives a prime number before or after given number |
| CProcessInfo | ProcessInfo holds the current value of different solution parameters |
| CProperties | Properties encapsulates data shared by different Elements or Conditions. It can store any type of data and provides a variable base access to them |
| CRadiationSettings | Short class definition |
| CRegistry | Kratos 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 |
| CRegistryAuxiliaries | Kratos registry auxiliaries This static class collect all the auxiliary functions to be used to register c++ items |
| ►CRegistryItem | The registry item to be stored by Registry class. It is the base class for some more specific ones |
| CKeyReturnConstIterator | Custom iterator with key as return type to be used in the Python export |
| CReorderConsecutiveModelPartIO | An IO class for reading and writing a modelpart |
| CSerializer | The 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 |
| CStreamSerializer | |
| CTable< double, double > | |
| CTableAccessor | This class defines the way a certain property is accessed according to a table |
| Cendl | |
| CTableStream | This is a fancy table to stream data in a fancy way |
| CThreadFixedSizeMemoryPool | ThreadFixedSizeMemoryPool holds chunks belong to a certain thread and operate over them |
| ►CBase64EncodedOutput | Encodes given iterator data to base 64 string representation |
| CByteIterator | A forward iterator that iterates over bytes in a sequence |
| CCadJsonInput | |
| CCadJsonOutput | |
| CFileLoggerOutput | FileLoggerOutput is a class for all file logger outputs |
| CLogger | Logger is in charge of writing the messages to output streams |
| ►CLoggerMessage | LoggerMessage class holdes message and the properties of the message |
| CDistributedFilter | |
| CMessageSource | |
| CLoggerOutput | LoggerOutput is the base class for all logger outputs |
| CLoggerTableOutput | LoggerTableOutput takes columns names and only prints the messages with lable given with column name |
| CStlIO | This class reads from STL file format and creates triangular elements in given model_part |
| CUnvOutput | Provides a tool to write UNV files |
| CVtkDefinitions | |
| CVtkOutput | VtkOutput A simple class that has functionality to write vtk output |
| CVtuOutput | Class to output Kratos Flags, Variables and ContainerExpressions to vtu. Supports both shared and distributed memory architectures |
| CHexahedronGaussLegendreIntegrationPoints1 | |
| CHexahedronGaussLegendreIntegrationPoints2 | |
| CHexahedronGaussLegendreIntegrationPoints3 | |
| CHexahedronGaussLegendreIntegrationPoints4 | |
| CHexahedronGaussLegendreIntegrationPoints5 | |
| CHexahedronGaussLobattoIntegrationPoints1 | |
| CHexahedronGaussLobattoIntegrationPoints2 | |
| CIntegrationInfo | Integration information for the creation of integration points |
| CIntegrationPoint | Short class definition |
| CIntegrationPointUtilities | |
| CLineCollocationIntegrationPoints1 | |
| CLineCollocationIntegrationPoints2 | |
| CLineCollocationIntegrationPoints3 | |
| CLineCollocationIntegrationPoints4 | |
| CLineCollocationIntegrationPoints5 | |
| CLineGaussLegendreIntegrationPoints1 | |
| CLineGaussLegendreIntegrationPoints2 | |
| CLineGaussLegendreIntegrationPoints3 | |
| CLineGaussLegendreIntegrationPoints4 | |
| CLineGaussLegendreIntegrationPoints5 | |
| CLineGaussLegendreIntegrationPoints6 | |
| CLineGaussLegendreIntegrationPoints7 | |
| CLineGaussLegendreIntegrationPoints8 | |
| CLineGaussLegendreIntegrationPoints9 | |
| CLineGaussLegendreIntegrationPoints10 | |
| CLineGaussLobattoIntegrationPoints1 | |
| CLineGaussLobattoIntegrationPoints2 | |
| CLineGaussLobattoIntegrationPoints3 | |
| CLineGaussLobattoIntegrationPoints4 | |
| CLineGaussLobattoIntegrationPoints5 | |
| CLineGaussLobattoIntegrationPoints6 | |
| CLineGaussLobattoIntegrationPoints7 | |
| CLineGaussLobattoIntegrationPoints8 | |
| CLineGaussLobattoIntegrationPoints9 | |
| CLineGaussLobattoIntegrationPoints10 | |
| CPrismGaussLegendreIntegrationPoints1 | |
| CPrismGaussLegendreIntegrationPoints2 | |
| CPrismGaussLegendreIntegrationPoints3 | |
| CPrismGaussLegendreIntegrationPoints4 | |
| CPrismGaussLegendreIntegrationPoints5 | |
| CPrismGaussLegendreIntegrationPointsExt1 | |
| CPrismGaussLegendreIntegrationPointsExt2 | |
| CPrismGaussLegendreIntegrationPointsExt3 | |
| CPrismGaussLegendreIntegrationPointsExt4 | |
| CPrismGaussLegendreIntegrationPointsExt5 | |
| CPrismGaussLobattoIntegrationPoints1 | |
| CPrismGaussLobattoIntegrationPoints2 | |
| CPyramidGaussLegendreIntegrationPoints1 | |
| CPyramidGaussLegendreIntegrationPoints2 | |
| CPyramidGaussLegendreIntegrationPoints3 | |
| CPyramidGaussLegendreIntegrationPoints4 | |
| CPyramidGaussLegendreIntegrationPoints5 | |
| CPow | |
| CPow< 1 > | |
| CQuadrature | Short class definition |
| CQuadrilateralCollocationIntegrationPoints1 | |
| CQuadrilateralCollocationIntegrationPoints2 | |
| CQuadrilateralCollocationIntegrationPoints3 | |
| CQuadrilateralCollocationIntegrationPoints4 | |
| CQuadrilateralCollocationIntegrationPoints5 | |
| CQuadrilateralGaussLegendreIntegrationPoints1 | |
| CQuadrilateralGaussLegendreIntegrationPoints2 | |
| CQuadrilateralGaussLegendreIntegrationPoints3 | |
| CQuadrilateralGaussLegendreIntegrationPoints4 | |
| CQuadrilateralGaussLegendreIntegrationPoints5 | |
| CQuadrilateralGaussLobattoIntegrationPoints1 | |
| CQuadrilateralGaussLobattoIntegrationPoints2 | |
| CTetrahedronGaussLegendreIntegrationPoints1 | |
| CTetrahedronGaussLegendreIntegrationPoints2 | |
| CTetrahedronGaussLegendreIntegrationPoints3 | |
| CTetrahedronGaussLegendreIntegrationPoints4 | |
| CTetrahedronGaussLegendreIntegrationPoints5 | |
| CTriangleCollocationIntegrationPoints1 | |
| CTriangleCollocationIntegrationPoints2 | |
| CTriangleCollocationIntegrationPoints3 | |
| CTriangleCollocationIntegrationPoints4 | |
| CTriangleCollocationIntegrationPoints5 | |
| CTriangleGaussLegendreIntegrationPoints1 | |
| CTriangleGaussLegendreIntegrationPoints2 | |
| CTriangleGaussLegendreIntegrationPoints3 | |
| CTriangleGaussLegendreIntegrationPoints4 | |
| CTriangleGaussLegendreIntegrationPoints5 | |
| CTriangleGaussRadauIntegrationPoints1 | |
| CTriangleGaussRadauIntegrationPoints2 | |
| CTriangleGaussRadauIntegrationPoints3 | |
| CTriangleGaussRadauIntegrationPoints4 | |
| CTriangleGaussRadauIntegrationPoints5 | |
| CTriangleGaussRadauIntegrationPoints6 | |
| CAMGCL_NS_Solver | |
| CAMGCLSolver | This is a multigrid solver based on the AMGCL library |
| CBICGSTABSolver | Short class definition |
| CCGSolver | Short class definition |
| CDeflatedCGSolver | Short class definition |
| CDiagonalPreconditioner | DiagonalPreconditioner class |
| CDirectSolver | |
| CILU0Preconditioner | ILU0Preconditioner class |
| CILUPreconditioner | ILUPreconditioner class |
| CIterativeSolver | Base class for all the iterative solvers in Kratos |
| CLinearSolver | Base class for all the linear solvers in Kratos |
| CMonotonicityPreservingSolver | |
| CPowerIterationEigenvalueSolver | This class uses the inverted power iteration method to obtain the lowest eigenvalue of a system |
| CPowerIterationHighestEigenvalueSolver | This class uses the inverted power iteration method to obtain the lowest eigenvalue of a system |
| CPreconditioner | Preconditioner class |
| CRayleighQuotientIterationEigenvalueSolver | This is a eigen solver based on the Rayleigh quotient iteration algorithm |
| CReorderer | Base class for all reorderer objects in Kratos used in linear solvers |
| CScalingSolver | This solvers rescales in order to improve the conditioning of the system |
| CSkylineLUCustomScalarSolver | |
| CLUSkylineFactorization | |
| CSkylineLUFactorizationSolver | |
| CTFQMRSolver | |
| CMapper | Base Class for all Mappers |
| CMapperFlags | Flags needed used in the MappingApplication |
| CCadIoModeler | Short class definition |
| CCartesianMeshGeneratorModeler | Short class definition |
| CCombineModelPartModeler | This modeler combines several model parts into a new one. All input model parts should share the same root model part |
| CConnectivityPreserveModeler | A tool to generate a copy of a ModelPart, sharing the same nodes as the original |
| CCopyPropertiesModeler | Copy the properties from one model part to another |
| CCreateEntitiesFromGeometriesModeler | Modeler to create element/condition entities from geometries |
| CDuplicateMeshModeler | Short class definition |
| CEdgeSwapping2DModeler | Optimizes a 2D mesh by swapping the edges between elements |
| CMeshSuiteModeler | Short class definition |
| CModeler | Modeler to interact with ModelParts |
| CSerialModelPartCombinatorModeler | This modeler combines several model parts in serial, reading its respective *.mdpa files (maybe others in the future) |
| CStructuredMeshRefinementModeler | Short class definition |
| CTetrahedraBall | Stores a ball of tetrahedra sourronding a node of mesh |
| CTetrahedraEdgeShell | This class defines an edge shell for a mesh of tetrahedra |
| CAusasModifiedShapeFunctions | |
| CModifiedShapeFunctions | |
| CTetrahedra3D4AusasIncisedShapeFunctions | |
| CTetrahedra3D4AusasModifiedShapeFunctions | |
| CTetrahedra3D4ModifiedShapeFunctions | |
| CTriangle2D3AusasIncisedShapeFunctions | |
| CTriangle2D3AusasModifiedShapeFunctions | |
| CTriangle2D3ModifiedShapeFunctions | |
| CMPICommunicator | MPICommunicator manages the transfer of ModelPart data in MPI distributed memory environment |
| CMPIDataCommunicator | Wrapper for common MPI calls within Kratos |
| CMPIManager | Helper class to manage the MPI lifecycle |
| CMPIMessage | |
| CAmgclDistributedCSRConversionUtilities | |
| CDistributedAmgclCSRSpMMUtilities | |
| ►CMpiDebugUtilities | |
| Cis_any | |
| Cis_kratos_bounded_vector_variable | |
| Cis_kratos_single_variable | |
| Cis_kratos_unbounded_vector_variable | |
| CDistributedModelPartInitializer | Initialize a distributed ModelPart from a serial one |
| CGatherModelPartUtility | |
| CModelPartCommunicatorUtilities | Utilitiy class for ModelPart::Comunicator management in an MPI context |
| CMPINormalCalculationUtils | Some tools to calculate face and nodal normals on an MPI partitioned environment |
| CParallelFillCommunicator | This function recomputes the communication plan for MPI |
| COperation | The base class for all operations in Kratos |
| CApplyConstantScalarValueProcess | The base class for all processes in Kratos |
| CApplyConstantVectorValueProcess | The base class for all processes in Kratos |
| CApplyPeriodicConditionProcess | |
| CApplyRayCastingInterfaceRecognitionProcess | Applies ray casting to distinguish the color (like in/out) of each node in modelpart |
| CApplyRayCastingProcess | Applies ray casting to distinguish the color (like in/out) of each node in modelpart |
| CAssignScalarFieldToEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignScalarInputToEntitiesProcessSettings | This struct is used in order to identify when using the hitorical and non historical variables |
| CAssignScalarInputToEntitiesProcess | This function assigns a value from an input to a variable belonging to all of the entities in a given mesh |
| CAssignScalarVariableToEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CCalculateDiscontinuousDistanceToSkinProcessFlags | |
| CCalculateDiscontinuousDistanceToSkinProcess | This only calculates the distance. Calculating the inside outside should be done by a derived class of this |
| CCalculateDistanceToPathSettings | This struct is used in order to identify when using the hitorical and non historical variables |
| CCalculateDistanceToPathProcess | Computes DISTANCE from a path model part to a given model part |
| CCalculateDistanceToSkinProcess | Calculates the nodal distances using elemental discontinuous distances |
| CEmbeddedNodalVariableFromSkinTypeHelperClass | |
| CCalculateEmbeddedNodalVariableFromSkinProcess | |
| CCalculateEmbeddedSignedDistanceTo3DSkinProcess | Short class definition |
| CCalculateNodalAreaSettings | This struct is used in order to identify when using the hitorical and non historical variables |
| CCalculateNodalAreaProcess | Computes NODAL_AREA |
| ►CDistanceSpatialContainersConditionConfigure | |
| CCellNodeData | |
| ►CCalculateSignedDistanceTo3DConditionSkinProcess | Short class definition |
| CIntersectionNodeStruct | |
| CTetEdgeStruct | |
| ►CDistanceSpatialContainersConfigure | |
| CCellNodeData | |
| ►CCalculateSignedDistanceTo3DSkinProcess | Short class definition |
| CIntersectionNodeStruct | |
| CTetEdgeStruct | |
| CCheckSameModelPartUsingSkinDistanceProcess | Checks that the model part is the same using the skin distance |
| CCheckSkinProcess | This function verifies that the skin has no holes nor overlapped geometries this is accomplished by storing all of the edges in the model in a hash map and verifying that no edge appears more than twice (which would imply an overlap) or less than once (which would imply a gap in the skin) |
| CComputeNodalGradientProcessSettings | This struct is used in order to identify when using the hitorical and non historical variables |
| CAuxiliarVariableVectorRetriever | This struct is an auxiliar base class of the VariableVectorRetriever |
| CVariableVectorRetriever | This struct is used in order to retrieve values without loosing performance |
| CComputeNodalGradientProcess | Compute Nodal Gradient process |
| CComputeNodalDivergenceProcessSettings | This struct is used in order to identify when using the hitorical and non historical variables |
| CComputeNodalNormalDivergenceProcess | Compute Nodal Normal Divergence process |
| CConstructSystemMatrixElementalProcess | Short class definition |
| CEdgeBasedGradientRecoveryProcess | Edge-based gradient recovery process This process implements the edge-based gradient recovery process technique described in https://onlinelibrary.wiley.com/doi/epdf/10.1002/nme.4374 |
| CEliminateIsolatedNodesProcess | Short class definition |
| CEntitiesEraseProcessFlags | |
| CEntitiesEraseProcess | This process removes the entities from a model part with the flag TO_ERASE |
| CFastTransferBetweenModelPartsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CFindConditionsNeighboursProcess | Short class definition |
| CFindGlobalNodalElementalNeighboursProcess | Short class definition |
| CFindGlobalNodalEntityNeighboursProcess | Short class definition |
| CFindNodalNeighboursForEntitiesProcess | Short class definition |
| CFindGlobalNodalNeighboursProcess | Short class definition |
| CFindIntersectedGeometricalObjectsProcess | This class takes two modelparts and marks the intersected ones with SELECTED flag |
| CFindIntersectedGeometricalObjectsWithOBBProcess | This class takes two modelparts and marks the intersected ones with SELECTED flag. Does the check considering an OBB for the intersection |
| CFindNodalHSettings | This struct is used in order to identify when using the hitorical and non historical variables |
| CFindNodalHProcess | Computes NODAL_H |
| CFindNodalNeighboursProcess | This method allows to look for neighbours in a triangular or tetrahedral mesh |
| CFluxCorrectedTransportConvectionProcess | Process to solve a pure convection problem using a Flux Corrected Transport scheme and an edge-based data structure |
| CFromJSONCheckResultProcess | This class is used in order to check results using a json file containing the solution a given model part with a certain frequency |
| CGenericFindElementalNeighboursProcess | |
| CGraphColoringProcess | Getting a graph of connectivities (of domains) and performs a coloring procedure |
| CIntegrationValuesExtrapolationToNodesProcess | This process extrapolates vales from the integration points to the nodes |
| CLevelSetConvectionProcess | Short class definition |
| CMeasureMeshQualityProcess | Short class definition |
| CMeshCoarseningProcess | Short class definition |
| CMeshLocalSmoothingProcess | The base class for local smoothing processes providing a laplacian smoothing |
| CMeshNodeCollapsingProcess | Remove the selected node from the mesh and collapse the connectivity arround it |
| COutputProcess | The base class for output processes |
| CParallelDistanceCalculationProcess | Short class definition |
| CProcess | The base class for all processes in Kratos |
| ►CReorderAndOptimizeModelPartProcess | Short class definition |
| CCuthillMcKee | |
| CReplaceElementsAndConditionsProcess | This methods replaces elements and conditions in a model part by a given name |
| CSetInitialStateProcess | The SetInitialStateProcess |
| ►CSimpleMortarMapperProcess | This is basic mapper of values between domains using mortar formulation |
| CTLS | Auxiliar struct for mapping |
| CSimpleMortarMapperProcessWrapper | This class wraps automatically the different types mof mappers |
| CSkinDetectionProcess | An algorithm that looks for neighbour elements in a mesh and creates a submodelpart containing the skin of the disconnected elements (interface elements) |
| CSplitInternalInterfacesProcess | Computes NODAL_AREA |
| CStructuredMeshGeneratorProcess | Short class definition |
| CSubModelPartSkinDetectionProcess | Create a SubModelPart covering a part of the outside skin of the computation domain where a condition is met |
| CTetrahedraMeshEdgeSwappingProcess | Short class definition |
| CTetrahedraMeshQualityWeightedSmoothingProcess | Short class definition |
| CTetrahedraMeshWorstElementSmoothingProcess | Short class definition |
| CTetrahedralMeshOrientationCheck | Check a triangular or tetrahedral mesh to ensure that local connectivities follow the expected convention |
| CTimeAveragingProcess | |
| CVariationalDistanceCalculationProcess | Short class definition |
| CAdjointResponseFunction | A base class for adjoint response functions |
| CBuilderAndSolver | Current class provides an implementation for the base builder and solving operations |
| CExplicitBuilder | Current class provides an implementation for the base explicit builder and solving operations |
| CResidualBasedBlockBuilderAndSolver | Current class provides an implementation for standard builder and solving operations |
| CResidualBasedBlockBuilderAndSolverWithLagrangeMultiplier | Current class provides an implementation for standard builder and solving operations |
| CResidualBasedEliminationBuilderAndSolver | Current class provides an implementation for standard elimination builder and solving operations |
| CResidualBasedEliminationBuilderAndSolverComponentwise | |
| CResidualBasedEliminationBuilderAndSolverWithConstraints | Current class provides an implementation for standard builder and solving operations |
| CConvergenceAccelerator | Base class for convergence accelerators This class is intended to be the base of any convergence accelerator in Kratos |
| CAnd_Criteria | This convergence criteria checks simultaneously two convergence criteria (both must be satisfied) |
| CConvergenceCriteria | This is the base class to define the different convergence criterion considered |
| CDisplacementCriteria | This is a convergence criteria that considers the increment on the solution as criteria |
| CMixedGenericCriteria | Convergence criteria for mixed vector-scalar problems |
| COr_Criteria | This convergence criteria checks simultaneously two convergence criteria (one of them must be satisfied) |
| CResidualCriteria | This is a convergence criteria that considers the residual as criteria |
| ►CResidualBasedAdjointBossakScheme | A scheme for dynamic adjoint equations, using Bossak time integration |
| CBossakConstants | |
| CResidualBasedAdjointStaticScheme | A scheme for static adjoint equations |
| CResidualBasedAdjointSteadyScheme | A scheme for steady adjoint equations |
| CResidualBasedBDFCustomScheme | BDF integration scheme (for dynamic problems) |
| CResidualBasedBDFDisplacementScheme | BDF integration scheme (displacement based) |
| ►CResidualBasedBDFScheme | BDF integration scheme (for dynamic problems) |
| CGeneralVectors | |
| ►CResidualBasedBossakDisplacementScheme | Bossak integration scheme (for linear and nonlinear dynamic problems) for displacements |
| CBossakAlphaMethod | Bossak Alpha parameters |
| CGeneralVectors | Velocities and accelerations used for integration |
| CNewmarkMethod | Newmark parameters used for integration |
| ►CResidualBasedImplicitTimeScheme | This is the base class for the implicit time schemes |
| CGeneralMatrices | |
| CResidualBasedNewmarkDisplacementScheme | Bossak integration scheme (for dynamic problems) for displacements |
| CResidualBasedPseudoStaticDisplacementScheme | This is a pseudo-static scheme |
| CResidualBasedIncrementalAitkenStaticScheme | A scheme for the solution of a problem using Aitken iterations |
| CResidualBasedIncrementalUpdateStaticScheme | This class provides the implementation of a static scheme |
| CResidualBasedIncrementalUpdateStaticSchemeSlip | Scheme for the solution of problems involving a slip condition |
| CScheme | This class provides the implementation of the basic tasks that are needed by the solution strategy |
| CSensitivityBuilderScheme | Scheme used in the Sensitivity Builder |
| CAdaptiveResidualBasedNewtonRaphsonStrategy | Short class definition |
| CArcLengthStrategy | This is the base ArcLengthStrategy |
| CButcherTableau | Butcher tableau for Runge-Kutta method |
| CButcherTableauForwardEuler | |
| CButcherTableauMidPointMethod | |
| CButcherTableauRK3TVD | Explicit total variation diminishing 3rd order Runge-Kutta |
| CButcherTableauRK4 | |
| CExplicitSolvingStrategy | Explicit solving strategy base class |
| ►CExplicitSolvingStrategyBFECC | Explicit Back-and-Forth Error Compensation Correction time-integration scheme |
| CSubstepData | |
| CExplicitSolvingStrategyRungeKutta | Family of explicit Runge-Kutta schemes |
| CImplicitSolvingStrategy | Implicit solving strategy base class This is the base class from which we will derive all the implicit strategies (line-search, NR, etc...) |
| CLineSearchStrategy | Short class definition |
| CResidualBasedLinearStrategy | This is a very simple strategy to solve linearly the problem |
| CResidualBasedNewtonRaphsonStrategy | This is the base Newton Raphson strategy |
| CSolvingStrategy | Solving strategy base class This is the base class from which we will derive all the strategies (implicit and explicit) |
| CKratosSpace | Short class definition |
| CUblasSpace | A class template for handling data types, matrices, and vectors in a Ublas space |
| ►CBinsDynamic | A dynamic binning data structure template for organizing and querying points in multi-dimensional space |
| CGetObjectType | |
| CGetObjectType< T, std::void_t< typename T::ObjectType > > | |
| CBinsObjectDynamic | Short class definition |
| CBins | |
| CBinsObjectStatic | Short class definition |
| CkDOP | |
| C_6DOP | |
| C_8DOP | |
| C_12DOP | |
| C_14DOP | |
| C_18DOP | |
| C_20DOP | |
| C_26DOP | |
| CBoundingVolumePartitioner | |
| CSimpleBoundingVolumePartitioner | |
| CLineRegressionVolumePartitioner | |
| CBoundingVolumeTree | |
| CBucket | Short class definition |
| CCell | |
| CNodeConfigure | Configuration file for Nodes |
| CPointDistance2 | Short class definition |
| CRadiusPoint | |
| CDEMSearch | |
| CGeometricalObjectsBins | A bins container for 3 dimensional GeometricalObject entities |
| CKDTreePartitionBase | Short class definition |
| CKDTreePartition | |
| CKDTreePartitionAverageSplit | |
| CKDTreePartitionMidPointSplit | |
| COcTreeAverageSplit | |
| COcTreeMidPointSplit | |
| COCTreePartition | Short class definition |
| COctreeBinary | Short class definition |
| COctreeBinaryCell | This class represents a cell in an octree to be used with Octree class |
| CPointObject | Custom Point container to be used by the search |
| CTvector | Short class definition |
| CSubBinAxis | TOOLS UTILS /// |
| CSearchStructure | |
| CSpatialSearch | This class is used to search for elements, conditions and nodes in a given model part |
| CSpatialSearchResult | This class is the result of the spatial searches |
| CSpecializedSpatialSearch | This class is used to search for elements, conditions and nodes in a given model part |
| CSpecializedSpatialSearchFactory | Factory for the specialized spatial search |
| CTreeNode | Short class definition |
| ►CTree | A generic tree data structure for spatial partitioning |
| CGetObjectType | |
| CGetObjectType< T, std::void_t< typename T::ObjectType > > | |
| CPartitions | Class to represent partitions for the tree |
| CTestSkippedException | Exception type used to signal that a test should be skipped |
| CActivationUtilities | Tool to evaluate the normals on nodes based on the normals of a set of surface conditions |
| CAdjointExtensions | Interface extensions for adjoint elements and conditions |
| CAmgclCSRConversionUtilities | |
| CAmgclCSRSpMMUtilities | |
| CApplyFunctionToNodesUtility | This function applies a givn function to its nodes calling GenericFunctionUtility |
| CAssignMasterSlaveConstraintsToNeighboursUtility | Assing Master-Slave Constraints to Neighbouring Nodes |
| CAssignUniqueModelPartCollectionTagUtility | Get the collection of submodelparts each node, condition and element belongs to |
| CAuxiliarModelPartUtilities | This utility includes auxiliar methods not included in the model part to avoid increase more than necessary the API |
| CBeamMathUtils | |
| CBinBasedFastPointLocator | This class is designed to allow the fast location of MANY points on the top of a 3D mesh |
| CBinBasedFastPointLocatorConditions | This class is designed to allow the fast location of MANY points on the top of a 3D mesh. (for conditions) |
| CBinBasedNodesInElementLocator | REMARK: the location function is threadsafe, and can be used in OpenMP loops |
| CBodyDistanceCalculationUtils | |
| CBodyNormalCalculationUtils | |
| CBrentIteration | |
| CBruteForcePointLocator | Utility class to find an entity of a mesh based on a location |
| CBuiltinTimer | |
| CMPIColoringUtilities | This class provides elementary function for computing the recv list and to define a coloring for communications |
| CCompareElementsAndConditionsUtility | |
| CComputeNeighbourListFunctor | Short class definition |
| CConditionNumberUtility | Utility to compute the condition number |
| CParticleConvectUtily | |
| CCoordinateTransformationUtils | |
| CCounter | Short class definition |
| CCurveAxisIntersection | |
| CCuttingUtility | CUTTING UTILITY |
| CDataTypeTraits | Generic data type traits class for arithmetic types |
| CDataTypeTraits< array_1d< TDataType, TSize > > | Data type traits for array_1d data types |
| CDataTypeTraits< DenseVector< TDataType > > | Data type traits for DenseVector data types |
| CDataTypeTraits< DenseMatrix< TDataType > > | |
| CDataTypeTraits< std::string > | |
| CDataTypeTraits< std::vector< TDataType > > | |
| CDeflationUtils | |
| CDenseHouseholderQRDecomposition | |
| CDenseQRDecomposition | |
| CDenseSingularValueDecomposition | |
| CDiscontinuousShapeFunctionsUtilities_2D | This utility can be used to calculate the enriched shape function for tetrahedra element |
| CDiscontinuousShapeFunctionsUtilities | |
| CIndexedPoint | |
| CDivideGeometry | |
| CDivideTetrahedra3D4 | |
| CDivideTriangle2D3 | |
| CDivideTriangle3D3 | |
| CDofUpdater | Utility class to update the values of degree of freedom (Dof) variables after solving the system |
| CElementSizeCalculator | A collection of functions to compute element size, to be used as the h parameter in stabilized CFD formulations |
| CEmbeddedSkinUtility | Utility to compute the skin representation from a distance function |
| CEnrichmentUtilities_2D | This utility can be used to calculate the enriched shape function for tetrahedra element |
| CEnrichmentUtilities | |
| CEnrichmentUtilitiesDuplicateDofs | |
| CExactMortarIntegrationUtility | This utility calculates the exact integration necessary for the Mortar Conditions |
| ►CFileNameDataCollector | |
| CFileNameData | |
| CForceAndTorqueUtils | |
| CBasicGenericFunctionUtility | This function allows to call a function method of type f(x, y, z, t) implemented in python style |
| CGenericFunctionUtility | GenericFunctionUtility |
| CFunctionParser | GenericFunctionUtility |
| CGeometricalProjectionUtilities | This is a class that provides auxiliar utilities for projections |
| ►CShapeParameter | |
| CSequence | |
| CGeometricalSensitivityUtility | |
| CGeometryMetricCalculator | |
| CGeometryTesterUtility | This utility tests the geometries |
| ►CBrepTrimmingUtilities | |
| CDiagonal | |
| CDPState | |
| CNearestPointUtilities | Tools to calculate the nearest point in different geometries |
| CGeometryUtils | This function provides basic routines for working with simplicial meshes |
| CGetValueFunctor | Short class definition |
| CGlobalPointerUtilities | This 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 |
| CIndirectScalar | Wrapper for a function which behaves like an arithmetic type |
| CIntegrationUtilities | Utilities to integrate in different cases |
| CIntersectionUtilities | Utilities to compute intersections between different geometries |
| CIntervalUtility | |
| CIsosurfacePrinterApplication | |
| CLineSensitivityUtility | |
| CMathUtils | Various mathematical utilitiy functions |
| CMergeVariableListsUtility | Merges the variable lists of the input modelparts |
| CMLSShapeFunctionsUtility | Moving 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 |
| CModelPartCombinationUtilities | This utility helps combine different ModelParts into one single ModelPart, with the corresponding sub ModelParts |
| CModelPartGraphUtilities | This file computes the graph representing the connectivity of a modelpart |
| CModelPartOperationUtilities | |
| CModelPartUnionOperator | |
| CModelPartSubstractionOperator | |
| CModelPartIntersectionOperator | |
| CModelPartUtils | Class collecting a set of free-floating utility functions for querying and mutating ModelPart s |
| CMortarUtilitiesSettings | This struct is used in order to identify when using the historical and non historical variables |
| CNormalCalculationUtils | |
| CProjectionNurbsGeometryUtilities | |
| CObjectCounter | Short class definition |
| COpenMPUtils | Implements basic tasks for OpenMP parallelism and suitable scalar alternatives |
| CParallelUtilities | Shared memory parallelism related helper class |
| CBlockPartition | |
| CIndexPartition | This class is useful for index iteration over containers |
| CParticlesUtilities | Collection of utilities to compute statistic of particles |
| CPlaneApproximationUtility | Utility to compute an approximation plane for a set of points |
| CGlobalPointerCommunicator | A template class for handling communication related to global pointers |
| CResultsProxy | A template class to proxy results, whether they are locally or remotely owned |
| CGlobalPointerMapCommunicator | Short class definition |
| CApplyProxy | Proxy class to update local and non-local data |
| CContainerProxy | A view with a uniform interface for ModelPart::NodesContainerType, ModelPart::ElementsContainerType, or ModelPart::ConditionsContainerType |
| CEntityProxy | Wrapper class providing a uniform interface for historical/non-historical Node, Element, and Condition |
| CPythonGenericFunctionUtility | This function allows to call a function method of type f(x, y, z, t) implemented in python |
| CQuadraticErrorFunction | Utilities 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/ |
| CCreateQuadraturePointsUtility | A Class for the creation of integration points |
| CQuaternion | Quaternion A simple class that implements the main features of quaternion algebra |
| CRandomInitializeUtility | Utility to initialize a random vector |
| CRBFShapeFunctionsUtility | Radial 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 |
| CReadAndSetAccessorsUtilities | |
| CReadMaterialsUtility | Process to read constitutive law and material properties from a json file |
| CSumReduction | Utility function to do a sum reduction |
| CSubReduction | |
| CMaxReduction | |
| CAbsMaxReduction | |
| CMinReduction | |
| CAbsMinReduction | |
| CAccumReduction | |
| CMapReduction | |
| CCombinedReduction | |
| CEntityDatabase | This class stores the results of a entity |
| CVariableDatabase | This class stores the results of a variable |
| CResultDatabase | This class stores the results of a simulation for a later comparison |
| CRetrieveGlobalPointersByIndex | Short class definition |
| CRVEPeriodicityUtility | This defines a class to define periodic BC to a RVE |
| CDistributedSearchInformation | This struct provides information related with distributed search |
| CSearchUtilities | MPI utilities for searching geometrical objects |
| ►CSensitivityBuilder | |
| CSensitivityVariables | Contains the sensitivity design and output variables |
| CSensitivityUtilities | |
| CShiftedBoundaryMeshlessInterfaceUtility | Utilities 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 |
| CSignedDistanceCalculationUtils | |
| CSingleImportModelPart | |
| ►CSparseMatrixMultiplicationUtility | An utility to multiply sparse matrix in Ublas |
| Cvalue_type | Metafunction that returns value type of a matrix or a vector type |
| CSpatialContainersConfigure | Thhis class is a container for spatial search |
| CSpecificationsUtilities | This namespace includes several utilities necessaries for evaluate specifications |
| CTetrahedraSplit | This class performs the splitting of a tetrahedra. It contains three helper functions to ease the splitting: TetrahedraSplitMode, Split_Tetrahedra, and TetrahedraGetNewConnectivityGID |
| CSplitTetrahedraUtilities | |
| CTriangleSplit | |
| CSubModelPartEntitiesBooleanOperationUtility | Wrapper of boolean operations: union, intersection and difference |
| CSVDUtils | Various mathematical utilities to compute SVD and the condition number of a matrix |
| CTableStreamUtility | |
| CCurveTessellation | |
| CTimer | This utility can be used to compute the time employed on computations |
| CVariableRedistributionUtility | Helper utility to transform between point-wise nodal variables and distributed values |
| CVariableUtils | This class implements a set of auxiliar, already parallelized, methods to perform some common tasks related with the variable values and fixity |
| CXmlExpressionElement | |
| CXmlOStreamAsciiWriter | |
| CXmlOStreamBase64BinaryWriter | |
| CXmlOStreamWriter | |
| CKratosCableNetApplication | Short class definition |
| CEmpiricalSpringElement3D2N | This spring reads a fitted polynomial as displacement-load curve takes u and returns f |
| CRingElement3D | This is a ring elemen with 3 translational dofs per node |
| CSlidingCableElement3D | This is a sliding node element with 3 translational dofs per node |
| CWeakSlidingElement3D3N | This is a penalty element to realize sliding nodes element with 3 translational dofs per node |
| CLine3DN | A arbitrary node 3D line geometry with quadratic shape functions |
| CApplyWeakSlidingProcess | |
| CEdgeCableElementProcess | |
| CEmpiricalSpringElementProcess | |
| CCableNetMpcProcess | |
| CSlidingEdgeProcess | |
| CKratosChimeraApplication | Short class definition |
| CApplyChimera | This class contains methods applies the continuity between the patch and background using linear master-slave constraints |
| CApplyChimeraProcessFractionalStep | This class extends ApplyChimera base class and overwrites the function ApplyContinuityWithMpcs to use different containers for storing pressure and velocity constraints |
| CApplyChimeraProcessMonolithic | This class extends ApplyChimera base class and overwrites the function ApplyContinuityWithMpcs to use same container for storing pressure and velocity constraints |
| CRotateRegionProcess | This is the to apply rotation to a given modelpart |
| CResidualBasedBlockBuilderAndSolverWithConstraintsForChimera | Current class provides an implementation for applying the chimera constraints that is enforcing continuity |
| CFractionalStepStrategyForChimera | |
| CChimeraDistanceCalculationUtility | Utility for calculating the Distance on a given modelpart |
| CFractionalStepSettingsForChimera | Helper class to define solution strategies for FS_Strategy |
| CChimeraHoleCuttingUtility | Short class definition |
| CKratosCompressiblePotentialFlowApplication | Short class definition |
| CAdjointPotentialWallCondition | |
| CPotentialWallCondition | Implements a wall condition for the potential flow formulation |
| CAdjointAnalyticalIncompressiblePotentialFlowElement | |
| CAdjointBasePotentialFlowElement | |
| CAdjointFiniteDifferencePotentialFlowElement | |
| ►CCompressiblePerturbationPotentialFlowElement | |
| CElementalData | |
| ►CCompressiblePotentialFlowElement | |
| CElementalData | |
| CEmbeddedCompressiblePotentialFlowElement | |
| CEmbeddedIncompressiblePotentialFlowElement | |
| CEmbeddedTransonicPerturbationPotentialFlowElement | |
| ►CIncompressiblePerturbationPotentialFlowElement | |
| CElementalData | |
| ►CIncompressiblePotentialFlowElement | |
| CElementalData | |
| CTransonicPerturbationPotentialFlowElement | |
| CPotentialToCompressibleNavierStokesOperation | This operation pass the nodal velocities from Potential model part as initial condition of a compressible Navier Stokes model part in conservative variables form |
| CApplyFarFieldProcess | Auxiliary process to define the wake in 2 dimensional problems |
| CComputeEmbeddedLiftProcess | |
| CComputeNodalValueProcess | |
| CComputeWingSectionVariableProcessSettings | |
| CComputeWingSectionVariableProcess | |
| CDefine2DWakeProcess | Auxiliary process to define the wake in 2 dimensional problems |
| CDefine3DWakeProcess | Auxiliary process to define the wake in 2 dimensional problems |
| CDefineEmbeddedWakeProcess | |
| CKuttaConditionProcess | |
| CMoveModelPartProcess | |
| CAdjointLiftFarFieldResponseFunction | AdjointLiftFarFieldResponseFunction |
| CAdjointLiftJumpCoordinatesResponseFunction | AdjointLiftJumpCoordinatesResponseFunction |
| CAdjointPotentialResponseFunction | |
| CKratosConstitutiveLawsApplication | Short class definition |
| CGenericCompressionConstitutiveLawIntegratorDplusDminusDamage | : This object integrates the predictive stress using the isotropic the d+d- damage theory |
| CGenericTensionConstitutiveLawIntegratorDplusDminusDamage | : This object integrates the predictive stress using the isotropic the d+d- damage theory |
| CGenericConstitutiveLawIntegratorDamage | : This object integrates the predictive stress using the isotropic damage theory by means of linear/exponential softening |
| CGenericConstitutiveLawIntegratorKinematicPlasticity | This object integrates the predictive stress using the plasticity theory by means of linear/exponential softening or hardening + softening evolution laws |
| CGenericConstitutiveLawIntegratorPlasticity | This object integrates the predictive stress using the plasticity theory by means of linear/exponential softening or hardening + softening evolution laws |
| CHighCycleFatigueLawIntegrator | : This object computes all the required information for the high cycle fatigue constitutive law |
| ►CHCFDataContainer | Defining all the methods and variables required in fatigue simulations |
| CFatigueVariables | |
| CDruckerPragerPlasticPotential | This class defines a plastic potential following the theory of Drucker-Prager |
| CGenericPlasticPotential | 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 |
| CModifiedMohrCoulombPlasticPotential | This class defines a plastic potential following the theory of Mohr-Coulomb (modified) |
| CMohrCoulombPlasticPotential | This class defines a plastic potential following the theory of Mohr-Coulomb |
| CRankinePlasticPotential | This class defines a plastic potential following the theory of Rankine |
| CTrescaPlasticPotential | This class defines a plastic potential following the theory of Tresca |
| CVonMisesPlasticPotential | This class defines a plastic potential following the theory of Von Mises |
| CDruckerPragerYieldSurface | This class defines a yield surface according to Drucker-Prager theory |
| CGenericYieldSurface | This class defines a generic yield surface |
| CModifiedMohrCoulombYieldSurface | This class defines a yield surface according to Modified Mohr-Coulumb theory |
| CMohrCoulombYieldSurface | This class defines a yield surface according to Von-Mises theory |
| CRankineYieldSurface | This class defines a yield surface according to Rankine theory |
| CSimoJuYieldSurface | Short class definition |
| CTrescaYieldSurface | This class defines a yield surface according to Tresca theory |
| CVonMisesYieldSurface | This class defines a yield surface according to Von-Mises theory |
| CParallelRuleOfMixturesLaw | This law defines a parallel rule of mixture (classic law of mixture) |
| CSerialParallelRuleOfMixturesLaw | This CL implements the serial-parallel rule of mixtures developed by F.Rastellini |
| CTractionSeparationLaw3D | This law defines a parallel rule of mixture (classic law of mixture) |
| CHyperElasticIsotropicHenky1D | |
| CHyperElasticIsotropicKirchhoff3D | This law defines an hyperelastic material according to the Saint-Venant–Kirchhoff formulation for 3D cases |
| CHyperElasticIsotropicKirchhoffPlaneStrain2D | This law defines an hyperelastic material according to the Saint-Venant–Kirchhoff formulation for 2D-plane strain cases |
| CHyperElasticIsotropicKirchhoffPlaneStress2D | This law defines an hyperelastic material according to the Saint-Venant–Kirchhoff formulation for 2D-plane stress cases |
| CHyperElasticIsotropicNeoHookean3D | This law defines an hyperelastic material according to the NeoHookean formulation for 3D cases |
| CHyperElasticIsotropicNeoHookeanPlaneStrain2D | This law defines an hyperelastic material according to the NeoHookean formulation for 2D-plane strain cases |
| CHyperElasticIsotropicOgden1D | |
| CHyperElasticIsotropicQuasiIncompressibleIshochoricNeoHookean3D | This law defines an hyperelastic material according to the NeoHookean formulation for 3D cases assuming quasi incompressibility |
| CHyperElasticSimoTaylorNeoHookean3D | This law defines a Neo-Hookean hyperelastic material with monotonic behavior for 3D problems |
| CHyperElasticSimoTaylorNeoHookeanPlaneStrain2D | This law defines a Neo-Hookean hyperelastic material with monotonic behavior for plane strain problems |
| CFiniteStrainIsotropicPlasticityFactory | Dummy class to register, only implements create() |
| CFiniteStrainKinematicPlasticityFactory | Dummy class to register, only implements create() |
| CGenericFiniteStrainIsotropicPlasticity | This class is the base class which define all the constitutive laws for plasticity in strain framework |
| CGenericFiniteStrainKinematicPlasticity | This class is the base class which define all the constitutive laws for plasticity in strain framework |
| CGenericAnisotropic3DLaw | This CL takes into account the material anisotropy in terms of young modulus, poisson ratio, orientation and strengths |
| ►CDamageDPlusDMinusMasonry3DLaw | |
| CDamageParameters | |
| ►CGenericSmallStrainDplusDminusDamage | This class is the base class which define all the constitutive laws for damage in small deformation |
| CDamageParameters | |
| CGenericSmallStrainIsotropicDamage | This class is the base class which define all the constitutive laws for damage in small deformation |
| CGenericSmallStrainIsotropicDamagePlaneStress | This class is the base class which define all the constitutive laws for damage in plane stress small deformation |
| CGenericSmallStrainOrthotropicDamage | This class defines an small strain orthotropic damage model developed by Cervera et. al in "Appraisement of planar, bending and twisting cracks in 3D with isotropic and orthotropic damage models" International Journal of Fracture |
| ►CDamageDPlusDMinusMasonry2DLaw | |
| CCalculationData | |
| CSmallStrainIsotropicDamage3D | Defines a damage with hardening constitutive law in 3D |
| CSmallStrainIsotropicDamageFactory | Dummy class to register, only implements create() |
| CSmallStrainIsotropicDamageImplex3D | Damage with hardening constitutive law in 3D, using Implex integration scheme (see J Oliver et al, 2008, An implicit/explicit integration scheme to increase computability of non-linear material and contact/friction problems) |
| CSmallStrainIsotropicDamagePlaneStrain2D | |
| CSmallStrainIsotropicDamageTractionOnly3D | |
| CSmallStrainIsotropicDamageTractionOnlyImplex3D | Traction-only damage with hardening constitutive law in 3D, using Implex integration scheme (see J Oliver et al, 2008, An implicit/explicit integration scheme to increase computability of non-linear material and contact/friction problems) |
| CGenericSmallStrainHighCycleFatigueLaw | This class is the base class which defines the constitutive law used for high cycle fatigue (HCF) in small deformation |
| CElasticIsotropicPlaneStressUncoupledShear | Defines a elastic constitutive law in 2D under plane stress in addition the shear modulus is independent from the Young modulus as well as the poisson ratio |
| CLinearElasticOrthotropic2DLaw | |
| CMultiLinearElastic1DLaw | |
| CMultiLinearIsotropicPlaneStress2D | |
| CWrinklingLinear2DLaw | This law defines a wrinkling modification for any linear 2D claw |
| ►CAssociativePlasticDamageModel | This law defines a parallel rule of mixture (classic law of mixture) |
| CPlasticDamageParameters | |
| ►CGenericSmallStrainPlasticDamageModel | This class is the base class which define the Plastic Damage model developed by Luccioni B. and Oller S |
| CPlasticDamageParameters | |
| CGenericSmallStrainIsotropicPlasticity | This class is the base class which define all the constitutive laws for plasticity in small deformation |
| CGenericSmallStrainKinematicPlasticity | This class is the base class which define all the constitutive laws for kinematic plasticity in small deformation |
| CPlasticityIsotropicKinematicJ2 | Defines a Simo J2 plasticity CL with Isotropic & Kinematic Hardening in 3D |
| CSmallStrainIsotropicPlasticityFactory | Dummy class to register, only implements create() |
| CSmallStrainJ2Plasticity3D | |
| CSmallStrainJ2PlasticityPlaneStrain2D | |
| CSmallStrainKinematicPlasticityFactory | Dummy class to register, only implements create() |
| CTrussPlasticityConstitutiveLaw | |
| CGenericSmallStrainViscoplasticity3D | |
| CViscousGeneralizedKelvin | This is a constitutive law that reproduces the behaviour of viscous Kelvin material |
| CViscousGeneralizedMaxwell | This is a viscous law using Maxwell formulation |
| CThermalDruckerPragerYieldSurface | This class defines a yield surface according to Drucker-Prager theory |
| CThermalModifiedMohrCoulombYieldSurface | This class defines a yield surface according to Modified Mohr-Coulumb theory |
| CThermalMohrCoulombYieldSurface | This class defines a yield surface according to Von-Mises theory |
| CThermalRankineYieldSurface | |
| CThermalSimoJuYieldSurface | This class defines a yield surface according to Simo-Ju theory |
| CThermalTrescaYieldSurface | |
| CThermalVonMisesYieldSurface | This class defines a yield surface according to Von-Mises theory |
| CGenericSmallStrainThermalIsotropicDamage | This class derives from the Isotropic damage CL and adds thermal effects (material properties affectation and internal variables) |
| CGenericSmallStrainThermalIsotropicDamagePlaneStress | |
| CThermalElasticIsotropic3D | This class defines a Thermo dependant CL, including the addition of thermal expansion strains |
| CThermalLinearPlaneStrain | This class defines a Thermo dependant CL, including the addition of thermal expansion strains |
| CThermalLinearPlaneStress | This class defines a Thermo dependant CL, including the addition of thermal expansion strains |
| CAdvanceInTimeHighCycleFatigueProcess | This class determines the advance in time to be performed for a regular cyclic load for the high cycle fatigue CL |
| CElementDeactivationProcess | This class process deactivates elements according to a certain variable threshold We currently suport double and Vector variable types |
| CSetAutomatedInitialDamageProcess | This class automotes the creation of the DAMAGE variable using tables imported from csv files |
| CAdvancedConstitutiveLawUtilities | This class includes several utilities necessaries for the computation of the constitutive law |
| CAutomaticDifferentiationTangentUtilities | |
| CTangentOperatorCalculatorUtility | An algorithm that derives numerically the constitutive tangent tensor at one GP |
| CKratosConstitutiveModelsApplication | Short class definition |
| CConstitutive3DLaw | |
| CLargeStrain3DLaw | |
| CLargeStrainAxisymmetric2DLaw | Short class definition |
| CLargeStrainPlaneStrain2DLaw | Short class definition |
| CSmallStrain3DLaw | |
| CSmallStrainAxisymmetric2DLaw | Short class definition |
| CSmallStrainOrthotropic3DLaw | Short class definition |
| CSmallStrainPlaneStrain2DLaw | Short class definition |
| CSmallStrainPlaneStress2DLaw | Short class definition |
| CNewtonianFluid3DLaw | |
| CNewtonianFluidPlaneStrain2DLaw | Short class definition |
| CStrainRate3DLaw | |
| CStrainRatePlaneStrain2DLaw | Short class definition |
| CConstitutiveModel | Short class definition |
| ►CConstitutiveModelData | Short class definition |
| CConstitutiveLawData | |
| CMaterialData | |
| CModelData | |
| CVariableValue | |
| CVariableValueData | |
| CBorjaModel | Short class definition |
| CHenckyHyperElasticModel | Short class definition |
| ►CHyperElasticModel | Short class definition |
| CHyperElasticFactors | |
| CHyperElasticModelData | |
| CStrainData | |
| CStrainEigenData | |
| CStrainInvariants | |
| ►CHypoElasticModel | Short class definition |
| CElasticModelData | |
| CIncompressibleHypoElasticModel | Short class definition |
| CIncompressibleNeoHookeanModel | Short class definition |
| CIsochoricHypoElasticModel | Short class definition |
| CIsochoricMooneyRivlinModel | Short class definition |
| CIsochoricNeoHookeanLnJSquaredModel | Short class definition |
| CIsochoricNeoHookeanModel | Short class definition |
| CIsochoricOgdenModel | Short class definition |
| ►CLinearElasticModel | Short class definition |
| CElasticModelData | |
| CMooneyRivlinModel | Short class definition |
| CNeoHookeanJ_1SquaredModel | Short class definition |
| CNeoHookeanLnJSquaredModel | Short class definition |
| CNeoHookeanModel | Short class definition |
| COgdenModel | Short class definition |
| CSaintVenantKirchhoffModel | Short class definition |
| CTamagniniModel | Short class definition |
| CYeohModel | Short class definition |
| CBakerJohnsonCookJ2ThermoPlasticityModel | Short class definition |
| CCamClayModel | Short class definition |
| CDamageModel | Short class definition |
| CGensNovaModel | Short class definition |
| CBakerJohnsonCookThermalHardeningRule | Short class definition |
| CCamClayHardeningRule | Short class definition |
| CExponentialDamageHardeningRule | Short class definition |
| CGensNovaHardeningRule | Short class definition |
| ►CHardeningRule | Short class definition |
| CInternalVariables | |
| CPlasticModelData | |
| CJohnsonCookThermalHardeningRule | Short class definition |
| CModifiedExponentialDamageHardeningRule | Short class definition |
| CSimoExponentialHardeningRule | Short class definition |
| CSimoExponentialThermalHardeningRule | Short class definition |
| CSimoLinearHardeningRule | Short class definition |
| CJohnsonCookJ2ThermoPlasticityModel | Short class definition |
| CLinearAssociativePlasticityModel | Short class definition |
| CNonAssociativePlasticityModel | Short class definition |
| ►CNonLinearAssociativePlasticityModel | Short class definition |
| CPlasticFactors | |
| CThermalVariables | |
| CNonLinearRateDependentPlasticityModel | Short class definition |
| CNonlocalCamClayModel | Short class definition |
| CNonlocalV2GensNovaModel | Short class definition |
| CPlasticityModel | Short class definition |
| CSimoJ2PlasticityModel | Short class definition |
| CSimoJ2ThermoPlasticityModel | Short class definition |
| CSimoJuExponentialDamageModel | Short class definition |
| CSimoJuModifiedExponentialDamageModel | Short class definition |
| CStructuredSoilModel | Short class definition |
| CV2GensNovaModel | Short class definition |
| CVonMisesLinearElasticPlasticityModel | Short class definition |
| CVonMisesNeoHookeanPlasticityModel | Short class definition |
| CGensNovaYieldSurface | Short class definition |
| CMisesHuberThermalYieldSurface | Short class definition |
| CMisesHuberYieldSurface | Short class definition |
| CModifiedCamClayYieldSurface | Short class definition |
| CModifiedMisesYieldSurface | Short class definition |
| CYieldSurface | Short class definition |
| ►CNonLocalPlasticityProcess | |
| CGaussPoint | |
| CPythonOutfittedConstitutiveLaw | |
| CConstitutiveModelUtilities | Short class definition |
| CPropertiesLayout | PropertiesLayout |
| CShapeAtDeviatoricPlaneMCCUtility | |
| CStressInvariantsUtilities | |
| CTableKeyVariables | TableKeyVariables |
| CKratosContactMechanicsApplication | Short class definition |
| CCircleBoundingBox | Short class definition |
| ►CCompoundNosesBoundingBox | Short class definition |
| CBoxNoseVariables | |
| CCylinderBoundingBox | Short class definition |
| ►CPlaneBoundingBox | Short class definition |
| CPlaneVariables | |
| CSphereBoundingBox | Short class definition |
| CTubeBoundingBox | Short class definition |
| CBeamPointPressureCondition | Short class definition |
| ►CBeamPointRigidContactCondition | Beam Point Rigid Contact Condition for 3D and 2D geometries. (base class) |
| CConditionVariables | |
| CLocalSystemComponents | |
| CSurfaceScalar | |
| CSurfaceVector | |
| ►CBeamPointRigidContactLM3DCondition | Short class definition |
| CTangentialContactVariables | |
| ►CBeamPointRigidContactPenalty3DCondition | Short class definition |
| CTangentialContactVariables | |
| CAxisymContactDomainLM2DCondition | |
| CAxisymContactDomainPenalty2DCondition | |
| ►CContactDomainCondition | |
| CConditionVariables | |
| CContactParameters | |
| CContactSurfaceParameters | |
| CContactTangentParameters | |
| CContactTangentVariables | |
| CContactVariables | |
| CLocalSystemComponents | |
| CContactDomainLM2DCondition | |
| CContactDomainLM3DCondition | |
| CContactDomainPenalty2DCondition | |
| CHydraulicAxisymRigidContactPenalty2DCondition | Short class definition |
| CHydraulicRigidContactPenalty3DCondition | Short class definition |
| ►CRigidBodyPointLinkCondition | Rigid Body Point Rigid Contact Condition for 3D and 2D geometries. (base class) |
| CGeneralVariables | |
| CLocalSystemComponents | |
| CRigidBodyPointLinkSegregatedVCondition | Rigid Body Point Rigid Contact Condition for 3D and 2D geometries. (base class) |
| CAxisymPointRigidContactPenalty2DCondition | Short class definition |
| CEPAxisymPointRigidContactPenalty2DCondition | Short class definition |
| CEPPointRigidContactPenalty2DCondition | Short class definition |
| ►CEPPointRigidContactPenalty3DCondition | Short class definition |
| CConstitutiveVariables | |
| CGeometricalInformation | |
| CEPPointRigidContactPenaltywP3DCondition | |
| ►CPointRigidContactCondition | Point Rigid Contact Condition for 3D and 2D geometries. (base class) |
| CConditionVariables | |
| CLocalSystemComponents | |
| CSurfaceScalar | |
| CSurfaceVector | |
| ►CPointRigidContactPenalty2DCondition | Short class definition |
| CTangentialContactVariables | |
| CPointRigidContactPenalty3DCondition | Short class definition |
| CRigidBodyPointRigidContactCondition | Rigid Body Point Rigid Contact Condition for 3D and 2D geometries. (base class) |
| CAxisymThermalContactDomainPenalty2DCondition | |
| ►CThermalContactDomainCondition | |
| CContactVariables | |
| CGeneralVariables | |
| CThermalContactDomainPenalty2DCondition | |
| ►CRigidBodyElement | Rigid Body Element for 3D space dimension |
| CElementVariables | |
| CLocalSystemComponents | |
| CRigidBodyProperties | |
| CRigidBodySegregatedVElement | Rigid Body Segregated V Element for 3D space dimension |
| CTranslatoryRigidBodyElement | Rigid Body Element for 3D space dimension |
| CTranslatoryRigidBodySegregatedVElement | Rigid Body Segregated V Element for 3D space dimension |
| CCoulombAdhesionFrictionLaw | Short class definition |
| ►CFrictionLaw | Short class definition |
| CFrictionLawVariables | |
| CHardeningCoulombFrictionLaw | Short class definition |
| ►CContactDomain2DMesher | Short class definition |
| CContactVariables | |
| ►CContactDomain3DMesher | Short class definition |
| CContactVariables | |
| CBuildContactModelPartProcess | Short class definition |
| CClearContactConditionsMesherProcess | Short class definition |
| CClearPointContactConditionsProcess | Short class definition |
| CGenerateNewContactConditionsMesherProcess | Short class definition |
| CHMParametricWallContactSearchProcess | The base class for all processes in Kratos |
| CParametricWallContactSearchProcess | The base class for all processes in Kratos |
| CSettleContactModelStructureProcess | Short class definition |
| ►CResidualBasedBossakDisplacementRotationScheme | |
| CGeneralAlphaMethod | |
| CGeneralMatrices | |
| CGeneralVectors | |
| CNewmarkMethod | |
| ►CContactDomainUtilities | Short class definition |
| CBaseLengths | |
| CScalarBaseType | |
| CSurfaceBase | |
| CSurfaceScalar | |
| CSurfaceVector | |
| CRigidBodyElementCreationUtility | Rigid body element build processes in Kratos |
| CRigidBodyUtilities | Short class definition |
| ►CSplineCurveUtilities | Short class definition |
| CSplineType | |
| CKratosContactStructuralMechanicsApplication | This application features Elements, Conditions, Constitutive laws and Utilities for structural analysis problems with contact constraints |
| CAugmentedLagrangianMethodFrictionalMortarContactAxisymCondition | AugmentedLagrangianMethodFrictionalMortarContactAxisymCondition |
| CAugmentedLagrangianMethodFrictionalMortarContactCondition | AugmentedLagrangianMethodFrictionalMortarContactCondition |
| CAugmentedLagrangianMethodFrictionlessComponentsMortarContactCondition | AugmentedLagrangianMethodFrictionlessComponentsMortarContactCondition |
| CAugmentedLagrangianMethodFrictionlessMortarContactAxisymCondition | AugmentedLagrangianMethodFrictionlessMortarContactAxisymCondition |
| CAugmentedLagrangianMethodFrictionlessMortarContactCondition | AugmentedLagrangianMethodFrictionlessMortarContactCondition |
| ►CMeshTyingMortarCondition | MeshTyingMortarCondition |
| CDofData | |
| CMortarContactCondition | MortarContactCondition |
| CMPCMortarContactCondition | MPCMortarContactCondition |
| CPairedCondition | This is a base class for the conditions paired |
| CPenaltyMethodFrictionalMortarContactAxisymCondition | PenaltyMethodFrictionalMortarContactAxisymCondition |
| CPenaltyMethodFrictionalMortarContactCondition | PenaltyMethodFrictionalMortarContactCondition |
| CPenaltyMethodFrictionlessMortarContactAxisymCondition | PenaltyMethodFrictionlessMortarContactAxisymCondition |
| CPenaltyMethodFrictionlessMortarContactCondition | PenaltyMethodFrictionlessMortarContactCondition |
| CCoulombFrictionalLaw | This class defines the Coulomb frictional laws |
| CFrictionalLaw | This class defines the base class for frictional laws |
| CFrictionalLawWithDerivative | This class defines the base class for frictional laws with derivative |
| CTrescaFrictionalLaw | This class defines the Tresca frictional laws |
| CMixedULMLinearSolver | This solver is designed for the solution of mixed U-LM problems (this solver in particular is optimized for dual LM, to avoid the resolution) |
| CContactMasterSlaveConstraint | This is a constraint for contact mechanics based in a linear kinematic MPC constriant |
| CAALMAdaptPenaltyValueProcess | This process is used in order to adapt the penalty in the ALM formulation |
| CAdvancedContactSearchProcess | This utilitiy has as objective to create the contact conditions |
| CALMFastInit | This process initializes the variables related with the ALM |
| CALMVariablesCalculationProcess | This process calculates the variables related with the ALM |
| CAssignParentElementConditionsProcess | This process initializes the variables related with the ALM |
| CBaseContactSearchProcess | This process has as objective to create the contact conditions |
| CComputeDynamicFactorProcess | This process is used in order to compute the dynamic factor for dynamic problems |
| CContactSearchWrapperProcess | This process is a wrapper for AdvancedContactSearchProcess and SimpleContactSearchProcess |
| CContactSPRErrorProcess | This class is can be used to compute the metrics of the model part with a superconvergent patch recovery (SPR) approach |
| CFindIntersectedGeometricalObjectsWithOBBContactSearchProcess | This class is a modification of FindIntersectedGeometricalObjectsWithOBBProcess for contact search |
| CMasterSlaveProcess | This process assigns as master/slave the conditions |
| CMPCContactSearchProcess | This utilitiy has as objective to create the contact constraints |
| CMPCContactSearchWrapperProcess | This process is a wrapper forMPCContactSearchProcess |
| CNormalCheckProcess | This process checks the normal |
| CNormalGapProcess | This process computes the normal gap |
| CSimpleContactSearchProcess | This utilitiy has as objective to create the contact conditions |
| CProcessFactoryUtility | This is a experimental process factory utility |
| CContactResidualBasedBlockBuilderAndSolver | Current class provides an implementation for contact builder and solving operations |
| CContactResidualBasedEliminationBuilderAndSolver | Current class provides an implementation for contact builder and solving operations. (elimination) |
| CContactResidualBasedEliminationBuilderAndSolverWithConstraints | Current class provides an implementation for contact builder and solving operations. (elimination) |
| CALMFrictionalMortarConvergenceCriteria | Custom convergence criteria for the mortar condition for frictional case |
| CALMFrictionlessComponentsMortarConvergenceCriteria | Custom convergence criteria for the mortar condition for frictionless case with components |
| CALMFrictionlessMortarConvergenceCriteria | Custom convergence criteria for the mortar condition for frictionless case with components |
| CBaseMortarConvergenceCriteria | Custom convergence criteria for the mortar condition |
| CContactErrorMeshCriteria | Custom convergence for used to check the convergence in the mesh error |
| CDisplacementContactCriteria | Convergence criteria for contact problems |
| CDisplacementLagrangeMultiplierContactCriteria | Convergence criteria for contact problems |
| CDisplacementLagrangeMultiplierFrictionalContactCriteria | Convergence criteria for contact problems |
| CDisplacementLagrangeMultiplierMixedContactCriteria | Convergence criteria for contact problems |
| CDisplacementLagrangeMultiplierMixedFrictionalContactCriteria | Convergence criteria for contact problems |
| CDisplacementLagrangeMultiplierResidualContactCriteria | Convergence criteria for contact problems This class implements a convergence control based on nodal displacement and lagrange multiplier values. The error is evaluated separately for each of them, and relative and absolute tolerances for both must be specified |
| CDisplacementLagrangeMultiplierResidualFrictionalContactCriteria | Convergence criteria for contact problems (only for frictional cases) This class implements a convergence control based on nodal displacement and lagrange multiplier values. The error is evaluated separately for each of them, and relative and absolute tolerances for both must be specified |
| CDisplacementResidualContactCriteria | Convergence criteria for contact problems This class implements a convergence control based on nodal displacement (for penalty contact) |
| CMeshTyingMortarConvergenceCriteria | |
| CMortarAndConvergenceCriteria | Custom AND convergence criteria for the mortar condition |
| CMPCContactCriteria | Custom convergence criteria for the contact problem |
| CPenaltyFrictionalMortarConvergenceCriteria | Custom convergence criteria for the mortar condition for frictional case |
| CPenaltyFrictionlessMortarConvergenceCriteria | Custom convergence criteria for the mortar condition for frictionless case with components |
| CLineSearchContactStrategy | A strategy for solving contact problems using a line search method |
| CResidualBasedNewtonRaphsonContactStrategy | Contact Newton Raphson class |
| CResidualBasedNewtonRaphsonMPCContactStrategy | Contact Newton Raphson class |
| CContactUtilities | This class includes some utilities used for contact computations |
| CDerivativesUtilities | This utilities are used in order to compute the directional derivatives during mortar contact |
| CImplementationDerivativesUtilities | Auxiliary implementation for DerivativesUtilities |
| CInterfacePreprocessCondition | Creates Model Parts containing the interface |
| CMortarExplicitContributionUtilities | This namespace includes several utilities necessaries for the computation of the explicit contribution of the mortar conditions |
| CKratosConvectionDiffusionApplication | The Convection Diffusion Application contains a series of elements and conditions and the corresponding strategies and solvers within Kratos Multiphysics necesaries in order to simulate a convection-diffusion problem |
| CAdjointThermalFace | Heat flux Neumann condition for the ajdoint thermal diffusion problem |
| CAxisymmetricThermalFace | Axisymmetric thermal face condition Extension of the base ThermalFace class to be used in axisymmetric problems |
| CFluxCondition | A basic Neumann condition for convection-diffusion problems |
| ►CThermalFace | A basic Neumann condition for convection-diffusion problems |
| CConditionDataStruct | Gauss pt. data structure Auxiliar data structure to pass the Gauss pt. data |
| CAdjointDiffusionElement | Basic element for the ajdoint diffusion problem |
| CAxisymmetricEulerianConvectionDiffusionElement | |
| CConvDiff2D | A stabilized element for solving the convection diffusion equations in 2D |
| CConvDiff3D | Short class definition |
| CConvDiffChangeOfPhase2D | Short class definition |
| CDConvectionDiffusionExplicit | This element solves the convection-diffusion equation, stabilized with algebraic subgrid scale or orthogonal subgrid scale |
| CEmbeddedLaplacianElement | |
| ►CEulerianConvectionDiffusionElement | Formulation described in https://docs.google.com/document/d/13a_zGLj6xORDuLgoOG5LwHI6BwShvfO166opZ815zLY/edit?usp=sharing |
| CElementVariables | |
| CEulerianDiffusionElement | Formulation described in https://docs.google.com/document/d/13a_zGLj6xORDuLgoOG5LwHI6BwShvfO166opZ815zLY/edit?usp=sharing |
| CLaplacianElement | Short class definition |
| CMixedLaplacianElement | Mixed Laplacian formulation element This element implements a mixed Laplacian (scalar - gradient) formulation |
| ►CQSConvectionDiffusionExplicit | This element solves the convection-diffusion equation, stabilized with algebraic subgrid scale or orthogonal subgrid scale |
| CElementData | |
| CLocalTemperatureAverageResponseFunction | |
| CExplicitSolvingStrategyRungeKutta4ConvectionDiffusion | This strategy adds the orthogonal subgrid projections computation to the base explicit runge kutta 4 integration method |
| CResidualBasedConvectionDiffusionStrategy | This strategy is used to solve convection-diffusion problem |
| CResidualBasedConvectionDiffusionStrategyNonLinear | This strategy is used to solve convection-diffusion problem |
| CResidualBasedEulerianConvectionDiffusionStrategy | This strategy is used to solve convection-diffusion problem |
| CResidualBasedSemiEulerianConvectionDiffusionStrategy | This strategy is used to solve convection-diffusion problem |
| CBFECCConvection | |
| CBFECCLimiterConvection | |
| CConvection_Particle | PFEM Particle class |
| CEmbeddedMLSConstraintProcess | |
| CFaceHeatUtilities | |
| CMoveParticleUtilityScalarTransport | |
| CPureConvectionCrankNUtilities | |
| CPureConvectionUtilities | |
| CKratosCoSimulationApplication | Short class definition |
| CCoSimIOConversionUtilities | Short class definition |
| CConversionUtilities | Short class definition |
| CFetiDynamicCouplingUtilities | |
| CKratosCSharpWrapperApplication | This is a custom application for being able to couple C++ code of Kratos with CSharp |
| CAddedMassCondition | |
| CFreeSurfaceCondition | |
| CInfiniteDomainCondition | |
| ►CUPCondition | |
| CConditionVariables | |
| CLinearElastic2DPlaneStrainNodal | |
| CLinearElastic2DPlaneStressNodal | |
| CLinearElastic3DLawNodal | |
| CThermalLinearElastic2DPlaneStrain | |
| CThermalLinearElastic2DPlaneStrainNodal | |
| CThermalLinearElastic2DPlaneStress | |
| CThermalLinearElastic2DPlaneStressNodal | |
| CThermalLinearElastic3DLaw | |
| CThermalLinearElastic3DLawNodal | |
| CThermalLocalDamage3DLaw | |
| CThermalLocalDamagePlaneStrain2DLaw | |
| CThermalLocalDamagePlaneStress2DLaw | |
| CThermalModifiedMisesNonlocalDamage3DLaw | |
| CThermalModifiedMisesNonlocalDamagePlaneStrain2DLaw | |
| CThermalModifiedMisesNonlocalDamagePlaneStress2DLaw | |
| CThermalNonlocalDamage3DLaw | |
| CThermalNonlocalDamagePlaneStrain2DLaw | |
| CThermalNonlocalDamagePlaneStress2DLaw | |
| CThermalSimoJuLocalDamage3DLaw | |
| CThermalSimoJuLocalDamagePlaneStrain2DLaw | |
| CThermalSimoJuLocalDamagePlaneStress2DLaw | |
| CThermalSimoJuNonlocalDamage3DLaw | |
| CThermalSimoJuNonlocalDamagePlaneStrain2DLaw | |
| CThermalSimoJuNonlocalDamagePlaneStress2DLaw | |
| CSmallDisplacementElement | Small Displacement Element for 3D and 2D geometries |
| ►CSmallDisplacementInterfaceElement | |
| CElementVariables | |
| CSmallDisplacementThermoMechanicElement | |
| ►CSolidElement | Large Displacement Lagrangian Element for 3D and 2D geometries. (base class) |
| CElementData | |
| CLocalSystemComponents | |
| CWaveEquationElement | |
| CApplyComponentTableProcessDam | |
| CDamAddedMassConditionProcess | |
| CDamAzenhaHeatFluxProcess | |
| CDamBofangConditionTemperatureProcess | |
| CDamChemoMechanicalAgingYoungProcess | |
| CDamFixTemperatureConditionProcess | |
| CDamGroutingReferenceTemperatureProcess | |
| CDamHydroConditionLoadProcess | |
| CDamInputTableNodalYoungModulusProcess | |
| CDamNodalReferenceTemperatureProcess | |
| CDamNodalYoungModulusProcess | |
| CDamNoorzaiHeatFluxProcess | |
| CDamRandomFieldsVariableProcess | |
| CDamReservoirConstantTemperatureProcess | |
| CDamReservoirMonitoringTemperatureProcess | |
| CDamTSolAirHeatFluxProcess | |
| CDamTemperaturebyDeviceProcess | |
| CDamUpliftCircularConditionLoadProcess | |
| ►CDamUpliftConditionLoadProcess | |
| CGaussPoint | Structs for mapping model parts ----------------------------------------------------------------------------------------------------------------------------------------— |
| CDamWestergaardConditionLoadProcess | |
| CBossakDisplacementSmoothingScheme | |
| CDamPScheme | |
| CDamUPScheme | |
| CIncrementalUpdateStaticDampedSmoothingScheme | |
| CIncrementalUpdateStaticSmoothingScheme | |
| CConstructionUtility | |
| CGlobalJointStressUtility | |
| ►CMappingVariables2DUtilities | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| ►CMappingVariables3DUtilities | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| CStreamlinesOutput3DUtilities | |
| CTransferSelfweightStressUtility | |
| CKratosDamApplication | |
| ►CSpatialBoundingBox | Short class definition |
| CBoundingBoxParameters | |
| CBoundingBoxVariables | |
| CCompositeCondition | Updated Total Lagrangian element for 2D and 3D geometries |
| CLaplacianSmoothing | Short class definition |
| CMesher | Short class definition |
| CTetrahedralMesh3DMesher | Short class definition |
| CTriangularMesh2DMesher | Short class definition |
| CBuildModelPartBoundaryProcess | Short class definition |
| CConstantRotationProcess | |
| CElementalNeighboursSearchProcess | Short class definition |
| CGenerateNewConditionsMesherProcess | Short class definition |
| CGenerateNewElementsMesherProcess | Short class definition |
| CGenerateNewNodesMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CMesherProcess | The base class for processes passed to the solution scheme |
| CModelVolumeCalculationProcess | |
| CNodalNeighboursSearchProcess | Short class definition |
| CPrintMeshOutputMesherProcess | |
| CRefineConditionsMesherProcess | Refine Mesh Boundary Process |
| CRefineElementsInEdgesMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CRefineElementsOnSizeMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CRefineElementsOnThresholdMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CRemoveNodesMesherProcess | Remove Mesh Nodes Process for 2D and 3D cases |
| ►CSelectElementsMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CNodalFlags | |
| CSettleModelStructureProcess | Short class definition |
| CTransferBetweenModelPartsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CBoundaryNormalsCalculationUtilities | |
| ►CMeshDataTransferUtilities | Short class definition |
| CBoundaryVariableArrays | |
| CBoundaryVariables | |
| CTransferParameters | |
| CMeshErrorCalculationUtilities | Short class definition |
| ►CMesherUtilities | Short class definition |
| CMeshContainer | |
| CMeshingInfoParameters | |
| CMeshingParameters | |
| CRefineBodyInfo | |
| CRefineBoundaryInfo | |
| CRefiningInfoParameters | |
| CRefiningParameters | |
| CKratosDelaunayMeshingApplication | Short class definition |
| CAnalyticRigidFace3D | |
| CDEMWall | |
| CMAPcond | |
| CRigidEdge2D | |
| ►CRigidFace3D | |
| CFaceDataBuffer | |
| CSolidFace3D | |
| CDEMBeamConstitutiveLaw | |
| CDEM_compound_constitutive_law | |
| CDEM_compound_constitutive_law_for_PBM | |
| CDemContact | |
| CDEMContinuumConstitutiveLaw | |
| CDEM_D_Bentonite_Colloid | |
| CDEM_D_Conical_damage | |
| CDEM_D_DMT_Cohesive_Law | |
| CDEM_D_Hertz_confined | |
| CDEM_D_Hertz_viscous_Coulomb2D | |
| CDEM_D_Hertz_viscous_Coulomb | |
| CDEM_D_Hertz_viscous_Coulomb_Nestle | |
| CDEM_D_JKR_Cohesive_Law | |
| CDEM_D_Linear_classic | |
| CDEM_D_Linear_confined | |
| CDEM_D_Linear_Custom_Constants | |
| CDEM_D_Linear_HighStiffness_2D | |
| CDEM_D_Linear_HighStiffness | |
| CDEM_D_Linear_viscous_Coulomb2D | |
| CDEM_D_Linear_viscous_Coulomb | |
| CDEM_D_Quadratic | |
| CDEM_D_Stress_Dependent_Cohesive | |
| CDEM_D_void | |
| CDEM_Dempack2D | |
| CDEM_Dempack2D_dev | |
| CDEM_Dempack | |
| CDEM_Dempack_dev | |
| CDEM_Dempack_torque | |
| CDEMDiscontinuumConstitutiveLaw | |
| CDEM_ExponentialHC | |
| CDEM_KDEM2D | |
| CDEM_KDEM_CamClay | |
| CDEM_KDEM | |
| CDEM_KDEMFabric2D | |
| CDEM_KDEMFabric | |
| CDEM_KDEM_Fissured_Rock_CL | |
| CDEM_KDEM_Mohr_Coulomb | |
| CDEM_KDEM_Rankine | |
| CDEM_KDEM_soft_torque | |
| CDEM_KDEM_soft_torque_with_noise | |
| CDEM_KDEM_with_damage | |
| CDEM_KDEM_with_damage_parallel_bond_2D | |
| CDEM_KDEM_with_damage_parallel_bond_capped | |
| CDEM_KDEM_with_damage_parallel_bond | |
| CDEM_KDEM_with_damage_parallel_bond_Hertz_2D | |
| CDEM_KDEM_with_damage_parallel_bond_Hertz | |
| CDEM_parallel_bond | |
| CDEM_parallel_bond_for_membrane | |
| CDEMRollingFrictionModel | |
| CDEMRollingFrictionModelBounded | |
| CDEMRollingFrictionModelConstantTorque | |
| CDEMRollingFrictionModelViscousTorque | |
| CDEM_smooth_joint | |
| CAnalyticRigidBodyElement | |
| ►CAnalyticSphericParticle | |
| CParticleDataBuffer | |
| CBeamParticle | |
| CBondingSphericContinuumParticle | |
| CCluster3D | |
| ►CContactInfoSphericParticle | |
| CParticleDataBuffer | |
| CSingleSphereCluster3D | |
| CCylinderContinuumParticle | |
| CCylinderParticle | |
| CDiscreteElement | |
| CIceContinuumParticle | |
| CNanoParticle | |
| CParticleContactElement | |
| CPolyhedronSkinSphericParticle | |
| CRigidBodyElement3D | |
| CShipElement3D | |
| ►CSphericContinuumParticle | |
| CParticleDataBuffer | |
| ►CSphericParticle | |
| CParticleDataBuffer | |
| CApplyForcesAndMomentsProcess | Auxiliary process to apply forces and moments to particles |
| CApplyForcesAndMomentsToWallsProcess | Auxiliary process to apply forces and moments to walls |
| CApplyKinematicConstraintsProcess | Auxiliary process to apply forces and moments to particles |
| CApplyKinematicConstraintsToWallsProcess | Auxiliary process to apply forces and moments to particles |
| CAutomaticDTProcess | |
| CControlModule2DProcess | |
| CBinsObjectDynamicPeriodic | Short class definition |
| CSubBinAxisPeriodic | TOOLS UTILS /// |
| CSearchStructurePeriodic | |
| CDEMIntegrationScheme | |
| CForwardEulerScheme | |
| CGluedToWallScheme | |
| CQuaternionIntegrationScheme | |
| CRungeKuttaScheme | |
| CSymplecticEulerScheme | |
| CTaylorScheme | |
| CVelocityVerletScheme | |
| CContinuumExplicitSolverStrategy | |
| CExplicitSolverSettings | |
| ►CExplicitSolverStrategy | |
| CLessX | |
| CLessY | |
| CLessZ | |
| CSpatialSortingTraits | |
| CIterativeSolverStrategy | |
| CVelocityVerletSolverStrategy | |
| ►CAnalyticFaceWatcher | |
| CCrossingsTimeStepDataBase | |
| CFaceHistoryDatabase | |
| CAnalyticModelPartFiller | |
| ►CAnalyticParticleWatcher | |
| CFaceParticleImpactDataOfAllParticlesSingleTimeStep | |
| CFaceParticleImpactDataOfAllTimeStepsSingleParticle | |
| CInterParticleImpactDataOfAllParticlesSingleTimeStep | |
| CInterParticleImpactDataOfAllTimeStepsSingleParticle | |
| CAnalyticWatcher | |
| CParticlesHistoryWatcher | |
| CAuxiliaryUtilities | |
| CSphericElementGlobalPhysicsCalculator | |
| CClusterInformation | |
| CParticleCreatorDestructor | |
| CDEM_FEM_Search | Short class definition |
| CDEMFEMUtilities | |
| CDiscreteParticleConfigure | |
| CDiscreteRandomVariable | |
| CExcavatorUtility | |
| CDEM_Force_Based_Inlet | |
| CGeometricalConfigure | |
| CDEM_Inlet | |
| CMoveMeshUtility | This utilitiy moves the nodes of a dem wall used especially in the fem-dem coupling |
| CMultiaxialControlModuleGeneralized2DUtilities | |
| COMP_DEMSearch | Short class definition |
| CParallelBondUtilities | |
| CParticle_Data | |
| CPiecewiseLinearRandomVariable | |
| CPostUtilities | |
| CPreUtilities | |
| CPropertiesProxy | |
| CPropertiesProxiesManager | |
| CRandomVariable | |
| CReorderConsecutiveFromGivenIdsModelPartIO | |
| CRigidFaceGeometricalObjectConfigure | |
| CDemSearchUtilities | |
| CStationarityChecker | |
| CKratosDEMApplication | |
| CDEMFlags | |
| CLineLoadFromDEMCondition2D | |
| CSurfaceLoadFromDEMCondition3D | |
| CControlModuleProcess | |
| CComputeDEMFaceLoadUtility | |
| CControlModuleFemDem2DUtilities | |
| CControlModuleFemDemUtilities | |
| CDemStructuresCouplingUtilities | |
| CEffectiveStressesCommunicatorUtility | |
| CInterpolateStructuralSolutionForDEM | |
| CMultiaxialControlModuleFEMDEMGeneralized2DUtilities | |
| CPermeabilityTensorCommunicatorUtility | |
| CPorePressureCommunicatorUtility | |
| CPostProcessUtilities | |
| CSandProductionUtilities | |
| CStressFailureCheckUtilities | Note: For the moment this only works for cylindrical probes with its axis oriented in Z direction |
| CKratosDemStructuresCouplingApplication | |
| CDemStructuresCouplingFlags | |
| CDropletDynamicsElement | |
| CKratosDropletDynamicsApplication | Short class definition |
| CCalculateDivergenceProcess | Process to compute divergence |
| CMetricDivergenceFreeProcess | This class is can be used to compute the metrics of the model part with different strategies, exploting the divergence. The developed strategies are: mean distribution strategy: this strategy builds a metric which tries to uniformly spread the refinement indicator in the whole domain maximum strategy: this strategy build a metric which aims at refining only if the refinement indicator belong to the interval [coefficient*max(refinement indicator),max(refinement indicator)] |
| CWeightedDivergenceCalculationProcess | Process to compute element time average of the divergence |
| CDragAndMomentUtilities | Auxiliary utility to compute the drag force and the moment around a given point |
| CKratosExaquteSandboxApplication | Short class definition |
| CElasticIsotropic3DFEMDEM | |
| CHyperElasticIsotropicNeoHookean3DFEMDEM | This law defines an hyperelastic material according to the NeoHookean formulation for 3D cases |
| CHyperElasticIsotropicNeoHookeanPlaneStrain2DFEMDEM | This law defines an hyperelastic material according to the NeoHookean formulation for 2D-plane strain cases |
| CLinearPlaneStrainFEMDEM | This class defines a small deformation linear elastic constitutive model for plane strain cases |
| CLinearPlaneStressFEMDEM | This class defines a small deformation linear elastic constitutive model for plane stress cases |
| ►CBaseSolidElement | This is base class used to define the solid elements |
| CConstitutiveVariables | |
| CKinematicVariables | |
| CGenericSmallStrainFemDemElement | Small Displacement element for the 2D and 3D cases |
| CGenericTotalLagrangianFemDemElement | Total Lagrangian element for 2D and 3D geometries |
| CGenericTotalLagrangianMixturesFemDemElement | Total Lagrangian element taking into account a Classical Rule Of Mixtures and j2-plasticity for the fiber. See Computational Methods for Plasticity - EA de Souza Neto, D Peric and DRJ Owen |
| CApplyComponentTableProcess | |
| CApplyDoubleTableProcess | |
| CAssignPressureIdProcess | |
| CAssignVectorFieldToEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignVectorVariableToConditionsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CComputeInitialVolumeProcess | Computes the initial volume of the blast circle and assigns it to the nodes |
| CExpandWetNodesProcess | Assigns the pressure Id to the nodes of the elements that are going to be removed |
| CExtendPressureConditionProcess | Creates the new presure line loads after removing some elements |
| CFixFreeVelocityOnNodesProcess | |
| CFixScalarDofProcess | The base class for fixing scalar variable Dof or array_1d component Dof processes in Kratos |
| CFreeScalarDofProcess | The base class for freeing scalar variable Dof or array_1d component Dof processes in Kratos |
| CGenerateDemProcess | |
| CGenerateInitialSkinDEMProcess | |
| CRegeneratePfemPressureConditionsProcess | Regenerates the pressure conditions for the PFEM coupling |
| CRemoveAloneDEMElementsProcess | |
| CTransferEntitiesBetweenModelPartsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CTransferNodalForcesToFem | |
| CUpdateDemKinematicsProcess | |
| CUpdateFlagNoRemeshFemDemBoundaryProcess | |
| CUpdatePressureValuePfemConditionsProcess | Assigns the pressure value according to the nodal PRESSURE at this time step |
| CUpdatePressureVolumeProcess | Updates the volume according to a pressure load |
| CFemDemResidualCriteria | This is a convergence criteria that employes the residual as criteria |
| CHexahedraNewtonRaphsonStrategy | This is the base Newton Raphson strategy |
| CResidualBasedDEMCoupledNewtonRaphsonStrategy | This is the base Newton Raphson strategy coupled with the DEM strategy |
| CAitkenRelaxationFEMDEMUtility | Aitken relaxation technique for FSI PFEM-FEM-DEM coupling |
| CConstitutiveLawUtilities | This class includes several utilities necessaries for the computation of the constitutive law |
| CFEMDEMCouplingUtilities | This class includes several utilities necessaries for the coupling between the FEM and the DEM |
| CRenumberingNodesUtility | |
| CKratosFemToDemApplication | |
| CAdjointMonolithicWallCondition | |
| ►CEmbeddedAusasNavierStokesWallCondition | Implements a wall condition for the Navier-Stokes monolithic formulation |
| CConditionDataStruct | |
| CFSGeneralizedWallCondition | Implements a generalized wall model accounting for pressure gradients |
| CFSPeriodicCondition | Condition used to assign periodic boundary conditions when using a fractional step fluid solver |
| CFSWernerWengleWallCondition | Implements a power-law wall model |
| CMonolithicWallCondition | Implements a wall condition for the monolithic formulation |
| ►CNavierStokesWallCondition | Implements a wall condition for the Navier-Stokes (and Stokes) monolithic formulations This condition is intended to be used in combination with Navier-Stokes (or Stokes) monolithic formulations. It supports the Neumann BC contribution as well as the addition of a wall law contribution through the TWallModel template argument. Such TWallModel must be a class implementing the wall model RHS and LHS Gauss point contributions (as example see @NavierSlipWallLaw). Current condition also has optional features that help numerical stability such as the outlet inflow energy correction or the spurious tangential velocity correction for pure slip boundaries |
| CConditionDataStruct | |
| CStokesWallCondition | Implements a wall condition for the monolithic stokes formulation - based on BDF2 |
| CTwoFluidNavierStokesWallCondition | Implements a wall condition for the Navier-Stokes monolithic formulation |
| CWallCondition | Implements a wall condition for the monolithic formulation |
| CWallConditionDiscontinuous | Implements a wall condition for the monolithic formulation |
| CLinearLogWallLaw | 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) |
| CNavierSlipWallLaw | 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 |
| CBingham3DLaw | |
| CEuler2DLaw | |
| CEuler3DLaw | |
| CFluidConstitutiveLaw | This class contains the common infrastructure for fluid constitutive laws |
| CHerschelBulkley3DLaw | |
| CNewtonian2DLaw | |
| CNewtonian3DLaw | |
| CNewtonianTemperatureDependent2DLaw | |
| CNewtonianTemperatureDependent3DLaw | |
| CNewtonianTwoFluid2DLaw | |
| CNewtonianTwoFluid3DLaw | |
| CAlternativeDVMSDEMCoupled | |
| CAlternativeQSVMSDEMCoupled | |
| CAxisymmetricNavierStokes | |
| CBinghamFluid | |
| ►CCompressibleNavierStokesExplicit | Compressible Navier-Stokes explicit element This element implements a compressible Navier-Stokes explicit formulation. The formulation is written in conservative form so the element unknowns are the DENSITY, MOMENTUM and TOTAL_ENERGY variables. This element is intended to work with the Kratos explicit DOF based strategy. Hence, the explicit residual is written in the corresponding REACTION variables |
| CElementDataStruct | |
| CDVMS | |
| CDVMSDEMCoupled | |
| CAxisymmetricNavierStokesData | |
| CZeroDerivatives | This provides zero derivatives for given any variable |
| CSubAssembly | Assembles sub-vectors to element vectors and matrices |
| CCalculationContainerTraits | This is traits clas sto hold combined data containers and calculation containers |
| CQSVMSAdjointElementData | Traits class to hold QSVMS adjoint element data |
| ►CQSVMSDerivativeUtilities | These are helper classes to define derivatives of coefficients of Navier-Stokes |
| CDerivative | Base class for Derivatives |
| CPressureDerivative | Pressure derivative computation container |
| CShapeDerivative | Shape derivative computation container |
| CVelocityDerivative | Velocity derivative computation container |
| ►CQSVMSResidualDerivatives | Computes the QSVMS residual derivatives |
| CQSVMSResidualData | |
| CResidualsContributions | Computes residual contributions |
| CSecondDerivatives | Computes second derivatives of the QS VMS residual |
| CVariableDerivatives | Computes QS VMS residual derivative residuals for given variable |
| CDistanceSmoothingElement | |
| CDPGVMS | |
| CDynamicVMS | A stabilized element for the incompressible Navier-Stokes equations |
| ►CEmbeddedAusasNavierStokes | |
| CEmbeddedAusasElementDataStruct | |
| CEmbeddedFluidElement | |
| CEmbeddedFluidElementDiscontinuous | |
| ►CEmbeddedNavierStokes | |
| CEmbeddedElementDataStruct | |
| CFIC | |
| CFluidAdjointElement | |
| ►CFluidElement | Large Displacement Lagrangian Element for 3D and 2D geometries. (base class) |
| CElementData | |
| CLocalSystemComponents | |
| CFractionalStep | A stabilized element for the incompressible Navier-Stokes equations |
| CFractionalStepDiscontinuous | A stabilized element for the incompressible Navier-Stokes equations |
| CHerschelBulkleyFluid | |
| ►CNavierStokes | |
| CElementDataStruct | |
| CQSVMS | |
| CQSVMSDEMCoupled | |
| CSpalartAllmaras | Short class definition |
| CStationaryStokes | GLS-stabilized element for the solution of the stationary Stokes problem |
| ►CStokes3D | |
| Celement_data | |
| CStokes3DTwoFluid | |
| CSymbolicStokes | |
| CTwoFluidNavierStokes | |
| CTwoFluidNavierStokesAlphaMethod | |
| CTwoFluidVMS | |
| CTwoFluidVMSLinearizedDarcy | Version of TwoFluidVMS that treats the Darcy term explicitly |
| CVMS | A stabilized element for the incompressible Navier-Stokes equations |
| CVMSAdjointElement | An adjoint element for discrete shape sensitivity of VMS fluid element |
| CWeaklyCompressibleNavierStokes | |
| ►CApplyCompressibleNavierStokesBoundaryConditionsProcess | This process applies diferent boundary conditions accoring to the mach regime. Parameters: |
| CBoundaryConditionUtility | This class validates and manages a variable to fix and the value to fix it to |
| CWindkesselModel | An impelementation of the Windkessel model for boundary condition of incompressible flows |
| CBoussinesqForceProcess | Auxiliary process to set Boussinesq buoyancy forces in variable temperature flows |
| CCalulateLevelsetConsistentNodalGradientProcess | Utility to calculate the nodal gradient separately for the positive and negative sides of the zero level-set function (interface) |
| CComputePressureCoefficientProcess | This process computes the pressure coefficient as a function of reference fluid properties |
| CComputeYPlusProcess | |
| CDistanceModificationProcess | |
| CDistanceSmoothingProcess | |
| CEmbeddedNodesInitializationProcess | |
| CEmbeddedPostprocessProcess | Utility to filter the embedded velocity and pressure values |
| ►CEmbeddedSkinVisualizationProcess | This process saves the intersected elements in a different model part for its visualization |
| CHash | |
| CKeyEqual | |
| CIntegrationPointStatisticsProcess | Helper process to record statistics on the integration points of the mesh |
| CMassConservationCheckProcess | |
| ►CShockCapturingEntropyViscosityProcess | |
| CInfNormData | |
| CTotalDerivativeUtil | Small utility to compute the total derivative of a magnitude |
| ►CShockCapturingPhysicsBasedProcess | |
| CShockCapturingTLSContainer2D3N | Type for the 2D (linear triangle) TLS geometry data |
| CShockCapturingTLSContainer3D4N | Type for the 3D (linear tetrahedra) TLS geometry data |
| CSpalartAllmarasTurbulenceModel | An impelementation of the Spalart-Allmaras turbulence model for incompressible flows |
| CStokesInitializationProcess | A process to provide initial values for Navier-Stokes problems |
| CTwoFluidsInletProcess | |
| CPyDragResponseFunction | |
| CDragResponseFunction | A response function for drag |
| CVelocityPressureNormSquareResponseFunction | A response function for norm square calculation |
| CResidualBasedBlockBuilderAndSolverPeriodic | |
| CBDF2TurbulentScheme | A scheme for BDF2 time integration |
| CResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulent | Bossak time scheme for the incompressible flow problem |
| CResidualBasedSimpleSteadyScheme | |
| CSimpleSteadySensitivityBuilderScheme | |
| CVelocityBossakAdjointScheme | |
| CVelocityBossakSensitivityBuilderScheme | |
| CCompressibleNavierStokesExplicitSolvingStrategy | Explicit solving strategy base class |
| ►CCompressibleNavierStokesExplicitSolvingStrategyBFECC | |
| Coptional | |
| CCompressibleNavierStokesExplicitSolvingStrategyRungeKutta | Explicit solving strategy base class |
| CFractionalStepStrategy | Fractional-step strategy for incompressible Navier-Stokes formulation This strategy implements a splitting scheme for the incompressible Navier-Stokes equations. It is intended to be used in combination with the FractionalStep element in the FluidDynamicsApplication. The fractional step index, which is stored in the ProcessInfo, takes the values 1 : Momentum step (calculate fractional step velocity) 2-3 : Unused (reserved for componentwise calculation of frac step velocity) 4 : Pressure step 5 : Computation of projections 6 : End of step velocity |
| CAccelerationLimitationUtilities | |
| CCompressibleElementRotationUtility | A utility to rotate the local contributions of certain nodes to the system matrix, which is required to apply slip conditions in arbitrary directions |
| CDragUtilities | Auxiliary utility to compute the drag force |
| CDynamicSmagorinskyUtils | Helper class to dynamically determine a value for the Smagorinsly parameter |
| CEmbeddedData | |
| CEmbeddedDiscontinuousData | |
| CEstimateDtUtility | Estimate the time step in a fluid problem to obtain a given Courant number |
| CFICData | |
| CFluidAdjointSlipUtilities | |
| CFluidAdjointTestUtilities | |
| CFluidAdjointUtilities | |
| CFluidAuxiliaryUtilities | |
| CFluidCalculationUtilities | |
| CFluidCharacteristicNumbersUtilities | Fluid characteristic numbers calculation utility This class provides static methods to calculate the common adimensional magnitudes that characterize any fluid flow |
| CFluidElementData | Base class for data containers used within FluidElement and derived types |
| CFluidElementUtilities | Auxiliary and specialized functions for elements derived from FluidElement |
| ►CFluidTestUtilities | |
| CGetContainer | |
| CFractionalStepSettings | Helper class to define solution strategies for FS_Strategy |
| CFractionalStepSettingsPeriodic | Helper class to define solution strategies for FS_Strategy |
| CIntegrationPointToNodeTransformationUtility | A utility for transforming values on integration points to nodes |
| CPeriodicConditionUtilities | Auxiliary utilitiy to define periodic boundary conditions for flow problems |
| CQSVMSData | |
| CQSVMSDEMCoupledData | |
| CSolverSettings | Helper class to define solution strategies for FS_Strategy |
| CStatisticsData | Internal container for integration point statistitcs on a given element |
| CStatisticsRecord | Main class for online statistics calculation |
| CStatisticsSampler | Base class for statistical measurements |
| CScalarAverageSampler | This class manages the computation of the average of a scalar quantity |
| CVectorAverageSampler | This class manages the computation of the average of a vector quantity |
| CVarianceSampler | This class manages the computation of the (co)variance between two given quantities (scalar or vector) |
| CSymmetricVarianceSampler | This class manages the computation of the variance for a given quantity |
| CComponentwiseVarianceSampler | This class manages the computation of the (co)variance when one or both variables are Vector components |
| CThirdOrderCorrelationSampler | This class manages the computation of third order moments of scalars or vector components |
| CSymbolicStokesData | |
| CTimeIntegratedFICData | |
| CTimeIntegratedQSVMSData | |
| CTwoFluidNavierStokesAlphaMethodData | |
| CTwoFluidNavierStokesData | |
| CVorticityUtilities | A set of functions to compute quantities of interest for turbulent flows |
| CWeaklyCompressibleNavierStokesData | |
| CKratosFluidDynamicsApplication | Main class of the Fluid Dynamics Application |
| CTrilinosSpalartAllmarasTurbulenceModel | Trilinos implementation of the Spalart-Allmaras turbulence model |
| CTrilinosStokesInitializationProcess | A process to provide initial values for Navier-Stokes problems |
| CTrilinosFractionalStepSettings | Helper class to define solution strategies for FS_Strategy |
| CTrilinosFractionalStepSettingsPeriodic | Helper class to define solution strategies for FS_Strategy |
| CParabolicProfileUtilities | A set of functions to compute the Wall Shear Stress (WSS) |
| CWssStatisticsUtilities | A set of functions to compute the Wall Shear Stress (WSS) |
| CKratosFluidDynamicsBiomedicalApplication | Main class of the Fluid Dynamics Application |
| CHydraulicFluidAuxiliaryUtilities | |
| CKratosFluidDynamicsHydraulicsApplication | Short class definition |
| ►CSteadyConvectionDiffusionFICElement | |
| CElementVariables | |
| CTransientConvectionDiffusionFICElement | |
| CTransientConvectionDiffusionFICExplicitElement | |
| CTransientConvectionDiffusionPFEM2FICElement | Short class definition |
| CExplicitForwardEulerScheme | |
| CGeneralizedNewmarkGN11Scheme | |
| CElementUtilities | |
| CKratosFluidTransportApplication | Short class definition |
| CEdgesStructureType | |
| CMatrixContainer | |
| CEdgesStructureTypeC2C | |
| CMatrixContainerC2C | |
| CEdgeBasedLevelSet | |
| CEdgebasedLevelsetAuxiliaryUtils | |
| CEdgeBasedLevelSetSubstep | |
| CKratosFreeSurfaceApplication | Short class definition |
| CAitkenConvergenceAccelerator | Aitken convergence accelerator Aitken formula-based |
| CConstantRelaxationConvergenceAccelerator | Constant relaxation convergence accelerator This utility corrects the iteration guess with a constant relaxation factor |
| CFSIUtils | |
| CMVQNFullJacobianConvergenceAccelerator | MVQN acceleration scheme MultiVectorQuasiNewton convergence accelerator from Bogaers et al. 2016 |
| CIBQNMVQNConvergenceAccelerator | Interface Block Newton convergence accelerator Interface Block Newton equations convergence accelerator |
| CMVQNRandomizedSVDConvergenceAccelerator | MVQN-RZ acceleration scheme RandomiZed Multi-Vector Quasi-Newton (MVQN-RZ) method convergence accelerator from Zorrilla and Rossi 2022. The MVQN-RZ overcomes the memory and computational bottlenecks of the original MVQN algorithm by doing a randomized SVD decomposition of the previous step inverse Jacobian approximation. This makes possible to reduce the complexity of the method from quadratic (MVQN) to linear (MVQN-RZ). The settings of the method are "automatic_jacobian_modes": if true automatically selects the number of modes to be used in the decomposition "jacobian_modes": if not automatic, the number of modes to be used in the decomposition "w_0": relaxation parameter to be used in the very first update "cut_off_tol": relative tolerance to avoid (almost) linear dependent information in the observation matrices "interface_block_newton": false for the IQN equations case and true for the IBQN equations once "limit_modes_to_iterations": if not automatic, limits the modes to the number of iterations to avoid numerical noise "min_rand_svd_extra_modes": minimum of extra modes to be used in the randomized SVD decomposition |
| CIBQNMVQNRandomizedSVDConvergenceAccelerator | Interface Block Newton MVQN with randomized Jacobian convergence accelerator Interface Block Newton equations convergence accelerator with MVQN randomized SVD Jacobian for the subdomains |
| CJacobianEmulator | Jacobian emulator |
| CMVQNRecursiveJacobianConvergenceAccelerator | Recursive MVQN acceleration scheme Recursive MultiVectorQuasiNewton convergence accelerator. This convergence accelerator is an alternative implementation of the standard MVQN that avoids the storage of the |
| CNodalUpdateBaseClass | |
| CNodalUpdateNewmark | |
| CPartitionedFSIUtilities | |
| CSharedPointsMapper | Short class definition |
| CKratosFSIApplication | |
| CAxisymmetricLineNormalFluidFlux2DDiffOrderCondition | |
| CAxisymmetricLineNormalLoad2DDiffOrderCondition | |
| CAxisymmetricUPwNormalFaceLoadCondition | |
| ►CGeneralUPwDiffOrderCondition | |
| CConditionVariables | |
| CLineLoad2DDiffOrderCondition | |
| CLineNormalFluidFlux2DDiffOrderCondition | |
| CLineNormalLoad2DDiffOrderCondition | |
| CPwCondition | |
| ►CPwNormalFluxCondition | |
| CNormalFluxVariables | |
| CSurfaceLoad3DDiffOrderCondition | |
| CSurfaceNormalFluidFlux3DDiffOrderCondition | |
| CSurfaceNormalLoad3DDiffOrderCondition | |
| CGeoTCondition | |
| CWaterFluxes | |
| CGeoTMicroClimateFluxCondition | |
| CGeoTNormalFluxCondition | |
| CUPwCondition | |
| CUPwFaceLoadCondition | |
| CUPwFaceLoadInterfaceCondition | |
| CUPwForceCondition | |
| ►CUPwNormalFaceLoadCondition | |
| CNormalFaceLoadVariables | |
| ►CUPwNormalFluxCondition | |
| CNormalFluxVariables | |
| ►CUPwNormalFluxFICCondition | |
| CNormalFluxFICVariables | |
| CUPwNormalFluxInterfaceCondition | |
| ►CUPwLysmerAbsorbingCondition | |
| CNormalLysmerAbsorbingVariables | |
| CBilinearCohesive2DLaw | |
| ►CBilinearCohesive3DLaw | |
| CConstitutiveLawVariables | |
| CElasticIsotropicK03DLaw | This class defines a small deformation linear elastic constitutive model for 3D cases |
| CLinearElastic2DBeamLaw | This class defines a small deformation linear elastic constitutive model for plane strain beam elements |
| CLinearElastic2DInterfaceLaw | This class defines a small deformation linear elastic constitutive model for plane strain cases |
| CLinearElastic3DInterfaceLaw | This class defines a small deformation linear elastic constitutive model for plane strain cases |
| CGeoLinearElasticLaw | |
| CGeoLinearElasticPlaneStrain2DLaw | This class defines a small deformation linear elastic constitutive model for plane strain cases |
| CLinearPlaneStrainK0Law | This class defines a small deformation linear elastic constitutive model for plane strain cases |
| CGeoLinearElasticPlaneStress2DLaw | This class defines a small deformation linear elastic constitutive model for plane stress cases |
| CSmallStrainUDSM2DInterfaceLaw | Short class definition |
| CSmallStrainUDSM2DPlaneStrainLaw | Short class definition |
| CSmallStrainUDSM3DInterfaceLaw | Short class definition |
| CSmallStrainUDSM3DLaw | Short class definition |
| CSmallStrainUMAT2DInterfaceLaw | Short class definition |
| CSmallStrainUMAT2DPlaneStrainLaw | Short class definition |
| CSmallStrainUMAT3DInterfaceLaw | Short class definition |
| CSmallStrainUMAT3DLaw | Short class definition |
| CGeoThermalDispersionLaw | This class defines the thermal dispersion for heat cases |
| CDrainedUPwSmallStrainElement | |
| CGeoCableElement | This is a cable element inheriting from the GeoTrussElement |
| CGeoCrBeamElement2D2N | This is a 2D-2node beam element with 2 translational dofs and 1 rotational dof per node based on the same element in Structural Mechanics, modified to consider reset displacements |
| CGeoCrBeamElement3D2N | This is a 3D-2node beam element with 3 translational dofs and 3 rotational dof per node, based on CrBeamElement3D2N element in Structural Mechanics application, modified to account for reset displacements |
| CGeoCrBeamElementLinear2D2N | This is a linear 2D-2node beam element with 2 translational dofs and 1 rotational dof per node inheriting from CrBeamElementLinear2D2N |
| CGeoCrBeamElementLinear3D2N | This is a linear 3D-2node beam element with 3 translational dofs and 3 rotational dof per node inheriting from CrBeamElement3D2N |
| CGeoCurvedBeamElement | This is a geometrically non-linear (curved) beam element. The formulation can be found in papers written by Karan S. Surana, e.g: "1. Geometrically non-linear formulation for the axisymmetric shell elements" "2. Geometrically non-linear formulation for two dimensional curved beam elements" Discriptions of beam elements can be found in the following book, chapter 9. For 2D curved beams, see section 9.4: "Non-linear Finite element analysis of solids and structures" by De Borst et al |
| CGeoLinearTrussElement | This is a linear truss element |
| CGeoTrussElementLinearBase | This is a linear truss element inheriting from GeoTrussElementBase |
| ►CGeoStructuralBaseElement | |
| CElementVariables | Member Variables |
| CGeoTrussElement | This is a 2node truss element with reset-displacement |
| CGeoTrussElementBase | This is a 2D-2node truss element with 2 translational dofs per node |
| CSmallStrainUPwDiffOrderAxisymmetricElement | |
| ►CSmallStrainUPwDiffOrderElement | |
| CElementalVariables | |
| CElementVariables | |
| CSteadyStatePwElement | |
| CSteadyStatePwInterfaceElement | |
| CSteadyStatePwPipingElement | |
| CTransientPwElement | |
| CTransientPwInterfaceElement | |
| CTransientThermalElement | |
| CUPwBaseElement | |
| CUPwSmallStrainAxisymmetricElement | |
| CUPwSmallStrainAxisymmetricFICElement | |
| ►CUPwSmallStrainElement | |
| CElementVariables | |
| ►CUPwSmallStrainFICElement | |
| CFICElementVariables | |
| ►CUPwSmallStrainInterfaceElement | |
| CInterfaceElementVariables | |
| CSFGradAuxVariables | |
| CUPwSmallStrainLinkInterfaceElement | |
| CUPwUpdatedLagrangianElement | Updated Lagrangian element for 2D and 3D geometries |
| CUPwUpdatedLagrangianFICElement | Updated Lagrangian element for 2D and 3D geometries |
| CUndrainedUPwSmallStrainElement | |
| CUPwUpdatedLagrangianAxisymmetricElement | |
| CUPwUpdatedLagrangianAxisymmetricFICElement | |
| CUpdatedLagrangianUPwDiffOrderAxisymmetricElement | |
| CUpdatedLagrangianUPwDiffOrderElement | Updated Lagrangian element for 2D and 3D geometries |
| CActivateModelPartOperation | This operation emulate the effect of an excavation by deactivating some parts of the computational domain |
| CDeactivateModelPartOperation | This operation emulate the effect of an excavation by deactivating some parts of the computational domain |
| CApplyBoundaryHydrostaticPressureTableProcess | |
| CApplyBoundaryPhreaticLinePressureTableProcess | |
| CApplyBoundaryPhreaticSurfacePressureTableProcess | |
| CApplyConstantBoundaryHydrostaticPressureProcess | |
| CApplyConstantBoundaryPhreaticLinePressureProcess | |
| CApplyConstantBoundaryPhreaticSurfacePressureProcess | |
| CApplyConstantHydrostaticPressureProcess | |
| CApplyConstantInterpolateLinePressureProcess | |
| CApplyConstantPhreaticLinePressureProcess | |
| CApplyConstantPhreaticMultiLinePressureProcess | |
| CApplyConstantPhreaticSurfacePressureProcess | |
| CApplyExcavationProcess | |
| CApplyHydrostaticPressureTableProcess | |
| CApplyK0ProcedureProcess | |
| CApplyNormalLoadTableProcess | |
| CApplyPhreaticLinePressureTableProcess | |
| CApplyPhreaticMultiLinePressureTableProcess | |
| CApplyPhreaticSurfacePressureTableProcess | |
| CApplyScalarConstraintTableProcess | |
| CApplyVectorConstraintTableProcess | |
| CApplyWriteScalarProcess | |
| CDeactivateConditionsOnInactiveElements | Deactivate a condition if all elements attached to that are inactive |
| CFindNeighbourElementsOfConditionsProcess | Finds list of elements attached to conditions |
| CPeriodicInterfaceProcess | |
| CSetAbsorbingBoundaryParametersProcess | |
| CSetMultipleMovingLoadsProcess | Process to set and manage multiple moving loads offset according to a configuration variable |
| CSetParameterFieldProcess | Process to set a parameter field |
| ►CRetentionLaw | |
| CParameters | |
| CRetentionLawFactory | |
| CSaturatedBelowPhreaticLevelLaw | This class defines The Van-Genuchten Soil Water Characteristic Curve (retention curve) |
| CSaturatedLaw | This class defines a saturated Soil Water Characteristic Curve (retention curve) |
| CVanGenuchtenLaw | This class defines The Van-Genuchten Soil Water Characteristic Curve (retention curve) |
| CResidualBasedBlockBuilderAndSolverWithMassAndDamping | Current class provides an implementation for builder and solving operations, while the global mass and damping matrices are stored |
| CBackwardEulerQuasistaticPwScheme | |
| CBackwardEulerQuasistaticUPwScheme | |
| CBackwardEulerScheme | |
| CBackwardEulerTScheme | |
| CGeneralizedNewmarkScheme | |
| CGeneralizedNewmarkTScheme | |
| CFirstOrderScalarVariable | |
| CSecondOrderVectorVariable | |
| CGeoMechanicsTimeIntegrationScheme | |
| CNewmarkDynamicUPwScheme | |
| CNewmarkQuasistaticDampedUPwScheme | |
| CNewmarkQuasistaticPwScheme | |
| CNewmarkQuasistaticUPwScheme | |
| CGeoMechanicsNewtonRaphsonErosionProcessStrategy | |
| CGeoMechanicsNewtonRaphsonStrategy | |
| CGeoMechanicsRammArcLengthStrategy | |
| CBuilderAndSolverFactory | |
| CConditionUtilities | |
| CConvergenceCriteriaFactory | |
| CGeoElementUtilities | |
| CFileInputUtility | |
| CInputUtility | |
| CInterfaceElementUtilities | |
| CJsonProcessInfoParser | |
| CGeoMechanicsMathUtilities | |
| CParametersUtilities | |
| CProcessFactory | |
| CProcessInfoParser | |
| CProcessParameters | |
| CSchemeFactory | |
| CSolvingStrategyFactory | |
| CGeoStaticCondensationUtility | This utilitiy condenses given degrees of freedom from any element stiffness matrix to model e.g. hinges |
| CStressStrainUtilities | |
| CGeoStructuralMechanicsElementUtilities | |
| CVariablesUtilities | |
| CAdaptiveTimeIncrementor | |
| CCustomWorkflowFactory | |
| ►CKratosExecute | |
| CCallBackFunctions | |
| CCriticalHeadInfo | |
| CKratosGeoSettlement | |
| CGeoOutputWriter | |
| CPrescribedTimeIncrementor | |
| CScopedOutputFileAccess | |
| CSolvingStrategyWrapper | |
| CStrategyWrapper | |
| CTimeIncrementor | |
| CTimeLoopExecutor | |
| CTimeLoopExecutorInterface | |
| CTimeStepEndState | |
| CTimeStepExecutor | |
| CKratosGeoMechanicsApplication | Short class definition |
| CReadVariableFunctor | |
| CWriteVariableFunctor | |
| CRegisteredComponentLookup | A class for calling a functor on a variable specified by it's registered name |
| CKratosHDF5Application | This application provides an interface to write Kratos data using HDF5 |
| CCouplingLagrangeCondition | Lagrange factor based coupling condition |
| ►CCouplingNitscheCondition | Nitsche factor based coupling condition |
| CConstitutiveVariables | |
| CKinematicVariables | Internal variables used for metric transformation |
| CCouplingPenaltyCondition | Penalty factor based coupling condition |
| CLoadCondition | Condition for basic load types |
| CLoadMomentDirector5pCondition | Condition for moment loads for the 5p shell based on directors |
| COutputCondition | Output condition |
| CSupportLagrangeCondition | Lagrange Multiplier based support condition |
| ►CSupportNitscheCondition | Nitsche-type based support condition |
| CConstitutiveVariables | |
| CKinematicVariables | Internal variables used for metric transformation |
| CSupportPenaltyCondition | Condition for penalty support condition |
| ►CIgaMembraneElement | |
| CConstitutiveVariables | |
| CKinematicVariables | Internal variables used for metric transformation |
| CSecondVariations | |
| ►CShell3pElement | |
| CConstitutiveVariables | |
| CKinematicVariables | Internal variables used for metric transformation |
| CSecondVariations | |
| ►CShell5pElement | |
| CConstitutiveVariables | |
| CKinematicVariables | Internal variables used for metric transformation |
| CVariationVariables | |
| CShell5pHierarchicElement | |
| CTrussElement | |
| CTrussEmbeddedEdgeElement | |
| CIgaModeler | Short class definition |
| CNurbsGeometryModeler | |
| CRefinementModeler | Short class definition |
| CAssignIntegrationPointsToBackgroundElementsProcess | |
| CMapNurbsVolumeResultsToEmbeddedGeometryProcess | |
| CNitscheStabilizationModelPartProcess | |
| COutputEigenValuesProcess | |
| COutputQuadratureDomainProcess | |
| CAdditiveSchwarzPreconditioner | |
| CEigensolverNitscheStabilizationScheme | An adapter scheme for obtaining stiffness and stabilization matrices for Nitsche eigenvalue problems |
| CEigensolverNitscheStabilizationStrategy | Strategy for solving generalized eigenvalue problems to obtain Nitsche stabilization factor |
| CDirectorUtilities | |
| CIgaFlags | Flags needed used in the IGAApplication |
| CKratosIgaApplication | Short class definition |
| CEigenDenseBDCSVD | |
| CEigenDenseColumnPivotingHouseholderQRDecomposition | |
| CEigenDenseHouseholderQRDecomposition | |
| CEigenDenseJacobiSVD | |
| CDenseLinearSolverFactory | Here we add the functions needed for the registration of dense linear solvers |
| CEigenDenseColPivHouseholderQRSolver | |
| CEigenDenseDirectSolver | |
| CDenseEigenvalueSolver | |
| CEigenDenseHouseholderQRSolver | |
| CEigenDenseLLTSolver | |
| CEigenDensePartialPivLUSolver | |
| CSpaceType | |
| CSpaceType< double > | |
| CSpaceType< std::complex< double > > | |
| CEigenDirectSolver | |
| CEigenPardisoLDLTSolver | |
| CEigenPardisoLLTSolver | |
| CEigenPardisoLUSolver | |
| CEigenSparseCGSolver | |
| CEigenSparseLUSolver | |
| CEigenSparseQRSolver | |
| CEigensystemSolver | |
| CFEASTEigensystemSolver | |
| CSpectraSymGEigsShiftSolver | |
| CFEASTConditionNumberUtility | This utility uses the FEAST solver to obtain (estimate) the the condition number of a regular matrix |
| CUblasWrapper | |
| CKratosLinearSolversApplication | |
| CBarycentricInterfaceInfo | |
| CBarycentricLocalSystem | |
| CBarycentricMapper | Barycentric Mapper |
| CCouplingGeometryLocalSystem | |
| CCouplingGeometryMapper | |
| CAccessorInterpolativeMapperBase | Definition of an accessor auxiliary class |
| CInterpolativeMapperBase | |
| CNearestElementOptions | Options for configuring the behavior of the Mapper |
| CNearestElementInterfaceInfo | |
| CNearestElementLocalSystem | |
| CNearestElementMapper | Interpolative Mapper |
| CNearestNeighborInterfaceInfo | |
| CNearestNeighborLocalSystem | |
| CNearestNeighborMapper | Nearest Neighbor Mapper |
| CProjection3D2DMapper | This mapper simplifies the mapping between two model parts thanks to the projection over a reference plane |
| CMappingGeometriesModeler | Short class definition |
| CInterfaceObjectConfigure | |
| CInterfaceCommunicator | Object for exchanging data on the Interface |
| CInterfaceObject | Object used by the bin-search |
| CInterfaceNode | |
| CInterfaceGeometryObject | |
| CPointWithId | |
| CClosestPointsContainer | |
| CInterfaceVectorContainer | Short class definition |
| CMapperBackend | |
| CMapperInterfaceInfo | Object for storing data that is needed to construct the local-mapping-system |
| CMapperLocalSystem | This is the "Condition" of the mappers |
| CMappingMatrixUtilities | |
| CKratosMappingApplication | Short class definition |
| CInterfaceCommunicatorMPI | Object for exchanging data on the Interface in MPI |
| CMapperMPIBackend | |
| ►CMedModelPartIO | Short class definition |
| CMedFileHandler | |
| CMedTestingUtilities | Short class definition |
| CKratosMedApplication | |
| CGaussPointItem | Custom Gauss Point container to be used by the search |
| CMeshingFlags | Flags needed used in the MeshingApplication |
| CMmgIO | This class is a IO which uses the MMG library |
| CPfemGidGaussPointsContainer | |
| CPfemGidMeshContainer | |
| CEmbeddedMeshLocatorProcess | Short class definition |
| CInternalVariablesInterpolationProcess | This utilitiy has as objective to interpolate the values inside elements (and conditions?) in a model part, using as input the original model part and the new one |
| CMetricFastInit | This process initializes the variables related with the ALM |
| CMetricErrorProcess | This class is can be used to compute the metrics of the model part with a error already computed |
| CAuxiliarHessianComputationVariables | This is an auxiliar struct to store remeshing variables |
| CComputeHessianSolMetricProcess | This class is can be used to compute the metrics of the model part with an Hessian approach |
| CComputeLevelSetSolMetricProcess | This class is can be used to compute the metrics of the model part with a level set approach |
| CMmgProcess | This class is a remesher which uses the MMG library |
| CMultiscaleRefiningProcess | This class provides a non conforming refinement to perform multi scale analysis @detail This process manages three model parts, the coarse model part, refined model part and the visualization model part. This process can be constructed again with the refined model part as the coarse model part in order to get several subscales levels. The refinement is executed by the UniformRefinementUtility where the nodal flag TO_REFINE is set to True. Then, the coarse elements are removed from the visualization model part and the refined elements are added to the visualization model part. The coarsening is executed by the UniformRefinementUtility where the nodal flag TO_REFINE is set to False. Then, the refined elements are deleted and the corresponding coarse elements are added again to the visualization model part. Flags used by the process: TO_REFINE : Those entities will be refined MeshingFlags::REFINED : Once they are refined MeshingFlags::TO_COARSEN : When they aren't TO_REFINE and they doesn't have dependencies TO_ERASE : auxiliary flag NEW_ENTITY : auxiliary flag INTERFACE : the boundary of the refined model part INSIDE : the refined nodes which are not boundary Variables used by the process: SUBSCALE_INDEX : is increased from the coarse model part to the refined one FATHER_NODES : the pointers to the coarse nodes FATHER_NODES_WEIGHTS : the weights of the father nodes SLAVE_NODE : a pointer to the refined node (matching nodes between coarse and refined model parts) FATHER_ELEMENT : the pointer to the coarse element FATHER_CONDITION : the pointer to the coarse condition |
| CPointBoundary | Custom Point container to be used to look in the boundary skin |
| CNodalValuesInterpolationProcess | This utilitiy has as objective to interpolate the values inside elements (and conditions?) in a model part, using as input the original model part and the new one |
| CParMmgProcess | This class is a remesher which uses the PMMG library |
| CSetHMapProcess | Short class definition |
| CBinBasedMeshTransfer | This class allows the interpolation between non-matching meshes in 2D and 3D |
| CCutting_Isosurface_Application | CUTTING ISOSURFACE APPLICATION |
| CGradualVariableInterpolationUtility | |
| CLinearToQuadraticTetrahedraMeshConverter | |
| CLocalRefineGeometryMesh | |
| CLocalRefinePrismMesh | |
| CLocalRefineTetrahedraMesh | |
| CLocalRefineTetrahedraMeshOnlyOnBoundaries | |
| CLocalRefineTetrahedraMeshParallelToBoundaries | |
| CLocalRefineTriangleMesh | |
| CLocalRefineTriangleMeshConditions | |
| CLocalRefineTriangleMeshGeneric | |
| CMetricsMathUtils | This class is used to compute some mathematical operations needed for the metrics computing |
| CMMGMeshInfo | Stores the Mmg mesh information |
| CMmgUtilities | Provides the Kratos interface to the MMG library API |
| CPMMGMeshInfo | Stores the ParMmg mesh information |
| CParMmgUtilities | Provides the Kratos interface to the PMMG library API |
| CDistanceCalculator | |
| CMeshTransfer | This class allows the interpolation between non-matching meshes in 2D and 3D |
| CTetgenVolumeMesher | This class performs the (constrained) Delaunay meshing of the internal volume given a surface discretized in terms of triangular conditions |
| CTetrahedraReconnectUtility | Short class definition |
| CUniformRefinementUtility | This 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 |
| CMSuitePFEMModeler | Short class definition |
| CPragmaticAdaptor | |
| CTetGenCDT | Short class definition |
| CTetGenPfemContact | Short class definition |
| CTetGenPfemModeler | Short class definition |
| CTetGenPfemRefineFace | Short class definition |
| CTetGenPfemModelerVms | Short class definition |
| CTriGenCDT | Short class definition |
| CTriGenDropletModeler | Short class definition |
| CTriGenGLASSModeler | Short class definition |
| CTriGenModeler | Short class definition |
| CTriGenPFEMModeler | Short class definition |
| CTriGenPFEMRefineSegment | Short class definition |
| CTriGenPFEMModelerVMS | Short class definition |
| CKratosMeshingApplication | Short class definition |
| CLaplacianMeshMovingElement | |
| CStructuralMeshMovingElement | |
| CLaplacianMeshMovingStrategy | Short class definition |
| CStructuralMeshMovingStrategy | Short class definition |
| CAffineTransform | Class for applying affine transformations |
| CFixedMeshALEUtilities | Utility 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 |
| CParametricAffineTransform | Class for applying parametrically defined affine transformations |
| CKratosMeshMovingApplication | Short class definition |
| CTrilinosLaplacianMeshMovingStrategy | Short class definition |
| CTrilinosStructuralMeshMovingStrategy | Short class definition |
| CMetisDivideHeterogeneousInputInMemoryProcess | Call Metis to divide an heterogeneous mesh, by partitioning its nodal graph |
| CMetisDivideHeterogeneousInputProcess | Call Metis to divide an heterogeneous mesh, by partitioning its nodal graph |
| CMetisDivideSubModelPartsHeterogeneousInputProcess | Short class definition |
| ►CMortonDivideInputToPartitionsProcess | Short class definition |
| CDomainEntitiesIdContainer | |
| CMortonPartitioningProcess | Short class definition |
| CLegacyPartitioningUtilities | This class contains legacy versions of utilities used by the metis partitioners |
| CMetisPartitioningUtilities | This class contains utilities used by the metis partitioners |
| CKratosMetisApplication | Short class definition |
| CHelmholtzSurfShapeCondition | This is the class of surface PDE/Helmholtz-based surface filtering |
| CHelmholtzSurfaceShapeCondition | Short class definition |
| CHelmholtzJacobianStiffened3D | This class defines constitutive model for shape filtering of solid 3D cases. This current implementation is basically elastic isotropic materical which computes young modules based on element's jacobian and helmholtz filter radius |
| CAdjointSmallDisplacementElement | Short class definition |
| ►CHelmholtzSolidDataContainer | |
| CConstantDataContainer | |
| ►CHelmholtzSolidShapeDataContainer | |
| CConstantDataContainer | |
| ►CHelmholtzSurfaceDataContainer | |
| CConstantDataContainer | |
| CHelmholtzVariableData | |
| CHelmholtzVariableData< 1 > | |
| CHelmholtzVariableData< 2 > | |
| CHelmholtzVariableData< 3 > | |
| CHelmholtzBulkElement | Short class definition |
| CHelmholtzBulkShapeElement | Short class definition |
| CHelmholtzElement | Short class definition |
| CHelmholtzSurfShapeElement | Short class definition |
| CHelmholtzSurfThicknessElement | Short class definition |
| CHelmholtzStrategy | Short class definition |
| CCollectiveExpression | Construct a new CollectiveExpression instance |
| ►CCollectiveExpressionIO | |
| CHistoricalVariable | |
| CNonHistoricalVariable | |
| CPropertiesVariable | |
| CContainerExpressionUtils | |
| CContainerDataIO< ContainerDataIOTags::Properties > | |
| CSigmoidalProjectionUtils | |
| CEntityCalculationUtils | |
| CDampingFunction | Short class definition |
| CEntityPoint | |
| CExplicitFilter | |
| CFilterFunction | Short class definition |
| ►CSymmetryUtility | Short class definition |
| CPlaneSymmetryData | |
| CRotationalSymmetryData | |
| CImplicitFilterUtils | |
| COptimizationUtils | |
| ►CPropertiesVariableExpressionIO | |
| CInput | |
| COutput | |
| CLinearStrainEnergyResponseUtils | |
| CMassResponseUtils | |
| CMaxOverhangAngleResponseUtils | |
| CKratosOptimizationApplication | Short class definition |
| CMPMGridAxisymLineLoadCondition2D | Axisymmetric line load condition |
| CMPMGridAxisymPointLoadCondition | Axisymmetric point load condition |
| CMPMGridBaseLoadCondition | |
| CMPMGridLineLoadCondition2D | Short class definition |
| CMPMGridPointLoadCondition | Short class definition |
| CMPMGridSurfaceLoadCondition3D | |
| ►CMPMParticleBaseCondition | |
| CGeneralVariables | |
| CMPMParticleBaseDirichletCondition | |
| CMPMParticleBaseLoadCondition | Short class definition |
| CMPMParticlePenaltyDirichletCondition | Short class definition |
| CMPMParticlePointLoadCondition | Short class definition |
| ►CDispNewtonianFluid3DLaw | |
| CMaterialResponseVariables | |
| CDispNewtonianFluidPlaneStrain2DLaw | |
| ►CBorjaCamClayPlasticFlowRule | Short class definition |
| CMaterialParameters | |
| ►CMCPlasticFlowRule | Short class definition |
| CMaterialParameters | |
| CMCStrainSofteningPlasticFlowRule | Short class definition |
| ►CParticleFlowRule | Short class definition |
| CInternalVariables | |
| CPlasticFactors | |
| CRadialReturnVariables | |
| CThermalVariables | |
| CCamClayHardeningLaw | Short class definition |
| CExponentialStrainSofteningLaw | Short class definition |
| ►CParticleHardeningLaw | Short class definition |
| CParameters | |
| CHenckyBorjaCamClayPlastic3DLaw | |
| CHenckyBorjaCamClayPlasticAxisym2DLaw | |
| CHenckyBorjaCamClayPlasticPlaneStrain2DLaw | |
| CHenckyMCPlastic3DLaw | |
| CHenckyMCPlasticAxisym2DLaw | |
| CHenckyMCPlasticPlaneStrain2DLaw | |
| CHenckyMCPlasticPlaneStrainUP2DLaw | |
| CHenckyMCStrainSofteningPlastic3DLaw | |
| CHenckyMCStrainSofteningPlasticAxisym2DLaw | |
| CHenckyMCStrainSofteningPlasticPlaneStrain2DLaw | |
| CHenckyMCPlasticUP3DLaw | |
| ►CHenckyElasticPlastic3DLaw | |
| CMatrixSplit | |
| CPlasticMaterialResponseVariables | |
| CVectorSplit | |
| CHenckyElasticPlasticAxisym2DLaw | |
| CHenckyElasticPlasticPlaneStrain2DLaw | |
| CHenckyElasticPlasticPlaneStrainUP2DLaw | |
| CHenckyElasticPlasticUP3DLaw | |
| ►CHyperElastic3DLaw | |
| CMaterialResponseVariables | |
| CHyperElasticAxisym2DLaw | |
| CHyperElasticPlaneStrain2DLaw | |
| CHyperElasticPlaneStrainUP2DLaw | |
| ►CHyperElasticUP3DLaw | |
| CMatrixSplit | |
| CVectorSplit | |
| CJohnsonCookThermalPlastic3DLaw | |
| CJohnsonCookThermalPlastic2DAxisymLaw | |
| CJohnsonCookThermalPlastic2DPlaneStrainLaw | |
| CLinearElastic3DLaw | |
| CLinearElasticAxisym2DLaw | |
| CLinearElasticPlaneStrain2DLaw | |
| CLinearElasticPlaneStress2DLaw | |
| CMCYieldCriterion | Short class definition |
| CModifiedCamClayYieldCriterion | Short class definition |
| ►CParticleYieldCriterion | Short class definition |
| CParameters | |
| ►CMPMUpdatedLagrangian | Large Displacement Lagrangian Element for 3D and 2D geometries. (base class) |
| CGeneralVariables | |
| CMaterialPointVariables | |
| CMPMUpdatedLagrangianPQ | Partitioned Quadrature Large Displacement Lagrangian Element for 3D and 2D geometries. (base class) |
| CMPMUpdatedLagrangianUP | Large Displacement Lagrangian Element for 3D and 2D geometries. (base class) |
| CQuadraturePointPartitionedGeometry | |
| CParticleVtkOutput | ParticleVtkOutput A simple class that has functionality to write vtk output |
| CParticleEraseProcess | Delete particle elements and conditions with flag TO_ERASE |
| CMPMExplicitScheme | A MPM explicit scheme |
| CMPMResidualBasedBossakScheme | Bossak integration scheme (for linear and nonlinear dynamic problems) for displacements adjusted for Material Point Method |
| CMPMExplicitStrategy | Short class definition |
| CMPMResidualBasedNewtonRaphsonStrategy | Short class definition |
| CMPM_MPI_Utilities | Provides place to add mpi related utility functions |
| CMPMBoundaryRotationUtility | |
| CMPMStressPrincipalInvariantsUtility | |
| CParticleMechanicsMathUtilities | |
| CPQMPMPartitionUtilities | This class includes several utilities necessaries for the PQMPM |
| CKratosParticleMechanicsApplication | Short class definition |
| CMonolithicAutoSlipInlet3D | Implements a wall condition for the PFEM2 formulation |
| CFixedPressure2D | |
| CFixedPressure3D | |
| CFixedVelocity2D | |
| CFixedVelocity3D | |
| CWaterFixedVelocity2D | |
| CFractionalStepPFEM22D | |
| CFractionalStepPFEM23D | |
| CMonolithicPFEM22D | |
| CMonolithicAutoSlipPFEM22D | |
| CMonolithicPFEM23D | |
| CMonolithicAutoSlipPFEM23D | |
| CMonolithic3FluidPFEM22D | |
| CMonolithic3FluidPFEM23D | |
| CNoNewtonianMonolithicPFEM22D | |
| CNoNewtonianMonolithicPFEM23D | |
| CQFluid2D | This element implements a Multi-stage element (2D case) to be used in conjuntion with |
| CQFluid3D | Short class definition |
| CVelocityEnrichedPFEM22D | |
| CBackwardEulerMonolithicAleScheme | A first order scheme for testing purpose |
| CPFEM2_Explicit_Strategy | |
| CFluid_Phase_PFEM2_Explicit_Strategy | |
| CFracStepStrategy | Short class definition |
| CPFEM2MonolithicSlipScheme | |
| CPFEM2MonolithicSlipStrategy | |
| CResidualBasedPredictorCorrectorVelocityBossakAleScheme | Bossak time scheme for the incompressible flow problem |
| CAddFixedVelocityCondition2D | |
| CAddFixedVelocityCondition3D | |
| CAddFixedPressureCondition2D | |
| CAddFixedPressureCondition3D | |
| CAddWaterFixedVelocityCondition2D | |
| CCalculateWaterFraction | |
| CEnrichmentUtilitiesforPFEM2 | |
| CMarkFluidProcess | Short class definition |
| CMarkOuterNodesProcess | Short class definition |
| CMoveParticleUtilityPFEM2 | |
| CDistanceCalculator1 | |
| CParticleUtils | |
| CPfem2Utils | |
| CPFEM_Particle | PFEM Particle class |
| CPFEM_Particle_Fluid | PFEM Particle class |
| CSaveLagrangianSurfaceProcess_p | Short class definition |
| CMoveParticleUtilityDiffFluidOnly | |
| CPfem2ApplyBCProcess | Short class definition |
| CVisualizationUtilities | |
| CKratosPFEM2Application | Short class definition |
| CUpdatedLagrangianSegregatedFluidElement | Updated Lagrangian Segregated Fluid Element for 3D and 2D geometries |
| CAdaptiveTimeIntervalProcess | Short class definition |
| CAssignPropertiesToNodesProcess | The base class for fixing scalar variable Dof or array_1d component Dof processes in Kratos |
| CInletMesherProcess | Insert a new Inlet Layer when the previous one has gone away |
| CInsertFluidNodesMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CManageIsolatedNodesProcess | Process for managing the time integration of variables for isolated nodes |
| CManageSelectedElementsProcess | Process for managing the time integration of variables for selected elements |
| CRecoverVolumeLossesProcess | Move free surface to restore volume losses |
| CRefineFluidElementsInEdgesMesherProcess | Refine Mesh Elements Process 2D and 3D |
| CRemoveFluidNodesMesherProcess | Remove Fluid Nodes Process for 2D and 3D cases |
| CVolumeShapingProcess | Move free surface to restore volume losses |
| CKratosPfemApplication | Short class definition |
| CBingham2DLaw | |
| CPfemFluidConstitutiveLaw | This class contains the common infrastructure for the pfem fluid constitutive laws |
| CFrictionalViscoplastic2DLaw | |
| CFrictionalViscoplastic3DLaw | |
| CHerschelBulkley2DLaw | |
| CMuIRheology2DLaw | |
| CMuIRheology3DLaw | |
| CBinghamTemperatureDependent2DLaw | |
| CBinghamTemperatureDependent3DLaw | |
| CFrictionalViscoplasticTemperatureDependent2DLaw | |
| CFrictionalViscoplasticTemperatureDependent3DLaw | |
| CMuIRheologyTemperatureDependent2DLaw | |
| CMuIRheologyTemperatureDependent3DLaw | |
| CHypoelastic2DLaw | |
| CHypoelastic3DLaw | |
| CPfemSolidConstitutiveLaw | This class contains the common infrastructure for solid constitutive laws |
| CHypoelasticTemperatureDependent2DLaw | |
| CHypoelasticTemperatureDependent3DLaw | |
| CThreeStepFirstOrderUpdatedLagrangianElement | A stabilized element for the incompressible Navier-Stokes equations |
| CThreeStepSecondOrderPspgUpdatedLagrangianElement | A stabilized element for the incompressible Navier-Stokes equations |
| CThreeStepSecondOrderUpdatedLagrangianElement | A stabilized element for the incompressible Navier-Stokes equations |
| CThreeStepUpdatedLagrangianElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitFluidDEMcouplingElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitFluidElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitFluidFicElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitFluidPspgElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitNodallyIntegratedElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitNodallyIntegratedFluidElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitNodallyIntegratedSolidElement | A stabilized element for the incompressible Navier-Stokes equations |
| CTwoStepUpdatedLagrangianVPImplicitSolidElement | A stabilized element for the incompressible Navier-Stokes equations |
| ►CUpdatedLagrangianElement | A stabilized element for the incompressible Navier-Stokes equations |
| CElementalVariables | |
| CUpdatedLagrangianVImplicitSolidElement | A stabilized element for the incompressible Navier-Stokes equations |
| CAssignScalarFieldToPfemEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignScalarVariableToPfemEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignVectorFieldToPfemEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignVectorVariableToPfemConditionsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CBuildMeshBoundaryForFluidsProcess | Short class definition |
| CBuildModelPartBoundaryForFluidsProcess | Short class definition |
| CCalculateWaveHeightProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CComputeAveragePfemMeshParametersProcess | Refine Mesh Elements Process 2D and 3D |
| CFindNodalHForRigidWallsProcess | Refine Mesh Elements Process 2D and 3D |
| CPFEMFixFreeVelocityOnNodesProcess | |
| CFixScalarPfemDofProcess | The base class for fixing scalar variable Dof or array_1d component Dof processes in Kratos |
| CFreeScalarPfemDofProcess | The base class for freeing scalar variable Dof or array_1d component Dof processes in Kratos |
| CGenerateNewConditionsMesherForFluidsProcess | Short class definition |
| CGenerateNewNodesBeforeMeshingProcess | Refine Mesh Elements Process 2D and 3D |
| CInletManagementProcess | Refine Mesh Elements Process 2D and 3D |
| CLagrangianRotationProcess | Process used to rotate lagrangian model parts using Rodrigues' rotation formula |
| CModelStartEndMeshingForFluidsProcess | Short class definition |
| CRemoveMeshNodesForFluidsProcess | Remove Mesh Nodes Process for 2D and 3D cases |
| CSelectMeshElementsForFluidsProcess | Refine Mesh Elements Process 2D and 3D |
| CSetActiveFlagMesherProcess | Short class definition |
| CSetActiveFlagProcess | Short class definition |
| CSetDummyPropertyForRigidElementsProcess | |
| CSetEulerianInletProcess | Refine Mesh Elements Process 2D and 3D |
| CSetLagrangianInletProcess | Refine Mesh Elements Process 2D and 3D |
| CSetMainMaterialPropertyProcess | Short class definition |
| CSetMaterialPropertiesForThermalCouplingProcess | This process sets the nodal value of thermal properties (density, conductivity and capacity) that depends on the temperature, which is necesssary for solving the termal part, since the convection-diffusion solver gets these nodal values for assembling the system. The value of these properties are computed according to the constitutive law of the incident elements of each node, using the nodal temperature, and the average is taken as the nodal value for the property |
| CSetMaterialPropertiesFromFluidToRigidNodesProcess | Short class definition |
| CSetMaterialPropertiesToFluidNodesProcess | Short class definition |
| CSetMaterialPropertiesToSolidNodesProcess | Short class definition |
| CSetMeshVelocityForThermalCouplingProcess | This method sets the MESH_VELOCITY equal to the nodal VELOCITY |
| CSplitElementsProcess | Short class definition |
| CTransferModelPartElementsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CUpdateConditionsOnFreeSurfaceProcess | This process updates the conditions applied to the free surface after the remeshing |
| CUpdateThermalModelPartProcess | |
| CNodalResidualBasedEliminationBuilderAndSolver | Current class provides an implementation for standard builder and solving operations |
| CNodalResidualBasedEliminationBuilderAndSolverContinuity | Current class provides an implementation for standard builder and solving operations |
| CNodalResidualBasedEliminationBuilderAndSolverContinuityForFSI | Current class provides an implementation for standard builder and solving operations |
| CNodalResidualBasedEliminationBuilderAndSolverForFSI | Current class provides an implementation for standard builder and solving operations |
| CGaussSeidelLinearStrategy | Short class definition |
| CNodalTwoStepVPStrategy | |
| CNodalTwoStepVPStrategyForFSI | |
| CThreeStepVPStrategy | |
| CTwoStepVPDEMcouplingStrategy | |
| CTwoStepVPStrategy | |
| CTwoStepVPThermalStrategy | |
| CVPStrategy | |
| CCalculateWaveHeightUtility | This function computes the wave height at a given point |
| CPFEMMoveMeshUtility | This utility resets the nodes of a PFEM fluid ModelPart, used especially in the PFEM-FEM coupling |
| CPfemFluidGidIO | |
| CTwoStepVPSolverSettings | Helper class to define solution strategies for TwoStepVPStrategy |
| CTwoStepVPSettings | Helper class to define solution strategies for FS_Strategy |
| CKratosPfemFluidDynamicsApplication | Short class definition |
| CPFEMFlags | |
| CBorjaHenckyCamClayPlastic3DLaw | |
| CBorjaHenckyCamClayPlasticAxisym2DLaw | |
| CBorjaHenckyCamClayPlasticPlaneStrain2DLaw | |
| CBorjaCamClayExplicitFlowRule | Short class definition |
| CJ2ExplicitFlowRule | Short class definition |
| ►CNonAssociativeExplicitPlasticFlowRule | Short class definition |
| CAuxiliarDerivativesStructure | |
| CExplicitStressUpdateInformation | |
| CTrescaExplicitFlowRule | Short class definition |
| CCamClayYieldCriterion | Short class definition |
| CJ2YieldCriterion | Short class definition |
| CNewTrescaYieldCriterion | Short class definition |
| CTrescaStressInvariants | |
| CTrescaYieldCriterion | Short class definition |
| CHenckyJ2PlasticAxisym2DLaw | |
| CHenckyJ2PlasticPlaneStrain2DLaw | |
| CHenckyTresca3DLaw | |
| CHenckyTrescaPlasticAxisym2DLaw | |
| CHenckyTrescaPlasticPlaneStrain2DLaw | |
| CHenckyPlasticUPJ2Axisym2DLaw | |
| CHenckyPlasticUPJ2PlaneStrain2DLaw | |
| CHenckyPlasticUPTrescaAxisym2DLaw | |
| CHenckyPlasticUPTrescaPlaneStrain2DLaw | |
| CNewHenckyTrescaPlasticAxisym2DLaw | |
| CNewHenckyTrescaPlasticPlaneStrain2DLaw | |
| CNonLinearHenckyElasticPlastic3DLaw | |
| CNonLinearHenckyElasticPlasticAxisym2DLaw | |
| CNonLinearHenckyElasticPlasticPlaneStrain2DLaw | |
| CNonLinearHenckyElasticPlasticUP3DLaw | |
| CNonLinearHenckyElasticPlasticUPAxisym2DLaw | |
| CNonLinearHenckyElasticPlasticUPPlaneStrain2DLaw | |
| CAxisymUpdatedLagrangianUJElement | |
| CAxisymUpdatedLagrangianUJWwPDMEElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CAxisymUpdatedLagrangianUJWwPElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CAxisymUpdatedLagrangianUJwPElement | Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CAxisymUpdatedLagrangianUPwPElement | Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CAxisymUpdatedLagrangianUPressureElement | |
| CAxisymUpdatedLagrangianUwPElement | Axisymmetric Updated Lagrangian Large Displacement Lagrangian U-Pw Element |
| CAxisymUpdatedLagrangianUwPStabElement | Stabilization of the Axisim Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries |
| CSmallDisplacementUWwPElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CTotalUpdatedLagrangianElement | Total Updated Lagrangian Element for 3D and 2D geometries |
| CTotalUpdatedLagrangianUPElement | Total Updated Lagrangian U-P Element for 3D and 2D geometries. Linear Triangles and Tetrahedra |
| CUpdatedLagrangianUJElement | Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| ►CUpdatedLagrangianUJPElement | |
| CUJPElementData | |
| CUpdatedLagrangianUJWwPDMEElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUJWwPElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUJWwPHOElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUJwPElement | Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUPwPElement | Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| ►CUpdatedLagrangianUPressureElement | Large Displacement Lagrangian U-P Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CThisElementData | |
| CUpdatedLagrangianUWElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUWwPDMEElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUWwPElement | Updated Lagrangian Large Displacement Lagrangian U-W Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUwPElement | Updated Lagrangian Large Displacement Lagrangian U-wP Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CUpdatedLagrangianUwPStabElement | Updated Lagrangian Large Displacement U-Pw Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| ►CRefineConditionsInContactMesherProcess | Refine Mesh Boundary Process |
| CRefineCounters | |
| CSetMechanicalInitialStateProcess | |
| ►CResidualBasedBossakScheme | |
| CGeneralAlphaMethod | |
| CGeneralMatrices | |
| CGeneralVectors | |
| CNewmarkMethod | |
| CAxisymWaterPressureUtilities | |
| CAxisymWaterPressureJacobianUtilities | |
| CDeviatoricPlaneShapeUtilities | |
| ►CWaterPressureUtilities | |
| CHydroMechanicalVariables | |
| CWaterPressureJacobianUtilities | |
| CKratosPfemSolidMechanicsApplication | Short class definition |
| CUPwDischargeCondition | |
| ►CFlowRule | Short class definition |
| CInternalVariables | |
| CPlasticFactors | |
| CRadialReturnVariables | |
| CThermalVariables | |
| CIsotropicDamageFlowRule | Short class definition |
| CLocalDamageFlowRule | |
| CNonlocalDamageFlowRule | |
| CExponentialDamageHardeningLaw | Short class definition |
| ►CHardeningLaw | Short class definition |
| CParameters | |
| CModifiedExponentialDamageHardeningLaw | Short class definition |
| CModifiedMisesYieldCriterion | Short class definition |
| CSimoJuYieldCriterion | Short class definition |
| ►CYieldCriterion | Short class definition |
| CParameters | |
| CElasticCohesive2DLaw | |
| ►CElasticCohesive3DLaw | |
| CConstitutiveLawVariables | |
| CElastoPlasticModMohrCoulombCohesive2DLaw | |
| ►CElastoPlasticModMohrCoulombCohesive3DLaw | |
| CConstitutiveLawVariables | |
| CElastoPlasticMohrCoulombCohesive2DLaw | |
| ►CElastoPlasticMohrCoulombCohesive3DLaw | |
| CConstitutiveLawVariables | |
| CElastoPlasticConstitutiveLawVariables | |
| CExponentialCohesive2DLaw | |
| CExponentialCohesive3DLaw | |
| CHistoryLinearElastic3DLaw | |
| CHistoryLinearElasticPlaneStrain2DLaw | |
| CHistoryLinearElasticPlaneStress2DLaw | |
| ►CHyperElasticPlastic3DLaw | |
| CMatrixSplit | |
| CVectorSplit | |
| CIsotropicDamageCohesive2DLaw | |
| ►CIsotropicDamageCohesive3DLaw | |
| CConstitutiveLawVariables | |
| CLinearElasticPlastic3DLaw | |
| CLocalDamage3DLaw | |
| CLocalDamagePlaneStrain2DLaw | |
| CLocalDamagePlaneStress2DLaw | |
| CModifiedMisesNonlocalDamage3DLaw | |
| CModifiedMisesNonlocalDamagePlaneStrain2DLaw | |
| CModifiedMisesNonlocalDamagePlaneStress2DLaw | |
| CNonlocalDamage3DLaw | |
| CNonlocalDamagePlaneStrain2DLaw | |
| CNonlocalDamagePlaneStress2DLaw | |
| CSimoJuLocalDamage3DLaw | |
| CSimoJuLocalDamagePlaneStrain2DLaw | |
| CSimoJuLocalDamagePlaneStress2DLaw | |
| CSimoJuNonlocalDamage3DLaw | |
| CSimoJuNonlocalDamagePlaneStrain2DLaw | |
| CSimoJuNonlocalDamagePlaneStress2DLaw | |
| CUPwElement | |
| CPoromechanicsFaceLoadControlModuleProcess | FaceLoad control module for displacements |
| CPoroExplicitCDScheme | An explicit forward euler scheme with a split of the inertial term |
| CPoroExplicitVVScheme | An explicit forward euler scheme with a split of the inertial term |
| CPoroNewmarkDynamicUPwScheme | |
| CPoroNewmarkQuasistaticDampedUPwScheme | |
| CPoroNewmarkQuasistaticUPwScheme | |
| CPoromechanicsExplicitNonlocalStrategy | |
| CPoromechanicsExplicitStrategy | |
| CPoromechanicsNewtonRaphsonNonlocalStrategy | |
| CPoromechanicsNewtonRaphsonStrategy | |
| CPoromechanicsRammArcLengthNonlocalStrategy | |
| CPoromechanicsRammArcLengthStrategy | |
| ►CFracturePropagation2DUtilities | |
| CBifurcation | |
| CFracturePoint | Structs for fracture propagation check ---------------------------------------------------------------------------------------------------------------------------------— |
| CGaussPointOld | Structs for mapping model parts ----------------------------------------------------------------------------------------------------------------------------------------— |
| CPropagation | |
| CPropagationGlobalVariables | |
| CPropagationLocalVariables | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| ►CFracturePropagation3DUtilities | |
| CBifurcation | |
| CFracturePoint | Structs for fracture propagation check ---------------------------------------------------------------------------------------------------------------------------------— |
| CGaussPointOld | Structs for mapping model parts ----------------------------------------------------------------------------------------------------------------------------------------— |
| CPropagation | |
| CPropagationGlobalVariables | |
| CPropagationLocalVariables | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| ►CInitialStress2DUtilities | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| ►CInitialStress3DUtilities | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| CIsotropicDamageUtilities | |
| CNonlocalDamage2DUtilities | |
| CNonlocalDamage3DUtilities | |
| ►CNonlocalDamageUtilities | |
| CGaussPoint | |
| CPoroConditionUtilities | |
| CPoroElementUtilities | |
| CSolidMechanicsMathUtilities | |
| CKratosPoromechanicsApplication | |
| CFractionalStepKBasedWallCondition | Implements a wall condition for the monolithic formulation |
| CIncompressiblePotentialFlowVelocityInletCondition | |
| CScalarWallFluxCondition | |
| CScalarWallFluxConditionData | |
| CVMSMonolithicKBasedWallCondition | |
| CRansNewtonian2DLaw | This class is extending Newtonian2DLaw in FluidDynamicsApplication |
| CRansNewtonian3DLaw | This class is extending Newtonian3DLaw in FluidDynamicsApplication |
| CConvectionDiffusionReactionCrossWindStabilizedElement | |
| CConvectionDiffusionReactionElement | |
| CConvectionDiffusionReactionElementData | Base class to hold Convection-Diffusion-Reaction transport equation data |
| CConvectionDiffusionReactionResidualBasedFluxCorrectedElement | |
| CIncompressiblePotentialFlowVelocityElement | |
| CLaplaceElement | |
| CRansApplyExactNodalPeriodicConditionProcess | A process to create periodic conditions between two boundaries |
| CRansApplyFlagToSkinProcess | Apply a specific flag for nodes and conditions |
| CRansClipScalarVariableProcess | Clips given scalar variable to a range |
| CRansComputeReactionsProcess | Computes the reaction forces for slip modelpart, can be further used for drag calculation |
| CRansEpsilonTurbulentMixingLengthInletProcess | Sets epsilon value best on turbulent mixing length |
| CRansFormulationProcess | This class is extending standard Process interface |
| CRansKTurbulentIntensityInletProcess | Set turbulent kinetic energy value based on the given turbulent intensity |
| CRansLineOutputProcess | Line output process |
| CRansNutKEpsilonUpdateProcess | Calculates turbulent kinematic viscosity |
| CRansNutKOmegaSSTUpdateProcess | Calculates turbulent kinematic viscosity |
| CRansNutKOmegaUpdateProcess | Calculates turbulent kinematic viscosity |
| CRansNutNodalUpdateProcess | Updates nodal VISCOSITY |
| CRansNutYPlusWallFunctionUpdateProcess | |
| CRansOmegaTurbulentMixingLengthInletProcess | Sets omega value best on turbulent mixing length |
| CRansWallDistanceCalculationProcess | |
| CRansWallFunctionUpdateProcess | |
| CAlgebraicFluxCorrectedSteadyScalarScheme | Algebraic flux corrected scalar steady transport scheme |
| CBossakRelaxationScalarScheme | A scheme for steady and dynamic equations, using Bossak time integration |
| CRelaxedDofUpdater | Utility class to update the values of degree of freedom (Dof) variables after solving the system |
| CSteadyScalarScheme | |
| CRansVariableDifferenceNormsCalculationUtility | This class is used to calculate difference norms of a given variable |
| CKratosRANSApplication | Short class definition |
| CHRomVisualizationMeshModeler | Modeler for setting up HROM visualization meshes This modeler is intended to be used for setting up HROM visualization meshes From a parent HROM model part (the model part on which the HROM problem is solved) this modeler fills up the required data in the provided visualization model part. The process info, variable list and buffer size are taken from the provided HROM model part while the ROM_BASIS and DOFs are retrieved from the RomParameters.json |
| CGlobalPetrovGalerkinROMBuilderAndSolver | This class provides an implementation for the GlobalPetrovGalerkinROM builder and solver operations. This Builder and Solver (B&S) now inherits from the GlobalROMBuilderAndSolver, which in turn inherits from the ResidualBasedBlockBuilderAndSolver. The Right-Hand Side (RHS) is composed of unbalanced loads (residual) and is constructed using the ResidualBasedBlockBuilderAndSolver. Similarly, the Left-Hand Side (LHS) is constructed using the ResidualBasedBlockBuilderAndSolver and is then multiplied by the ROM RIGHT BASIS. We then project it onto the ROM LEFT BASIS, yielding a rectangular system (ROM size) that is then solved using the QR decomposition. The degrees of freedom are rearranged so that the restrained ones are placed at the end of the system, ordered inversely to the DofSet, mirroring the arrangement in the Full Order Model (FOM) |
| CGlobalROMBuilderAndSolver | |
| CLeastSquaresPetrovGalerkinROMBuilderAndSolver | This class provides an implementation for the LeastSquaresPetrovGalerkinROM builder and solver operations. This B&S now inherits from the GlobalROMBuilderAndSolver, which in turn inherits from the ResidualBasedBlockBuilderAndSolver. The RHS is composed of unbalanced loads (residual) and is constructed using the ResidualBasedBlockBuilderAndSolver. Similarly, the LHS is constructed using the ResidualBasedBlockBuilderAndSolver and is then multiplied by the ROM RIGHT BASIS. This results in a rectangular system with dimensions of FOM size by ROM size. This system can be solved using either the normal equations or the QR decomposition. The degrees of freedom are rearranged so that the restrained ones are placed at the end of the system, ordered inversely to the DofSet, mirroring the arrangement in the FOM |
| ►CPetrovGalerkinROMBuilderAndSolver | Current class provides an implementation for PetrovGalerkinROM builder and solving operations |
| CAssemblyTLS | |
| CNonTrivialSumReduction | |
| ►CROMBuilderAndSolver | |
| CAssemblyTLS | |
| CNonTrivialSumReduction | |
| CRomAuxiliaryUtilities | |
| CRomResidualsUtility | |
| CKratosRomApplication | Short class definition |
| CBoussinesqCondition | Implementation of a condition for shallow water waves problems |
| CConservativeCondition | Implementation of a condition for shallow water waves problems |
| CPrimitiveCondition | Implementation of a condition for shallow water waves problems |
| ►CWaveCondition | Implementation of a condition for shallow water waves problems |
| CConditionData | |
| CBoussinesqElement | Implementation of a linear element for shallow water problems |
| CConservativeElement | Implementation of a linear element for shallow water problems |
| CConservativeElementFC | Implementation of a linear element for shallow water problems |
| CConservativeElementRV | Implementation of a linear element for shallow water problems |
| CCrankNicolsonWaveElement | Implementation of a linear element for shallow water problems |
| CPrimitiveElement | Implementation of a linear element for shallow water problems |
| ►CWaveElement | Implementation of a linear element for shallow water problems |
| CElementData | |
| CChezyLaw | The base class for the bottom and surface friction laws |
| CFrictionLawsFactory | The base class for the bottom and surface friction laws |
| CManningLaw | The base class for the bottom and surface friction laws |
| CNodalManningLaw | This class computes the bottom friction according to the Manning law |
| CWindWaterFriction | The base class for the bottom and surface friction laws |
| CMeshMovingModeler | Tools for lagrangian computations |
| CApplyPerturbationFunctionProcess | This process assigns a default value or a perturbation if the node is close to an influence area |
| CApplySinusoidalFunctionProcess | The aim of this process is to generate sinusoidal waves |
| CCalculateDistanceToBoundaryProcess | Calculate the minimum distance from all the nodes to a boundary condition in 2D |
| CDepthIntegrationProcess | Calculate the minimum distance from all the nodes to a boundary condition in 2D |
| ►CWriteFromSwAtInterfaceProcess | Calculate the minimum distance from all the nodes to a boundary condition in 2D |
| Clocator_tls | |
| CFluxCorrectedShallowWaterScheme | BDF integration scheme (for dynamic problems) with flux correction for extra diffusion to ensure monotonic solutions |
| CResidualBasedAdamsMoultonScheme | Predictor-corrector semi imlicit scheme for the Boussinesq element |
| CShallowWaterResidualBasedBDFScheme | BDF integration scheme (for dynamic problems) |
| CDerivativesRecoveryUtility | Superconvergent patch recovery for linear meshes using quadratic polynomials |
| CEstimateTimeStepUtility | Utility to estimate the time step in terms of the courant number |
| CFlowRateSlipUtility | Tools to apply slip conditions @detail A utility to rotate the local contributions of certain nodes to the system matrix, which is required to apply slip conditions in arbitrary directions |
| ►CFluxLimiter | This is a helper class to separate the physics from the flux corrected scheme |
| CAllowableIncrements | |
| ►CInterpolateSwToPfemUtility | |
| CUtilityVariables | Basic Structs for the utility ------------------------------------------------------------------------------------------------------------------------------------------— |
| CMoveShallowMeshUtility | Tools for lagrangian computations |
| CPhaseFunction | This class is a wrapper of useful utilities for shallow water computations |
| CShallowWaterUtilities | This class is a wrapper of useful utilities for shallow water computations |
| CKratosShallowWaterApplication | Short class definition |
| CDampingUtilities | Short class definition |
| CDirectionDampingUtilities | Class for direction damping of the shape update |
| CGeometryUtilities | Short class definition |
| CUniversalFileIO | Short class definition |
| CMapperVertexMorphing | Short class definition |
| CMapperVertexMorphingAdaptiveRadius | Short class definition |
| CMapperVertexMorphingImprovedIntegration | Short class definition |
| CMapperVertexMorphingMatrixFree | Short class definition |
| CMapperVertexMorphingSymmetric | Short class definition |
| CSymmetryBase | |
| CSymmetryPlane | |
| CSymmetryRevolution | |
| CMeshControllerUtilities | Short class definition |
| COptimizationUtilities | Short class definition |
| CFaceAngleResponseFunctionUtility | Short class definition |
| CSearchBasedFunctions | Short class definition |
| CKratosShapeOptimizationApplication | Short class definition |
| ►CBoundaryCondition | General Boundary Condition base type for 3D and 2D geometries |
| CConditionVariables | |
| CLocalSystemComponents | |
| CAxisymmetricLineElasticCondition | Elastic Condition for 2D axisymmetric geometries. (base class) |
| CAxisymmetricPointElasticCondition | Axisymmetric point elastic condition for 2D geometries |
| CElasticCondition | Elastic Condition for 3D and 2D geometries. (base class) |
| CLineElasticCondition | Line load condition for 3D and 2D geometries |
| CPointElasticCondition | Point Load Condition for 3D and 2D geometries. (base class) |
| CSurfaceElasticCondition | |
| CAxisymmetricLineLoadCondition | Load Condition for 2D axisymmetric geometries. (base class) |
| CAxisymmetricPointLoadCondition | Axisymmetric point load condition for 2D geometries |
| CLineLoadCondition | Line load condition for 3D and 2D geometries |
| CPointLoadCondition | Point Load Condition for 3D and 2D geometries. (base class) |
| CSurfaceLoadCondition | |
| CLineMomentCondition | Line load condition for 3D and 2D geometries |
| CMomentCondition | Load Condition for 3D and 2D geometries. (base class) |
| CPointMomentCondition | Point Load Condition for 3D and 2D geometries. (base class) |
| CSurfaceMomentCondition | |
| CLineHeatFluxCondition | Short class definition |
| CLinearAssociativePlasticFlowRule | Short class definition |
| CNonLinearAssociativePlasticFlowRule | Short class definition |
| CNonLinearRateDependentPlasticFlowRule | Short class definition |
| CBakerJohnsonCookThermalHardeningLaw | Short class definition |
| CJohnsonCookThermalHardeningLaw | Short class definition |
| CLinearIsotropicKinematicHardeningLaw | Short class definition |
| CNonLinearIsotropicKinematicHardeningLaw | Short class definition |
| CNonLinearIsotropicKinematicThermalHardeningLaw | Short class definition |
| CMisesHuberThermalYieldCriterion | Short class definition |
| CMisesHuberYieldCriterion | Short class definition |
| CHyperElasticPlasticAxisym2DLaw | |
| CHyperElasticPlasticJ23DLaw | |
| CHyperElasticPlasticJ2Axisym2DLaw | |
| CHyperElasticPlasticJ2PlaneStrain2DLaw | |
| CHyperElasticPlasticPlaneStrain2DLaw | |
| CHyperElasticPlasticThermalBakerJohnsonCookPlaneStrain2DLaw | |
| CHyperElasticPlasticThermalJ2PlaneStrain2DLaw | |
| CHyperElasticPlasticThermalJohnsonCookPlaneStrain2DLaw | |
| CHyperElasticPlasticThermalUPBakerJohnsonCookPlaneStrain2DLaw | |
| CHyperElasticPlasticThermalUPJ23DLaw | |
| CHyperElasticPlasticThermalUPJ2Axisym2DLaw | |
| CHyperElasticPlasticThermalUPJ2PlaneStrain2DLaw | |
| CHyperElasticPlasticThermalUPJohnsonCookAxisym2DLaw | |
| CHyperElasticPlasticThermalUPJohnsonCookPlaneStrain2DLaw | |
| CHyperElasticPlasticUP3DLaw | |
| CHyperElasticPlasticUPAxisym2DLaw | |
| CHyperElasticPlasticUPJ23DLaw | |
| CHyperElasticPlasticUPJ2Axisym2DLaw | |
| CHyperElasticPlasticUPJ2PlaneStrain2DLaw | |
| CHyperElasticPlasticUPPlaneStrain2DLaw | |
| CHyperElasticUPAxisym2DLaw | |
| CHyperElasticUPPlaneStrain2DLaw | |
| CIsotropicDamageModifiedMises3DLaw | |
| CIsotropicDamageModifiedMisesPlaneStrain2DLaw | |
| CIsotropicDamageModifiedMisesPlaneStress2DLaw | |
| CIsotropicDamageSimoJu3DLaw | |
| CIsotropicDamageSimoJuPlaneStrain2DLaw | |
| CIsotropicDamageSimoJuPlaneStress2DLaw | |
| CLinearElasticOrthotropic3DLaw | |
| CLinearElasticPlasticPlaneStrain2DLaw | |
| CLinearElasticPlasticPlaneStress2DLaw | |
| ►CBeamElement | Beam Element for 2D and 3D space dimensions |
| CDirectorsVariables | |
| CElementData | |
| CLocalSystemComponents | |
| CSectionProperties | |
| CGeometricallyExactRodElement | Beam Element for 3D space dimension Romero Displacement-Rotation Geometrically Exact Rod element (based on cross section director vectors) |
| CLargeDisplacementBeamElement | Beam Element for 3D space dimension Simo Displacement-Rotation Geometrically Exact Rod element |
| CLargeDisplacementBeamEMCElement | Beam Element for 3D space dimension |
| CLargeDisplacementBeamSEMCElement | Beam Element for 3D space dimension |
| CSmallDisplacementBeamElement | Small displacements beam element for 2D and 3D space |
| ►CSmallDisplacementBeamElement3D2N | Beam Element for 3D space dimension |
| CLocalSystemComponents | |
| CSectionProperties | |
| ►CShellThickElement3D4N | ShellThickElement3D4N |
| CEASOperator | EASOperator |
| CEASOperatorStorage | EASOperatorStorage |
| CJacobianOperator | JacobianOperator |
| CMITC4Params | MITC4Params |
| CShellThinElement3D3N | ShellThinElement3D3N |
| CAxisymmetricSmallDisplacementElement | Axisymmetric Small Displacements Element for 2D geometries |
| CAxisymmetricUpdatedLagrangianElement | Axisymmetric Updated Lagrangian Element 2D geometries |
| CAxisymmetricUpdatedLagrangianUPElement | Axisymmetric Updated Lagrangian U-P Element for 2D geometries. For Linear Triangles |
| CLargeDisplacementElement | Large Displacement Lagrangian Element for 3D and 2D geometries. (base class) |
| CLargeDisplacementSegregatedVPElement | Large Displacement Lagrangian V Element for 3D and 2D geometries |
| CLargeDisplacementUPElement | Large Displacement Lagrangian U-P Element for 3D and 2D geometries. Linear Triangles and Tetrahedra (base class) |
| CLargeDisplacementVElement | Large Displacement Lagrangian V Element for 3D and 2D geometries |
| CLinearSolidElement | Linear Solid Element for 3D and 2D geometries. (Template for learning element design) |
| CSmallDisplacementBbarElement | Small Displacement Bbar Element for 3D and 2D geometries |
| CTotalLagrangianElement | Total Lagrangian Element for 3D and 2D geometries |
| CUpdatedLagrangianSegregatedVPElement | Updated Lagrangian Segregated Solid Element for 3D and 2D geometries |
| CUpdatedLagrangianUPElement | Spatial Lagrangian U-P Element for 3D and 2D geometries. Linear Triangles and Tetrahedra |
| CUpdatedLagrangianVElement | Updated Lagrangian Element for 3D and 2D geometries |
| CAxisymmetricThermalElement | |
| ►CThermalElement | |
| CGeneralVariables | |
| CAddDofsProcess | The base class for fixing scalar variable Dof or array_1d component Dof processes in Kratos |
| CAssignFlagsToModelPartEntitiesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignRotationAboutAnAxisToNodesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignRotationFieldAboutAnAxisToNodesProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignTorqueAboutAnAxisToConditionsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CAssignTorqueFieldAboutAnAxisToConditionsProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CBuildStringSkinProcess | |
| CManageTimeStepProcess | The base class for assigning a value to scalar variables or array_1d components processes in Kratos |
| CSolverProcess | The base class for processes passed to the solution scheme |
| ►CTimeDiscretizationProcessTimeDiscretizationProcess | Short class definition |
| CTimeParameters | |
| CTransferSolvingModelPartEntitiesProcess | Process to transfer model part entities to a solving submodelpart |
| CCompositeCriterion | This convergence criteria checks simultaneously different convergence criteria |
| CConvergenceCriterion | Convergence Criterion base class |
| CDofsCriterion | This convergence criteria checks the variable dofs |
| CResidualCriterion | This convergence criteria checks the residual |
| ►CBlockBuilderAndSolver | Solution Buider and Solver based on block matrix |
| Cdof_iterator_equal | |
| Cdof_iterator_hash | |
| CExplicitBuilderAndSolver | Explicit Solution Buider and Solver base class |
| CExplicitHamiltonBuilderAndSolver | |
| ►CReductionBuilderAndSolver | |
| Cdof_iterator_equal | |
| Cdof_iterator_hash | |
| CSolutionBuilderAndSolver | Solution Buider and Solver base class |
| CSolverLocalFlags | Solver local flags class definition |
| CCriterionLocalFlags | Solver local flags class definition |
| CTimeIntegrationLocalFlags | Solver local flags class definition |
| ►CDynamicScheme | Dynamic integration scheme |
| CGeneralMatrices | |
| CGeneralVectors | |
| CEigensolverScheme | An adapter scheme for obtaining mass and stiffness matrices for dynamic eigenvalue problems |
| ►CExplicitCentralDifferencesScheme | An explicit central difference scheme |
| CDeltaTimeParameters | This struct contains the information related with the increment od time step |
| CTimeVariables | This struct contains the details of the time variables |
| ►CExplicitHamiltonScheme | |
| CDeltaTimeParameters | |
| CGeneralMatrices | |
| CGeneralVectors | |
| CTimeVariables | |
| CSolutionScheme | Solution scheme base class |
| CStaticScheme | Static integration scheme (for static problems) |
| CEigensolverStrategy | Strategy for solving generalized eigenvalue problems |
| CExplicitHamiltonStrategy | |
| CExplicitSolutionStrategy | |
| CLineSearchSolutionStrategy | |
| CLinearStrategy | This is the base linear strategy jacobi / gauss-seidel linear strategies |
| CNewtonRaphsonStrategy | This is the base Newton Raphson strategy |
| CSegregatedStrategy | This is the base class for a segregated strategy for the same model part |
| CSolutionStrategy | Solution strategy base class |
| CBackwardEulerMethod | Short class definition |
| CBdfMethod | Short class definition |
| CBossakMethod | Short class definition |
| CBossakStepMethod | Short class definition |
| CBossakStepRotationMethod | Short class definition |
| ►CEmcStepMethod | Short class definition |
| CEmcParameters | |
| CEmcStepRotationMethod | Short class definition |
| ►CNewmarkMethod | Short class definition |
| CNewmarkParameters | |
| CNewmarkStepMethod | Short class definition |
| CNewmarkStepRotationMethod | Short class definition |
| CSimoMethod | Short class definition |
| CSimoStepMethod | Short class definition |
| CSimoStepRotationMethod | Short class definition |
| CStaticMethod | Short class definition |
| CStaticStepMethod | Short class definition |
| CStaticStepRotationMethod | Short class definition |
| CTimeIntegrationMethod | Short class definition |
| CTimeIntegrationMethodsContainer | |
| CEICR | EICR Element Independent CoRotational formulation |
| CEigenvectorToSolutionStepVariableTransferUtility | Transfer eigenvectors to solution step variables for GiD output or solution initialization |
| CEnergyUtilities | Short class definition |
| ►CShellCrossSection | ShellCrossSection |
| CElementVariables | |
| CFeatures | |
| CGeneralVariables | |
| CIntegrationPoint | |
| CParameters | |
| CPly | |
| CSectionParameters | SectionParameters |
| CShellQ4_CoordinateTransformation | ShellQ4_CoordinateTransformation |
| CShellQ4_CorotationalCoordinateTransformation | EICR ShellQ4_CorotationalCoordinateTransformation |
| CShellQ4_LocalCoordinateSystem | ShellQ4_LocalCoordinateSystem |
| CShellT3_CoordinateTransformation | ShellT3_CoordinateTransformation |
| CShellT3_CorotationalCoordinateTransformation | EICR ShellT3_CorotationalCoordinateTransformation |
| CShellT3_LocalCoordinateSystem | ShellT3_LocalCoordinateSystem |
| CKratosSolidMechanicsApplication | Short class definition |
| CKratosStatisticsApplication | Short class definition |
| CAxisymLineLoadCondition2D | Axisymmetric line load condition |
| CAxisymPointLoadCondition | Axisymmetric point load condition |
| CBaseLoadCondition | This is the base class of all the load conditions on StructuralMechanicsApplication |
| CDisplacementControlCondition | This class is to add contributions to LHS and RHS of the displacement control condition |
| CMovingLoadCondition | This class is the responsible to add the contributions of the RHS and LHS of the moving loads of the structure |
| CPointContactCondition | Short class definition |
| CPointMomentCondition3D | |
| CSmallDisplacementLineLoadCondition | This class is the responsible to add the contributions of the RHS and LHS of the line loads of the structure |
| CSmallDisplacementSurfaceLoadCondition3D | This class is the responsible to add the contributions of the RHS and LHS of the surface loads of the structure |
| CSurfaceLoadCondition3D | This class is the responsible to add the contributions of the RHS and LHS of the surface loads of the structure |
| CAxisymElasticIsotropic | |
| CBeamConstitutiveLaw | |
| CElasticIsotropic3D | |
| CLinearPlaneStrain | This class defines a small deformation linear elastic constitutive model for 3D cases |
| CLinearPlaneStress | This class defines a small deformation linear elastic constitutive model for plane stress cases |
| CTrussConstitutiveLaw | |
| CUserProvidedLinearElasticLaw | This class defines a linear elastic law with user provided constitutive tensor |
| CAxisymSmallDisplacement | Axisymmetric Kinematic Linear element |
| CAxisymTotalLagrangian | Axisymmetric Total Lagrangian element |
| CAxisymUpdatedLagrangian | Axisymmetric Updated Lagrangian element |
| CBaseShellElement | |
| CCableElement3D2N | This is a 3D-2node cable element with 3 translational dofs per node inheriting from the TrussElement3D2N |
| CCrBeamElement2D2N | This is a 2D-2node beam element with 2 translational dofs and 1 rotational dof per node |
| CCrBeamElement3D2N | This is a 3D-2node beam element with 3 translational dofs and 3 rotational dof per node |
| CCrBeamElementLinear2D2N | This is a linear 2D-2node beam element with 2 translational dofs and 1 rotational dof per node inheriting from CrBeamElement2D2N |
| CCrBeamElementLinear3D2N | This is a linear 3D-2node beam element with 3 translational dofs and 3 rotational dof per node inheriting from CrBeamElement3D2N |
| CIsotropicShellElement | Short class definition |
| CMassElement | |
| CMembraneElement | |
| CNodalConcentratedElement | Concentrated nodal for 3D and 2D points |
| CShellThickElement3D3N | ShellThickElement3D3N |
| CShellThinElement3D4N | ShellThinElement3D4N |
| CSmallDisplacement | Small displacement element for 2D and 3D geometries |
| ►CSmallDisplacementBbar | Infinitesimal strain definition with mixed B-bar formulation |
| CKinematicVariablesBbar | |
| ►CSmallDisplacementMixedVolumetricStrainElement | Small displacement with strain based mixed formulation element |
| CConstitutiveVariables | |
| CKinematicVariables | |
| ►CSolidShellElementSprism3D6N | This is a triangular prism solid element for the analysis of thin/thick shells undergoing large elastic–plastic strains |
| CCartesianDerivatives | Here the cartesian derivatives are defined |
| CCommonComponents | Common Components defined in order to compute the Cauchy tensor and the deformation matrix |
| CEASComponents | EAS Components |
| CGeneralVariables | |
| CLocalSystemComponents | |
| COrthogonalBase | OrthogonalBase |
| CStressIntegratedComponents | Stress integrated Components used during the integration |
| CTransverseGradient | TransverseGradient |
| CTransverseGradientIsoParametric | TransverseGradientIsoParametric |
| CSpringDamperElement | Concentrated nodal for 3D and 2D points |
| CTotalLagrangian | Total Lagrangian element for 2D and 3D geometries |
| ►CTotalLagrangianMixedVolumetricStrainElement | Total Lagrangian mixed displacement volumetric strain formulation element |
| CConstitutiveVariables | |
| CKinematicVariables | |
| CTotalLagrangianQ1P0MixedElement | Total Lagrangian mixed u-p element (Q1P0) for 2D and 3D geometries |
| CTrussElement3D2N | This is a 3D-2node truss element with 3 translational dofs per node |
| CTrussElementLinear3D2N | This is a linear 3D-2node truss element with 3 translational dofs per node inheriting from TrussElement3D2N |
| CUpdatedLagrangian | Updated Lagrangian element for 2D and 3D geometries |
| CZStrainDriven2p5DSmallDisplacement | Small displacement element for 2.5D cases |
| CGidEigenIO | GidIO extended for writting Eigenvalue Results |
| CVtkEigenOutput | VtkEigenOutput A simple class to write Eigenresults in Vtk format |
| CComputeCenterOfGravityProcess | This method computes the center of gravity |
| CComputeMassMomentOfInertiaProcess | This method computes the moment of inertia (rotational) |
| CDistributeLoadOnSurfaceProcess | This process distributes a load on surface load conditions belonging to a modelpart |
| CImposeRigidMovementProcess | This method assign linear kinematic constrains to a certain submodelpart |
| CImposeZStrainProcess | This class assigns the same Z-Strain value to the member variables of all 2.5D solid elements |
| CPostprocessEigenvaluesProcess | Process to create the animated Eigenvectors |
| CPrismNeighboursProcess | An algorithm that looks for neighbour nodes and elements in a mesh of prismatic elements |
| CSetAutomatedInitialVariableProcess | This class automotes the creation of the variables INITIAL_STRAIN_VECTOR and INITIAL_STRESS_VECTOR using tables imported from csv files |
| CSetCartesianLocalAxesProcess | This class set the local axes of the elements according to a given set of cartesian axes |
| CSetCylindricalLocalAxesProcess | This class set the local axes of the elements according to a cylindrical coordinates |
| CSetMovingLoadProcess | Process to set the moving load |
| CSetSphericalLocalAxesProcess | This class set the local axes of the elements according to a SPHERICAL coordinates |
| CShellToSolidShellProcess | This method transforms triangular and quadrilateral elements into prisms and hexahedra elements |
| CSolidShellThickComputeProcess | This method computes the current thickness in a node of a solid-shell |
| CSPRErrorProcess | This class is can be used to compute the metrics of the model part with a superconvergent patch recovery (SPR) approach |
| CTotalStructuralMassProcess | This method computes the total mass of a structure |
| CAdjointSemiAnalyticBaseCondition | AdjointSemiAnalyticBaseCondition |
| CAdjointSemiAnalyticPointLoadCondition | |
| CAdjointFiniteDifferencingBaseElement | AdjointFiniteDifferencingBaseElement |
| CAdjointFiniteDifferenceCrBeamElement | |
| CAdjointFiniteDifferencingShellElement | AdjointFiniteDifferencingShellElement |
| CAdjointFiniteDifferencingSmallDisplacementElement | AdjointFiniteDifferencingSmallDisplacementElement |
| CAdjointFiniteDifferenceSpringDamperElement | AdjointFiniteDifferenceSpringDamperElement |
| CAdjointFiniteDifferenceTrussElement | AdjointFiniteDifferencingBaseElement |
| CAdjointFiniteDifferenceTrussElementLinear | AdjointFiniteDifferencingBaseElement |
| CAdjointSolidElement | A template class for creating adjoint elements for solids |
| CReplaceMultipleElementsAndConditionsProcess | This methods replaces elements and conditions in a model part by a given table |
| CAdjointLinearStrainEnergyResponseFunction | AdjointLinearStrainEnergyResponseFunction |
| CAdjointLocalStressResponseFunction | AdjointLocalStressResponseFunction |
| CAdjointMaxStressResponseFunction | AdjointMaxStressResponseFunction |
| CAdjointNodalDisplacementResponseFunction | AdjointNodalDisplacementResponseFunction |
| CAdjointNodalReactionResponseFunction | AdjointNodalReactionResponseFunction |
| CAdjointStructuralResponseFunction | AdjointStructuralResponseFunction |
| CEigenfrequencyResponseFunctionUtility | Short class definition |
| CFiniteDifferenceUtility | FiniteDifferenceUtility |
| CMassResponseFunctionUtility | Short class definition |
| CStrainEnergyResponseFunctionUtility | Short class definition |
| CStressCalculation | StressCalculation |
| CErrorMeshCriteria | Custom convergence for used to check the convergence in the mesh error |
| CResidualDisplacementAndOtherDoFCriteria | This is a convergence criteria that employes the residual as criteria, it divides the problem in two dofs, displacement and another one |
| CEigensolverDynamicScheme | An adapter scheme for obtaining mass and stiffness matrices for dynamic eigenvalue problems |
| ►CExplicitMultiStageKimScheme | An explicit multi stage scheme |
| CDeltaTimeParameters | This struct contains the information related with the increment od time step |
| CTimeVariables | This struct contains the details of the time variables |
| CResidualBasedRelaxationScheme | |
| CFormfindingStrategy | |
| CHarmonicAnalysisStrategy | Strategy for solving generalized eigenvalue problems |
| CMechanicalExplicitStrategy | This strategy is used for the explicit time integration |
| CPrebucklingStrategy | Strategy for linearized prebuckling analysis |
| CNodeConfigureForNodeSearch | Configuration file for nodes |
| CNodeSearchUtility | Node Search |
| CPerturbGeometryBaseUtility | Base class for geometry perturbation utilities |
| CPerturbGeometrySparseUtility | This class generates a random field based on a sparse correlation matrix |
| CPerturbGeometrySubgridUtility | This class generates a random field based on a reduced correlation matrix |
| CProjectVectorOnSurfaceUtility | Short class definition |
| CStructuralMechanicsMathUtilities | |
| CKratosStructuralMechanicsApplication | This application features Elements, Conditions, Constitutive laws and Utilities for structural analysis problems |
| CComputeLaplacianSimplexCondition | Implements a wall condition for the laplacian recovery |
| CMonolithicDEMCoupledWallCondition | Implements a wall condition for the monolithic formulation |
| CArchimedesBuoyancyLaw | |
| CBuoyancyLaw | |
| CBeetstraDragLaw | |
| CChienDragLaw | |
| CDallavalleDragLaw | |
| CDragLaw | |
| CGanserDragLaw | |
| CHaiderAndLevenspielDragLaw | |
| CNewtonDragLaw | |
| CSchillerAndNaumannDragLaw | |
| CShahDragLaw | |
| CStokesDragLaw | |
| CBoussinesqBassetHistoryForceLaw | |
| CHistoryForceLaw | |
| CHydrodynamicInteractionLaw | |
| CAutonHuntPrudhommeInviscidForceLaw | |
| CInviscidForceLaw | |
| CZuberInviscidForceLaw | |
| CPowerLawFluidHydrodynamicInteractionLaw | |
| CLothRotationInducedLiftLaw | |
| COesterleAndDinhLiftLaw | |
| CRotationInducedLiftLaw | |
| CRubinowAndKellerLiftLaw | |
| CLothSteadyViscousTorqueLaw | |
| CRubinowAndKellerTorqueLaw | |
| CSteadyViscousTorqueLaw | |
| CElSamniLiftLaw | |
| CMeiLiftLaw | |
| CSaffmanLiftLaw | |
| CVorticityInducedLiftLaw | |
| CComputeComponentGradientSimplex | A post-processing element to recover the Laplacian from the velocity solution |
| CComputeGradientPouliot2012 | A post-processing element to recover the Laplacian from the velocity solution |
| CComputeGradientPouliot2012Edge | A post-processing element to recover the Laplacian from the velocity solution |
| CComputeLaplacianSimplex | A post-processing element to recover the Laplacian from the velocity solution |
| CComputeMaterialDerivativeSimplex | A post-processing element to recover the Laplacian from the velocity solution |
| CComputeVelocityLaplacianSimplex | A post-processing element to recover the Laplacian from the velocity solution |
| CComputeVelocityLaplacianComponentSimplex | A post-processing element to recover the Laplacian from the velocity solution |
| CMonolithicDEMCoupled | A stabilized element for the incompressible Navier-Stokes equations |
| CMonolithicDEMCoupledWeak | A stabilized element for the incompressible Navier-Stokes equations |
| CShellRigid | Short class definition |
| CSwimmingParticle | |
| CApplyRigidRotationProcess | Process used to rotate eulerian model parts using Rodrigues' rotation formula |
| CBumpTransientPorositySolutionBodyForceProcess | |
| CHyperbolicTangentialPorositySolutionAndBodyForceProcess | |
| CHyperbolicTangentialPorositySolutionTransientBodyForceProcess | |
| CPorositySolutionAndBodyForceProcess | |
| CPorositySolutionAndSinusoidalBodyForceProcess | |
| CPorositySolutionTransientBodyForceProcess | |
| CSinusoidalPorositySolutionAndBodyForceProcess | |
| CSinusoidalPorositySolutionTransientBodyForceProcess | |
| CHybridBashforthScheme | |
| CSymplecticEulerOldVelocityScheme | |
| CTerminalVelocityScheme | |
| CAdamsBashforthStrategy | |
| CBDF2TurbulentSchemeDEMCoupled | A scheme for BDF2 time integration |
| CRelaxedResidualBasedNewtonRaphsonStrategy | This is the base Newton Raphson strategy |
| CResidualBasedDerivativeRecoveryStrategy | Short class definition |
| CResidualBasedPredictorCorrectorVelocityBossakSchemeTurbulentDEMCoupled | |
| CBassetForceTools | |
| CBinBasedDEMFluidCoupledMapping | |
| CCustomFunctionsCalculator | |
| CDerivativeRecovery | This class constructs nodal approximations of the derivatives of a field given a Lagrangian linear FEM approximation of it |
| CDerivativeRecoveryMeshingTools | This class performs simple meshing tools related to the derivative recovery algorithms |
| CEmbeddedVolumeTool | |
| CCellularFlowField | |
| CCellularFlowPartialDerivatives | |
| CCodinaManufacturedField | |
| CConstantVelocityField | |
| CEthierFlowField | |
| CFieldUtility | |
| CFluidFieldUtility | |
| CPouliotFlowField | |
| CPouliotFlowField2D | |
| CProductOfSines | |
| CRealField | |
| CLinearRealField | |
| CRealFunction | |
| CLinearFunction | |
| CPowerFunction | |
| CAdditionFunction | |
| CProductFunction | |
| CCompositionFunction | |
| CSpaceTimeRule | |
| CBoundingBoxRule | |
| CMoreThanRule | |
| CEqualToRule | |
| CSpaceTimeSet | |
| CShearFlow1DWithExponentialViscosityField | |
| CTimeDependant1DPorosityField | |
| CTimeDependantForceField | |
| CTimeDependantPorosityField | |
| CVectorField | |
| CVelocityField | |
| CBentonite_Force_Based_Inlet | |
| CL2ErrorNormCalculator | |
| CMeshRotationUtility | |
| CDensityFunction | |
| CDensityFunctionNormal | |
| CDensityFunctionPolynomial | |
| CMollifier | |
| CPorosityUtils | |
| CMpiDiscreteParticleConfigure | |
| CMpi_Neighbours_Calculator | |
| CPointConfigure | |
| CPointPointSearch | Short class definition |
| CFlowStationarityCheck | This defines a class to assess whether stationarity has been reached in the fluid |
| CSamplingTool | |
| CSwimmingDemInPfemUtils | |
| CVolumeAveragingTool | This class is designed to manage the volume averaging of DEM properties and their projection onto a mesh |
| CKratosSwimmingDEMApplication | |
| CDirectConductionBOBComplete | |
| CDirectConductionBOBModified | |
| CDirectConductionBOBSimple | |
| CDirectConductionCollision | |
| CDirectConductionModel | |
| CDirectConductionPipe | |
| CIndirectConductionModel | |
| CIndirectConductionSurroundLayer | |
| CIndirectConductionVargas | |
| CIndirectConductionVoronoiA | |
| CIndirectConductionVoronoiB | |
| CConvectionModel | |
| CNusseltGunn | |
| CNusseltHanzMarshall | |
| CNusseltLiMason | |
| CNusseltWhitaker | |
| CGenerationDissipation | |
| CGenerationModel | |
| CHeatExchangeMechanism | |
| CHeatGenerationMechanism | |
| CRadiationContinuumKrause | |
| CRadiationContinuumZhou | |
| CRadiationModel | |
| CRealContactLu | |
| CRealContactModel | |
| CRealContactMorris | |
| CRealContactZhou | |
| CSinteringContinuum | |
| CSinteringSphericContinuumParticle | |
| CThermalSphericContinuumParticle | |
| ►CThermalSphericParticle | |
| CContactParams | |
| CThermalDEMIntegrationScheme | |
| CThermalForwardEulerScheme | |
| CThermalExplicitSolverStrategy | |
| CGraphUtilities | |
| CHeatMapUtilities | |
| CAdaptiveSimpsonQuadrature | |
| ►CNumericalIntegrationMethod | |
| CIntegrandParams | |
| CSetThermalDataUtilities | |
| CTesselationUtilities2D | |
| CTesselationUtilities3D | |
| CKratosThermalDEMApplication | |
| CDEMThermalFlags | |
| CSmallDisplacementSIMPElement | Topology Optimization Small Displacement Element for 3D geometries |
| CResidualBasedIncrementalUpdateStaticSIMPScheme | |
| CStructureAdjointSensitivityStrategy | |
| CIOUtilities | Solution utility to filter results |
| CStructureResponseFunctionUtilities | Solution utility to compute structural analysis responses |
| ►CTopologyFilteringUtilities | Solution utility to filter results |
| CElementPositionItem | |
| CTopologyUpdatingUtilities | Solution utility that updates response values for next iteration |
| CKratosTopologyOptimizationApplication | Short class definition |
| CTrilinosLinearSolverFactory | Here we add the functions needed for the registration of linear solvers |
| CTrilinosLevelSetConvectionProcess | Short class definition |
| CAuxiliaryMatrixWrapper | Auxiliarty Trilinos matrix pointer wrapper class |
| CAuxiliaryVectorWrapper | Auxiliarty Trilinos vector pointer wrapper class |
| CTrilinosBlockBuilderAndSolver | Current class provides an implementation for trilinos builder and solving operations |
| CTrilinosBlockBuilderAndSolverPeriodic | |
| CTrilinosResidualBasedEliminationBuilderAndSolver | |
| CTrilinosDisplacementCriteria | MPI version of the DisplacementCriteria |
| CTrilinosMixedGenericCriteria | Convergence criteria for mixed vector-scalar problems |
| CTrilinosResidualCriteria | MPI version of the ResidualCriteria |
| CTrilinosResidualBasedIncrementalAitkenStaticScheme | A scheme for the solution of a problem using Aitken iterations |
| CTrilinosAssemblingUtilities | The Trilinos assembling utilities |
| CTrilinosCuttingApplication | TRILINOS CUTTING APPLICATION |
| CTrilinosCuttingIsosurfaceApplication | |
| CTrilinosDofUpdater | Utility class to update the values of degree of freedom (Dof) variables after solving the system |
| CTrilinosJacobianEmulator | Jacobian emulator |
| CTrilinosMVQNRecursiveJacobianConvergenceAccelerator | MVQN (MultiVectorQuasiNewton method) acceleration scheme Recursive MultiVectorQuasiNewton convergence accelerator. This convergence accelerator is an alternative implementation of the standard MVQN that avoids the storage of the |
| CTrilinosPartitionedFSIUtilities | Trilinos version of the partitioned FSI tools |
| CTrilinosRefineMesh | |
| CAmesos2Solver | Wrapper for Trilinos-Amesos2 Direct Solvers |
| CAmesosSolver | Wrapper for Trilinos-Amesos Direct Solvers |
| CAmgclMPISchurComplementSolver | |
| CAmgclMPISolver | This is a multigrid solver based on the AMGCL library |
| CAztecSolver | Wrapper for Trilinos-Aztec Iterative Solvers |
| CMultiLevelSolver | Wrapper for Trilinos-ML preconditioner using the Aztec-Solver |
| CTrilinosMonotonicityPreservingSolver | |
| CKratosTrilinosApplication | Short class definition |
| CTrilinosSpace | The space adapted for Trilinos vectors and matrices |
| CPointNeumann2D | Short class definition |
| CPointNeumann3D | Short class definition |
| CPointNeumannAxisym | Short class definition |
| CFluid2DGLS_expl | Short class definition |
| CHypoElasticSolid2D | Short class definition |
| CSurfaceTension | A stabilized element for the incompressible Navier-Stokes equations, utilizing lagrangian_Eulerian approach for droplet dynamics |
| CUlfAxisym | Short class definition |
| CUlfFrac2D | Short class definition |
| CUlfFrac3D | Short class definition |
| CUpdatedLagrangianFluid | Short class definition |
| CUpdatedLagrangianFluid3D | Short class definition |
| CUpdatedLagrangianFluid3Dinc | Short class definition |
| CUpdatedLagrangianFluidInc | Short class definition |
| CAddWallProcess | Short class definition |
| CAssignSurfaceTensionConditions | Short class definition |
| CCalculateAdhesionForce | Short class definition |
| CCalculateContactAngle | Short class definition |
| CCalculateCurvature | Short class definition |
| CCalculateNodalLength | Short class definition |
| CCalculateNormalEq | Short class definition |
| CFindNodalNeighboursSurfaceProcess | Short class definition |
| CFindTriplePoint | Short class definition |
| CHypoelasticStressCalculateProcess | Short class definition |
| CLagrangianInletProcess | Short class definition |
| CMarkBadElementsProcess | Short class definition |
| CMarkCloseNodesProcess | Short class definition |
| CMarkFreeSurfaceProcess | Short class definition |
| CMassCalculateProcess | Short class definition |
| CMergeModelPartsProcess | Short class definition |
| CPressureCalculateProcess | Short class definition |
| CPressureCalculateProcessAxisym | Short class definition |
| CRemoveAndSaveWallNodesProcess | Short class definition |
| CSaveFluidOnlyProcess | Short class definition |
| CSaveStructureConditionsProcess | Short class definition |
| CSaveStructureModelPartProcess | Short class definition |
| CUlfTimeStepDecProcess | Short class definition |
| CResidualBasedEliminationQuasiIncompressibleBuilderAndSolver | |
| CResidualBasedPredictorCorrectorBossakScheme | |
| CLapModifiedLinearStrategy | Short class definition |
| CRungeKuttaFracStepStrategy | Short class definition |
| CAssignPointNeumannConditions | |
| CNistUtils | |
| CUlfUtils | |
| CKratosULFApplication | Short class definition |
| CFabricSmallStrainUmatModel | Short class definition |
| CHypoplasticSmallStrainUmatModel | Short class definition |
| CLargeStrainUmatModel | Short class definition |
| ►CSmallStrainUmatModel | Short class definition |
| CUmatModelData | |
| CVonMisesLargeStrainUmatModel | Short class definition |
| CVonMisesSmallStrainUmatModel | Short class definition |
| CKratosUmatApplication | Short class definition |
| CKratosWindEngineeringApplication | |
| ►Nkratos_analysis_execution_policy | |
| CKratosAnalysisExecutionPolicy | |
| ►Nkratos_collada | |
| CColladaImporter | |
| ►Nkratos_perturbation_process | An initial condition process for KratosMultiphysics license: license.txt |
| CParameters | |
| CImposePerturbedInitialConditionAnalysisStage | This analysis stage class solves the Poisson problem, required by the correlated initial condition to apply no penetrability into the bluff body |
| CImposePerturbedInitialConditionProcess | Process generating divergence-free correlated noise, imposing no-penetrability condition on bluff bodies, preserving boundary conditions on boundaries and (if required) adding the contribution of a manually-loaded velocity field |
| ►NKratosDEMAnalysis | |
| CDEMAnalysisStageWithFlush | |
| ►NKratosMonitor | |
| CKratosMonitor | |
| ►NKratosSwimmingDEMAnalysis | |
| CSwimmingDEMAnalysisWithFlush | |
| ►NKratosSwimmingDEMPFEM | |
| CSolution | |
| ►NKratosSwimmingDEMPFEMAnalysis | |
| CSDEMPFEMAnalysisWithFlush | |
| ►NKratosUnittest | |
| CTestLoader | |
| CTestCase | |
| CKratosTextTestResult | |
| CWorkFolderScope | Helper-class to execute test in a specific target path |
| ►NL2_error_calculator_utility | |
| CL2ErrorCalculatorUtility | |
| ►Nlagrangian_rotation_process | |
| CLagrangianRotationProcess | |
| ►Nlagrangian_shallow_water_solver | |
| CLagrangianShallowWaterSolver | |
| ►Nlevel_set_remeshing_process | |
| CLevelSetRemeshingProcess | All the processes python should be derived from "Process" |
| ►Nline_envelope_output_process | |
| CLineEnvelopeOutputProcess | This process writes the maximum results along a line to generate a graph |
| ►Nline_graph_output_process | |
| CLineGraphOutputProcess | This process writes results along a line to generate a graph |
| COutputControl | |
| CTimeOutputControl | |
| CStepOutputControl | |
| ►Nline_output_process | |
| CLineOutputProcess | This process writes output for several points along a line to a file Internally it holds an object of type "MultiplePointsOutputProcess" Usage: |
| ►Nlinear_elastic_constitutive_law | |
| CLinearElasticLaw | |
| ►Nlinear_strain_energy_response_function | |
| CLinearStrainEnergyResponseFunction | |
| ►Nlogger_utilities | |
| CFileLogger | A context responsible for managing the lifetime of logger files |
| CTimeLogger | A context responsible for outputting execution times |
| COptimizationAlgorithmTimeLogger | A context responsible for outputting execution times |
| COptimizationAnalysisTimeLogger | |
| ►Nloggers | |
| ►Ndata_logger_factory | |
| CDataLogger | |
| ►Ndesign_logger_base | |
| CDesignLogger | |
| ►Ndesign_logger_gid | |
| CDesignLoggerGID | |
| ►Ndesign_logger_unv | |
| CDesignLoggerUNV | |
| ►Ndesign_logger_vtk | |
| CDesignLoggerVTK | |
| ►Nsensitivity_heatmap_logger | |
| CSensitivityHeatmapLoggerBase | |
| CSensitivityHeatmapLoggerSteepestDescent | |
| CSensitivityHeatmapLoggerPenalizedProjection | |
| CSensitivityHeatmapLoggerGradientProjection | |
| CSensitivityHeatmapLoggerTrustRegion | |
| CSensitivityHeatmapLoggerBeadOptimization | |
| ►Nvalue_logger_base | |
| CValueLogger | |
| ►Nvalue_logger_bead_optimization | |
| CValueLoggerBeadOptimization | |
| ►Nvalue_logger_gradient_projection | |
| CValueLoggerGradientProjection | |
| ►Nvalue_logger_penalized_projection | |
| CValueLoggerPenalizedProjection | |
| ►Nvalue_logger_relaxed_gradient_projection | |
| CValueLoggerRelaxedGradientProjection | |
| ►Nvalue_logger_shape_fraction_optimization | |
| CValueLoggerShapeFractionOptimization | |
| ►Nvalue_logger_steepest_descent | |
| CValueLoggerSteepestDescent | |
| ►Nvalue_logger_trust_region | |
| CValueLoggerTrustRegion | |
| ►Nlsdyna_mesh_to_mdpa | |
| CLsDynaSet | |
| CLsDynaMeshConverter | Very simple function to parse a Gid mesh file and extract nodal coordinates and tetrahedra connectivity |
| ►Nmac_donald_shock_benchmark | |
| CMacDonaldShockBenchmark | Mac Donald's shock benchmark |
| ►Nmac_donald_transition_benchmark | |
| CMacDonaldTransitionBenchmark | Mac Donald's transcritical flow |
| ►NMainCoupling2WayFemDem | |
| CMainCoupled2WayFemDem_Solution | |
| ►NMainCouplingFemDem | |
| CMainCoupledFemDem_Solution | |
| ►NMainCouplingFemDem_for_PFEM_coupling | |
| CMainCoupledFemDem_for_PFEM_coupling_Solution | |
| ►NMainCouplingFemDemSubstepping | |
| CMainCoupledFemDemSubstepping_Solution | |
| ►NMainCouplingFemDemSubstepping_for_PFEM_coupling | |
| CMainCoupledFemDemSubstepping_for_PFEM_coupling_Solution | |
| ►NMainCouplingPfemFemDem | |
| CMainCouplingPfemFemDem_Solution | |
| ►NMainCouplingPfemFemDemAitken | |
| CMainCouplingPfemFemDemAitken_Solution | |
| ►NMainCouplingPfemFemDemAitkenSubstepping | |
| CMainCouplingPfemFemDemAitkenSubstepping_Solution | |
| ►NMainCouplingPfemFemDemSubstepping | |
| CMainCouplingPfemFemDemSubstepping_Solution | |
| ►NMainDEM_for_coupling | |
| CDEM_for_coupling_Solution | |
| ►NMainFEM_for_coupling | |
| CFEM_for_coupling_Solution | |
| ►NMainFEM_for_PFEM_coupling | |
| CFEM_for_PFEM_coupling_Solution | |
| ►NMainFemDem | |
| CFEM_Solution | |
| ►NMainKratosThermalDEMAnalysis | |
| CDEMAnalysisStageWithFlush | |
| ►NMainMaterial | |
| CSolution | |
| ►NMainPfem | |
| CPfemSolution | |
| ►NMainPFEM_for_coupling | |
| CMainPFEM_for_coupling_solution | The derived class for the PfemFluidDynamicsAnalysis |
| ►NMainSolidFEM | |
| CSolution | |
| ►Nmake_mesh_ethier_benchmark_analysis | |
| CEthierBenchmarkMakeMeshAnalysis | |
| ►Nmanage_isolated_nodes_process | |
| CManageIsolatedNodesProcess | |
| ►Nmanage_selected_elements_process | |
| CManageSelectedElementsProcess | |
| ►Nmanufactured_solution | |
| CManufacturedSolution | |
| ►Nmap_nurbs_volume_results_to_embedded_geometry_process | |
| CMapNurbsVolumeResultsToEmbeddedGeometryProcess | |
| ►Nmapping | |
| ►Nin_plane_vertex_morphing_mapper | |
| CInPlaneVertexMorphingMapper | The InPlaneVertexMorphingMapper extends the standard Vertex Morphing approach by restricting the shape update of nodes to an in-plane motion only |
| ►Nsliding_vertex_morphing_mapper | |
| CSlidingVertexMorphingMapper | The SlidingVertexMorphingMapper extends the standard Vertex Morphing approach by restricting the nodal shape update of a specified model part |
| ►NMappingApplication | |
| C_DeprecatedMapper | |
| C_DeprecatedMapperFactory | |
| ►Nmarine_rain_analysis | |
| CMarineRainAnalysis | |
| ►Nmass_response_function | |
| CMassResponseFunction | |
| ►Nmaster_control | |
| CMasterControl | Master control class |
| ►Nmaterial_properties_control | |
| CMaterialPropertiesControl | Material properties control |
| ►Nmaterials_assignation_utility | |
| CMaterialsAssignationUtility | |
| ►Nmdpa_model_part_controller | |
| CMdpaModelPartController | |
| ►Nmesh_controllers | |
| ►Nmesh_controller_base | |
| CMeshController | |
| ►Nmesh_controller_basic_updating | |
| CMeshControllerBasicUpdating | |
| ►Nmesh_controller_with_solver | |
| CMeshControllerWithSolver | |
| ►Nmesh_moving_analysis | |
| CMeshMovingAnalysis | This class is the main-script of the MeshMovingApplication put in a class It can be imported and used as "black-box" |
| ►Nmesh_solver_base | |
| CMeshSolverBase | The base class for mesh motion solvers |
| ►Nmesh_solver_laplacian | |
| CMeshSolverLaplacian | |
| ►Nmesh_solver_structural_similarity | |
| CMeshSolverStructuralSimilarity | |
| ►Nmesh_tying_process | |
| CMeshTyingProcess | This class is used in order to compute the a mortar mesh tying formulation |
| ►Nmesher | |
| CMesher | |
| ►Nmeshing | |
| ►Nmeshing_utilities | |
| CParallelepipedRegularMesher | |
| ►Nmeshing_domain | |
| CMeshingDomain | |
| ►Nmeshing_strategy | |
| CMeshingStrategy | |
| ►Nmmg_process | |
| CMmgProcess | This process remeshes using MMG library |
| ►Nmodel_manager | |
| CModelManager | The base class for solid mechanic model build process |
| ►Nmodel_parameters_factory | |
| CKratosModelParametersFactory | Registry-based model and Kratos parameters factory This class implements a registry-based factory for any model and parameters constructible object (e.g |
| ►Nmodel_part_controller | |
| CModelPartController | |
| ►Nmodel_part_controller_factory | |
| CModelPartController | |
| ►Nmodel_part_utilities | |
| ►CModelPartOperation | |
| COperationType | |
| CModelPartUtilities | |
| ►Nmodeler_factory | |
| CKratosModelerFactory | |
| ►Nmodels_solver | |
| Ccompiled_space_time_function | |
| CMaterialsSolver | |
| ►Nmonolithic_k_epsilon_rans_formulation | |
| CMonolithicKEpsilonRansFormulation | |
| ►Nmonolithic_k_omega_rans_formulation | |
| CMonolithicKOmegaRansFormulation | |
| ►Nmonolithic_k_omega_sst_rans_formulation | |
| CMonolithicKOmegaSSTRansFormulation | |
| ►Nmonolithic_velocity_pressure_rans_formulation | |
| CStabilizedFormulation | Helper class to define stabilization-dependent parameters |
| CMonolithicVelocityPressureRansFormulation | |
| ►Nmove_particle_utility_process | |
| CMoveParticleUtilityProcess | |
| ►Nmpc_contact_process | |
| CMPCContactProcess | This class is used in order to compute the contact using a mortar MPC formulation |
| ►Nmpc_contact_structural_mechanics_implicit_dynamic_solver | |
| CMPCContactImplicitMechanicalSolver | The MPC contact implicit dynamic solver |
| ►Nmpc_contact_structural_mechanics_static_solver | |
| CMPCContactStaticSolver | The MPC contact static solver |
| ►NMPIer | |
| CMPIerClass | |
| ►Nmpm_explicit_solver | |
| CMPMExplicitSolver | |
| ►Nmpm_implicit_dynamic_solver | |
| CMPMImplicitDynamicSolver | |
| ►Nmpm_quasi_static_solver | |
| CMPMQuasiStaticSolver | |
| ►Nmpm_solver | |
| CMPMSolver | |
| ►Nmpm_static_solver | |
| CMPMStaticSolver | |
| ►Nmultiaxial_control_module_fem_dem_generalized_2d_utility | |
| CMultiaxialControlModuleFEMDEMGeneralized2DUtility | |
| ►Nmultiaxial_control_module_generalized_2d_utility | |
| CMultiaxialControlModuleGeneralized2DUtility | |
| ►Nmultiple_points_output_process | |
| CMultiplePointsOutputProcess | This process writes several points to a file Internally it holds objects of type "PointOutputProcess" Usage: |
| ►Nmultiscale_refining_process | |
| CMultiscaleRefiningProcess | |
| ►Nnavier_stokes_ale_fluid_solver | |
| CNavierStokesAleFluidSolver | |
| ►Nnavier_stokes_compressible_explicit_solver | |
| CNavierStokesCompressibleExplicitSolver | |
| ►Nnavier_stokes_embedded_solver | |
| CEmbeddedFormulation | Helper class to define embedded-dependent parameters |
| CNavierStokesEmbeddedMonolithicSolver | |
| ►Nnavier_stokes_solver_fractionalstep | |
| CNavierStokesSolverFractionalStep | |
| ►Nnavier_stokes_solver_fractionalstep_chimera | |
| CNavierStokesSolverFractionalStepForChimera | |
| ►Nnavier_stokes_solver_vms_monolithic_DEMCoupled | |
| CStabilizedFormulationDEMCoupled | |
| CNavierStokesSolverMonolithicDEM | |
| ►Nnavier_stokes_solver_vmsmonolithic | |
| CStabilizedFormulation | Helper class to define stabilization-dependent parameters |
| CNavierStokesSolverMonolithic | |
| ►Nnavier_stokes_solver_vmsmonolithic_chimera | |
| CNavierStokesSolverMonolithicChimera | |
| ►Nnavier_stokes_solver_vmsmonolithic_rom | |
| CROMSolver | |
| ►Nnavier_stokes_two_fluid_hydraulic_solver | |
| CNavierStokesTwoFluidsHydraulicSolver | |
| ►Nnavier_stokes_two_fluids_solver | |
| CNavierStokesTwoFluidsSolver | |
| ►Nnice_names | |
| Cmaterialconstants | |
| Celementvariables | |
| Cintegrationvariables | |
| Cloaddef | |
| Cueldef | |
| Celement | |
| Cnset | |
| Celset | |
| Cboundary | |
| ►Nnitsche_stabilization_process | |
| CNitscheStabilizationProcess | This class is used in order to compute automatically the Nitsche stabilization factor |
| ►NNLOPT_algorithms | |
| CNLOPTAlgorithms | A classical steepest descent algorithm to solve unconstrainted optimization problems |
| ►Nnodal_variable_recording_process | |
| CNodalVariableRecordingProcess | |
| ►Nnon_local_plasticity_process | |
| CNonLocalPlasticityProcess | |
| ►Nnormed_exact_hinsberg_test | |
| CProblemParameters | |
| CHinsbergPointsSetGivenNorm | |
| ►Node_solve | |
| CGrid1D | |
| CFEM_coefficient_matrix_generator | |
| CFEM_load_vector_generator | |
| Code_solve | |
| ►Noffset_ids_process | |
| COffsetIdsProcess | SwapCoordinatesAndOffsetIdsProcess |
| ►Nonthefly_kratos_inlet_process | An inlet boundary condition process for KratosMultiphysics |
| CParameters | DONE: added support for power law DONE: read all mean profile parameters from json file DONE: can choose between power law and logarithmic profile |
| CRegularGrid1D | |
| CSubGrid1D | |
| CInletPanel3D | |
| CLogMeanProfile | |
| CImposeWindInletProcess | |
| CImposeMPIWindInletProcess | |
| ►Nopt_convergence | |
| CMaxIterConvCriterion | |
| CL2ConvCriterion | |
| ►Nopt_line_search | |
| CConstStep | |
| CBBStep | |
| CQNBBStep | |
| ►Noptimization_analysis | |
| COptimizationAnalysis | |
| ►Noptimization_problem | |
| COptimizationProblem | This is the main data holder for optimization problems |
| ►Noptimization_problem_ascii_output_process | |
| CHeader | |
| COptimizationProblemAsciiOutputProcess | |
| ►Noptimization_problem_vtu_output_process | |
| CExpressionData | |
| CContainerExpressionData | |
| CCollectiveExpressionData | |
| CExpressionVtuOutput | |
| COptimizationProblemVtuOutputProcess | |
| ►Noptimizer_factory | |
| COptimizer | |
| ►Norchestrator | |
| COrchestrator | Base class for multistage orchestrators |
| ►Noutput_process_with_controller | |
| COutputProcessWithController | This process divides its responsabilities between two objects: a controller that decides whether current time step must be printed or not and a print process that controls what will be printed and in which format |
| ►Noutput_quadrature_domain_process | |
| COutputIntegrationDomainProcess | |
| ►Nparametric_wall | |
| CParametricWall | |
| ►Nparametric_walls_process | |
| CParametricWallsProcess | |
| ►Nparticle_from_json_check_result_process | |
| CLegacyFromJsonCheckResultProcess | This class is used in order to check results using a json file containing the solution a given model part with a certain frequency |
| CParticleFromJsonCheckResultProcess | |
| ►Nparticle_gid_output_process | |
| CParticleGiDOutputProcess | |
| ►Nparticle_json_output_process | |
| CParticleJsonOutputProcess | |
| ►Nparticle_mechanics_analysis | |
| CParticleMechanicsAnalysis | This class is the main-script of the ParticleMechanicsApplication put in a class |
| ►Nparticle_vtk_condition_output_process | |
| CLegacyParticleConditionVTKOutputProcess | |
| ►Nparticle_vtk_output_process | |
| CParticleVtkOutputProcess | |
| ►Npartitioned_embedded_fsi_base_solver | |
| CPartitionedEmbeddedFSIBaseSolver | |
| ►Npartitioned_fsi_base_solver | |
| CPartitionedFSIBaseSolver | |
| ►Npde_tools | |
| CPeriodicBoundary | Periodic boundary conditions |
| ►Npenalty_contact_process | |
| CPenaltyContactProcess | This class is used in order to compute the contact using a mortar penalty formulation |
| ►Nperiodic_interface_activation_process | |
| CPeriodicInterfaceActivationProcess | All the python processes should be derived from "python_process" |
| ►Nperturb_geometry_sparse_utility | |
| CPerturbGeometrySparseUtility | An utility to perturb the initial geometry of a structure based on a sparse correlation matrix |
| ►Nperturb_geometry_subgrid_utility | |
| CPerturbGeometrySubgridUtility | An utility to perturb the initial geometry of a structure based on a reduced correlation matrix |
| ►Npetrov_galerkin_training_utility | |
| CPetrovGalerkinTrainingUtility | Auxiliary utility for the Petrov Galerkin training |
| ►Npetsc_conversion_tools | |
| CPetscCSRWrapper | |
| ►Npfem2_fluid_transport_process | |
| CPFEM2FluidTransportProcess | |
| ►Npfem_2_base_solver | |
| CPFEM2BaseSolver | |
| ►Npfem_2_fluid_dynamics_analysis | |
| CPFEM2FluidDynamicsAnalysis | Main script for fluid dynamics simulations using the navier_stokes family of python solvers in PFEM2 framework |
| ►Npfem_2_monolithic_solver | |
| CPFEM2MonolithicSolver | |
| ►Npfem_2_navier_stokes_monolithic_solver | |
| CPFEM2NavierStokesMonolithicSolver | |
| ►Npfem_2_process | |
| CPFEM2Process | |
| ►Npfem_2_solver_fractional_step_fluid | |
| CPFEM2Solver | |
| ►Npfem_2_solver_fsi | |
| CPFEM2Solver | |
| ►Npfem_2_solver_fsi_2resolutions | |
| CPFEM2Solver | |
| ►Npfem_2_solver_monolithic | |
| CPFEM2Solver | |
| ►Npfem_2_solver_monolithic_autoslip_fluid | |
| CPFEM2Solver | |
| ►Npfem_2_solver_monolithic_fluid | |
| CPFEM2Solver | |
| ►Npfem_2_solver_monolithic_fluid_2scales | |
| CPFEM2Solver | |
| ►Npfem_2_solver_monolithic_fluid_prashanth | |
| CPFEM2Solver | |
| ►Npfem_check_and_prepare_fluid_model_process | |
| CCheckAndPrepareModelProcess | All the processes python should be derived from "Process" |
| ►Npfem_check_and_prepare_model_process_fluid_for_coupling | |
| CCheckAndPrepareModelProcessForCoupling | The class of the CheckAndPrepareModelProcess class |
| ►Npfem_dem_solver | |
| CPfemDemSolver | |
| ►Npfem_fluid_complete_mesher | |
| CPfemFluidCompleteMesher | |
| ►Npfem_fluid_DEM_coupling_solver | |
| CPfemFluidDEMcouplingSolver | |
| ►Npfem_fluid_dynamics_analysis | |
| CPfemFluidDynamicsAnalysis | The base class for the PfemFluidDynamicsAnalysis |
| ►Npfem_fluid_gid_output_process | |
| CGiDOutputProcess | |
| ►Npfem_fluid_keeping_nodes_mesher | |
| CPfemFluidKeepingNodesMesher | |
| ►Npfem_fluid_nodal_integration_solver | |
| CPfemFluidNodalIntegrationSolver | |
| ►Npfem_fluid_none_mesher | |
| CPfemFluidNoneMesher | |
| ►Npfem_fluid_solver | |
| CPfemFluidSolver | |
| ►Npfem_fluid_solver_for_coupling | |
| CPfemFluidSolverForCoupling | |
| ►Npfem_fluid_thermal_solver | |
| CPfemFluidThermalSolver | |
| ►Npfem_fluid_thermally_coupled_solver | |
| CCoupledPfemFluidThermalSolver | |
| ►Npfem_fluid_three_step_solver | |
| CPfemFluidThreeStepSolver | |
| ►Npfem_solid_gid_output_process | |
| CPfemGiDOutputProcess | LOCAL DERIVATE CLASS IN ORDER TO BE CONSISTENT WITH RESTART (I.E |
| ►NPID | |
| ►Napply_rigid_rotation_process | |
| CApplyRigidRotationProcess | |
| ►Naverage_field | |
| CRotator | |
| CAverager | |
| ►Nhdf5_io_tools_PID | |
| CFluidHDF5LoaderPID | |
| ►Nrotating_ale_analysis | |
| CRotatingAleAnalysis | |
| ►Npiping_analysis | |
| CPipingAnalysis | Main script for geomechanics simulations |
| ►Nplaceholder_process | |
| CPlaceholderProcess | |
| ►Nplanar_surface_in_parabola_benchmark | |
| CPlanarSurfaceInParabolaBenchmark | Planar surface in parabola benchark |
| ►Nplanar_surface_in_parabola_modeler | |
| CPlanarSurfaceInParabolaModeler | |
| ►Nplot_variables | |
| Cvariable_plotter | |
| Ctangential_force_plotter | |
| ►Nploughing_utility | |
| CPloughingUtility | |
| ►Npoint_output_process | |
| CPointOutputProcess | This process writes results from a geometrical position (point) in the model to a file It first searches the entity containing the requested output location and then interpolates the requested variable(s) The output can be requested for elements, conditions and nodes |
| ►Npoint_set_output_process | |
| CPointSetOutputProcess | |
| ►Npolynomial_vortex | |
| CPolynomialVortex | |
| ►Nporomechanics_analysis | |
| CPoromechanicsAnalysis | Main script for poromechanics simulations |
| ►Nporomechanics_face_load_control_module_process | |
| CPoromechanicsFaceLoadControlModuleProcess | All the processes python should be derived from "Process" |
| ►Nporomechanics_fracture_propagation_utility | |
| CFracturePropagationUtility | |
| ►Nporomechanics_initial_stress_utility | |
| CInitialStressUtility | |
| ►Nporomechanics_U_Pw_explicit_dynamic_solver | |
| CExplicitUPwSolver | The Poromechanics explicit U (displacement) dynamic solver |
| ►Nporomechanics_U_Pw_solver | |
| CUPwSolver | Solver for the solution of displacement-pore pressure coupled problems |
| ►Npost_refining_mesher | |
| CPostRefiningMesher | |
| ►Npotential_flow_adjoint_solver | |
| CPotentialFlowAdjointFormulation | |
| CPotentialFlowAdjointSolver | |
| ►Npotential_flow_analysis | |
| CPotentialFlowAnalysis | Main script for potential flow simulations |
| ►Npotential_flow_response | |
| CAdjointResponseFunction | |
| ►Npotential_flow_solver | |
| CPotentialFlowFormulation | |
| CPotentialFlowSolver | |
| ►Npouliot_benchmark_2D_analysis | |
| CPouliotBenchmark2DAnalysis | |
| ►Npre_calculated_fluid_analysis | |
| CPreCalculatedFluidAnalysis | |
| ►Npre_refining_mesher | |
| CPreRefiningMesher | |
| ►Npredictors | |
| ►Naverage_value_based | |
| CAverageValuePredictor | |
| ►Nlinear | |
| CLinearPredictor | |
| ►Nlinear_derivative_based | |
| CLinearDerivativeBasedPredictor | |
| ►Nprimitive_solver | |
| CPrimitiveSolver | |
| ►Nprint_eigenvalues_process | |
| CPrintEigenvaluesProcess | |
| ►Nprint_info_in_file_process | |
| CPrintInfoInFileProcess | All the processes python should be derived from "Process" |
| ►Nprocess_factory | |
| CKratosProcessFactory | Please do not change the following class: |
| ►Nprocess_handler | |
| CProcessHandler | |
| ►Nprocesses | |
| ►Ncreate_point_based_entites_process | |
| CCreatePointBasedEntitiesProcess | This process creates point based entities on the nodes of SubModelPart(s) |
| ►Nmultiaxial_control_module_generalized_2d_process | |
| CMultiaxialControlModuleGeneralized2DProcess | All the processes python should be derived from "Process" |
| ►Nproduct_of_sines_benchmark_analysis | |
| CProductOfSinesBenchmarkAnalysis | |
| ►Nproject | |
| CProject | Kratos Multiphysics multistage project container |
| ►Nproject_vector_on_surface_process | |
| CProjectVectorOnSurfaceProcess | All the processes python should be derived from "Process" |
| ►Nprojection_utilities | |
| CRegularGrid1D | |
| CDomainPanel3D | |
| CDomainPanel2D | |
| ►NProjectParameters | |
| CConvectionSolverSettings | |
| ►CSolverSettings | |
| Clinear_solver_config | |
| ►CSolverSettings2 | |
| Clinear_solver_config | |
| ►CSolverSettings1 | |
| Clinear_solver_config | |
| ►CFluidSolverConfiguration | |
| Clinear_solver_config | |
| ►Npython_interface | |
| ►Nkratos_globals | |
| CKratosGlobalsImpl | |
| ►Npython_registry | |
| CRegistryContext | |
| CPythonRegistryIterator | PythonRegistry iterator class |
| CPythonRegistry | |
| CKratosPaths | |
| ►Npython_mapper | |
| CPythonMapper | Baseclass for python based mappers in Kratos The inteface matches the C++ version ("custom_mappers/mapper.h") The py-mappers are intentionally NOT derived from the c++ version |
| ►Npython_solver | |
| CPythonSolver | The base class for the Python Solvers in the applications Changes to this BaseClass have to be discussed first! |
| ►Nrandomized_singular_value_decomposition | |
| CRandomizedSingularValueDecomposition | This 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 |
| ►NRandomMaterial | |
| CRandomMaterial | Random material generator class |
| ►Nrans_analysis | |
| CRANSAnalysis | Main script for fluid dynamics simulations using the navier_stokes family of python solvers |
| ►Nread_csv_table_utility | |
| CReadCsvTableUtility | This class is used to retrieve a table from the specified parameters |
| ►Nread_distance_from_file | |
| CDistanceImportUtility | Distance import utility class definition |
| ►Nread_from_sw_interface_process | |
| CReadFromSwInterfaceProcess | ReadFromSwInterfaceProcess |
| ►Nreconnect_mesher | |
| CReconnectMesher | |
| ►Nrefine_embedded_object | |
| CMeshAdaptor | |
| ►Nremesh_domains_process | |
| CRemeshDomainsProcess | |
| ►Nremesh_fluid_domains_process | |
| CRemeshFluidDomainsProcess | The base class for the RemeshFluidDomainsProcess |
| ►Nreplace_properties_process | |
| CReplacePropertiesProcess | All the processes python should be derived from "Process" |
| ►Nresponse_function | |
| CResponseFunction | Base response function |
| ►Nresponse_function_output_process | |
| CResponseFunctionOutputProcess | |
| ►Nresponse_functions | |
| ►Nairfoil_2d_responses | |
| CAngleOfAttackResponseFunction | |
| CChordLengthResponseFunction | |
| CPerimeterResponseFunction | |
| ►Nconvection_diffusion_response | This module contains an interface to the available response functions |
| CAdjointResponseFunction | Linear adjoint response function |
| ►Nface_angle | |
| CFaceAngleResponseFunction | Face angle response function |
| ►Nmesh_based_packaging | |
| CMeshBasedPackaging | A class for mesh packaging response function |
| ►Npackaging_response_base | |
| CPackagingResponseBase | A base class for packaging response functions that agglomerate the nodal violations into a single response function |
| ►Nplane_based_packaging | |
| CPlaneBasedPackaging | A class that defines the response function for plane-based packaging |
| ►Nresponse_function_interface | |
| CResponseFunctionInterface | This response function interface provides a unique interface for all possible ways to calculate the value and gradient of a response |
| ►Nsurface_normal_shape_change | |
| CSurfaceNormalShapeChange | This simple geometric response function calculates the sum of all shape updates in surface normal direction |
| ►Ntotal_volume | This module contains an interface to the total volume response function |
| CTotalVolume | |
| ►Nresponse_routine | |
| CResponseRoutine | A class which adds optimization-specific utilities to simplify routines and synchronization between the control field from algorithms and analysis models |
| ►Nrestart_process | |
| CRestartProcess | |
| ►Nrestart_utility | |
| CRestartUtility | This class collects the common functionalities needed for saving / loading restart files |
| ►Nrigid_bodies_process | |
| CRigidBodiesProcess | |
| ►Nrigid_body | |
| CRigidBody | |
| ►Nrom_manager | |
| CRomManager | |
| ►Nroot_finder | |
| Cpol | |
| ►Nrotate_region_process | |
| CApplyRotateRegionProcess | This process applies a rotation to a given modelpart or a submodelpart |
| ►Nrun_ethier_benchmark | |
| CMeshType | |
| ►Nrunge_kutta_frac_step_solver | |
| CRungeKuttaFracStepSolver | |
| ►Nrve_analysis | |
| CRVEAnalysis | |
| ►NSampling_Methods | |
| CSampling_method_base | |
| CSampling_method_freq | |
| CSampling_FFTW | |
| CSampling_VF_FFTW | |
| CSampling_FFT | |
| CSampling_DST | |
| CSampling_DCT | |
| CSampling_NFFT | |
| CSampling_H2 | |
| CSampling_ODE | |
| CSampling_Rational | |
| CSampling_Rational_VK_Wind_Blocking | This function assumes \mcL u = -\nabla\cdot ( L(x)^2 \nabla u ) |
| CSampling_Rational_Rapid_Distortion_Wind_Blocking | Solves (1 -\nabla\cdot ( \Theta_t \nabla ))^\alpha u = f_t |
| ►Nsand_production_post_process_tool | |
| CSandProductionPostProcessTool | |
| ►Nsave_restart_process | |
| CSaveRestartProcess | This process compares saves restart files It works both in OpenMP and MPI see the "default_settings" for available options |
| ►Nsave_variables_utility | |
| CSaveVariablesUtility | |
| ►Nscalar_turbulence_model_rans_formulation | |
| CScalarTurbulenceModelRansFormulation | |
| ►Nschemes_factory | |
| CSolutionScheme | |
| ►Nsearch_base_process | |
| CSearchBaseProcess | This class is a base class used to perform the search for contact and mesh tying |
| ►Nsensitivity_builder_cpp | |
| CSetNonHistoricalValueToZeroFunctor | |
| CSetHistoricalValueToZeroFunctor | |
| CCalculateNodalSolutionStepSensitivityFunctor | |
| CCalculateNonHistoricalSensitivitiesFunctor | |
| ►Nsequential_orchestrator | |
| CSequentialOrchestrator | Multistage orchestrator to sequentially execute a collection of stages |
| ►Nserial_output_process | |
| CSerialOutputProcess | This process is used in distributed simulations to do post-processing on one rank For this first the results are mapped to a serial ModelPart, with which then postprocessing is done This is not the most efficient approach by principle, but sometimes it is necessary to collect all the results on one rank |
| ►Nset_absorbing_boundary_parameters_process | |
| CSetAbsorbingBoundaryParametersProcess | |
| ►Nset_directors_process | |
| CSetDirectorsProcess | All the processes python should be derived from "Process" |
| ►Nset_initial_perturbation_process | |
| CInitialPerturbationProcess | This process sets the value of a scalar variable using the AssignScalarVariableProcess |
| ►Nset_initial_state_process | |
| CSetInitialStateProcess | This process sets a given value for a certain flag in all the nodes of a submodelpart |
| ►Nset_initial_water_level_process | |
| CSetInitialWaterLevelProcess | This process sets the value of a scalar variable using the AssignScalarVariableProcess |
| ►Nset_mesh_motion_and_get_forces_process | |
| ►CSetMeshMotionAndGetForcesProcess | |
| ►CMotion | |
| CRampedSin | |
| ►Nset_parameter_field_process | |
| CSetParameterFieldProcess | Sets parameter field process |
| ►Nset_topography_process | |
| CSetTopographyProcess | This process sets the value of a scalar variable using the AssignScalarVariableProcess |
| ►Nset_up_pre_stressed_oriented_composite_materials | |
| CSetUpPreStressedOrientedCompositeMaterials | This process sets a proper orientation of the local axes of the elements intersected by line elements (steel tendons) |
| ►Nshallow_water_analysis | |
| CShallowWaterAnalysis | Main script for shallow water simulations |
| ►Nshallow_water_base_solver | |
| CShallowWaterBaseSolver | |
| ►Nshell_thickness_control | |
| CShellThicknessControl | Shell thickness control |
| ►Nsimplified_nodal_contact_process | |
| CSimplifiedNodalContactProcess | |
| ►Nsinusoidal_vortex | |
| CManufacturedVortex | |
| ►Nskin_detection_process | |
| CSkinDetectionProcess | All the processes python should be derived from "Process" |
| ►Nsliding_edge_process | |
| CSlidingEdgeProcess | |
| ►Nsoil_sampler_utility | |
| CSoilSamplerUtility | |
| ►Nsolid_analysis | |
| CSolution | |
| ►Nsolid_mechanics_composite_solver | |
| CCompositeSolver | The solid mechanics composite solver |
| ►Nsolid_mechanics_eigensolver | |
| CEigenSolver | The solid mechanics eigen solver |
| ►Nsolid_mechanics_explicit_dynamic_solver | |
| CExplicitMonolithicSolver | The solid mechanics explicit dynamic solver |
| ►Nsolid_mechanics_implicit_dynamic_solver | |
| CImplicitMonolithicSolver | The solid mechanics implicit dynamic solver |
| ►Nsolid_mechanics_monolithic_solver | |
| CMonolithicSolver | The base class for solid mechanics solvers |
| ►Nsolid_mechanics_segregated_solver | |
| CSegregatedSolver | The solid mechanics segregated solver |
| ►Nsolid_mechanics_static_solver | |
| CStaticMonolithicSolver | The solid mechanics static solver |
| ►Nsolitary_wave_benchmark | |
| CSolitaryWaveBenchmark | Solitary wave benchmark |
| ►Nsolitary_wave_utilities | |
| CSolitaryWaveSolution | Base class for analytical solutions of a solitary wave |
| CGoringSolution | Goring analytical solution |
| CRayleighSolution | Goring analytical solution |
| CBoussinesqSolution | Analytical solution for a solitary wave with the modified Boussinesq equations |
| ►Nsolver_wrappers | |
| ►Ncpp_ping_pong | |
| ►Nping_pong_io | |
| CPingPongIO | This is the IO wrapper for the PING-PONG example |
| ►Nping_pong_wrapper | |
| CPingPongWrapper | This class serves as wrapper for the cpp ping and pong solvers |
| ►Ndummy_io | |
| CDummyIO | This class is used if a Solver directly uses Kratos as a data-structure e.g |
| ►Nempire_io | |
| CEmpireIO | IO for the legacy EMPIRE_API |
| ►Nexternal | |
| ►Nacusolve_wrapper | |
| CacuSolveWrapper | This class serves as a dedicated Kratos wrapper for acuSolve |
| ►Nexternal_solver_wrapper | |
| CExternalSolverWrapper | This class is a generic wrapper for connecting external solvers The import of meshes is done once in the beginning |
| ►Nflower_wrapper | |
| CFLOWerWrapper | This class serves as wrapper for the CFD solver FLOWer |
| ►Nopenfoam_wrapper | |
| COpenFOAMWrapper | This class serves as wrapper for the CFD solver OpenFOAM |
| ►Nremote_controlled_solver_wrapper | |
| CRemoteControlledSolverWrapper | This class is a generic wrapper for connecting external solvers that are being remote controlled |
| ►Nkratos | |
| ►Nconvection_diffusion_wrapper | |
| CConvectionDiffusionWrapper | This class is the interface to the ConvectionDiffusionApplication of Kratos |
| ►Ndem_wrapper | |
| CDEMWrapper | This class is the interface to the DEMApplication of Kratos |
| ►Nfluid_dynamics_wrapper | |
| CFluidDynamicsWrapper | This class is the interface to the FluidDynamicsApplication of Kratos |
| ►Nkratos_base_wrapper | |
| CThreadManager | Class for setting and ressting the number of threads a context should use |
| CKratosBaseWrapper | This class serves as basis for the kratos-wrappers It uses the AnalysisStage as black-box interface to Kratos |
| ►Nparticle_mechanics_dirichlet_wrapper | |
| CParticleMechanicsDirichletWrapper | This class is the interface to the ParticleMechanicsApplication of Kratos |
| ►Nparticle_mechanics_neumann_wrapper | |
| CParticleMechanicsNeumannWrapper | This class is the interface to the ParticleMechanicsApplication of Kratos |
| ►Npfem_fluid_dynamics_wrapper | |
| CPfemFluidDynamicsWrapper | This class is the interface to the PfemFluidDynamicsApplication of Kratos |
| ►Npotential_flow_wrapper | |
| CPotentialFlowWrapper | |
| ►Nrom_wrapper | |
| CRomWrapper | This class is the interface to the RomApplication of Kratos |
| ►Nstructural_mechanics_wrapper | |
| CStructuralMechanicsWrapper | This class is the interface to the StructuralMechanicsApplication of Kratos |
| ►Nkratos_co_sim_io | |
| CKratosCoSimIO | Wrapper for the CoSimIO to be used with Kratos |
| ►Nsdof | |
| ►Nsdof_solver | |
| CSDoFSolver | This class implements an SDof solver, independent of Kratos Several types of applying loads are available |
| ►Nsdof_solver_wrapper | |
| CSdofSolverWrapper | This class implements a wrapper for an SDof solver to be used in CoSimulation |
| ►Nsdof_static_solver | |
| CSDoFStaticSolver | |
| ►Nstatic_sdof_solver_wrapper | |
| CSdofStaticSolverWrapper | This class implements a wrapper for an SDof solver to be used in CoSimulation |
| ►Nsp_dem_fem_coupling_algorithm | |
| CSPAlgorithm | |
| ►Nspatial_statistics_process | |
| CSpatialStatisticsProcess | A process to calculate spatial statistics on Kratos containers |
| ►Nspatial_utilities | |
| CSpatialMethodOutput | |
| CSpatialSumOutput | |
| CSpatialMeanOutput | |
| CSpatialRootMeanSquareOutput | |
| CSpatialMinOutput | |
| CSpatialMaxOutput | |
| CSpatialMedianOutput | |
| CSpatialVarianceOutput | |
| CSpatialDistributionOutput | |
| ►Nspecial_condition_process | |
| CSpecialConditionProcess | All the processes python should be derived from "Process" |
| ►Nsphere_strategy | |
| CExplicitStrategy | |
| ►Nspreader | |
| Cscanner | |
| ►Nsprism_process | |
| CSPRISMProcess | This class is used in order to compute some pre and post process on the SPRISM solid shell elements |
| ►Nstabilized_shallow_water_solver | |
| CStabilizedShallowWaterSolver | |
| ►Nstandardized_constraint | |
| CStandardizedConstraint | Standardized constraint response function |
| ►Nstandardized_NLOPT_constraint | |
| CStandardizedNLOPTConstraint | Standardized constraint response function |
| ►Nstandardized_NLOPT_objective | |
| CStandardizedNLOPTObjective | Standardized objective response function |
| ►Nstandardized_objective | |
| CStandardizedObjective | Standardized objective response function |
| ►Nstd | Namespace |
| Chash< Kratos::array_1d< T, N > > | |
| Chash< std::pair< T1, T2 > > | This is a hasher for pairs |
| ►Nsteady_wind_kratos_inlet_process | An inlet boundary condition process for KratosMultiphysics |
| CParameters | DONE: added support for power law DONE: read all mean profile parameters from json file DONE: can choose between power law and logarithmic profile |
| CLogMeanProfile | |
| CImposeWindInletProcess | |
| ►Nstepping_analysis_execution_policy | |
| CSteppingAnalysisExecutionPolicy | |
| ►Nstochastic_potential_flow_response | |
| CAdjointResponseFunction | |
| CSimulationScenario | |
| ►Nstokes_solver_monolithic | |
| CStabilizedStokesFormulation | Helper class to define Stokes formulation parameters |
| CStokesSolverMonolithic | Monolithic Stokes formulations solver |
| ►Nstrategy_python | |
| CSolvingStrategyPython | |
| ►Nstrategy_python_nonlinear | |
| CSolvingStrategyPython | |
| ►Nstreamlines_output_utility | |
| CStreamlinesOutputUtility | |
| ►Nstress_failure_check_utility | |
| CStressFailureCheckUtility | |
| ►Nstructural_mechanics_adjoint_static_solver | |
| CStructuralMechanicsAdjointStaticSolver | |
| ►Nstructural_mechanics_analysis | |
| CStructuralMechanicsAnalysis | This class is the main-script of the StructuralMechanicsApplication put in a class |
| ►Nstructural_mechanics_analysis_rom | |
| CStructuralMechanicsAnalysisROM | |
| ►Nstructural_mechanics_custom_scipy_base_solver | |
| CCustomScipyBaseSolver | The structural mechanics custom scipy base solver |
| ►Nstructural_mechanics_eigensolver | |
| CEigenSolver | The structural mechanics eigen solver |
| ►Nstructural_mechanics_explicit_dynamic_solver | |
| CExplicitMechanicalSolver | The structural mechanics explicit dynamic solver |
| ►Nstructural_mechanics_formfinding_solver | |
| CFormfindingMechanicalSolver | The structural mechanics formfinding solver |
| ►Nstructural_mechanics_harmonic_analysis_solver | |
| CHarmonicAnalysisSolver | The structural mechanics harmonic analysis solver |
| ►Nstructural_mechanics_implicit_dynamic_rom_solver | |
| CROMSolver | The stationary class for ROM structural mechanics solvers |
| ►Nstructural_mechanics_implicit_dynamic_solver | |
| CImplicitMechanicalSolver | The structural mechanics implicit dynamic solver |
| ►Nstructural_mechanics_prebuckling_analysis | |
| CStructuralMechanicsPrebucklingAnalysis | |
| ►Nstructural_mechanics_prebuckling_solver | |
| CPrebucklingSolver | The structural mechanics prebuckling solver |
| ►Nstructural_mechanics_solver | |
| CMechanicalSolver | The base class for structural mechanics solvers |
| ►Nstructural_mechanics_static_rom_solver | |
| CROMSolver | The stationary class for ROM structural mechanics solvers |
| ►Nstructural_mechanics_static_solver | |
| CStaticMechanicalSolver | The structural mechanics static solver |
| ►Nstructural_response | |
| CStrainEnergyResponseFunction | Linear strain energy response function |
| CEigenFrequencyResponseFunction | Eigenfrequency response function |
| CMassResponseFunction | Mass response function |
| CAdjointResponseFunction | Linear static adjoint strain energy response function |
| ►Nsub_model_part_entities_boolean_operation_process | |
| CSubModelPartEntitiesBooleanOperationProcess | Apply a boolean operation to the entities of the given sub model parts |
| ►NSurfaceTension_monolithic_solver | |
| CSTMonolithicSolver | |
| ►Nswap_coordinates_process | |
| CSwapCoordinatesProcess | SwapCoordinatesProcess |
| ►Nswimming_DEM_analysis | |
| CSDEMLogger | |
| Cpython_parameters | |
| CSwimmingDEMAnalysis | |
| ►Nswimming_DEM_gid_output | |
| CSwimmingDEMGiDOutput | |
| ►Nswimming_DEM_PFEM_analysis | |
| CSDEMPFEMAnalysis | |
| ►Nswimming_DEM_procedures | |
| ►CFluidFractionFieldUtility | |
| CLinearField | |
| CIOTools | |
| CProjectionDebugUtils | |
| CCounter | |
| CAverager | |
| CPostUtils | |
| CResultsFileCreator | |
| ►Nswimming_DEM_solver | |
| CSwimmingDEMSolver | |
| ►Nswimming_sphere_strategy | |
| CSwimmingStrategy | |
| ►Nsymbolic_generation | |
| ►Ncompressible_navier_stokes | |
| ►Ncompressible_navier_stokes_symbolic_generator | |
| CCompressibleNavierStokesSymbolicGenerator | This class is in charge of generating a element to solve the compressible Navier-Stokes using the conservative magnitudes (density, momentum, energy) as solution |
| ►Nsrc | |
| ►Ndefines | |
| CCompressibleNavierStokesDefines | |
| ►Nsymbolic_geometry | |
| CGeometryData | |
| CTriangleData | |
| CQuadrilateralData | |
| CTetrahedronData | |
| ►Nsymbolic_parameters | |
| CFormulationParameters | |
| CShockCapturingParameters | |
| CShockCapturingNodalParameters | |
| ►Nt_junction | |
| ►Nt_junction_analysis | |
| CTJunctionAnalysis | |
| ►Nt_win_vs_m_fixed_error | |
| CProblemParameters | |
| CHinsbergPointsSetGivenNorm | |
| ►Ntaylor_green_cell | |
| Ctaylor_green_vector_field | |
| ►Ntemplate_user_defined_parameter_field | |
| CParameterField | Base class of a user defined parameter field |
| ►Ntemporal_statistics_process | |
| CTemporalStatisticsProcess | A process to use temporal statistics for Kratos containers |
| ►Ntensors | |
| Coperator(.dot.) | |
| Coperator(.dyad.) | |
| Coperator(.double.) | |
| Cunit | |
| Cnorm | |
| Ctr | |
| Cdet | |
| Cinverse | |
| Cmb | |
| Chs1 | |
| Csign1 | |
| Cdev | |
| ►Ntest_case | |
| CTestCase | Custom test case class for sorting cases into suites automatically while globbing |
| ►Ntest_suite | |
| CSuiteFlags | |
| CTestSuite | Custom test suite class for sorting cases into suites automatically while globbing |
| ►Ntesting | |
| ►Nrun_tests | |
| CCommander | |
| ►Nutilities | |
| CCommander | |
| ►Nthermal_continuum_sphere_strategy | |
| CExplicitStrategy | |
| ►Nthermal_dem_analysis | |
| CThermalDEMAnalysis | |
| ►Nthermal_dem_io | |
| CThermalDEMIo | |
| ►Nthermal_sphere_strategy | |
| CExplicitStrategy | |
| ►Ntikz_output_process | |
| CTikZOutputProcess | All the processes python should be derived from "Process" |
| ►Ntime_based_ascii_file_writer_utility | |
| CTimeBasedAsciiFileWriterUtility | This utility handles a file to which results are to be written |
| ►Ntime_discretization_process | |
| CTimeDiscretizationProcess | All the processes python should be derived from "Process" |
| ►Ntime_step_testing_stage | |
| CTimeStepTester | |
| CCustomizedSolutionForTimeStepTesting | |
| ►Ntimer | |
| CTimer | |
| ►Ntimer_process | |
| CTimerProcess | This process helps to measure the time consumed on the simulations |
| ►Ntopology_optimization_simp_static_solver | |
| CSIMPStaticMechanicalSolver | |
| ►Ntopology_optimizer_factory | |
| CSIMPMethod | |
| CController | |
| ►Ntransfer_mesher | |
| CTransferMesher | |
| ►Ntransfer_selfweight_stress_utility | |
| CTransferSelfweightStressToMainModelPartUtility | |
| ►Ntriaxial2d_test | |
| CTriaxial2D | |
| ►Ntrilinos_adjoint_monolithic_solver | |
| CAdjointMonolithicMPISolver | |
| ►Ntrilinos_convergence_criteria_factory | |
| Cconvergence_criterion | |
| ►Ntrilinos_mesh_solver_base | |
| CTrilinosMeshSolverBase | |
| ►Ntrilinos_mesh_solver_laplacian | |
| CTrilinosMeshSolverLaplacian | |
| ►Ntrilinos_mesh_solver_structural_similarity | |
| CTrilinosMeshSolverStructuralSimilarity | |
| ►Ntrilinos_navier_stokes_embedded_solver | |
| CNavierStokesMPIEmbeddedMonolithicSolver | |
| ►Ntrilinos_navier_stokes_solver_fractionalstep | |
| CTrilinosNavierStokesSolverFractionalStep | |
| ►Ntrilinos_navier_stokes_solver_vmsmonolithic | |
| CTrilinosNavierStokesSolverMonolithic | |
| ►Ntrilinos_navier_stokes_two_fluids_solver | |
| CNavierStokesMPITwoFluidsSolver | |
| ►Ntrilinos_partitioned_fsi_base_solver | |
| CTrilinosPartitionedFSIBaseSolver | |
| ►Ntrilinos_structural_mechanics_implicit_dynamic_solver | |
| CTrilinosImplicitMechanicalSolver | The trilinos structural mechanics implicit dynamic solver |
| ►Ntrilinos_structural_mechanics_solver | |
| CTrilinosMechanicalSolver | The base class for trilinos structural mechanics solver |
| ►Ntrilinos_structural_mechanics_static_solver | |
| CTrilinosStaticMechanicalSolver | The trilinos structural mechanics static solver |
| ►Ntwo_equation_turbulence_model_rans_formulation | |
| CTwoEquationTurbulenceModelRansFormulation | |
| ►Nulf_frac | |
| CULF_FSISolver | |
| ►Nulf_frac_strategy | |
| CULFFracStrategyPython | |
| ►Nulf_fsi | |
| CULF_FSISolver | |
| ►Nulf_fsi_inc | |
| CULF_FSISolver | |
| ►Nulf_PGLASS | |
| CULF_FSISolver | THIS 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 ); |
| ►Nulf_strategy_PGLASS | |
| CULFStrategyPython | |
| ►Nulf_strategy_python | |
| CULFStrategyPython | |
| ►Nulf_strategy_python_inc | |
| CULFStrategyPythonInc | |
| ►Nulf_strategy_python_inc_rigid | |
| CULFStrategyPythonInc | |
| ►Nunv_output_process | |
| CUnvOutputProcess | |
| ►Nuser_defined_parameter_field_base | |
| CParameterFieldBase | Base class of a user defined parameter field |
| ►Nutilities | |
| ►Ncustom_sensitivity_heatmap | |
| CSensitivityHeatmapCalculator | |
| ►Ncustom_timer | |
| CTimer | |
| ►Nutils | HDF5 custom IO process utilities |
| ►Nio | |
| Cbcolors | |
| ►NtemplateRule | |
| CTemplateRule | |
| ►Nvariables_management | |
| CVariablesManager | |
| ►Nverlet_continuum_sphere_strategy | |
| CExplicitStrategy | |
| ►Nvertex_morphing_shape_control | |
| CVertexMorphingShapeControl | Node-based shape control using implicit and explicit Vertex Morphing techniques |
| ►Nvisualization_mesh_process | |
| CVisualizationMeshProcess | VisualizationMeshProcess |
| ►Nvolume_recovery_process | |
| CVolumeRecoveryProcess | All the processes python should be derived from "Process" |
| ►Nvolume_shaping_process | |
| CVolumeShapingProcess | All the processes python should be derived from "Process" |
| ►Nvtk_embedded_geometry_output_process | |
| CVtkEmbeddeGeometryOutputProcess | |
| ►Nvtk_output_process | |
| CVtkOutputProcess | |
| ►Nvtu_output_process | |
| CVtuOutputProcess | |
| ►Nwave_envelope_output_process | |
| CWaveHeightOutputProcess | WaveHeightOutputProcess |
| ►Nwave_generator_process | |
| CWaveGeneratorProcess | |
| ►Nwave_height_output_process | |
| CWaveHeightOutputProcess | WaveHeightOutputProcess |
| ►Nwave_solver | |
| CWaveSolver | |
| ►Nwave_theory_utilities | |
| CWaveTheory | Base class for waves calculations |
| CBoussinesqTheory | Boussinesq theory for dispersive waves |
| CLinearTheory | Linear theory for intermediate water |
| CShallowTheory | Linear theory for shallow water |
| ►Nwrite_from_sw_at_interface_process | |
| CWriteFromSwAtInterfaceProcess | WriteFromSwAtInterfaceProcess |
| ►Nwrite_json_input | |
| CJsonWriter | |
| ►Nxdmf_utils | Utilities for creating XDMF metadata from results stored in HDF5 |
| CNonExistingModule | |
| Celement | |
| CEmpiricalSpringElementProcess | This process creates a spring element w.r.t. to given displacement/load data points |
| CGatherModelPartUtility | This function gathers a model part from a given rank to the master rank |
| CGenericConstitutiveLawIntegrator | |
| CGeoFlowApplyConstantHydrostaticPressureProcess | |
| CGeoFlowApplyConstantScalarValueProcess | |
| CLinearIsotropicDamagePlaneStrain2D | Defines a damage with hardening/softening constitutive law in 2D (Plane Strain) |
| CLinearIsotropicDamageTractionOnly3D | Defines a damage with hardening/softening constitutive law in 3D |
| CLinearJ2Plasticity3D | Defines a Simo J2 plasticity constitutive law in 3D |
| CLinearJ2PlasticityPlaneStrain2D | Defines a Simo J2 plasticity constitutive law in 2D (Plane Strain) |
| Cnode | |
| CNurbsVolumeShapeFunctions | Provides the shape functions and evaluation methods for trivariant BSpline volumes |
| CTemporal | A temporal controller to control behavior based on temporal values |
1.9.1