Cantera 2.6.0

TransportFactory.h
Go to the documentation of this file.
1/**
2 * @file TransportFactory.h
3 * Header file defining class TransportFactory
4 * (see \link Cantera::TransportFactory TransportFactory\endlink)
5 */
6
7// This file is part of Cantera. See License.txt in the top-level directory or
8// at https://cantera.org/license.txt for license and copyright information.
9
10#ifndef CT_TRANSPORTFACTORY_H
11#define CT_TRANSPORTFACTORY_H
12
13// Cantera includes
14#include "TransportBase.h"
15#include "cantera/base/FactoryBase.h"
16
17 namespace Cantera
18{
19
20//! Factory class for creating new instances of classes derived from Transport.
21/*!
22 * Creates 'transport managers', which are classes derived from class
23 * Transport that provide transport properties. TransportFactory handles all
24 * initialization required, including evaluation of collision integrals and
25 * generating polynomial fits. Transport managers can also be created in
26 * other ways.
27 *
28 * @ingroup tranprops
29 */
30 class TransportFactory : public Factory<Transport>
31{
32 public:
33 //! Return a pointer to a TransportFactory instance.
34 /*!
35 * TransportFactory is implemented as a 'singleton', which means that at
36 * most one instance may be created. The constructor is private. When a
37 * TransportFactory instance is required, call static method factory() to
38 * return a pointer to the TransportFactory instance.
39 *
40 * @code
41 * TransportFactory* f;
42 * f = TransportFactory::factory();
43 * @endcode
44 */
45 static TransportFactory* factory() {
46 std::unique_lock<std::mutex> transportLock(transport_mutex);
47 if (!s_factory) {
48 s_factory = new TransportFactory();
49 }
50 return s_factory;
51 }
52
53 //! Deletes the statically allocated factory instance.
54 virtual void deleteFactory();
55
56 //! Build a new transport manager using a transport manager
57 //! that may not be the same as in the phase description
58 //! and return a base class pointer to it
59 /*!
60 * @param model String name for the transport manager
61 * @param thermo ThermoPhase object
62 * @param log_level log level
63 */
64 virtual Transport* newTransport(const std::string& model, ThermoPhase* thermo, int log_level=0);
65
66 //! Build a new transport manager using the default transport manager
67 //! in the phase description and return a base class pointer to it
68 /*!
69 * @param thermo ThermoPhase object
70 * @param log_level log level
71 */
72 virtual Transport* newTransport(ThermoPhase* thermo, int log_level=0);
73
74 private:
75 //! Static instance of the factor -> This is the only instance of this
76 //! object allowed
77 static TransportFactory* s_factory;
78
79 //! Static instance of the mutex used to ensure the proper reading of the
80 //! transport database
81 static std::mutex transport_mutex;
82
83 //! The constructor is private; use static method factory() to
84 //! get a pointer to a factory instance
85 /*!
86 * The default constructor for this class sets up m_models[], a mapping
87 * between the string name for a transport model and the integer name.
88 */
89 TransportFactory();
90
91 //! Models included in this map are initialized in CK compatibility mode
92 std::map<std::string, bool> m_CK_mode;
93};
94
95//! @copydoc TransportFactory::newTransport(const std::string&, ThermoPhase*, int)
96 Transport* newTransportMgr(const std::string& model="", ThermoPhase* thermo=0,
97 int log_level=0);
98
99//! Create a new Transport instance.
100/*!
101 * @param thermo the ThermoPhase object associated with the phase
102 * @param model name of transport model; if "default", the default
103 * transport model for the ThermoPhase object is created
104 * @returns a Transport object for the phase
105 * @ingroup tranprops
106 */
107 inline shared_ptr<Transport> newTransport(ThermoPhase* thermo,
108 const std::string& model = "default") {
109 Transport* tr;
110 if (model == "default") {
111 tr = TransportFactory::factory()->newTransport(thermo, 0);
112 } else {
113 tr = TransportFactory::factory()->newTransport(model, thermo, 0);
114 }
115 return shared_ptr<Transport> (tr);
116}
117
118//! Create a new transport manager instance.
119/*!
120 * @param thermo ThermoPhase object associated with the phase
121 * @param loglevel int containing the Loglevel, defaults to zero
122 * @returns a transport manager for the phase
123 * @ingroup tranprops
124 */
125Transport* newDefaultTransportMgr(ThermoPhase* thermo, int loglevel = 0);
126
127} // End of namespace Cantera
128
129#endif
FactoryBase.h
File contains the FactoryBase class declarations.
TransportBase.h
Headers for the Transport object, which is the virtual base class for all transport property evaluato...
Cantera::Factory
Factory class that supports registering functions to create objects.
Definition: FactoryBase.h:70
Cantera::ThermoPhase
Base class for a phase with thermodynamic properties.
Definition: ThermoPhase.h:102
Cantera::TransportFactory
Factory class for creating new instances of classes derived from Transport.
Definition: TransportFactory.h:31
Cantera::TransportFactory::s_factory
static TransportFactory * s_factory
Static instance of the factor -> This is the only instance of this object allowed.
Definition: TransportFactory.h:77
Cantera::TransportFactory::deleteFactory
virtual void deleteFactory()
Deletes the statically allocated factory instance.
Definition: TransportFactory.cpp:56
Cantera::TransportFactory::factory
static TransportFactory * factory()
Return a pointer to a TransportFactory instance.
Definition: TransportFactory.h:45
Cantera::TransportFactory::m_CK_mode
std::map< std::string, bool > m_CK_mode
Models included in this map are initialized in CK compatibility mode.
Definition: TransportFactory.h:92
Cantera::TransportFactory::newTransport
virtual Transport * newTransport(const std::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...
Definition: TransportFactory.cpp:63
Cantera::TransportFactory::transport_mutex
static std::mutex transport_mutex
Static instance of the mutex used to ensure the proper reading of the transport database.
Definition: TransportFactory.h:81
Cantera::TransportFactory::TransportFactory
TransportFactory()
The constructor is private; use static method factory() to get a pointer to a factory instance.
Definition: TransportFactory.cpp:30
Cantera::Transport
Base class for transport property managers.
Definition: TransportBase.h:138
Cantera::newDefaultTransportMgr
Transport * newDefaultTransportMgr(ThermoPhase *thermo, int loglevel)
Create a new transport manager instance.
Definition: TransportFactory.cpp:113
Cantera::newTransport
shared_ptr< Transport > newTransport(ThermoPhase *thermo, const std::string &model="default")
Create a new Transport instance.
Definition: TransportFactory.h:107
Cantera
Namespace for the Cantera kernel.
Definition: AnyMap.cpp:557
Cantera::newTransportMgr
Transport * newTransportMgr(const std::string &model, ThermoPhase *thermo, int log_level)
Build a new transport manager using a transport manager that may not be the same as in the phase desc...
Definition: TransportFactory.cpp:107