Add more context to errors - mesh/ files

src/coreComponents/dataRepository/GroupContext.cpp

@@ -46,7 +46,8 @@ string GroupContext::toString() const
   for( auto info = parentsInfo.rbegin(); info != parentsInfo.rend(); ++info )
   {
     path << ( std::prev( info.base() ) == lastFileInfo ? // Is `info` pointing to the last file info?
-              GEOS_FMT( "/{}({},l.{})", info->m_targetName, info->m_filePath, info->m_line ) :
+              GEOS_FMT( "/{}({},l.{})",
+                        info->m_targetName, splitPath( info->m_filePath ).second, info->m_line ) :
               GEOS_FMT( "/{}", info->m_targetName ));
   }
   return path.str();

src/coreComponents/mainInterface/ProblemManager.cpp

@@ -434,17 +434,25 @@ void ProblemManager::parseXMLDocument( xmlWrapper::xmlDocument & xmlDocument )
     for( xmlWrapper::xmlNode regionNode : elementRegionsNode.children() )
     {
       string const regionName = regionNode.attribute( "name" ).value();
-      string const
-      regionMeshBodyName = ElementRegionBase::verifyMeshBodyName( meshBodies,
-                                                                  regionNode.attribute( "meshBody" ).value() );
+      try
+      {
+        string const
+        regionMeshBodyName = ElementRegionBase::verifyMeshBodyName( meshBodies,
+                                                                    regionNode.attribute( "meshBody" ).value() );
 
-      MeshBody & meshBody = domain.getMeshBody( regionMeshBodyName );
-      meshBody.forMeshLevels( [&]( MeshLevel & meshLevel )
+        MeshBody & meshBody = domain.getMeshBody( regionMeshBodyName );
+        meshBody.forMeshLevels( [&]( MeshLevel & meshLevel )
+        {
+          ElementRegionManager & elementManager = meshLevel.getElemManager();
+          Group * newRegion = elementManager.createChild( regionNode.name(), regionName );
+          newRegion->processInputFileRecursive( xmlDocument, regionNode );
+        } );
+      }
+      catch( InputError const & e )
       {
-        ElementRegionManager & elementManager = meshLevel.getElemManager();
-        Group * newRegion = elementManager.createChild( regionNode.name(), regionName );
-        newRegion->processInputFileRecursive( xmlDocument, regionNode );
-      } );
+        string const nodePosString = xmlDocument.getNodePosition( regionNode ).toString();
+        throw InputError( e, "Error while parsing region " + regionName + " (" + nodePosString + "):\n" );
+      }
     }
 
     // Parse particle regions

src/coreComponents/mesh/CellElementRegion.cpp

@@ -24,7 +24,7 @@ CellElementRegion::CellElementRegion( string const & name, Group * const parent
   ElementRegionBase( name, parent )
 {
   registerWrapper( viewKeyStruct::sourceCellBlockNamesString(), &m_cellBlockNames ).
-    setInputFlag( InputFlags::OPTIONAL );
+    setInputFlag( InputFlags::REQUIRED );
 
   registerWrapper( viewKeyStruct::coarseningRatioString(), &m_coarseningRatio ).
     setInputFlag( InputFlags::OPTIONAL );

src/coreComponents/mesh/CellElementSubRegion.cpp

@@ -390,13 +390,13 @@ void CellElementSubRegion::
     default:
     {
       GEOS_ERROR( GEOS_FMT( "Volume calculation not supported for element type {} in subregion {}",
-                            m_elementType, getName() ) );
+                            m_elementType, getDataContext() ) );
     }
   }
 
   GEOS_ERROR_IF( m_elementVolume[k] <= 0.0,
                  GEOS_FMT( "Negative volume for element {} type {} in subregion {}",
-                           k, m_elementType, getName() ) );
+                           k, m_elementType, getDataContext() ) );
 }
 
 void CellElementSubRegion::calculateElementGeometricQuantities( NodeManager const & nodeManager,

src/coreComponents/mesh/FaceManager.cpp

@@ -28,6 +28,7 @@
 #include "mesh/NodeManager.hpp"
 #include "mesh/utilities/MeshMapUtilities.hpp"
 #include "utilities/ComputationalGeometry.hpp"
+#include "CellElementRegion.hpp"
 
 namespace geos
 {
@@ -264,12 +265,15 @@ void FaceManager::sortAllFaceNodes( NodeManager const & nodeManager,
   ElementRegionManager::ElementViewAccessor< arrayView2d< real64 const > > elemCenter =
     elemManager.constructArrayViewAccessor< real64, 2 >( ElementSubRegionBase::viewKeyStruct::elementCenterString() );
 
-  forAll< parallelHostPolicy >( size(), [=, elemCenter = elemCenter.toNestedViewConst()]( localIndex const faceIndex )
+  forAll< parallelHostPolicy >( size(), [=, elemCenter = elemCenter.toNestedViewConst(), &elemManager]( localIndex const faceIndex )
   {
     // The face should be connected to at least one element.
     if( facesToElements( faceIndex, 0 ) < 0 && facesToElements( faceIndex, 1 ) < 0 )
     {
-      GEOS_ERROR( "Face " << faceIndex << " is not connected to an element." );
+      GEOS_ERROR( getDataContext() << ": Face " << faceIndex << " is not connected to any cell." <<
+                  "You might have forgotten one cell type in the " <<
+                  elemManager.getWrapperDataContext( CellElementRegion::viewKeyStruct::sourceCellBlockNamesString() ) <<
+                  ", or your mesh might be invalid" );
     }
 
     // Take the first defined face-to-(elt/region/sub region) to sorting direction.
@@ -281,10 +285,17 @@ void FaceManager::sortAllFaceNodes( NodeManager const & nodeManager,
 
     if( er < 0 || esr < 0 || ei < 0 )
     {
-      GEOS_ERROR( GEOS_FMT( "Face {} is connected to an invalid element ({}/{}/{}).", faceIndex, er, esr, ei ) );
+      GEOS_ERROR( GEOS_FMT( "{0}: Face {1} is connected to an invalid element ({2}/{3}/{4}).",
+                            getDataContext().toString(), faceIndex, er, esr, ei ) );
     }
 
-    sortFaceNodes( X, elemCenter[er][esr][ei], facesToNodes[faceIndex] );
+    try
+    {
+      sortFaceNodes( X, elemCenter[er][esr][ei], facesToNodes[faceIndex] );
+    } catch( std::runtime_error const & e )
+    {
+      throw std::runtime_error( getDataContext().toString() + ": " + e.what() );
+    }
   } );
 }
 
@@ -293,7 +304,7 @@ void FaceManager::sortFaceNodes( arrayView2d< real64 const, nodes::REFERENCE_POS
                                  Span< localIndex > const faceNodes )
 {
   localIndex const numFaceNodes = LvArray::integerConversion< localIndex >( faceNodes.size() );
-  GEOS_ERROR_IF_GT_MSG( numFaceNodes, MAX_FACE_NODES, "Node per face limit exceeded" );
+  GEOS_THROW_IF_GT_MSG( numFaceNodes, MAX_FACE_NODES, "The number of maximum nodes allocated per cell face has been reached.", std::runtime_error );
 
   localIndex const firstNodeIndex = faceNodes[0];
 

src/coreComponents/mesh/Perforation.cpp

@@ -45,7 +45,8 @@ Perforation::Perforation( string const & name, Group * const parent )
 void Perforation::postProcessInput()
 {
   GEOS_ERROR_IF( m_distanceFromHead <= 0,
-                 "Invalid distance well head to perforation " << getName() );
+                 getWrapperDataContext( viewKeyStruct::distanceFromHeadString() ) <<
+                 ": distance from well head to perforation cannot be negative." );
 }
 
 

src/coreComponents/mesh/PerforationData.cpp

@@ -128,9 +128,11 @@ void PerforationData::computeWellTransmissibility( MeshLevel const & mesh,
       WellElementRegion const & wellRegion = dynamicCast< WellElementRegion const & >( wellElemSubRegion.getParent().getParent() );
       GEOS_UNUSED_VAR( wellRegion ); // unused if geos_error_if is nulld
       GEOS_LOG_RANK_IF( isZero( m_wellTransmissibility[iperf] ),
-                        "\n \nWarning! A perforation is defined with a zero transmissibility in " << wellRegion.getWellGeneratorName() << "! \n" <<
+                        "\n \nWarning! Perforation " << wellRegion.getWellGeneratorName() <<
+                        " is defined with a zero transmissibility.\n" <<
                         "The simulation is going to proceed with this zero transmissibility,\n" <<
-                        "but a better strategy to shut down a perforation is to remove the <Perforation> block from the XML\n \n" );
+                        "but a better strategy to shut down a perforation is to remove the " <<
+                        "<Perforation> block from the XML\n \n" );
       continue;
     }
 
@@ -150,7 +152,8 @@ void PerforationData::computeWellTransmissibility( MeshLevel const & mesh,
     if( dx <= 0 || dy <= 0 || dz <= 0 )
     {
       WellElementRegion const & wellRegion = dynamicCast< WellElementRegion const & >( wellElemSubRegion.getParent().getParent() );
-      GEOS_THROW( "The reservoir element dimensions (dx, dy, and dz) should be positive in " << wellRegion.getWellGeneratorName(),
+      GEOS_THROW( "The reservoir element dimensions (dx, dy, and dz) should be positive in " <<
+                  wellRegion.getWellGeneratorName(),
                   InputError );
     }
 
@@ -212,7 +215,8 @@ void PerforationData::computeWellTransmissibility( MeshLevel const & mesh,
     if( m_wellTransmissibility[iperf] <= 0 )
     {
       WellElementRegion const & wellRegion = dynamicCast< WellElementRegion const & >( wellElemSubRegion.getParent().getParent() );
-      GEOS_THROW( "The well index is negative or equal to zero in " << wellRegion.getWellGeneratorName(),
+      GEOS_THROW( "The well index is negative or equal to zero in " <<
+                  wellRegion.getWellGeneratorName(),
                   InputError );
     }
   }

src/coreComponents/mesh/SurfaceElementRegion.hpp

@@ -201,7 +201,8 @@ class SurfaceElementRegion : public ElementRegionBase
       subRegionNames.push_back( sr.getName() );
     } );
     GEOS_ERROR_IF( subRegionNames.size() != 1,
-                   "Surface region \"" << getName() << "\" should have one unique sub region. \"" << subRegionNames.size() << "\" found." );
+                   "Surface region \"" << getDataContext() <<
+                   "\" should have one unique sub region (" << subRegionNames.size() << " found)." );
     return subRegionNames.front();
   }
 

src/coreComponents/mesh/WellElementRegion.cpp

@@ -20,6 +20,7 @@
 
 #include "common/MpiWrapper.hpp"
 #include "mesh/WellElementSubRegion.hpp"
+#include "mesh/generators/InternalWellGenerator.hpp"
 
 namespace geos
 {
@@ -64,7 +65,8 @@ void WellElementRegion::generateWell( MeshLevel & mesh,
 
   globalIndex const matchedPerforations = MpiWrapper::sum( perforationData->size() );
   GEOS_THROW_IF( matchedPerforations != numPerforationsGlobal,
-                 "Invalid mapping perforation-to-element in well " << lineBlock.getName() << "." <<
+                 "Invalid mapping perforation-to-element in "<<
+                 InternalWellGenerator::catalogName() << " " << getWellGeneratorName() << "." <<
                  " This happens when GEOSX cannot match a perforation with a reservoir element." <<
                  " There are two common reasons for this error:\n" <<
                  " 1- The most common reason for this error is that a perforation is on a section of " <<

src/coreComponents/mesh/WellElementSubRegion.cpp

@@ -368,7 +368,7 @@ void WellElementSubRegion::generate( MeshLevel & mesh,
   // if they belong to the same well element. This is a temporary solution.
   // TODO: split the well elements that contain multiple perforations, so that no element is shared
   GEOS_THROW_IF( sharedElems.size() > 0,
-                 "Well " << lineBlock.getName() << " contains shared well elements",
+                 "Well " << lineBlock.getDataContext() << " contains shared well elements",
                  InputError );
 
   // In Steps 1 and 2 we determine the local objects on this rank (elems and nodes)
@@ -519,7 +519,7 @@ void WellElementSubRegion::checkPartitioningValidity( LineBlockABC const & lineB
       globalIndex const prevGlobal  = prevElemIdsGlobal[iwelemGlobal][numBranches-1];
 
       GEOS_THROW_IF( prevGlobal <= iwelemGlobal || prevGlobal < 0,
-                     "The structure of well " << lineBlock.getName() << " is invalid. " <<
+                     "The structure of well " << lineBlock.getDataContext() << " is invalid. " <<
                      " The main reason for this error is that there may be no perforation" <<
                      " in the bottom well element of the well, which is required to have" <<
                      " a well-posed problem.",

src/coreComponents/mesh/generators/CellBlock.cpp

@@ -120,7 +120,7 @@ void CellBlock::setElementType( ElementType elementType )
     }
     default:
     {
-      GEOS_ERROR( "Invalid element type " << m_elementType << " for CellBlock " << getName() );
+      GEOS_ERROR( "Invalid element type " << m_elementType << " for CellBlock " << getDataContext() );
     }
   }
 

src/coreComponents/mesh/generators/CellBlockUtilities.cpp

@@ -23,11 +23,24 @@
 namespace geos
 {
 
+
+/**
+ * @brief error message to output when the number the number of node is insufficient for a given
+ * face of a primitive.
+ */
+constexpr std::string_view nodeCountError = "Not enough nodes for {} element (face index = {}).";
+/**
+ * @brief error message to output when the number the number of node is insufficient for a given
+ * face of a primitive.
+ */
+constexpr std::string_view faceIndexError = "Local face index out of range for {} element: face index = {}.";
+
+
 static localIndex getFaceNodesHex( localIndex const faceNum,
                                    arraySlice1d< localIndex const, cells::NODE_MAP_USD-1 > const & elemNodes,
                                    Span< localIndex > const faceNodes )
 {
-  GEOS_ERROR_IF_LT( faceNodes.size(), 4 );
+  GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 4, GEOS_FMT( nodeCountError, "Hexahedron", faceNum ) );
   switch( faceNum )
   {
     case 0:
@@ -80,7 +93,7 @@ static localIndex getFaceNodesHex( localIndex const faceNum,
     }
     default:
     {
-      GEOS_ERROR( "Invalid local face index for element of type Hexahedron: " << faceNum );
+      GEOS_ERROR( GEOS_FMT( faceIndexError, "Hexahedron", faceNum ) );
     }
   }
   return 4;
@@ -94,7 +107,7 @@ static localIndex getFaceNodesWedge( localIndex const faceNum,
   {
     case 0:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 4 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 4, GEOS_FMT( nodeCountError, "Wedge", faceNum ) );
       faceNodes[0] = elemNodes[0];
       faceNodes[1] = elemNodes[1];
       faceNodes[2] = elemNodes[5];
@@ -103,7 +116,7 @@ static localIndex getFaceNodesWedge( localIndex const faceNum,
     }
     case 1:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 4 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 4, GEOS_FMT( nodeCountError, "Wedge", faceNum ) );
       faceNodes[0] = elemNodes[0];
       faceNodes[1] = elemNodes[2];
       faceNodes[2] = elemNodes[3];
@@ -112,23 +125,23 @@ static localIndex getFaceNodesWedge( localIndex const faceNum,
     }
     case 2:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Wedge", faceNum ) );
       faceNodes[0] = elemNodes[0];
       faceNodes[1] = elemNodes[4];
       faceNodes[2] = elemNodes[2];
       return 3;
     }
     case 3:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Wedge", faceNum ) );
       faceNodes[0] = elemNodes[1];
       faceNodes[1] = elemNodes[3];
       faceNodes[2] = elemNodes[5];
       return 3;
     }
     case 4:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 4 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 4, GEOS_FMT( nodeCountError, "Wedge", faceNum ) );
       faceNodes[0] = elemNodes[2];
       faceNodes[1] = elemNodes[4];
       faceNodes[2] = elemNodes[5];
@@ -137,7 +150,7 @@ static localIndex getFaceNodesWedge( localIndex const faceNum,
     }
     default:
     {
-      GEOS_ERROR( "Invalid local face index for element of type Wedge: " << faceNum );
+      GEOS_ERROR( GEOS_FMT( faceIndexError, "Wedge", faceNum ) );
       return 0;
     }
   }
@@ -147,7 +160,7 @@ static localIndex getFaceNodesTet( localIndex const faceNum,
                                    arraySlice1d< localIndex const, cells::NODE_MAP_USD-1 > const & elemNodes,
                                    Span< localIndex > const faceNodes )
 {
-  GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+  GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Tetrahedron", faceNum ) );
   switch( faceNum )
   {
     case 0:
@@ -180,7 +193,7 @@ static localIndex getFaceNodesTet( localIndex const faceNum,
     }
     default:
     {
-      GEOS_ERROR( "Invalid local face index for element of type Tetrahedron: " << faceNum );
+      GEOS_ERROR( GEOS_FMT( faceIndexError, "Tetrahedron", faceNum ) );
     }
   }
   return 3;
@@ -194,15 +207,15 @@ static localIndex getFaceNodesPyramid( localIndex const faceNum,
   {
     case 0:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Pyramid", faceNum ) );
       faceNodes[0] = elemNodes[0];
       faceNodes[1] = elemNodes[1];
       faceNodes[2] = elemNodes[4];
       return 3;
     }
     case 1:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 4 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 4, GEOS_FMT( nodeCountError, "Pyramid", faceNum ) );
       faceNodes[0] = elemNodes[0];
       faceNodes[1] = elemNodes[2];
       faceNodes[2] = elemNodes[3];
@@ -211,31 +224,31 @@ static localIndex getFaceNodesPyramid( localIndex const faceNum,
     }
     case 2:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Pyramid", faceNum ) );
       faceNodes[0] = elemNodes[0];
       faceNodes[1] = elemNodes[4];
       faceNodes[2] = elemNodes[2];
       return 3;
     }
     case 3:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Pyramid", faceNum ) );
       faceNodes[0] = elemNodes[1];
       faceNodes[1] = elemNodes[3];
       faceNodes[2] = elemNodes[4];
       return 3;
     }
     case 4:
     {
-      GEOS_ERROR_IF_LT( faceNodes.size(), 3 );
+      GEOS_ERROR_IF_LT_MSG( faceNodes.size(), 3, GEOS_FMT( nodeCountError, "Pyramid", faceNum ) );
       faceNodes[0] = elemNodes[2];
       faceNodes[1] = elemNodes[4];
       faceNodes[2] = elemNodes[3];
       return 3;
     }
     default:
     {
-      GEOS_ERROR( "Invalid local face index for element of type Pyramid: " << faceNum );
+      GEOS_ERROR( GEOS_FMT( faceIndexError, "Pyramid", faceNum ) );
       return 0;
     }
   }
@@ -295,7 +308,7 @@ localIndex getFaceNodes( ElementType const elementType,
     }
     default:
     {
-      GEOS_ERROR( "Invalid element type: " << elementType );
+      GEOS_ERROR( "Invalid element type " << elementType << " at face index " << faceNumber );
     }
   }
   return 0;