classfactory.h

Go to the documentation of this file.

/*
 *
 *                 #####    #####   ######  ######  ###   ###
 *               ##   ##  ##   ##  ##      ##      ## ### ##
 *              ##   ##  ##   ##  ####    ####    ##  #  ##
 *             ##   ##  ##   ##  ##      ##      ##     ##
 *            ##   ##  ##   ##  ##      ##      ##     ##
 *            #####    #####   ##      ######  ##     ##
 *
 *
 *             OOFEM : Object Oriented Finite Element Code
 *
 *               Copyright (C) 1993 - 2013   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 "oofemcfg.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>

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 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 ContactManager;
class ContactDefinition;

#ifdef _GNUC
#define OOFEM_ATTR_UNUSED __attribute__((unused))
#else
#define OOFEM_ATTR_UNUSED 
#endif

// Templates to wrap constructors into functions
template< typename T > Element *elemCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > DofManager *dofmanCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > GeneralBoundaryCondition *bcCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > CrossSection *csCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > Material *matCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > EngngModel *engngCreator(int n, EngngModel *m) { return ( new T(n, m) ); }
template< typename T > Function *funcCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > NonlocalBarrier *nlbCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > ExportModule *exportCreator(int n, EngngModel *e) { return ( new T(n, e) ); }
template< typename T > SparseNonLinearSystemNM *nonlinCreator(Domain *d, EngngModel *m) { return ( new T(d, m) ); }
template< typename T > InitModule *initCreator(int n, EngngModel *e) { return ( new T(n, e) ); }
template< typename T > TopologyDescription *topologyCreator(Domain *d) { return new T(d); }

template< typename T > Dof *dofCreator(DofIDItem dofid, DofManager *dman) { return new T(dman, dofid); }
template< typename T > SparseMtrx *sparseMtrxCreator() { return new T(); }
template< typename T > SparseLinearSystemNM *sparseLinSolCreator(Domain *d, EngngModel *m) { return new T(d, m); }
template< typename T > ErrorEstimator *errEstCreator(int n, Domain *d) { return new T(n, d); }

template< typename T > NodalRecoveryModel *nrmCreator(Domain *d) { return new T(d); }
template< typename T > SparseGeneralEigenValueSystemNM *gesCreator(Domain *d, EngngModel *m) { return new T(d, m); }
template< typename T > MesherInterface *mesherCreator(Domain *d) { return new T(d); }
template< typename T > MaterialMappingAlgorithm *mmaCreator() { return new T(); }


template< typename T > LoadBalancer *loadBalancerCreator(Domain *d) { return new T(d); }
template< typename T > LoadBalancerMonitor *loadMonitorCreator(EngngModel *e) { return new T(e); }

// XFEM stuff
template< typename T > XfemManager *xManCreator(Domain *d) { return new T(d); }
template< typename T > EnrichmentItem *enrichItemCreator(int n, XfemManager *x, Domain *d) { return new T(n, x, d); }
template< typename T > NucleationCriterion *nucleationCritCreator(Domain *d) { return new T(d); }
template< typename T > EnrichmentFunction *enrichFuncCreator(int n, Domain *d) { return new T(n, d); }
template< typename T > EnrichmentDomain *enrichmentDomainCreator() { return new T(); }
template< typename T > BasicGeometry *geometryCreator() { return new T(); }
template< typename T > EnrichmentFront *enrichFrontCreator() { return new T(); }
template< typename T > PropagationLaw *propagationLawCreator() { return new T(); }


template< typename T > FailureCriteria *failureCriteriaCreator(int n, FractureManager *x) { return new T(n, x); }
template< typename T > FailureCriteriaStatus *failureCriteriaCreator(int n, FailureCriteria *x) { return new T(n, x); }

template< typename T > ContactManager *contactManCreator(Domain *d) { return new T(d); }
template< typename T > ContactDefinition *contactDefCreator(ContactManager *cMan) { return new T(cMan); }


#define REGISTER_Element(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerElement(_IFT_ ## class ## _Name, elemCreator< class > );
#define REGISTER_DofManager(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerDofManager(_IFT_ ## class ## _Name, dofmanCreator< class > );
#define REGISTER_BoundaryCondition(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerBoundaryCondition(_IFT_ ## class ## _Name, bcCreator< class > );
#define REGISTER_CrossSection(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerCrossSection(_IFT_ ## class ## _Name, csCreator< class > );
#define REGISTER_Material(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterial(_IFT_ ## class ## _Name, matCreator< class > );
#define REGISTER_Material_Alt(class, altname) static bool __dummy_ ## class ## altname OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterial(#altname, matCreator< class > );
#define REGISTER_EngngModel(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEngngModel(_IFT_ ## class ## _Name, engngCreator< class > );
#define REGISTER_Function(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFunction(_IFT_ ## class ## _Name, funcCreator< class > );
#define REGISTER_NonlocalBarrier(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNonlocalBarrier(_IFT_ ## class ## _Name, nlbCreator< class > );
#define REGISTER_ExportModule(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerExportModule(_IFT_ ## class ## _Name, exportCreator< class > );
#define REGISTER_SparseNonLinearSystemNM(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseNonLinearSystemNM(_IFT_ ## class ## _Name, nonlinCreator< class > );
#define REGISTER_InitModule(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerInitModule(_IFT_ ## class ## _Name, initCreator< class > );
#define REGISTER_TopologyDescription(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerTopologyDescription(_IFT_ ## class ## _Name, topologyCreator< class > );
#define REGISTER_LoadBalancerMonitor(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerLoadBalancerMonitor(_IFT_ ## class ## _Name, loadMonitorCreator< class > );
#define REGISTER_LoadBalancer(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerLoadBalancer(_IFT_ ## class ## _Name, loadBalancerCreator< class > );

// These should be converted to use strings.
#define REGISTER_SparseMtrx(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseMtrx(type, sparseMtrxCreator< class > );
#define REGISTER_SparseLinSolver(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerSparseLinSolver(type, sparseLinSolCreator< class > );
#define REGISTER_ErrorEstimator(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerErrorEstimator(type, errEstCreator< class > );
#define REGISTER_NodalRecoveryModel(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNodalRecoveryModel(type, nrmCreator< class > );
#define REGISTER_GeneralizedEigenValueSolver(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerGeneralizedEigenValueSolver(type, gesCreator< class > );
#define REGISTER_Mesher(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMesherInterface(type, mesherCreator< class > );
#define REGISTER_MaterialMappingAlgorithm(class, type) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerMaterialMappingAlgorithm(type, mmaCreator< class > );

#define REGISTER_XfemManager(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerXfemManager(_IFT_ ## class ## _Name, xManCreator< class > );
#define REGISTER_EnrichmentItem(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentItem(_IFT_ ## class ## _Name, enrichItemCreator< class > );
#define REGISTER_NucleationCriterion(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerNucleationCriterion(_IFT_ ## class ## _Name, nucleationCritCreator< class > );
#define REGISTER_EnrichmentFunction(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentFunction(_IFT_ ## class ## _Name, enrichFuncCreator< class > );
#define REGISTER_EnrichmentDomain(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentDomain(_IFT_ ## class ## _Name, enrichmentDomainCreator< class > );
#define REGISTER_Geometry(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerGeometry(_IFT_ ## class ## _Name, geometryCreator< class > );
#define REGISTER_EnrichmentFront(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerEnrichmentFront(_IFT_ ## class ## _Name, enrichFrontCreator< class > );
#define REGISTER_PropagationLaw(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerPropagationLaw(_IFT_ ## class ## _Name, propagationLawCreator< class > );

#define REGISTER_FailureCriteria(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFailureCriteria(_IFT_ ## class ## _Name, failureCriteriaCreator< class > );
#define REGISTER_FailureCriteriaStatus(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerFailureCriteriaStatus(_IFT_ ## class ## _Name, failureCriteriaCreator< class > );

#define REGISTER_ContactManager(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerContactManager(_IFT_ ## class ## _Name, contactManCreator< class > );
#define REGISTER_ContactDefinition(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerContactDefinition(_IFT_ ## class ## _Name, contactDefCreator< class > );
#define REGISTER_Quasicontinuum(class) static bool __dummy_ ## class OOFEM_ATTR_UNUSED = GiveClassFactory().registerQuasicontinuum(_IFT_ ## class ## _Name, QuasicontinuumCreator< class > );


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

    // XFEM:
    std :: map < std :: string, EnrichmentItem * ( * )(int, XfemManager *, Domain *) > enrichItemList;
    std :: map < std :: string, NucleationCriterion * ( * )(Domain *) > nucleationCritList;
    std :: map < std :: string, EnrichmentFunction * ( * )(int, Domain *) > enrichFuncList;
    std :: map < std :: string, BasicGeometry * ( * )() > geometryList;
    std :: map < std :: string, EnrichmentDomain * ( * )() > enrichmentDomainList;
    std :: map < std :: string, EnrichmentFront * ( * )() > enrichmentFrontList;
    std :: map < std :: string, PropagationLaw * ( * )() > propagationLawList;
    std :: map < std :: string, XfemManager * ( * )(Domain *) > xManList;


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

    std :: map < std :: string, ContactManager * ( * )(Domain *) > contactManList;
    std :: map < std :: string, ContactDefinition * ( * )(ContactManager *) > contactDefList;
    
public:
    ClassFactory();

    Element *createElement(const char *name, int num, Domain *domain);
    bool registerElement( const char *name, Element * ( *creator )( int, Domain * ) );
    DofManager *createDofManager(const char *name, int num, Domain *domain);
    bool registerDofManager( const char *name, DofManager * ( *creator )( int, Domain * ) );
    GeneralBoundaryCondition *createBoundaryCondition(const char *name, int num, Domain *domain);
    bool registerBoundaryCondition( const char *name, GeneralBoundaryCondition * ( *creator )( int, Domain * ) );
    CrossSection *createCrossSection(const char *name, int num, Domain *domain);
    bool registerCrossSection( const char *name, CrossSection * ( *creator )( int, Domain * ) );
    Material *createMaterial(const char *name, int num, Domain *domain);
    bool registerMaterial( const char *name, Material * ( *creator )( int, Domain * ) );
    EngngModel *createEngngModel(const char *name, int num, EngngModel *master);
    bool registerEngngModel( const char *name, EngngModel * ( *creator )( int, EngngModel * ) );
    Function *createFunction(const char *name, int num, Domain *domain);
    bool registerFunction( const char *name, Function * ( *creator )( int, Domain * ) );
    NonlocalBarrier *createNonlocalBarrier(const char *name, int num, Domain *domain);
    bool registerNonlocalBarrier( const char *name, NonlocalBarrier * ( *creator )( int, Domain * ) );
    ExportModule *createExportModule(const char *name, int num, EngngModel *emodel);
    bool registerExportModule( const char *name, ExportModule * ( *creator )( int, EngngModel * ) );
    SparseNonLinearSystemNM *createNonLinearSolver(const char *name, Domain *domain, EngngModel *emodel);
    bool registerSparseNonLinearSystemNM( const char *name, SparseNonLinearSystemNM * ( *creator )( Domain *, EngngModel * ) );
    InitModule *createInitModule(const char *name, int num, EngngModel *emodel);
    bool registerInitModule( const char *name, InitModule * ( *creator )( int, EngngModel * ) );
    InitialCondition *createInitialCondition(const char *name, int num, Domain *d);
    TopologyDescription *createTopology(const char *name, Domain *domain);
    bool registerTopologyDescription( const char *name, TopologyDescription * ( *creator )( Domain * ) );

    SparseMtrx *createSparseMtrx(SparseMtrxType type);
    bool registerSparseMtrx( SparseMtrxType type, SparseMtrx * ( *creator )() );
    Dof *createDof(dofType type, DofIDItem dofid, DofManager *dman);
    SparseLinearSystemNM *createSparseLinSolver(LinSystSolverType st, Domain *d, EngngModel *m);
    bool registerSparseLinSolver( LinSystSolverType type, SparseLinearSystemNM * ( *creator )(Domain *, EngngModel *) );
    ErrorEstimator *createErrorEstimator(ErrorEstimatorType type, int num, Domain *d);
    bool registerErrorEstimator( ErrorEstimatorType type, ErrorEstimator * ( *creator )(int, Domain *) );
    bool registerNodalRecoveryModel( NodalRecoveryModel :: NodalRecoveryModelType name, NodalRecoveryModel * ( *creator )(Domain *) );
    NodalRecoveryModel *createNodalRecoveryModel(NodalRecoveryModel :: NodalRecoveryModelType type, Domain *d);

    // XFEM:
    EnrichmentItem *createEnrichmentItem(const char *name, int num, XfemManager *xm, Domain *domain);
    bool registerEnrichmentItem( const char *name, EnrichmentItem * ( *creator )( int, XfemManager *, Domain * ) );

    NucleationCriterion *createNucleationCriterion(const char *name, Domain *domain);
    bool registerNucleationCriterion( const char *name, NucleationCriterion * ( *creator )( Domain * ) );

    EnrichmentFunction *createEnrichmentFunction(const char *name, int num, Domain *domain);
    bool registerEnrichmentFunction( const char *name, EnrichmentFunction * ( *creator )( int, Domain * ) );

    EnrichmentDomain *createEnrichmentDomain(const char *name);
    bool registerEnrichmentDomain( const char *name, EnrichmentDomain * ( *creator )( ) );

    EnrichmentFront *createEnrichmentFront(const char *name);
    bool registerEnrichmentFront( const char *name, EnrichmentFront * ( *creator )( ) );

    PropagationLaw *createPropagationLaw(const char *name);
    bool registerPropagationLaw( const char *name, PropagationLaw * ( *creator )( ) );

    BasicGeometry *createGeometry(const char *name);
    bool registerGeometry( const char *name, BasicGeometry * ( *creator )( ) );

    XfemManager *createXfemManager(const char *name, Domain *domain);
    bool registerXfemManager( const char *name, XfemManager * ( *creator )( Domain * ) );


    ContactManager *createContactManager(const char *name, Domain *domain);
    bool registerContactManager( const char *name, ContactManager * ( *creator )( Domain * ) );

    ContactDefinition *createContactDefinition(const char *name, ContactManager *cMan);
    bool registerContactDefinition( const char *name, ContactDefinition * ( *creator )( ContactManager * ) );

    // Failure module (in development!)
    FailureCriteria *createFailureCriteria(const char *name, int num, FractureManager *fracManager);
    bool registerFailureCriteria( const char *name, FailureCriteria * ( *creator )( int, FractureManager * ) );

    FailureCriteriaStatus *createFailureCriteriaStatus(const char *name, int num, FailureCriteria *critManager);
    bool registerFailureCriteriaStatus( const char *name, FailureCriteriaStatus * ( *creator )( int, FailureCriteria * ) );

    bool registerGeneralizedEigenValueSolver( GenEigvalSolverType name, SparseGeneralEigenValueSystemNM * ( *creator )(Domain *, EngngModel *) );
    SparseGeneralEigenValueSystemNM *createGeneralizedEigenValueSolver(GenEigvalSolverType name, Domain *d, EngngModel *m);

    IntegrationRule *createIRule(IntegrationRuleType name, int number, Element *e);

    bool registerMaterialMappingAlgorithm( MaterialMappingAlgorithmType name, MaterialMappingAlgorithm * ( *creator )( ) );
    MaterialMappingAlgorithm *createMaterialMappingAlgorithm(MaterialMappingAlgorithmType name);

    bool registerMesherInterface( MeshPackageType name, MesherInterface * ( *creator )( Domain * ) );
    MesherInterface *createMesherInterface(MeshPackageType name, Domain *d);

    LoadBalancerMonitor *createLoadBalancerMonitor(const char *name, EngngModel *e);
    bool registerLoadBalancerMonitor( const char *name, LoadBalancerMonitor * ( *creator )( EngngModel * ) );
    LoadBalancer *createLoadBalancer(const char *name, Domain *d);
    bool registerLoadBalancer( const char *name, LoadBalancer * ( *creator )( Domain * ) );
};

extern ClassFactory &classFactory;

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