Meilleures pratiques C ++ pour gérer de nombreuses constantes, variables dans les codes scientifiques

Je développe un code pour simuler l'écoulement des fluides avec des substances biologiques présentes dans l'écoulement. Cela implique les équations de Navier-Stokes standard couplées à certains modèles biologiques supplémentaires. Il existe de nombreux paramètres / constantes.

J'ai écrit des fonctions pour gérer les principaux calculs, mais un problème que j'ai est le grand nombre de constantes / paramètres dont dépendent ces calculs. Il semble lourd de transmettre 10 à 20 arguments à une fonction.

Une alternative est de rendre toutes les constantes variables globales, mais je sais que cela est mal vu en C ++.

Quelle est la manière standard de gérer de nombreuses entrées d'une fonction? Dois-je faire une structure et la passer à la place?

Je vous remercie

Si vous avez des constantes qui ne changeront pas avant les exécutions, déclarez-les dans un fichier d'en-tête:

//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 raison pour laquelle vous voudriez faire cela est qu'elle permet au compilateur de calculer les valeurs constantes avant l'exécution, ce qui est bien si vous en avez beaucoup.

Vous pouvez également utiliser une classe simple pour transmettre des valeurs:

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);
}

Une autre alternative qui peut être en ligne avec votre réflexion est d'utiliser un espace de noms (ou des espaces de noms imbriqués) pour regrouper correctement les constantes. Un exemple pourrait être:

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

En utilisant la technique ci-dessus, vous pouvez localiser les constantes de référence dans certains fichiers et espaces de noms souhaités, ce qui les rend plus contrôlés que les variables globales tout en bénéficiant de certains avantages similaires. Lorsque vous utilisez les constantes, c'est aussi simple que de faire:

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

Si vous n'aimez pas les longues chaînes d'espaces de noms imbriqués, vous pouvez toujours raccourcir les choses si nécessaire en utilisant un alias d'espace de noms:

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

Une façon que je fais est d'utiliser singleton.

Lorsque vous démarrez votre programme, vous lancez votre singleton et le remplissez avec les données constantes (probablement à partir d'un fichier de propriétés que vous avez pour l'exécution). Vous obtenez cela dans chaque classe dont vous avez besoin des valeurs et utilisez-le simplement.