Cantera  3.1.0a1
TransportFactory.cpp
Go to the documentation of this file.
1 //! @file TransportFactory.cpp Implementation file for class TransportFactory.
2 
3 // This file is part of Cantera. See License.txt in the top-level directory or
4 // at https://cantera.org/license.txt for license and copyright information.
5 
6 // known transport models
16 #include "cantera/base/utilities.h"
17 
18 namespace Cantera
19 {
20 TransportFactory* TransportFactory::s_factory = 0;
21 
22 // declaration of static storage for the mutex
24 
25 //////////////////// class TransportFactory methods //////////////
26 
28 {
29  reg("none", []() { return new Transport(); });
30  addDeprecatedAlias("none", "Transport");
31  addDeprecatedAlias("none", "None");
32  addDeprecatedAlias("none", "");
33  reg("unity-Lewis-number", []() { return new UnityLewisTransport(); });
34  addDeprecatedAlias("unity-Lewis-number", "UnityLewis");
35  reg("mixture-averaged", []() { return new MixTransport(); });
36  addDeprecatedAlias("mixture-averaged", "Mix");
37  reg("mixture-averaged-CK", []() { return new MixTransport(); });
38  addDeprecatedAlias("mixture-averaged-CK", "CK_Mix");
39  reg("multicomponent", []() { return new MultiTransport(); });
40  addDeprecatedAlias("multicomponent", "Multi");
41  reg("multicomponent-CK", []() { return new MultiTransport(); });
42  addDeprecatedAlias("multicomponent-CK", "CK_Multi");
43  reg("ionized-gas", []() { return new IonGasTransport(); });
44  addDeprecatedAlias("ionized-gas", "Ion");
45  reg("water", []() { return new WaterTransport(); });
46  addDeprecatedAlias("water", "Water");
47  reg("high-pressure", []() { return new HighPressureGasTransport(); });
48  addDeprecatedAlias("high-pressure", "HighP");
49  m_CK_mode["CK_Mix"] = m_CK_mode["mixture-averaged-CK"] = true;
50  m_CK_mode["CK_Multi"] = m_CK_mode["multicomponent-CK"] = true;
51 }
52 
54  std::unique_lock<std::mutex> transportLock(transport_mutex);
55  if (!s_factory) {
57  }
58  return s_factory;
59 }
60 
62 {
63  std::unique_lock<std::mutex> transportLock(transport_mutex);
64  delete s_factory;
65  s_factory = 0;
66 }
67 
68 Transport* TransportFactory::newTransport(const string& transportModel,
69  ThermoPhase* phase, int log_level)
70 {
71  if (transportModel != "DustyGas" && canonicalize(transportModel) == "none") {
72  return create(transportModel);
73  }
74  if (!phase) {
75  throw CanteraError("TransportFactory::newTransport",
76  "Valid phase definition required for initialization of "
77  "new '{}' object", transportModel);
78  }
79 
80  vector<double> state;
81  Transport* tr = 0;
82  phase->saveState(state);
83 
84  if (transportModel == "DustyGas") {
85  tr = new DustyGasTransport;
86  Transport* gastr = new MultiTransport;
87  gastr->init(phase, 0, log_level);
89  dtr->initialize(phase, gastr);
90  } else {
91  tr = create(transportModel);
92  int mode = m_CK_mode[transportModel] ? CK_Mode : 0;
93  tr->init(phase, mode, log_level);
94  }
95  phase->restoreState(state);
96  return tr;
97 }
98 
100 {
101  string transportModel = "none";
102  AnyMap& input = phase->input();
103  if (input.hasKey("transport")) {
104  transportModel = input["transport"].asString();
105  }
106  return newTransport(transportModel, phase,log_level);
107 }
108 
109 shared_ptr<Transport> newTransport(shared_ptr<ThermoPhase> thermo, const string& model)
110 {
111  Transport* tr;
112  if (model == "default") {
113  tr = TransportFactory::factory()->newTransport(thermo.get(), 0);
114  } else {
115  tr = TransportFactory::factory()->newTransport(model, thermo.get(), 0);
116  }
117  return shared_ptr<Transport>(tr);
118 }
119 
120 }
Headers for the DustyGasTransport object, which models transport properties in porous media using the...
Interface for class HighPressureGasTransport.
Headers for the MixTransport object, which models transport properties in ideal gas solutions using a...
Interface for class MultiTransport.
Header file defining class TransportFactory (see TransportFactory)
Headers for the UnityLewisTransport object, which models transport properties in ideal gas solutions ...
Header file defining class WaterTransport.
A map of string keys to values whose type can vary at runtime.
Definition: AnyMap.h:427
bool hasKey(const string &key) const
Returns true if the map contains an item named key.
Definition: AnyMap.cpp:1423
Base class for exceptions thrown by Cantera classes.
Definition: ctexceptions.h:66
Class DustyGasTransport implements the Dusty Gas model for transport in porous media.
void initialize(ThermoPhase *phase, Transport *gastr)
Initialization routine called by TransportFactory.
Transport * create(const string &name, Args... args)
Create an object using the object construction function corresponding to "name" and the provided cons...
Definition: FactoryBase.h:75
void reg(const string &name, function< Transport *(Args...)> f)
Register a new object construction function.
Definition: FactoryBase.h:80
string canonicalize(const string &name)
Get the canonical name registered for a type.
Definition: FactoryBase.h:94
void addDeprecatedAlias(const string &original, const string &alias)
Add a deprecated alias for an existing registered type.
Definition: FactoryBase.h:116
Class MultiTransport implements transport properties for high pressure gas mixtures.
Class IonGasTransport implements Stockmayer-(n,6,4) model for transport of ions.
Class MixTransport implements mixture-averaged transport properties for ideal gas mixtures.
Definition: MixTransport.h:55
Class MultiTransport implements multicomponent transport properties for ideal gas mixtures.
void restoreState(const vector< double > &state)
Restore a state saved on a previous call to saveState.
Definition: Phase.cpp:260
void saveState(vector< double > &state) const
Save the current internal state of the phase.
Definition: Phase.cpp:236
Base class for a phase with thermodynamic properties.
Definition: ThermoPhase.h:390
const AnyMap & input() const
Access input data associated with the phase description.
Factory class for creating new instances of classes derived from Transport.
static TransportFactory * s_factory
Static instance of the factor -> This is the only instance of this object allowed.
void deleteFactory() override
Deletes the statically allocated factory instance.
static TransportFactory * factory()
Return a pointer to a TransportFactory instance.
static std::mutex transport_mutex
Static instance of the mutex used to ensure the proper reading of the transport database.
map< string, bool > m_CK_mode
Models included in this map are initialized in CK compatibility mode.
TransportFactory()
The constructor is private; use static method factory() to get a pointer to a factory instance.
Transport * newTransport(const string &model, ThermoPhase *thermo, int log_level=0)
Build a new transport manager using a transport manager that may not be the same as in the phase desc...
Base class for transport property managers.
Definition: Transport.h:72
virtual void init(ThermoPhase *thermo, int mode=0, int log_level=0)
Initialize a transport manager.
Definition: Transport.h:407
Class UnityLewisTransport implements the unity Lewis number approximation for the mixture-averaged sp...
Transport Parameters for pure water.
shared_ptr< Transport > newTransport(shared_ptr< ThermoPhase > thermo, const string &model)
Create a new Transport instance.
Namespace for the Cantera kernel.
Definition: AnyMap.cpp:564
Contains declarations for string manipulation functions within Cantera.
Various templated functions that carry out common vector and polynomial operations (see Templated Arr...