Recording and reading series

Recorder for time steps and solution sequences. More...

Collaboration diagram for Recording and reading series:

Files
file	SeriesRecorder.hpp
	MoFEM interface.

Macros
#define	_IT_SERIES_STEPS_BY_NAME_FOR_LOOP_(RECORDER, NAME, IT)
	loop over recorded series step More...

Functions
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::add_series_recorder (const std::string &series_name)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::delete_recorder_series (const std::string &series_name)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::initialize_series_recorder (const std::string &serie_name)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::finalize_series_recorder (const std::string &serie_name)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::record_begin (const std::string &serie_name)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::record_problem (const std::string &serie_name, const Problem *problemPtr, RowColData rc)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::record_problem (const std::string &serie_name, const std::string &problem_name, RowColData rc)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::record_field (const std::string &serie_name, const std::string &field_name, const BitRefLevel &bit, const BitRefLevel &mask)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::record_end (const std::string &serie_name, double time=0)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::load_series_data (const std::string &serie_name, const int step_number)
virtual MoFEMErrorCode	MoFEM::SeriesRecorder::print_series_steps ()
virtual bool	MoFEM::SeriesRecorder::check_series (const std::string &name) const
	check if series is in database More...

Detailed Description

Recorder for time steps and solution sequences.

Macro Definition Documentation

_IT_SERIES_STEPS_BY_NAME_FOR_LOOP_

#define _IT_SERIES_STEPS_BY_NAME_FOR_LOOP_	(		RECORDER,
			NAME,
			IT
	)

Value:

  SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator IT =         \
      (RECORDER)->get_series_steps_byName_begin(NAME);                         \
  IT != (RECORDER)->get_series_steps_byName_end(NAME);                         \
  IT++

loop over recorded series step

Parameters

NAME	series name \parma IT iterator variable

Example:

  for(_IT_SERIES_STEPS_BY_NAME_FOR_LOOP_(recorder_ptr,"TEST_SERIES1",sit)) {
 
    ierr = mField.load_series_data("TEST_SERIES1",sit->get_step_number());
CHKERRG(ierr);
  } 

Examples

elasticity.cpp.

Definition at line 205 of file SeriesRecorder.hpp.

Function Documentation

add_series_recorder()

MoFEMErrorCode MoFEM::SeriesRecorder::add_series_recorder ( const std::string &  series_name )

virtual

Add series recorder

Parameters

name

of series

Definition at line 90 of file SeriesRecorder.cpp.

                                                                {
 
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  EntityHandle meshset;
  CHKERR moab.create_meshset(MESHSET_SET, meshset);
  void const *tag_data[] = {series_name.c_str()};
  int tag_sizes[1];
  tag_sizes[0] = series_name.size();
  CHKERR moab.tag_set_by_ptr(th_SeriesName, &meshset, 1, tag_data, tag_sizes);
  std::pair<Series_multiIndex::iterator, bool> p =
      sEries.insert(FieldSeries(moab, meshset));
  if (!p.second) {
    SETERRQ1(PETSC_COMM_SELF, 1, "series recorder <%s> is already there",
             series_name.c_str());
  }
  MoFEMFunctionReturn(0);
}

check_series()

bool MoFEM::SeriesRecorder::check_series ( const std::string &  name ) const

virtual

check if series is in database

Parameters

name	field name

Returns

true if field exist

Examples

elasticity.cpp.

Definition at line 301 of file SeriesRecorder.cpp.

                                                             {
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(name);
  if (sit != sEries.get<SeriesName_mi_tag>().end())
    return true;
  return false;
}

delete_recorder_series()

MoFEMErrorCode MoFEM::SeriesRecorder::delete_recorder_series ( const std::string &  series_name )

virtual

delete recorded series

Parameters

name

of series

Definition at line 111 of file SeriesRecorder.cpp.

                                                                   {
 
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator ssit, hi_ssit;
  ssit = seriesSteps.get<SeriesName_mi_tag>().lower_bound(series_name);
  hi_ssit = seriesSteps.get<SeriesName_mi_tag>().upper_bound(series_name);
  seriesSteps.get<SeriesName_mi_tag>().erase(ssit, hi_ssit);
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit;
  sit = sEries.get<SeriesName_mi_tag>().find(series_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(m_field.get_comm(), MOFEM_DATA_INCONSISTENCY,
             "series recorder <%s> not exist and can be deleted",
             series_name.c_str());
  }
  EntityHandle series_meshset = sit->getMeshset();
  CHKERR moab.tag_delete(sit->th_SeriesTime);
  CHKERR moab.tag_delete(sit->th_SeriesDataHandles);
  CHKERR moab.tag_delete(sit->th_SeriesDataUIDs);
  CHKERR moab.tag_delete(sit->th_SeriesData);
  sEries.get<SeriesName_mi_tag>().erase(sit);
  std::vector<EntityHandle> contained;
  CHKERR moab.get_contained_meshsets(series_meshset, contained);
  CHKERR moab.remove_entities(series_meshset, &contained[0], contained.size());
  CHKERR moab.delete_entities(&contained[0], contained.size());
  CHKERR moab.delete_entities(&series_meshset, 1);
  MoFEMFunctionReturn(0);
}

finalize_series_recorder()

MoFEMErrorCode MoFEM::SeriesRecorder::finalize_series_recorder ( const std::string &  serie_name )

virtual

finalize series for recording, recorded data are not accessible until finalize

Parameters

series

name

Definition at line 264 of file SeriesRecorder.cpp.

                                                                    {
 
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(serie_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
             serie_name.c_str());
  }
  CHKERR sit->save(moab);
  int nb_steps;
  CHKERR sit->get_nb_steps(moab, nb_steps);
  int ss = 0;
  for (; ss < nb_steps; ss++) {
    /*std::pair<SeriesStep_multiIndex::iterator,bool> p =*/seriesSteps.insert(
        FieldSeriesStep(moab, &*sit, ss));
  }
  MoFEMFunctionReturn(0);
}

initialize_series_recorder()

MoFEMErrorCode MoFEM::SeriesRecorder::initialize_series_recorder ( const std::string &  serie_name )

virtual

initialize sries for recording

Parameters

series

name

Definition at line 246 of file SeriesRecorder.cpp.

                                                                      {
 
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  MoFEMFunctionBegin;
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(serie_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
             serie_name.c_str());
  }
  CHKERR const_cast<FieldSeries *>(&*sit)->read(moab);
  const_cast<FieldSeries *>(&*sit)->record_begin = false;
  const_cast<FieldSeries *>(&*sit)->record_end = false;
  MoFEMFunctionReturn(0);
}

load_series_data()

MoFEMErrorCode MoFEM::SeriesRecorder::load_series_data ( const std::string &  serie_name, const int  step_number  )

virtual

load data from series into dofs database

Parameters

series	name
step	number

Examples

elasticity.cpp.

Definition at line 309 of file SeriesRecorder.cpp.

                                                                       {
 
  Interface &m_field = cOre;
  moab::Interface &moab = m_field.get_moab();
  auto dofs_ptr = m_field.get_dofs();
  MoFEMFunctionBegin;
  SeriesStep_multiIndex::index<
      Composite_SeriesName_And_Step_mi_tag>::type::iterator sit;
  sit = seriesSteps.get<Composite_SeriesName_And_Step_mi_tag>().find(
      boost::make_tuple(serie_name, step_number));
  if (sit == seriesSteps.get<Composite_SeriesName_And_Step_mi_tag>().end()) {
    SETERRQ2(PETSC_COMM_SELF, 1, "series <%s> and step %d not found",
             serie_name.c_str(), step_number);
  }
  CHKERR sit->get(moab, *(const_cast<DofEntity_multiIndex *>(dofs_ptr)));
  MoFEMFunctionReturn(0);
}

print_series_steps()

MoFEMErrorCode MoFEM::SeriesRecorder::print_series_steps ( )

virtual

print series

Definition at line 286 of file SeriesRecorder.cpp.

                                                  {
  SeriesRecorderFunctionBegin;
 
  for (auto &sit : sEries.get<SeriesName_mi_tag>())
    MOFEM_LOG("SYNC", Sev::inform) << "series " << sit;
 
  for (auto &ssit : seriesSteps.get<SeriesName_mi_tag>())
    MOFEM_LOG("SYNC", Sev::inform) << "series steps " << ssit;
 
  MOFEM_LOG_CHANNEL("WORLD");
  MOFEM_LOG_CHANNEL("SYNC");
  MOFEM_LOG_CHANNEL("SELF");
  MoFEMFunctionReturn(0);
}

record_begin()

MoFEMErrorCode MoFEM::SeriesRecorder::record_begin ( const std::string &  serie_name )

virtual

begin series recording

Parameters

series

name

Definition at line 218 of file SeriesRecorder.cpp.

                                                                       {
 
  MoFEMFunctionBegin;
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(serie_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
             serie_name.c_str());
  }
  CHKERR const_cast<FieldSeries *>(&*sit)->begin();
  MoFEMFunctionReturn(0);
}

record_end()

MoFEMErrorCode MoFEM::SeriesRecorder::record_end ( const std::string &  serie_name, double  time = 0  )

virtual

end series recording

Parameters

series

name

Definition at line 231 of file SeriesRecorder.cpp.

                                                       {
 
  MoFEMFunctionBegin;
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(serie_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
             serie_name.c_str());
  }
  CHKERR const_cast<FieldSeries *>(&*sit)->end(time);
  MoFEMFunctionReturn(0);
}

record_field()

MoFEMErrorCode MoFEM::SeriesRecorder::record_field ( const std::string &  serie_name, const std::string &  field_name, const BitRefLevel &  bit, const BitRefLevel &  mask  )

virtual

record field

Parameters

field	name
bit	ref level
mask	for bit ref level

Definition at line 181 of file SeriesRecorder.cpp.

                                                                     {
  Interface &m_field = cOre;
  auto dofs_ptr = m_field.get_dofs();
  MoFEMFunctionBegin;
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(serie_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "serie recorder <%s> not exist",
             serie_name.c_str());
  }
 
  const auto bit_number = m_field.get_field_bit_number(field_name);
 
  auto dit = dofs_ptr->get<Unique_mi_tag>().lower_bound(
      FieldEntity::getLoBitNumberUId(bit_number));
  if (dit == dofs_ptr->get<Unique_mi_tag>().end())
    SETERRQ1(PETSC_COMM_SELF, MOFEM_NOT_FOUND, "field <%s> not exist", field_name.c_str());
  auto hi_dit = dofs_ptr->get<Unique_mi_tag>().upper_bound(
      FieldEntity::getHiBitNumberUId(bit_number));
 
  for (; dit != hi_dit; dit++) {
    const BitRefLevel &dof_bit = (*dit)->getBitRefLevel();
    if ((dof_bit & mask) != dof_bit)
      continue;
    if ((dof_bit & bit).any()) {
      EntityHandle ent = (*dit)->getEnt();
      ShortId uid = (*dit)->getNonNonuniqueShortId();
      FieldData val = (*dit)->getFieldData();
      CHKERR const_cast<FieldSeries *>(&*sit)->push_dofs(ent, uid, val);
    }
  }
  MoFEMFunctionReturn(0);
}

record_problem() [1/2]

MoFEMErrorCode MoFEM::SeriesRecorder::record_problem ( const std::string &  serie_name, const Problem *  problemPtr, RowColData  rc  )

virtual

record problem

Parameters

series	name
problem	pointer
rc	could be Row or Col

Definition at line 141 of file SeriesRecorder.cpp.

                                                             {
  MoFEMFunctionBegin;
 
  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
      sEries.get<SeriesName_mi_tag>().find(serie_name);
  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
    SETERRQ1(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "series recorder <%s> not exist", serie_name.c_str());
  }
  switch (rc) {
  case ROW:
    CHKERR const_cast<FieldSeries *>(&*sit)->push_dofs(
        problemPtr->numeredRowDofsPtr->begin(),
        problemPtr->numeredRowDofsPtr->end());
    break;
  case COL:
    CHKERR const_cast<FieldSeries *>(&*sit)->push_dofs(
        problemPtr->numeredColDofsPtr->begin(),
        problemPtr->numeredColDofsPtr->end());
    break;
  default:
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
  }
  MoFEMFunctionReturn(0);
}

record_problem() [2/2]

MoFEMErrorCode MoFEM::SeriesRecorder::record_problem ( const std::string &  serie_name, const std::string &  problem_name, RowColData  rc  )

virtual

record problem

Parameters

series	name
problem	name
rc	could be Row or Col

Definition at line 169 of file SeriesRecorder.cpp.

                                                             {
 
  Interface &m_field = cOre;
  MoFEMFunctionBegin;
  const Problem *problem_ptr;
  CHKERR m_field.get_problem(problem_name, &problem_ptr);
  CHKERR record_problem(serie_name, problem_ptr, rc);
  MoFEMFunctionReturn(0);
}