| Njlcxx | |
| CIsBits< mgis::julia::Ptr< T > > | |
| CInstantiateParametricType< mgis::julia::Ptr< T > > | |
| CInstantiateParametricType< mgis::julia::ArrayView< T, N > > | |
| CIsImmutable< mgis::julia::ArrayView< T, N > > | |
| CConvertToJulia< mgis::julia::ArrayView< T, N > > | |
| Cstatic_type_mapping< mgis::julia::ArrayView< T, N > > | |
| CIsMirroredType< mgis::behaviour::Variable::Type > | |
| CIsMirroredType< mgis::behaviour::Hypothesis > | |
| CIsMirroredType< mgis::behaviour::Behaviour::Symmetry > | |
| CIsMirroredType< mgis::behaviour::Behaviour::BehaviourType > | |
| CIsMirroredType< mgis::behaviour::Behaviour::Kinematic > | |
| CIsMirroredType< mgis::behaviour::FiniteStrainBehaviourOptions::StressMeasure > | |
| CIsMirroredType< mgis::behaviour::FiniteStrainBehaviourOptions::TangentOperator > | |
| CIsMirroredType< mgis::behaviour::IntegrationType > | |
| CIsMirroredType< mgis::behaviour::BehaviourDataView > | |
| CSuperType< mgis::julia::SharedBehaviour > | |
| CUpCast< mgis::julia::SharedBehaviour > | |
| CDownCast< mgis::behaviour::Behaviour, mgis::julia::SharedBehaviour > | |
| CSuperType< mgis::julia::Wrapper< T > > | |
| CUpCast< mgis::julia::Wrapper< T > > | |
| CDownCast< T, mgis::julia::Wrapper< T > > | |
| Nmgis | Namespace mgis encloses all the MGIS project |
| Nfenics | |
| CNonLinearMaterial | Main interface between MGIS and FEniCS. This design has been inspired by the one of the fenics-solid-mechanics project |
| CNonLinearMaterialFunctionBase | Main interface between MGIS and FEniCS. This design has been inspired by the one of the fenics-solid-mechanics project |
| CNonLinearMaterialTangentOperatorFunction | Function in charge of the export the flux to FEniCS |
| CNonLinearMaterialThermodynamicForcesFunction | Function in charge of the export the flux to FEniCS |
| CNonLinearMechanicalProblem | |
| Njulia | |
| Ndetail | |
| CLongNTuple | |
| CLongNTuple< 0, TypesT... > | |
| CPtr | Wrap a const pointer |
| CArrayView | |
| CSharedBehaviour | Behaviour returned by load. It is shared by the objects built from it (states, behaviour data and material data managers), which thus keep it alive when the Julia object of the behaviour is collected |
| CWrapper | Object of type T (State, BehaviourData or MaterialDataManager) built from a shared behaviour, which it keeps alive |
| Nbehaviour | |
| Ndebug | |
| CBehaviourIntegrationFailureAnalyser | Object in charge of analysing and integration failure. This object is used by the integrate_debug function |
| CBehaviourInitializeFunction | Structure describing an initialize function of a behaviour |
| CBehaviourPostProcessing | Structure describing a post-processing of a behaviour |
| CBehaviour | Structure describing a behaviour |
| CLoadFromDatabaseOptions | Options passed to the loadFromDatabase function |
| CBehaviourData | Structure in charge of containing the data required for a behaviour integration |
| CBehaviourDescription | Structure describing a behaviour |
| CFiniteStrainBehaviourOptions | Option available for finite strain behaviours |
| CBehaviourIntegrationOptions | Structure defining various option |
| CBehaviourIntegrationResult | Structure in charge of reporting the result of a behaviour integration |
| CMultiThreadedBehaviourIntegrationResult | Structure in charge of reporting the result of a behaviour integration |
| CBehaviourIntegrationWorkSpace | Structure in charge of handling temporary memory access |
| CMaterialDataManagerInitializer | Structure in charge of holding information on how a material data manager shall be initialized. It may contain pointers to externally allocated data, that won't be handled by the final data manager. If a pointer is not initialized, the material data manager will allocate and handle memory internally |
| CMaterialDataManager | Structure in charge of handling the data associated with a material in an optimized way. Here, the "material" is defined by a behaviour and a number of integration points |
| CUpdateArguments | Additional arguments passed to the upate function |
| CMaterialFunctionManager | Simple wrapper around the MaterialDataManager class |
| CMaterialStateManagerInitializer | Structure in charge of holding information on how a material state manager shall be initialized. It may contain pointers to externally allocated data, that won't be handled by the final state manager. If a pointer is not initialized, the material state manager will allocate and handle memory internally |
| CMaterialStateManager | Structure in charge of handling the state of a material in an optimized way. Here, the "material" is defined by a behaviour and a number of integration points |
| CMutableFieldHolder | Structure defining a mutable field holder |
| CFieldHolder | |
| CMaterialAxisStorage | Helper structure to store a material axis |
| CRotationMatrix2D | Structure to represent a 2D rotation matrix |
| CRotationMatrix3D | Structure to represent a 3D rotation matrix |
| CState | Structure in charge of containing the state of a material |
| CVariable | Structure describing a variable |
| Nattributes | |
| CUnsafeAttribute | Attribute use to indicate that a method or a function as being unsafe without precautions |
| CThrowingAttribute | Attribute use to indicate that a method may throw or not |
| CAbortingAttribute | Attribute use to indicate that a method may abort the process in case of error is the boolean value is true |
| Nfunction | |
| Ninternals | |
| CBinaryOperationModifierBase | Helper base class giving the number of components of the values returned by a binary operation applied to two evaluators |
| CBinaryOperatorCurrying | Partial application of a binary operation to the evaluator of its second argument |
| CBinaryOperatorCurrying2 | Partial application of a binary operation to the evaluator of its second argument, without storing the operation |
| Cbinary_operation_modifier | Helper applying a stored binary operation to one or two evaluators |
| Cbinary_operation_modifier2_impl | Helper applying a binary operation which is not stored in the helper to one or two evaluators |
| CCompileTimeSize | Traits giving the number of components of a type |
| CCompileTimeSize< real > | Specialization for a scalar value, which has one component |
| CCompileTimeSize< std::span< real, N > > | Specialization for a fixed-sized span |
| CCompileTimeSize< std::span< const real, N > > | Specialization for a constant fixed-sized span |
| CCompileTimeSize< std::span< real > > | Specialization for a dynamic-sized span |
| CCompileTimeSize< std::span< const real > > | Specialization for a constant dynamic-sized span |
| CCompileTimeSize< std::array< real, N > > | Specialization for a fixed-sized array |
| CCompileTimeSize< std::array< const real, N > > | Specialization for a constant fixed-sized array |
| CNumberOfComponents | Traits giving the number of components of a function or an evaluator when it is known at compile-time, dynamic_extent otherwise |
| CIsDataView | Traits stating if the given type is a view to some values, which must be specialized for the classes holding views to data, such as std::span or tfel::math::View |
| CIsDataView< T & > | Specialization for reference types: a reference does not own the value it refers to, so it is always considered as a view |
| CIsDataView<::std::span< T, Extent > > | Specialization for std::span |
| CEvaluatorResultQueryImplementation1 | Helper class used to determine the type returned by an evaluator called with an element index, which is an invalid type if the evaluator cannot be called this way |
| CEvaluatorResultQueryImplementation1< true, EvaluatorType > | Specialization used when the evaluator can be called this way |
| CEvaluatorResultQueryImplementation2 | Helper class used to determine the type returned by an evaluator called with an element workspace and an element index, which is an invalid type if the evaluator cannot be called this way |
| CEvaluatorResultQueryImplementation2< true, EvaluatorType > | Specialization used when the evaluator can be called this way |
| CEvaluatorResultQueryImplementation3 | Helper class used to determine the type returned by an evaluator called with a cell index and a quadrature point index, which is an invalid type if the evaluator cannot be called this way |
| CEvaluatorResultQueryImplementation3< true, EvaluatorType > | Specialization used when the evaluator can be called this way |
| CEvaluatorResultQueryImplementation4 | Helper class used to determine the type returned by an evaluator called with a cell workspace, a cell index and a quadrature point index, which is an invalid type if the evaluator cannot be called this way |
| CEvaluatorResultQueryImplementation4< true, EvaluatorType > | Specialization used when the evaluator can be called this way |
| CEvaluatorResultQueryImplementation | Helper class used to determine how an evaluator can be called and the type of the values it returns |
| CEvaluatorResultQueryImplementation< true, EvaluatorType > | Specialization used when the evaluator provides a getSpace function |
| CEvaluatorResultQuery | Alias used to determine how an evaluator can be called and the type of the values it returns |
| CNumberOfComponents< EvaluatorType > | Number of components of an evaluator when known at compile-time, dynamic_extent otherwise |
| CFunctionResultTypeTraits | Traits that must be specialized to allow functions to return this type |
| CFunctionResultTypeTraits< real & > | Partial specialization for reference to a scalar value |
| CFunctionResultTypeTraits< std::span< real, N > > | Partial specialization for a mutable span |
| CFunctionResultTypeTraits< std::array< real, N > & > | Partial specialization for a reference to a mutable array |
| CFunctionResultQueryImplementation1 | Helper class used to determine the type returned by a function called with an element index, which is an invalid type if the function cannot be called this way |
| CFunctionResultQueryImplementation1< true, FunctionType > | Specialization used when the function can be called this way |
| CFunctionResultQueryImplementation2 | Helper class used to determine the type returned by a function called with an element workspace and an element index, which is an invalid type if the function cannot be called this way |
| CFunctionResultQueryImplementation2< true, FunctionType > | Specialization used when the function can be called this way |
| CFunctionResultQueryImplementation3 | Helper class used to determine the type returned by a function called with a cell index and a quadrature point index, which is an invalid type if the function cannot be called this way |
| CFunctionResultQueryImplementation3< true, FunctionType > | Specialization used when the function can be called this way |
| CFunctionResultQueryImplementation4 | Helper class used to determine the type returned by a function called with a cell workspace, a cell index and a quadrature point index, which is an invalid type if the function cannot be called this way |
| CFunctionResultQueryImplementation4< true, FunctionType > | Specialization used when the function can be called this way |
| CFunctionResultQueryImplementation | Helper class used to determine how a function can be called and the type of the values it returns |
| CFunctionResultQueryImplementation< true, FunctionType > | Specialization used when the function provides a getSpace function |
| CFunctionResultQuery | Alias used to determine how a function can be called and the type of the values it returns |
| CViewResultType | Helper structure used to determine the type of the view of a function which is not its own view |
| CViewResultType< false, FunctionType > | Specialization used when a view is required |
| CNumberOfComponents< FunctionType > | Number of components of a function when known at compile-time, dynamic_extent otherwise |
| Cfixed_size_modifier | Structure used to modify a function or an evaluator so that it returns a fixed number of components |
| CSharedElementSpaceAddElementWorkspace | Helper class used to build the traits of a SharedSpace: this primary template adds no ElementWorkspace type, which is the case when the underlying space does not expose such a type |
| CSharedElementSpaceAddElementWorkspace< true, SpaceType > | Specialization used when the underlying space exposes an ElementWorkspace type: this type is forwarded to the traits of the shared space |
| CSharedElementSpaceTraits | Traits of a SharedSpace whose underlying space does not match the ElementSpaceConcept concept, which are thus empty |
| CSharedElementSpaceTraits< SpaceType > | Specialization used when the underlying space matches the ElementSpaceConcept concept: the index type and the element workspace type of the underlying space are forwarded to the traits of the shared space |
| CSharedLinearElementSpaceTraits | Helper class used to build the traits of a SharedSpace: this primary template adds nothing, as the underlying space does not match the LinearElementSpaceConcept concept |
| CSharedLinearElementSpaceTraits< SpaceType > | Specialization used when the underlying space matches the LinearElementSpaceConcept concept: the elements of the shared space are addressed exactly as those of the underlying space |
| CSharedQuadratureSpaceAddCellWorkspace | Helper class used to build the traits of a SharedSpace: this primary template adds no CellWorkspace type, which is the case when the underlying space does not expose such a type |
| CSharedQuadratureSpaceAddCellWorkspace< true, SpaceType > | Specialization used when the underlying space exposes a CellWorkspace type: this type is forwarded to the traits of the shared space |
| CSharedQuadratureSpaceTraits | Traits of a SharedSpace whose underlying space does not match the QuadratureSpaceConcept concept, which are thus empty |
| CSharedQuadratureSpaceTraits< SpaceType > | Specialization used when the underlying space matches the QuadratureSpaceConcept concept: the index types of the underlying space are forwarded to the traits of the shared space |
| CSharedLinearQuadratureSpaceTraits | Helper class used to build the traits of a SharedSpace: this primary template adds nothing, as the underlying space does not match the LinearQuadratureSpaceConcept concept |
| CSharedLinearQuadratureSpaceTraits< SpaceType > | Specialization used when the underlying space matches the LinearQuadratureSpaceConcept concept: the cells of the shared space are addressed exactly as those of the underlying space |
| CUndefinedTypeSelector | Helper metafunction returning an undefined type, used as fallback when a space does not expose the queried type |
| CElementIndexTypeSelector | Metafunction used to return the element_index_type type alias of SpaceTraits<Space> if it is defined, UndefinedTypeSelector::Undefined otherwise |
| CElementIndexTypeSelector< true, Space > | Specialization used when the space exposes an element_index_type type alias |
| CElementWorkspaceSelector | Metafunction used to return the ElementWorkspace type of SpaceTraits<Space> if it is defined, UndefinedTypeSelector::Undefined otherwise |
| CElementWorkspaceSelector< true, Space > | Specialization used when the space exposes an ElementWorkspace type |
| CCellIndexTypeSelector | Metafunction used to return the cell_index_type type alias of SpaceTraits<Space> if it is defined, UndefinedTypeSelector::Undefined otherwise |
| CCellIndexTypeSelector< true, Space > | Specialization used when the space exposes a cell_index_type type alias |
| CQuadraturePointIndexTypeSelector | Metafunction used to return the quadrature_point_index_type type alias of SpaceTraits<Space> if it is defined, UndefinedTypeSelector::Undefined otherwise |
| CQuadraturePointIndexTypeSelector< true, Space > | Specialization used when the space exposes a quadrature_point_index_type type alias |
| CCellWorkspaceSelector | Metafunction used to return the CellWorkspace type of SpaceTraits<Space> if it is defined, UndefinedTypeSelector::Undefined otherwise |
| CCellWorkspaceSelector< true, Space > | Specialization used when the space exposes a CellWorkspace type |
| CFunctionResultTypeTraits<::tfel::math::CoalescedView< TensorType > > | Partial specialization allowing functions to return a tfel::math::CoalescedView, i.e. a tensorial object whose components are stored in separate contiguous memory regions |
| CIsDataView<::tfel::math::qt_ref< UnitType, ValueType > > | Partial specialisation for tfel::math::qt_ref, a quantity which wraps a mutable reference to a value owned by another object |
| CIsDataView<::tfel::math::const_qt_ref< UnitType, ValueType > > | Partial specialisation for tfel::math::const_qt_ref, a quantity which wraps a read-only reference to a value owned by another object |
| CIsDataView<::tfel::math::View< MappedType, IndexingPolicyType > > | Partial specialisation for tfel::math::View, a view of a mathematical object which may use a non contiguous indexing policy |
| CIsDataView<::tfel::math::CoalescedView< MappedType, IndexingPolicyType > > | Partial specialisation for tfel::math::CoalescedView, a view of a mathematical object whose values are stored in a coalesced memory |
| CHydrostaticStressOperator | Callable object computing the hydrostatic stress, i.e. the mean normal stress, of a symmetric tensor, defined as trace(s) / 3 |
| CVonMisesStressOperator | Callable object computing the von Mises stress of a symmetric tensor interpreted as a stress |
| CFirstPiolaKirchhoffStressToCauchyStressOperator | Callable object converting a first Piola-Kirchhoff stress into a Cauchy stress given the deformation gradient |
| CConvertFiniteStrainStiffnessEvaluator | Evaluator computing a finite strain tangent operator from a tangent operator of another kind, given two deformation gradients and the Cauchy stress |
| CConvertFiniteStrainStiffnessModifierGenerator | Modifier which, applied to an evaluator returning a tangent operator of kind SourceFlag, builds a ConvertFiniteStrainStiffnessEvaluator converting it into a tangent operator of kind ResultFlag |
| CCompileTimeSize<::tfel::math::qt< UnitType, real > > | Specialization for a quantity owning its value, which has one component |
| CCompileTimeSize<::tfel::math::qt_ref< UnitType, real > > | Specialization for a mutable reference to a quantity, which has one component |
| CCompileTimeSize<::tfel::math::const_qt_ref< UnitType, real > > | Specialization for a read-only reference to a quantity, which has one component |
| Cquantity_modifier | Structure used to modify a function or an evaluator so that it returns its values as quantities, i.e. scalar values associated with a physical unit |
| CScalarModifier | Metafunction giving the modifier used to view the values of a function or an evaluator as scalars of type T |
| CScalarModifier< real > | Specialization for real scalars, which have no physical unit |
| CFunctionResultTypeTraits<::tfel::math::qt_ref< UnitType, real > > | Partial specialization allowing functions to return a mutable reference to a quantity, i.e. a qt_ref object of TFEL/Math |
| CFunctionResultTypeTraits< ::tfel::math::StridedCoalescedView< TensorType > > | Partial specialization allowing functions to return a tfel::math::StridedCoalescedView, i.e. a tensorial object whose components are stored contiguously in a single memory region, in a non interleaved manner |
| CCompileTimeSize< tfel::math::fsarray< N, ValueType > > | Partial specialization for finite size arrays |
| CCompileTimeSize< tfel::math::tvector< N, ValueType > > | Partial specialization for tiny vectors |
| CCompileTimeSize< tfel::math::tmatrix< N, M, ValueType > > | Partial specialization for tiny matrices |
| CCompileTimeSize< tfel::math::stensor< N, ValueType > > | Partial specialization for symmetric tensors of dimension N, where N is equal to 1, 2 or 3 |
| CCompileTimeSize< tfel::math::tensor< N, ValueType > > | Partial specialization for tensors of dimension N, where N is equal to 1, 2 or 3 |
| CCompileTimeSize< tfel::math::t2tot2< N, ValueType > > | Partial specialization for fourth order tensors describing a linear mapping from tensors to tensors, of dimension N, where N is equal to 1, 2 or 3 |
| CCompileTimeSize< tfel::math::t2tost2< N, ValueType > > | Partial specialization for fourth order tensors describing a linear mapping from tensors to symmetric tensors, of dimension N, where N is equal to 1, 2 or 3 |
| CCompileTimeSize< tfel::math::st2tot2< N, ValueType > > | Partial specialization for fourth order tensors describing a linear mapping from symmetric tensors to tensors, of dimension N, where N is equal to 1, 2 or 3 |
| CCompileTimeSize< tfel::math::st2tost2< N, ValueType > > | Partial specialization for fourth order tensors describing a linear mapping from symmetric tensors to symmetric tensors, of dimension N, where N is equal to 1, 2 or 3 |
| CCompileTimeSize< tfel::math::View< T > > | Partial specialization for mutable and immutable views |
| CIsTensor | Traits stating if a type may be used as a tensorial object |
| CIsTensor< tfel::math::fsarray< N, ValueType > > | Specialization for finite size arrays |
| CIsTensor< tfel::math::tvector< N, ValueType > > | Specialization for tiny vectors |
| CIsTensor< tfel::math::tmatrix< N, M, ValueType > > | Specialization for tiny matrices |
| CIsTensor< tfel::math::stensor< N, ValueType > > | Specialization for symmetric tensors whose dimension is 1, 2 or 3 |
| CIsTensor< tfel::math::tensor< N, ValueType > > | Specialization for tensors whose dimension is 1, 2 or 3 |
| CIsTensor< tfel::math::t2tot2< N, ValueType > > | Specialization for fourth order tensors mapping tensors to tensors, whose dimension is 1, 2 or 3 |
| CIsTensor< tfel::math::t2tost2< N, ValueType > > | Specialization for fourth order tensors mapping tensors to symmetric tensors, whose dimension is 1, 2 or 3 |
| CIsTensor< tfel::math::st2tot2< N, ValueType > > | Specialization for fourth order tensors mapping symmetric tensors to tensors, whose dimension is 1, 2 or 3 |
| CIsTensor< tfel::math::st2tost2< N, ValueType > > | Specialization for fourth order tensors mapping symmetric tensors to symmetric tensors, whose dimension is 1, 2 or 3 |
| CFunctionResultTypeTraits< TensorType & > | Partial specialization stating that a mutable reference to a tensorial object is a valid result type for a function |
| CFunctionResultTypeTraits< tfel::math::View< TensorType > > | Partial specialization stating that a view on a tensorial object is a valid result type for a function |
| Ctensor_modifier | Modifier exposing the values computed by an evaluator, or the values of a function, as a tensorial object of type TensorType |
| CRotateModifier | Modifier changing the basis of the tensorial values computed by an evaluator, in the direction for which the given rotation matrix is defined |
| CRotateBackwardsModifier | Modifier changing the basis of the tensorial values computed by an evaluator in the backwards direction, i.e. using the transpose of the given rotation matrix |
| CUnaryOperationBase | Helper base class giving the number of components of the values returned by a unary operation applied to an evaluator |
| Cunary_operation_modifier | Modifier building a UnaryOperation from a callable object which is stored in the modifier itself |
| Cunary_operation_modifier2_impl | Modifier building a UnaryOperation2 from a callable object which is not stored in the modifier |
| CAbsoluteValueOperator | Functor returning the absolute value of the values returned by an evaluator, using the customization_points::AbsoluteValue customization point |
| CMaximumComponentOperator | Functor returning the largest component of the values returned by an evaluator, using the customization_points::MaximumComponent customization point |
| CMinimumComponentOperator | Functor returning the smallest component of the values returned by an evaluator, using the customization_points::MinimumComponent customization point |
| Ncustomization_points | |
| CAbsoluteValue< TensorType > | Partial specialization computing the absolute value of a tensorial object component by component |
| CAbsoluteValue< tfel::math::View< const TensorType > > | Partial specialization computing the absolute value of a view on a tensorial object component by component |
| CMaximumComponent< TensorType > | Partial specialization returning the largest component of a tensorial object |
| CMaximumComponent< tfel::math::View< const TensorType > > | Partial specialization returning the largest component of a view on a tensorial object |
| CMinimumComponent< TensorType > | Partial specialization returning the smallest component of a tensorial object |
| CMinimumComponent< tfel::math::View< const TensorType > > | Partial specialization returning the smallest component of a view on a tensorial object |
| CAbsoluteValue | Customization point giving the absolute value of a value which can be returned by an evaluator |
| CAbsoluteValue< real > | Specialization for scalar values |
| CAbsoluteValue< std::span< const real, N > > | Specialization for constant fixed sized spans |
| CAbsoluteValue< std::array< real, N > > | Specialization for fixed sized arrays of scalar values |
| CMaximumComponent | Customization point giving the largest component of a value which can be returned by an evaluator |
| CMaximumComponent< real > | Specialization for scalar values |
| CMaximumComponent< std::span< const real, N > > | Specialization for constant fixed sized spans |
| CMaximumComponent< std::array< real, N > > | Specialization for fixed sized arrays of scalar values |
| CMinimumComponent | Customization point giving the smallest component of a value which can be returned by an evaluator |
| CMinimumComponent< real > | Specialization for scalar values |
| CMinimumComponent< std::span< const real, N > > | Specialization for constant fixed sized spans |
| CMinimumComponent< std::array< real, N > > | Specialization for fixed sized arrays of scalar values |
| CBasicLinearQuadratureSpace | Minimal implementation of a linear quadrature space |
| CDummyCellWorkspace | Empty cell workspace, as the cells of this space do not require any information to be accessed |
| CSpaceTraits< BasicLinearQuadratureSpace< N > > | Traits defining the properties of a BasicLinearQuadratureSpace |
| CBasicLinearSpace | Simplest implementation of a linear space |
| CSpaceTraits< BasicLinearSpace > | Traits defining the properties of a BasicLinearSpace |
| CBinaryOperationModifier | Evaluator applying a binary operation to the values returned by two evaluators |
| CBinaryOperationModifier2 | Evaluator applying a binary operation to the values returned by two evaluators, without storing this operation |
| CBinaryOperationEvaluatorBase | Base class to construct an evaluator by applying a binary operation on the results of two evaluators |
| CCoalescedMemoryAccessFunctionViewBase | Base class for views whose components are stored contiguously in separate memory regions |
| CCUDAExecutionConfiguration | Execution configuration used to launch CUDA's kernels |
| CEvaluatorModifierBase | Base class to construct a new evaluator by applying a modifier to the values returned by an existing evaluator |
| CEvaluatorModifierTag | Small class to specify that a type is a modifier |
| CEvaluatorModifiersGroup | Class meant to group modifiers, allowing modifiers composability |
| CFixedSizeModifier | Evaluator returning the values of a function view as a fixed size span or a scalar |
| CFixedSizeView | Modifier returning the values of a function view as a fixed size span or a scalar |
| CLightweightViewTraits< FixedSizeView< FunctionType, N > > | Specialisation stating that a FixedSizeView is a lightweight view, i.e. that a copy of the view is cheap and can be used to evaluate the function |
| CFunctionDataSize | Class describing the size (number of components) of the data manipulated by a function, when this size is known at compile time |
| CFunctionDataSize< dynamic_extent > | Specialisation of FunctionDataSize used when the number of components of the function is only known at run time |
| CFunctionDataStride | Class describing the stride of the data manipulated by a function, i.e. the distance between the values associated with two successive integration points, when this stride is known at compile time |
| CFunctionDataStride< dynamic_extent > | Specialisation of FunctionDataStride used when the stride is only known at run time |
| CFunctionDataLayoutDescription | Simple data structure describing how the data of a function is mapped in memory, which is used as a non-type template argument |
| CFunctionDataLayout | Simple data structure describing how the data of a function is mapped in memory |
| CFunctionView | Function defined on a space, whose values are stored in an external memory region |
| CLightweightViewTraits< FunctionView< Space, layout, is_mutable > > | Specialisation stating that a FunctionView is a lightweight view, i.e. a function which is its own view: it can be copied at a negligible cost |
| CFunctionStorage | Helper class storing the values of a function in a std::vector |
| CFunction | Default implementation of a function, which owns its values |
| CLightweightViewTraits | Traits defining the functions which are their own view |
| CSharedSpace | This class provides a way to encapsulate a space into a sharable object |
| CSpaceTraits< SharedSpace< SpaceType > > | Specialization of the SpaceTraits class for a shared space: the properties of the underlying space which make sense for a shared space are forwarded by the helpers of the mgis::function::internals namespace |
| CSpaceTraits | Quadrature traits class defining the main properties of a space |
| CStridedCoalescedMemoryAccessFunctionViewBase | Class meant to describe a function, each component of which is stored contiguously in non interleaved manner using the following scheme: |
| CCoalescedMemoryAccessCompositeTensorsViewMutableValue | Traits defining the type used by the CoalescedMemoryAccessCompositeTensorsView class to return a mutable value of the given type |
| CCoalescedMemoryAccessCompositeTensorsViewMutableValue< real > | Specialization for scalar values, which are returned as mutable references to the value of the corresponding component |
| CCoalescedMemoryAccessCompositeTensorsViewConstValue | Traits defining the type used by the CoalescedMemoryAccessCompositeTensorsView class to return a read-only value of the given type |
| CCoalescedMemoryAccessCompositeTensorsViewConstValue< real > | Specialization for scalar values, which are returned as read-only references to the value of the corresponding component |
| CCoalescedMemoryAccessCompositeTensorsView | Coalesced memory access view handling several tensorial objects of possibly different types sharing the same set of components |
| CCoalescedMemoryAccessTensorView | Coalesced memory access view which acts as a function returning TFEL's tensorial objects |
| CLightweightViewTraits< CoalescedMemoryAccessTensorView< Space, TensorType, is_mutable > > | Partial specialisation stating that a CoalescedMemoryAccessTensorView is its own view: it only stores the views of the components, so copying it is cheap |
| CQuantityModifier | Evaluator returning the values computed by an evaluator as quantities |
| CQuantityView | View returning the values of a function as quantities |
| CLightweightViewTraits< QuantityView< FunctionType, UnitType > > | Partial specialisation stating that a QuantityView is its own view: it only stores a view of the underlying function, so copying it is cheap |
| CStridedCoalescedMemoryAccessCompositeTensorsViewMutableValue | Traits defining the type used by the StridedCoalescedMemoryAccessCompositeTensorsView class to return a mutable value of the given type |
| CStridedCoalescedMemoryAccessCompositeTensorsViewMutableValue< real > | Specialization for scalar values, which are returned as mutable references to the value of the corresponding component |
| CStridedCoalescedMemoryAccessCompositeTensorsViewConstValue | Traits defining the type used by the StridedCoalescedMemoryAccessCompositeTensorsView class to return a read-only value of the given type |
| CStridedCoalescedMemoryAccessCompositeTensorsViewConstValue< real > | Specialization for scalar values, which are returned as read-only references to the value of the corresponding component |
| CStridedCoalescedMemoryAccessCompositeTensorsView | Strided coalesced memory access view handling several tensorial objects of possibly different types sharing the same set of components |
| CStridedCoalescedMemoryAccessTensorView | Strided coalesced memory access view which acts as a function returning TFEL's tensorial objects |
| CLightweightViewTraits< StridedCoalescedMemoryAccessTensorView< Space, TensorType, is_mutable > > | Partial specialisation stating that a StridedCoalescedMemoryAccessTensorView is its own view: it only stores the space and a pointer to the first value, so copying it is cheap |
| CTensorialFunction | Default implementation of a function whose values are TFEL's tensorial objects |
| CTensorModifier | Evaluator returning the values computed by an evaluator as TFEL's tensorial objects |
| CTensorView | Evaluator returning the values of a function as TFEL's tensorial objects |
| CLightweightViewTraits< TensorView< FunctionType, TensorType > > | Partial specialisation stating that a TensorView is its own view: it only stores a view of the underlying function, so copying it is cheap |
| CUnaryOperation | Evaluator applying a unary operation to the values returned by another evaluator |
| CUnaryOperation2 | Evaluator applying a unary operation to the values returned by another evaluator, without storing this operation |
| CUniformEvaluator | Class describing a uniform evaluator, i.e. an evaluator which returns the same value at each integration point of a space |
| Ninternal | |
| CInvalidValueTraits | Metafunction returning an invalid value associated with a type |
| COptionalTraits | Metafunction allowing returning a value from an optional-like type or void for boolean values |
| COptionalTraits< bool > | Partial specialisation for boolean values |
| COptionalTraits< std::optional< T > > | Partial specialisation for std::optional values |
| CInvalidValueTraits< bool > | Partial specialisation for boolean values |
| CInvalidValueTraits< std::optional< T > > | Partial specialisation for std::optional |
| CInvalidValueTraits< std::optional< bool > > | Partial specialisation for std::optional<bool> |
| CInvalidValueTraits< std::unique_ptr< T > > | Partial specialisation for std::unique_ptr |
| CInvalidValueTraits< std::shared_ptr< T > > | Partial specialisation for std::shared_ptr |
| CInvalidValueTraits< mgis::OptionalReference< ValueType > > | Partial specialisation for optional references |
| COptionalTraits< OptionalReference< T > > | Partial specialisation for optional reference |
| Nmaterial_property | |
| CMaterialProperty | Structure describing a material property |
| CAbstractErrorHandler | Base class for error handlers This class shall be used as arguments to checkPreconditions methods |
| CContextInitializer | Class that can be used to initialize a context, in particular in a constexpr function |
| CContext | Class used to pass an execution context to most methods of MGIS and gather information (error, logs, profiling) |
| CFailureHandler | |
| CContractViolationHandler | Class used to report a contract violation |
| CPreconditionsCheck | |
| CPreconditionsChecker | |
| CCste | |
| CErrorBacktrace | Structure to keep trace of error messages |
| CInvalidResult | Class convertible to many values used as invalid result |
| CLibrariesManager | Structure in charge of handling libraries and querying MGIS' meta-data |
| CProfilingSection | |
| CProfilingData | |
| CThreadedTaskResultBase | Non-template base class of the ThreadedTaskResult class |
| CThreadedTaskResult | Class standing for the result of a taks |
| CThreadedTaskResult< void > | Partial specialisation for non-returning tasks |
| CThreadPool | Structure handling a fixed-size pool of threads |
| COptionalReference | Class that may contain a reference to a class |
| Nstd | STL namespace |
| Chash<::mgis::OptionalReference< ValueType > > | |
| Cmgis_bv_BehaviourDataView | View on the data associated with an integration point |
| Cmgis_bv_InitialStateView | State of the material at the beginning of the time step |
| Cmgis_bv_StateView | State of the material at the end of the time step |
| Cmgis_mp_OutputStatus | This structure summarizes the exit status of a function conforming to one of the generic material property interface |