SIMCoupled.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SIM_COUPLED_H_
#define _SIM_COUPLED_H_
 
#include "Property.h"
#include "matrix.h"
#include <map>
 
class SIMdependency;
class ASMbase;
class ProcessAdm;
class DataExporter;
class VecFunc;
class TimeStep;
class VTF;
 
 
template<class T1, class T2> class SIMCoupled
{
public:
  SIMCoupled(T1& s1, T2& s2) : S1(s1), S2(s2) {}
 
  virtual ~SIMCoupled() { S2.setVTF(nullptr); }
 
  virtual void setupDependencies() {}
 
  bool preprocess()
  {
    return S1.preprocess() && S2.preprocess();
  }
 
  const ProcessAdm& getProcessAdm() const { return S1.getProcessAdm(); }
 
  int getRefined() const { return S1.getRefined(); }
 
  std::string getName(int substep = 1) const
  {
    if (substep == 1)
      return S1.getName();
    else if (substep == 2)
      return S2.getName();
 
    return "SIMCoupled<" + S1.getName() +","+ S2.getName() +">";
  }
 
  virtual bool advanceStep(TimeStep& tp)
  {
    return S1.advanceStep(tp) && S2.advanceStep(tp);
  }
 
  virtual void enableStaggering(bool = true) {}
 
  virtual bool solveStep(TimeStep& tp, bool firstS1 = true)
  {
    if (firstS1)
      return S1.solveStep(tp) && S2.solveStep(tp);
    else
      return S2.solveStep(tp) && S1.solveStep(tp);
  }
 
  virtual bool saveStep(const TimeStep& tp, int& nBlock)
  {
    return S2.saveStep(tp,nBlock) && S1.saveStep(tp,nBlock);
  }
 
  virtual bool saveModel(char* fileName, int& geoBlk, int& nBlock)
  {
    if (!S1.saveModel(fileName,geoBlk,nBlock))
      return false;
 
    S2.setVTF(S1.getVTF());
    return true;
  }
 
  VTF* getVTF() const { return S1.getVTF(); }
 
  virtual bool init(const TimeStep& tp)
  {
    return S1.init(tp) && S2.init(tp);
  }
 
  virtual void registerDependency(SIMdependency* sim, const std::string& name,
                                  short int nvc,
                                  const std::vector<ASMbase*>& patches,
                                  char diffBasis = 0, int component = 1)
  {
    S1.registerDependency(sim, name, nvc, patches, diffBasis, component);
    S2.registerDependency(sim, name, nvc, patches, diffBasis, component);
  }
 
  virtual void registerDependency(SIMdependency* sim, const std::string& name,
                                  short int nvc = 1)
  {
    S1.registerDependency(sim, name, nvc);
    S2.registerDependency(sim, name, nvc);
  }
 
  int getUniquePropertyCode(const std::string& setName, int comp = 0)
  {
    return S1.getUniquePropertyCode(setName, comp);
  }
 
  bool createPropertySet(const std::string& setName, int pc)
  {
    return S1.createPropertySet(setName, pc);
  }
 
  size_t setVecProperty(int code, Property::Type ptype,
                        VecFunc* field = nullptr, int pflag = -1)
  {
    return S1.setVecProperty(code, ptype, field, pflag);
  }
 
  void registerFields(DataExporter& exporter)
  {
    S1.registerFields(exporter);
    S2.registerFields(exporter);
  }
 
  bool setInitialConditions()
  {
    return S1.setInitialConditions() && S2.setInitialConditions();
  }
 
  bool hasIC(const std::string& name) const
  {
    return S1.hasIC(name) || S2.hasIC(name);
  }
 
  utl::vector<double>* getField(const std::string& name)
  {
    utl::vector<double>* result = S1.getField(name);
    if (!result)
      result = S2.getField(name);
 
    return result;
  }
 
  bool serialize(std::map<std::string,std::string>& data)
  {
    return S1.serialize(data) && S2.serialize(data);
  }
 
  bool deSerialize(const std::map<std::string,std::string>& data)
  {
    return S1.deSerialize(data) && S2.deSerialize(data);
  }
 
protected:
  T1& S1; 
  T2& S2; 
};
 
#endif