calculation_continuity.h

// This file is part of Hermes2D
//
// Copyright (c) 2009 hp-FEM group at the University of Nevada, Reno (UNR).
// Email: hpfem-group@unr.edu, home page: http://hpfem.org/.
//
// Hermes2D is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published
// by the Free Software Foundation; either version 2 of the License,
// or (at your option) any later version.
//
// Hermes2D is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with Hermes2D; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
#include "config.h"
#include "compat.h"
#include "function/solution.h"

namespace Hermes
{
  namespace Hermes2D
  {
    class HERMES_API CalculationContinuityException : public Hermes::Exceptions::Exception
    {
    public:
      enum exceptionEntityType
      {
        meshes,
        spaces,
        solutions,
        time_steps,
        error,
        general
      };
      CalculationContinuityException();
      CalculationContinuityException(exceptionEntityType type, const char * msg);
      void init(exceptionEntityType type, const char * msg);
    };

    class HERMES_API IOCalculationContinuityException : public CalculationContinuityException
    {
    public:
      enum inputOutput
      {
        input,
        output
      };
      IOCalculationContinuityException(exceptionEntityType type, inputOutput inputOutput, const char * filename);
      IOCalculationContinuityException(exceptionEntityType type, inputOutput inputOutput, const char * filename, const char * reason);
    };

    template<typename Scalar>
    class HERMES_API CalculationContinuity
    {
    public:
      enum IdentificationMethod
      {
        timeAndNumber,
        onlyTime,
        onlyNumber
      };

      CalculationContinuity(IdentificationMethod identification_method);

      class HERMES_API Record
      {
      public:
        Record(double time, unsigned int number);
        Record(double time);
        Record(unsigned int number);

        void save_meshes(Hermes::vector<Mesh*> meshes);
        void save_mesh(Mesh* mesh);

        void save_spaces(Hermes::vector<Space<Scalar>*> spaces);
        void save_space(Space<Scalar>* space);

        void save_solutions(Hermes::vector<Solution<Scalar>*> solutions);
        void save_solution(Solution<Scalar>* solution);

        void save_time_step_length(double time_step_length_to_save);
        void save_time_step_length_n_minus_one(double time_step_length_to_save);

        void save_error(double error);

        void load_meshes(Hermes::vector<Mesh*> meshes);
        void load_mesh(Mesh* mesh);

        Hermes::vector<Space<Scalar>*> load_spaces(Hermes::vector<Mesh*> meshes, Hermes::vector<EssentialBCs<Scalar>*> essential_bcs, Hermes::vector<Shapeset*> shapeset = Hermes::vector<Shapeset*>());

        Hermes::vector<Space<Scalar>*> load_spaces(Hermes::vector<Mesh*> meshes, Hermes::vector<Shapeset*> shapeset = Hermes::vector<Shapeset*>());

        Space<Scalar>* load_space(Mesh* mesh, EssentialBCs<Scalar>* essential_bcs = NULL, Shapeset* shapeset = NULL);

        void load_solutions(Hermes::vector<Solution<Scalar>*> solutions, Hermes::vector<Space<Scalar>*> spaces);
        void load_solution(Solution<Scalar>* solution, Space<Scalar>* space);

        void load_time_step_length(double & time_step_length);
        void load_time_step_length_n_minus_one(double & time_step_length);

        void load_error(double & error);

        double get_time();

        unsigned int get_number();

      private:
        Hermes::vector<std::string> meshFiles;
        Hermes::vector<std::string> spaceFiles;
        Hermes::vector<std::string> solutionFiles;

        double time;
        unsigned int number;
      };

      void add_record(double time, unsigned int number, Mesh* mesh, Space<Scalar>* space = NULL, Solution<Scalar>* sln = NULL, double time_step = 0.0, double time_step_n_minus_one = 0.0, double error = 0.0);
      void add_record(double time, unsigned int number, Hermes::vector<Mesh*> meshes, Hermes::vector<Space<Scalar>*> spaces = Hermes::vector<Space<Scalar>*>(), Hermes::vector<Solution<Scalar>*> slns = Hermes::vector<Solution<Scalar>*>(), double time_step = 0.0, double time_step_n_minus_one = 0.0, double error = 0.0);

      void add_record(double time, Mesh* mesh, Space<Scalar>* space = NULL, Solution<Scalar>* sln = NULL, double time_step = 0.0, double time_step_n_minus_one = 0.0, double error = 0.0);
      void add_record(double time, Hermes::vector<Mesh*> meshes, Hermes::vector<Space<Scalar>*> spaces = Hermes::vector<Space<Scalar>*>(), Hermes::vector<Solution<Scalar>*> slns = Hermes::vector<Solution<Scalar>*>(), double time_step = 0.0, double time_step_n_minus_one = 0.0, double error = 0.0);

      void add_record(unsigned int number, Mesh* mesh, Space<Scalar>* space = NULL, Solution<Scalar>* sln = NULL, double time_step = 0.0, double time_step_n_minus_one = 0.0, double error = 0.0);
      void add_record(unsigned int number, Hermes::vector<Mesh*> meshes, Hermes::vector<Space<Scalar>*> spaces = Hermes::vector<Space<Scalar>*>(), Hermes::vector<Solution<Scalar>*> slns = Hermes::vector<Solution<Scalar>*>(), double time_step = 0.0, double time_step_n_minus_one = 0.0, double error = 0.0);

      bool have_record_available();

      Record* get_last_record() const;

      int get_num() const;

      static void set_mesh_file_name(std::string mesh_file_nameToSet);
      static void set_space_file_name(std::string space_file_nameToSet);
      static void set_solution_file_name(std::string solution_file_nameToSet);
      static void set_time_step_file_name(std::string time_step_file_nameToSet);
      static void set_error_file_name(std::string error_file_nameToSet);

    private:
      static std::string mesh_file_name;
      static std::string space_file_name;
      static std::string solution_file_name;
      static std::string time_step_file_name;
      static std::string time_stepNMinusOne_file_name;
      static std::string error_file_name;

      std::map<std::pair<double, unsigned int>, Record*> records;

      std::map<double, Record*> time_records;

      std::map<unsigned int, Record*> numbered_records;

      Record* last_record;

      bool record_available;

      IdentificationMethod identification_method;

      int num;

      friend class Record;
    };
  }
}