[santiagomarquezd]

Hi all, I spent some hours overnight to understand how turbulence models are selected by the run time selection mechanism, the best commentary I've read was by marupio:

"4.3.5 When does this all happen?

The "virtual constructor" table is fully built and loaded into memory when the include list is fully read, and before the first line of code is executed. This is achieved using the static keyword. All static members of a class exist prior to any instance of that class."

OpenFOAM guide/runTimeSelection mechanism

For example en turbulenceModel.C

   75 
   76 autoPtr<turbulenceModel> turbulenceModel::New
   77 (
   78     const volVectorField& U,
   79     const surfaceScalarField& phi,
   80     transportModel& transport,
   81     const word& turbulenceModelName
   82 )
   83 {
   84     // get model name, but do not register the dictionary
   85     // otherwise it is registered in the database twice
   86     const word modelType
   87     (
   88         IOdictionary
   89         (
   90             IOobject
   91             (
   92                 "turbulenceProperties",
   93                 U.time().constant(),
   94                 U.db(),
   95                 IOobject::MUST_READ_IF_MODIFIED,
   96                 IOobject::NO_WRITE,
   97                 false
   98             )
   99         ).lookup("simulationType")
  100     );
  101 
  102     Info<< "Selecting turbulence model type " << modelType << endl;
  103 
  104     turbulenceModelConstructorTable::iterator cstrIter =
  105         turbulenceModelConstructorTablePtr_->find(modelType);
  106 
  107     if (cstrIter == turbulenceModelConstructorTablePtr_->end())
  108     {
  109         FatalErrorIn
  110         (
  111             "turbulenceModel::New(const volVectorField&, "
  112             "const surfaceScalarField&, transportModel&, const word&)"
  113         )   << "Unknown turbulenceModel type "
  114             << modelType << nl << nl
  115             << "Valid turbulenceModel types:" << endl
  116             << turbulenceModelConstructorTablePtr_->sortedToc()
  117             << exit(FatalError);
  118     }
  119 
  120     return autoPtr<turbulenceModel>
  121     (
  122         cstrIter()(U, phi, transport, turbulenceModelName)
  123     );

The general turbulence model indicated in constant/turbulenceProperties, for example "RASModel", is searched in the turbulenceModelConstructorTable (lines 104-105). Next if it is found the proper constructor is called, if not, an error is presented in stdout. I've walked through the code using gdb until these lines and checked the Hash Table. I wasn't be able to see the contents of the table entries, but they are three, I guess they're RASModel, LESModel and laminar. Clearly this table was created and filled before any turbulence model is instantiated. I found the macros which define the method to create the table and add the entries but I couldn't find the very moment when they're are called such as marupio wrote. They are static so they are available before the objects are instantiated, but they need to be invoked in some code line. This was also a question of Jaswinder,

http://www.cfd-online.com/Forums/ope...nderstand.html

I've read other material about this topic, such as:

Run-time type selection in OpenFOAM – the type name system

but the point of when these tables are created and how isn't completely clear for me yet.

All commentaries are appreciated!

Santiago.