gmpMechanicalFemPhysicsFactory.h

Go to the documentation of this file.

/************************************************************************
**
** Copyright (C) 2014 by Carlos Augusto Teixera Mendes
** All rights reserved.
**
** This file is part of the "GeMA" software. It's use should respect
** the terms in the license agreement that can be found together
** with this source code.
** It is provided AS IS, with NO WARRANTY OF ANY KIND,
** INCLUDING THE WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR
** A PARTICULAR PURPOSE.
**
************************************************************************/

#ifndef _GEMA_PLUGIN_MECHANICAL_FEM_PHYSICS_FACTORY_H_
#define _GEMA_PLUGIN_MECHANICAL_FEM_PHYSICS_FACTORY_H_

#include <QObject>

#include <gmPluginObjectFactory.h>
#include "gmpMechanicalLargeDisplacementSolid.h"
#include "gmpMechanicalReinforcedInterface.h"
#include "gmpMechanicLargeDisplacement.h"
#include "gmpMechanicalPhysics.h"
#include "gmpMechanicalInterface.h"
#include "gmpMechanicalComposite.h"
#include "gmpMechanicalSolid.h"
#include "gmpInterface.h"
#include "gmpMechanic.h"
#include "gmpBar.h"

#include "gmpMechanicalVersion.h"

#include "gmpMaterialCohesiveExponentialSoftening.h"
#include "gmpMaterialCohesivePotentialSoftening.h"
#include "gmpMaterialCohesiveLinearSoftening.h"
#include "gmpMaterialInterfaceMohrCoulomb.h"
#include "gmpFemPhysicsCommonMaterial.h"
#include "gmpMaterialElasticInterface.h"
#include "gmpMaterialIsotropicDamage.h"
#include "gmpMaterialEquivalentContinuum.h"
#include "gmpMaterialElastic.h"
#include "gmpMaterialPorousElastic.h"
#include "gmpMaterialModifMohrCoulomb.h"
#include "gmpMaterialCrackingCrushingDamage.h"
#include "gmpMaterialCrackingCrushingPlasticDamage.h"
#include "gmpMaterialModifiedCamClay.h"
#include "gmpMaterialCapMohrCoulomb.h"
#include "gmpMaterialMohrCoulomb.h"
#include "gmpMaterialBreslerPister.h"
#include "gmpMaterialDruckerPrager.h"
#include "gmpMaterialVonMises.h"
#include "gmpMaterialDMCreep.h"
#include "gmpMaterialExtendedDruckerPrager.h"
#include "gmpMaterialCapModel.h"
#include "gmpMaterialMACreep.h"
#include "gmpMaterialMDCreep.h"
#include "gmpMaterialEDMTCreep.h"
#include "gmpMaterialDPCreep.h"
#include "gmpMaterialFluid.h"
#include "gmpMaterialPowerLawCreep.h"
#include "gmpMaterialSolidifyingKelvinChain.h"
#include "gmpMaterialGeneralYieldSurface.h"
#include "gmpMaterialWDCreep.h"
#include "gmpMaterialWDTCreep.h"
#include "gmpMaterialLadeKim.h"
#include "gmpMaterialCapGeneralYieldSurface.h"
#include "gmpMaterialHyperelastic.h"
#include "gmpMaterialHencky.h"
#include "gmpMaterialOneDimPlasticity.h"
#include "gmpMaterialFiberStrainHardening.h"
#include "gmpMaterialLua.h"
#include "gmpSpring.h"
#include "gmpMechanicalEmbeddedFracture.h"

#include <gmSimulationData.h>
#include <gmPluginLoader.h>
#include <gmPluginInfo.h>


class GmpMechanicalPhysicsFactory : public QObject, GmPluginObjectFactory
{
        Q_OBJECT
        Q_PLUGIN_METADATA(IID GmPluginObjectFactoryInterfaceIID)
  Q_INTERFACES(GmPluginObjectFactory)

public:
  GmpMechanicalPhysicsFactory() : GmPluginObjectFactory("MechanicalFemPhysics") {}

  const GmpFemPhysicsCommonMaterialFactory* matFactory(GmSimulationData* simulation)
  {
    static GmpFemPhysicsCommonMaterialFactory matFactory;

    // If this is the first time that instance() is called, lets register material types
    if(matFactory.numMaterialTypes() == 0)
    {
      const GmPluginInfo* ourInfo = simulation->loader()->pluginInfo("MechanicalFemPhysics");
      assert(ourInfo);
      const QVariantMap& map = ourInfo->attributes().value("constants").value<QVariantMap>().value("materialModels").value<QVariantMap>();

      matFactory.registerMaterial(map.value("elastic").toInt(), "elastic", GmpMechanicalMaterialElastic::instance, true);
      matFactory.registerMaterial(map.value("isotropicDamage").toInt(), "isotropicDamage", GmpMaterialIsotropicDamage::instance);
      matFactory.registerMaterial(map.value("elasticInterface").toInt(), "elasticInterface", GmpElasticInterface::instance);
      matFactory.registerMaterial(map.value("interfaceMohrCoulomb").toInt(), "interfaceMohrCoulomb", GmpInterfaceMohrCoulomb::instance);
      matFactory.registerMaterial(map.value("cohesiveLinearSoftening").toInt(), "cohesiveLinearSoftening", GmpCohesiveLinearSoftening::instance);
      matFactory.registerMaterial(map.value("cohesiveExponentialSoftening").toInt(), "cohesiveExponentialSoftening", GmpCohesiveExponentialSoftening::instance);
      matFactory.registerMaterial(map.value("cohesivePotentialSoftening").toInt(), "cohesivePotentialSoftening", GmpMaterialCohesivePotentialSoftening::instance);
      matFactory.registerMaterial(map.value("modifiedMohrCoulomb").toInt(), "modifiedMohrCoulomb", GmpMaterialModifiedMohrCoulomb::instance);
      matFactory.registerMaterial(map.value("mohrCoulomb").toInt(), "mohrCoulomb", GmpMaterialMohrCoulomb::instance);
      matFactory.registerMaterial(map.value("breslerPister").toInt(), "breslerPister", GmpMaterialBreslerPister::instance);
      matFactory.registerMaterial(map.value("druckerPrager").toInt(), "druckerPrager", GmpMaterialDruckerPrager::instance);
      matFactory.registerMaterial(map.value("vonMises").toInt(), "vonMises", GmpMaterialVonMises::instance);
      matFactory.registerMaterial(map.value("DMCreep").toInt(), "DMCreep", GmpMaterialDMCreep::instance);
      matFactory.registerMaterial(map.value("equivalentContinuum").toInt(), "equivalentContinuum", GmpMechanicalMaterialEquivalentContinuum::instance);
      matFactory.registerMaterial(map.value("capMohrCoulomb").toInt(), "capMohrCoulomb", GmpMaterialCapMohrCoulomb::instance);
      matFactory.registerMaterial(map.value("crackingCrushingDamage").toInt(), "crackingCrushingDamage", GmpMaterialCrackingCrushingDamage::instance);
          matFactory.registerMaterial(map.value("crackingCrushingPlasticDamage").toInt(), "crackingCrushingPlasticDamage", GmpMaterialCrackingCrushingPlasticDamage::instance);
      matFactory.registerMaterial(map.value("modifiedCamClay").toInt(), "modifiedCamClay", GmpMaterialModifiedCamClay::instance);
      matFactory.registerMaterial(map.value("porousElastic").toInt(), "porousElastic", GmpMechanicalMaterialPorousElastic::instance);
      matFactory.registerMaterial(map.value("extendedDruckerPrager").toInt(), "extendedDruckerPrager", GmpMaterialExtendedDruckerPrager::instance);
      matFactory.registerMaterial(map.value("MACreep").toInt(), "MACreep", GmpMaterialMACreep::instance);
      matFactory.registerMaterial(map.value("capModel").toInt(), "capModel", GmpMaterialCapModel::instance);
      matFactory.registerMaterial(map.value("fluid").toInt(), "fluid", GmpMaterialFluid::instance);
      matFactory.registerMaterial(map.value("PLCreep").toInt(), "PLCreep", GmpMaterialPowerLawCreep::instance);
      matFactory.registerMaterial(map.value("DPCreep").toInt(), "DPCreep", GmpMaterialDPCreep::instance);
      matFactory.registerMaterial(map.value("solidifyingKelvinChain").toInt(), "solidifyingKelvinChain", GmpMaterialSolidifyingKelvinChain::instance);
      matFactory.registerMaterial(map.value("generalYieldSurface").toInt(), "generalYieldSurface", GmpMaterialGeneralYieldSurface::instance);
      matFactory.registerMaterial(map.value("WDCreep").toInt(), "WDCreep", GmpMaterialWDCreep::instance);
      matFactory.registerMaterial(map.value("WDTCreep").toInt(), "WDTCreep", GmpMaterialWDTCreep::instance);
      matFactory.registerMaterial(map.value("EDMTCreep").toInt(), "EDMTCreep", GmpMaterialEDMTCreep::instance);
      matFactory.registerMaterial(map.value("MDCreep").toInt(), "MDCreep", GmpMaterialMDCreep::instance);
      matFactory.registerMaterial(map.value("ladeKim").toInt(), "ladeKim", GmpMaterialLadeKim::instance);
      matFactory.registerMaterial(map.value("capGeneralYieldSurface").toInt(), "capGeneralYieldSurface", GmpMaterialCapGeneralYieldSurface::instance);
      matFactory.registerMaterial(map.value("Plasticity1D").toInt(), "Plasticity1D", GmpMaterialOneDimPlasticity::instance);
      matFactory.registerMaterial(map.value("fiberStrainHardening").toInt(), "fiberStrainHardening", GmpMaterialFiberStrainHardening::instance);

      // special materials for Large displacement formulation
      matFactory.registerMaterial(map.value("hyperelastic").toInt(), "hyperelastic", GmpMechanicalMaterialHyperelastic::instance);
      matFactory.registerMaterial(map.value("hencky").toInt(), "hencky", GmpMechanicalMaterialHencky::instance);

      // User materials. Instanced only if an equivalent User material plugin data object is availabe
      // in the simulation data object
      matFactory.registerMaterial(map.value("umat1").toInt(), "umat1", GmpMechanicalMaterialLua::instance);
      matFactory.registerMaterial(map.value("umat2").toInt(), "umat2", GmpMechanicalMaterialLua::instance);
      matFactory.registerMaterial(map.value("umat3").toInt(), "umat3", GmpMechanicalMaterialLua::instance);
      matFactory.registerMaterial(map.value("umat4").toInt(), "umat4", GmpMechanicalMaterialLua::instance);
      matFactory.registerMaterial(map.value("umat5").toInt(), "umat5", GmpMechanicalMaterialLua::instance);

          
      assert(matFactory.checkTypeMap());
    }

    return &matFactory;
  }

        // See comments on the base class method declaration
        virtual GmPluginObject* instance(QString category, QString objType, GmSimulationData* simulation,
                                               QString id, QString description)
        {
    assert(category == GM_PLUGIN_PHYSICS);

    // Instance the requested physics object
    if(objType == "Bar")
      return new GmpBar("Bar", simulation, id, description, matFactory(simulation), logger());
    else if(objType == "PlaneStress")
      return new GmpMechanicPlaneStress<GmpMechanicalSolid>("PlaneStress", simulation, id, description, matFactory(simulation), logger());
    else if(objType == "PlaneStrain")
      return new GmpMechanic<GmpMechanicalSolid>("PlaneStrain", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Axisymmetric")
      return new GmpMechanicAxy<GmpMechanicalSolid>("Axisymmetric", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "3D")
      return new GmpMechanic<GmpMechanicalSolid>("3D", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Interface")
      return new GmpInterface<GmpMechanicalInterface>("Interface", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "AxInterface")
      return new GmpAxiInterface<GmpMechanicalInterface>("AxInterface", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "CompositePE")
                return new GmpMechanic<GmpMechanicalComposite>("CompositePE", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Composite3D")
      return new GmpMechanic<GmpMechanicalComposite>("Composite3D", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "CompositePS")
                return new GmpMechanicPlaneStress<GmpMechanicalComposite>("CompositePS", simulation, id, description, matFactory(simulation), logger());
          else if (objType == "PlaneStressLD")
                return new GmpMechanicPlaneStressLargeDisplacement<GmpMechanicalLargeDisplacementSolid>("PlaneStressLD", simulation, id, description, matFactory(simulation), logger());
          else if (objType == "PlaneStrainLD")
                return new GmpMechanicLargeDisplacement<GmpMechanicalLargeDisplacementSolid>("PlaneStrainLD", simulation, id, description, matFactory(simulation), logger());
          else if (objType == "AxisymmetricLD")
                return new GmpMechanicAxyLargeDisplacement<GmpMechanicalLargeDisplacementSolid>("AxisymmetricLD", simulation, id, description, matFactory(simulation), logger());
          else if (objType == "3DLD")
                return new GmpMechanicLargeDisplacement<GmpMechanicalLargeDisplacementSolid>("3DLD", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "ReinforcedInterface")
      return new GmpInterface<GmpMechanicalReinforcedInterface>("ReinforcedInterface", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Spring")
      return new GmpSpring("Spring", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "EmbeddedPS")
      return new GmpMechanicPlaneStress<GmpMechanicalEmbeddedFracture>("EmbeddedPS", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "EmbeddedPE")
      return new GmpMechanic<GmpMechanicalEmbeddedFracture>("EmbeddedPE", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Embedded3D")
      return new GmpMechanic<GmpMechanicalEmbeddedFracture>("Embedded3D", simulation, id, description, matFactory(simulation), logger());
    else
      return NULL;
  }

  virtual const QStringList& versionInfo() const { return GmpMechanicalFemPhysicsVersionInfo(); }

  virtual const QStringList& depVersionInfo() const { return GmpMechanicalFemPhysicsRevisionDependencies(); }
};

#endif