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"
16
17namespace 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 */
30class TransportFactory : public Factory<Transport>
31{
32public:
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 */
46 std::unique_lock<std::mutex> transportLock(transport_mutex);
47 if (!s_factory) {
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
74private:
75 //! Static instance of the factor -> This is the only instance of this
76 //! object allowed
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 */
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)
96Transport* 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 */
107inline 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
File contains the FactoryBase class declarations.
Headers for the Transport object, which is the virtual base class for all transport property evaluato...
Factory class that supports registering functions to create objects.
Definition: FactoryBase.h:70
Base class for a phase with thermodynamic properties.
Definition: ThermoPhase.h:102
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.
virtual void deleteFactory()
Deletes the statically allocated factory instance.
static TransportFactory * factory()
Return a pointer to a TransportFactory instance.
std::map< std::string, bool > m_CK_mode
Models included in this map are initialized in CK compatibility mode.
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...
static std::mutex transport_mutex
Static instance of the mutex used to ensure the proper reading of the transport database.
TransportFactory()
The constructor is private; use static method factory() to get a pointer to a factory instance.
Base class for transport property managers.
shared_ptr< Transport > newTransport(ThermoPhase *thermo, const std::string &model="default")
Create a new Transport instance.
Transport * newDefaultTransportMgr(ThermoPhase *thermo, int loglevel=0)
Create a new transport manager instance.
Namespace for the Cantera kernel.
Definition: AnyMap.h:29
Transport * newTransportMgr(const std::string &model="", ThermoPhase *thermo=0, int log_level=0)
Build a new transport manager using a transport manager that may not be the same as in the phase desc...