C ++ Best practice per gestire molte costanti, variabili nei codici scientifici

Sto sviluppando un codice per simulare il flusso di fluidi con sostanze biologiche presenti nel flusso. Ciò comporta le equazioni standard di Navier-Stokes accoppiate ad alcuni modelli biologici aggiuntivi. Ci sono molti parametri / costanti.

Ho scritto funzioni per gestire i calcoli principali, ma un problema che sto riscontrando è il gran numero di costanti / parametri da cui dipendono questi calcoli. Sembra ingombrante passare 10-20 argomenti a una funzione.

Un'alternativa è rendere globali tutte le costanti variabili, ma so che questo è disapprovato in C ++.

Qual è il modo standard di gestire molti input per una funzione? Dovrei fare una strutt e passarla invece?

Grazie

Se hai delle costanti che non cambieranno prima dell'esecuzione, dichiarale in un file di intestazione:

//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

Il motivo per cui vorresti farlo è che consente al compilatore di calcolare i valori costanti in anticipo prima del runtime, il che è positivo se ne hai molti.

Puoi anche usare una semplice classe per passare valori in giro:

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

Un'altra alternativa che può essere in linea con il tuo treno di pensieri è quella di utilizzare uno spazio dei nomi (o spazi dei nomi nidificati) per raggruppare correttamente le costanti. Un esempio potrebbe essere:

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 tecnica sopra, è possibile localizzare le costanti di riferimento in alcuni file e spazi dei nomi desiderati, rendendoli più controllati delle variabili globali e ottenendo alcuni dei vantaggi simili. Quando usi le costanti, è semplice come fare:

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

Se non ti piacciono le catene lunghe di spazi dei nomi nidificati, puoi sempre abbreviare le cose quando necessario utilizzando un alias dello spazio dei nomi:

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

Un modo che faccio è usare singleton.

Quando avvii il tuo programma, avvia il tuo singleton e lo riempi con i dati costanti (probabilmente da un file delle proprietà che hai per l'esecuzione). Ottieni questo in ogni classe in cui hai bisogno dei valori e semplicemente lo usi.