13                {
   14 
   15
   16 
   18SeriesRecorder::query_interface(boost::typeindex::type_index type_index,
   19                                UnknownInterface **iface) const {
   20  *iface = const_cast<SeriesRecorder *>(this);
   21  return 0;
   22}
   23 
   24SeriesRecorder::SeriesRecorder(const Core &core)
   25    : cOre(const_cast<
Core &>(core)) {}
 
   26 
   28 
   30  moab::Interface &moab = m_field.
get_moab();
 
   32  const int def_val_len = 0;
   33  CHKERR moab.tag_get_handle(
 
   34      "_SeriesName", def_val_len, MB_TYPE_OPAQUE, th_SeriesName,
   35      MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
   37}
   38 
   41  sEries.clear();
   42  seriesSteps.clear();
   44}
   45 
   46MoFEMErrorCode SeriesRecorder::initialiseDatabaseFromMesh(
int verb) {
 
   48  moab::Interface &moab = m_field.
get_moab();
 
   51  const int def_val_len = 0;
   52  CHKERR moab.tag_get_handle(
 
   53      "_SeriesName", def_val_len, MB_TYPE_OPAQUE, th_SeriesName,
   54      MB_TAG_CREAT | MB_TAG_BYTES | MB_TAG_VARLEN | MB_TAG_SPARSE, NULL);
   55 
   56  CHKERR moab.get_entities_by_type(0, MBENTITYSET, meshsets, 
false);
 
   57  for (Range::iterator mit = meshsets.begin(); mit != meshsets.end(); mit++) {
   58    const void *tagName;
   59    int tagNameSize;
   60    rval = moab.tag_get_by_ptr(th_SeriesName, &*mit, 1, (const void **)&tagName,
   61                               &tagNameSize);
   62    if (rval == MB_SUCCESS) {
   63      std::pair<Series_multiIndex::iterator, bool> p =
   64          sEries.insert(FieldSeries(moab, *mit));
   66        MOFEM_LOG(
"SYNC", Sev::inform) << 
"read series " << *p.first;
 
   67    }
   68  }
   69  
   70  for (Series_multiIndex::iterator sit = sEries.begin(); sit != sEries.end();
   71       sit++) {
   72    int nb_steps;
   73    CHKERR sit->get_nb_steps(moab, nb_steps);
 
   74    int ss = 0;
   75    for (; ss < nb_steps; ss++) {
   76      std::pair<SeriesStep_multiIndex::iterator, bool> p =
   77          seriesSteps.insert(FieldSeriesStep(moab, &*sit, ss));
   79        MOFEM_LOG(
"SYNC", Sev::inform) << 
"add series step " << *p.first;
 
   80    }
   81  }
   86}
   87 
   89SeriesRecorder::add_series_recorder(const std::string &series_name) {
   90 
   92  moab::Interface &moab = m_field.
get_moab();
 
   95  CHKERR moab.create_meshset(MESHSET_SET, meshset);
 
   96  void const *tag_data[] = {series_name.c_str()};
   97  int tag_sizes[1];
   98  tag_sizes[0] = series_name.size();
   99  CHKERR moab.tag_set_by_ptr(th_SeriesName, &meshset, 1, tag_data, tag_sizes);
 
  100  std::pair<Series_multiIndex::iterator, bool> p =
  101      sEries.insert(FieldSeries(moab, meshset));
  102  if (!p.second) {
  103    SETERRQ(PETSC_COMM_SELF, 1, "series recorder <%s> is already there",
  104             series_name.c_str());
  105  }
  107}
  108 
  110SeriesRecorder::delete_recorder_series(const std::string &series_name) {
  111 
  113  moab::Interface &moab = m_field.
get_moab();
 
  115  SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator ssit, hi_ssit;
  116  ssit = seriesSteps.get<SeriesName_mi_tag>().lower_bound(series_name);
  117  hi_ssit = seriesSteps.get<SeriesName_mi_tag>().upper_bound(series_name);
  118  seriesSteps.get<SeriesName_mi_tag>().erase(ssit, hi_ssit);
  119  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit;
  120  sit = sEries.get<SeriesName_mi_tag>().find(series_name);
  121  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  123             "series recorder <%s> not exist and can be deleted",
  124             series_name.c_str());
  125  }
  127  CHKERR moab.tag_delete(sit->th_SeriesTime);
 
  128  CHKERR moab.tag_delete(sit->th_SeriesDataHandles);
 
  129  CHKERR moab.tag_delete(sit->th_SeriesDataUIDs);
 
  130  CHKERR moab.tag_delete(sit->th_SeriesData);
 
  131  sEries.get<SeriesName_mi_tag>().erase(sit);
  132  std::vector<EntityHandle> contained;
  133  CHKERR moab.get_contained_meshsets(series_meshset, contained);
 
  134  CHKERR moab.remove_entities(series_meshset, &contained[0], contained.size());
 
  135  CHKERR moab.delete_entities(&contained[0], contained.size());
 
  136  CHKERR moab.delete_entities(&series_meshset, 1);
 
  138}
  139 
  140MoFEMErrorCode SeriesRecorder::record_problem(
const std::string &serie_name,
 
  141                                              const Problem *problemPtr,
  144 
  145  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  146      sEries.get<SeriesName_mi_tag>().find(serie_name);
  147  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  149             "series recorder <%s> not exist", serie_name.c_str());
  150  }
  151  switch (rc) {
  153    CHKERR const_cast<FieldSeries *
>(&*sit)->push_dofs(
 
  154        problemPtr->numeredRowDofsPtr->begin(),
  155        problemPtr->numeredRowDofsPtr->end());
  156    break;
  158    CHKERR const_cast<FieldSeries *
>(&*sit)->push_dofs(
 
  159        problemPtr->numeredColDofsPtr->begin(),
  160        problemPtr->numeredColDofsPtr->end());
  161    break;
  162  default:
  164  }
  166}
  167 
  168MoFEMErrorCode SeriesRecorder::record_problem(
const std::string &serie_name,
 
  169                                              const std::string &problem_name,
  171 
  174  const Problem *problem_ptr;
  176  CHKERR record_problem(serie_name, problem_ptr, rc);
 
  178}
  179 
  180MoFEMErrorCode SeriesRecorder::record_field(
const std::string &serie_name,
 
  182                                            const BitRefLevel &
bit,
 
  183                                            const BitRefLevel &mask) {
  187  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  188      sEries.get<SeriesName_mi_tag>().find(serie_name);
  189  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  190    SETERRQ(PETSC_COMM_SELF, 
MOFEM_NOT_FOUND, 
"serie recorder <%s> not exist",
 
  191             serie_name.c_str());
  192  }
  193 
  194  const auto bit_number = m_field.get_field_bit_number(
field_name);
 
  195 
  196  auto dit = dofs_ptr->get<Unique_mi_tag>().lower_bound(
  197      FieldEntity::getLoBitNumberUId(bit_number));
  198  if (dit == dofs_ptr->get<Unique_mi_tag>().end())
  200  auto hi_dit = dofs_ptr->get<Unique_mi_tag>().upper_bound(
  201      FieldEntity::getHiBitNumberUId(bit_number));
  202 
  203  for (; dit != hi_dit; dit++) {
  204    const BitRefLevel &dof_bit = (*dit)->getBitRefLevel();
 
  205    if ((dof_bit & mask) != dof_bit)
  206      continue;
  207    if ((dof_bit & 
bit).any()) {
 
  209      ShortId uid = (*dit)->getNonNonuniqueShortId();
 
  211      CHKERR const_cast<FieldSeries *
>(&*sit)->push_dofs(ent, uid, val);
 
  212    }
  213  }
  215}
  216 
  217MoFEMErrorCode SeriesRecorder::record_begin(
const std::string &serie_name) {
 
  218 
  220  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  221      sEries.get<SeriesName_mi_tag>().find(serie_name);
  222  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  223    SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
  224             serie_name.c_str());
  225  }
  226  CHKERR const_cast<FieldSeries *
>(&*sit)->begin();
 
  228}
  229 
  230MoFEMErrorCode SeriesRecorder::record_end(
const std::string &serie_name,
 
  231                                          double time) {
  232 
  234  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  235      sEries.get<SeriesName_mi_tag>().find(serie_name);
  236  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  237    SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
  238             serie_name.c_str());
  239  }
  240  CHKERR const_cast<FieldSeries *
>(&*sit)->end(time);
 
  242}
  243 
  245SeriesRecorder::initialize_series_recorder(const std::string &serie_name) {
  246 
  248  moab::Interface &moab = m_field.
get_moab();
 
  250  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  251      sEries.get<SeriesName_mi_tag>().find(serie_name);
  252  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  253    SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
  254             serie_name.c_str());
  255  }
  256  CHKERR const_cast<FieldSeries *
>(&*sit)->read(moab);
 
  257  const_cast<FieldSeries *>(&*sit)->record_begin = false;
  258  const_cast<FieldSeries *>(&*sit)->record_end = false;
  260}
  261 
  263SeriesRecorder::finalize_series_recorder(const std::string &serie_name) {
  264 
  266  moab::Interface &moab = m_field.
get_moab();
 
  268  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  269      sEries.get<SeriesName_mi_tag>().find(serie_name);
  270  if (sit == sEries.get<SeriesName_mi_tag>().end()) {
  271    SETERRQ(PETSC_COMM_SELF, 1, "serie recorder <%s> not exist",
  272             serie_name.c_str());
  273  }
  275  int nb_steps;
  276  CHKERR sit->get_nb_steps(moab, nb_steps);
 
  277  int ss = 0;
  278  for (; ss < nb_steps; ss++) {
  279    seriesSteps.insert(
  280        FieldSeriesStep(moab, &*sit, ss));
  281  }
  283}
  284 
  287 
  288  for (auto &sit : sEries.get<SeriesName_mi_tag>())
  290 
  291  for (auto &ssit : seriesSteps.get<SeriesName_mi_tag>())
  292    MOFEM_LOG(
"SYNC", 
Sev::inform) << 
"series steps " << ssit;
 
  293 
  298}
  299 
  300bool SeriesRecorder::check_series(const std::string &name) const {
  301  Series_multiIndex::index<SeriesName_mi_tag>::type::iterator sit =
  302      sEries.get<SeriesName_mi_tag>().find(name);
  303  if (sit != sEries.get<SeriesName_mi_tag>().end())
  304    return true;
  305  return false;
  306}
  307 
  308MoFEMErrorCode SeriesRecorder::load_series_data(
const std::string &serie_name,
 
  309                                                const int step_number) {
  310 
  312  moab::Interface &moab = m_field.
get_moab();
 
  313  auto dofs_ptr = m_field.get_dofs();
  315  SeriesStep_multiIndex::index<
  316      Composite_SeriesName_And_Step_mi_tag>::type::iterator sit;
  317  sit = seriesSteps.get<Composite_SeriesName_And_Step_mi_tag>().find(
  318      boost::make_tuple(serie_name, step_number));
  319  if (sit == seriesSteps.get<Composite_SeriesName_And_Step_mi_tag>().end()) {
  320    SETERRQ(PETSC_COMM_SELF, 1, "series <%s> and step %d not found",
  321             serie_name.c_str(), step_number);
  322  }
  325}
  326 
  327SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator
  328SeriesRecorder::get_series_steps_byName_begin(const std::string &name) {
  329  return seriesSteps.get<SeriesName_mi_tag>().lower_bound(name);
  330}
  331 
  332SeriesStep_multiIndex::index<SeriesName_mi_tag>::type::iterator
  333SeriesRecorder::get_series_steps_byName_end(const std::string &name) {
  334  return seriesSteps.get<SeriesName_mi_tag>().upper_bound(name);
  335}
  336 
  337} 
#define SeriesRecorderFunctionBegin
@ MOFEM_DATA_INCONSISTENCY
#define MoFEMFunctionReturn(a)
Last executable line of each PETSc function used for error handling. Replaces return()
#define CHKERR
Inline error check.
multi_index_container< boost::shared_ptr< DofEntity >, indexed_by< ordered_unique< tag< Unique_mi_tag >, const_mem_fun< DofEntity, UId, &DofEntity::getLocalUniqueId > >, ordered_non_unique< tag< Ent_mi_tag >, const_mem_fun< DofEntity, EntityHandle, &DofEntity::getEnt > > > > DofEntity_multiIndex
MultiIndex container keeps DofEntity.
virtual const Problem * get_problem(const std::string problem_name) const =0
Get the problem object.
virtual const DofEntity_multiIndex * get_dofs() const =0
Get the dofs object.
#define MOFEM_LOG(channel, severity)
Log.
#define MOFEM_LOG_CHANNEL(channel)
Set and reset channel.
PetscErrorCode MoFEMErrorCode
MoFEM/PETSc error code.
double FieldData
Field data type.
std::bitset< BITREFLEVEL_SIZE > BitRefLevel
Bit structure attached to each entity identifying to what mesh entity is attached.
int ShortId
Unique Id in the field.
MoFEM::LogManager::SeverityLevel Sev
DeprecatedCoreInterface Interface
constexpr auto field_name
virtual moab::Interface & get_moab()=0