src/MEDLoader/MeshFormatReader.hxx

   1 // Copyright (C) 2021  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License, or (at your option) any later version.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #ifndef MESHFORMATREADER_HXX
  21 #define MESHFORMATREADER_HXX
  22
  23 #include <vector>
  24 #include <string>
  25 #include <map>
  26 #include <algorithm>
  27 #include <utility>
  28 #include <iterator>
  29 #include "MCAuto.hxx"
  30 #include "InterpKernelException.hxx"
  31 #include "NormalizedUnstructuredMesh.hxx"
  32 #include "MCType.hxx"
  33 #include "MEDMESHConverterUtilities.hxx"
  34 #include "libmesh5.hxx"
  35
  36 #include <fstream>
  37
  38 #ifndef WIN32
  39 #include <features.h>
  40 #endif
  41
  42 namespace MEDCoupling
  43 {
  44 class DataArrayDouble;
  45 class DataArrayInt;
  46 class MEDFileData;
  47 class MEDFileFields;
  48 class MEDFileFieldMultiTS;
  49 class MEDFileUMesh;
  50 class MEDCouplingUMesh;
  51
  52
  53 struct MeshFormatElement {
  54     MeshFormatElement(int type, int id=0):_type(type), _id(id) {}
  55     int _type;
  56     int _id;
  57
  58     inline friend bool operator==(const MeshFormatElement& a, const MeshFormatElement&b ) {
  59         return ((a._type == b._type) && (a._id == b._id));
  60     }
  61 };
  62
  63 struct MeshFormatFamily {
  64
  65     std::map <int, std::vector<MeshFormatElement>* > _meshFormatFams;
  66     std::map <int, std::vector<MeshFormatElement>* > _meshFormatFams_0;
  67     std::map <int, std::vector<MeshFormatElement>* > _meshFormatFams_1;
  68     std::map <int, std::vector<MeshFormatElement>* > _meshFormatFams_2;
  69     std::map <int, std::vector<MeshFormatElement>* > _meshFormatFamsNodes;
  70
  71 public:
  72     void insert(std::pair<int, MeshFormatElement> addToFamily, int dimRelMax)
  73     {
  74         insertPairInMap(_meshFormatFams, addToFamily);
  75         insertPairInMap(getMapAtLevel(dimRelMax), addToFamily);
  76     }
  77 private:
  78     void insertPairInMap(std::map <int, std::vector<MeshFormatElement>* >& aMap, std::pair<int, MeshFormatElement> addToFamily)
  79     {
  80         std::map <int, std::vector<MeshFormatElement>* >::iterator it = aMap.find(addToFamily.first);
  81         if (it!= aMap.end())
  82         {
  83             aMap[addToFamily.first]->push_back(addToFamily.second);
  84         }
  85         else
  86         {
  87             std::vector <MeshFormatElement>* tmpVec = new std::vector <MeshFormatElement> ;
  88             tmpVec->push_back(addToFamily.second);
  89             aMap.insert(std::pair <int, std::vector <MeshFormatElement>* > (addToFamily.first, tmpVec) );
  90
  91         }
  92
  93     }
  94 public:
  95     void remove(std::pair<int, MeshFormatElement> removeFromFamily, int dimRelMax)
  96     {
  97         removePairFromMap(_meshFormatFams, removeFromFamily);
  98         removePairFromMap(getMapAtLevel(dimRelMax), removeFromFamily);
  99
 100     }
 101 private:
 102     void removePairFromMap(std::map <int, std::vector<MeshFormatElement>* > & aMap, const std::pair<int, MeshFormatElement> removeFromFamily)
 103     {
 104
 105         if (!aMap.size() ) return;
 106         std::map <int, std::vector<MeshFormatElement>* >::iterator itTmp = aMap.find(removeFromFamily.first);
 107         if (itTmp == aMap.end()) return;
 108         else
 109         {
 110             std::vector <MeshFormatElement>* tmpVec2 = aMap[removeFromFamily.first];
 111             const MeshFormatElement e = removeFromFamily.second;
 112             auto itt2 = std::find(tmpVec2->cbegin(), tmpVec2->cend(), e);
 113             if (itt2 != tmpVec2->cend())
 114                 tmpVec2->erase(itt2);
 115
 116             if (!tmpVec2->size())
 117             {
 118                 delete tmpVec2;
 119                 aMap.erase(removeFromFamily.first);
 120             }
 121         }
 122     }
 123 public:
 124     std::map <int, std::vector<MeshFormatElement>* > & getMapAtLevel(int dimRelMax)
 125     {
 126         switch(dimRelMax)
 127         {
 128         case 0 :
 129             return  _meshFormatFams_0;
 130             break;
 131         case -1 :
 132             return  _meshFormatFams_1;
 133             break;
 134         case -2 :
 135             return  _meshFormatFams_2;
 136             break;
 137         case 1 :
 138             return  _meshFormatFamsNodes;
 139             break;
 140         }
 141     }
 142 public:
 143     ~MeshFormatFamily()
 144     {
 145
 146         freeMap(_meshFormatFams);
 147         freeMap(_meshFormatFams_0);
 148         freeMap(_meshFormatFams_1);
 149         freeMap(_meshFormatFams_2);
 150         freeMap(_meshFormatFamsNodes);
 151
 152     }
 153
 154 private:
 155     void freeMap(std::map <int, std::vector<MeshFormatElement>* > & aMap)
 156     {
 157         std::map <int, std::vector<MeshFormatElement>* >::iterator it = aMap.begin();
 158         for (; it !=aMap.end(); ++it) delete it->second;
 159     }
 160
 161 };
 162 class MeshFormatReader
 163 {
 164 public :
 165     MEDLOADER_EXPORT MeshFormatReader();
 166     MEDLOADER_EXPORT MeshFormatReader(const std::string& meshFileName, const std::vector<std::string>& fieldFileName);
 167     MEDLOADER_EXPORT ~MeshFormatReader();
 168
 169     MEDLOADER_EXPORT MEDCoupling::MCAuto<MEDCoupling::MEDFileData> loadInMedFileDS() ;
 170     MEDLOADER_EXPORT void setMeshName(const std::string& theMeshName);
 171     MEDLOADER_EXPORT std::string getMeshName() const;
 172     MEDLOADER_EXPORT void setFile(const std::string& theFileName);
 173     MEDLOADER_EXPORT void setFieldFileNames(const std::vector<std::string>& theFieldFileNames);
 174     MEDLOADER_EXPORT std::vector<std::string> getFieldFileNames() const;
 175     MEDLOADER_EXPORT std::vector< std::string > getErroMessage() const;
 176
 177 private :
 178
 179     MeshFormat::Status addMessage(const std::string& msg, const bool isFatal=false);
 180     MeshFormat::Status perform();
 181     MeshFormat::Status performFields();
 182     MeshFormat::Status setNodes(MEDCoupling::DataArrayDouble* coordArray);
 183     void setEdges(MEDCoupling::MEDCouplingUMesh* dimMesh1, int nbEdges);
 184     void setTriangles( MEDCoupling::MEDCouplingUMesh* dimMesh2, int nbTria);
 185     void setQuadrangles( MEDCoupling::MEDCouplingUMesh* dimMesh2, int nbQuad);
 186     void setTetrahedras( MEDCoupling::MEDCouplingUMesh* dimMesh3, int nbTet);
 187     void setPyramids(MEDCoupling::MEDCouplingUMesh* dimMesh3, int nbPyr);
 188     void setHexahedras(MEDCoupling::MEDCouplingUMesh* dimMesh3, int nbHex);
 189     void setPrisms(MEDCoupling::MEDCouplingUMesh* dimMesh3, int nbPrism);
 190     void callParserGetLin( MeshFormat::GmfKwdCod kwd,  double* val, int valSize, int* ref);
 191     void setTypeOfFieldAndDimRel(MeshFormat::GmfKwdCod kwd, MEDCoupling::TypeOfField* typeOfField, int* dimRel );
 192     void backward_shift(MEDCoupling::mcIdType*, int size);
 193     void setFields( MeshFormat::GmfKwdCod kwd, int nmbSol, int nbComp);
 194     INTERP_KERNEL::NormalizedCellType toMedType(MeshFormat::GmfKwdCod kwd);
 195     void buildFamilies();
 196     void buildNodesFamilies();
 197     void buildCellsFamilies();
 198
 199     std::string _myFile;
 200     MeshFormat::MeshFormatParser _reader;
 201     std::string _myCurrentOpenFile;
 202     int _myCurrentFileId;
 203     std::string _myMeshName;
 204     std::vector<std::string> _myFieldFileNames;
 205     int _dim, _version;
 206     std::vector< std::string > _myErrorMessages;
 207     MeshFormat::Status                     _myStatus;
 208     MEDCoupling::MCAuto<MEDCoupling::MEDFileData> _myMed;
 209     MEDCoupling::MCAuto<MEDCoupling::MEDFileUMesh> _uMesh;
 210     MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> _fields;
 211     // map id family --element
 212     MeshFormatFamily _fams;
 213
 214     int _dim1NbEl;
 215     int _dim2NbEl;
 216     int _dim3NbEl;
 217 };
 218 }
 219 #endif //MESHFORMATREADER_HXX