Bump submods/amrex from 85adcdd to 3c1f1c7 (#1781)

dependabot[bot] · marchdf · web-flow · commit e7dd8c0ce943 · 2025-11-03T10:11:09.000-07:00
* Bump submods/amrex from `85adcdd` to `3c1f1c7` Bumps [submods/amrex](https://github.com/AMReX-Codes/amrex) from `85adcdd` to `3c1f1c7`. - [Release notes](https://github.com/AMReX-Codes/amrex/releases) - [Commits](AMReX-Codes/amrex@85adcdd...3c1f1c7) --- updated-dependencies: - dependency-name: submods/amrex dependency-version: 3c1f1c78f60530e4ee17f766cf195c2c776f7b00 dependency-type: direct:production ... Signed-off-by: dependabot[bot] <support@github.com> * fix some * more * fixes --------- Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: Marc Henry de Frahan <marc.henrydefrahan@nrel.gov>
diff --git a/amr-wind/boundary_conditions/BCInterface.cpp b/amr-wind/boundary_conditions/BCInterface.cpp
@@ -42,7 +42,7 @@ void BCIface::read_bctype()
         amrex::ParmParse pp(bcid);
         std::string bcstr = "null";
         pp.query("type", bcstr);
-        pp.query(key.c_str(), bcstr);
+        pp.query(key, bcstr);
         bcstr = amrex::toLower(bcstr);
 
         // Protect against copy/paste errors where user intended to add a BC but
@@ -133,9 +133,9 @@ amrex::Array<const std::string, 3> BCIface::get_dirichlet_udfs()
         amrex::ParmParse pp(bcid);
 
         if (bct == BC::mass_inflow) {
-            if (pp.contains(inflow_key.c_str())) {
+            if (pp.contains(inflow_key)) {
                 std::string val;
-                pp.get(inflow_key.c_str(), val);
+                pp.get(inflow_key, val);
 
                 if (has_inflow_udf && (inflow_udf != val)) {
                     amrex::Abort(
@@ -148,9 +148,9 @@ amrex::Array<const std::string, 3> BCIface::get_dirichlet_udfs()
         }
 
         if (bct == BC::mass_inflow_outflow) {
-            if (pp.contains(inflow_outflow_key.c_str())) {
+            if (pp.contains(inflow_outflow_key)) {
                 std::string val;
-                pp.get(inflow_outflow_key.c_str(), val);
+                pp.get(inflow_outflow_key, val);
 
                 if (has_inflow_outflow_udf && (inflow_outflow_udf != val)) {
                     amrex::Abort(
@@ -164,9 +164,9 @@ amrex::Array<const std::string, 3> BCIface::get_dirichlet_udfs()
         }
 
         if (bct == BC::slip_wall) {
-            if (pp.contains(wall_key.c_str())) {
+            if (pp.contains(wall_key)) {
                 std::string val;
-                pp.get(wall_key.c_str(), val);
+                pp.get(wall_key, val);
 
                 if (has_wall_udf && (wall_udf != val)) {
                     amrex::Abort(
@@ -276,7 +276,7 @@ void BCVelocity::read_values()
         const auto bct = bctype[ori];
 
         amrex::ParmParse pp(bcid);
-        pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);
+        pp.queryarr(fname, bcval[ori], 0, ndim);
         if (bct == BC::no_slip_wall) {
             // Set normal component to zero
             bcval[ori][ori.coordDir()] = 0.0;
@@ -366,9 +366,9 @@ void BCScalar::read_values()
         if (((bct == BC::mass_inflow) && (const_dirichlet_inflow)) ||
             ((bct == BC::mass_inflow_outflow) &&
              (const_dirichlet_inflow_outflow))) {
-            pp.getarr(fname.c_str(), bcval[ori], 0, ndim);
+            pp.getarr(fname, bcval[ori], 0, ndim);
         } else {
-            pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);
+            pp.queryarr(fname, bcval[ori], 0, ndim);
         }
     }
 }
@@ -386,7 +386,7 @@ void BCPressure::read_values()
 
         amrex::ParmParse pp(bcid);
         if ((bct == BC::pressure_outflow)) {
-            pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);
+            pp.queryarr(fname, bcval[ori], 0, ndim);
         }
     }
 }
diff --git a/amr-wind/core/MultiParser.H b/amr-wind/core/MultiParser.H
@@ -30,8 +30,7 @@ public:
     //! Check if the keyword is present in either namespace
     bool contains(const std::string& name) const
     {
-        return m_pp.contains(name.c_str()) ||
-               m_pp_default.contains(name.c_str());
+        return m_pp.contains(name) || m_pp_default.contains(name);
     }
 
     /** Get a vector from the input file
@@ -115,39 +114,39 @@ public:
     template <typename T>
     void get(const std::string& name, T& value) const
     {
-        if (m_pp.contains(name.c_str())) {
-            m_pp.get(name.c_str(), value);
+        if (m_pp.contains(name)) {
+            m_pp.get(name, value);
         } else {
-            m_pp_default.get(name.c_str(), value);
+            m_pp_default.get(name, value);
         }
     }
 
     //! Get a vector of values for the given keyword entry from either namespace
     template <typename T>
     void getarr(const std::string& name, T& value) const
     {
-        if (m_pp.contains(name.c_str())) {
-            m_pp.getarr(name.c_str(), value);
+        if (m_pp.contains(name)) {
+            m_pp.getarr(name, value);
         } else {
-            m_pp_default.getarr(name.c_str(), value);
+            m_pp_default.getarr(name, value);
         }
     }
 
     //! Query the value for the keyword entry from either namespace
     template <typename T>
     void query(const std::string& name, T& value) const
     {
-        m_pp_default.query(name.c_str(), value);
-        m_pp.query(name.c_str(), value);
+        m_pp_default.query(name, value);
+        m_pp.query(name, value);
     }
 
     //! Query a vector of values for the given keyword entry from either
     //! namespace
     template <typename T>
     void queryarr(const std::string& name, T& value) const
     {
-        m_pp_default.queryarr(name.c_str(), value);
-        m_pp.queryarr(name.c_str(), value);
+        m_pp_default.queryarr(name, value);
+        m_pp.queryarr(name, value);
     }
 
 private:
diff --git a/amr-wind/equation_systems/vof/vof_bciface.H b/amr-wind/equation_systems/vof/vof_bciface.H
@@ -84,9 +84,9 @@ protected:
 
             amrex::ParmParse pp(bcid);
             if (bct == BC::mass_inflow || bct == BC::mass_inflow_outflow) {
-                pp.getarr(fname.c_str(), bcval[ori], 0, ndim);
+                pp.getarr(fname, bcval[ori], 0, ndim);
             } else {
-                pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);
+                pp.queryarr(fname, bcval[ori], 0, ndim);
             }
         }
     }
@@ -165,9 +165,9 @@ protected:
 
             amrex::ParmParse pp(bcid);
             if (bct == BC::mass_inflow || bct == BC::mass_inflow_outflow) {
-                pp.getarr(fname.c_str(), bcval[ori], 0, ndim);
+                pp.getarr(fname, bcval[ori], 0, ndim);
             } else {
-                pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);
+                pp.queryarr(fname, bcval[ori], 0, ndim);
             }
         }
     }
diff --git a/amr-wind/physics/FreeStream.cpp b/amr-wind/physics/FreeStream.cpp
@@ -13,7 +13,7 @@ std::unique_ptr<udf::UDF> process_field_func(Field& fld)
     std::string udf_name{"ConstValue"};
     amrex::ParmParse pp("FreeStream");
     const std::string key = fld.name() + "_type";
-    pp.query(key.c_str(), udf_name);
+    pp.query(key, udf_name);
 
     return udf::UDF::create(udf_name, fld);
 }
diff --git a/amr-wind/physics/udfs/UDF.cpp b/amr-wind/physics/udfs/UDF.cpp
@@ -17,7 +17,7 @@ ConstValue::ConstValue(Field& fld) : m_field(fld)
 {
     amrex::ParmParse pp_old("incflo");
     amrex::ParmParse pp(identifier() + "." + m_field.name());
-    pp_old.queryarr(m_field.name().c_str(), m_value);
+    pp_old.queryarr(m_field.name(), m_value);
     pp.queryarr("value", m_value);
 
     if (fld.num_comp() != m_value.size()) {
diff --git a/amr-wind/transport_models/ConstTransport.H b/amr-wind/transport_models/ConstTransport.H
@@ -101,7 +101,7 @@ public:
         amrex::ParmParse pp("transport");
         const std::string key = scalar_name + "_laminar_schmidt";
         amrex::Real lam_schmidt = 1.0;
-        pp.query(key.c_str(), lam_schmidt);
+        pp.query(key, lam_schmidt);
         return lam_schmidt;
     }
 
@@ -110,7 +110,7 @@ public:
         amrex::ParmParse pp("transport");
         const std::string key = scalar_name + "_turbulent_schmidt";
         amrex::Real turb_schmidt = 1.0;
-        pp.query(key.c_str(), turb_schmidt);
+        pp.query(key, turb_schmidt);
         return turb_schmidt;
     }
 
diff --git a/amr-wind/transport_models/TwoPhaseTransport.H b/amr-wind/transport_models/TwoPhaseTransport.H
@@ -114,7 +114,7 @@ public:
         amrex::ParmParse pp("transport");
         const std::string key = scalar_name + "_laminar_schmidt";
         amrex::Real lam_schmidt = 1.0;
-        pp.query(key.c_str(), lam_schmidt);
+        pp.query(key, lam_schmidt);
         return lam_schmidt;
     }
 
@@ -123,7 +123,7 @@ public:
         amrex::ParmParse pp("transport");
         const std::string key = scalar_name + "_turbulent_schmidt";
         amrex::Real turb_schmidt = 1.0;
-        pp.query(key.c_str(), turb_schmidt);
+        pp.query(key, turb_schmidt);
         return turb_schmidt;
     }
 
diff --git a/amr-wind/utilities/tagging/BoxRefiner.cpp b/amr-wind/utilities/tagging/BoxRefiner.cpp
@@ -11,7 +11,7 @@ namespace {
 inline vs::Vector parse_vector(amrex::ParmParse& pp, const std::string& key)
 {
     amrex::Vector<amrex::Real> tmp;
-    pp.getarr(key.data(), tmp);
+    pp.getarr(key, tmp);
     AMREX_ALWAYS_ASSERT(tmp.size() == 3U);
 
     return vs::Vector{tmp[0], tmp[1], tmp[2]};
diff --git a/submods/amrex b/submods/amrex
@@ -1 +1 @@
-Subproject commit 85adcdd0abd17790a436cc3ac12839b4b092d5af
+Subproject commit 3c1f1c78f60530e4ee17f766cf195c2c776f7b00
diff --git a/unit_tests/aw_test_utils/pp_utils.H b/unit_tests/aw_test_utils/pp_utils.H
@@ -10,7 +10,7 @@ namespace amr_wind_tests::pp_utils {
 template <typename T>
 void set_default(amrex::ParmParse& pp, const std::string& key, const T& val)
 {
-    if (!pp.contains(key.data())) {
+    if (!pp.contains(key)) {
         pp.add(key.data(), val);
     }
 }
@@ -19,7 +19,7 @@ template <typename T>
 void set_default(
     amrex::ParmParse& pp, const std::string& key, const amrex::Vector<T>& val)
 {
-    if (!pp.contains(key.data())) {
+    if (!pp.contains(key)) {
         pp.addarr(key.data(), val);
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -30,8 +30,7 @@ public:`
`30`	`30`	`//! Check if the keyword is present in either namespace`
`31`	`31`	`bool contains(const std::string& name) const`
`32`	`32`	`{`
`33`		`- return m_pp.contains(name.c_str()) \|\|`
`34`		`- m_pp_default.contains(name.c_str());`
	`33`	`+ return m_pp.contains(name) \|\| m_pp_default.contains(name);`
`35`	`34`	`}`
`36`	`35`
`37`	`36`	`/** Get a vector from the input file`
`@@ -115,39 +114,39 @@ public:`
`115`	`114`	`template <typename T>`
`116`	`115`	`void get(const std::string& name, T& value) const`
`117`	`116`	`{`
`118`		`- if (m_pp.contains(name.c_str())) {`
`119`		`- m_pp.get(name.c_str(), value);`
	`117`	`+ if (m_pp.contains(name)) {`
	`118`	`+ m_pp.get(name, value);`
`120`	`119`	`} else {`
`121`		`- m_pp_default.get(name.c_str(), value);`
	`120`	`+ m_pp_default.get(name, value);`
`122`	`121`	`}`
`123`	`122`	`}`
`124`	`123`
`125`	`124`	`//! Get a vector of values for the given keyword entry from either namespace`
`126`	`125`	`template <typename T>`
`127`	`126`	`void getarr(const std::string& name, T& value) const`
`128`	`127`	`{`
`129`		`- if (m_pp.contains(name.c_str())) {`
`130`		`- m_pp.getarr(name.c_str(), value);`
	`128`	`+ if (m_pp.contains(name)) {`
	`129`	`+ m_pp.getarr(name, value);`
`131`	`130`	`} else {`
`132`		`- m_pp_default.getarr(name.c_str(), value);`
	`131`	`+ m_pp_default.getarr(name, value);`
`133`	`132`	`}`
`134`	`133`	`}`
`135`	`134`
`136`	`135`	`//! Query the value for the keyword entry from either namespace`
`137`	`136`	`template <typename T>`
`138`	`137`	`void query(const std::string& name, T& value) const`
`139`	`138`	`{`
`140`		`- m_pp_default.query(name.c_str(), value);`
`141`		`- m_pp.query(name.c_str(), value);`
	`139`	`+ m_pp_default.query(name, value);`
	`140`	`+ m_pp.query(name, value);`
`142`	`141`	`}`
`143`	`142`
`144`	`143`	`//! Query a vector of values for the given keyword entry from either`
`145`	`144`	`//! namespace`
`146`	`145`	`template <typename T>`
`147`	`146`	`void queryarr(const std::string& name, T& value) const`
`148`	`147`	`{`
`149`		`- m_pp_default.queryarr(name.c_str(), value);`
`150`		`- m_pp.queryarr(name.c_str(), value);`
	`148`	`+ m_pp_default.queryarr(name, value);`
	`149`	`+ m_pp.queryarr(name, value);`
`151`	`150`	`}`
`152`	`151`
`153`	`152`	`private:`
Original file line number	Diff line number	Diff line change
`@@ -84,9 +84,9 @@ protected:`
`84`	`84`
`85`	`85`	`amrex::ParmParse pp(bcid);`
`86`	`86`	`if (bct == BC::mass_inflow \|\| bct == BC::mass_inflow_outflow) {`
`87`		`- pp.getarr(fname.c_str(), bcval[ori], 0, ndim);`
	`87`	`+ pp.getarr(fname, bcval[ori], 0, ndim);`
`88`	`88`	`} else {`
`89`		`- pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);`
	`89`	`+ pp.queryarr(fname, bcval[ori], 0, ndim);`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`	`}`
`@@ -165,9 +165,9 @@ protected:`
`165`	`165`
`166`	`166`	`amrex::ParmParse pp(bcid);`
`167`	`167`	`if (bct == BC::mass_inflow \|\| bct == BC::mass_inflow_outflow) {`
`168`		`- pp.getarr(fname.c_str(), bcval[ori], 0, ndim);`
	`168`	`+ pp.getarr(fname, bcval[ori], 0, ndim);`
`169`	`169`	`} else {`
`170`		`- pp.queryarr(fname.c_str(), bcval[ori], 0, ndim);`
	`170`	`+ pp.queryarr(fname, bcval[ori], 0, ndim);`
`171`	`171`	`}`
`172`	`172`	`}`
`173`	`173`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ std::unique_ptr<udf::UDF> process_field_func(Field& fld)`
`13`	`13`	`std::string udf_name{"ConstValue"};`
`14`	`14`	`amrex::ParmParse pp("FreeStream");`
`15`	`15`	`const std::string key = fld.name() + "_type";`
`16`		`- pp.query(key.c_str(), udf_name);`
	`16`	`+ pp.query(key, udf_name);`
`17`	`17`
`18`	`18`	`return udf::UDF::create(udf_name, fld);`
`19`	`19`	`}`
Original file line number	Diff line number	Diff line change
`@@ -17,7 +17,7 @@ ConstValue::ConstValue(Field& fld) : m_field(fld)`
`17`	`17`	`{`
`18`	`18`	`amrex::ParmParse pp_old("incflo");`
`19`	`19`	`amrex::ParmParse pp(identifier() + "." + m_field.name());`
`20`		`- pp_old.queryarr(m_field.name().c_str(), m_value);`
	`20`	`+ pp_old.queryarr(m_field.name(), m_value);`
`21`	`21`	`pp.queryarr("value", m_value);`
`22`	`22`
`23`	`23`	`if (fld.num_comp() != m_value.size()) {`
Original file line number	Diff line number	Diff line change
`@@ -11,7 +11,7 @@ namespace {`
`11`	`11`	`inline vs::Vector parse_vector(amrex::ParmParse& pp, const std::string& key)`
`12`	`12`	`{`
`13`	`13`	`amrex::Vector<amrex::Real> tmp;`
`14`		`- pp.getarr(key.data(), tmp);`
	`14`	`+ pp.getarr(key, tmp);`
`15`	`15`	`AMREX_ALWAYS_ASSERT(tmp.size() == 3U);`
`16`	`16`
`17`	`17`	`return vs::Vector{tmp[0], tmp[1], tmp[2]};`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ namespace amr_wind_tests::pp_utils {`
`10`	`10`	`template <typename T>`
`11`	`11`	`void set_default(amrex::ParmParse& pp, const std::string& key, const T& val)`
`12`	`12`	`{`
`13`		`- if (!pp.contains(key.data())) {`
	`13`	`+ if (!pp.contains(key)) {`
`14`	`14`	`pp.add(key.data(), val);`
`15`	`15`	`}`
`16`	`16`	`}`
`@@ -19,7 +19,7 @@ template <typename T>`
`19`	`19`	`void set_default(`
`20`	`20`	`amrex::ParmParse& pp, const std::string& key, const amrex::Vector<T>& val)`
`21`	`21`	`{`
`22`		`- if (!pp.contains(key.data())) {`
	`22`	`+ if (!pp.contains(key)) {`
`23`	`23`	`pp.addarr(key.data(), val);`
`24`	`24`	`}`
`25`	`25`	`}`