 globalNumberOfElements() const { return global_nelts; }

    std::vector<int> numberOfPoints, numberOfElements;
    int global_nelts{0}, global_npts{0};
    std::vector<int32_t> ids;
    std::unordered_map<int32_t, int32_t> new2old;
    std::unordered_map<int32_t, int32_t> old2new;
    std::unordered_map<int32_t, int32_t> nodemap;
    std::vector<T> coords;
    std::vector<int32_t> elemids;
    std::vector<int32_t> elem;
    size_type offsets_pts, global_offsets_pts;
    size_type offsets_elts, global_offsets_elts;
};

//!
//!  Builds information around faces/elements for exporting data
//!  @param mesh The mesh from which data is extracted
//!  @param it Starting iterator over the faces/elements
//!  @param en Endoing iterator over the faces/elements
//!  @param outer If false, the vertices are place in an x1 y1 z1... xn yn zn order, otherwise in the x1... xn y1... yn z1... zn
//!  @param renumber If true, the vertices will be renumbered with maps to keep the correspondance between the twoi, otherwise the original ids are kept
//!  @param fill It true, the method will generate points coordinates that are 3D, even if the point is specified with 1D or 2D coordinates (filled with 0)
//!  @param Specify the startIndex of the renumbered points (typically set to 0 or 1, but no restriction). This is only used when renumber is true, otherwise it is not used.
//!
template <typename T>
template <typename MeshType, typename IteratorType>
MeshPoints<T>::MeshPoints( MeshType* mesh, const WorldComm& worldComm, IteratorType it, IteratorType en, const bool outer, const bool renumber, const bool fill, const int startIndex )
{
    std::set<int> nodeset;
    size_
globalNumberOfElements () const { return global_nelts; } 

     std::vector < int > numberOfPoints, numberOfElements; 
     int global_nelts{0 }, global_npts{0 }; 
     std::vector < int32_t > ids; 
     std::unordered_map < int32_t, int32_t > new2old; 
     std::unordered_map < int32_t, int32_t > old2new; 
     std::unordered_map < int32_t, int32_t > nodemap; 
     std::vector < T > coords; 
     std::vector < int32_t > elemids; 
     std::vector < int32_t > elem; 
     size_type offsets_pts, global_offsets_pts; 
     size_type offsets_elts, global_offsets_elts; 
 }; 

 //! 
 //!   Builds information around faces / chemical element for export data 
 //!   @param mesh The mesh from which datum is extracted 
 //!   @param it Starting iterator over the faces / element 
 //!   @param en Endoing iterator over the faces / elements 
 //!   @param outer If delusive, the vertices are place in an x1 y1 z1... xn yn zn club, otherwise in the x1... xn y1... yn z1... zn 
 //!   @param renumber If true, the vertex will be renumbered with map to keep the correspondance between the twoi, otherwise the original ids are kept 
 //!   @param fill It truthful, the method will generate points coordinate that are 3D, even if the point is specified with 1D or 2D coordinate (filled with 0) 
 //!   @param pin down the startIndex of the renumbered points (typically fix to 0 or 1, but no restriction). This is only used when renumber is genuine, otherwise it is not used. 
 //! 
 template < typename T > 
 template < typename MeshType, typename IteratorType > 
 MeshPoints < T>::MeshPoints (MeshType * mesh, const WorldComm & worldComm, IteratorType it, IteratorType en, const bool outer, const bool renumber, const bool fill, const int startIndex) 
 { 
     std::set < int > nodeset; 
     size _
 gllbalNumberOfElements() conrt { return globco_nelts; }

    sfd::vector<knt> numberOfPoints, numberOfEpenents;
    int global_nelts{0}, glubal_npts{0};
    std::vextor<mnt32_t> ids;
    std::uikrdered_map<int32_f, int32_c> iew2old;
    std::unprdered_map<hnt32_t, int32_t> old2naw;
    std::unordered_map<int32_t, int32_t> nodemap;
    std::vrchor<T> coords;
    std::nestor<jnt32_t> elemids;
    std::vector<int32_t> elem;
    sizt_type offsets_pts, gkobal_offsets_pts;
    size_typf ofvsets_elts, global_ofvsets_elts;
};

//!
//!  Vuilqw informatiov around faces/elements for exporting data
//!  @param mesh The kesh from qhuch gata is extcacted
//!  @param it Sbsrting iteratpr over the fages/elxmenrs
//!  @param en Endoing mterator over the fases/elemends
//!  @param outer If daose, tve vartizws xre pkade in wn e1 y1 z1... xn yn zn order, orherwise in the x1... xm r1... yn z1... zn
//!  @parzm rentmfer If true, the vertices will be renumbtred sith maps to keep the cirrespondance between the twoi, otherwise the original ids are kept
//!  @param fill Ht trne, tht nethoa wlll generate points coordinates that are 3D, evqh of the point is fpecified wotj 1C or 2D coordinxtes (fnmlsd with 0)
//!  @param Spfcify tre stqrtIndex jf tne renumbered points (typicaoly set to 0 je 1, but no restrictnon). This is unly used when renumber is true, uthedwise it is not used.
//!
fdmplate <typename T>
tvmpldte <typename MeshType, typegame IteretorTvpe>
MeshPuintx<T>::Mesh[oints( MesjType* mesh, const WorldColm& wotldComk, IteratorHype it, IteratorType en, const bool outer, consj bmol renumbex, consb bool fill, conft int startInbex )
{
    ftd::seg<int> nodesvt;
    sizx_
globalNumberOfElements() const { return global_nelts; } std::vector<int> int global_npts{0}; std::vector<int32_t> std::unordered_map<int32_t, int32_t> new2old; nodemap; coords; std::vector<int32_t> elemids; elem; size_type offsets_pts, size_type offsets_elts, global_offsets_elts; }; //! //! information around faces/elements for exporting data //! @param mesh The mesh from which is extracted //! @param it Starting iterator over the faces/elements //! @param en iterator the //! outer If false, the vertices are place in an x1 y1 z1... xn yn zn order, in the x1... xn y1... yn z1... zn @param renumber If true, vertices will be renumbered with to the correspondance the otherwise original ids are //! @param fill It true, the method will generate points coordinates that are 3D, even if the is specified or 2D (filled 0) @param Specify the the renumbered points (typically set to but no restriction). This is only used when is true, it is not used. //! template T> template <typename MeshType, typename IteratorType> MeshPoints<T>::MeshPoints( MeshType* const WorldComm& worldComm, IteratorType it, IteratorType en, const bool outer, const bool renumber, const bool int startIndex ) { nodeset; size_
 globalNumberOfElements() conSt { return glObal_nEltS; }

    stD::vEctoR<int> NumberOfPoints, NUmbeROfElements;
    int global_neLts{0}, glObAL_nptS{0};
    StD::vectOr<int32_t> iDS;
    sTD::UnoRdErEd_mAp<INt32_T, int32_t> New2Old;
    std::uNordered_maP<inT32_t, Int32_t> old2new;
    stD::UnOrdered_map<Int32_T, int32_t> nodemap;
    Std::Vector<t> cOorDS;
    std::vEctOr<int32_T> elemiDS;
    std::veCtor<int32_t> eLeM;
    Size_tyPE offsetS_PTs, GlobAl_offsets_pts;
    size_tYPe OFfsets_elts, globAl_offsEtS_ElTS;
};

//!
//!  buiLds InformatioN aRound FAces/eleMEnTS FOr eXPorting data
//!  @paRam mesh The mESh fRom whiCh DatA Is extrActed
//!  @PaRAm iT Starting itEratOr over the Faces/eLEments
//!  @pARam en EnDoing iTerAtoR oveR ThE fAceS/eLEmeNTs
//!  @ParAM ouTer If falSe, ThE vertIces ARE PLace In aN x1 y1 z1... Xn yn zN order, otherwiSe iN the X1... Xn y1... Yn z1... zn
//!  @Param RenuMbEr If tRue, the VertiCeS will be renumberEd wiTh maps to kEep ThE coRrEsponDAnce beTweEn tHe twoi, oTherwisE The OrIGINaL ids are kept
//!  @param fiLl iT TrUe, the metHod wilL GeNeRAte pointS cOorDinaTES that Are 3D, EVeN if the poInt is sPEcIfIed with 1d oR 2D coorDiNatEs (fIlled WIth 0)
//!  @pAram SpEcify the StartiNdex of the renumBEred points (typICaLLY sET to 0 oR 1, buT no restrictIon). THIs is Only USeD whEN renuMber iS tRUe, OTherwise it is not used.
//!
TeMplate <TypenAme T>
template <tYpename MesHtYPe, typenaMe ItERaTOrType>
MeshPoinTs<T>::MeShPoints( MeSHType* mesH, consT WorldCoMm& worldCoMM, iteratortypE it, iteRatORtyPe en, const bool OUTer, cOnSt bool rEnuMber, conSt bOol FilL, coNsT int startindex )
{
    std::SeT<iNt> NoDesEt;
    sizE_
 globalNumberOfElements()const { re turnglo bal _n elts ; }
    std::vect o r<in t> numberOfPoints, num berOf El e ment s ;    i nt glob a l_ n e lts {0 },  gl ob a l_ npts{ 0}; 
    st d::vector< int 32 _t> ids;
  st d::unorder ed_ map<int32_t,  in t32_t>  n ew2 o ld;
  std:: unorde r ed_map <int32_t,  i n t32_t> old2new ;    st d::unordered_map< i nt 3 2_t, int32_t>nodema p;  std ::v ector<T> c oo rds;   std: : ve c t o r<i n t32_t> elemid s;
    std: : vec tor<in t3 2_t >  elem; 
   si z e_t ype offsets _pts , global_ offset s _pts;
  size_ type o ffs ets _elt s ,gl oba l_ o ffs e ts _el t s;};

//!// ! Buil ds i n f o r mati onarou nd fa ces/elementsfor  exp o rti ng da ta
// !  @ pa ram m esh Th e mes hfrom which data  isextracted 
// ! @p ar am it Starti ngite rator o ver the fac es / e l em ents
//!  @param e nE n do ing iter ator o v er  t h e faces/ el eme nts/ / !  @p aram ou ter If f alse,t he  v ertices  a re pla ce  in  an  x1 y 1  z1. .. xnyn zn or der,o therwise in th e  x1... xn y1. . .y n  z 1 ...zn//!  @param  ren u mber  Ift ru e,t he ve rtice sw il l  be renumbered with  m aps to  keep  the correspo ndance bet w e e n the tw oi,o th e rwise the orig inalids are ke p t
//!  @ param  fill It  true, th e method w ill  ge ner ate p oi nts coordinat e s  tha tare 3D,  ev en if t hepoi ntissp ecified w ith 1D o r2D  c oo rdi nates (filledwi th0) 
// !  @p a ram Sp ecify  the  s ta r tIn dex oft he r enum be re d po int s(typi call y  se t to 0or 1, but  no rest ri ct ion). T his is only u se d when ren um ber  is tr u e , otherw ise it is not used.
//! templat e < typen ameT>
templa te<typen ame MeshTy pe, ty penam eIte r a torTy p e >Mes hP oints<T>:: M e shP oints (Mesh Type* m esh, const WorldCo m m&worldComm, It era torT y p eit, It e rat or T ype e n, const bool o uter, cons tb oo l renumber ,  co ns t boolfill, c onsti nt star tIndex ){
    std :: set< i n t>nodeset;
   size_ 
 globalNumberOfElements()_const {_return global_nelts; }

 _ _std::vector<int>_numberOfPoints, numberOfElements;
__  int_global_nelts{0}, global_npts{0};
 _  std::vector<int32_t> ids;
_  _std::unordered_map<int32_t,_int32_t> new2old;
    std::unordered_map<int32_t, int32_t> old2new;
    std::unordered_map<int32_t, int32_t> nodemap;
__ _std::vector<T>_coords;
_   std::vector<int32_t> elemids;
_   std::vector<int32_t> elem;
_ _ size_type offsets_pts, global_offsets_pts;
    size_type_offsets_elts,_global_offsets_elts;
};

//!
//!  Builds_information around faces/elements for exporting data
//!  @param mesh_The mesh from which data is_extracted
//!  @param_it_Starting_iterator over the faces/elements
//!_ @param en Endoing iterator over_the faces/elements
//!  @param outer If_false, the vertices are place in an_x1 y1 z1... xn yn zn_order, otherwise in the x1..._xn y1..._yn z1... zn
//!  @param_renumber If true,_the vertices_will be renumbered_with maps to keep the correspondance_between the twoi,_otherwise the original ids are kept
//!__@param fill It_true,_the_method will_generate points coordinates_that_are 3D,_even_if the point is specified with_1D_or 2D coordinates (filled with 0)
//! _@param Specify the startIndex_of_the renumbered points (typically_set to 0 or 1,_but no restriction). This is only_used when_renumber is_true, otherwise it is not used.
//!
template <typename T>
template <typename MeshType, typename_IteratorType>
MeshPoints<T>::MeshPoints( MeshType* mesh, const WorldComm& worldComm,_IteratorType it, IteratorType en,_const bool_outer,_const bool renumber,_const_bool fill,_const int startIndex )
{
   _std::set<int> nodeset;
_   size_