inmost_model.h

#ifndef INMOST_MODEL_INCLUDED
#define INMOST_MODEL_INCLUDED
 
#include "inmost_common.h"
#include "inmost_autodiff.h"
#include "inmost_residual.h"
#include "inmost_operator.h"
 
#if defined(USE_AUTODIFF) && defined(USE_MESH) && defined(USE_SOLVER)
 
namespace INMOST
{
 
    class Model;
    class AbstractOperator;
 
    class AbstractSubModel
    {
    public:
        virtual bool PrepareEntries(Model& P) = 0;
        virtual bool Initialize(Model& P) = 0;
        virtual bool SetupCoupling(Model& P) { return true; }
        virtual bool PrepareIterations() { return true; }
        virtual bool FillResidual(Residual& R) const = 0;
        virtual bool UpdateSolution(const Sparse::Vector& sol, double alpha) = 0;
        virtual bool UpdateTimeStep() = 0;
        virtual bool SetTimeStep(double dt) = 0;
        virtual bool SetTime(double t) = 0;
        virtual bool RestoreTimeStep() = 0;
        virtual double UpdateMultiplier(const Sparse::Vector& sol) const { (void)sol; return 1; }
        virtual double AdjustTimeStep(double dt) const { return dt; }
        /*
        virtual void Adaptation(Mesh& m) const { (void)m; }
 
        virtual void PrepareAdaptation(Mesh& m) { (void)m; }
 
        //new hanging node was introduced, no connectivity at function call
        virtual void NewNode(Cell& c, Node& n, Storage::reference_array cell_hanging_nodes) { (void)c; (void)n; (void)cell_hanging_nodes; }
        virtual void NewNode(Face& f, Node& n, Storage::reference_array face_hanging_nodes) { (void)f; (void)n; (void)face_hanging_nodes; }
        virtual void NewNode(Edge& e, Node& n) { (void)e; (void)n; }
        //new hanging edge was introduced, no connectivity at function call
        virtual void NewEdge(Cell& c, Edge& e) { (void)c; (void)e; }
        virtual void NewEdge(Face& f, Edge& e) { (void)f; (void)e; }
        //new hanging face was introduced, no connectivity at function call
        virtual void NewFace(Cell& c, Face& f) { (void)c; (void)f; }
        //element was refined into new elements
        virtual void CellRefinement(Cell& old_cell, ElementArray<Cell>& new_cells, ElementSet& new_cell_set) { (void)old_cell; (void)new_cells; (void)new_cell_set; }
        virtual void FaceRefinement(Face& old_face, ElementArray<Face>& new_faces) { (void)old_face; (void)new_faces; }
        virtual void EdgeRefinement(Edge& old_edge, ElementArray<Edge>& new_edges) { (void)old_edge; (void)new_edges; }
        //old elements were connected into an old element
        virtual void CellCoarsening(ElementArray<Cell>& old_cells, Cell& new_cell, ElementSet& old_cells_set) { (void)old_cells; (void)new_cell; (void)old_cells_set; }
        virtual void FaceCoarsening(ElementArray<Face>& old_faces, Face& new_face) { (void)old_faces; (void)new_face; }
        virtual void EdgeCoarsening(ElementArray<Edge>& old_edges, Edge& new_edge) { (void)old_edges; (void)new_edge; }
        */
        virtual void PrepareOutput() {}
        virtual void FinishOutput() {}
    };
 
    class AbstractCouplingTerm
    {
    public:
        virtual bool Initialize(Model& P) = 0;
        virtual bool SetupCoupling(Model& P) { return true; }
        virtual bool FillResidual(Residual& R) const = 0;
        
        
        virtual bool PrepareIterations() { return true; }
        virtual bool UpdateTimeStep() { return true; }
        virtual bool SetTimeStep(double dt) { return true; }
        virtual bool SetTime(double t) { return true; }
        virtual bool RestoreTimeStep() { return true; }
        virtual double UpdateMultiplier(const Sparse::Vector& sol) const { (void)sol; return 1; }
        virtual double AdjustTimeStep(double dt) const { return dt; }
    };
 
    class AbstractScalarFunction
    {
    public:
        virtual bool Initialize(Model& P) = 0;
        virtual bool SetupCoupling(Model& P) { return true; }
        virtual variable Evaluate(const Storage& e) const = 0;
 
        
        virtual bool PrepareIterations() { return true; }
        virtual bool UpdateTimeStep() { return true; }
        virtual bool SetTimeStep(double dt) { return true; }
        virtual bool SetTime(double t) { return true; }
        virtual bool RestoreTimeStep() { return true; }
        virtual double UpdateMultiplier(const Sparse::Vector& sol) const { (void)sol; return 1; }
        virtual double AdjustTimeStep(double dt) const { return dt; }
    };
 
    class AbstractMatrixFunction
    {
    public:
        virtual bool Initialize(Model& P) = 0;
        virtual bool SetupCoupling(Model& P) { return true; }
        virtual vMatrix Evaluate(const Storage& e) const = 0;
 
 
        virtual bool PrepareIterations() { return true; }
        virtual bool UpdateTimeStep() { return true; }
        virtual bool SetTimeStep(double dt) { return true; }
        virtual bool SetTime(double t) { return true; }
        virtual bool RestoreTimeStep() { return true; }
        virtual double UpdateMultiplier(const Sparse::Vector& sol) const { (void)sol; return 1; }
        virtual double AdjustTimeStep(double dt) const { return dt; }
    };
    
    class Model
    {
        Automatizator & aut; 
        //todo: decide later on how it should be stored
        std::vector< std::pair<std::string, AbstractSubModel *> > SubModels; 
        std::vector< std::pair<std::string, AbstractEntry *> > Entries; 
        std::vector< std::pair<std::string, Mesh *> > Meshes; 
        std::map< AbstractSubModel*, std::vector< std::pair<std::string, AbstractCouplingTerm*> > > CouplingTerms; 
        //std::map< AbstractSubModel*, std::vector< std::pair<std::string, AbstractEntry*> > > SubModelEntries;
        std::vector< std::pair<std::string, AbstractScalarFunction*> > ScalarFunctions; 
        std::vector< std::pair<std::string, AbstractMatrixFunction*> > MatrixFunctions; 
        std::vector< std::pair<std::string, AbstractOperator *> > Operators; 
        std::map< std::string, bool> activeEntries, activeSubModels; 
 
        bool initialized; 
        bool setentries; 
    public:
        Model(Automatizator & aut) : aut(aut), initialized(false), setentries(false) {}
        //todo:
        //Model(const Model & b) aut(b.aut) {}
        //todo:
        //Model & operator =(Model const & b);
        virtual ~Model() {}
        void ActivateSubModel(std::string name) { activeSubModels[name] = true; }
        void DeactivateSubModel(std::string name) { activeSubModels[name] = false; }
        void ToggleEntryState();
        void ActivateEntry(std::string name) { activeEntries[name] = true; }
        void DeactivateEntry(std::string name) { activeEntries[name] = false; }
        void AddEntry(std::string name, AbstractEntry& entry);
        void AddAfterEntry(std::string name, AbstractEntry& entry, std::string after);
        void AddFirstEntry(std::string name, AbstractEntry& entry);
        void AddMesh(std::string name, Mesh & m);
        void AddSubModel(std::string name, AbstractSubModel & submodel);
        void AddCouplingTerm(std::string submodel, std::string name, AbstractCouplingTerm& term);
        void AddScalarFunction(std::string name, AbstractScalarFunction& func);
        void AddMatrixFunction(std::string name, AbstractMatrixFunction& func);
        void AddOperator(std::string name, AbstractOperator & op);
        Automatizator & GetAutomatizator() {return aut;}
        const Automatizator & GetAutomatizator() const {return aut;}
        Mesh * GetMesh(std::string);
        const Mesh * GetMesh(std::string) const;
        std::vector<std::string> GetMeshesNames() const;
        AbstractEntry * GetEntry(std::string name);
        const AbstractEntry * GetEntry(std::string name) const;
        std::vector<std::string> GetEntriesNames() const;
        AbstractSubModel * GetSubModel(std::string name);
        const AbstractSubModel * GetSubModel(std::string name) const;
        std::string GetSubModelName(const AbstractSubModel* model) const;
        std::vector<std::string> GetSubModelsNames() const;
        AbstractCouplingTerm* GetCouplingTerm(std::string submodel, std::string name);
        const AbstractCouplingTerm* GetCouplingTerm(std::string submodel, std::string name) const;
        std::vector< std::pair< std::string, std::vector<std::string> > > GetCouplingTermNames() const;
        AbstractScalarFunction* GetScalarFunction(std::string name);
        const AbstractScalarFunction* GetScalarFunction(std::string name) const;
        std::vector<std::string> GetScalarFunctionNames() const;
        AbstractMatrixFunction* GetMatrixFunction(std::string name);
        const AbstractMatrixFunction* GetMatrixFunction(std::string name) const;
        std::vector<std::string> GetMatrixFunctionNames() const;
        AbstractOperator * GetOperator(std::string name);
        const AbstractOperator * GetOperator(std::string name) const;
        std::vector<std::string> GetOperatorsNames() const;
        bool PrepareEntries();
        bool Initialize();
        bool SetupCoupling();
        bool PrepareIterations();
        bool FillResidual(Residual & R) const;
        bool UpdateSolution(const Sparse::Vector & sol, double alpha);
        bool UpdateTimeStep();
        bool SetTimeStep(double dt);
        bool SetTime(double t);
        bool RestoreTimeStep();
        bool isInitialized() const {return initialized;}
        bool areEntriesSet() const { return setentries; }
        void SynchronizeData() { aut.SynchronizeData(); }
        double UpdateMultiplier(const Sparse::Vector & sol) const;
        double AdjustTimeStep(double dt) const;
        /*
        void Adaptation(Mesh & m) const;
        
        void PrepareAdaptation(Mesh& m);
 
        void NewNode(Cell& c, Node& n, Storage::reference_array cell_hanging_nodes);
        void NewNode(Face& f, Node& n, Storage::reference_array face_hanging_nodes);
        void NewNode(Edge& e, Node& n);
 
        void NewEdge(Cell& c, Edge& e);
        void NewEdge(Face& f, Edge& e);
 
        void NewFace(Cell& c, Face& f);
        
        void CellRefinement(Cell & old_cell, ElementArray<Cell> & new_cells, ElementSet & new_cell_set);
        void FaceRefinement(Face & old_face, ElementArray<Face> & new_faces);
        void EdgeRefinement(Edge & old_edge, ElementArray<Edge> & new_edges);
        
        void CellCoarsening(ElementArray<Cell> & old_cells, Cell & new_cell, ElementSet & old_cells_set);
        void FaceCoarsening(ElementArray<Face> & old_faces, Face & new_face);
        void EdgeCoarsening(ElementArray<Edge> & old_edges, Edge & new_edge);
        */
        void ReportErrors(const Residual & R) const;
        void PrepareOutput();
        void FinishOutput();
    };
}
 
#endif //USE_AUTODIFF && USE_MESH && USE_SOLVER
 
#endif //INMOST_MODEL_INCLUDED