gmpHydroFemPhysicsFactory.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_HYDRO_FEM_PHYSICS_FACTORY_H_
#define _GEMA_PLUGIN_HYDRO_FEM_PHYSICS_FACTORY_H_
 
#include <QObject>
 
#include <gmPluginObjectFactory.h>
 
#include "gmpHydraulicMultiPhaseFlow.h"
#include "gmpHydraulicTwoPhaseFlow.h"
#include "gmpHydraulicTwoPhaseFlowPgPc.h"
#include "gmpHydraulicInterfaceTwoPhaseFlow.h"
#include "gmpHydraulicDualFlow.h"
#include "gmpHydraulicFlow.h"
#include "gmpInterfaceFlow.h"
#include "gmpHydraulicPipe.h"
#include "gmpHydraulicMaterialMultiPhase.h"
#include "gmpHydraulicMaterialTwoPhase.h"
#include "gmpMaterialInterfaceMultiPhaseFlow.h"
#include "gmpMaterialCubicLaw.h"
#include "gmpMaterialShearLaw.h"
#include "gmpMaterialPipeFlow.h"
#include "gmpMaterialDualPorosity.h"
#include "gmpMaterialGeneralizedDualPorosity.h"
#include "gmpMaterialEnhancedDualPorosity.h"
#include "gmpMaterialBrinkman.h"
#include "gmpHydraulicBrinkmanFlow.h"
#include "gmpMaterialSaturated.h"
#include "gmpHydraulicEmbeddedFracture.h"
#include "gmpHydraulicEmbeddedFractureConductive.h"
#include "gmpHydraulicEnhancedDualFlow.h"
#include "gmpHydraulicMaterialEquivalentContinuum.h"
#include "gmpHydraulicVersion.h"
#include "gmpHydraulicNeuralNetwork.h"
 
 
#include <gmpFemPhysicsCommonMaterial.h>
#include <gmSimulationData.h>
#include <gmPluginLoader.h>
#include <gmPluginInfo.h>
 
 
class GmpHydroFemPhysicsFactory : public QObject, GmPluginObjectFactory
{
        Q_OBJECT
        Q_PLUGIN_METADATA(IID GmPluginObjectFactoryInterfaceIID)
Q_INTERFACES(GmPluginObjectFactory)
 
public:
  GmpHydroFemPhysicsFactory() : GmPluginObjectFactory("HydroFemPhysics") {}
 
  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("HydroFemPhysics");
      assert(ourInfo);
      const QVariantMap& map = ourInfo->attributes().value("constants").value<QVariantMap>().value("materialModels").value<QVariantMap>();
 
      matFactory.registerMaterial(map.value("saturated").toInt(),      "saturated",      GmpHydraulicMaterialSaturated::instance, true);
      matFactory.registerMaterial(map.value("dualPorosity").toInt(),   "dualPorosity",   GmpHydraulicMaterialDualPorosity::instance);
      matFactory.registerMaterial(map.value("cubicLaw").toInt(),  "cubicLaw",  GmpMaterialCubicLaw::instance);
      matFactory.registerMaterial(map.value("shearLaw").toInt(), "shearLaw", GmpMaterialShearLaw::instance);
      matFactory.registerMaterial(map.value("pipeFlow").toInt(),       "pipeFlow",       GmpMaterialPipeFlow::instance);
      matFactory.registerMaterial(map.value("generalizedDualPorosity").toInt(), "generalizedDualPorosity", GmpHydraulicMaterialGeneralizedDualPorosity::instance);
      matFactory.registerMaterial(map.value("enhancedDualPorosity").toInt(), "enhancedDualPorosity", GmpHydraulicMaterialEnhancedDualPorosity::instance);
      matFactory.registerMaterial(map.value("brinkman").toInt(), "brinkman", GmpHydraulicMaterialBrinkman::instance);
      matFactory.registerMaterial(map.value("equivalentContinuum").toInt(), "equivalentContinuum", GmpHydraulicMaterialEquivalentContinuum::instance);
      matFactory.registerMaterial(map.value("twoPhaseFlow").toInt(), "twoPhaseFlow", GmpHydraulicMaterialTwoPhase::instance);
      matFactory.registerMaterial(map.value("interfaceTwoPhaseFlow").toInt(), "interfaceTwoPhaseFlow", GmpMaterialInterfaceMultiPhaseFlow::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 == "Flow")
      return new GmpHydraulicFlow<GmpHydraulic>("Flow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "AxFlow")
      return new GmpHydraulicAxFlow<GmpHydraulic>("AxFlow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Interface")
      return new GmpInterfaceFlow<GmpHydraulicInterface>("Interface", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "AxInterface")
      return new GmpInterfaceAxFlow<GmpHydraulicInterface>("AxInterface", simulation, id, description, matFactory(simulation), logger());
        else if (objType == "DualFlow")
      return new GmpHydraulicFlow<GmpHydraulicDualFlow>("DualFlow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Pipe")
      return new GmpHydraulicPipe("Pipe", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "MultiPhaseFlow")
      return new GmpHydraulicFlow<GmpHydraulicMultiPhaseFlow>("MultiPhaseFlow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "TwoPhaseFlow")
      return new GmpHydraulicFlow<GmpHydraulicTwoPhaseFlow>("TwoPhaseFlow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "AxTwoPhaseFlow")
        return new GmpHydraulicAxFlow<GmpHydraulicTwoPhaseFlow>("AxTwoPhaseFlow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "TwoPhaseFlowPgPc")
        return new GmpHydraulicFlow<GmpHydraulicTwoPhaseFlowPgPc>("TwoPhaseFlowPgPc", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "AxTwoPhaseFlowPgPc")
        return new GmpHydraulicAxFlow<GmpHydraulicTwoPhaseFlowPgPc>("AxTwoPhaseFlowPgPc", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "TwoPhaseFlowInterface")
        return new GmpInterfaceFlow<GmpHydraulicInterfaceTwoPhaseFlow>("TwoPhaseFlowInterface", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "Brinkman")
      return new GmpHydraulicBrinkman<GmpHydraulicBrinkmanFlow>("Brinkman", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "EmbeddedFracture")
                  return new GmpHydraulicFlow<GmpHydraulicEmbeddedFracture>("EmbeddedFracture", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "EmbeddedFractureConductive")
        return new GmpHydraulicFlow<GmpHydraulicEmbeddedFractureConductive>("EmbeddedFractureConductive", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "EnhancedDualFlow")
      return new GmpHydraulicFlow<GmpHydraulicEnhancedDualFlow>("EnhancedDualFlow", simulation, id, description, matFactory(simulation), logger());
    else if (objType == "NeuralNetworkFlow")
      return new GmpHydraulicFlow<GmpHydraulicNeuralNetwork>("NeuralNetworkFlow", simulation, id, description, matFactory(simulation), logger());
    else
      return NULL;
  }
 
  virtual const QMap<QString, QString>& versionInfo() const { return GmpHydroFemPhysicsVersionInfo(); }
 
  virtual const QStringList& depVersionInfo() const { return GmpHydroFemPhysicsRevisionDependencies(); }
};
 
#endif