Hermes::vector<Space<Scalar>*> CalculationContinuity<Scalar>::Record::load_spaces(Hermes::vector<Mesh*> meshes, Hermes::vector<Shapeset*> shapesets)
{
Hermes::vector<Space<Scalar>*> spaces;
if(shapesets == Hermes::vector<Shapeset*>())
for(unsigned int i = 0; i < meshes.size(); i++)
shapesets.push_back(NULL);
for(unsigned int i = 0; i < meshes.size(); i++)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::space_file_name << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
spaces.push_back(Space<Scalar>::load(filename.str().c_str(), meshes[i], false, NULL, shapesets[i]));
}
catch(Hermes::Exceptions::SpaceLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
}
void CalculationContinuity<Scalar>::add_record(unsigned int number, Hermes::vector<Mesh*> meshes, Hermes::vector<Space<Scalar>*> spaces, Hermes::vector<Solution<Scalar>*> slns, double time_step, double time_step_n_minus_one, double error)
{
std::ofstream ofile("onlyNumber.h2d", std::ios_base::app);
if(ofile)
{
ofile << ++this->num << ' ' << number << std::endl;
ofile.close();
}
else
throw IOCalculationContinuityException(CalculationContinuityException::general, IOCalculationContinuityException::output, "onlyNumber.h2d");
CalculationContinuity<Scalar>::Record* record = new CalculationContinuity<Scalar>::Record(number);
record->save_meshes(meshes);
if(spaces != Hermes::vector<Space<Scalar>*>())
record->save_spaces(spaces);
if(slns != Hermes::vector<Solution<Scalar>*>())
record->save_solutions(slns);
if(time_step > 0.0)
record->save_time_step_length(time_step);
if(time_step_n_minus_one > 0.0)
record->save_time_step_length_n_minus_one(time_step_n_minus_one);
if(error > 0.0)
record->save_error(error);
this->numbered_records.insert(std::pair<unsigned int, CalculationContinuity<Scalar>::Record*>(number, record));
this->last_record = record;
}
void CalculationContinuity<Scalar>::add_record(double time, Mesh* mesh, Space<Scalar>* space, Solution<Scalar>* sln, double time_step, double time_step_n_minus_one, double error)
{
std::ofstream ofile("onlyTime.h2d", std::ios_base::app);
if(ofile)
{
ofile << ++this->num << ' ' << time << std::endl;
ofile.close();
}
else
throw IOCalculationContinuityException(CalculationContinuityException::general, IOCalculationContinuityException::output, "onlyTime.h2d");
CalculationContinuity<Scalar>::Record* record = new CalculationContinuity<Scalar>::Record(time);
record->save_mesh(mesh);
if(space != NULL)
record->save_space(space);
if(sln != NULL)
record->save_solution(sln);
if(time_step > 0.0)
record->save_time_step_length(time_step);
if(time_step_n_minus_one > 0.0)
record->save_time_step_length_n_minus_one(time_step_n_minus_one);
if(error > 0.0)
record->save_error(error);
this->time_records.insert(std::pair<double, CalculationContinuity<Scalar>::Record*>(time, record));
this->last_record = record;
}
void CalculationContinuity<Scalar>::Record::load_solution(Solution<Scalar>* solution, Space<Scalar>* space)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::solution_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
solution->load(filename.str().c_str(), space);
solution->space_type = space->get_type();
}
catch(Hermes::Exceptions::SolutionLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::solutions, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::solutions, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
Space<Scalar>* CalculationContinuity<Scalar>::Record::load_space(Mesh* mesh, EssentialBCs<Scalar>* essential_bcs, Shapeset* shapeset)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::space_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
return Space<Scalar>::load(filename.str().c_str(), mesh, false, essential_bcs, shapeset);
}
catch(Hermes::Exceptions::SpaceLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::load_space(Space<Scalar>* space, SpaceType space_type, Mesh* mesh, EssentialBCs<Scalar>* essential_bcs, Shapeset* shapeset)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::spaceFileName << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
space->free();
try
{
switch(space_type)
{
case HERMES_H1_SPACE:
if(essential_bcs == NULL)
dynamic_cast<H1Space<Scalar>*>(space)->load(filename.str().c_str(), mesh, shapeset);
else
dynamic_cast<H1Space<Scalar>*>(space)->load(filename.str().c_str(), mesh, essential_bcs, shapeset);
break;
case HERMES_HCURL_SPACE:
if(essential_bcs == NULL)
dynamic_cast<HcurlSpace<Scalar>*>(space)->load(filename.str().c_str(), mesh, shapeset);
else
dynamic_cast<HcurlSpace<Scalar>*>(space)->load(filename.str().c_str(), mesh, essential_bcs, shapeset);
break;
case HERMES_HDIV_SPACE:
if(essential_bcs == NULL)
dynamic_cast<HdivSpace<Scalar>*>(space)->load(filename.str().c_str(), mesh, shapeset);
else
dynamic_cast<HdivSpace<Scalar>*>(space)->load(filename.str().c_str(), mesh, essential_bcs, shapeset);
break;
case HERMES_L2_SPACE:
dynamic_cast<L2Space<Scalar>*>(space)->load(filename.str().c_str(), mesh, shapeset);
break;
}
}
catch(Hermes::Exceptions::SpaceLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::load_spaces(Hermes::vector<Space<Scalar>*> spaces, Hermes::vector<SpaceType> space_types, Hermes::vector<Mesh*> meshes, Hermes::vector<Shapeset*> shapesets)
{
if(shapesets == Hermes::vector<Shapeset*>())
for(unsigned int i = 0; i < spaces.size(); i++)
shapesets.push_back(NULL);
for(unsigned int i = 0; i < spaces.size(); i++)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::spaceFileName << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
spaces[i]->free();
try
{
switch(space_types[i])
{
case HERMES_H1_SPACE:
dynamic_cast<H1Space<Scalar>*>(spaces[i])->load(filename.str().c_str(), meshes[i], shapesets[i]);
break;
case HERMES_HCURL_SPACE:
dynamic_cast<HcurlSpace<Scalar>*>(spaces[i])->load(filename.str().c_str(), meshes[i], shapesets[i]);
break;
case HERMES_HDIV_SPACE:
dynamic_cast<HdivSpace<Scalar>*>(spaces[i])->load(filename.str().c_str(), meshes[i], shapesets[i]);
break;
case HERMES_L2_SPACE:
dynamic_cast<L2Space<Scalar>*>(spaces[i])->load(filename.str().c_str(), meshes[i], shapesets[i]);
break;
}
}
catch(Hermes::Exceptions::SpaceLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
}
void CalculationContinuity<Scalar>::Record::save_solution(Solution<Scalar>* solution)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::solution_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
solution->save(filename.str().c_str());
}
catch(Hermes::Exceptions::SolutionSaveFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::solutions, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::save_space(Space<Scalar>* space)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::space_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
space->save(filename.str().c_str());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::load_solutions(Hermes::vector<Solution<Scalar>*> solutions, Hermes::vector<Space<Scalar>*> spaces)
{
if(solutions.size() != spaces.size())
throw Exceptions::LengthException(1, 2, solutions.size(), spaces.size());
for(unsigned int i = 0; i < solutions.size(); i++)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::solution_file_name << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
solutions[i]->load(filename.str().c_str(), spaces[i]);
solutions[i]->space_type = spaces[i]->get_type();
}
catch(Hermes::Exceptions::SolutionLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::solutions, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::solutions, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
}
void CalculationContinuity<Scalar>::Record::save_mesh(Mesh* mesh)
{
MeshReaderH2DXML reader;
std::stringstream filename;
filename << CalculationContinuity<Scalar>::mesh_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
reader.save(filename.str().c_str(), mesh);
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::meshes, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::load_mesh(Mesh* mesh)
{
MeshReaderH2DXML reader;
std::stringstream filename;
filename << CalculationContinuity<Scalar>::mesh_file_name << 0 << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
reader.load(filename.str().c_str(), mesh);
}
catch(Hermes::Exceptions::MeshLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::meshes, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::save_error(double error)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::error_file_name << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
std::ofstream out(filename.str().c_str());
out << error;
out.close();
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::error, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::save_time_step_length_n_minus_one(double time_step_length_to_save)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::time_stepNMinusOne_file_name << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
std::ofstream out(filename.str().c_str());
out << time_step_length_to_save;
out.close();
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::time_steps, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::load_error(double & error)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::error_file_name << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
std::ifstream in(filename.str().c_str());
in >> error;
in.close();
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::error, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::load_time_step_length_n_minus_one(double & time_step_length)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::time_stepNMinusOne_file_name << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
std::ifstream in(filename.str().c_str());
in >> time_step_length;
in.close();
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::time_steps, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
void CalculationContinuity<Scalar>::Record::save_spaces(Hermes::vector<Space<Scalar>*> spaces)
{
for(unsigned int i = 0; i < spaces.size(); i++)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::space_file_name << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
spaces[i]->save(filename.str().c_str());
}
catch(std::exception& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::spaces, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
}
void CalculationContinuity<Scalar>::Record::save_solutions(Hermes::vector<Solution<Scalar>*> solutions)
{
for(unsigned int i = 0; i < solutions.size(); i++)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::solutionFileName << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
solutions[i]->save(filename.str().c_str());
}
catch(Hermes::Exceptions::SolutionSaveFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::solutions, IOCalculationContinuityException::output, filename.str().c_str(), e.what());
}
}
}
void CalculationContinuity<Scalar>::Record::load_meshes(Hermes::vector<Mesh*> meshes)
{
MeshReaderH2DXML reader;
for(unsigned int i = 0; i < meshes.size(); i++)
{
std::stringstream filename;
filename << CalculationContinuity<Scalar>::mesh_file_name << i << '_' << (std::string)"t = " << this->time << (std::string)"n = " << this->number << (std::string)".h2d";
try
{
reader.load(filename.str().c_str(), meshes[i]);
}
catch(Hermes::Exceptions::MeshLoadFailureException& e)
{
throw IOCalculationContinuityException(CalculationContinuityException::meshes, IOCalculationContinuityException::input, filename.str().c_str(), e.what());
}
}
}
