SIMinput.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SIM_INPUT_H
#define _SIM_INPUT_H
 
#include "SIMbase.h"
#include "TopologySet.h"
#include "Interface.h"
#include "Vec3.h"
 
class ModelGenerator;
class IntFunc;
 
namespace LR { struct RefineData; }
 
 
class SIMinput : public SIMbase
{
public:
  struct ICInfo
  {
    int file_level; 
    int geo_level;  
    char basis;     
    char component; 
    std::string sim_field;  
    std::string file_basis; 
    std::string file_field; 
    std::string function;   
 
    ICInfo() : file_level(-1), geo_level(0), basis(1), component(0) {}
    explicit ICInfo(const std::string& f) : file_level(-1), geo_level(0),
                                            basis(1), component(0),
                                            sim_field(f), file_field(f) {}
  };
  typedef std::vector<ICInfo> InitialCondVec; 
  typedef std::vector<unsigned char> CharVec; 
  typedef std::pair<int,Vec3>        IdxVec3; 
 
protected:
  explicit SIMinput(IntegrandBase* itg);
 
public:
  virtual ~SIMinput() {}
 
  virtual const char** getPrioritizedTags() const;
 
  bool readTopologyOnly(const std::string& fileName);
 
  int getUniquePropertyCode(const std::string& setName, int comp = 0);
 
  size_t setVecProperty(int code, Property::Type ptype,
                        VecFunc* field = nullptr, int pflag = -1);
 
  bool setTracProperty(int code, Property::Type ptype,
                       TractionFunc* field = nullptr);
 
private:
  bool parseGeometryTag(const tinyxml2::XMLElement* elem);
  bool parseBCTag(const tinyxml2::XMLElement* elem);
  bool parseICTag(const tinyxml2::XMLElement* elem);
  bool parseLinSolTag(const tinyxml2::XMLElement* elem);
 
protected:
  virtual bool parse(char* keyWord, std::istream& is);
 
  virtual bool parse(const tinyxml2::XMLElement* elem);
 
  virtual bool parseGeometryDimTag(const tinyxml2::XMLElement* elem) = 0;
  bool parsePeriodic(const tinyxml2::XMLElement* elem);
  virtual bool parseOutputTag(const tinyxml2::XMLElement* elem);
  FunctionBase* parseDualTag(const tinyxml2::XMLElement* elem, int ftype = 1);
  int parseMaterialSet(const tinyxml2::XMLElement* elem, int mindex);
  bool parseTopologySet(const tinyxml2::XMLElement* elem,
                        std::vector<int>& patches) const;
  bool parsePatchList(const tinyxml2::XMLElement* elem,
                      std::vector<int>& patches) const;
 
  virtual IntFunc* parseElemActivator(const std::string&,
                                      const std::string&) const;
 
  bool createPropertySet(const std::string& setName, int pc);
 
public:
  size_t setPropertyType(int code, Property::Type ptype, int pindex = -1,
                         char basis = 1);
 
  bool setNeumann(const std::string& prop, const std::string& type,
                  int ndir, int code);
 
  std::vector<int> getFunctionsForElements(const std::vector<int>& elements);
 
  bool refine(const LR::RefineData& prm);
  bool refine(const LR::RefineData& prm, Vector& sol);
  bool refine(const LR::RefineData& prm, Vectors& sol);
 
  int refine(const RealFunc& refC, double refTol);
 
  bool readPatches(std::istream& isp, const char* whiteSpace = "");
 
  bool addConnection(int mst, int slv, int mIdx, int sIdx,
                     bool coordCheck = false, int dim = 1, int thick = 1)
  {
    return this->connectPatches(ASM::Interface{mst,slv,mIdx,sIdx,0,dim,0,thick},
                                coordCheck);
  }
 
  const std::vector<ASM::Interface>& getInterfaces() const
  { return myInterfaces; }
 
protected:
  static std::istream* getPatchStream(const char* tag, const char* patch);
 
  virtual ASMbase* readPatch(std::istream& isp, int pchInd,
                             const CharVec& unf = CharVec(),
                             const char* whiteSpace = "") const = 0;
 
  virtual bool readNodes(std::istream& isn, int pchInd, int basis = 0,
                         bool oneBased = false) { return false; }
  virtual void readNodes(std::istream& isn) {}
 
  virtual ModelGenerator* getModelGenerator(const tinyxml2::XMLElement* geo) const = 0;
 
  virtual bool connectPatches(const ASM::Interface& ifc, bool coordCheck) = 0;
 
  typedef std::map<std::string,std::string> SerializeMap; 
 
  bool saveBasis(SerializeMap& data) const;
 
  bool restoreBasis(const SerializeMap& data);
 
public:
  int restartBasis(const std::string& restartFile, int restartStep);
 
  virtual bool createFEMmodel(char resetNumb = 'y');
 
  virtual void clonePatches(const PatchVec&, const std::map<int,int>&) {}
 
  virtual bool hasIC(const std::string& name) const;
 
  bool setInitialConditions(SIMdependency* fieldHolder = nullptr);
 
  virtual bool deSerialize(const SerializeMap&);
 
  const TopEntity& getEntity(const std::string& name) const;
  TopEntity& topology(const std::string& name) { return myEntitys[name]; }
  const TopologySet& getTopology() const { return myEntitys; }
 
  bool getTopItemNodes(const TopItem& titem, std::vector<int>& glbNodes) const;
 
  IdxVec3* getDiscretePoint(int idx);
 
  virtual std::vector<std::vector<int>> getElmConnectivities() const;
 
private:
  bool setInitialCondition(SIMdependency* fieldHolder,
                           const std::string& fileName,
                           const InitialCondVec& info);
 
protected:
  ModelGenerator* myGen; 
 
  TopologySet myEntitys; 
 
  std::vector<IdxVec3> myTopPts; 
 
  std::vector<ASM::Interface> myInterfaces; 
 
  std::map<std::string,InitialCondVec> myICs; 
 
private:
  bool isReading; 
  bool isSaved;   
};
 
#endif