MultiStepSIM.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _MULTI_STEP_SIM_H
#define _MULTI_STEP_SIM_H
 
#include "SIMsolution.h"
#include "SIMadmin.h"
#include "SIMenums.h"
 
class SIMoutput;
class SIMbase;
class TimeStep;
struct TimeDomain;
 
 
class MultiStepSIM : public SIMsolution, public SIMadmin
{
protected:
  enum NormOp { MAX, ALL };
 
  explicit MultiStepSIM(SIMbase& sim);
 
public:
  virtual void printProblem(bool stopInputTimer = false) const;
 
  virtual const char** getPrioritizedTags() const;
 
  using SIMadmin::parse;
  virtual bool parse(const tinyxml2::XMLElement* elem);
 
  virtual void initPrm();
 
  virtual void initSol(size_t nSol = 1, size_t nDof = 0);
 
  bool initEqSystem(bool withRF = true, size_t nScl = 0);
 
  virtual bool advanceStep(TimeStep& param, bool updateTime = true);
 
  virtual SIM::ConvStatus solveStep(TimeStep& param,
                                    SIM::SolutionMode = SIM::STATIC,
                                    double zero_tolerance = 1.0e-8,
                                    std::streamsize outPrec = 0) = 0;
 
protected:
  void printStep(const TimeStep& param) const;
 
  virtual bool solutionNorms(const TimeDomain&, double zero_tolerance = 1.0e-8,
                             std::streamsize outPrec = 0);
 
  int getLastSavedStep() const { return lastSt; }
 
public:
  virtual bool preprocess(const std::vector<int>& ignored, bool fixDup);
 
  void setStartGeo(int gID);
 
  bool saveModel(const char* fileName);
 
  bool saveModel(int& gBlock, int& rBlock, const char* fileName = nullptr,
                 bool clearG = true);
 
  bool saveModel(int& gBlock, int& rBlock, double time);
 
  bool saveStep(int iStep, double time, const char* vecName = nullptr);
  bool saveStep(int iStep, int& rBlock, double time,
                const char* vecName = nullptr);
  bool saveStep(int iStep, int& rBlock, const char* vecName);
 
  virtual bool serialize(SerializeMap& data) const;
  virtual bool deSerialize(const SerializeMap& data);
  bool checkForRestart();
 
  void dumpStep(int iStep, double time, utl::LogStream& os,
                bool withID = true) const;
 
  virtual void dumpResults(double time, utl::LogStream& os,
                           std::streamsize precision = 3,
                           bool formatted = true) const;
 
  bool hasPointResultFile() const;
  bool savePoints(double time, int step) const;
 
  virtual bool isLinear() const { return true; }
  virtual bool isDynamic() const { return false; }
 
  const SIMoutput& getModel() const { return model; }
 
  enum SubIt { ITER = 0, FIRST = 1, LAST = 2, NONE = 3 };
 
  void setSubIteration(SubIt flag) { subiter = flag; }
  SubIt getSubIteration() const { return subiter; }
 
  virtual size_t numSolution() const { return solution.size(); }
  virtual const Vector& realSolution(int i = 0) const { return solution[i]; }
  virtual const Vectors& realSolutions(bool = false) { return solution; }
 
  double* theRefNorm() { return &refNorm; }
  const double* getRefNorm() const { return &refNorm; }
 
protected:
  SIMoutput& model; 
  Vector loadVec;   
  Vector residual;  
  Vector linsol;    
 
  NormOp refNopt; 
  double refNorm; 
  double rCond;   
  SubIt  subiter; 
  size_t nRHSvec; 
  char   rotUpd;  
 
  int geoBlk; 
  int nBlock; 
 
private:
  bool saveBCs; 
  int  lastSt;  
};
 
#endif