SIMSolverAdap.h

Go to the documentation of this file.

// $Id$
//==============================================================================
//==============================================================================
 
#ifndef _SIM_SOLVER_ADAP_H_
#define _SIM_SOLVER_ADAP_H_
 
#include "SIMSolver.h"
#include "AdaptiveSIM.h"
#include "TimeStep.h"
 
 
template<class T1, bool SolutionTransfer = false>
class AdaptiveISolver : public AdaptiveSIM
{
public:
  AdaptiveISolver(T1& sim, bool sa) : AdaptiveSIM(sim,sa), model(sim) {}
 
  bool adaptMesh(int iStep, std::streamsize outPrec = 0)
  {
    if constexpr (SolutionTransfer) {
      if (iStep > 1) {
        transfered = solution;
        this->prepareAdapt();
      }
      return this->AdaptiveSIM::adaptMesh(iStep, transfered, outPrec);
    } else
      return this->AdaptiveSIM::adaptMesh(iStep, outPrec);
  }
 
protected:
  virtual void prepareAdapt() {}
 
  virtual void prepareSolutionTransfer() {}
 
  bool assembleAndSolveSystem() override
  {
    TimeStep dummy;
    model.init(dummy);
 
    if constexpr (SolutionTransfer) {
      if (!transfered.empty()) {
        this->prepareSolutionTransfer();
        for (size_t i = 0; i < transfered.size(); ++i)
          model.setSolution(transfered[i], i);
      }
    }
 
    if (model.solveStep(dummy))
      solution = model.getSolutions();
    else
      return false;
 
    return true;
  }
 
  bool savePoints(int iStep) const override
  {
    return model.savePoints(0.0,iStep);
  }
 
  T1& model; 
  Vectors transfered; 
};
 
 
template<class T1, class AdapSim>
class SIMSolverAdapImpl : public SIMSolverStat<T1>
{
public:
  explicit SIMSolverAdapImpl(T1& s1) : SIMSolverStat<T1>(s1), aSim(s1,false)
  {
    this->S1.setSol(&aSim.getSolution());
    this->S1.opt.saveNorms = true;
  }
 
  virtual ~SIMSolverAdapImpl() {}
 
  virtual bool read(const char* file) { return this->SIMadmin::read(file); }
 
  virtual int solveProblem(char* infile, const char* = nullptr)
  {
    if (!aSim.initAdaptor())
      return 1;
 
    if (SIMSolverStat<T1>::exporter)
      SIMSolverStat<T1>::exporter->setFieldValue(exporterName, &this->S1,
                                                 &aSim.getSolution(),
                                                 &aSim.getProjections(),
                                                 &aSim.getEnorm());
 
    for (int iStep = 1; aSim.adaptMesh(iStep); iStep++)
      if (!aSim.solveStep(infile,iStep))
        return 1;
      else if (!aSim.writeGlv(infile,iStep))
        return 2;
      else if (SIMSolverStat<T1>::exporter)
        SIMSolverStat<T1>::exporter->dumpTimeLevel(nullptr,true);
 
    return 0;
  }
 
  void setExporterName(const std::string& name) { exporterName = name; }
 
protected:
  virtual bool parse(char* kyw, std::istream& is) { return aSim.parse(kyw,is); }
  virtual bool parse(const tinyxml2::XMLElement* elem) { return aSim.parse(elem); }
 
  AdapSim aSim; 
  std::string exporterName = "u"; 
};
 
 
template<class T1>
using SIMSolverAdap = SIMSolverAdapImpl<T1,AdaptiveSIM>;
 
 
template<class T1>
class SIMSolverAdapInternal : public SIMSolverStat<T1>
{
public:
  explicit SIMSolverAdapInternal(T1& s1) : SIMSolverStat<T1>(s1) {}
 
  virtual ~SIMSolverAdapInternal() {}
 
  bool read(const char* file) override { return this->SIMadmin::read(file); }
 
  int solveProblem(char* infile, const char* = nullptr) override
  {
    if (!this->S1.initAdapPrm())
      return 1;
 
    int geoBlk = 0, nBlock = 0;
    for (int iStep = 1; this->S1.adaptMesh(iStep); iStep++) {
      IFEM::cout <<"\nAdaptive step "<< iStep << std::endl;
      if (!this->S1.solveStep(infile,iStep))
        return 1;
      else if (!this->S1.projectNorms(iStep))
        return 2;
      else if (!this->saveState(geoBlk,nBlock,iStep,infile))
        return 3;
    }
 
    return 0;
  }
 
  bool parse(const tinyxml2::XMLElement* elem) override
  {
    return this->S1.parse(elem);
  }
 
protected:
  bool saveState(int& geoBlk, int& nBlock, int iStep, char* infile)
  {
    if (!this->S1.saveModel(iStep == 1 ? infile : nullptr,geoBlk,nBlock))
      return false;
 
    TimeStep tp;
    tp.step = iStep;
 
    if (!this->S1.saveElmNorms(iStep,nBlock))
      return false;
 
    if (!this->S1.saveProjections(iStep,nBlock))
      return false;
 
    if (!this->S1.saveStep(tp,nBlock))
      return false;
 
    return this->exporter ? this->exporter->dumpTimeLevel(&tp,true) : true;
  }
};
 
#endif