Added: Error message when non-registered vector or field detected.
Changed: getName is now a virtual method in SIMdependency. Changed: Default constructor for struct Dependency now accepts arguments.
This commit is contained in:
		@@ -36,41 +36,25 @@ template<class T> class SIMOverride : public SIMdependency
 | 
			
		||||
 | 
			
		||||
public:
 | 
			
		||||
  //! \brief The constructor initializes the reference to the wrapped simulator.
 | 
			
		||||
  //! \param t The simulator to wrap
 | 
			
		||||
  SIMOverride(T& t) : base(t) {}
 | 
			
		||||
 | 
			
		||||
  //! \brief Empty destructor.
 | 
			
		||||
  virtual ~SIMOverride() {}
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMinput::read(const char*)
 | 
			
		||||
  bool read(const char* fileName)
 | 
			
		||||
  {
 | 
			
		||||
    return base.read(fileName);
 | 
			
		||||
  }
 | 
			
		||||
  bool read(const char* fileName) { return base.read(fileName); }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc ISolver::setInitialConditions()
 | 
			
		||||
  void setInitialConditions()
 | 
			
		||||
  {
 | 
			
		||||
    base.setInitialConditions();
 | 
			
		||||
  }
 | 
			
		||||
  void setInitialConditions() { base.setInitialConditions(); }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMdependency::hasIC(const std::string&) const
 | 
			
		||||
  virtual bool hasIC(const std::string& name) const
 | 
			
		||||
  {
 | 
			
		||||
    return base.hasIC(name);
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMbase::getNoSpaceDim()
 | 
			
		||||
  virtual size_t getNoSpaceDim() const
 | 
			
		||||
  {
 | 
			
		||||
    return base.getNoSpaceDim();
 | 
			
		||||
  }
 | 
			
		||||
  virtual bool hasIC(const std::string& name) const { return base.hasIC(name); }
 | 
			
		||||
  //! \copydoc SIMdependency::getNoSpaceDim() const
 | 
			
		||||
  virtual size_t getNoSpaceDim() const { return base.getNoSpaceDim(); }
 | 
			
		||||
  //! \copydoc SIMdependency::getName() const
 | 
			
		||||
  virtual std::string getName() const { return base.getName(); }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMbase::getFEModel() const
 | 
			
		||||
  const PatchVec& getFEModel() const
 | 
			
		||||
  {
 | 
			
		||||
    return base.getFEModel();
 | 
			
		||||
  }
 | 
			
		||||
  const PatchVec& getFEModel() const { return base.getFEModel(); }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc ISolver::saveModel(char*,int&,int&)
 | 
			
		||||
  bool saveModel(char* fileName, int& geoBlk, int& nBlock)
 | 
			
		||||
@@ -79,15 +63,12 @@ public:
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMoutput::getVTF() const
 | 
			
		||||
  VTF* getVTF() const
 | 
			
		||||
  {
 | 
			
		||||
    return base.getVTF();
 | 
			
		||||
  }
 | 
			
		||||
  VTF* getVTF() const { return base.getVTF(); }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMbase::getProcessAdm() const
 | 
			
		||||
  const ProcessAdm& getProcessAdm() const { return base.getProcessAdm(); }
 | 
			
		||||
 | 
			
		||||
  //! \copydoc SIMdependency::registerDependency(SIMdependency*,const std::string&,short int,const PatchVec&,bool)
 | 
			
		||||
  //! \copydoc SIMdependency::registerDependency(SIMdependency*,const std::string&,short int,const PatchVec&,char)
 | 
			
		||||
  virtual void registerDependency(SIMdependency* sim, const std::string& name,
 | 
			
		||||
                                  short int nvc, const PatchVec& patches,
 | 
			
		||||
                                  char diffBasis = 0)
 | 
			
		||||
@@ -156,11 +137,6 @@ public:
 | 
			
		||||
    return base.advanceStep(tp);
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  void postSolve(const TimeStep& tp)
 | 
			
		||||
  {
 | 
			
		||||
    base.postSolve(tp);
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  T& get() { return base; }
 | 
			
		||||
  const T& get() const { return base; }
 | 
			
		||||
 | 
			
		||||
 
 | 
			
		||||
@@ -24,6 +24,7 @@ public:
 | 
			
		||||
    setinitialconditions_called(false),
 | 
			
		||||
    hasic_called(false),
 | 
			
		||||
    getnospacedim_called(false),
 | 
			
		||||
    getname_called(false),
 | 
			
		||||
    getfemodel_called(false),
 | 
			
		||||
    savemodel_called(false),
 | 
			
		||||
    getvtf_called(false),
 | 
			
		||||
@@ -39,26 +40,22 @@ public:
 | 
			
		||||
    registerfields_called(false),
 | 
			
		||||
    savestep_called(false),
 | 
			
		||||
    advancestep_called(false),
 | 
			
		||||
    postsolve_called(false),
 | 
			
		||||
    getglobalnode_called(false),
 | 
			
		||||
    getlocalnode_called(false)
 | 
			
		||||
  {}
 | 
			
		||||
 | 
			
		||||
  bool read(const char* fileName) { read_called = true; return true;}
 | 
			
		||||
  bool read(const char*) { return read_called = true; }
 | 
			
		||||
  void setInitialConditions() { setinitialconditions_called = true; }
 | 
			
		||||
  bool hasIC(const std::string& name) const { hasic_called = true; return true; }
 | 
			
		||||
  bool hasIC(const std::string&) const { return hasic_called = true; }
 | 
			
		||||
  size_t getNoSpaceDim() const { getnospacedim_called = true; return 2; }
 | 
			
		||||
  std::string getName() const { getname_called = true; return "SIMMock"; }
 | 
			
		||||
  const std::vector<ASMbase*>& getFEModel() const
 | 
			
		||||
  {
 | 
			
		||||
    static std::vector<ASMbase*> result;
 | 
			
		||||
    getfemodel_called = true;
 | 
			
		||||
    return result;
 | 
			
		||||
  }
 | 
			
		||||
  bool saveModel(char* fileName, int& geoBlk, int& nBlock)
 | 
			
		||||
  {
 | 
			
		||||
    savemodel_called = true;
 | 
			
		||||
    return true;
 | 
			
		||||
  }
 | 
			
		||||
  bool saveModel(char*, int&, int&) { return savemodel_called = true; }
 | 
			
		||||
  VTF* getVTF() const { getvtf_called = true; return NULL; }
 | 
			
		||||
  const ProcessAdm& getProcessAdm() const
 | 
			
		||||
  {
 | 
			
		||||
@@ -66,54 +63,47 @@ public:
 | 
			
		||||
    getprocessadm_called = true;
 | 
			
		||||
    return result;
 | 
			
		||||
  }
 | 
			
		||||
  void registerDependency(SIMdependency* sim, const std::string& name,
 | 
			
		||||
                          short int nvc, const std::vector<ASMbase*>& patches,
 | 
			
		||||
                          bool diffBasis = false)
 | 
			
		||||
  void registerDependency(SIMdependency*, const std::string&, short int,
 | 
			
		||||
                          const std::vector<ASMbase*>&, char)
 | 
			
		||||
  {
 | 
			
		||||
    registerdependency_called = true;
 | 
			
		||||
  }
 | 
			
		||||
  void registerDependency(SIMdependency* sim, const std::string& name,
 | 
			
		||||
                          short int nvc = 1)
 | 
			
		||||
  void registerDependency(SIMdependency*, const std::string&, short int)
 | 
			
		||||
  {
 | 
			
		||||
    registerdependency2_called = true;
 | 
			
		||||
  }
 | 
			
		||||
  bool fillField(const std::string& name, const std::vector<double>& values)
 | 
			
		||||
  bool fillField(const std::string&, const std::vector<double>&)
 | 
			
		||||
  {
 | 
			
		||||
    fillfield_called = true;
 | 
			
		||||
    return true;
 | 
			
		||||
    return fillfield_called = true;
 | 
			
		||||
  }
 | 
			
		||||
  utl::vector<double>* getField(const std::string& name)
 | 
			
		||||
  utl::vector<double>* getField(const std::string&)
 | 
			
		||||
  {
 | 
			
		||||
    getfield_called = true;
 | 
			
		||||
    return NULL;
 | 
			
		||||
  }
 | 
			
		||||
  const utl::vector<double>* getField(const std::string& name) const
 | 
			
		||||
  const utl::vector<double>* getField(const std::string&) const
 | 
			
		||||
  {
 | 
			
		||||
    getfield2_called = true;
 | 
			
		||||
    return NULL;
 | 
			
		||||
  }
 | 
			
		||||
  const utl::vector<double>* getDependentField(const std::string& name) const
 | 
			
		||||
  const utl::vector<double>* getDependentField(const std::string&) const
 | 
			
		||||
  {
 | 
			
		||||
    getdependentfield_called = true;
 | 
			
		||||
    return NULL;
 | 
			
		||||
  }
 | 
			
		||||
  void setupDependencies() { setupdependencies_called = true; }
 | 
			
		||||
  bool init(const TimeStep& tp) { init_called = true; return true; }
 | 
			
		||||
  void registerFields(DataExporter& exporter) { registerfields_called = true; }
 | 
			
		||||
  bool saveStep(const TimeStep& tp, int& nBlock)
 | 
			
		||||
  {
 | 
			
		||||
    savestep_called = true;
 | 
			
		||||
    return true;
 | 
			
		||||
  }
 | 
			
		||||
  bool advanceStep(TimeStep& tp) { advancestep_called = true; return true; }
 | 
			
		||||
  void postSolve(const TimeStep& tp) { postsolve_called = true; }
 | 
			
		||||
  int getGlobalNode(int node) const { getglobalnode_called = true; return 0; }
 | 
			
		||||
  int getLocalNode(int node) const { getlocalnode_called = true; return 0; }
 | 
			
		||||
  bool init(const TimeStep&) { return init_called = true; }
 | 
			
		||||
  void registerFields(DataExporter&) { registerfields_called = true; }
 | 
			
		||||
  bool saveStep(const TimeStep&, int&) { return savestep_called = true; }
 | 
			
		||||
  bool advanceStep(TimeStep&) { return advancestep_called = true; }
 | 
			
		||||
  int getGlobalNode(int) const { getglobalnode_called = true; return 0; }
 | 
			
		||||
  int getLocalNode(int) const { getlocalnode_called = true; return 0; }
 | 
			
		||||
 | 
			
		||||
  bool read_called;
 | 
			
		||||
  bool setinitialconditions_called;
 | 
			
		||||
  mutable bool hasic_called;
 | 
			
		||||
  mutable bool getnospacedim_called;
 | 
			
		||||
  mutable bool getname_called;
 | 
			
		||||
  mutable bool getfemodel_called;
 | 
			
		||||
  bool savemodel_called;
 | 
			
		||||
  mutable bool getvtf_called;
 | 
			
		||||
@@ -129,7 +119,6 @@ public:
 | 
			
		||||
  bool registerfields_called;
 | 
			
		||||
  bool savestep_called;
 | 
			
		||||
  bool advancestep_called;
 | 
			
		||||
  bool postsolve_called;
 | 
			
		||||
  mutable bool getglobalnode_called;
 | 
			
		||||
  mutable bool getlocalnode_called;
 | 
			
		||||
};
 | 
			
		||||
@@ -142,6 +131,7 @@ TEST(TestSIMOverride, Override)
 | 
			
		||||
  sim.setInitialConditions();
 | 
			
		||||
  sim.hasIC("");
 | 
			
		||||
  sim.getNoSpaceDim();
 | 
			
		||||
  sim.getName();
 | 
			
		||||
  sim.getFEModel();
 | 
			
		||||
  int geoBlk, nBlock;
 | 
			
		||||
  sim.saveModel((char*)"", geoBlk, nBlock);
 | 
			
		||||
@@ -160,7 +150,6 @@ TEST(TestSIMOverride, Override)
 | 
			
		||||
  sim.registerFields(exp);
 | 
			
		||||
  sim.saveStep(tp, nBlock);
 | 
			
		||||
  sim.advanceStep(tp);
 | 
			
		||||
  sim.postSolve(tp);
 | 
			
		||||
  sim.getGlobalNode(1);
 | 
			
		||||
  sim.getLocalNode(1);
 | 
			
		||||
 | 
			
		||||
@@ -168,6 +157,7 @@ TEST(TestSIMOverride, Override)
 | 
			
		||||
  ASSERT_TRUE(ovr.setinitialconditions_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.hasic_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.getnospacedim_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.getname_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.getfemodel_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.savemodel_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.getvtf_called);
 | 
			
		||||
@@ -183,7 +173,6 @@ TEST(TestSIMOverride, Override)
 | 
			
		||||
  ASSERT_TRUE(ovr.registerfields_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.savestep_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.advancestep_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.postsolve_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.getglobalnode_called);
 | 
			
		||||
  ASSERT_TRUE(ovr.getlocalnode_called);
 | 
			
		||||
}
 | 
			
		||||
 
 | 
			
		||||
@@ -22,24 +22,16 @@ void SIMdependency::registerDependency (SIMdependency* sim,
 | 
			
		||||
                                        const std::string& name, short int nvc,
 | 
			
		||||
                                        const PatchVec& patches, char diffBasis)
 | 
			
		||||
{
 | 
			
		||||
  Dependency dep;
 | 
			
		||||
  dep.sim = sim;
 | 
			
		||||
  dep.name = name;
 | 
			
		||||
  dep.components = nvc;
 | 
			
		||||
  dep.patches = patches;
 | 
			
		||||
  dep.differentBasis = diffBasis;
 | 
			
		||||
  depFields.push_back(dep);
 | 
			
		||||
  depFields.push_back(Dependency(sim,name,nvc));
 | 
			
		||||
  depFields.back().patches = patches;
 | 
			
		||||
  depFields.back().differentBasis = diffBasis;
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
void SIMdependency::registerDependency (SIMdependency* sim,
 | 
			
		||||
                                        const std::string& name, short int nvc)
 | 
			
		||||
{
 | 
			
		||||
  Dependency dep;
 | 
			
		||||
  dep.sim = sim;
 | 
			
		||||
  dep.name = name;
 | 
			
		||||
  dep.components = nvc;
 | 
			
		||||
  depFields.push_back(dep);
 | 
			
		||||
  depFields.push_back(Dependency(sim,name,nvc));
 | 
			
		||||
}
 | 
			
		||||
 | 
			
		||||
 | 
			
		||||
@@ -123,16 +115,30 @@ bool SIMdependency::extractPatchDependencies (IntegrandBase* problem,
 | 
			
		||||
  DepVector::const_iterator it;
 | 
			
		||||
  for (it = depFields.begin(); it != depFields.end(); ++it)
 | 
			
		||||
  {
 | 
			
		||||
    const Vector* gvec = it->sim->getField(it->name);
 | 
			
		||||
    Vector* lvec = problem->getNamedVector(it->name);
 | 
			
		||||
    if (lvec && gvec && !gvec->empty())
 | 
			
		||||
    const Vector* gvec = it->sim->getField(it->name);
 | 
			
		||||
    if (!lvec)
 | 
			
		||||
    {
 | 
			
		||||
      if (pindx < it->patches.size())
 | 
			
		||||
	patch = it->patches[pindx];
 | 
			
		||||
      else
 | 
			
		||||
	patch = model[pindx];
 | 
			
		||||
      int bflag = it->components < 0 ? it->components : it->differentBasis; // HACK
 | 
			
		||||
      patch->extractNodeVec(*gvec,*lvec,abs(it->components),bflag);
 | 
			
		||||
      std::cerr <<" *** SIMdependency::extractPatchDependencies: \""
 | 
			
		||||
                << it->name <<"\" is not a registered vector in the integrand"
 | 
			
		||||
                <<" of the simulator \""<< this->getName() <<"\""<< std::endl;
 | 
			
		||||
      //return false;
 | 
			
		||||
      continue; //TODO: Fix all apps for which this gives error
 | 
			
		||||
    }
 | 
			
		||||
    else if (!gvec)
 | 
			
		||||
    {
 | 
			
		||||
      std::cerr <<" *** SIMdependency::extractPatchDependencies: \""
 | 
			
		||||
                << it->name <<"\" is not a registered field in the simulator \""
 | 
			
		||||
                << it->sim->getName() <<"\""<< std::endl;
 | 
			
		||||
      return false;
 | 
			
		||||
    }
 | 
			
		||||
    else if (gvec->empty())
 | 
			
		||||
      continue; // No error, silently ignore empty fields (treated as zero)
 | 
			
		||||
 | 
			
		||||
    patch = pindx < it->patches.size() ? it->patches[pindx] : model[pindx];
 | 
			
		||||
    // See ASMbase::extractNodeVec for interpretation of negative value on basis
 | 
			
		||||
    int basis = it->components < 0 ? it->components : it->differentBasis;
 | 
			
		||||
    patch->extractNodeVec(*gvec,*lvec,abs(it->components),basis);
 | 
			
		||||
    if (it->differentBasis > 0) {
 | 
			
		||||
      if (it->components == 1)
 | 
			
		||||
        problem->setNamedField(it->name,Field::create(patch,*lvec,it->differentBasis));
 | 
			
		||||
@@ -144,7 +150,6 @@ bool SIMdependency::extractPatchDependencies (IntegrandBase* problem,
 | 
			
		||||
              <<"\" for patch "<< pindx+1 << *lvec;
 | 
			
		||||
#endif
 | 
			
		||||
  }
 | 
			
		||||
  }
 | 
			
		||||
 | 
			
		||||
  return true;
 | 
			
		||||
}
 | 
			
		||||
 
 | 
			
		||||
@@ -41,7 +41,7 @@ public:
 | 
			
		||||
    char basis;     //!< The basis to inject field into (for mixed)
 | 
			
		||||
    int component;  //!< Component for field (for functions)
 | 
			
		||||
    std::string sim_field;  //!< The name of the field in the SIM class
 | 
			
		||||
    std::string file_field; //!< The name of the field in the file, type of function if function form
 | 
			
		||||
    std::string file_field; //!< The field name in the file or type of function
 | 
			
		||||
    std::string function;   //!< Function if given in function form
 | 
			
		||||
    //! \brief Default constructor.
 | 
			
		||||
    ICInfo() : sim_level(0), file_level(0), geo_level(0) {}
 | 
			
		||||
@@ -64,7 +64,9 @@ private:
 | 
			
		||||
    short int      components;     //!< Number of field components per node
 | 
			
		||||
    char           differentBasis; //!< Toggle usage of an independent basis
 | 
			
		||||
    //! \brief Default constructor.
 | 
			
		||||
    Dependency() : sim(nullptr), components(1), differentBasis(0) {}
 | 
			
		||||
    Dependency(SIMdependency* s = nullptr, const std::string& f = "",
 | 
			
		||||
               short int n = 1) : sim(s), name(f), components(n),
 | 
			
		||||
                                  differentBasis(0) {}
 | 
			
		||||
  };
 | 
			
		||||
 | 
			
		||||
  //! \brief SIM dependency container
 | 
			
		||||
@@ -88,6 +90,8 @@ public:
 | 
			
		||||
 | 
			
		||||
  //! \brief Returns the number of spatial dimensions in the model.
 | 
			
		||||
  virtual size_t getNoSpaceDim() const = 0;
 | 
			
		||||
  //! \brief Returns the given name of this simulator.
 | 
			
		||||
  virtual std::string getName() const = 0;
 | 
			
		||||
 | 
			
		||||
  //! \brief Registers a dependency on a field from another SIM object.
 | 
			
		||||
  //! \param[in] sim The SIM object holding the field we depend on
 | 
			
		||||
@@ -117,6 +121,7 @@ public:
 | 
			
		||||
  ASMbase* getDependentPatch(const std::string& name, int pindx) const;
 | 
			
		||||
  //! \brief Registers a named field with associated nodal vector in this SIM.
 | 
			
		||||
  void registerField(const std::string& name, const utl::vector<double>& vec);
 | 
			
		||||
 | 
			
		||||
private:
 | 
			
		||||
  //! \brief Returns an iterator pointing to a named dependency.
 | 
			
		||||
  DepVector::const_iterator getDependency(const std::string& name) const;
 | 
			
		||||
@@ -128,6 +133,7 @@ protected:
 | 
			
		||||
  //! \param[in] pindx Local patch index to extract solution vectors for
 | 
			
		||||
  bool extractPatchDependencies(IntegrandBase* problem,
 | 
			
		||||
                                const PatchVec& model, size_t pindx) const;
 | 
			
		||||
 | 
			
		||||
private:
 | 
			
		||||
  FieldMap  myFields;  //!< The named fields of this SIM object
 | 
			
		||||
  DepVector depFields; //!< Other fields this SIM objecy depends on
 | 
			
		||||
 
 | 
			
		||||
		Reference in New Issue
	
	Block a user