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   struct MeshFormatElement
  53   {
  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     {
  60       return ((a._type == b._type) && (a._id == b._id));
  61     }
  62   };
  63
  64   struct MeshFormatFamily
  65   {
  66
  67     std::map<int, std::vector<MeshFormatElement> *> _meshFormatFams;
  68     std::map<int, std::vector<MeshFormatElement> *> _meshFormatFams_0;
  69     std::map<int, std::vector<MeshFormatElement> *> _meshFormatFams_1;
  70     std::map<int, std::vector<MeshFormatElement> *> _meshFormatFams_2;
  71     std::map<int, std::vector<MeshFormatElement> *> _meshFormatFamsNodes;
  72
  73   public:
  74     void insert(std::pair<int, MeshFormatElement> addToFamily, int dimRelMax)
  75     {
  76       insertPairInMap(_meshFormatFams, addToFamily);
  77       insertPairInMap(getMapAtLevel(dimRelMax), addToFamily);
  78     }
  79
  80   private:
  81     void insertPairInMap(std::map<int, std::vector<MeshFormatElement> *> &aMap, std::pair<int, MeshFormatElement> addToFamily)
  82     {
  83       std::map<int, std::vector<MeshFormatElement> *>::iterator it = aMap.find(addToFamily.first);
  84       if (it != aMap.end())
  85       {
  86         aMap[addToFamily.first]->push_back(addToFamily.second);
  87       }
  88       else
  89       {
  90         std::vector<MeshFormatElement> *tmpVec = new std::vector<MeshFormatElement>;
  91         tmpVec->push_back(addToFamily.second);
  92         aMap.insert(std::pair<int, std::vector<MeshFormatElement> *>(addToFamily.first, tmpVec));
  93       }
  94     }
  95
  96   public:
  97     void remove(std::pair<int, MeshFormatElement> removeFromFamily, int dimRelMax)
  98     {
  99       removePairFromMap(_meshFormatFams, removeFromFamily);
 100       removePairFromMap(getMapAtLevel(dimRelMax), removeFromFamily);
 101     }
 102
 103   private:
 104     void removePairFromMap(std::map<int, std::vector<MeshFormatElement> *> &aMap, const std::pair<int, MeshFormatElement> removeFromFamily)
 105     {
 106
 107       if (!aMap.size())
 108         return;
 109       std::map<int, std::vector<MeshFormatElement> *>::iterator itTmp = aMap.find(removeFromFamily.first);
 110       if (itTmp == aMap.end())
 111         return;
 112       else
 113       {
 114         std::vector<MeshFormatElement> *tmpVec2 = aMap[removeFromFamily.first];
 115         std::vector<MeshFormatElement>::iterator itt2;
 116         const MeshFormatElement e = removeFromFamily.second;
 117         itt2 = std::find(tmpVec2->begin(), tmpVec2->end(), e);
 118         if (itt2 != tmpVec2->end())
 119           tmpVec2->erase(itt2);
 120
 121         if (!tmpVec2->size())
 122         {
 123           delete tmpVec2;
 124           aMap.erase(removeFromFamily.first);
 125         }
 126       }
 127     }
 128
 129   public:
 130     std::map<int, std::vector<MeshFormatElement> *> &getMapAtLevel(int dimRelMax)
 131     {
 132       switch (dimRelMax)
 133       {
 134       case 0:
 135         return _meshFormatFams_0;
 136         break;
 137       case -1:
 138         return _meshFormatFams_1;
 139         break;
 140       case -2:
 141         return _meshFormatFams_2;
 142         break;
 143       case 1:
 144         return _meshFormatFamsNodes;
 145         break;
 146       }
 147     }
 148
 149   public:
 150     ~MeshFormatFamily()
 151     {
 152
 153       freeMap(_meshFormatFams);
 154       freeMap(_meshFormatFams_0);
 155       freeMap(_meshFormatFams_1);
 156       freeMap(_meshFormatFams_2);
 157       freeMap(_meshFormatFamsNodes);
 158     }
 159
 160   private:
 161     void freeMap(std::map<int, std::vector<MeshFormatElement> *> &aMap)
 162     {
 163       std::map<int, std::vector<MeshFormatElement> *>::iterator it = aMap.begin();
 164       for (; it != aMap.end(); ++it)
 165         delete it->second;
 166     }
 167   };
 168   class MeshFormatReader
 169   {
 170   public:
 171     MEDLOADER_EXPORT MeshFormatReader();
 172     MEDLOADER_EXPORT MeshFormatReader(const std::string &meshFileName, const std::vector<std::string> &fieldFileName);
 173     MEDLOADER_EXPORT ~MeshFormatReader();
 174
 175     MEDLOADER_EXPORT MEDCoupling::MCAuto<MEDCoupling::MEDFileData> loadInMedFileDS();
 176     MEDLOADER_EXPORT void setMeshName(const std::string &theMeshName);
 177     MEDLOADER_EXPORT std::string getMeshName() const;
 178     MEDLOADER_EXPORT void setFile(const std::string &theFileName);
 179     MEDLOADER_EXPORT void setFieldFileNames(const std::vector<std::string> &theFieldFileNames);
 180     MEDLOADER_EXPORT std::vector<std::string> getFieldFileNames() const;
 181     MEDLOADER_EXPORT std::vector<std::string> getErroMessage() const;
 182
 183   private:
 184     MeshFormat::Status addMessage(const std::string &msg, const bool isFatal = false);
 185     MeshFormat::Status perform();
 186     MeshFormat::Status performFields();
 187     MeshFormat::Status setNodes(MEDCoupling::DataArrayDouble *coordArray);
 188     void setEdges(MEDCoupling::MEDCouplingUMesh *dimMesh1, int nbEdges);
 189     void setTriangles(MEDCoupling::MEDCouplingUMesh *dimMesh2, int nbTria);
 190     void setQuadrangles(MEDCoupling::MEDCouplingUMesh *dimMesh2, int nbQuad);
 191     void setTetrahedras(MEDCoupling::MEDCouplingUMesh *dimMesh3, int nbTet);
 192     void setPyramids(MEDCoupling::MEDCouplingUMesh *dimMesh3, int nbPyr);
 193     void setHexahedras(MEDCoupling::MEDCouplingUMesh *dimMesh3, int nbHex);
 194     void setPrisms(MEDCoupling::MEDCouplingUMesh *dimMesh3, int nbPrism);
 195     void callParserGetLin(MeshFormat::GmfKwdCod kwd, double *val, int valSize, int *ref);
 196     void setTypeOfFieldAndDimRel(MeshFormat::GmfKwdCod kwd, MEDCoupling::TypeOfField *typeOfField, int *dimRel);
 197     void backward_shift(MEDCoupling::mcIdType *, int size);
 198     void setFields(MeshFormat::GmfKwdCod kwd, int nmbSol, int nbComp);
 199     INTERP_KERNEL::NormalizedCellType toMedType(MeshFormat::GmfKwdCod kwd);
 200     void buildFamilies();
 201     void buildNodesFamilies();
 202     void buildCellsFamilies();
 203
 204     std::string _myFile;
 205     MeshFormat::MeshFormatParser _reader;
 206     std::string _myCurrentOpenFile;
 207     int _myCurrentFileId;
 208     std::string _myMeshName;
 209     std::vector<std::string> _myFieldFileNames;
 210     int _dim, _version;
 211     std::vector<std::string> _myErrorMessages;
 212     MeshFormat::Status _myStatus;
 213     MEDCoupling::MCAuto<MEDCoupling::MEDFileData> _myMed;
 214     MEDCoupling::MCAuto<MEDCoupling::MEDFileUMesh> _uMesh;
 215     MEDCoupling::MCAuto<MEDCoupling::MEDFileFields> _fields;
 216     // map id family --element
 217     MeshFormatFamily _fams;
 218
 219     int _dim1NbEl;
 220     int _dim2NbEl;
 221     int _dim3NbEl;
 222   };
 223 } // namespace MEDCoupling
 224 #endif //MESHFORMATREADER_HXX