OOFEM 3.0
Loading...
Searching...
No Matches
classfactory.h File Reference
#include "oofemenv.h"
#include "sparsemtrxtype.h"
#include "errorestimatortype.h"
#include "doftype.h"
#include "linsystsolvertype.h"
#include "nodalrecoverymodel.h"
#include "integrationrule.h"
#include "geneigvalsolvertype.h"
#include "materialmappingalgorithmtype.h"
#include "meshpackagetype.h"
#include "dofiditem.h"
#include <map>
#include <string>
#include <cstring>
#include <memory>

Go to the source code of this file.

Classes

class  oofem::ClassFactory

Namespaces

namespace  oofem

Macros

#define OOFEM_ATTR_UNUSED

Functions

template<typename B, typename T, typename... V>
std::unique_ptr< B > oofem::CTOR (V... x)
template<typename T>
Dofoofem::dofCreator (DofIDItem dofid, DofManager *dman)

Macros for registering new components. Unique dummy variables must be created as a result (design flaw in C++).

#define REGISTER_Element(class)
#define REGISTER_DofManager(class)
#define REGISTER_BoundaryCondition(class)
#define REGISTER_CrossSection(class)
#define REGISTER_Material(class)
#define REGISTER_Material_Alt(class, altname)
#define REGISTER_EngngModel(class)
#define REGISTER_Function(class)
#define REGISTER_NonlocalBarrier(class)
#define REGISTER_ExportModule(class)
#define REGISTER_SparseNonLinearSystemNM(class)
#define REGISTER_InitModule(class)
#define REGISTER_TopologyDescription(class)
#define REGISTER_LoadBalancerMonitor(class)
#define REGISTER_LoadBalancer(class)
#define REGISTER_Monitor(class)
#define REGISTER_SparseMtrx(class, type)
#define REGISTER_SparseLinSolver(class, type)
#define REGISTER_ErrorEstimator(class, type)
#define REGISTER_NodalRecoveryModel(class, type)
#define REGISTER_GeneralizedEigenValueSolver(class, type)
#define REGISTER_Mesher(class, type)
#define REGISTER_MaterialMappingAlgorithm(class, type)
#define REGISTER_XfemManager(class)
#define REGISTER_EnrichmentItem(class)
#define REGISTER_NucleationCriterion(class)
#define REGISTER_EnrichmentFunction(class)
#define REGISTER_EnrichmentFront(class)
#define REGISTER_PropagationLaw(class)
#define REGISTER_Geometry(class)
#define REGISTER_FailureCriteria(class)
#define REGISTER_FailureCriteriaStatus(class)
#define REGISTER_ContactSurface(class)
#define REGISTER_Field(class)
#define REGISTER_Term(class)
#define REGISTER_Quasicontinuum(class)
#define REGISTER_TimeStepReductionStrategy(class)
ClassFactoryoofem::GiveClassFactory ()

Macro Definition Documentation

◆ OOFEM_ATTR_UNUSED

#define OOFEM_ATTR_UNUSED

Definition at line 111 of file classfactory.h.

◆ REGISTER_BoundaryCondition

#define REGISTER_BoundaryCondition ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerBoundaryCondition(_IFT_ ## class ## _Name, CTOR< GeneralBoundaryCondition, class, int, Domain* > );
#define OOFEM_ATTR_UNUSED
bool registerBoundaryCondition(const char *name, std::unique_ptr< GeneralBoundaryCondition >(*creator)(int, Domain *))

Definition at line 133 of file classfactory.h.

◆ REGISTER_ContactSurface

#define REGISTER_ContactSurface ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerContactSurface(_IFT_ ## class ## _Name, CTOR< ContactSurface, class, int, Domain * >);
bool registerContactSurface(const char *name, std::unique_ptr< ContactSurface >(*creator)(int, Domain *))

Definition at line 169 of file classfactory.h.

◆ REGISTER_CrossSection

#define REGISTER_CrossSection ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerCrossSection(_IFT_ ## class ## _Name, CTOR< CrossSection, class, int, Domain* > );
bool registerCrossSection(const char *name, std::unique_ptr< CrossSection >(*creator)(int, Domain *))

Definition at line 134 of file classfactory.h.

◆ REGISTER_DofManager

#define REGISTER_DofManager ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerDofManager(_IFT_ ## class ## _Name, CTOR< DofManager, class, int, Domain* > );
bool registerDofManager(const char *name, std::unique_ptr< DofManager >(*creator)(int, Domain *))

Definition at line 132 of file classfactory.h.

◆ REGISTER_Element

#define REGISTER_Element ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerElement(_IFT_ ## class ## _Name, CTOR< Element, class, int, Domain* > );
bool registerElement(const char *name, std::unique_ptr< Element >(*creator)(int, Domain *))

Definition at line 131 of file classfactory.h.

◆ REGISTER_EngngModel

#define REGISTER_EngngModel ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEngngModel(_IFT_ ## class ## _Name, CTOR< EngngModel, class, int, EngngModel* > );
bool registerEngngModel(const char *name, std::unique_ptr< EngngModel >(*creator)(int, EngngModel *))

Definition at line 137 of file classfactory.h.

◆ REGISTER_EnrichmentFront

#define REGISTER_EnrichmentFront ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentFront(_IFT_ ## class ## _Name, CTOR< EnrichmentFront, class > );
bool registerEnrichmentFront(const char *name, std::unique_ptr< EnrichmentFront >(*creator)())

Definition at line 162 of file classfactory.h.

◆ REGISTER_EnrichmentFunction

#define REGISTER_EnrichmentFunction ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentFunction(_IFT_ ## class ## _Name, CTOR< EnrichmentFunction, class, int, Domain* > );
bool registerEnrichmentFunction(const char *name, std::unique_ptr< EnrichmentFunction >(*creator)(int, Domain *))

Definition at line 160 of file classfactory.h.

◆ REGISTER_EnrichmentItem

#define REGISTER_EnrichmentItem ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentItem(_IFT_ ## class ## _Name, CTOR< EnrichmentItem, class, int, XfemManager*, Domain* > );
bool registerEnrichmentItem(const char *name, std::unique_ptr< EnrichmentItem >(*creator)(int, XfemManager *, Domain *))

Definition at line 158 of file classfactory.h.

◆ REGISTER_ErrorEstimator

#define REGISTER_ErrorEstimator ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerErrorEstimator(type, CTOR< ErrorEstimator, class, int, Domain* > );
bool registerErrorEstimator(ErrorEstimatorType type, std::unique_ptr< ErrorEstimator >(*creator)(int, Domain *))

Definition at line 151 of file classfactory.h.

◆ REGISTER_ExportModule

#define REGISTER_ExportModule ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerExportModule(_IFT_ ## class ## _Name, CTOR< ExportModule, class, int, EngngModel* > );
bool registerExportModule(const char *name, std::unique_ptr< ExportModule >(*creator)(int, EngngModel *))

Definition at line 140 of file classfactory.h.

◆ REGISTER_FailureCriteria

#define REGISTER_FailureCriteria ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFailureCriteria(_IFT_ ## class ## _Name, CTOR< FailureCriteria, class, int, FractureManager* > );
bool registerFailureCriteria(const char *name, std::unique_ptr< FailureCriteria >(*creator)(int, FractureManager *))

Definition at line 166 of file classfactory.h.

◆ REGISTER_FailureCriteriaStatus

#define REGISTER_FailureCriteriaStatus ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFailureCriteriaStatus(_IFT_ ## class ## _Name, CTOR< FailureCriteriaStatus, class, FailureCriteria* > );
bool registerFailureCriteriaStatus(const char *name, std::unique_ptr< FailureCriteriaStatus >(*creator)(int, FailureCriteria *))

Definition at line 167 of file classfactory.h.

◆ REGISTER_Field

#define REGISTER_Field ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerField(_IFT_ ## class ## _Name, CTOR< Field, class > );
bool registerField(const char *name, std::unique_ptr< Field >(*creator)())

Definition at line 171 of file classfactory.h.

◆ REGISTER_Function

#define REGISTER_Function ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFunction(_IFT_ ## class ## _Name, CTOR< Function, class, int, Domain* > );
bool registerFunction(const char *name, std::unique_ptr< Function >(*creator)(int, Domain *))

Definition at line 138 of file classfactory.h.

◆ REGISTER_GeneralizedEigenValueSolver

#define REGISTER_GeneralizedEigenValueSolver ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerGeneralizedEigenValueSolver(type, CTOR< SparseGeneralEigenValueSystemNM, class, Domain*, EngngModel* > );
bool registerGeneralizedEigenValueSolver(GenEigvalSolverType name, std::unique_ptr< SparseGeneralEigenValueSystemNM >(*creator)(Domain *, EngngModel *))

Definition at line 153 of file classfactory.h.

◆ REGISTER_Geometry

#define REGISTER_Geometry ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerGeometry(_IFT_ ## class ## _Name, CTOR< BasicGeometry, class > );
bool registerGeometry(const char *name, std::unique_ptr< BasicGeometry >(*creator)())

Definition at line 164 of file classfactory.h.

◆ REGISTER_InitModule

#define REGISTER_InitModule ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerInitModule(_IFT_ ## class ## _Name, CTOR< InitModule, class, int, EngngModel* > );
bool registerInitModule(const char *name, std::unique_ptr< InitModule >(*creator)(int, EngngModel *))

Definition at line 142 of file classfactory.h.

◆ REGISTER_LoadBalancer

#define REGISTER_LoadBalancer ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerLoadBalancer(_IFT_ ## class ## _Name, CTOR< LoadBalancer, class, EngngModel* > );
bool registerLoadBalancer(const char *name, std::unique_ptr< LoadBalancer >(*creator)(Domain *))

Definition at line 145 of file classfactory.h.

◆ REGISTER_LoadBalancerMonitor

#define REGISTER_LoadBalancerMonitor ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerLoadBalancerMonitor(_IFT_ ## class ## _Name, CTOR< LoadBalancerMonitor, class, EngngModel* > );
bool registerLoadBalancerMonitor(const char *name, std::unique_ptr< LoadBalancerMonitor >(*creator)(EngngModel *))

Definition at line 144 of file classfactory.h.

◆ REGISTER_Material

#define REGISTER_Material ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterial(_IFT_ ## class ## _Name, CTOR< Material, class, int, Domain* > );
bool registerMaterial(const char *name, std::unique_ptr< Material >(*creator)(int, Domain *))

Definition at line 135 of file classfactory.h.

◆ REGISTER_Material_Alt

#define REGISTER_Material_Alt ( class,
altname )
Value:
static bool __dummy_ ## class ## altname OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterial(#altname, CTOR< Material, class, int, Domain* > );

Definition at line 136 of file classfactory.h.

◆ REGISTER_MaterialMappingAlgorithm

#define REGISTER_MaterialMappingAlgorithm ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterialMappingAlgorithm(type, CTOR< MaterialMappingAlgorithm, class > );
bool registerMaterialMappingAlgorithm(MaterialMappingAlgorithmType name, std::unique_ptr< MaterialMappingAlgorithm >(*creator)())

Definition at line 155 of file classfactory.h.

◆ REGISTER_Mesher

#define REGISTER_Mesher ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMesherInterface(type, CTOR< MesherInterface, class, Domain* > );
bool registerMesherInterface(MeshPackageType name, std::unique_ptr< MesherInterface >(*creator)(Domain *))

Definition at line 154 of file classfactory.h.

◆ REGISTER_Monitor

#define REGISTER_Monitor ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMonitor(_IFT_ ## class ## _Name, CTOR< Monitor, class, int > );
bool registerMonitor(const char *name, std::unique_ptr< Monitor >(*creator)(int))

Definition at line 146 of file classfactory.h.

◆ REGISTER_NodalRecoveryModel

#define REGISTER_NodalRecoveryModel ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNodalRecoveryModel(type, CTOR< NodalRecoveryModel, class, Domain* > );
bool registerNodalRecoveryModel(NodalRecoveryModel ::NodalRecoveryModelType name, std::unique_ptr< NodalRecoveryModel >(*creator)(Domain *))

Definition at line 152 of file classfactory.h.

◆ REGISTER_NonlocalBarrier

#define REGISTER_NonlocalBarrier ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNonlocalBarrier(_IFT_ ## class ## _Name, CTOR< NonlocalBarrier, class, int, Domain* > );
bool registerNonlocalBarrier(const char *name, std::unique_ptr< NonlocalBarrier >(*creator)(int, Domain *))

Definition at line 139 of file classfactory.h.

◆ REGISTER_NucleationCriterion

#define REGISTER_NucleationCriterion ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNucleationCriterion(_IFT_ ## class ## _Name, CTOR< NucleationCriterion, class, Domain* > );
bool registerNucleationCriterion(const char *name, std::unique_ptr< NucleationCriterion >(*creator)(Domain *))

Definition at line 159 of file classfactory.h.

◆ REGISTER_PropagationLaw

#define REGISTER_PropagationLaw ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerPropagationLaw(_IFT_ ## class ## _Name, CTOR< PropagationLaw, class > );
bool registerPropagationLaw(const char *name, std::unique_ptr< PropagationLaw >(*creator)())

Definition at line 163 of file classfactory.h.

◆ REGISTER_Quasicontinuum

#define REGISTER_Quasicontinuum ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerQuasicontinuum(_IFT_ ## class ## _Name, < QuasiContinuum, class, ????? > );
Todo
What is this? Doesn't seem needed / Mikael

Definition at line 176 of file classfactory.h.

◆ REGISTER_SparseLinSolver

#define REGISTER_SparseLinSolver ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseLinSolver(type, CTOR< SparseLinearSystemNM, class, Domain*, EngngModel* > );
bool registerSparseLinSolver(LinSystSolverType type, std::unique_ptr< SparseLinearSystemNM >(*creator)(Domain *, EngngModel *))

Definition at line 150 of file classfactory.h.

◆ REGISTER_SparseMtrx

#define REGISTER_SparseMtrx ( class,
type )
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseMtrx(type, CTOR< SparseMtrx, class > );
bool registerSparseMtrx(SparseMtrxType type, std::unique_ptr< SparseMtrx >(*creator)(void))

Definition at line 149 of file classfactory.h.

◆ REGISTER_SparseNonLinearSystemNM

#define REGISTER_SparseNonLinearSystemNM ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseNonLinearSystemNM(_IFT_ ## class ## _Name, CTOR< SparseNonLinearSystemNM, class, Domain*, EngngModel* > );
bool registerSparseNonLinearSystemNM(const char *name, std::unique_ptr< SparseNonLinearSystemNM >(*creator)(Domain *, EngngModel *))

Definition at line 141 of file classfactory.h.

◆ REGISTER_Term

#define REGISTER_Term ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTerm(_IFT_ ## class ## _Name, CTOR< Term, class > );
bool registerTerm(const char *name, std::unique_ptr< Term >(*creator)())

Definition at line 173 of file classfactory.h.

◆ REGISTER_TimeStepReductionStrategy

#define REGISTER_TimeStepReductionStrategy ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTimeStepReductionStrategy(_IFT_ ## class ## _Name, CTOR< TimeStepReductionStrategy, class, int > );
bool registerTimeStepReductionStrategy(const char *name, std::unique_ptr< TimeStepReductionStrategy >(*creator)(int))

Definition at line 179 of file classfactory.h.

◆ REGISTER_TopologyDescription

#define REGISTER_TopologyDescription ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTopologyDescription(_IFT_ ## class ## _Name, CTOR< TopologyDescription, class, Domain* > );
bool registerTopologyDescription(const char *name, std::unique_ptr< TopologyDescription >(*creator)(Domain *))

Definition at line 143 of file classfactory.h.

◆ REGISTER_XfemManager

#define REGISTER_XfemManager ( class)
Value:
static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerXfemManager(_IFT_ ## class ## _Name, CTOR< XfemManager, class, Domain* > );
bool registerXfemManager(const char *name, std::unique_ptr< XfemManager >(*creator)(Domain *))

Definition at line 157 of file classfactory.h.


This page is part of the OOFEM-3.0 documentation. Copyright Copyright (C) 1994-2025 Borek Patzak Bořek Patzák
Project e-mail: oofem@fsv.cvut.cz
Generated at for OOFEM by doxygen 1.15.0 written by Dimitri van Heesch, © 1997-2011