C ++ Mejores prácticas para tratar con muchas constantes, variables en códigos científicos

Estoy desarrollando un código para simular el flujo de fluidos con sustancias biológicas presentes en el flujo. Esto implica las ecuaciones estándar de Navier-Stokes acopladas a algunos modelos biológicos adicionales. Hay muchos parámetros / constantes.

He escrito funciones para manejar los cálculos principales, pero un problema que tengo es la gran cantidad de constantes / parámetros de los que dependen estos cálculos. Parece engorroso pasar 10-20 argumentos a una función.

Una alternativa es hacer que todas las constantes sean variables globales, pero sé que esto está mal visto en C ++.

¿Cuál es la forma estándar de manejar muchas entradas a una función? ¿Debo hacer una estructura y pasar eso en su lugar?

Gracias

Si tiene constantes que no cambiarán antes de las ejecuciones, declarelas en un archivo de encabezado:

//constants.hpp
#ifndef PROJECT_NAME_constants_hpp
#define PROJECT_NAME_constants_hpp
namespace constants {
  constexpr double G        = 6.67408e-11;
  constexpr double M_EARTH  = 5.972e24;
  constexpr double GM_EARTH = G*M_EARTH; 
}
#endif

//main.cpp
using namespace constants;
auto f_earth = GM_EARTH*m/r/r;  //Good
auto f_earth = G*M_EARTH*m/r/r; //Also good: compiler probably does math here too

La razón por la que desearía hacer esto es que permite que el compilador calcule valores constantes antes del tiempo de ejecución, lo cual es bueno si tiene muchos de ellos.

También puede usar una clase simple para pasar valores:

class Params {
 public:
  double a,b,c,d;
  Params(std::string config_file_name){
    //Load configuration here
  }
};

void Foo(const Params &params) {
  ...
}

int main(int argc, char **argv){
  Params params(argv[1]);
  Foo(params);
}

Otra alternativa que puede estar en línea con su línea de pensamiento es usar un espacio de nombres (o espacios de nombres anidados) para agrupar adecuadamente las constantes. Un ejemplo podría ser:

namespace constants {
   namespace earth {
      constexpr double G = 6.67408e-11;
      constexpr double Mass_Earth = 5.972e24;
      constexpr double GM = G*Mass_Earth;
   }// constant properties about Earth

   namespace fluid {
      constexpr double density = 0.999; // g/cm^3
      constexpr double dyn_viscosity = 1.6735; //mPa * s
   }// constants about fluid at 2C

   // ... 

} // end namespace for constants

Usando la técnica anterior, puede localizar constantes de referencia en algunos archivos y espacios de nombres deseados, haciéndolos más controlados que las variables globales mientras obtiene algunos de los beneficios similares. Cuando usa las constantes, es tan simple como hacer:

constexpr double G_times_2 = 2.0*constants::earth::G;

Si no le gustan las largas cadenas de espacios de nombres anidados, siempre puede acortar las cosas cuando sea necesario utilizando un alias de espacio de nombres:

namespace const_earth = constants::earth;
constexpr double G_times_2 = 2.0*const_earth::G;

Una forma en que lo hago es usar singleton.

Cuando inicia su programa, inicia su singleton y lo llena con los datos constantes (probablemente de un archivo de propiedades que tiene para la ejecución). Obtiene esto en cada clase que necesita los valores y simplemente lo usa.