everybody now use Get<T>

Author: glesur

CHANGELOG.md

@@ -7,6 +7,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## Upcoming
 ### Changed
 - slight optimisation of the cfl estimation for parabolic terms (makes a difference when several explicit parabolic terms are used simultaneously)
+- use input::Get<T> and input::GetOrSet<T> instead of the old input:GetInt, input:GetReal... the new functions have a better error handling, and also allows explicit default values.
+- ensure that error messages are sent to std::cerr using a dedicated stream
 
 ### Added
 - isotropic thermal diffusion (anisotropic diffusion in MHD will come later)

doc/source/programmingguide.rst

@@ -207,14 +207,16 @@ It provides accessors such as
   // Accessor to input parameters
   // the arguments are always: BlockName, EntryName, ParameterNumber (starting from 0)
 
-  // Read a string
-  std::string GetString(std::string, std::string, int);
+  // Read a parameter of type T from the input file and throw an error if it cannot be found
+  // T can be a std::string or a number (real, int, double, float, int64_t, ...)
+  template<typename T>
+  T Get(std::string blockName, std::string paramName, int num);
 
-  // Read a real number
-  real GetReal(std::string, std::string, int);
+  // Read a parameter of type T from the input file. Set it to default if it cannot be found.
+  // T can be a std::string or a number (real, int, double, float, int64_t, ...)
+  template<typename T>
+  T GetOrSet(std::string blockName, std::string paramName, int num, T default);
 
-  // Read an integer
-  int GetInt(std::string, std::string, int);
 
   // Check that a block/entry is present
   int CheckEntry(std::string, std::string);
@@ -236,11 +238,14 @@ instance of ``Input`` is allocated in ``myInput``:
 
 .. code-block:: c++
 
-  real firstParameter = myInput.GetReal("MyBlock","myentry",0)  // firstParameter=1.0
-  real secondParameter = myInput.GetReal("MyBlock","myentry",1)  // secondParameter=0.0
+  real firstParameter = myInput.Get<real>("MyBlock","myentry",0)  // firstParameter=1.0
+  real secondParameter = myInput.Get<real>("MyBlock","myentry",1)  // secondParameter=0.0
+  real thirdParameter = myInput.GetOrSet<real>("MyBlock","myentry",2, 0.0) // thirdParameter default to 0.0
 
-If a parameter is not found, *Idefix* will log an error and exit. One can use the ``CheckEntry``
-method to check if a parameter is set in the ini file before trying to access it.
+
+If a parameter is not found, ``Get<T>`` will log an error and exit. One can use the ``CheckEntry``
+method to check if a parameter is set in the ini file before trying to access it, or use ``GetOrSet<T>``
+with a default value, as in the example above.
 
 .. tip::
   Command line options are also parsed by the ``Input`` class. These options are stored in a

doc/source/reference/idefix.ini.rst

@@ -9,7 +9,7 @@ allows for comments, which should start with ``#``.
 
 .. tip::
     Note that you can add arbitray sections and entries in the input file freely. *Idefix* will automatically read and store them on startup. They are then accessible in the code using the
-    ``Input::GetReal(..)``, ``Input::GetInt(...)`` and ``Input::GetString(..)`` methods defined in the ``Input`` class (see :ref:`inputClass`)
+    ``Input::Get<T>(..)`` and ``Input::GetOrSet<T>`` methods defined in the ``Input`` class (see :ref:`inputClass`).
 
 ``Grid`` section
 --------------------
@@ -116,7 +116,7 @@ This section is used by the hydrodynamics class of *Idefix*. It defines the hydr
 |                |                         | | to be enrolled with   ``EnrollIsoSoundSpeed(IsoSoundSpeedFunc)``                          |
 |                |                         | | (see :ref:`functionEnrollment`). In this case, the second parameter is not used.          |
 +----------------+-------------------------+---------------------------------------------------------------------------------------------+
-| gamma          | float                   | Adiabatic index when ISOTHERMAL is not defined                                              |
+| gamma          | float                   | Adiabatic index when ISOTHERMAL is not defined. Default to 5/3 if not set.                  |
 +----------------+-------------------------+---------------------------------------------------------------------------------------------+
 | resistivity    | string, string, (float) | | Switches on Ohmic diffusion.                                                              |
 |                |                         | | The first parameter can be ``explicit`` or ``rkl``. When ``explicit``, diffusion is       |

doc/source/reference/setup.cpp.rst

@@ -111,7 +111,7 @@ constructor which reads a parameter from the .ini file and enroll the user-defin
   // Setup constructor
   Setup::Setup(Input &input, Grid &grid, DataBlock &data, Output &output) {
     // Read some parameter from the ini file
-    Mass = input.GetReal("Setup","mass",0);
+    Mass = input.Get<real>("Setup","mass",0);
 
     // Enroll the user-defined potential
     data.hydro.EnrollGravPotential(&Potential);

src/dataBlock/fargo.cpp

@@ -140,7 +140,7 @@ void Fargo::Init(Input &input, DataBlock *data) {
   }
 
   if(input.CheckBlock("Fargo")) {
-    std::string opType = input.GetString("Fargo","velocity",0);
+    std::string opType = input.Get<std::string>("Fargo","velocity",0);
     if(opType.compare("userdef")==0) {
       this->type=userdef;
     } else if(opType.compare("shearingbox")==0) {
@@ -152,13 +152,11 @@ void Fargo::Init(Input &input, DataBlock *data) {
       IDEFIX_ERROR("Unknown fargo velocity in the input file. "
       "Only userdef and shearingbox are allowed");
     }
-    if(input.CheckEntry("Fargo","maxShift")>=0) {
-      this->maxShift = input.GetInt("Fargo", "maxShift",0);
-    }
+    this->maxShift = input.GetOrSet<int>("Fargo", "maxShift",0, 10);
   } else {
     // DEPRECATED: initialisation from the [Hydro] block
     if(input.CheckEntry("Hydro","fargo")>=0) {
-      std::string opType = input.GetString("Hydro","fargo",0);
+      std::string opType = input.Get<std::string>("Hydro","fargo",0);
       if(opType.compare("userdef")==0) {
         this->type=userdef;
       } else if(opType.compare("shearingbox")==0) {

src/dataBlock/fargo.hpp

@@ -44,7 +44,7 @@ class Fargo {
   int beg[3];
   int end[3];
   int nghost[3];
-  int maxShift{10};                     //< maximum number of cells along which we plan to shift.
+  int maxShift;                         //< maximum number of cells along which we plan to shift.
   real dtMax{0};                        //< Maximum allowable dt for a given Fargo velocity
                                         //< when domain decomposition is enabled
   bool velocityHasBeenComputed{false};

src/gravity/gravity.cpp

@@ -19,15 +19,13 @@ void Gravity::Init(Input &input, DataBlock *datain) {
   if(nPotential >=0) {
     this->havePotential = true;
     for(int i = 0 ; i < nPotential ; i++) {
-      std::string potentialString = input.GetString("Gravity","potential",i);
+      std::string potentialString = input.Get<std::string>("Gravity","potential",i);
       if(potentialString.compare("userdef") == 0) {
         this->haveUserDefPotential = true;
         idfx::cout << "Gravity: Enabling user-defined gravitational potential" << std::endl;
       } else if (potentialString.compare("central") == 0) {
         this->haveCentralMassPotential = true;
-        if(input.CheckEntry("Gravity","Mcentral") >= 0) {
-          this->centralMass = input.GetReal("Gravity","Mcentral",0);
-        }
+        this->centralMass = input.GetOrSet<real>("Gravity","Mcentral",0, 1.0);
         idfx::cout << "Gravity: Enabling central mass gravitational potential with M="
                    << this->centralMass << std::endl;
       } else if (potentialString.compare("selfgravity") == 0) {
@@ -41,7 +39,7 @@ void Gravity::Init(Input &input, DataBlock *datain) {
 
   // Body Force
   if(input.CheckEntry("Gravity","bodyForce")>=0) {
-    std::string potentialString = input.GetString("Gravity","bodyForce",0);
+    std::string potentialString = input.Get<std::string>("Gravity","bodyForce",0);
     if(potentialString.compare("userdef") == 0) {
       this->haveBodyForce = true;
       idfx::cout << "Gravity:: Enabling user-defined body force" << std::endl;

src/gravity/gravity.hpp

@@ -53,7 +53,7 @@ class Gravity {
  private:
   bool haveInitialisedPotential{false};     ///< whether a potential has already been initialised
   bool haveInitialisedBodyForce{false};     ///< whether a body force has already been initialised
-  real centralMass{1.0};                    ///< central mass parameter when central mass potential
+  real centralMass;                    ///< central mass parameter when central mass potential
                                             ///< is enabled
   DataBlock *data;
 

src/grid.cpp

@@ -26,7 +26,7 @@ Grid::Grid(Input &input) {
     npoints[dir] = 1;
     nghost[dir] = 0;
     std::string label = std::string("X")+std::to_string(dir+1)+std::string("-grid");
-    int numPatch = input.GetInt("Grid",label,0);
+    int numPatch = input.Get<int>("Grid",label,0);
 
     if(dir<DIMENSIONS) {
       #if ORDER < 4
@@ -36,7 +36,7 @@ Grid::Grid(Input &input) {
       #endif
       npoints[dir] = 0;
       for(int patch = 0; patch < numPatch ; patch++) {
-        npoints[dir] += input.GetInt("Grid",label,2+3*patch );
+        npoints[dir] += input.Get<int>("Grid",label,2+3*patch );
       }
     }
   }
@@ -47,7 +47,7 @@ Grid::Grid(Input &input) {
     np_int[dir] = npoints[dir];
 
     std::string label = std::string("X")+std::to_string(dir+1)+std::string("-beg");
-    std::string boundary = input.GetString("Boundary",label,0);
+    std::string boundary = input.Get<std::string>("Boundary",label,0);
 
     if(boundary.compare("outflow") == 0) {
       lbound[dir] = outflow;
@@ -74,7 +74,7 @@ Grid::Grid(Input &input) {
     }
 
     label = std::string("X")+std::to_string(dir+1)+std::string("-end");
-    boundary = input.GetString("Boundary",label,0);
+    boundary = input.Get<std::string>("Boundary",label,0);
     if(boundary.compare("outflow") == 0) {
       rbound[dir] = outflow;
     } else if(boundary.compare("periodic") == 0) {
@@ -143,7 +143,7 @@ Grid::Grid(Input &input) {
       // Manual domain decomposition (with -dec option)
       int ntot=1;
       for(int dir=0 ; dir < DIMENSIONS; dir++) {
-        nproc[dir] = input.GetInt("CommandLine","dec",dir);
+        nproc[dir] = input.Get<int>("CommandLine","dec",dir);
         // Check that the dimension is effectively divisible by number of procs
         if(np_int[dir] % nproc[dir])
           IDEFIX_ERROR("Grid size must be a multiple of the domain decomposition");

src/gridHost.cpp

@@ -55,10 +55,10 @@ void GridHost::MakeGrid(Input &input) {
   idfx::cout << "GridHost::MakeGrid: " << std::endl;
   for(int dir = 0 ; dir < 3 ; dir++) {
     std::string label = std::string("X")+std::to_string(dir+1)+std::string("-grid");
-    int numPatch = input.GetInt("Grid",label,0);
+    int numPatch = input.Get<int>("Grid",label,0);
 
-    xstart[dir] = input.GetReal("Grid",label,1);
-    xend[dir] = input.GetReal("Grid",label,4+(numPatch-1)*3);
+    xstart[dir] = input.Get<real>("Grid",label,1);
+    xend[dir] = input.Get<real>("Grid",label,4+(numPatch-1)*3);
 
     this->xbeg[dir] = xstart[dir];
     this->xend[dir] = xend[dir];
@@ -68,10 +68,10 @@ void GridHost::MakeGrid(Input &input) {
       // Loop on all the patches
       int idxstart = nghost[dir];
       for(int patch = 0 ; patch < numPatch ; patch++) {
-        std::string patchType = input.GetString("Grid",label,3+patch*3);
-        real patchStart = input.GetReal("Grid",label,1+patch*3);
-        real patchEnd = input.GetReal("Grid",label,4+patch*3);
-        int patchSize = input.GetInt("Grid",label,2+patch*3);
+        std::string patchType = input.Get<std::string>("Grid",label,3+patch*3);
+        real patchStart = input.Get<real>("Grid",label,1+patch*3);
+        real patchEnd = input.Get<real>("Grid",label,4+patch*3);
+        int patchSize = input.Get<int>("Grid",label,2+patch*3);
 
         // If this is the first or last patch, also define ghost cells
         int ghostStart = 0;
@@ -119,14 +119,14 @@ void GridHost::MakeGrid(Input &input) {
                          "from a non-existent patch");
           }
           // Check that the reference patch is a uniform one
-          if(input.GetString("Grid",label,3+3*refPatch).compare("u")) {
+          if(input.Get<std::string>("Grid",label,3+3*refPatch).compare("u")) {
             IDEFIX_ERROR("You're attempting to construct a stretched patch "
                          "from a non-uniform grid");
           }
           // Ok, we have a well-behaved reference patch, compute dx from the reference patch
-          real refPatchStart = input.GetReal("Grid",label,1+refPatch*3);
-          real refPatchEnd = input.GetReal("Grid",label,4+refPatch*3);
-          int refPatchSize = input.GetInt("Grid",label,2+refPatch*3);
+          real refPatchStart = input.Get<real>("Grid",label,1+refPatch*3);
+          real refPatchEnd = input.Get<real>("Grid",label,4+refPatch*3);
+          int refPatchSize = input.Get<int>("Grid",label,2+refPatch*3);
           double delta = (refPatchEnd-refPatchStart)/refPatchSize;
           double logdelta = log((patchEnd-patchStart)/delta);