Merge branch 'feature/boost-std-cleanup' of gitlab.nektar.info:dmoxey/nektar...

Merge branch 'feature/boost-std-cleanup' of gitlab.nektar.info:dmoxey/nektar into feature/boost-std-cleanup

CHANGELOG.md

@@ -6,8 +6,9 @@ v5.0.0
 **Library**
 - Added in sum factorisation version for pyramid expansions and orthogonal
   expansion in pyramids (!750)
-- Significant overhaul of CMake infrastructure (!770)
+- Significant overhaul of CMake infrastructure (!770, !804)
 - Fix ThridpartyCCM options (!802)
+- Fix Windows CRLF tokens in GEO reader and improve comment handling (!805)
 
 **NekMesh**:
 - Add feature to read basic 2D geo files as CAD (!731)

library/CMakeLists.txt

@@ -23,6 +23,6 @@ IF (NEKTAR_UTILITY_NEKMESH)
     SUBDIRS(NekMeshUtils)
 ENDIF()
 
-IF (NEKTAR_UTILITY_FIELDCONVERT OR NEKTAR_BUILD_SOLVERS)
+IF (NEKTAR_UTILITY_FIELDCONVERT OR NEKTAR_UTILITY_NEKMESH OR NEKTAR_BUILD_SOLVERS)
     SUBDIRS(FieldUtils)
 ENDIF()

library/Collections/CollectionOptimisation.cpp

@@ -90,7 +90,7 @@ CollectionOptimisation::CollectionOptimisation(
             // For 1<=N<=3 use SumFac otherwise NoCollection. Note that
             // default is not currently overwritten by given default
             // type
-            defaultsPhysDeriv [ElmtOrder(it2->second, -1)] = eNoCollection;
+            defaultsPhysDeriv [ElmtOrder(it2.second, -1)] = eNoCollection;
             for (int i = 1; i < 3; ++i)
             {
                 defaultsPhysDeriv[ElmtOrder(it2.second, i)] = eSumFac;

library/NekMeshUtils/CADSystem/OCE/CADSystemOCE.cpp

@@ -57,9 +57,9 @@ bool CADSystemOCE::LoadCAD()
 {
     if (m_naca.size() == 0)
     {
-        //not a naca profile behave normally
-        //could be a geo
-        string ext  = boost::filesystem::extension(m_name);
+        // not a naca profile behave normally
+        // could be a geo
+        string ext = boost::filesystem::extension(m_name);
 
         if (boost::iequals(ext, ".geo"))
         {
@@ -422,15 +422,11 @@ TopoDS_Shape CADSystemOCE::BuildGeo(string geo)
     {
         getline(f, fline);
 
-        if (fline.size() == 0)
-        {
-            continue;
-        }
+        boost::erase_all(fline, "\r");
 
-        if (boost::starts_with(fline, "//"))
-        {
-            continue;
-        }
+        vector<string> tmp1, tmp2;
+        boost::split(tmp1, fline, boost::is_any_of("//"));
+        fline = tmp1[0];
 
         if (!boost::contains(fline, ";"))
         {
@@ -441,7 +437,6 @@ TopoDS_Shape CADSystemOCE::BuildGeo(string geo)
         fline = flinetmp + fline;
         flinetmp.clear();
 
-        vector<string> tmp1, tmp2;
         boost::split(tmp1, fline, boost::is_any_of("="));
 
         boost::split(tmp2, tmp1[0], boost::is_any_of("("));
@@ -472,9 +467,9 @@ TopoDS_Shape CADSystemOCE::BuildGeo(string geo)
         }
         else if (boost::iequals(type, "Line Loop"))
         {
-            //line loops sometimes have negative entries for gmsh
-            //orientaton purposes
-            //we dont care so remove it
+            // line loops sometimes have negative entries for gmsh
+            // orientaton purposes
+            // we dont care so remove it
             boost::erase_all(var, "-");
             loops[id] = var;
         }
@@ -561,6 +556,5 @@ TopoDS_Shape CADSystemOCE::BuildGeo(string geo)
 
     return sf.Face();
 }
-
 }
 }

utilities/NekMesh/InputModules/InputNek.cpp

@@ -777,9 +777,10 @@ void InputNek::Process()
         // m_mesh->condition. This is currently a linear search and should
         // probably be made faster!
         bool found = false;
-        for (auto &it : m_mesh->m_condition)
+        auto it = m_mesh->m_condition.begin();
+        for (; it != m_mesh->m_condition.end(); ++it)
         {
-            if (c == it.second)
+            if (c == it->second)
             {
                 found = true;
                 break;

utilities/NekMesh/OutputModules/OutputNekpp.cpp

@@ -707,7 +707,7 @@ void OutputNekpp::WriteXmlCurves(TiXmlElement *pRoot)
                     f->SetAttribute(
                         "TYPE",
                         LibUtilities::kPointsTypeStr[face->m_curveType]);
-                    TiXmlText *t0 = new TiXmlText(fave->GetXmlCurveString());
+                    TiXmlText *t0 = new TiXmlText(face->GetXmlCurveString());
                     f->LinkEndChild(t0);
                     curved->LinkEndChild(f);
                 }

utilities/NekMesh/ProcessModules/ProcessExtractSurf.cpp

@@ -241,7 +241,7 @@ void ProcessExtractSurf::Process()
             continue;
         }
 
-        m_mesh->m_composite.insert(*it);
+        m_mesh->m_composite.insert(it);
 
         // Figure out the maximum ID so if we need to create new
         // composites we can give them a unique ID.
@@ -276,7 +276,7 @@ void ProcessExtractSurf::Process()
             // composite, otherwise we create a new composite and store
             // it in newComps.
             string tag = el[i]->GetTag();
-            it2 = newComps.find(tag);
+            auto it2 = newComps.find(tag);
             if (it2 == newComps.end())
             {
                 CompositeSharedPtr newComp(new Composite());
@@ -298,14 +298,16 @@ void ProcessExtractSurf::Process()
         }
 
         // Insert new composites.
-        for (i = 0, it2 = newComps.begin(); it2 != newComps.end(); ++it2, ++i)
+        i = 0;
+        for (auto &it2 : newComps)
         {
             if (m_mesh->m_verbose && newComps.size() > 1)
             {
-                cout << (i > 0 ? ", " : " ") << it2->second->m_id << "("
-                     << it2->second->m_tag << ")";
+                cout << (i > 0 ? ", " : " ") << it2.second->m_id << "("
+                     << it2.second->m_tag << ")";
             }
-            m_mesh->m_composite[it2->second->m_id] = it2->second;
+            m_mesh->m_composite[it2.second->m_id] = it2.second;
+            ++i;
         }
 
         if (m_mesh->m_verbose && newComps.size() > 1)

utilities/NekMesh/ProcessModules/ProcessOptiExtract.cpp

@@ -313,7 +313,7 @@ void ProcessOptiExtract::Process()
 
         for (auto &node : inp_mesh->m_vertexSet)
         {
-            nmap[node->m_id] = *nit;
+            nmap[node->m_id] = node;
         }
         // for all the nodes in the main mesh see if they are in nmap, if so
         // update the node

utilities/NekMesh/ProcessModules/ProcessPerAlign.cpp

@@ -209,6 +209,7 @@ void ProcessPerAlign::Process()
         }
         centroid /= (NekDouble)c1->m_items[i]->GetVertexCount();
 
+        bool found = false;
         for (auto &it : centroidMap)
         {
             if (elmtDone.count(it.first) > 0)
@@ -302,11 +303,12 @@ void ProcessPerAlign::Process()
                     perFaces[id2] =
                         make_pair(c1->m_items[i]->GetFaceLink(), perVertsInv);
                 }
+                found = true;
                 break;
             }
         }
 
-        if (it == centroidMap.end())
+        if (!found)
         {
             cerr << "WARNING: Could not find matching edge for surface "
                  << "element " << c1->m_items[i]->GetId() << ". "

utilities/NekMesh/ProcessModules/ProcessSpherigon.cpp

@@ -224,7 +224,9 @@ void ProcessSpherigon::SuperBlend(vector<double> &r,
 void ProcessSpherigon::FindNormalFromPlyFile(MeshSharedPtr &plymesh,
                                              map<int,NodeSharedPtr> &surfverts)
 {
-    int cnt  = 0, j = 0, prog = 0, n_neighbs = 5, cntmin;
+    int      cnt = 0;
+    int      j = 0;
+    int      prog=0,cntmin;
 
     typedef bg::model::point<NekDouble, 3, bg::cs::cartesian> Point;
     typedef pair<Point, unsigned int> PointI;
@@ -234,10 +236,10 @@ void ProcessSpherigon::FindNormalFromPlyFile(MeshSharedPtr &plymesh,
     map<int,int>  TreeidtoPlyid;
 
     //Fill vertex array into tree format
+    vector<PointI> dataPts;
     for (auto &it : plymesh->m_vertexSet)
     {
-        dataPts.push_back(
-            make_pair(Point(it->m_x, it->m_y, it->m_z), j));
+        dataPts.push_back(make_pair(Point(it->m_x, it->m_y, it->m_z), j));
         TreeidtoPlyid[j++] = it->m_id;
     }
 
@@ -250,8 +252,8 @@ void ProcessSpherigon::FindNormalFromPlyFile(MeshSharedPtr &plymesh,
     {
         if(m_mesh->m_verbose)
         {
-            prog = LibUtilities::PrintProgressbar(
-                cnt, surfverts.size(), "Nearest ply verts", prog);
+            prog = LibUtilities::PrintProgressbar(cnt,surfverts.size(),
+                                                  "Nearest ply verts",prog);
         }
 
         Point queryPt(vIt.second->m_x, vIt.second->m_y, vIt.second->m_z);
@@ -264,20 +266,22 @@ void ProcessSpherigon::FindNormalFromPlyFile(MeshSharedPtr &plymesh,
         ASSERTL1(cntmin < plymesh->m_vertexNormals.size(),
                  "cntmin is out of range");
 
-        m_mesh->m_vertexNormals[vIt.first] = plymesh->m_vertexNormals[cntmin];
+        m_mesh->m_vertexNormals[vIt.first] =
+            plymesh->m_vertexNormals[cntmin];
         ++cnt;
     }
 }
 
 /**
- * @brief Generate a set of approximate vertex normals to a surface represented
- * by line segments in 2D and a hybrid triangular/quadrilateral mesh in 3D.
+ * @brief Generate a set of approximate vertex normals to a surface
+ * represented by line segments in 2D and a hybrid
+ * triangular/quadrilateral mesh in 3D.
  *
- * This routine approximates the true vertex normals to a surface by averaging
- * the normals of all edges/faces which connect to the vertex. It is better to
- * use the exact surface normals which can be set in Mesh::vertexNormals, but
- * where they are not supplied this routine calculates an approximation for the
- * spherigon implementation.
+ * This routine approximates the true vertex normals to a surface by
+ * averaging the normals of all edges/faces which connect to the
+ * vertex. It is better to use the exact surface normals which can be
+ * set in Mesh::vertexNormals, but where they are not supplied this
+ * routine calculates an approximation for the spherigon implementation.
  *
  * @param el  Vector of elements denoting the surface mesh.
  */
@@ -341,8 +345,9 @@ void ProcessSpherigon::GenerateNormals(std::vector<ElementSharedPtr> &el,
     }
 
     // Normalize resulting vectors.
-    for (auto &n : mesh->m_vertexNormals)
+    for (auto &nIt : mesh->m_vertexNormals)
     {
+        Node &n = nIt.second;
         n /= sqrt(n.abs2());
     }
 
@@ -375,6 +380,7 @@ void ProcessSpherigon::Process()
     {
         // Full 2D or 3D case - iterate over stored edges/faces and
         // create segments/triangles representing those edges/faces.
+        set<pair<int, int> >::iterator it;
         vector<int> t;
         t.push_back(0);
 
@@ -443,11 +449,13 @@ void ProcessSpherigon::Process()
 
         if (m_mesh->m_expDim == 3)
         {
-            for (auto &it : m_mesh->m_spherigonSurfs)
+            for (it = m_mesh->m_spherigonSurfs.begin();
+                 it != m_mesh->m_spherigonSurfs.end();
+                 ++it)
             {
                 FaceSharedPtr f =
-                    m_mesh->m_element[m_mesh->m_expDim][it.first]->GetFace(
-                        it.second);
+                    m_mesh->m_element[m_mesh->m_expDim][it->first]->GetFace(
+                        it->second);
                 vector<NodeSharedPtr> nodes = f->m_vertexList;
                 LibUtilities::ShapeType eType =
                     (LibUtilities::ShapeType)(nodes.size());
@@ -472,11 +480,13 @@ void ProcessSpherigon::Process()
         }
         else
         {
-            for (auto &it : m_mesh->m_spherigonSurfs)
+            for (it = m_mesh->m_spherigonSurfs.begin();
+                 it != m_mesh->m_spherigonSurfs.end();
+                 ++it)
             {
                 EdgeSharedPtr edge =
-                    m_mesh->m_element[m_mesh->m_expDim][it.first]->GetEdge(
-                        it.second);
+                    m_mesh->m_element[m_mesh->m_expDim][it->first]->GetEdge(
+                        it->second);
                 vector<NodeSharedPtr> nodes;
                 LibUtilities::ShapeType eType = LibUtilities::eSegment;
                 ElmtConfig conf(eType, 1, false, false);
@@ -493,8 +503,8 @@ void ProcessSpherigon::Process()
                 elmt->SetVertex(1, nodes[1]);
                 elmt->SetEdge(
                     0,
-                    m_mesh->m_element[m_mesh->m_expDim][it.first]->GetEdge(
-                        it.second));
+                    m_mesh->m_element[m_mesh->m_expDim][it->first]->GetEdge(
+                        it->second));
                 el.push_back(elmt);
             }
         }
@@ -545,6 +555,8 @@ void ProcessSpherigon::Process()
         // finally find nearest vertex and set normal to mesh surface file
         // normal.  probably should have a hex tree search ?
         Node minx(0, 0.0, 0.0, 0.0), tmp, tmpsav;
+        NodeSet::iterator it;
+        map<int, NodeSharedPtr>::iterator vIt;
         map<int, NodeSharedPtr> surfverts;
 
         // make a map of normal vertices to visit based on elements el
@@ -600,6 +612,7 @@ void ProcessSpherigon::Process()
             cout << endl;
         }
 
+        map<int, NodeSharedPtr>::iterator vIt;
         map<int, NodeSharedPtr> surfverts;
 
         // make a map of normal vertices to visit based on elements el
@@ -614,7 +627,7 @@ void ProcessSpherigon::Process()
             }
         }
 
-        for (auto &vIt : surfverts)
+        for (vIt = surfverts.begin(); vIt != surfverts.end(); ++vIt)
         {
             bool AddNoise = false;
 
@@ -625,8 +638,8 @@ void ProcessSpherigon::Process()
                 {
                     case 1:
                     {
-                        if ((vIt.second->m_x > values[2 * i + 1]) &&
-                            (vIt.second->m_x < values[2 * i + 2]))
+                        if (((vIt->second)->m_x > values[2 * i + 1]) &&
+                            ((vIt->second)->m_x < values[2 * i + 2]))
                         {
                             AddNoise = true;
                         }
@@ -634,10 +647,10 @@ void ProcessSpherigon::Process()
                     break;
                     case 2:
                     {
-                        if ((vIt.second->m_x > values[2 * i + 1]) &&
-                            (vIt.second->m_x < values[2 * i + 2]) &&
-                            (vIt.second->m_y > values[2 * i + 3]) &&
-                            (vIt.second->m_y < values[2 * i + 4]))
+                        if (((vIt->second)->m_x > values[2 * i + 1]) &&
+                            ((vIt->second)->m_x < values[2 * i + 2]) &&
+                            ((vIt->second)->m_y > values[2 * i + 3]) &&
+                            ((vIt->second)->m_y < values[2 * i + 4]))
                         {
                             AddNoise = true;
                         }
@@ -645,12 +658,12 @@ void ProcessSpherigon::Process()
                     break;
                     case 3:
                     {
-                        if ((vIt.second->m_x > values[2 * i + 1]) &&
-                            (vIt.second->m_x < values[2 * i + 2]) &&
-                            (vIt.second->m_y > values[2 * i + 3]) &&
-                            (vIt.second->m_y < values[2 * i + 4]) &&
-                            (vIt.second->m_z > values[2 * i + 5]) &&
-                            (vIt.second->m_z < values[2 * i + 6]))
+                        if (((vIt->second)->m_x > values[2 * i + 1]) &&
+                            ((vIt->second)->m_x < values[2 * i + 2]) &&
+                            ((vIt->second)->m_y > values[2 * i + 3]) &&
+                            ((vIt->second)->m_y < values[2 * i + 4]) &&
+                            ((vIt->second)->m_z > values[2 * i + 5]) &&
+                            ((vIt->second)->m_z < values[2 * i + 6]))
 
                         {
                             AddNoise = true;
@@ -665,12 +678,12 @@ void ProcessSpherigon::Process()
                     Node rvec(0, rand(), rand(), rand());
                     rvec *= values[0] / sqrt(rvec.abs2());
 
-                    Node normal = m_mesh->m_vertexNormals[vIt.first];
+                    Node normal = m_mesh->m_vertexNormals[vIt->first];
 
                     normal += rvec;
                     normal /= sqrt(normal.abs2());
 
-                    m_mesh->m_vertexNormals[vIt.first] = normal;
+                    m_mesh->m_vertexNormals[vIt->first] = normal;
                 }
             }
         }

utilities/NekMesh/ProcessModules/ProcessVarOpti/NodeOpti.h

@@ -60,7 +60,7 @@ public:
     NodeOpti(NodeSharedPtr n, std::vector<ElUtilSharedPtr> e,
              ResidualSharedPtr r,
              std::map<LibUtilities::ShapeType, DerivUtilSharedPtr> d,
-             optiType o)
+             optiType o, int dim)
         : m_node(n), m_res(r), m_derivUtils(d), m_opti(o)
     {
         // filter element types within d vector
@@ -79,12 +79,12 @@ public:
             const int nElmt  = typeIt.second.size();
 
             storageCount = std::max(storageCount,
-                                    3 * m_derivUtils[typeIt.first]->ptsStd *
+                                    dim * m_derivUtils[typeIt.first]->ptsStd *
                                     typeIt.second.size());
 
             m_derivs.insert(std::make_pair(
                                 typeIt.first,
-                                DerivArray(boost::extents[3][nElmt][3][pts])));
+                                DerivArray(boost::extents[dim][nElmt][dim][pts])));
         }
 
         m_tmpStore.resize(storageCount);
@@ -148,7 +148,7 @@ public:
                  ResidualSharedPtr r,
                  std::map<LibUtilities::ShapeType, DerivUtilSharedPtr> d,
                  optiType o)
-        : NodeOpti(n, e, r, d, o)
+        : NodeOpti(n, e, r, d, o, 3)
     {
     }
 
@@ -174,7 +174,7 @@ public:
                  ResidualSharedPtr r,
                  std::map<LibUtilities::ShapeType, DerivUtilSharedPtr> d,
                  optiType o)
-        : NodeOpti(n, e, r, d, o)
+        : NodeOpti(n, e, r, d, o, 2)
     {
     }
 

utilities/NekMesh/ProcessModules/ProcessVarOpti/NodeOptiCAD.h

@@ -52,7 +52,7 @@ public:
                  ResidualSharedPtr r,
                  std::map<LibUtilities::ShapeType, DerivUtilSharedPtr> d,
                  optiType o, CADCurveSharedPtr c)
-        : NodeOpti(n, e, r, d, o), curve(c)
+        : NodeOpti(n, e, r, d, o, 3), curve(c)
     {
     }
 
@@ -81,7 +81,7 @@ public:
                  ResidualSharedPtr r,
                  std::map<LibUtilities::ShapeType, DerivUtilSharedPtr> d,
                  optiType o, CADSurfSharedPtr s)
-        : NodeOpti(n, e, r, d, o), surf(s)
+        : NodeOpti(n, e, r, d, o, 3), surf(s)
     {
     }
 

utilities/NekMesh/ProcessModules/ProcessVarOpti/PreProcessing.cpp

@@ -350,7 +350,7 @@ vector<vector<NodeSharedPtr> > ProcessVarOpti::GetColouredNodes(
     // check if volume nodes are in boundary or ignored nodes, otherwise add to VOLUME remain nodes
     for (int i = 0; i < m_mesh->m_element[m_mesh->m_expDim].size(); i++)
     {
-        vector<NodeSharedPtr> &ns =
+        vector<NodeSharedPtr> ns =
             m_mesh->m_element[m_mesh->m_expDim][i]->GetVolumeNodes();
         for (int j = 0; j < ns.size(); j++)
         {