Práticas recomendadas de C ++ para lidar com muitas constantes e variáveis ​​em códigos científicos

Estou desenvolvendo um código para simular o fluxo de fluidos com substâncias biológicas presentes no fluxo. Isso envolve as equações padrão de Navier-Stokes acopladas a alguns modelos biológicos adicionais. Existem muitos parâmetros / constantes.

Eu escrevi funções para lidar com os principais cálculos, mas um problema que estou tendo é o grande número de constantes / parâmetros dos quais esses cálculos dependem. Parece complicado passar de 10 a 20 argumentos para uma função.

Uma alternativa é tornar todas as constantes variáveis ​​globais, mas sei que isso é desaprovado em C ++.

Qual é a maneira padrão de lidar com muitas entradas para uma função? Devo fazer uma estrutura e passar isso em vez disso?

Obrigado

Se você tiver constantes que não serão alteradas antes das execuções, declare-as em um arquivo de cabeçalho:

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

A razão pela qual você deseja fazer isso é que ele permite que o compilador calcule valores constantes antes do tempo de execução, o que é bom se você tiver muitos deles.

Você também pode usar uma classe simples para passar 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);
}

Outra alternativa que pode estar alinhada com sua linha de pensamento é usar um espaço para nome (ou espaços para nome aninhados) para agrupar corretamente as constantes. Um exemplo pode 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 a técnica acima, você pode localizar constantes de referência em alguns arquivos e espaços de nomes desejados, tornando-os mais controlados que as variáveis ​​globais e obtendo alguns dos benefícios semelhantes. Quando você usa as constantes, é tão simples quanto fazer:

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

Se você não gosta de longas cadeias de namespaces aninhados, sempre pode encurtar as coisas quando necessário, usando um alias de namespace:

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

Uma maneira que eu faço é usar o singleton.

Ao iniciar seu programa, você inicia seu singleton e o preenche com os dados constantes (provavelmente de um arquivo de propriedades que você possui para a execução). Você obtém isso em todas as classes que precisa dos valores e apenas o usa.