Vrftsjtryk

I am developing a code to simulate fluid flow with biological substances present in the flow. This involves the standard Navier-Stokes equations coupled to some additional biological models. There are many parameters/constants.

I have written functions to handle the major computations, but a problem I am having is the large number of constants/parameters that these computations depend on. It seems cumbersome to pass 10-20 arguments to a function.

One alternative is to make all the constants global variables, but I know this is frowned upon in C++.

What is the standard way of handling many inputs to a function? Should I make a struct and pass that instead?

Thank you

If you have constants that will not change before runs, declare them in a header file:

//constants.hpp

#ifndef _constants_hpp_

#define _constants_hpp_

  constexpr double G        = 6.67408e-11;

  constexpr double M_EARTH  = 5.972e24;

  constexpr double GM_EARTH = G*M_EARTH; 

#endif



//main.cpp

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

The reason why you would want to do this is that it allows the compiler to calculate constant values ahead before run-time, which is good if you have a lot of them.

You can also use a simple class to pass values around:

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

}

Another alternative that may be in line with your train of thought is to use a namespace (or nested namespaces) to properly group constants. An example might be:

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 density = 0.999; // g/cm^3

      constexpr dyn_viscosity = 1.6735; //mPa * s

   }// constants about fluid at 2C



   // ... 



} // end namespace for constants

Using the above technique, you can localize reference constants to some desired files and namespaces, making them more controlled than global variables while getting some of the similar benefits. When you use the constants, it is as simple as doing:

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

If you dislike long chains of nested namespaces, you can always shorten things when necessary by using a namespace alias:

namespace const_earth = constants::earth;

constexpr double G_times_2 = 2.0*const_earth::G;

One way that I do is to use singleton.

When you start your program you initiate your singleton and fill it with the constant data (probably from a properties file that you have for the run). You get this in every class that you need the values and just use it.