Structure for recording (time) series. More...

#include <src/multi_indices/SeriesMultiIndices.hpp>

Collaboration diagram for MoFEM::FieldSeries:

Public Member Functions
	FieldSeries (Interface &moab, const EntityHandle _meshset)

EntityHandle	getMeshset () const
	get meshset More...

EntityID	get_meshset_id () const

boost::string_ref	getNameRef () const
	get string_ref of series More...

std::string	getName () const
	get series name More...

MoFEMErrorCode	get_nb_steps (Interface &moab, int &nb_setps) const

MoFEMErrorCode	set_time (double time)

MoFEMErrorCode	push_dofs (const EntityHandle ent, const ShortId uid, const FieldData val)

template<typename IT >
MoFEMErrorCode	push_dofs (IT it, IT hi_it)

MoFEMErrorCode	begin ()

MoFEMErrorCode	end (double time=0)

MoFEMErrorCode	read (Interface &moab)

MoFEMErrorCode	save (Interface &moab) const

const FieldSeries *	get_FieldSeries_ptr () const

Public Attributes
EntityHandle	meshset

const void *	tagName
	tag keeps name of the series More...

int	tagNameSize
	number of bits necessary to keep field series More...

bool	record_begin

bool	record_end

Tag	th_SeriesData

Tag	th_SeriesDataUIDs

Tag	th_SeriesDataHandles

Tag	th_SeriesTime

std::vector< int >	ia

std::vector< double >	time

std::vector< EntityHandle >	handles

std::vector< ShortId >	uids

std::vector< FieldData >	data

Friends
std::ostream &	operator<< (std::ostream &os, const FieldSeries &e)

Detailed Description

Structure for recording (time) series.

Bug:

Fix member functions names. Not follow naming convention.

Member functions not documented

Definition at line 23 of file SeriesMultiIndices.hpp.

Constructor & Destructor Documentation

◆ FieldSeries()

MoFEM::FieldSeries::FieldSeries	(	Interface &	moab,
		const EntityHandle	_meshset
	)

Definition at line 8 of file SeriesMultiIndices.cpp.

    : meshset(_meshset), tagName(NULL), tagNameSize(0), record_begin(false),
      record_end(false) {
 
  Tag th_SeriesName;
  rval = moab.tag_get_handle("_SeriesName", th_SeriesName);
  MOAB_THROW(rval);
  rval = moab.tag_get_by_ptr(th_SeriesName, &meshset, 1,
                             (const void **)&tagName, &tagNameSize);
  MOAB_THROW(rval);
 
  const int def_val_len = 0;
 
  // time
  std::string Tag_SeriesTime = "_SeriesTime_" + getName();
  double def_time = 0;
  rval = moab.tag_get_handle(Tag_SeriesTime.c_str(), 1, MB_TYPE_DOUBLE,
                             th_SeriesTime, MB_TAG_CREAT | MB_TAG_SPARSE,
                             &def_time);
  MOAB_THROW(rval);
 
  // handles
  std::string Tag_DataHandles_SeriesName = "_SeriesDataHandles_" + getName();
  rval = moab.tag_get_handle(
      Tag_DataHandles_SeriesName.c_str(), def_val_len, MB_TYPE_HANDLE,
      th_SeriesDataHandles, MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_VARLEN, NULL);
  MOAB_THROW(rval);
 
  // uids
  std::string Tag_DataUIDs_SeriesName = "_SeriesDataUIDs_" + getName();
  rval = moab.tag_get_handle(
      Tag_DataUIDs_SeriesName.c_str(), def_val_len, MB_TYPE_OPAQUE,
      th_SeriesDataUIDs,
      MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
  MOAB_THROW(rval);
 
  // data
  std::string Tag_Data_SeriesName = "_SeriesData_" + getName();
  rval = moab.tag_get_handle(
      Tag_Data_SeriesName.c_str(), def_val_len, MB_TYPE_OPAQUE, th_SeriesData,
      MB_TAG_CREAT | MB_TAG_SPARSE | MB_TAG_BYTES | MB_TAG_VARLEN, NULL);
  MOAB_THROW(rval);
}

Member Function Documentation

◆ begin()

MoFEMErrorCode MoFEM::FieldSeries::begin ( )

Definition at line 72 of file SeriesMultiIndices.cpp.

                                  {
  MoFEMFunctionBegin;
  if (record_begin) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "recording already  begin");
  }
  record_begin = true;
  MoFEMFunctionReturn(0);
}

◆ end()

MoFEMErrorCode MoFEM::FieldSeries::end ( double time = 0 )

Definition at line 82 of file SeriesMultiIndices.cpp.

                                        {
  MoFEMFunctionBegin;
  if (!record_begin) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "recording not begin it can not be ended");
  }
  record_begin = false;
  record_end = true;
  ia.push_back(uids.size());
  time.push_back(t);
  MoFEMFunctionReturn(0);
}

◆ get_FieldSeries_ptr()

const FieldSeries * MoFEM::FieldSeries::get_FieldSeries_ptr ( ) const

inline

Definition at line 81 of file SeriesMultiIndices.hpp.

                                                        {
    return const_cast<FieldSeries *>(this);
  };

◆ get_meshset_id()

EntityID MoFEM::FieldSeries::get_meshset_id ( ) const

inline

Definition at line 36 of file SeriesMultiIndices.hpp.

                                         {
    return (EntityID)(meshset & MB_ID_MASK);
  }

◆ get_nb_steps()

MoFEMErrorCode MoFEM::FieldSeries::get_nb_steps	(	Interface &	moab,
		int &	nb_setps
	)		const

Definition at line 52 of file SeriesMultiIndices.cpp.

                                                              {
  MoFEMFunctionBegin;
  CHKERR moab.num_contained_meshsets(meshset, &nb_steps);
  MoFEMFunctionReturn(0);
}

◆ getMeshset()

EntityHandle MoFEM::FieldSeries::getMeshset ( ) const

inline

get meshset

Definition at line 35 of file SeriesMultiIndices.hpp.

35{ return meshset; }

◆ getName()

std::string MoFEM::FieldSeries::getName ( ) const

inline

get series name

Definition at line 44 of file SeriesMultiIndices.hpp.

                                   {
    return std::string((char *)tagName, tagNameSize);
  }

◆ getNameRef()

boost::string_ref MoFEM::FieldSeries::getNameRef ( ) const

inline

get string_ref of series

Definition at line 40 of file SeriesMultiIndices.hpp.

                                            {
    return boost::string_ref((char *)tagName, tagNameSize);
  }

◆ push_dofs() [1/2]

MoFEMErrorCode MoFEM::FieldSeries::push_dofs	(	const EntityHandle	ent,
		const ShortId	uid,
		const FieldData	val
	)

Definition at line 59 of file SeriesMultiIndices.cpp.

                                                           {
  MoFEMFunctionBegin;
  if (!record_begin) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "you neet to set recording");
  }
  handles.push_back(ent);
  uids.push_back(uid);
  data.push_back(val);
  MoFEMFunctionReturn(0);
}

◆ push_dofs() [2/2]

template<typename IT >

MoFEMErrorCode MoFEM::FieldSeries::push_dofs	(	IT	it,
		IT	hi_it
	)

inline

Definition at line 65 of file SeriesMultiIndices.hpp.

                                                                   {
    MoFEMFunctionBeginHot;
 
    for (; it != hi_it; it++) {
      ierr = push_dofs((*it)->getEnt(), (*it)->getNonNonuniqueShortId(),
                       (*it)->getFieldData());
      CHKERRG(ierr);
    }
    MoFEMFunctionReturnHot(0);
  }

◆ read()

MoFEMErrorCode MoFEM::FieldSeries::read ( Interface & moab )

Definition at line 95 of file SeriesMultiIndices.cpp.

                                                    {
  MoFEMFunctionBegin;
 
  if (record_begin) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "all series data will be lost");
  }
  if (record_end) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
            "all series data will be lost");
  }
 
  std::vector<EntityHandle> contained;
  CHKERR moab.get_contained_meshsets(meshset, contained);
  ia.resize(0);
  time.resize(0);
  handles.resize(0);
  uids.resize(0);
  data.resize(0);
  ia.push_back(0);
 
  for (unsigned int mm = 0; mm < contained.size(); mm++) {
    // time
    {
      double t;
      CHKERR moab.tag_set_data(th_SeriesTime, &meshset, 1, &t);
      time.push_back(t);
    }
    // handles
    {
      const EntityHandle *tag_data;
      int tag_size;
      CHKERR moab.tag_get_by_ptr(th_SeriesDataHandles, &meshset, 1,
                                 (const void **)&tag_data, &tag_size);
      handles.insert(handles.end(), tag_data, &tag_data[tag_size]);
    }
    // uids
    {
      const ShortId *tag_data;
      int tag_size;
      CHKERR moab.tag_get_by_ptr(th_SeriesDataUIDs, &meshset, 1,
                                 (const void **)&tag_data, &tag_size);
      int nb = tag_size / sizeof(ShortId);
      uids.insert(uids.end(), tag_data, &tag_data[nb]);
    }
    if (handles.size() != uids.size()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
    }
    // data
    {
      const FieldData *tag_data;
      int tag_size;
      CHKERR moab.tag_get_by_ptr(th_SeriesData, &meshset, 1,
                                 (const void **)&tag_data, &tag_size);
      int nb = tag_size / sizeof(FieldData);
      data.insert(data.end(), tag_data, &tag_data[nb]);
    }
    if (data.size() != uids.size()) {
      SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "data inconsistency");
    }
    ia.push_back(data.size());
  }
 
  MoFEMFunctionReturn(0);
}

◆ save()

MoFEMErrorCode MoFEM::FieldSeries::save ( Interface & moab ) const

Definition at line 161 of file SeriesMultiIndices.cpp.

                                                          {
  MoFEMFunctionBegin;
 
  if (record_begin) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "switch off recording");
  }
  if (!record_end) {
    SETERRQ(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY, "finish recording");
  }
 
  std::vector<EntityHandle> contained;
  CHKERR moab.get_contained_meshsets(meshset, contained);
  unsigned int nb_contained = contained.size();
  if (nb_contained < ia.size() - 1) {
    contained.resize(ia.size());
  }
  for (unsigned int mm = ia.size() - 1; mm < nb_contained; mm++) {
    CHKERR moab.remove_entities(meshset, &contained[mm], 1);
    CHKERR moab.delete_entities(&contained[mm], 1);
  }
  for (unsigned int mm = nb_contained; mm < ia.size() - 1; mm++) {
    EntityHandle new_meshset;
    CHKERR moab.create_meshset(MESHSET_SET, new_meshset);
    CHKERR moab.add_entities(meshset, &new_meshset, 1);
  }
  contained.resize(0);
  CHKERR moab.get_contained_meshsets(meshset, contained);
  if (contained.size() != ia.size() - 1) {
    SETERRQ2(PETSC_COMM_SELF, MOFEM_DATA_INCONSISTENCY,
             "data inconsistency nb_contained != ia.size()-1 %d!=%d",
             contained.size(), ia.size() - 1);
  }
 
  // time
  for (unsigned int ii = 1; ii < ia.size(); ii++) {
    CHKERR moab.tag_set_data(th_SeriesTime, &contained[ii - 1], 1,
                             &time[ii - 1]);
  }
 
  // handles
  for (unsigned int ii = 1; ii < ia.size(); ii++) {
    void const *tag_data[] = {&handles[ia[ii - 1]]};
    int tag_sizes[] = {(ia[ii] - ia[ii - 1])};
    CHKERR moab.tag_set_by_ptr(th_SeriesDataHandles, &contained[ii - 1], 1,
                               tag_data, tag_sizes);
  }
  // uids
  for (unsigned int ii = 1; ii < ia.size(); ii++) {
    void const *tag_data[] = {&uids[ia[ii - 1]]};
    int tag_sizes[] = {(ia[ii] - ia[ii - 1]) * (int)sizeof(ShortId)};
    CHKERR moab.tag_set_by_ptr(th_SeriesDataUIDs, &contained[ii - 1], 1,
                               tag_data, tag_sizes);
  }
 
  // data
  for (unsigned int ii = 1; ii < ia.size(); ii++) {
    void const *tag_data[] = {&data[ia[ii - 1]]};
    int tag_sizes[] = {(ia[ii] - ia[ii - 1]) * (int)sizeof(FieldData)};
    CHKERR moab.tag_set_by_ptr(th_SeriesData, &contained[ii - 1], 1, tag_data,
                               tag_sizes);
  }
 
  MoFEMFunctionReturn(0);
}

◆ set_time()

MoFEMErrorCode MoFEM::FieldSeries::set_time ( double time )

Friends And Related Function Documentation

◆ operator<<

std::ostream & operator<<	(	std::ostream &	os,
		const FieldSeries &	e
	)

friend

Definition at line 323 of file SeriesMultiIndices.cpp.

                                                             {
  os << "name " << e.getName() << " meshset " << e.getMeshset();
  return os;
}

Member Data Documentation

◆ data

std::vector<FieldData> MoFEM::FieldSeries::data

Definition at line 59 of file SeriesMultiIndices.hpp.

◆ handles

std::vector<EntityHandle> MoFEM::FieldSeries::handles

Definition at line 57 of file SeriesMultiIndices.hpp.

◆ ia

std::vector<int> MoFEM::FieldSeries::ia

Definition at line 55 of file SeriesMultiIndices.hpp.

◆ meshset

EntityHandle MoFEM::FieldSeries::meshset

Definition at line 25 of file SeriesMultiIndices.hpp.

◆ record_begin

bool MoFEM::FieldSeries::record_begin

Definition at line 29 of file SeriesMultiIndices.hpp.

◆ record_end

bool MoFEM::FieldSeries::record_end

Definition at line 30 of file SeriesMultiIndices.hpp.

◆ tagName

const void* MoFEM::FieldSeries::tagName

tag keeps name of the series

Definition at line 26 of file SeriesMultiIndices.hpp.

◆ tagNameSize

int MoFEM::FieldSeries::tagNameSize

number of bits necessary to keep field series

Definition at line 27 of file SeriesMultiIndices.hpp.

◆ th_SeriesData

Tag MoFEM::FieldSeries::th_SeriesData

Definition at line 48 of file SeriesMultiIndices.hpp.

◆ th_SeriesDataHandles

Tag MoFEM::FieldSeries::th_SeriesDataHandles

Definition at line 50 of file SeriesMultiIndices.hpp.

◆ th_SeriesDataUIDs

Tag MoFEM::FieldSeries::th_SeriesDataUIDs

Definition at line 49 of file SeriesMultiIndices.hpp.

◆ th_SeriesTime

Tag MoFEM::FieldSeries::th_SeriesTime

Definition at line 51 of file SeriesMultiIndices.hpp.

◆ time

std::vector<double> MoFEM::FieldSeries::time

Definition at line 56 of file SeriesMultiIndices.hpp.

◆ uids

std::vector<ShortId> MoFEM::FieldSeries::uids

Definition at line 58 of file SeriesMultiIndices.hpp.

The documentation for this struct was generated from the following files:

src/multi_indices/SeriesMultiIndices.hpp
src/multi_indices/impl/SeriesMultiIndices.cpp

Public Member Functions

Public Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ FieldSeries()

Member Function Documentation

◆ begin()

◆ end()

◆ get_FieldSeries_ptr()

◆ get_meshset_id()

◆ get_nb_steps()

◆ getMeshset()

◆ getName()

◆ getNameRef()

◆ push_dofs() [1/2]

◆ push_dofs() [2/2]

◆ read()

◆ save()

◆ set_time()

Friends And Related Function Documentation

◆ operator<<

Member Data Documentation

◆ data

◆ handles

◆ ia

◆ meshset

◆ record_begin

◆ record_end

◆ tagName

◆ tagNameSize

◆ th_SeriesData

◆ th_SeriesDataHandles

◆ th_SeriesDataUIDs

◆ th_SeriesTime

◆ time

◆ uids