classfactory.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2025   Borek Patzak
 *
 *
 *
 *       Czech Technical University, Faculty of Civil Engineering,
 *   Department of Structural Mechanics, 166 29 Prague, Czech Republic
 *
 *  This library is free software; you can redistribute it and/or
 *  modify it under the terms of the GNU Lesser General Public
 *  License as published by the Free Software Foundation; either
 *  version 2.1 of the License, or (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 *  Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public
 *  License along with this library; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef classfactory_h
#define classfactory_h
 
#include "oofemenv.h"
#include "sparsemtrxtype.h"
#include "errorestimatortype.h"
#include "doftype.h"
#include "linsystsolvertype.h"
//#include "patch.h" // for PatchType
#include "nodalrecoverymodel.h" // for NodalRecoveryModelType
#include "integrationrule.h" // for IntegrationRuleType
#include "geneigvalsolvertype.h"
#include "materialmappingalgorithmtype.h"
#include "meshpackagetype.h"
#include "dofiditem.h"
 
#include <map>
#include <string>
#include <cstring>
#include <memory>
 
namespace oofem {
class Domain;
class EngngModel;
class Element;
class DofManager;
class GeneralBoundaryCondition;
class CrossSection;
class Material;
class Function;
class NonlocalBarrier;
class ExportModule;
class SparseNonLinearSystemNM;
class InitModule;
class TopologyDescription;
class Monitor;
class Field;
 
class Dof;
class SparseMtrx;
class SparseLinearSystemNM;
class ErrorEstimator;
class InitialCondition;
class Patch;
class NodalRecoveryModel;
class SparseGeneralEigenValueSystemNM;
class IntegrationRule;
class MaterialMappingAlgorithm;
class MesherInterface;
 
class LoadBalancerMonitor;
class LoadBalancer;
 
class XfemManager;
class EnrichmentItem;
class NucleationCriterion;
class EnrichmentFunction;
class EnrichmentDomain;
class BasicGeometry;
class EnrichmentFront;
class PropagationLaw;
 
class FractureManager;
class FailureCriteriaStatus;
class FailureCriteria;
 
class ContactSurface;
 
class TimeStepReductionStrategy;
 
  
class Term;
 
#ifdef _GNUC
#define OOFEM_ATTR_UNUSED __attribute__((unused))
#else
#define OOFEM_ATTR_UNUSED 
#endif
 
// Templates to wrap constructors into functions
 
// Wraps any ctor into 

template< typename B, typename T, typename... V > std::unique_ptr<B> CTOR(V... x) { return std::make_unique<T>(x...); }
 
template< typename T > Dof *dofCreator(DofIDItem dofid, DofManager *dman) { return new T(dman, dofid); }


#define REGISTER_Element(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerElement(_IFT_ ## class ## _Name, CTOR< Element, class, int, Domain* > );
#define REGISTER_DofManager(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerDofManager(_IFT_ ## class ## _Name, CTOR< DofManager, class, int, Domain* > );
#define REGISTER_BoundaryCondition(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerBoundaryCondition(_IFT_ ## class ## _Name, CTOR< GeneralBoundaryCondition, class, int, Domain* > );
#define REGISTER_CrossSection(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerCrossSection(_IFT_ ## class ## _Name, CTOR< CrossSection, class, int, Domain* > );
#define REGISTER_Material(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterial(_IFT_ ## class ## _Name, CTOR< Material, class, int, Domain* > );
#define REGISTER_Material_Alt(class, altname) static bool __dummy_ ## class ## altname OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterial(#altname, CTOR< Material, class, int, Domain* > );
#define REGISTER_EngngModel(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEngngModel(_IFT_ ## class ## _Name, CTOR< EngngModel, class, int, EngngModel* > );
#define REGISTER_Function(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFunction(_IFT_ ## class ## _Name, CTOR< Function, class, int, Domain* > );
#define REGISTER_NonlocalBarrier(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNonlocalBarrier(_IFT_ ## class ## _Name, CTOR< NonlocalBarrier, class, int, Domain* > );
#define REGISTER_ExportModule(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerExportModule(_IFT_ ## class ## _Name, CTOR< ExportModule, class, int, EngngModel* > );
#define REGISTER_SparseNonLinearSystemNM(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseNonLinearSystemNM(_IFT_ ## class ## _Name, CTOR< SparseNonLinearSystemNM, class, Domain*, EngngModel* > );
#define REGISTER_InitModule(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerInitModule(_IFT_ ## class ## _Name, CTOR< InitModule, class, int, EngngModel* > );
#define REGISTER_TopologyDescription(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTopologyDescription(_IFT_ ## class ## _Name, CTOR< TopologyDescription, class, Domain* > );
#define REGISTER_LoadBalancerMonitor(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerLoadBalancerMonitor(_IFT_ ## class ## _Name, CTOR< LoadBalancerMonitor, class, EngngModel* > );
#define REGISTER_LoadBalancer(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerLoadBalancer(_IFT_ ## class ## _Name, CTOR< LoadBalancer, class, EngngModel* > );
#define REGISTER_Monitor(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMonitor(_IFT_ ## class ## _Name, CTOR< Monitor, class, int > );
 
// These should be converted to use strings.
#define REGISTER_SparseMtrx(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseMtrx(type, CTOR< SparseMtrx, class > );
#define REGISTER_SparseLinSolver(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseLinSolver(type, CTOR< SparseLinearSystemNM, class, Domain*, EngngModel* > );
#define REGISTER_ErrorEstimator(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerErrorEstimator(type, CTOR< ErrorEstimator, class, int, Domain* > );
#define REGISTER_NodalRecoveryModel(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNodalRecoveryModel(type, CTOR< NodalRecoveryModel, class, Domain* > );
#define REGISTER_GeneralizedEigenValueSolver(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerGeneralizedEigenValueSolver(type, CTOR< SparseGeneralEigenValueSystemNM, class, Domain*, EngngModel* > );
#define REGISTER_Mesher(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMesherInterface(type, CTOR< MesherInterface, class, Domain* > );
#define REGISTER_MaterialMappingAlgorithm(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterialMappingAlgorithm(type, CTOR< MaterialMappingAlgorithm, class > );
 
#define REGISTER_XfemManager(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerXfemManager(_IFT_ ## class ## _Name, CTOR< XfemManager, class, Domain* > );
#define REGISTER_EnrichmentItem(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentItem(_IFT_ ## class ## _Name, CTOR< EnrichmentItem, class, int, XfemManager*, Domain* > );
#define REGISTER_NucleationCriterion(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNucleationCriterion(_IFT_ ## class ## _Name, CTOR< NucleationCriterion, class, Domain* > );
#define REGISTER_EnrichmentFunction(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentFunction(_IFT_ ## class ## _Name, CTOR< EnrichmentFunction, class, int, Domain* > );
//#define REGISTER_EnrichmentDomain(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentDomain(_IFT_ ## class ## _Name, CTOR< EnrichmentDomain, class > );
#define REGISTER_EnrichmentFront(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentFront(_IFT_ ## class ## _Name, CTOR< EnrichmentFront, class > );
#define REGISTER_PropagationLaw(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerPropagationLaw(_IFT_ ## class ## _Name, CTOR< PropagationLaw, class > );
#define REGISTER_Geometry(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerGeometry(_IFT_ ## class ## _Name, CTOR< BasicGeometry, class > );
 
#define REGISTER_FailureCriteria(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFailureCriteria(_IFT_ ## class ## _Name, CTOR< FailureCriteria, class, int, FractureManager* > );
#define REGISTER_FailureCriteriaStatus(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFailureCriteriaStatus(_IFT_ ## class ## _Name, CTOR< FailureCriteriaStatus, class, FailureCriteria* > );
 
#define REGISTER_ContactSurface(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerContactSurface(_IFT_ ## class ## _Name, CTOR< ContactSurface, class, int, Domain * >);
 
#define REGISTER_Field(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerField(_IFT_ ## class ## _Name, CTOR< Field, class > );
// mpm stuff
#define REGISTER_Term(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTerm(_IFT_ ## class ## _Name, CTOR< Term, class > );

#define REGISTER_Quasicontinuum(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerQuasicontinuum(_IFT_ ## class ## _Name, < QuasiContinuum, class, ????? > );
 
 
#define REGISTER_TimeStepReductionStrategy(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTimeStepReductionStrategy(_IFT_ ## class ## _Name, CTOR< TimeStepReductionStrategy, class, int > );


class OOFEM_EXPORT ClassFactory
{
private:
    std :: map < std :: string, std::unique_ptr<Element> ( * )(int, Domain *) > elemList;
    std :: map < std :: string, std::unique_ptr<DofManager> ( * )(int, Domain *) > dofmanList;
    std :: map < std :: string, std::unique_ptr<GeneralBoundaryCondition> ( * )(int, Domain *) > bcList;
    std :: map < std :: string, std::unique_ptr<CrossSection> ( * )(int, Domain *) > csList;
    std :: map < std :: string, std::unique_ptr<Material> ( * )(int, Domain *) > matList;
    std :: map < std :: string, std::unique_ptr<EngngModel> ( * )(int, EngngModel *) > engngList;
    std :: map < std :: string, std::unique_ptr<Function> ( * )(int, Domain *) > funcList;
    std :: map < std :: string, std::unique_ptr<NonlocalBarrier> ( * )(int, Domain *) > nlbList;
    std :: map < std :: string, std::unique_ptr<ExportModule> ( * )(int, EngngModel *) > exportList;
    std :: map < std :: string, std::unique_ptr<Monitor> ( * )(int) > monitorList;
    std :: map < std :: string, std::unique_ptr<SparseNonLinearSystemNM> ( * )(Domain *, EngngModel *) > nonlinList;
    std :: map < std :: string, std::unique_ptr<InitModule> ( * )(int, EngngModel *) > initList;
    std :: map < std :: string, std::unique_ptr<TopologyDescription> ( * )(Domain *) > topologyList;
    // Internal structures (accessed by hard-coded enum values)
    std :: map < std :: string, std::unique_ptr<LoadBalancer> ( * )(Domain *) > loadBalancerList;
    std :: map < std :: string, std::unique_ptr<LoadBalancerMonitor> ( * )(EngngModel *) > loadMonitorList;
    std :: map < SparseMtrxType, std::unique_ptr<SparseMtrx> ( * )() > sparseMtrxList;
    std :: map < dofType, Dof * ( * )(DofIDItem, DofManager *) > dofList;
    std :: map < ErrorEstimatorType, std::unique_ptr<ErrorEstimator> ( * )(int, Domain *) > errEstList;
    std :: map < LinSystSolverType, std::unique_ptr<SparseLinearSystemNM> ( * )(Domain *, EngngModel *) > sparseLinSolList;
    std :: map < NodalRecoveryModel :: NodalRecoveryModelType, std::unique_ptr<NodalRecoveryModel> ( * )(Domain *) > nodalRecoveryModelList;
    std :: map < GenEigvalSolverType, std::unique_ptr<SparseGeneralEigenValueSystemNM> ( * )(Domain *, EngngModel *) > generalizedEigenValueSolverList;
    std :: map < MaterialMappingAlgorithmType, std::unique_ptr<MaterialMappingAlgorithm> ( * )() > materialMappingList;
    std :: map < MeshPackageType, std::unique_ptr<MesherInterface> ( * )(Domain *) > mesherInterfaceList;
 
    // XFEM:
    std :: map < std :: string, std::unique_ptr<EnrichmentItem> ( * )(int, XfemManager *, Domain *) > enrichItemList;
    std :: map < std :: string, std::unique_ptr<NucleationCriterion> ( * )(Domain *) > nucleationCritList;
    std :: map < std :: string, std::unique_ptr<EnrichmentFunction> ( * )(int, Domain *) > enrichFuncList;
    std :: map < std :: string, std::unique_ptr<BasicGeometry> ( * )() > geometryList;
    std :: map < std :: string, std::unique_ptr<EnrichmentDomain> ( * )() > enrichmentDomainList;
    std :: map < std :: string, std::unique_ptr<EnrichmentFront> ( * )() > enrichmentFrontList;
    std :: map < std :: string, std::unique_ptr<PropagationLaw> ( * )() > propagationLawList;
    std :: map < std :: string, std::unique_ptr<XfemManager> ( * )(Domain *) > xManList;
 

    std :: map < std :: string, std::unique_ptr<FailureCriteria> ( * )(int, FractureManager *) > failureCriteriaList;
    std :: map < std :: string, std::unique_ptr<FailureCriteriaStatus> ( * )(int, FailureCriteria *) > failureCriteriaStatusList;
 
    std :: map < std :: string, std::unique_ptr<TimeStepReductionStrategy> ( * )(int) > timeStepReductionStrategyList;

    std::map< std::string, std::unique_ptr< ContactSurface >( * )( int, Domain * ) >contactSurfaceList;

    std :: map < std :: string, std::unique_ptr<Field> ( * )() > fieldList; 

    std :: map < std :: string, std::unique_ptr<Term> ( * )() > termList;
 
public:
    ClassFactory();
 
    std::map<std::string,std::list<std::string>> getRegisteredNames();

    std::unique_ptr<Element> createElement(const char *name, int num, Domain *domain);
    bool registerElement( const char *name, std::unique_ptr<Element> ( *creator )( int, Domain * ) );
    std::unique_ptr<DofManager> createDofManager(const char *name, int num, Domain *domain);
    bool registerDofManager( const char *name, std::unique_ptr<DofManager> ( *creator )( int, Domain * ) );
    std::unique_ptr<GeneralBoundaryCondition> createBoundaryCondition(const char *name, int num, Domain *domain);
    bool registerBoundaryCondition( const char *name, std::unique_ptr<GeneralBoundaryCondition> ( *creator )( int, Domain * ) );
    std::unique_ptr<CrossSection> createCrossSection(const char *name, int num, Domain *domain);
    bool registerCrossSection( const char *name, std::unique_ptr<CrossSection> ( *creator )( int, Domain * ) );
    std::unique_ptr<Material> createMaterial(const char *name, int num, Domain *domain);
    bool registerMaterial( const char *name, std::unique_ptr<Material> ( *creator )( int, Domain * ) );
    std::unique_ptr<EngngModel> createEngngModel(const char *name, int num, EngngModel *master);
    bool registerEngngModel( const char *name, std::unique_ptr<EngngModel> ( *creator )( int, EngngModel * ) );
    std::unique_ptr<Function> createFunction(const char *name, int num, Domain *domain);
    bool registerFunction( const char *name, std::unique_ptr<Function> ( *creator )( int, Domain * ) );
    std::unique_ptr<NonlocalBarrier> createNonlocalBarrier(const char *name, int num, Domain *domain);
    bool registerNonlocalBarrier( const char *name, std::unique_ptr<NonlocalBarrier> ( *creator )( int, Domain * ) );
    std::unique_ptr<ExportModule> createExportModule(const char *name, int num, EngngModel *emodel);
    bool registerExportModule( const char *name, std::unique_ptr<ExportModule> ( *creator )( int, EngngModel * ) );
    std::unique_ptr<Monitor> createMonitor(const char *name, int num);
    bool registerMonitor( const char *name, std::unique_ptr<Monitor> ( *creator )( int ) );

    std::unique_ptr<SparseNonLinearSystemNM> createNonLinearSolver(const char *name, Domain *domain, EngngModel *emodel);
    bool registerSparseNonLinearSystemNM( const char *name, std::unique_ptr<SparseNonLinearSystemNM> ( *creator )( Domain *, EngngModel * ) );
    std::unique_ptr<InitModule> createInitModule(const char *name, int num, EngngModel *emodel);
    bool registerInitModule( const char *name, std::unique_ptr<InitModule> ( *creator )( int, EngngModel * ) );
    std::unique_ptr<InitialCondition> createInitialCondition(const char *name, int num, Domain *d);
    std::unique_ptr<TopologyDescription> createTopology(const char *name, Domain *domain);
    bool registerTopologyDescription( const char *name, std::unique_ptr<TopologyDescription> ( *creator )( Domain * ) );

    std::unique_ptr<SparseMtrx> createSparseMtrx(SparseMtrxType type);
    bool registerSparseMtrx( SparseMtrxType type, std::unique_ptr<SparseMtrx> ( *creator )(void) );
    Dof *createDof(dofType type, DofIDItem dofid, DofManager *dman);
    std::unique_ptr<SparseLinearSystemNM> createSparseLinSolver(LinSystSolverType st, Domain *d, EngngModel *m);
    bool registerSparseLinSolver( LinSystSolverType type, std::unique_ptr<SparseLinearSystemNM> ( *creator )(Domain *, EngngModel *) );
    std::unique_ptr<ErrorEstimator> createErrorEstimator(ErrorEstimatorType type, int num, Domain *d);
    bool registerErrorEstimator( ErrorEstimatorType type, std::unique_ptr<ErrorEstimator> ( *creator )(int, Domain *) );
    bool registerNodalRecoveryModel( NodalRecoveryModel :: NodalRecoveryModelType name, std::unique_ptr<NodalRecoveryModel> ( *creator )(Domain *) );
    std::unique_ptr<NodalRecoveryModel> createNodalRecoveryModel(NodalRecoveryModel :: NodalRecoveryModelType type, Domain *d);
 
    // XFEM:
    std::unique_ptr<EnrichmentItem> createEnrichmentItem(const char *name, int num, XfemManager *xm, Domain *domain);
    bool registerEnrichmentItem( const char *name, std::unique_ptr<EnrichmentItem> ( *creator )( int, XfemManager *, Domain * ) );
 
    std::unique_ptr<NucleationCriterion> createNucleationCriterion(const char *name, Domain *domain);
    bool registerNucleationCriterion( const char *name, std::unique_ptr<NucleationCriterion> ( *creator )( Domain * ) );
 
    std::unique_ptr<EnrichmentFunction> createEnrichmentFunction(const char *name, int num, Domain *domain);
    bool registerEnrichmentFunction( const char *name, std::unique_ptr<EnrichmentFunction> ( *creator )( int, Domain * ) );
 
#if 0
    std::unique_ptr<EnrichmentDomain> createEnrichmentDomain(const char *name);
    bool registerEnrichmentDomain( const char *name, std::unique_ptr<EnrichmentDomain> ( *creator )( ) );
#endif
 
    std::unique_ptr<EnrichmentFront> createEnrichmentFront(const char *name);
    bool registerEnrichmentFront( const char *name, std::unique_ptr<EnrichmentFront> ( *creator )( ) );
 
    std::unique_ptr<PropagationLaw> createPropagationLaw(const char *name);
    bool registerPropagationLaw( const char *name, std::unique_ptr<PropagationLaw> ( *creator )( ) );
 
    std::unique_ptr<BasicGeometry> createGeometry(const char *name);
    bool registerGeometry( const char *name, std::unique_ptr<BasicGeometry> ( *creator )( ) );
 
    std::unique_ptr<XfemManager> createXfemManager(const char *name, Domain *domain);
    bool registerXfemManager( const char *name, std::unique_ptr<XfemManager> ( *creator )( Domain * ) );
 
    std::unique_ptr< ContactSurface >createContactSurface(const char *name, int num, Domain *domain);
    bool registerContactSurface(const char *name, std::unique_ptr< ContactSurface >( * creator )(int, Domain *) );
 
    // MPM stuff
    std::unique_ptr<Term> createTerm(const char *name);
    bool registerTerm( const char *name, std::unique_ptr<Term> ( *creator )( ) );
 
    // Failure module (in development!)
    std::unique_ptr<FailureCriteria> createFailureCriteria(const char *name, int num, FractureManager *fracManager);
    bool registerFailureCriteria( const char *name, std::unique_ptr<FailureCriteria> ( *creator )( int, FractureManager * ) );
 
    std::unique_ptr<FailureCriteriaStatus> createFailureCriteriaStatus(const char *name, int num, FailureCriteria *critManager);
    bool registerFailureCriteriaStatus( const char *name, std::unique_ptr<FailureCriteriaStatus> ( *creator )( int, FailureCriteria * ) );
 
    std::unique_ptr<SparseGeneralEigenValueSystemNM> createGeneralizedEigenValueSolver(GenEigvalSolverType name, Domain *d, EngngModel *m);
    bool registerGeneralizedEigenValueSolver( GenEigvalSolverType name, std::unique_ptr<SparseGeneralEigenValueSystemNM> ( *creator )(Domain *, EngngModel *) );
 
    std::unique_ptr<IntegrationRule> createIRule(IntegrationRuleType name, int number, Element *e);
 
    std::unique_ptr<MaterialMappingAlgorithm> createMaterialMappingAlgorithm(MaterialMappingAlgorithmType name);
    bool registerMaterialMappingAlgorithm( MaterialMappingAlgorithmType name, std::unique_ptr<MaterialMappingAlgorithm> ( *creator )( ) );
 
    std::unique_ptr<MesherInterface> createMesherInterface(MeshPackageType name, Domain *d);
    bool registerMesherInterface( MeshPackageType name, std::unique_ptr<MesherInterface> ( *creator )( Domain * ) );
 
    std::unique_ptr<LoadBalancerMonitor> createLoadBalancerMonitor(const char *name, EngngModel *e);
    bool registerLoadBalancerMonitor( const char *name, std::unique_ptr<LoadBalancerMonitor> ( *creator )( EngngModel * ) );
 
    std::unique_ptr<LoadBalancer> createLoadBalancer(const char *name, Domain *d);
    bool registerLoadBalancer( const char *name, std::unique_ptr<LoadBalancer> ( *creator )( Domain * ) );
 
 
    std::unique_ptr<TimeStepReductionStrategy> createTimeStepReductionStrategy(const char *name, int number);
    
    bool registerTimeStepReductionStrategy( const char *name, std::unique_ptr<TimeStepReductionStrategy> ( *creator )( int ) );
 
    
 
    std::unique_ptr<Field> createField(const char *name);
    bool registerField( const char *name, std::unique_ptr<Field> ( *creator )() );
};
 
extern OOFEM_EXPORT ClassFactory &classFactory;

OOFEM_EXPORT ClassFactory &GiveClassFactory();
} // end namespace oofem
#endif // clasfactort_h