models.hh

Go to the documentation of this file.

 
#ifndef models_hh
#define models_hh
 
#include <sys/utsname.h>
#include "basics/exceptions.hh"
#include "basics/outputOperator.hh"
#include "toolbox/inputOutput.hh"
#include "formula/formula.hh"
#include "geometry/mesh.hh"
#include "graphics/matlab.hh"
#include "space/space.hh"
#include "function/vector.hh"
 
 
#define ModelControl_formulaOut_D 0
 
namespace concepts {
 
  // forward declaration
  template<class F>
  class ModelControlBase;
 
  template<class F>
  class ModelControl;
 
  // ********************************************************* ModelNotSolved **
 
  class ModelNotSolved : public ExceptionBase {};
 
  // ********************************************************* MatrixNotBuilt **
 
  class MatrixNotBuilt : public ExceptionBase {};
 
  // ***************************************************************** Model **
  
  template<class F>
  class Model : public OutputOperator {
    friend class ModelControlBase<Model<F> >;
    friend class ModelControl<Model<F> >;
  public:
    typedef F type;
    
    Model(const std::string problemName);
    virtual ~Model() {}
    virtual Space<Real>& space() const = 0;
    const Vector<F>* solution() {
      solve_();
      return sol_.get();
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    virtual Mesh& mesh_() = 0;
    virtual const std::string mshAbbr_() = 0;
    std::unique_ptr<Vector<F> > sol_;
    virtual void solve_() = 0;
    const std::string problemName_;
  };
 
  // ****************************************************** ModelControlBase **
 
  template<class F>
  class ModelControlBase : public OutputOperator {
  public:
    ModelControlBase(F& model) : model_(model) {
      parameters_.addString("vectorFile", "");
    }
    virtual ~ModelControlBase() {}
    virtual F& model() { return model_; }
    virtual const F& model() const { return model_; }
    void loadSolution(const std::string vectorFile);
    void writeSolution(const std::string vectorFile, bool verbose = true);
    void basisFunctions(const std::string path = "");
    virtual void dataOut(concepts::InOutParameters& parameters,
       const bool store = false,
       const std::string path = "");
    const concepts::InOutParameters& parameters() const {
      return parameters_;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    F& model_;
    concepts::InOutParameters parameters_;
    virtual std::string filename_(const std::string varname,
          const std::string path,
          const bool flag = false);
    void newfile_(std::string& name, const std::string varname,
      const std::string ending);
    template<class G>
    void formulaOut_(const concepts::PiecewiseFormulaBase<G>& frm,
                     const std::string frmstr, const std::string name);
 
  };
 
  template<class F>
  template<class G>
  void ModelControlBase<F>::formulaOut_
  (const concepts::PiecewiseFormulaBase<G>& frm,
   const std::string frmstr, const std::string name)
  {
    DEBUGL(ModelControl_formulaOut_D,
     "Writing formula " << frmstr << " into " << name << ".m");
    graphics::MatlabGraphics(model_.space(), name.c_str(), frm);
    parameters_.addString((std::string("grafik_") + frmstr).c_str(),
        (name + ".m").c_str());
  }
 
  // ********************************************************** ModelControl **
 
  template<class F>
  class ModelControl : public ModelControlBase<F> {
  public:
    ModelControl(F& model) : ModelControlBase<F>(model) {}
  };
 
} // namespace concepts
 
#endif // models_hh