Merge branch 'gambit-output' into 'master'

Add ability to output to GAMBIT neutral file format

See merge request !25

Common/CommandLine.cpp

@@ -74,7 +74,7 @@ std::vector<std::pair<std::string, std::string> > GetUsage()
   s.push_back(mp("-o file",            "Specify output file name"));
   s.push_back(mp("-format string",     "Select output mesh format (auto (default), msh, "
                                        "msh1, msh2, unv, vrml, ply2, stl, mesh, bdf, cgns, "
-                                       "p3d, diff, med, ...)"));
+                                       "p3d, diff, med, neu, ...)"));
   s.push_back(mp("-bin",               "Use binary format when available"));
   s.push_back(mp("-refine",            "Perform uniform mesh refinement, then exit"));
   s.push_back(mp("-reclassify",        "Reclassify mesh, then exit"));
@@ -1163,5 +1163,3 @@ void GetOptions(int argc, char *argv[])
   if(CTX::instance()->terminal == 99)
     CTX::instance()->terminal = terminal;
 }
-
-

Common/CreateFile.cpp

@@ -79,6 +79,7 @@ int GetFileFormatFromExtension(const std::string &ext)
   else if(ext == ".stp")  return FORMAT_STEP;
   else if(ext == ".iges") return FORMAT_IGES;
   else if(ext == ".igs")  return FORMAT_IGES;
+  else if(ext == ".neu")  return FORMAT_NEU;
   else                           return -1;
 }
 
@@ -133,6 +134,7 @@ std::string GetDefaultFileName(int format)
   case FORMAT_BREP: name += ".brep"; break;
   case FORMAT_IGES: name += ".iges"; break;
   case FORMAT_STEP: name += ".step"; break;
+  case FORMAT_NEU: name += ".neu"; break;
   default: break;
   }
   return name;
@@ -396,6 +398,11 @@ void CreateOutputFile(const std::string &fileName, int format,
     GModel::current()->writeOCCSTEP(name);
     break;
 
+  case FORMAT_NEU:
+    GModel::current()->writeNEU
+      (name, CTX::instance()->mesh.saveAll, CTX::instance()->mesh.scalingFactor);
+    break;
+
 #if defined(HAVE_FLTK)
   case FORMAT_PPM:
   case FORMAT_YUV:

Common/GmshDefines.h

@@ -55,6 +55,7 @@
 #define FORMAT_X3D          46
 #define FORMAT_TOCHNOG      47
 #define FORMAT_TIKZ         48
+#define FORMAT_NEU          49
 
 // Element types
 #define TYPE_PNT     1

Fltk/graphicWindow.cpp

@@ -316,6 +316,8 @@ static int _save_vrml(const char *name){ return genericMeshFileDialog
     (name, "VRML Options", FORMAT_VRML, false, false); }
 static int _save_ply2(const char *name){ return genericMeshFileDialog
     (name, "PLY2 Options", FORMAT_PLY2, false, false); }
+static int _save_neu(const char *name){ return genericMeshFileDialog
+    (name, "NEU Options", FORMAT_NEU, false, false); }
 static int _save_eps(const char *name){ return gl2psFileDialog
     (name, "EPS Options", FORMAT_EPS); }
 static int _save_gif(const char *name){ return gifFileDialog(name); }
@@ -380,6 +382,7 @@ static int _save_auto(const char *name)
   case FORMAT_STL  : return _save_stl(name);
   case FORMAT_VRML : return _save_vrml(name);
   case FORMAT_PLY2 : return _save_ply2(name);
+  case FORMAT_NEU  : return _save_neu(name);
   case FORMAT_EPS  : return _save_eps(name);
   case FORMAT_GIF  : return _save_gif(name);
   case FORMAT_JPEG : return _save_jpeg(name);
@@ -436,6 +439,7 @@ static void file_export_cb(Fl_Widget *w, void *data)
     {"Mesh - Tochnog" TT "*.dat", _save_tochnog},
     {"Mesh - PLY2 Surface" TT "*.ply2", _save_ply2},
     {"Mesh - SU2" TT "*.su2", _save_su2},
+    {"Mesh - GAMBIT Neutral File" TT "*.neu", _save_neu},
     {"Post-processing - Gmsh POS" TT "*.pos", _save_view_pos},
     {"Post-processing - X3D (X3D)" TT "*.x3d", _save_view_x3d},
 #if defined(HAVE_MED)

Geo/CMakeLists.txt

@@ -30,7 +30,7 @@ set(SRC
       GModelIO_CGNS.cpp GModelIO_MED.cpp GModelIO_MESH.cpp GModelIO_STL.cpp
       GModelIO_PLY.cpp GModelIO_VRML.cpp GModelIO_UNV.cpp GModelIO_BDF.cpp
       GModelIO_IR3.cpp GModelIO_DIFF.cpp GModelIO_GEOM.cpp GModelIO_INP.cpp
-      GModelIO_MAIL.cpp GModelIO_P3D.cpp GModelIO_CELUM.cpp
+      GModelIO_MAIL.cpp GModelIO_P3D.cpp GModelIO_CELUM.cpp GModelIO_NEU.cpp
       GModelIO_ACTRAN.cpp GModelIO_SU2.cpp GModelIO_SAMCEF.cpp
   ExtrudeParams.cpp
   Geo.cpp

Geo/GModel.h

@@ -724,6 +724,9 @@ class GModel {
 
   // SU2 mesh file
   int writeSU2(const std::string &name, bool saveAll, double scalingFactor);
+
+  // GAMBIT neutral mesh file (.neu)
+  int writeNEU(const std::string &name, bool saveAll, double scalingFactor);
 };
 
 #endif

Geo/GModelIO_NEU.cpp

+// Gmsh - Copyright (C) 1997-2017 C. Geuzaine, J.-F. Remacle
+//
+// See the LICENSE.txt file for license information. Please report all
+// bugs and problems to the public mailing list <gmsh@onelab.info>.
+
+#include <algorithm>
+#include <limits>
+#if __cplusplus >= 201103L
+#include <unordered_map>
+#else
+#include <map>
+#endif
+#include "GModel.h"
+#include "OS.h"
+#include "MTriangle.h"
+#include "MTetrahedron.h"
+
+namespace
+{
+  static const unsigned GAMBIT_TYPE_EDGE = 1;
+  static const unsigned GAMBIT_TYPE_QUAD = 2;
+  static const unsigned GAMBIT_TYPE_TRI  = 3;
+  static const unsigned GAMBIT_TYPE_TET  = 6;
+
+  // This struct allows us to take advantage of C++11 unordered_map while
+  // maintaining backwards compatibility with C++03
+  template<typename Key, typename Value>
+  struct hashMap {
+    #if __cplusplus >= 201103L
+    typedef std::unordered_map<Key, Value> _;
+    #else
+    typedef std::map<Key, Value> _;
+    #endif
+  };
+
+  const hashMap<std::string, unsigned>::_::value_type rawData[] = {
+    hashMap<std::string, unsigned>::_::value_type("UNSPECIFIED", 0),
+    hashMap<std::string, unsigned>::_::value_type("AXIS", 1),
+    hashMap<std::string, unsigned>::_::value_type("CONJUGATE", 2),
+    hashMap<std::string, unsigned>::_::value_type("CONVECTION", 3),
+    hashMap<std::string, unsigned>::_::value_type("CYCLIC", 4),
+    hashMap<std::string, unsigned>::_::value_type("DEAD", 5),
+    hashMap<std::string, unsigned>::_::value_type("ELEMENT_SID", 6),
+    hashMap<std::string, unsigned>::_::value_type("ESPECIES", 7),
+    hashMap<std::string, unsigned>::_::value_type("EXHAUST_FAN", 8),
+    hashMap<std::string, unsigned>::_::value_type("FAN", 9),
+    hashMap<std::string, unsigned>::_::value_type("FREE_SURFACE", 10),
+    hashMap<std::string, unsigned>::_::value_type("GAP", 11),
+    hashMap<std::string, unsigned>::_::value_type("INFLOW", 12),
+    hashMap<std::string, unsigned>::_::value_type("INLET", 13),
+    hashMap<std::string, unsigned>::_::value_type("INLET_VENT", 14),
+    hashMap<std::string, unsigned>::_::value_type("INTAKE_FAN", 15),
+    hashMap<std::string, unsigned>::_::value_type("INTERFACE", 16),
+    hashMap<std::string, unsigned>::_::value_type("INTERIOR", 17),
+    hashMap<std::string, unsigned>::_::value_type("INTERNAL", 18),
+    hashMap<std::string, unsigned>::_::value_type("LIVE", 19),
+    hashMap<std::string, unsigned>::_::value_type("MASS_FLOW_INLET", 20),
+    hashMap<std::string, unsigned>::_::value_type("MELT", 21),
+    hashMap<std::string, unsigned>::_::value_type("MELT_INTERFACE", 22),
+    hashMap<std::string, unsigned>::_::value_type("MOVING_BOUNDARY", 23),
+    hashMap<std::string, unsigned>::_::value_type("NODE", 24),
+    hashMap<std::string, unsigned>::_::value_type("OUTFLOW", 25),
+    hashMap<std::string, unsigned>::_::value_type("OUTLET", 26),
+    hashMap<std::string, unsigned>::_::value_type("OUTLET_VENT", 27),
+    hashMap<std::string, unsigned>::_::value_type("PERIODIC", 28),
+    hashMap<std::string, unsigned>::_::value_type("PLOT", 29),
+    hashMap<std::string, unsigned>::_::value_type("POROUS", 30),
+    hashMap<std::string, unsigned>::_::value_type("POROUS_JUMP", 31),
+    hashMap<std::string, unsigned>::_::value_type("PRESSURE", 32),
+    hashMap<std::string, unsigned>::_::value_type("PRESSURE_FAR_FIELD", 33),
+    hashMap<std::string, unsigned>::_::value_type("PRESSURE_INFLOW", 34),
+    hashMap<std::string, unsigned>::_::value_type("PRESSURE_INLET", 35),
+    hashMap<std::string, unsigned>::_::value_type("PRESSURE_OUTFLOW", 36),
+    hashMap<std::string, unsigned>::_::value_type("PRESSURE_OUTLET", 37),
+    hashMap<std::string, unsigned>::_::value_type("RADIATION", 38),
+    hashMap<std::string, unsigned>::_::value_type("RADIATOR", 39),
+    hashMap<std::string, unsigned>::_::value_type("RECIRCULATION_INLET", 40),
+    hashMap<std::string, unsigned>::_::value_type("RECIRCULATION_OUTLET", 41),
+    hashMap<std::string, unsigned>::_::value_type("SLIP", 42),
+    hashMap<std::string, unsigned>::_::value_type("SREACTION", 43),
+    hashMap<std::string, unsigned>::_::value_type("SURFACE", 44),
+    hashMap<std::string, unsigned>::_::value_type("SYMMETRY", 45),
+    hashMap<std::string, unsigned>::_::value_type("TRACTION", 46),
+    hashMap<std::string, unsigned>::_::value_type("TRAJECTORY", 47),
+    hashMap<std::string, unsigned>::_::value_type("VELOCITY", 48),
+    hashMap<std::string, unsigned>::_::value_type("VELOCITY_INLET", 49),
+    hashMap<std::string, unsigned>::_::value_type("VENT", 50),
+    hashMap<std::string, unsigned>::_::value_type("WALL", 51),
+    hashMap<std::string, unsigned>::_::value_type("SPRING", 52),
+  };
+  static const hashMap<std::string, unsigned>::_ boundaryCodeMap(rawData, rawData + (sizeof rawData / sizeof rawData[0]));
+
+  // Gambit numbers its faces slightly differently
+  static const unsigned GAMBIT_FACE_MAP[4] = {1,2,4,3};
+
+  unsigned const gambitBoundaryCode(std::string name)
+  {
+    std::transform(name.begin(), name.end(),name.begin(), ::toupper);
+    hashMap<std::string, unsigned>::_::const_iterator code = boundaryCodeMap.find(name);
+    return code == boundaryCodeMap.end() ? 0 : code->second;
+  }
+
+  typedef std::pair<unsigned, unsigned> TetFacePair;
+  typedef hashMap<unsigned, std::vector<TetFacePair> >::_ IDTetFaceMap;
+
+  bool const sortBCs(TetFacePair const& lhs, TetFacePair const& rhs)
+  {
+    return lhs.first < rhs.first;
+  }
+
+  IDTetFaceMap const gatherBC(GModel* gm)
+  {
+    // create association map for vertices and faces
+    hashMap<unsigned, std::vector<unsigned> >::_ vertmap;
+    for (GModel::fiter it = gm->firstFace(); it != gm->lastFace(); ++it) {
+      for (unsigned i = 0; i < (*it)->triangles.size(); ++i) {
+        MTriangle* tri = (*it)->triangles[i];
+        for (int j = 0; j < tri->getNumVertices(); ++j) {
+          vertmap[tri->getVertex(j)->getNum()].push_back(tri->getNum());
+        }
+      }
+    }
+
+    // determine which faces belong to which tetrahedra by comparing vertices
+    IDTetFaceMap tetfacemap;
+    for (GModel::riter it = gm->firstRegion(); it != gm->lastRegion(); ++it) {
+      for (unsigned i = 0; i < (*it)->tetrahedra.size(); ++i) {
+        MTetrahedron* tet = (*it)->tetrahedra[i];
+        for (int faceNum = 0; faceNum < tet->getNumFaces(); ++faceNum) {
+          std::vector<MVertex*> verts;
+          tet->getFaceVertices(faceNum, verts);
+
+          std::vector<unsigned> current = vertmap[verts[0]->getNum()];
+          for (unsigned j = 1; j < verts.size() && current.size() != 0; ++j) {
+            std::vector<unsigned> common_data;
+            set_intersection(current.begin(), current.end(),
+                             vertmap[verts[j]->getNum()].begin(),
+                             vertmap[verts[j]->getNum()].end(),
+                             std::back_inserter(common_data));
+            current = common_data;
+          }
+          if (current.size() == 1) {
+            tetfacemap[current[0]].push_back(
+                TetFacePair(tet->getNum(), GAMBIT_FACE_MAP[faceNum]));
+          }
+        }
+      }
+    }
+
+    // populate boundary conditions for tetrahedra given triangle physicals
+    IDTetFaceMap boundaryConditions;
+    for (GModel::fiter it = gm->firstFace(); it != gm->lastFace(); ++it) {
+      if ((*it)->physicals.size()) {
+        for (unsigned i = 0; i < (*it)->physicals.size(); ++i) {
+          unsigned phys = (*it)->physicals[i];
+          for (unsigned j = 0; j < (*it)->triangles.size(); ++j) {
+            MTriangle* tri = (*it)->triangles[j];
+            IDTetFaceMap::iterator tets = tetfacemap.find(tri->getNum());
+            if (tets != tetfacemap.end()) {
+              for (unsigned tet = 0; tet < tets->second.size(); ++tet) {
+                boundaryConditions[phys].push_back(tets->second[tet]);
+              }
+            }
+          }
+        }
+      }
+    }
+
+    return boundaryConditions;
+  }
+}
+
+// for a specification of the GAMBIT neutral format:
+//   http://web.stanford.edu/class/me469b/handouts/gambit_write.pdf
+int GModel::writeNEU(const std::string &name, bool saveAll,
+                     double scalingFactor)
+{
+  FILE* fp = Fopen(name.c_str(), "w");
+  if (!fp) {
+    Msg::Error("Unable to open file '%s'", name.c_str());
+    return 0;
+  }
+
+  // gather tetrahedra and id normalization information
+  unsigned numTetrahedra = 0;
+  int lowestId = std::numeric_limits<int>::max();
+  hashMap<unsigned, std::vector<unsigned> >::_ elementGroups;
+  for (riter it = firstRegion(); it != lastRegion(); ++it) {
+    if (saveAll || (*it)->physicals.size()) {
+      numTetrahedra += (*it)->tetrahedra.size();
+
+      for (unsigned phys = 0; phys < (*it)->physicals.size(); ++phys) {
+        for (unsigned i = 0; i < (*it)->tetrahedra.size(); ++i) {
+          MTetrahedron* tet = (*it)->tetrahedra[i];
+          elementGroups[(*it)->physicals[phys]].push_back(tet->getNum());
+
+          if (tet->getNum() < lowestId) lowestId = tet->getNum()-1;
+        }
+      }
+    }
+  }
+
+  IDTetFaceMap boundaryConditions = gatherBC(this);
+
+  // Metadata
+  fprintf(fp, "        CONTROL INFO 2.0.0\n");
+  fprintf(fp, "** GAMBIT NEUTRAL FILE\n");
+  fprintf(fp, "Gmsh mesh in GAMBIT neutral file format\n");
+  fprintf(fp, "PROGRAM:                Gambit     VERSION:  2.0.0\n");
+
+  char datestring[256];
+  time_t rawtime;
+  struct tm* timeinfo;
+  time(&rawtime);
+  timeinfo = localtime(&rawtime);
+  strftime(datestring, sizeof(datestring), "%c", timeinfo);
+  fprintf(fp, "%s\n", datestring);
+
+  fprintf(fp, "     NUMNP     NELEM     NGRPS    NBSETS     NDFCD     NDFVL\n");
+  fprintf(fp, " %9d %9d %9lu %9lu %9d %9d\n", indexMeshVertices(saveAll), numTetrahedra,
+          elementGroups.size(), boundaryConditions.size(), getDim(),
+          getDim());
+  fprintf(fp, "ENDOFSECTION\n");
+
+  // Nodes
+  fprintf(fp, "   NODAL COORDINATES 2.0.0\n");
+  std::vector<GEntity*> entities;
+  getEntities(entities);
+  for (unsigned i = 0; i < entities.size(); ++i) {
+    for (unsigned j = 0; j < entities[i]->mesh_vertices.size(); ++j) {
+      entities[i]->mesh_vertices[j]->writeNEU(fp, getDim(), scalingFactor);
+    }
+  }
+  fprintf(fp, "ENDOFSECTION\n");
+
+  // Elements
+  fprintf(fp, "      ELEMENTS/CELLS 2.0.0\n");
+  for (riter it = firstRegion(); it != lastRegion(); ++it) {
+    unsigned numPhys = (*it)->physicals.size();
+    if (saveAll || numPhys) {
+      for (unsigned i = 0; i < (*it)->tetrahedra.size(); ++i) {
+        (*it)->tetrahedra[i]->writeNEU(fp, GAMBIT_TYPE_TET, lowestId,
+                                        numPhys ? (*it)->physicals[0] : 0);
+      }
+    }
+  }
+  fprintf(fp, "ENDOFSECTION\n");
+
+  // Element Groups
+
+  for (hashMap<unsigned, std::vector<unsigned> >::_::const_iterator
+        it = elementGroups.begin(); it != elementGroups.end(); ++it) {
+    fprintf(fp, "       ELEMENT GROUP 2.0.0\n");
+    fprintf(fp, "GROUP: %10d ELEMENTS: %10lu MATERIAL: 0 NFLAGS: %10d\n", it->first, it->second.size(), 1);
+    fprintf(fp, "Material group %d\n", it->first);
+    fprintf(fp, "       0");
+
+    for (unsigned i = 0; i < it->second.size(); ++i) {
+      if (i % 10 == 0) {
+        fprintf(fp, "\n");
+      }
+      fprintf(fp, "%8d", it->second[i] - lowestId);
+    }
+    fprintf(fp, "\n");
+    fprintf(fp, "ENDOFSECTION\n");
+  }
+
+  // Boundary Conditions
+  for (IDTetFaceMap::iterator it = boundaryConditions.begin();
+        it != boundaryConditions.end(); ++it) {
+    fprintf(fp, "       BOUNDARY CONDITIONS 2.0.0\n");
+
+    std::string const regionName = getPhysicalName(2, it->first);
+    fprintf(fp, "%32s%8d%8lu%8d%8d\n", regionName.c_str(), 1, it->second.size(), 0, gambitBoundaryCode(regionName));
+    std::sort(it->second.begin(), it->second.end(), sortBCs);
+    std::vector<TetFacePair>::iterator tfp = it->second.begin();
+    for (std::vector<TetFacePair>::iterator tfp = it->second.begin(); tfp != it->second.end(); ++tfp) {
+      fprintf(fp, "%10d %5d %5d\n", tfp->first-lowestId, GAMBIT_TYPE_TET, tfp->second);
+    }
+
+    fprintf(fp, "ENDOFSECTION\n");
+  }
+
+  fclose(fp);
+  return 1;
+}

Geo/MElement.cpp

@@ -1338,6 +1338,19 @@ void MElement::writeMESH(FILE *fp, int elementTagType, int elementary,
   if(physical < 0) reverse();
 }
 
+void MElement::writeNEU(FILE *fp, unsigned gambitType, int idAdjust, int phys)
+{
+  if(phys < 0) reverse();
+
+  fprintf(fp, "%8d %2d %2d ", _num-idAdjust, gambitType, getNumVertices());
+  for(int i = 0; i < getNumVertices(); ++i) {
+    fprintf(fp, "%8d", getVertex(i)->getIndex());
+  }
+  fprintf(fp, "\n");
+
+  if(phys < 0) reverse();
+}
+
 void MElement::writeIR3(FILE *fp, int elementTagType, int num, int elementary,
                         int physical)
 {

Geo/MElement.h

@@ -385,6 +385,7 @@ class MElement
   virtual void writeTOCHNOG(FILE *fp, int num);
   virtual void writeMESH(FILE *fp, int elementTagType=1, int elementary=1,
                          int physical=0);
+  virtual void writeNEU(FILE *fp, unsigned gambitType, int adjust, int phys=0);
   virtual void writeIR3(FILE *fp, int elementTagType, int num, int elementary,
                         int physical);
   virtual void writeBDF(FILE *fp, int format=0, int elementTagType=1,

Geo/MVertex.cpp

@@ -270,6 +270,26 @@ void MVertex::writeMESH(FILE *fp, double scalingFactor)
           _ge ? _ge->tag() : 0);
 }
 
+void MVertex::writeNEU(FILE *fp, int dim, double scalingFactor)
+{
+  if(_index < 0) return; // negative index vertices are never saved
+
+  switch(dim) {
+  case 3:
+    fprintf(fp, "%10d%20.11e%20.11e%20.11e\n",
+            _index, x() * scalingFactor, y() * scalingFactor,
+            z() * scalingFactor);
+    break;
+  case 2:
+    fprintf(fp, "%10d%20.11e%20.11e\n",
+            _index, x() * scalingFactor, y() * scalingFactor);
+    break;
+  case 1:
+    fprintf(fp, "%10d%20.11e\n", _index, x() * scalingFactor);
+    break;
+  }
+}
+
 static void double_to_char8(double val, char *str)
 {
   if(val >= 1.e6)

Geo/MVertex.h

@@ -100,6 +100,7 @@ class MVertex{
                 bool bigEndian=false);
   void writeTOCHNOG(FILE *fp, int dim, double scalingFactor=1.0);
   void writeMESH(FILE *fp, double scalingFactor=1.0);
+  void writeNEU(FILE *fp, int dim, double scalingFactor=1.0);
   void writeBDF(FILE *fp, int format=0, double scalingFactor=1.0);
   void writeINP(FILE *fp, double scalingFactor=1.0);
   void writeDIFF(FILE *fp, bool binary, double scalingFactor=1.0);