feat: support non-scalar valued field specifications

.integrated_tests.yaml

@@ -1,6 +1,6 @@
 baselines:
   bucket: geosx
-  baseline: integratedTests/baseline_integratedTests-pr3959-16478-faf1698
+  baseline: integratedTests/baseline_integratedTests-pr4034-16517-aef69ab
 
 allow_fail:
   all: ''

BASELINE_NOTES.md

@@ -5,6 +5,10 @@ This file is designed to track changes to the integrated test baselines.
 Any developer who updates the baseline ID in the .integrated_tests.yaml file is expected to create an entry in this file with the pull request number, date, and their justification for rebaselining.
 These notes should be in reverse-chronological order, and use the following time format: (YYYY-MM-DD).
 
+PR #4034 (2026-05-07) <https://storage.googleapis.com/geosx/integratedTests/baseline_integratedTests-pr4034-16517-aef69ab.tar.gz>
+=====================
+Add scales, functionNames and regionNames attribute to FieldSpecification
+
 PR #3959 (2026-05-04) <https://storage.googleapis.com/geosx/integratedTests/baseline_integratedTests-pr3959-16478-faf1698.tar.gz>
 Add reference thermal conductivity
 

inputFiles/singlePhaseFlow/sourceFlux_2d.xml

@@ -145,31 +145,12 @@
       scale="5e6"/>
 
     <FieldSpecification
-      name="permx_wall"
-      component="0"
+      name="perm_wall"
       initialCondition="1"
       setNames="{ wall1, wall2 }"
       objectPath="ElementRegions/Region1/block1"
       fieldName="rockPerm_permeability"
-      scale="2.0e-22"/>
-
-    <FieldSpecification
-      name="permy_wall"
-      component="1"
-      initialCondition="1"
-      setNames="{ wall1, wall2 }"
-      objectPath="ElementRegions/Region1/block1"
-      fieldName="rockPerm_permeability"
-      scale="2.0e-22"/>
-
-    <FieldSpecification
-      name="permz_wall"
-      component="2"
-      initialCondition="1"
-      setNames="{ wall1, wall2 }"
-      objectPath="ElementRegions/Region1/block1"
-      fieldName="rockPerm_permeability"
-      scale="2.0e-22"/>
+      scale="{ 2.0e-22, 2.0e-22, 2.0e-22 }"/>
 
     <SourceFlux
       name="sourceTerm"

src/coreComponents/codingUtilities/RTTypes.cpp

@@ -94,6 +94,8 @@ string rtTypes::getTypeName( std::type_index const key )
  *       be a simple type or a lower-dimensional array. Sub-elements and
  *       axes are given as a comma-separated list enclosed in a curly brace.
  *       For example, a 2D string array would look like: {{"a", "b"}, {"c", "d"}}
+ * @note At the top level a 1d array also accepts a single unbracketed value
+ *       (eg. "1") which is interpreted as "{ 1 }".
  */
 string constructArrayRegex( string_view subPattern, integer dimension, bool topLevelCall = true )
 {
@@ -107,10 +109,11 @@ string constructArrayRegex( string_view subPattern, integer dimension, bool topL
   string const arrayRegex = dimension == 1 ?
                             "\\{\\s*((" + subPatternStr + ",\\s*)*" + subPatternStr + ")?\\}":
                             "\\{\\s*(" + subPatternStr + ",\\s*)*" + subPatternStr + "\\}";
-  // accept spaces around surrounding braces at the top-level
-  return topLevelCall ?
-         "\\s*" + arrayRegex + "\\s*" :
-         arrayRegex;
+  // Allow the top-level to have a single unbracketed value
+  string const topLevelRegex = dimension == 1 ?
+                               "\\s*(" + arrayRegex + "|" + subPatternStr + ")\\s*":
+                               "\\s*" + arrayRegex + "\\s*";
+  return topLevelCall ? topLevelRegex : arrayRegex;
 }
 /**
  * @brief function to build array regexes.
@@ -131,7 +134,12 @@ Regex constructArrayRegex( string_view subPattern, string_view description, inte
     {
       arrayDesc << dimension << " levels of ";
     }
-    arrayDesc << "braces and separated by commas). Each value must ";
+    arrayDesc << "braces and separated by commas";
+    if( dimension == 1 )
+    {
+      arrayDesc << ", or a single value with no braces";
+    }
+    arrayDesc << "). Each value must ";
 
     // finish by the original description
     GEOS_ERROR_IF( !stringutilities::startsWith( description, "Input value must " ),
@@ -185,7 +193,7 @@ rtTypes::RegexMapType rtTypes::createBasicTypesRegexMap()
   string_view const groupNameRefRegex = "\\s*[a-zA-Z0-9.\\-_/*\\[\\]]*\\s*";
   // to reference an array of groups, we need to support the / for paths, and * [ ] for fnmatch patterns.
   string_view const groupNameRefArrayDesc = "Input value must be a list of strings that can contain only upper/lower letters, digits, and the characters  . - _ / * [ ]";
-  string_view const groupNameRefArrayRegex = "\\s*\\{([a-zA-Z0-9.\\-_/*\\[\\], ]+)*\\}\\s*";
+  string_view const groupNameRefArrayRegex = "\\s*(\\{([a-zA-Z0-9.\\-_/*\\[\\], ]+)*\\}|[a-zA-Z0-9.\\-_/*\\[\\]]+)\\s*";
 
 
   // Build master list of regexes

src/coreComponents/dataRepository/unitTests/testXmlWrapper.cpp

@@ -15,8 +15,9 @@
 
 #include <gtest/gtest.h>
 
-#include "dataRepository/xmlWrapper.hpp"
+#include "codingUtilities/RTTypes.hpp"
 #include "common/format/EnumStrings.hpp"
+#include "dataRepository/xmlWrapper.hpp"
 
 using namespace geos;
 
@@ -443,6 +444,10 @@ TEST( testXmlWrapper, testGroupNamesArrayFormats )
       GroupNameTest( groupNameRefArrayRegex, "{path/to/resource*}" ),
       GroupNameTest( groupNameRefArrayRegex, "{[arrayElement]}" ),
       GroupNameTest( groupNameRefArrayRegex, "{name1,name2,name3}" ),
+      GroupNameTest( groupNameRefArrayRegex, "groupName" ),
+      GroupNameTest( groupNameRefArrayRegex, " groupName" ),
+      GroupNameTest( groupNameRefArrayRegex, "name.with-special_chars" ),
+      GroupNameTest( groupNameRefArrayRegex, "path/to/resource*" ),
     };
     for( GroupNameTest const & input : workingInputs )
     {
@@ -475,7 +480,6 @@ TEST( testXmlWrapper, testGroupNamesArrayFormats )
       GroupNameTest( groupNameRefArrayRegex, "{test\tname}" ),
       GroupNameTest( groupNameRefArrayRegex, "{test\nname}" ),
       GroupNameTest( groupNameRefArrayRegex, "{test\rname}" ),
-      GroupNameTest( groupNameRefArrayRegex, "groupName" ),
       GroupNameTest( groupNameRefArrayRegex, "{groupName" ),
       GroupNameTest( groupNameRefArrayRegex, "groupName}" ),
       GroupNameTest( groupNameRefArrayRegex, "{groupName}} " ),
@@ -491,6 +495,9 @@ TEST( testXmlWrapper, testGroupNamesArrayFormats )
       GroupNameTest( groupNameRefArrayRegex, "{valuewith,,commas }" ),
       GroupNameTest( groupNameRefArrayRegex, "{ value with , commas }" ),
       GroupNameTest( groupNameRefArrayRegex, "{{groupname}}" ),
+      GroupNameTest( groupNameRefArrayRegex, "group name" ),
+      GroupNameTest( groupNameRefArrayRegex, "group,name" ),
+      GroupNameTest( groupNameRefArrayRegex, "group;name" ),
     };
     for( GroupNameTest const & input : erroneousInputs )
     {
@@ -501,6 +508,53 @@ TEST( testXmlWrapper, testGroupNamesArrayFormats )
   }
 }
 
+TEST( testXmlWrapper, testUnbracketedSingleValueFor1dArrays )
+{
+  {
+    array1d< real64 > array;
+    EXPECT_NO_THROW( xmlWrapper::stringToInputVariable( array, "1.5",
+                                                        rtTypes::getTypeRegex< array1d< real64 > >() ) );
+    ASSERT_EQ( array.size(), 1 );
+    EXPECT_DOUBLE_EQ( array[0], 1.5 );
+  }
+  {
+    array1d< real64 > array;
+    EXPECT_NO_THROW( xmlWrapper::stringToInputVariable( array, "  -2.3e-4   ",
+                                                        rtTypes::getTypeRegex< array1d< real64 > >() ) );
+    ASSERT_EQ( array.size(), 1 );
+    EXPECT_DOUBLE_EQ( array[0], -2.3e-4 );
+  }
+  {
+    array1d< integer > array;
+    EXPECT_NO_THROW( xmlWrapper::stringToInputVariable( array, "42",
+                                                        rtTypes::getTypeRegex< array1d< integer > >() ) );
+    ASSERT_EQ( array.size(), 1 );
+    EXPECT_EQ( array[0], 42 );
+  }
+  {
+    array1d< real64 > array;
+    EXPECT_NO_THROW( xmlWrapper::stringToInputVariable( array, "{ 1, 2, 3 }",
+                                                        rtTypes::getTypeRegex< array1d< real64 > >() ) );
+    ASSERT_EQ( array.size(), 3 );
+    EXPECT_DOUBLE_EQ( array[0], 1.0 );
+    EXPECT_DOUBLE_EQ( array[1], 2.0 );
+    EXPECT_DOUBLE_EQ( array[2], 3.0 );
+  }
+  {
+    stdVector< std::string > array;
+    Regex const & arrayRegex = rtTypes::getTypeRegex< string >( rtTypes::CustomTypes::groupNameRefArray );
+    EXPECT_NO_THROW( xmlWrapper::stringToInputVariable( array, "myRegion",
+                                                        arrayRegex ) );
+    ASSERT_EQ( array.size(), 1 );
+    EXPECT_EQ( array[0], "myRegion" );
+  }
+  {
+    array2d< real64 > array;
+    EXPECT_ANY_THROW( xmlWrapper::stringToInputVariable( array, "1.5",
+                                                         rtTypes::getTypeRegex< array1d< real64 > >() ) );
+  }
+}
+
 
 int main( int argc, char * argv[] )
 {

src/coreComponents/dataRepository/xmlWrapper.cpp

@@ -136,7 +136,12 @@ void stringToInputVariable( stdVector< std::string > & array, string const & val
 {
   validateString( value, regex );
   array1d< std::string > tmp;
-  LvArray::input::stringToArray( tmp, string( stringutilities::trimSpaces( value ) ) );
+  string valueTrimmed{ stringutilities::trimSpaces( value ) };
+  if( !valueTrimmed.empty() && valueTrimmed.front() != '{' )
+  {
+    valueTrimmed = "{ " + valueTrimmed + " }";
+  }
+  LvArray::input::stringToArray( tmp, valueTrimmed );
 
   array.resize( tmp.size() );
   for( localIndex i = 0; i < tmp.size(); ++i )

src/coreComponents/dataRepository/xmlWrapper.hpp

@@ -391,7 +391,12 @@ stringToInputVariable( Array< T, NDIM, PERMUTATION > & array, string const & val
 {
   validateString( value, regex );
 
-  LvArray::input::stringToArray( array, string( stringutilities::trimSpaces( value ) ) );
+  string valueTrimmed{ stringutilities::trimSpaces( value ) };
+  if( NDIM == 1 && !valueTrimmed.empty() && valueTrimmed.front() != '{' )
+  {
+    valueTrimmed = "{ " + valueTrimmed + " }";
+  }
+  LvArray::input::stringToArray( array, valueTrimmed );
 }
 
 /**

src/coreComponents/fieldSpecification/AquiferBoundaryCondition.cpp

@@ -114,6 +114,8 @@ AquiferBoundaryCondition::AquiferBoundaryCondition( string const & name, Group *
 
 void AquiferBoundaryCondition::postInputInitialization()
 {
+  FieldSpecificationBase::postInputInitialization();
+
   GEOS_THROW_IF_LE_MSG( m_permeability, 0.0,
                         "The aquifer permeability cannot be equal to zero or negative",
                         InputError, getDataContext() );

src/coreComponents/fieldSpecification/EquilibriumInitialCondition.cpp

@@ -96,6 +96,7 @@ EquilibriumInitialCondition::EquilibriumInitialCondition( string const & name, G
 
 void EquilibriumInitialCondition::postInputInitialization()
 {
+  FieldSpecificationBase::postInputInitialization();
 
   FunctionManager const & functionManager = FunctionManager::getInstance();
 

src/coreComponents/fieldSpecification/FieldSpecificationBase.cpp

@@ -15,6 +15,8 @@
 
 #include "FieldSpecificationBase.hpp"
 
+#include "common/format/StringUtilities.hpp"
+#include "common/logger/Logger.hpp"
 #include "fieldSpecification/FieldSpecificationManager.hpp"
 
 namespace geos
@@ -39,6 +41,11 @@ FieldSpecificationBase::FieldSpecificationBase( string const & name, Group * par
     setInputFlag( InputFlags::OPTIONAL ).
     setDescription( "Path to the target field" );
 
+  registerWrapper( viewKeyStruct::regionNamesString(), &m_regionNames ).
+    setRTTypeName( rtTypes::CustomTypes::groupNameRefArray ).
+    setInputFlag( InputFlags::OPTIONAL ).
+    setDescription( "Names of the regions where the field specification is applied." );
+
   registerWrapper( viewKeyStruct::fieldNameString(), &m_fieldName ).
     setRTTypeName( rtTypes::CustomTypes::groupNameRef ).
     setInputFlag( InputFlags::OPTIONAL ).
@@ -57,9 +64,9 @@ FieldSpecificationBase::FieldSpecificationBase( string const & name, Group * par
     setDescription( "Direction to apply boundary condition to." );
 
   registerWrapper( viewKeyStruct::functionNameString(), &m_functionName ).
-    setRTTypeName( rtTypes::CustomTypes::groupNameRef ).
+    setRTTypeName( rtTypes::CustomTypes::groupNameRefArray ).
     setInputFlag( InputFlags::OPTIONAL ).
-    setDescription( "Name of function that specifies variation of the boundary condition." );
+    setDescription( "Name(s) of function(s) that specifies variation of the boundary condition." );
 
   registerWrapper( viewKeyStruct::bcApplicationTableNameString(), &m_bcApplicationFunctionName ).
     setRTTypeName( rtTypes::CustomTypes::groupNameRef ).
@@ -69,7 +76,8 @@ FieldSpecificationBase::FieldSpecificationBase( string const & name, Group * par
   registerWrapper( viewKeyStruct::scaleString(), &m_scale ).
     setApplyDefaultValue( 0.0 ).
     setInputFlag( InputFlags::OPTIONAL ).
-    setDescription( "Apply a scaling factor for the value of the boundary condition." );
+    setSizedFromParent( 0 ).
+    setDescription( "Apply scaling factor(s) for the value(s) of the boundary condition." );
 
   registerWrapper( viewKeyStruct::initialConditionString(), &m_initialCondition ).
     setApplyDefaultValue( 0 ).
@@ -110,22 +118,58 @@ FieldSpecificationBase::getCatalog()
 }
 
 
+void FieldSpecificationBase::postInputInitialization()
+{
+  GEOS_THROW_IF( !m_functionName.empty() &&
+                 m_functionName.size() != 1 &&
+                 m_functionName.size() != static_cast< string_array::size_type >( m_scale.size() ),
+                 GEOS_FMT ( "Size mismatch: '{}' has {} entries but '{}' has {}. "
+                            "'{}' either must be empty, have a single entry, or be sized exactly like '{}'",
+                            viewKeyStruct::functionNameString(), m_functionName.size(),
+                            viewKeyStruct::scaleString(), m_scale.size(),
+                            viewKeyStruct::functionNameString(), viewKeyStruct::scaleString() ),
+                 InputError,
+                 getDataContext() );
+
+  if( usesNonScalarValues() )
+  {
+    GEOS_THROW_IF( m_component != -1,
+                   GEOS_FMT ( "'{}' must not be set when '{}' has more than one value.",
+                              viewKeyStruct::componentString(),
+                              viewKeyStruct::scaleString() ),
+                   InputError,
+                   getDataContext() );
+  }
+
+  if( !m_regionNames.empty() )
+  {
+    GEOS_THROW_IF( !m_objectPath.empty(),
+                   GEOS_FMT ( "'{}' must not be set when '{}' is set.",
+                              viewKeyStruct::objectPathString(),
+                              viewKeyStruct::regionNamesString() ),
+                   InputError,
+                   getDataContext() );
+  }
+}
 
 void FieldSpecificationBase::setMeshObjectPath( Group const & meshBodies )
 {
+  string const path = m_regionNames.empty()
+                      ? m_objectPath
+                      : "ElementRegions/{" + stringutilities::join( m_regionNames, ' ' ) + "}";
   try
   {
-    m_meshObjectPaths = std::make_unique< MeshObjectPath >( m_objectPath, meshBodies );
+    m_meshObjectPaths = std::make_unique< MeshObjectPath >( path, meshBodies );
   }
   catch( std::exception const & e )
   {
     ErrorLogger::global().modifyCurrentExceptionMessage()
       .addToMsg( getWrapperDataContext( viewKeyStruct::objectPathString() ).toString() +
-                 " is a wrong objectPath: " + m_objectPath + "\n" )
+                 " is a wrong objectPath: " + path + "\n" )
       .addContextInfo( getWrapperDataContext( viewKeyStruct::objectPathString() ).getContextInfo()
                          .setPriority( 2 ) );
     throw InputError( e, getWrapperDataContext( viewKeyStruct::objectPathString() ).toString() +
-                      " is a wrong objectPath: " + m_objectPath + "\n" );
+                      " is a wrong objectPath: " + path + "\n" );
   }
 }