The parameters are reduced parameters. More...

Namespaces
	AntiochPrivate

	Constants

	KineticsModel

	ReactionType

	UnitBaseConstant

	UnitBaseStorage

Classes
class	ArrheniusRate
	Arrhenius rate equation. More...

singleton	ASCIIParser

class	BerthelotHercourtEssenRate
	Berthelot Hercourt-Essen rate equation. More...

class	BerthelotRate
	Berthelot rate equation. More...

class	BinaryDiffusionBase
	Base class for binary diffusion models. More...

class	BlottnerViscosity

class	CEACurveFit
	This class only differs from NASA9CurveFit in the construction. More...

class	CEAEvaluator

class	CEAThermodynamics

class	CEAThermoMixture

singleton	ChemicalMixture
	Class storing chemical mixture properties. More...

class	ChemicalSpecies
	Class to encapsulate data for each chemical species. More...

class	ChemKinDefinitions

singleton	ChemKinParser
	ChemKin format file reader. More...

struct	ConductivityTraits

struct	ConductivityTraits< EuckenThermalConductivity< ThermoEvaluator > >

struct	ConductivityTraits< KineticsTheoryThermalConductivity< ThermoEvaluator, CoeffType > >

class	ConstantLewisDiffusivity
	Compute species diffusivity based on constant Lewis number. More...

class	ConstantRate
	Constant rate equation. More...

struct	constructor_or_reference

struct	constructor_or_reference< T, T >

class	Converter
	Class to deal with the conversion between units. More...

class	DefaultInstallFilename
	Default filenames in the install tree. More...

class	DefaultSourceFilename
	Default filenames in the source tree. More...

struct	DiffusionTraits
	Characteristics of various diffusion models. More...

struct	DiffusionTraits< ConstantLewisDiffusivity< CoeffType > >

class	DuplicateReaction
	A single reaction mechanism. More...

struct	eigen_library_tag

class	ElementaryReaction
	A single reaction mechanism. More...

struct	enable_if_c

struct	enable_if_c< false, T >

class	EuckenThermalConductivity
	Species conductivity based on Eucken relation. More...

class	FailedNewtonTTvInversion
	A class representing failed Newton convergence in T/Tv inversion. More...

class	FalloffReaction
	Base class for falloff processes. More...

class	FalloffThreeBodyReaction
	Base class for falloff processes coupled with efficiencies. More...

class	FileError
	A class representing a failed attempt by the library to open a file (or construct an fstream, etc), to be thrown by "antioch_file_error(filename);" For ease of debugging, "filename" should include any (absolute or relative or implicit) pathname that was part of the failed open. More...

struct	has_size

struct	has_size< std::valarray< T > >

struct	has_size< std::vector< T > >

struct	has_size< T, typename Antioch::enable_if_c< is_eigen< T >::value, void >::type >

struct	has_size< T, typename Antioch::enable_if_c< is_metaphysicl< T >::value, void >::type >

struct	has_size< vex::vector< T > >

class	HercourtEssenRate
	Hercourt-Essen rate equation. More...

class	IdealGasMicroThermo

struct	if_else_type

struct	if_else_type< false, T1, T2 >

class	InSI
	Seven integers to characterize the power vector. More...

struct	is_eigen

struct	is_eigen< _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >

struct	is_metaphysicl

struct	is_metaphysicl< MetaPhysicL::NumberArray< size, T > >

struct	is_valarray

struct	is_valarray< std::valarray< T > >

class	KineticsConditions
	This class contains the conditions of the chemistry. More...

class	KineticsEvaluator
	Class to handle computing mass source terms for a given ReactionSet. More...

class	KineticsTheoryThermalConductivity
	Conductivity based on kinetic theory of mixtures approximations. More...

class	KineticsType
	base class for kinetics models More...

class	KooijRate
	Kooij rate equation. More...

class	LennardJonesPotential

class	LindemannFalloff
	Simplest falloff model ( ) More...

class	LogicError
	A class to represent the internal "this should never happen" errors, to be thrown by "antioch_error();". More...

struct	metaphysicl_library_tag

class	MixtureAveragedTransportEvaluator
	Compute transport properties using ``mixture averaged" model. More...

class	MixtureAveragedTransportMixture
	Mixture object for MixtureAveragedTransport model. More...

class	MixtureConductivity
	Container class for species thermal conductivities. More...

class	MixtureDiffusion
	Container class for species binary diffusion models. More...

class	MixtureTransportBase
	Base class for MixtureViscosity, MixtureConductivity, etc. More...

class	MixtureViscosity
	Container class for species viscosities. More...

class	NASA7CurveFit

class	NASA9CurveFit
	This class stores the NASA polynomial fit to the thermodynamics quantities $\frac{C_p}{\mathrm{R}}$ $\frac{h}{\mathrm{R}T}$ and $\frac{s}{\mathrm{R}T}$ . More...

singleton	NASACurveFit

class	NASACurveFitBase

singleton	NASAEvaluator

class	NASAThermoMixture

class	NotImplemented
	A class to stub for features that should be in Antioch, but haven't been written yet, to be thrown by "antioch_not_implemented();". More...

struct	numeric_library_tag

class	ParserBase
	A parser is an instance related to a file. More...

class	ParsingError
	A class representing error while parsing. More...

class	ParticleFlux
	Stores the incoming flux of particles. More...

class	PhotochemicalRate
	Photochemical rate. More...

struct	raw_value_type

struct	raw_value_type< _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >

struct	raw_value_type< const T >

struct	raw_value_type< std::valarray< T > >

struct	raw_value_type< std::vector< T > >

struct	raw_value_type< T, typename Antioch::enable_if_c< is_metaphysicl< T >::value, void >::type >

struct	raw_value_type< vex::vector< T > >

class	Reaction
	A single reaction mechanism. More...

singleton	ReactionSet
	This class encapsulates all the reaction mechanisms considered in a chemical nonequilibrium simulation. More...

struct	rebind

struct	rebind< _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >, NewScalar >

struct	rebind< MetaPhysicL::NumberArray< size, T >, NewScalar >

struct	rebind< std::valarray< T >, NewScalar >

struct	rebind< std::vector< T >, NewScalar >

struct	rebind< vex::vector< T >, NewScalar >

struct	return_auto

struct	return_auto< std::vector< T > >

struct	return_auto< T, typename Antioch::enable_if_c< is_eigen< T >::value, void >::type >

struct	return_auto< T, typename Antioch::enable_if_c< is_metaphysicl< T >::value, void >::type >

struct	return_auto< T, typename Antioch::enable_if_c< is_valarray< T >::value, void >::type >

struct	return_auto< vex::vector< T > >

class	RotationalRelaxation

class	SigmaBinConverter

class	SIPrefixes
	Prefixes in unit. More...

struct	size_type

struct	size_type< std::valarray< T > >

struct	size_type< std::vector< T > >

struct	size_type< T, typename Antioch::enable_if_c< is_eigen< T >::value, void >::type >

struct	size_type< T, typename Antioch::enable_if_c< is_metaphysicl< T >::value, void >::type >

struct	size_type< vex::vector< T > >

class	SpeciesConductivityBase
	Base class for species conducitivity models. More...

class	SpeciesDiffusionBase
	Base class for species diffusion models. More...

class	SpeciesViscosityBase
	Base class for species viscosity models. More...

struct	state_type

struct	state_type< T, typename enable_if_c< is_eigen< T >::value, void >::type >

struct	state_type< T, typename enable_if_c< is_metaphysicl< T >::value, void >::type >

struct	state_type< T, typename enable_if_c< is_valarray< T >::value, void >::type >

class	StatMechThermodynamics

class	StockmayerPotential

class	SutherlandViscosity

struct	tag_type

struct	tag_type< T, typename std::enable_if< is_eigen< T >::value >::type >

struct	tag_type< T, typename std::enable_if< vex::is_vector_expression< T >::value >::type >

class	TempCache

class	ThreeBodyReaction
	A single reaction mechanism. More...

class	TransportMixture
	Class storing chemical mixture properties. More...

class	TransportSpecies
	Class to encapsulate data relevant for transport for each chemical species. More...

class	TroeFalloff
	The Troe falloff model is defined by: $\log_{10}\left(F\right) = \frac{\log_{10}\left(F_{\text{cent}}\right)} {1 + \left[ \frac{\log_{10}\left(P_r\right) + c} {n - d \cdot \left[\log_{10}\left(P_r\right) + c\right]} \right]^2}$ with $\begin{split} P_r & = [\mathrm{M}] \frac{k_0}{k_\infty} \\ n & = 0.75 - 1.27 \log_{10}\left(F_{\text{cent}}\right) \\ c & = - 0.40 - 0.67 \log_{10}\left(F_{\text{cent}}\right) \\ d & = 0.14 \\ F_{\text{cent}} & = (1 - \alpha) \cdot \exp\left(-\frac{T}{T^{**}}\right) + \alpha \cdot \exp\left(-\frac{T}{T^}\right) + \exp\left(-\frac{T^{}}{T}\right) \end{split}$ The derivatives are therefore: $\begin{split} \frac{\partial F_{\text{cent}}}{\partial T} & = \frac{\alpha - 1}{T^{}} \cdot \exp\left(-\frac{T}{T^{*}}\right) - \frac{\alpha}{T^{}} \cdot \exp\left(-\frac{T}{T^}\right) + \frac{T^{}}{T^{2}} \exp\left(-\frac{T^{*}}{T}\right) \\ \frac{\partial \log_{10}\left(F_\text{cent}\right)}{\partial T} & = \frac{1}{\ln(10) F_\text{cent}}\frac{\partial F_\text{cent}}{\partial T} \\ \frac{\partial n}{\partial T} & = - 1.27 \frac{\partial \log_{10}\left(F_\text{cent}\right)}{\partial T} \\ \frac{\partial c}{\partial T} & = - 0.67 \frac{\partial \log_{10}\left(F_\text{cent}\right)}{\partial T} \\\\ \frac{\partial P_r}{\partial T} & = P_r \left(\frac{\partial k_0}{\partial T} \frac{1}{k_0} - \frac{\partial k_\infty}{\partial T} \frac{1}{k_\infty} \right)\\ \frac{\partial \log_{10}(P_r)}{\partial T} & = \frac{1}{\ln(10) P_r} \frac{\partial P_r}{\partial T} \\\\ \frac{\partial \log_{10}(F)}{\partial T} & = \frac{\partial \log_{10}\left(F_\text{cent}\right)}{\partial T} \frac{1}{1 + \left[\frac{\log_{10}\left(P_r\right) + c} {n - d\left(\log_{10}\left(P_r\right) + c\right)}\right]^2} - \log_{10}\left(F_\text{cent}\right) 2\left[\frac{\log_{10}\left(P_r\right) + c}{n - d \left[\log_{10}\left(P_r\right) + c\right]}\right]^2 \left[\frac{\frac{\partial \log_{10}\left(P_r\right)}{\partial T} + \frac{\partial c}{\partial T}} {\log_{10}\left(P_r\right) + c} - \frac{\frac{\partial n}{\partial T} - d \left[\frac{\partial \log_{10}\left(P_r\right)}{\partial T} + \frac{\partial c}{\partial T}\right]} {n - d \left[\log_{10}\left(P_r\right) + c\right]} \right] \frac{1}{\left[1 + \left[\frac{\log_{10}\left(P_r\right) + c} {n - d\left(\log_{10}\left(P_r\right) + c\right)} \right]^2 \right]^2} \\ & = \log_{10}\left(F\right) \left[\frac{\partial \log_{10}\left(F_\text{cent}\right)}{\partial T} \frac{1}{F_\text{cent}} - 2\left[\frac{\log_{10}\left(P_r\right) + c}{n - d \left[\log_{10}\left(P_r\right) + c\right]}\right]^2 \left[\frac{\frac{\partial \log_{10}\left(P_r\right)}{\partial T} + \frac{\partial c}{\partial T}} {\log_{10}\left(P_r\right) + c} - \frac{\frac{\partial n}{\partial T} - d \left[\frac{\partial \log_{10}\left(P_r\right)}{\partial T} + \frac{\partial c}{\partial T}\right]} {n - d \left[\log_{10}\left(P_r\right) + c\right]} \right] \frac{1}{1 + \left[\frac{\log_{10}\left(P_r\right) + c} {n - d\left(\log_{10}\left(P_r\right) + c\right)} \right]^2} \right] \\ \frac{\partial F}{\partial T} & = \ln(10) F \frac{\partial \log_{10}\left(F\right)}{\partial T} \\\\\\\\ \frac{\partial P_r}{\partial c_i} & = \frac{k_0}{k_\infty} \\ \frac{\partial \log_{10}(P_r)}{\partial c_i} & = \frac{1}{\ln(10) P_r} \frac{\partial P_r}{\partial c_i} = \frac{1}{\ln(10) [\mathrm{M}]}\\\\ \frac{\partial \log_{10}\left(F\right)}{\partial c_i} & = -\frac{\log_{10}^2\left(F\right)}{\log_{10}\left(F_\text{cent}\right)} \frac{\partial \log_{10}\left(P_r\right)}{\partial c_i} \left(1 - \frac{1}{n - d\left[\log_{10}\left(P_r\right) + c\right]}\right) \left(\log_{10}\left(P_r\right) + c\right) \\ \frac{\partial F}{\partial c_i} & = \ln(10) F \frac{\partial \log_{10}\left(F\right)}{\partial c_i} \end{split}$ . More...

class	UnitBase
	wrapper for unit storage More...

class	UnitError
	A class representing error in units. More...

class	Units
	An advanced unit class. More...

struct	valarray_library_tag

struct	value_type

struct	value_type< _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > >

struct	value_type< const T >

struct	value_type< std::valarray< T > >

struct	value_type< std::vector< T > >

struct	value_type< T, typename Antioch::enable_if_c< is_metaphysicl< T >::value, void >::type >

struct	value_type< vex::vector< T > >

class	VantHoffRate
	Van't Hoff rate equation. More...

struct	vector_library_tag

struct	vexcl_library_tag

class	WilkeEvaluator
	Deprecated. Use MixtureAveragedTransportEvaluator instead. More...

class	WilkeMixture

class	XMLParser
	Nothing is stored, this parser is based on the tinyxml2 implementation. More...

Typedefs
typedef unsigned int	Species

typedef DefaultSourceFilename	DefaultFilename

Enumerations
enum	ParsingType { ASCII = 0, XML, CHEMKIN }

enum	ParsingKey { SPECIES_SET = 0, SPECIES_DATA, SPECIES, THERMO, PHASE_BLOCK, TMIN, TMAX, NASADATA, NASA7, NASA9, REACTION_DATA, REACTION, REVERSIBLE, ID, EQUATION, CHEMICAL_PROCESS, KINETICS_MODEL, REACTANTS, PRODUCTS, FORWARD_ORDER, BACKWARD_ORDER, PREEXP, POWER, ACTIVATION_ENERGY, BERTHELOT_COEFFICIENT, TREF, HV_LAMBDA, HV_CROSS_SECTION, UNIT, EFFICIENCY, FALLOFF_LOW, FALLOFF_LOW_NAME, TROE_FALLOFF, TROE_F_ALPHA, TROE_F_TS, TROE_F_TSS, TROE_F_TSSS }

enum	ParsingUnit { MOL_WEIGHT = 0, MASS_ENTHALPY }

Functions
template<typename CoeffType , typename VectorCoeffType >
KineticsType< CoeffType, VectorCoeffType > *	build_rate (const VectorCoeffType &data, const KineticsModel::KineticsModel &kin)
	cross-road to kinetics model More...

template<typename CoeffType , typename VectorCoeffType , typename VectorType >
void	reset_rate (KineticsType< CoeffType, VectorCoeffType > &kin, const VectorType &coefs)

template<typename CoeffType , typename VectorCoeffType >
void	reset_parameter_of_rate (KineticsType< CoeffType, VectorCoeffType > &rate, KineticsModel::Parameters parameter, const CoeffType new_value, const std::string &unit="SI")
	The rate constant models derived from the Arrhenius model have an activation energy which is stored and used, for efficiency reasons, in the reduced $\frac{E_a}{\mathrm{R}}$ form in K. More...

template<typename CoeffType , typename VectorCoeffType >
void	reset_parameter_of_rate (KineticsType< CoeffType, VectorCoeffType > &rate, KineticsModel::Parameters parameter, const CoeffType new_value, int l, const std::string &unit="SI")

template<typename CoeffType >
Reaction< CoeffType > *	build_reaction (const unsigned int n_species, const std::string &equation, const bool &reversible, const ReactionType::ReactionType &type, const KineticsModel::KineticsModel &kin)

template<class NumericType >
void	read_blottner_data_ascii (MixtureViscosity< BlottnerViscosity< NumericType >, NumericType > &mu, const std::string &filename)

template<class NumericType >
void	read_blottner_data_ascii_default (MixtureViscosity< BlottnerViscosity< NumericType >, NumericType > &mu)

template<class NumericType >
void	read_cea_mixture_data_ascii (CEAThermoMixture< NumericType > &thermo, const std::string &filename)

template<class NumericType >
void	read_cea_mixture_data_ascii_default (CEAThermoMixture< NumericType > &thermo)

template<class NumericType >
void	read_cea_mixture_data_ascii (CEAThermodynamics< NumericType > &thermo, const std::string &filename)

template<class NumericType >
void	read_cea_mixture_data (CEAThermoMixture< NumericType > &thermo, const std::string &filename, ParsingType type, bool verbose=true)

template<class NumericType >
void	read_cea_thermo_data_ascii (CEAThermodynamics< NumericType > &thermo, const std::string &filename)

template<class NumericType >
void	build_constant_lewis_diffusivity (MixtureDiffusion< ConstantLewisDiffusivity< NumericType >, NumericType > &D, const NumericType Le)

template<class NumericType >
void	build_constant_lewis_diffusivity (MixtureDiffusion< ConstantLewisDiffusivity< NumericType >, NumericType > &D, const std::vector< NumericType > &Le)

template<class MicroThermo , class NumericType >
void	build_eucken_thermal_conductivity (MixtureConductivity< EuckenThermalConductivity< MicroThermo >, NumericType > &k, const MicroThermo &thermo)

template<class MicroThermo , class NumericType >
void	build_kinetics_theory_thermal_conductivity (MixtureConductivity< KineticsTheoryThermalConductivity< MicroThermo, NumericType >, NumericType > &k, const MicroThermo &thermo)

template<class NumericType >
void	read_nasa_mixture_data_ascii (NASAThermoMixture< NumericType, NASA7CurveFit< NumericType > > &thermo, const std::string &filename)

template<class NumericType , typename CurveType >
void	read_nasa_mixture_data (NASAThermoMixture< NumericType, CurveType > &thermo, const std::string &filename=DefaultSourceFilename::thermo_data(), ParsingType=ASCII, bool verbose=true)

template<class NumericType >
void	read_reaction_set_data_xml (const std::string &filename, const bool verbose, ReactionSet< NumericType > &reaction_set)

template<class NumericType >
void	read_reaction_set_data_chemkin (const std::string &filename, const bool verbose, ReactionSet< NumericType > &reaction_set)

template<typename NumericType >
void	read_reaction_set_data (const std::string &filename, const bool verbose, ReactionSet< NumericType > &reaction_set, ParsingType type=ASCII)

template<typename NumericType >
void	verify_unit_of_parameter (Units< NumericType > &default_unit, const std::string &provided_unit, const std::vector< std::string > &accepted_unit, const std::string &equation, const std::string &parameter_name)

template<typename NumericType >
void	read_chemical_species_composition (ParserBase< NumericType > *parser, ChemicalMixture< NumericType > &mixture)

template<class NumericType >
void	read_species_data (ParserBase< NumericType > *parser, ChemicalMixture< NumericType > &chem_mixture)

template<class NumericType >
void	read_species_vibrational_data (ParserBase< NumericType > *parser, ChemicalMixture< NumericType > &chem_mixture)

template<class NumericType >
void	read_species_electronic_data (ParserBase< NumericType > *parser, ChemicalMixture< NumericType > &chem_mixture)

template<class NumericType >
void	read_sutherland_data_ascii (MixtureViscosity< SutherlandViscosity< NumericType >, NumericType > &mu, const std::string &filename)

template<class NumericType >
void	read_sutherland_data_ascii_default (MixtureViscosity< SutherlandViscosity< NumericType >, NumericType > &mu)

template<typename NumericType >
void	read_transport_species_data_ascii (TransportMixture< NumericType > &transport, const std::string &filename)

template<typename NumericType >
void	read_transport_species_data (ParserBase< NumericType > *parser, TransportMixture< NumericType > &transport)

	ANTIOCH_NUMERIC_TYPE_CLASS_INSTANTIATE (ASCIIParser)

	ANTIOCH_ASCII_PARSER_INSTANTIATE ()

	ANTIOCH_BLOTTNER_PARSING_INSTANTIATE ()

	ANTIOCH_CEA_MIXTURE_DATA_ASCII_PARSING_INSTANTIATE ()

template void	read_cea_mixture_data< float > (CEAThermoMixture< float > &, const std::string &, ParsingType, bool)

template void	read_cea_mixture_data< double > (CEAThermoMixture< double > &, const std::string &, ParsingType, bool)

template void	read_cea_mixture_data< long double > (CEAThermoMixture< long double > &, const std::string &, ParsingType, bool)

	ANTIOCH_NASA_MIXTURE_PARSING_INSTANTIATE (NASA7CurveFit)

	ANTIOCH_NASA_MIXTURE_PARSING_INSTANTIATE (NASA9CurveFit)

	ANTIOCH_NASA_MIXTURE_PARSING_INSTANTIATE (CEACurveFit)

template void	read_nasa_mixture_data_ascii< float > (NASAThermoMixture< float, NASA7CurveFit< float > > &, const std::string &)

template void	read_nasa_mixture_data_ascii< double > (NASAThermoMixture< double, NASA7CurveFit< double > > &, const std::string &)

template void	read_nasa_mixture_data_ascii< long double > (NASAThermoMixture< long double, NASA7CurveFit< long double > > &, const std::string &)

	ANTIOCH_READ_REACTION_SET_DATA_INSTANTIATE ()

	ANTIOCH_SPECIES_PARSING_INSTANTIATE ()

	ANTIOCH_SUTHERLAND_PARSING_INSTANTIATE ()

template void	read_transport_species_data< float > (ParserBase< float > *, TransportMixture< float > &)

template void	read_transport_species_data< double > (ParserBase< double > *, TransportMixture< double > &)

template void	read_transport_species_data< long double > (ParserBase< long double > *, TransportMixture< long double > &)

template void	read_transport_species_data_ascii< float > (TransportMixture< float > &, const std::string &)

template void	read_transport_species_data_ascii< double > (TransportMixture< double > &, const std::string &)

template void	read_transport_species_data_ascii< long double > (TransportMixture< long double > &, const std::string &)

	ANTIOCH_NUMERIC_TYPE_CLASS_INSTANTIATE (XMLParser)

	ANTIOCH_XML_PARSER_INSTANTIATE ()

template<typename StateType >
const ANTIOCH_AUTO(StateType) EuckenThermalConductivity < ThermoEvaluator > return	trans (s, mu_s)

template<typename StateType >
const	ANTIOCH_AUTO (StateType) KineticsTheoryThermalConductivity< ThermoEvaluator

template<typename T >
Antioch::enable_if_c< is_eigen < T >::value, typename value_type< T >::type >::type	max (const T &in)

template<typename T >
Antioch::enable_if_c< is_eigen < T >::value, typename value_type< T >::type >::type	min (const T &in)

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >	zero_clone (const _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &ex)

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename Scalar2 >
void	zero_clone (_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &output, const _Matrix< Scalar2, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &ex)

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename Scalar >
_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols >	constant_clone (const _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &ex, const Scalar &value)

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename Scalar >
void	constant_fill (_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &output, const Scalar &value)

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
void	set_zero (_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &a)

template<typename Condition , typename T1 , typename T2 >
enable_if_c< is_eigen< T1 > ::value &&is_eigen< T2 > ::value, typename state_type < T1 >::type >::type	if_else (const Condition &condition, const T1 &if_true, const T2 &if_false)

template<typename VectorT , template< typename, int, int, int, int, int > class _Matrix, typename _UIntT , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
enable_if_c< is_eigen < typename value_type< VectorT > ::type >::value, typename value_type< VectorT >::type > ::type	eval_index (const VectorT &vec, const _Matrix< _UIntT, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &index)

template<typename T >
bool	conjunction_root (const T &vec, eigen_library_tag)

template<typename T >
bool	disjunction_root (const T &vec, eigen_library_tag)

void	skip_comment_lines (std::istream &in, const char comment_start)
	Skip comment lines in the header of an ASCII text file prefixed with the comment character 'comment_start'. More...

template<typename T >
Antioch::enable_if_c < is_metaphysicl< T >::value, typename value_type< T >::type > ::type	max (const T &in)

template<typename T >
Antioch::enable_if_c < is_metaphysicl< T >::value, typename value_type< T >::type > ::type	min (const T &in)

template<typename Tbool , typename Ttrue , typename Tfalse >
Antioch::enable_if_c < is_metaphysicl< Tbool > ::value &&is_metaphysicl < Ttrue >::value &&is_metaphysicl< Tfalse > ::value, typename state_type < Ttrue >::type >::type	if_else (const Tbool &condition, const Ttrue &if_true, const Tfalse &if_false)

template<typename VectorT , typename UIntType >
Antioch::enable_if_c < is_metaphysicl< typename Antioch::value_type< VectorT > ::type >::value &&is_metaphysicl< UIntType > ::value, typename Antioch::value_type< VectorT > ::type >::type	eval_index (const VectorT &vec, const UIntType &indexes)

	ANTIOCH_PLAIN_SCALAR (float)

	ANTIOCH_PLAIN_SCALAR (double)

	ANTIOCH_PLAIN_SCALAR (long double)

	ANTIOCH_PLAIN_SCALAR (short)

	ANTIOCH_PLAIN_SCALAR (int)

	ANTIOCH_PLAIN_SCALAR (unsigned short)

template<typename T >
void	set_zero (T &output)

template<typename T >
T	zero_clone (const T &)

template<typename T , typename T2 >
void	zero_clone (T &output, const T2 &)

template<typename T >
void	init_clone (T &output, const T &example)

template<typename Vector , typename Scalar >
void	init_constant (Vector &output, const Scalar &example)

template<typename T , typename Scalar >
T	constant_clone (const T &, const Scalar &value)

template<typename T , typename Scalar >
void	constant_fill (T &output, const Scalar &value)

template<typename T , typename VectorScalar >
T	custom_clone (const T &, const VectorScalar &values, unsigned int indexes)

template<typename T , typename VectorScalar >
T	custom_clone (const T &, const VectorScalar &values, const typename Antioch::rebind< T, unsigned int >::type &indexes)

template<typename VectorT >
value_type< VectorT >::type	eval_index (const VectorT &vec, unsigned int index)

bool	conjunction (const bool &vec)

template<typename T >
bool	conjunction (const T &vec)

template<typename T >
bool	conjunction_root (const T &vec, numeric_library_tag)

bool	disjunction (const bool &vec)

template<typename T >
bool	disjunction (const T &vec)

template<typename T >
bool	disjunction_root (const T &vec, numeric_library_tag)

template<typename T1 , typename T2 >
void	zero_clone (T1 &output, const T2 &example)

template<typename T >
T	if_else (bool condition, T if_true, T if_false)

void	split_string (const std::string &input, const std::string &delimiter, std::vector< std::string > &results)
	All characters in delimiter will be treated as a delimiter. More...

void	remove_newline_from_strings (std::vector< std::string > &strings)
	Strips newline characters from strings in the input vector, strings. More...

template<typename T >
T	string_to_T (const std::string &input)

template<typename Type >
std::pair< std::string, Type >	split_string_on_colon (const std::string &token)

int	SplitString (const std::string &input, const std::string &delimiter, std::vector< std::string > &results, bool includeEmpties=true)
	Taken from FIN-S for XML parsing. More...

int	ascii_getline (std::istream &buf, std::string &line)
	adapted getline, never believe ascii file for the formatting of end-of-line. More...

KineticsModel::Parameters	string_to_kin_enum (const std::string &str)

ReactionType::Parameters	string_to_chem_enum (const std::string &str)

template<typename T >
T	max (const std::valarray< T > &in)

template<typename T >
T	min (const std::valarray< T > &in)

template<typename T >
std::valarray< T >	zero_clone (const std::valarray< T > &example)

template<typename T1 , typename T2 >
void	zero_clone (std::valarray< T1 > &output, const std::valarray< T2 > &example)

template<typename T , typename Scalar >
std::valarray< T >	constant_clone (const std::valarray< T > &example, const Scalar &value)

template<typename T >
void	init_clone (std::valarray< T > &output, const std::valarray< T > &example)

template<typename T >
std::valarray< T >	if_else (const std::valarray< bool > &condition, const std::valarray< T > &if_true, const std::valarray< T > &if_false)

template<typename VectorT >
Antioch::enable_if_c < Antioch::is_valarray < typename value_type< VectorT > ::type >::value, typename value_type< VectorT >::type > ::type	eval_index (const VectorT &vec, const std::valarray< unsigned int > &index)

template<typename T >
std::vector< T >	zero_clone (const std::vector< T > &example)

template<typename T1 , typename T2 >
void	zero_clone (std::vector< T1 > &output, const std::vector< T2 > &example)

template<typename T , typename Scalar >
std::vector< T >	zero_clone (const std::vector< T > &example, const Scalar &value)

template<typename T >
void	set_zero (std::vector< T > &a)

template<typename T , typename VectorScalar >
std::vector< T >	custom_clone (const std::vector< T > &, const VectorScalar &vecsrc, std::vector< unsigned int > &indexes)

template<typename T , typename Scalar >
std::vector< T >	constant_clone (const std::vector< T > &example, const Scalar &value)

template<typename T , typename VectorScalar >
std::vector< T >	custom_clone (const std::vector< T > &vec, const VectorScalar &vecsrc, const std::vector< unsigned int > &indexes)

template<typename T >
T	max (const vex::vector< T > &in)

template<typename T >
T	min (const vex::vector< T > &in)

template<typename T >
vex::vector< T >	zero_clone (const vex::vector< T > &example)

template<typename T1 , typename T2 >
void	zero_clone (vex::vector< T1 > &output, const vex::vector< T2 > &example)

template<typename T , typename Scalar >
vex::vector< T >	constant_clone (const vex::vector< T > &example, const Scalar &value)

template<typename T >
void	init_clone (vex::vector< T > &output, const vex::vector< T > &example)

template<typename BoolInput , typename IfValue , typename ElseValue >
boost::proto::result_of::make_expr < boost::proto::tag::if_else_, boost::proto::deduce_domain, const vex::vector_expression < BoolInput > &, const IfValue &, const ElseValue & >::type const	if_else (const vex::vector_expression< BoolInput > &condition, const IfValue &if_true, const ElseValue &if_false)

template<typename T >
bool	disjunction_root (const T &vec_input, vexcl_library_tag)

template<typename T >
bool	conjunction_root (const T &vec_input, vexcl_library_tag)

template<typename VectorT , typename IntT >
enable_if_c < vex::is_vector_expression < typename value_type< VectorT > ::type >::value &&vex::is_vector_expression < IntT >::value, typename value_type< VectorT >::type > ::type	eval_index (const VectorT &vec, const IntT &index)

int	get_antioch_version ()

Detailed Description

The parameters are reduced parameters.

Everything here is deprecated, it is for backward compatibility, using the deprecated name/object CEAThermo...<NumericType>.

The complete Van't Hoff equation is (all the others are deductible from it) $k(T) = A * \left(\frac{T}{\mathrm{T_0}}\right)^\beta \exp\left(-\frac{E_a}{\mathrm{R}T} + D T\right)$ with $\mathrm{T_0}$ being a reference temperature and $\mathrm{R}$ the ideal gas constant. The reduced parameters are:

$\begin{array}{ccc}\toprule \text{Parameter} & \text{reduced parameter} \\\midrule A & A \mathrm{T_0}^\beta \\ \beta & \beta \\ E_a & \frac{E_a}{\mathrm{R}}\\ D & D\\\bottomrule \end{array}$

This library is intended for performances, thus the reference temperature is taken equal to one in order to skip the division step ( $\frac{T}{\mathrm{T_0}}$ ). This is not an option, this is an obligation: the kinetics equations are coded without the division step.

We required to provide:

for both descriptions (Mixture, dynamics).

Typedef Documentation

typedef DefaultSourceFilename Antioch::DefaultFilename

Definition at line 106 of file default_filename.h.

typedef unsigned int Antioch::Species

Definition at line 49 of file chemical_mixture.h.

Enumeration Type Documentation

enum Antioch::ParsingKey

Enumerator
SPECIES_SET
SPECIES_DATA
SPECIES
THERMO
PHASE_BLOCK
TMIN
TMAX
NASADATA
NASA7
NASA9
REACTION_DATA
REACTION
REVERSIBLE
ID
EQUATION
CHEMICAL_PROCESS
KINETICS_MODEL
REACTANTS
PRODUCTS
FORWARD_ORDER
BACKWARD_ORDER
PREEXP
POWER
ACTIVATION_ENERGY
BERTHELOT_COEFFICIENT
TREF
HV_LAMBDA
HV_CROSS_SECTION
UNIT
EFFICIENCY
FALLOFF_LOW
FALLOFF_LOW_NAME
TROE_FALLOFF
TROE_F_ALPHA
TROE_F_TS
TROE_F_TSS
TROE_F_TSSS

Definition at line 36 of file parsing_enum.h.

                  {SPECIES_SET = 0,
                   SPECIES_DATA,
                   SPECIES,
                   THERMO,
                   PHASE_BLOCK,
 //
                   TMIN,
                   TMAX,
                   NASADATA,
                   NASA7,
                   NASA9,
 //
                   REACTION_DATA,
                   REACTION,
                   REVERSIBLE,
                   ID,
                   EQUATION,
                   CHEMICAL_PROCESS,
                   KINETICS_MODEL,
                   REACTANTS,
                   PRODUCTS,
                   FORWARD_ORDER,
                   BACKWARD_ORDER,
                   PREEXP,
                   POWER,
                   ACTIVATION_ENERGY,
                   BERTHELOT_COEFFICIENT,
                   TREF,
                   HV_LAMBDA,
                   HV_CROSS_SECTION,
                   UNIT,
                   EFFICIENCY,
                   FALLOFF_LOW,
                   FALLOFF_LOW_NAME,
                   TROE_FALLOFF,
                   TROE_F_ALPHA,
                   TROE_F_TS,
                   TROE_F_TSS,
                   TROE_F_TSSS
                  };

enum Antioch::ParsingType

Enumerator
ASCII
XML
CHEMKIN

Definition at line 32 of file parsing_enum.h.

                   {ASCII = 0,
                    XML,
                    CHEMKIN};

enum Antioch::ParsingUnit

Enumerator
MOL_WEIGHT
MASS_ENTHALPY

Definition at line 77 of file parsing_enum.h.

                   {
                     MOL_WEIGHT = 0,
                     MASS_ENTHALPY
                    };

Function Documentation

Antioch::ANTIOCH_ASCII_PARSER_INSTANTIATE ( )

template<typename StateType >

const Antioch::ANTIOCH_AUTO ( StateType )

inline

Referenced by Antioch::TroeFalloff< CoeffType >::F_and_derivatives(), and Antioch::TroeFalloff< CoeffType >::operator()().

Antioch::ANTIOCH_BLOTTNER_PARSING_INSTANTIATE ( )

Antioch::ANTIOCH_CEA_MIXTURE_DATA_ASCII_PARSING_INSTANTIATE ( )

Antioch::ANTIOCH_NASA_MIXTURE_PARSING_INSTANTIATE ( NASA7CurveFit )

Antioch::ANTIOCH_NASA_MIXTURE_PARSING_INSTANTIATE ( NASA9CurveFit )

Antioch::ANTIOCH_NASA_MIXTURE_PARSING_INSTANTIATE ( CEACurveFit )

Antioch::ANTIOCH_NUMERIC_TYPE_CLASS_INSTANTIATE ( ASCIIParser )

Antioch::ANTIOCH_NUMERIC_TYPE_CLASS_INSTANTIATE ( XMLParser )

Antioch::ANTIOCH_PLAIN_SCALAR ( float )

Antioch::ANTIOCH_PLAIN_SCALAR ( double )

Antioch::ANTIOCH_PLAIN_SCALAR ( long double )

Antioch::ANTIOCH_PLAIN_SCALAR ( short )

Antioch::ANTIOCH_PLAIN_SCALAR ( int )

Antioch::ANTIOCH_PLAIN_SCALAR ( unsigned short )

Antioch::ANTIOCH_READ_REACTION_SET_DATA_INSTANTIATE ( )

Antioch::ANTIOCH_SPECIES_PARSING_INSTANTIATE ( )

Antioch::ANTIOCH_SUTHERLAND_PARSING_INSTANTIATE ( )

Antioch::ANTIOCH_XML_PARSER_INSTANTIATE ( )

int Antioch::ascii_getline	(	std::istream &	buf,
		std::string &	line
	)

inline

adapted getline, never believe ascii file for the formatting of end-of-line.

end-of-line triggered by
or

Windows
Unix/Linux
Mac

Definition at line 169 of file string_utils.h.

Referenced by Antioch::ChemKinParser< NumericType >::initialize(), Antioch::ChemKinParser< NumericType >::next_meaningful_line(), Antioch::ChemKinParser< NumericType >::read_thermodynamic_data_root(), and Antioch::ChemKinParser< NumericType >::species_list().

   {
      char c('a');
      line.clear();
      while(!buf.eof())
      {
         c = buf.get();
         if(c == '\n' || c == '\r')break;
         line += c;
      }
      char n = buf.peek();
 
      /* never trust ascii files, they may come from
         Windows, suppodedly \n\r, but let's not
         underestimate Windows's viciousness
       */
      if((c == '\n' && n == '\r') ||
         (n == '\n' && c == '\r'))c = buf.get();
 
      return buf.good();
   }

template<class NumericType >

void Antioch::build_constant_lewis_diffusivity	(	MixtureDiffusion< ConstantLewisDiffusivity< NumericType >, NumericType > &	D,
		const NumericType	Le
	)

Definition at line 46 of file constant_lewis_diffusivity_building.h.

References Antioch::KineticsModel::D.

   {
     std::vector<NumericType> coeffs(1, Le);
     for(unsigned int s = 0; s < D.mixture().n_species(); s++)
       {
         D.add_species_diffusion(s,coeffs);
       }
   }

template<class NumericType >

void Antioch::build_constant_lewis_diffusivity	(	MixtureDiffusion< ConstantLewisDiffusivity< NumericType >, NumericType > &	D,
		const std::vector< NumericType > &	Le
	)

Definition at line 56 of file constant_lewis_diffusivity_building.h.

References Antioch::KineticsModel::D.

   {
     for(unsigned int s = 0; s < D.mixture().n_species(); s++)
       {
         std::vector<NumericType> coeffs(1, Le[s]);
         D.add_species_diffusion(s,coeffs);
       }
   }

template<class MicroThermo , class NumericType >

void Antioch::build_eucken_thermal_conductivity	(	MixtureConductivity< EuckenThermalConductivity< MicroThermo >, NumericType > &	k,
		const MicroThermo &	thermo
	)

Definition at line 42 of file eucken_thermal_conductivity_building.h.

   {
     for(unsigned int s = 0; s < k.mixture().n_species(); s++)
        {
          // Eucken doesn't have any coefficients to cache so we provide a dummy vector
          std::vector<NumericType> dummy;
          k.add(s,dummy,thermo);
        }
   }

template<class MicroThermo , class NumericType >

void Antioch::build_kinetics_theory_thermal_conductivity	(	MixtureConductivity< KineticsTheoryThermalConductivity< MicroThermo, NumericType >, NumericType > &	k,
		const MicroThermo &	thermo
	)

Definition at line 48 of file kinetics_theory_thermal_conductivity_building.h.

   {
     for(unsigned int s = 0; s < k.mixture().n_species(); s++)
        {
          std::vector<NumericType> coeffs(2);
          coeffs[0] = k.mixture().transport_species()[s]->rotational_relaxation();
          coeffs[1] = k.mixture().transport_species()[s]->LJ_depth();
          k.add(s,coeffs,thermo);
        }
   }

template<typename CoeffType , typename VectorCoeffType >

KineticsType< CoeffType, VectorCoeffType > * Antioch::build_rate	(	const VectorCoeffType &	data,
		const KineticsModel::KineticsModel &	kin
	)

inline

cross-road to kinetics model

We take here the parameters as:

Definition at line 89 of file kinetics_parsing.h.

References antioch_assert_equal_to, antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, Antioch::KineticsModel::PHOTOCHEM, std::pow(), and Antioch::KineticsModel::VANTHOFF.

   {
     using std::pow;
 
     KineticsType<CoeffType,VectorCoeffType>* rate = NULL;
 
     switch(kin)
       {
       case(KineticsModel::CONSTANT):
         {
           antioch_assert_equal_to(1,data.size());
           rate = new ConstantRate<CoeffType>(data[0]);//Cf
         }
         break;
 
       case(KineticsModel::HERCOURT_ESSEN):
         {
           antioch_assert_equal_to(3,data.size());
           rate = new HercourtEssenRate<CoeffType>(data[0],data[1],data[2]);//Cf,eta,Tref
         }
         break;
 
       case(KineticsModel::BERTHELOT):
         {
           antioch_assert_equal_to(2,data.size());
           rate = new BerthelotRate<CoeffType>(data[0],data[1]);// Cf, D
         }
         break;
 
       case(KineticsModel::ARRHENIUS):
         {
           antioch_assert_equal_to(3,data.size());
           rate = new ArrheniusRate<CoeffType>(data[0],data[1],data[2]);//Cf,Ea,scale
         }
         break;
 
       case(KineticsModel::BHE):
         {
           antioch_assert_equal_to(4,data.size());
           rate = new BerthelotHercourtEssenRate<CoeffType>(data[0],data[1],data[2],data[3]);//Cf,eta,D,Tref
         }
         break;
 
       case(KineticsModel::KOOIJ):
         {
           antioch_assert_equal_to(5,data.size());
           rate = new KooijRate<CoeffType>(data[0],data[1],data[2],data[3],data[4]);//Cf,eta,Ea,Tref,scale
         }
         break;
 
       case(KineticsModel::VANTHOFF):
         {
           antioch_assert_equal_to(6,data.size());
           rate = new VantHoffRate<CoeffType>(data[0],data[1],data[2],data[3],data[4],data[5]);//Cf,eta,Ea,D,Tref,scale
         }
         break;
 
       case(KineticsModel::PHOTOCHEM):
         {
           antioch_assert_equal_to(0,data.size()%2); //two vectors in one: lambda then cross-section
           VectorCoeffType cs;
           VectorCoeffType lambda;
           for(unsigned int i = 0; i < data.size()/2; i++)
           {
              lambda.push_back(data[i]);
              cs.push_back(data[i + data.size()/2]); 
           }
           rate = new PhotochemicalRate<CoeffType,VectorCoeffType>(cs,lambda);//cs,lambda
         }
         break;
 
       default:
         {
           antioch_error();
         }
 
       } // switch(kin)
 
     return rate;
   }

template<typename CoeffType >

Reaction< CoeffType > * Antioch::build_reaction	(	const unsigned int	n_species,
		const std::string &	equation,
		const bool &	reversible,
		const ReactionType::ReactionType &	type,
		const KineticsModel::KineticsModel &	kin
	)

inline

Definition at line 53 of file reaction_parsing.h.

References antioch_error, Antioch::ReactionType::DUPLICATE, Antioch::ReactionType::ELEMENTARY, Antioch::ReactionType::LINDEMANN_FALLOFF, Antioch::ReactionType::LINDEMANN_FALLOFF_THREE_BODY, Antioch::ReactionType::THREE_BODY, Antioch::ReactionType::TROE_FALLOFF, and Antioch::ReactionType::TROE_FALLOFF_THREE_BODY.

   {
     Reaction<CoeffType>* reaction = NULL;
 
     switch(type)
       {
       case(ReactionType::ELEMENTARY):
         {
           reaction = new ElementaryReaction<CoeffType>(n_species,equation,reversible,kin);
         }
         break;
 
       case(ReactionType::DUPLICATE):
         {
           reaction = new DuplicateReaction<CoeffType>(n_species,equation,reversible,kin);
         }
         break;
 
       case(ReactionType::THREE_BODY):
         {
           reaction = new ThreeBodyReaction<CoeffType>(n_species,equation,reversible,kin);
         }
         break;
 
       case(ReactionType::LINDEMANN_FALLOFF):
         {
           reaction = new FalloffReaction<CoeffType,LindemannFalloff<CoeffType> >(n_species,equation,reversible,type,kin);
         }
       case(ReactionType::TROE_FALLOFF):
         {
           reaction = new FalloffReaction<CoeffType,TroeFalloff<CoeffType> >(n_species,equation,reversible,type,kin);
         }
         break;
 
       case(ReactionType::LINDEMANN_FALLOFF_THREE_BODY):
         {
           reaction = new FalloffThreeBodyReaction<CoeffType,LindemannFalloff<CoeffType> >(n_species,equation,reversible,type,kin);
         }
       case(ReactionType::TROE_FALLOFF_THREE_BODY):
         {
           reaction = new FalloffThreeBodyReaction<CoeffType,TroeFalloff<CoeffType> >(n_species,equation,reversible,type,kin);
         }
         break;
 
       default:
         {
           antioch_error();
         }
 
       } // switch(type)
 
     // Dummy
     return reaction;
   }

bool Antioch::conjunction ( const bool & vec )

inline

Definition at line 161 of file metaprogramming.h.

Referenced by Antioch::SigmaBinConverter< VectorCoeffType >::y_on_custom_grid().

 {
   return vec;
 }

template<typename T >

bool Antioch::conjunction ( const T & vec )

inline

Definition at line 168 of file metaprogramming.h.

References conjunction_root().

 {
   typedef typename tag_type<T>::type tag;
   return conjunction_root(vec,tag());
 }

template<typename T >

bool Antioch::conjunction_root	(	const T &	vec,
		numeric_library_tag
	)

inline

Definition at line 176 of file metaprogramming.h.

 {
   for(unsigned int i = 0; i < vec.size(); i++)
   {
     if(!vec[i])return false;
   }
   return true;
 }

template<typename T >

bool Antioch::conjunction_root	(	const T &	vec_input,
		vexcl_library_tag
	)

inline

Definition at line 227 of file vexcl_utils.h.

References antioch_error.

 {
 #ifdef ANTIOCH_HAVE_VEXCL
   vex::detail::get_expression_properties prop;
   vex::detail::extract_terminals()(boost::proto::as_child(vec_input),prop);
 
   vex::all_of all_of(prop.queue);
   return all_of(vec_input); // at least one false
 #else
   antioch_error();
   return false;
 #endif
 }

template<typename T >

bool Antioch::conjunction_root	(	const T &	vec,
		eigen_library_tag
	)

inline

Definition at line 278 of file eigen_utils.h.

Referenced by conjunction().

 {
   return vec.all();
 }

template<typename T , typename Scalar >

std::vector<T> Antioch::constant_clone	(	const std::vector< T > &	example,
		const Scalar &	value
	)

inline

template<typename T , typename Scalar >

T Antioch::constant_clone	(	const T &	,
		const Scalar &	value
	)

inline

Definition at line 128 of file metaprogramming.h.

128 { return value; }

template<typename T , typename Scalar >

vex::vector< T > Antioch::constant_clone	(	const vex::vector< T > &	example,
		const Scalar &	value
	)

inline

Definition at line 176 of file vexcl_utils.h.

 {
   vex::vector<T> returnval(example.queue_list(), example.size());
   returnval = value;
   return returnval;
 }

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename Scalar >

_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > Antioch::constant_clone	(	const _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	ex,
		const Scalar &	value
	)

inline

Definition at line 181 of file eigen_utils.h.

Referenced by Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::compute_mu_mu_sqrt(), Antioch::Reaction< CoeffType, VectorCoeffType >::compute_rate_of_progress_and_derivatives(), Antioch::Converter< T >::Converter(), Antioch::NASAEvaluator< CoeffType, NASAFit >::cp(), Antioch::CEAThermodynamics< CoeffType >::cp(), Antioch::SigmaBinConverter< VectorCoeffType >::custom_bin_value(), Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::diffusion_mixing_rule(), Antioch::LindemannFalloff< CoeffType >::F_and_derivatives(), Antioch::TroeFalloff< CoeffType >::F_and_derivatives(), Antioch::NASACurveFitBase< CoeffType >::interval(), Antioch::LindemannFalloff< CoeffType >::operator()(), Antioch::TroeFalloff< CoeffType >::operator()(), Antioch::Converter< T >::operator=(), Antioch::LindemannFalloff< CoeffType >::value(), and Antioch::SigmaBinConverter< VectorCoeffType >::y_on_custom_grid().

 {
   // We can't just use setZero here with arbitrary _Scalar types
   if (ex.size())
     return
       _Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>
         (ex.rows(), ex.cols()).setConstant(value);
 
   return
     _Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>
       (ex.rows(), ex.cols());
 }

template<typename T , typename Scalar >

std::valarray< T > Antioch::constant_clone	(	const std::valarray< T > &	example,
		const Scalar &	value
	)

inline

Definition at line 187 of file valarray_utils.h.

 {
   if (example.size())
     return std::valarray<T>(value,example.size());
   else
     return std::valarray<T>();
 }

template<typename T , typename Scalar >

void Antioch::constant_fill	(	T &	output,
		const Scalar &	value
	)

inline

Definition at line 132 of file metaprogramming.h.

132 { output = value; }

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename Scalar >

void Antioch::constant_fill	(	_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	output,
		const Scalar &	value
	)

inline

Definition at line 204 of file eigen_utils.h.

Referenced by Antioch::ConstantRate< CoeffType >::rate_and_derivative().

 {
   output.fill(value);
 }

template<typename T , typename VectorScalar >

std::vector<T> Antioch::custom_clone	(	const std::vector< T > &	vec,
		const VectorScalar &	vecsrc,
		const std::vector< unsigned int > &	indexes
	)

inline

template<typename T , typename VectorScalar >

T Antioch::custom_clone	(	const T &	,
		const VectorScalar &	values,
		unsigned int	indexes
	)

inline

Definition at line 136 of file metaprogramming.h.

Referenced by Antioch::SigmaBinConverter< VectorCoeffType >::custom_bin_value().

136 {return values[indexes];}

template<typename T , typename VectorScalar >

T Antioch::custom_clone	(	const T &	,
		const VectorScalar &	values,
		const typename Antioch::rebind< T, unsigned int >::type &	indexes
	)

inline

Definition at line 140 of file metaprogramming.h.

 {
   T returnval(indexes.size()); //bof bof - metaphysicl has size within type, this suppose that size_type<indexes>::type can be changed in value_type<T>::type
 
   for(unsigned int i = 0; i < indexes.size(); i++)
   {
       returnval[i] = values[indexes[i]];
   }
   return returnval;
 }

template<typename T , typename VectorScalar >

std::vector<T> Antioch::custom_clone	(	const std::vector< T > &	,
		const VectorScalar &	vecsrc,
		std::vector< unsigned int > &	indexes
	)

inline

Definition at line 175 of file vector_utils.h.

 {
   std::vector<T> returnval;
   returnval.resize(indexes.size());
   for (std::size_t i=0; i != indexes.size(); ++i)
     returnval[i] = vecsrc[indexes[i]];
   return returnval;
 }

bool Antioch::disjunction ( const bool & vec )

inline

Definition at line 186 of file metaprogramming.h.

Referenced by Antioch::SigmaBinConverter< VectorCoeffType >::custom_bin_value().

 {
   return vec;
 }

template<typename T >

bool Antioch::disjunction ( const T & vec )

inline

Definition at line 193 of file metaprogramming.h.

References disjunction_root().

 {
   typedef typename tag_type<T>::type tag;
   return disjunction_root(vec,tag());
 }

template<typename T >

bool Antioch::disjunction_root	(	const T &	vec,
		numeric_library_tag
	)

inline

Definition at line 201 of file metaprogramming.h.

 {
   for(unsigned int i = 0; i < vec.size(); i++)
   {
     if(vec[i])return true;
   }
   return false;
 }

template<typename T >

bool Antioch::disjunction_root	(	const T &	vec_input,
		vexcl_library_tag
	)

inline

Definition at line 211 of file vexcl_utils.h.

References antioch_error.

 {
 #ifdef ANTIOCH_HAVE_VEXCL
   vex::detail::get_expression_properties prop;
   vex::detail::extract_terminals()(boost::proto::as_child(vec_input),prop);
 
   vex::any_of any_of(prop.queue);
   return any_of(vec_input); // at least one true
 #else
   antioch_error();
   return false;
 #endif
 }

template<typename T >

bool Antioch::disjunction_root	(	const T &	vec,
		eigen_library_tag
	)

inline

Definition at line 285 of file eigen_utils.h.

Referenced by disjunction().

 {
   return vec.any();
 }

template<typename VectorT , typename UIntType >

Antioch::enable_if_c< is_metaphysicl< typename Antioch::value_type< VectorT >::type >::value &&is_metaphysicl< UIntType >::value, typename Antioch::value_type< VectorT >::type >::type Antioch::eval_index	(	const VectorT &	vec,
		const UIntType &	indexes
	)

inline

Definition at line 154 of file metaphysicl_utils.h.

 {
   typename Antioch::value_type<VectorT>::type returnval;
 
   for(typename Antioch::size_type<typename Antioch::value_type<VectorT>::type>::type i = 0;
                 i < indexes.size(); i++)
     returnval[i] = vec[indexes[i]][i];
 
   return returnval;
 }

template<typename VectorT >

value_type< VectorT >::type Antioch::eval_index	(	const VectorT &	vec,
		unsigned int	index
	)

inline

Definition at line 155 of file metaprogramming.h.

 {
   return vec[index];
 }

template<typename VectorT , typename IntT >

enable_if_c< vex::is_vector_expression< typename value_type< VectorT >::type >::value &&vex::is_vector_expression< IntT >::value, typename value_type< VectorT >::type >::type Antioch::eval_index	(	const VectorT &	vec,
		const IntT &	index
	)

inline

Definition at line 248 of file vexcl_utils.h.

References zero_clone().

 {
   typename value_type<VectorT>::type returnval = zero_clone(vec[0]);
 
   // FIXME - this will be painfully slow
   for (unsigned int i=0; i != index.size(); ++i)
     returnval[i] = vec[index[i]][i];
 
   return returnval;
 }

template<typename VectorT >

Antioch::enable_if_c< Antioch::is_valarray< typename value_type< VectorT >::type >::value, typename value_type< VectorT >::type >::type Antioch::eval_index	(	const VectorT &	vec,
		const std::valarray< unsigned int > &	index
	)

inline

Definition at line 249 of file valarray_utils.h.

 {
   typename value_type<VectorT>::type returnval;
   std::size_t sz = index.size();
   returnval.resize(sz);
   for (std::size_t i=0; i != sz; ++i)
     returnval[i] = vec[index[i]][i];
   return returnval;
 }

template<typename VectorT , template< typename, int, int, int, int, int > class _Matrix, typename _UIntT , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>

enable_if_c< is_eigen< typename value_type< VectorT >::type >::value, typename value_type< VectorT >::type >::type Antioch::eval_index	(	const VectorT &	vec,
		const _Matrix< _UIntT, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	index
	)

inline

Definition at line 268 of file eigen_utils.h.

Referenced by Antioch::SigmaBinConverter< VectorCoeffType >::y_on_custom_grid().

 {
   typename value_type<VectorT>::type returnval = vec[0];
   for (unsigned int i=0; i != index.size(); ++i)
     returnval[i] = vec[index[i]][i];
   return returnval;
 }

int Antioch::get_antioch_version ( )

Definition at line 31 of file antioch_version.C.

   {
     /* Note: return format follows the versioning convention xx.yy.zz where
 
        xx = major version number
        yy = minor version number
        zz = micro version number
 
        For example:
        v.   0.23  -> 002300 = 2300
        v   0.23.1 -> 002301 = 2301
        v. 10.23.2 -> 102302         */
 
     int major_version = 0;
     int minor_version = 0;
     int micro_version = 0;
 
 #ifdef ANTIOCH_MAJOR_VERSION
     major_version = ANTIOCH_MAJOR_VERSION;
 #endif
 
 #ifdef ANTIOCH_MINOR_VERSION
     minor_version = ANTIOCH_MINOR_VERSION;
 #endif
 
 #ifdef ANTIOCH_MICRO_VERSION
     micro_version = ANTIOCH_MICRO_VERSION;
 #endif
 
     return major_version*10000 + minor_version*100 + micro_version;
   }

template<typename Tbool , typename Ttrue , typename Tfalse >

Antioch::enable_if_c< is_metaphysicl< Tbool >::value &&is_metaphysicl< Ttrue >::value &&is_metaphysicl< Tfalse >::value, typename state_type< Ttrue >::type >::type Antioch::if_else	(	const Tbool &	condition,
		const Ttrue &	if_true,
		const Tfalse &	if_false
	)

inline

Definition at line 133 of file metaphysicl_utils.h.

References antioch_assert_equal_to.

 {
   typename state_type<Ttrue>::type returnval;
   antioch_assert_equal_to(condition.size(), if_true.size());
   antioch_assert_equal_to(condition.size(), if_false.size());
 
   for (std::size_t i=0; i != condition.size(); ++i)
     returnval[i] = condition[i] ? if_true[i] : if_false[i];
 
   return returnval;
 }

template<typename BoolInput , typename IfValue , typename ElseValue >

boost::proto::result_of::make_expr< boost::proto::tag::if_else_, boost::proto::deduce_domain, const vex::vector_expression< BoolInput > &, const IfValue &, const ElseValue & >::type const Antioch::if_else	(	const vex::vector_expression< BoolInput > &	condition,
		const IfValue &	if_true,
		const ElseValue &	if_false
	)

inline

Definition at line 202 of file vexcl_utils.h.

 {
   return boost::proto::if_else(condition, if_true, if_false);
 }

template<typename T >

T Antioch::if_else	(	bool	condition,
		T	if_true,
		T	if_false
	)

inline

template<typename T >

std::valarray< T > Antioch::if_else	(	const std::valarray< bool > &	condition,
		const std::valarray< T > &	if_true,
		const std::valarray< T > &	if_false
	)

inline

Definition at line 226 of file valarray_utils.h.

References antioch_assert_equal_to.

 {
   antioch_assert_equal_to(condition.size(), if_true.size());
   antioch_assert_equal_to(condition.size(), if_false.size());
 
   const std::size_t size = condition.size();
   std::valarray<T> returnval(size);
 
   for (std::size_t i=0; i != size; ++i)
     returnval[i] = condition[i] ? if_true[i] : if_false[i];
 
   return returnval;
 }

template<typename Condition , typename T1 , typename T2 >

enable_if_c< is_eigen< T1 >::value &&is_eigen< T2 >::value, typename state_type< T1 >::type >::type Antioch::if_else	(	const Condition &	condition,
		const T1 &	if_true,
		const T2 &	if_false
	)

inline

Definition at line 250 of file eigen_utils.h.

 {
   return condition.select(if_true, if_false);
 }

template<typename T >

void Antioch::init_clone	(	T &	output,
		const T &	example
	)

inline

Definition at line 115 of file metaprogramming.h.

Referenced by init_clone(), init_constant(), Antioch::SIPrefixes< T >::operator=(), and Antioch::Units< T >::set_SI_converter().

115 { output = example; }

template<typename T >

void Antioch::init_clone	(	vex::vector< T > &	output,
		const vex::vector< T > &	example
	)

inline

Definition at line 186 of file vexcl_utils.h.

 {
   output.resize(example.queue_list(), example.size());
   output = example;
 }

template<typename T >

void Antioch::init_clone	(	std::valarray< T > &	output,
		const std::valarray< T > &	example
	)

inline

Definition at line 200 of file valarray_utils.h.

References init_clone().

 {
   const std::size_t sz = example.size();
   output.resize(sz);
   for (std::size_t i=0; i != sz; ++i)
     init_clone(output[i], example[i]);
 }

template<typename Vector , typename Scalar >

void Antioch::init_constant	(	Vector &	output,
		const Scalar &	example
	)

inline

Definition at line 119 of file metaprogramming.h.

References init_clone().

Referenced by Antioch::WilkeEvaluator< MixtureViscosity, ThermalConductivity, CoeffType >::compute_phi(), Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::D(), Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::k(), Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::mu(), Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::mu_and_k(), Antioch::MixtureAveragedTransportEvaluator< Diffusion, Viscosity, ThermalConductivity, CoeffType >::mu_and_k_and_D(), tester(), vectester(), and Antioch::SigmaBinConverter< VectorCoeffType >::y_on_custom_grid().

 {
   for (typename Antioch::size_type<Vector>::type i=0;
        i != output.size(); ++i)
     init_clone(output[i], example);
 }

template<typename T >

Antioch::enable_if_c< is_metaphysicl< T >::value, typename value_type< T >::type >::type Antioch::max ( const T & in )

inline

Definition at line 67 of file metaphysicl_utils.h.

References std::max(), and max().

 {
   using std::max;
 
   typename value_type<T>::type maxval = in[0];
   const std::size_t size = in.size();
   for (std::size_t i = 1; i < size; ++i)
     maxval = max(maxval, in[i]);
 
   return maxval;
 }

template<typename T >

Antioch::enable_if_c< is_eigen< T >::value, typename value_type< T >::type >::type Antioch::max ( const T & in )

inline

Definition at line 88 of file eigen_utils.h.

 {
   return in.maxCoeff();
 }

template<typename T >

T Antioch::max ( const vex::vector< T > & in )

inline

Definition at line 109 of file vexcl_utils.h.

 {
   vex::Reductor<T, vex::MAX> vex_max(in.queue_list());
   return vex_max(in);
 }

template<typename T >

T Antioch::max ( const std::valarray< T > & in )

inline

Definition at line 119 of file valarray_utils.h.

 {
   return in.max();
 }

template<typename T >

Antioch::enable_if_c< is_metaphysicl< T >::value, typename value_type< T >::type >::type Antioch::min ( const T & in )

inline

Definition at line 84 of file metaphysicl_utils.h.

References std::min(), and min().

 {
   using std::min;
 
   typename value_type<T>::type minval = in[0];
   const std::size_t size = in.size();
   for (std::size_t i = 1; i < size; ++i)
     minval = min(minval, in[i]);
 
   return minval;
 }

template<typename T >

Antioch::enable_if_c< is_eigen< T >::value, typename value_type< T >::type >::type Antioch::min ( const T & in )

inline

Definition at line 98 of file eigen_utils.h.

 {
   return in.minCoeff();
 }

template<typename T >

T Antioch::min ( const vex::vector< T > & in )

inline

Definition at line 118 of file vexcl_utils.h.

 {
   vex::Reductor<T, vex::MIN> vex_min(in.queue_list());
   return vex_min(in);
 }

template<typename T >

T Antioch::min ( const std::valarray< T > & in )

inline

Definition at line 127 of file valarray_utils.h.

 {
   return in.min();
 }

template<class NumericType >

void Antioch::read_blottner_data_ascii	(	MixtureViscosity< BlottnerViscosity< NumericType >, NumericType > &	mu,
		const std::string &	filename
	)

Definition at line 41 of file blottner_parsing.C.

References antioch_error, Antioch::ChemicalMixture< CoeffType >::chemical_mixture(), skip_comment_lines(), and Antioch::ChemicalMixture< CoeffType >::species_name_map().

Referenced by read_blottner_data_ascii_default(), and tester().

   {
     std::ifstream in(filename.c_str());
     if(!in.is_open())
       {
         std::cerr << "ERROR: unable to load file " << filename << std::endl;
         antioch_error();
       }
 
     // skip the header
     skip_comment_lines(in, '#');
 
     std::string name;
     NumericType a, b, c;
 
     while (in.good())
       {
         in >> name; // Species Name
         in >> a;    //
         in >> b;    //
         in >> c;    //
 
         // If we are still good, we have a valid set of transport
         // data for this species. Otherwise, we read past end-of-file
         // in the section above
         if (in.good())
           {
             const ChemicalMixture<NumericType>& chem_mixture = mu.chemical_mixture();
 
             // Check if this is a species we want.
             if( chem_mixture.species_name_map().find(name) !=
                 chem_mixture.species_name_map().end() )
               {
                 // Pack up coefficients
                 std::vector<NumericType> coeffs(3);
                 coeffs[0] = a;
                 coeffs[1] = b;
                 coeffs[2] = c;
                 mu.add(name, coeffs);
               }
           }
 
       }
     in.close();
     return;
   }

template<class NumericType >

void Antioch::read_blottner_data_ascii_default ( MixtureViscosity< BlottnerViscosity< NumericType >, NumericType > & mu )

Definition at line 90 of file blottner_parsing.C.

References Antioch::DefaultSourceFilename::blottner_data(), and read_blottner_data_ascii().

   {
     read_blottner_data_ascii(mu, DefaultFilename::blottner_data());
   }

template<class NumericType >

void Antioch::read_cea_mixture_data	(	CEAThermoMixture< NumericType > &	thermo,
		const std::string &	filename,
		ParsingType	type,
		bool	verbose = `true`
	)

Definition at line 41 of file cea_mixture_parsing.C.

References antioch_error, antioch_parsing_error, ASCII, Antioch::NASAThermoMixture< CoeffType, CEACurveFit< CoeffType > >::check(), CHEMKIN, Antioch::ParserBase< NumericType >::read_thermodynamic_data(), and XML.

Referenced by read_cea_mixture_data_ascii(), read_cea_mixture_data_ascii_default(), and tester().

   {
 
     ParserBase<NumericType> * parser(NULL);
     switch(type)
     {
       case ASCII:
          parser = new ASCIIParser<NumericType>(filename,verbose);
          break;
       case CHEMKIN:
          parser = new ChemKinParser<NumericType>(filename,verbose);
          break;
       case XML:
          parser = new XMLParser<NumericType>(filename,verbose);
          break;
       default:
          antioch_parsing_error("unknown type");
     }
 
     parser->read_thermodynamic_data(thermo);
    // Make sure we actually populated everything
     if( !thermo.check() )
     {
        std::cerr << "Error: CEA table not fully populated" << std::endl;
        antioch_error();
     }
   }

template void Antioch::read_cea_mixture_data< double >	(	CEAThermoMixture< double > &	,
		const std::string &	,
		ParsingType	,
		bool
	)

template void Antioch::read_cea_mixture_data< float >	(	CEAThermoMixture< float > &	,
		const std::string &	,
		ParsingType	,
		bool
	)

template void Antioch::read_cea_mixture_data< long double >	(	CEAThermoMixture< long double > &	,
		const std::string &	,
		ParsingType	,
		bool
	)

template<class NumericType >

void Antioch::read_cea_mixture_data_ascii	(	CEAThermoMixture< NumericType > &	thermo,
		const std::string &	filename
	)

Definition at line 45 of file cea_mixture_ascii_parsing.C.

References antioch_deprecated, ASCII, and read_cea_mixture_data().

Referenced by Antioch::CEAThermodynamics< CoeffType >::CEAThermodynamics(), and vectester().

   {
     antioch_deprecated();
     read_cea_mixture_data( thermo, filename, ASCII, true );
   }

template<class NumericType >

void Antioch::read_cea_mixture_data_ascii	(	CEAThermodynamics< NumericType > &	thermo,
		const std::string &	filename
	)

Definition at line 52 of file cea_mixture_ascii_parsing.C.

References antioch_deprecated, and Antioch::ASCIIParser< NumericType >::read_thermodynamic_data().

   {
     antioch_deprecated();
     ASCIIParser<NumericType> parser(filename);
     parser.read_thermodynamic_data(thermo);
   }

template<class NumericType >

void Antioch::read_cea_mixture_data_ascii_default ( CEAThermoMixture< NumericType > & thermo )

Definition at line 38 of file cea_mixture_ascii_parsing.C.

References antioch_deprecated, ASCII, read_cea_mixture_data(), and Antioch::DefaultSourceFilename::thermo_data().

   {
     antioch_deprecated();
     read_cea_mixture_data(thermo, DefaultFilename::thermo_data(), ASCII, true);
   }

template<class NumericType >

void Antioch::read_cea_thermo_data_ascii	(	CEAThermodynamics< NumericType > &	thermo,
		const std::string &	filename
	)

inline

Definition at line 40 of file cea_thermo_ascii_parsing.C.

References Antioch::CEAThermodynamics< CoeffType >::add_curve_fit(), antioch_error, Antioch::CEAThermodynamics< CoeffType >::check(), Antioch::CEAThermodynamics< CoeffType >::chemical_mixture(), skip_comment_lines(), and Antioch::ChemicalMixture< CoeffType >::species_name_map().

   {
     std::ifstream in(filename.c_str());
     if(!in.is_open())
     {
       std::cerr << "ERROR: unable to load file " << filename << std::endl;
       antioch_error();
     }
 
     skip_comment_lines(in, '#');
 
     std::string name;
     unsigned int n_int;
     std::vector<NumericType> coeffs;
     NumericType h_form, val;
 
     const ChemicalMixture<NumericType>& chem_mixture = thermo.chemical_mixture();
 
     while (in.good())
       {
         in >> name;   // Species Name
         in >> n_int;  // Number of T intervals: [200-1000], [1000-6000], ([6000-20000])
         in >> h_form; // Formation Enthalpy @ 298.15 K
 
         coeffs.clear();
         for (unsigned int interval=0; interval<n_int; interval++)
           {
             for (unsigned int n=0; n<10; n++)
               {
                 in >> val, coeffs.push_back(val);
               }
           }
 
         // If we are still good, we have a valid set of thermodynamic
         // data for this species. Otherwise, we read past end-of-file
         // in the section above
         if (in.good())
           {
             // Check if this is a species we want.
             if( chem_mixture.species_name_map().find(name) !=
                 chem_mixture.species_name_map().end() )
               {
                 thermo.add_curve_fit(name, coeffs);
               }
           }
       } // end while
 
     in.close();
 
     // Make sure we actually populated everything
     if( !thermo.check() )
       {
         std::cerr << "Error: CEA table not fully populated" << std::endl;
         antioch_error();
       }
   }

template<typename NumericType >

void Antioch::read_chemical_species_composition	(	ParserBase< NumericType > *	parser,
		ChemicalMixture< NumericType > &	mixture
	)

Definition at line 40 of file species_parsing.C.

References Antioch::ChemicalMixture< CoeffType >::initialize_species(), and Antioch::ParserBase< NumericType >::species_list().

   {
     std::vector<std::string> species = parser->species_list();
 
     mixture.initialize_species(species);
   }

template<class NumericType , typename CurveType >

void Antioch::read_nasa_mixture_data	(	NASAThermoMixture< NumericType, CurveType > &	thermo,
		const std::string &	filename = `DefaultSourceFilename::thermo_data()`,
		ParsingType	type = `ASCII`,
		bool	verbose = `true`
	)

Definition at line 42 of file nasa_mixture_parsing.C.

References antioch_error, antioch_parsing_error, ASCII, Antioch::NASAThermoMixture< CoeffType, NASAFit >::check(), CHEMKIN, Antioch::ParserBase< NumericType >::read_thermodynamic_data(), and XML.

Referenced by read_nasa_mixture_data_ascii(), AntiochTesting::NASA9XMLParsingTest< long double >::test_supplied_species(), AntiochTesting::NASA7XMLParsingTest< long double >::test_supplied_species(), test_type(), and tester().

   {
 
     ParserBase<NumericType> * parser(NULL);
     switch(type)
       {
       case ASCII:
         parser = new ASCIIParser<NumericType>(filename,verbose);
         break;
       case CHEMKIN:
         parser = new ChemKinParser<NumericType>(filename,verbose);
         break;
       case XML:
         parser = new XMLParser<NumericType>(filename,verbose);
         break;
       default:
         antioch_parsing_error("unknown type");
       }
 
     parser->read_thermodynamic_data(thermo);
 
     // Make sure we actually populated everything
     if( !thermo.check() )
       {
         std::cerr << "Error: NASA table not fully populated" << std::endl;
         antioch_error();
       }
 
     return;
   }

template<class NumericType >

void Antioch::read_nasa_mixture_data_ascii	(	NASAThermoMixture< NumericType, NASA7CurveFit< NumericType > > &	thermo,
		const std::string &	filename
	)

Definition at line 74 of file nasa_mixture_parsing.C.

References antioch_deprecated, CHEMKIN, and read_nasa_mixture_data().

   {
     antioch_deprecated();
     read_nasa_mixture_data( thermo, filename, CHEMKIN, true);
   }

template void Antioch::read_nasa_mixture_data_ascii< double >	(	NASAThermoMixture< double, NASA7CurveFit< double > > &	,
		const std::string &
	)

template void Antioch::read_nasa_mixture_data_ascii< float >	(	NASAThermoMixture< float, NASA7CurveFit< float > > &	,
		const std::string &
	)

template void Antioch::read_nasa_mixture_data_ascii< long double >	(	NASAThermoMixture< long double, NASA7CurveFit< long double > > &	,
		const std::string &
	)

template<typename NumericType >

void Antioch::read_reaction_set_data	(	const std::string &	filename,
		const bool	verbose,
		ReactionSet< NumericType > &	reaction_set,
		ParsingType	type = `ASCII`
	)

Definition at line 77 of file read_reaction_set_data.C.

   {
     ParserBase<NumericType> * parser(NULL);
     switch(type)
       {
       case ASCII:
         parser = new ASCIIParser<NumericType>(filename,verbose);
         break;
       case CHEMKIN:
         parser = new ChemKinParser<NumericType>(filename,verbose);
         break;
       case XML:
         parser = new XMLParser<NumericType>(filename,verbose);
         break;
       default:
         antioch_parsing_error("unknown type");
       }
 
     //error or no reaction data
     if(!parser->initialize())return;
 
     const ChemicalMixture<NumericType>& chem_mixture = reaction_set.chemical_mixture();
     unsigned int n_species = chem_mixture.n_species();
     // Sanity Check on species
     /*
       tinyxml2::XMLElement* species = element->FirstChildElement("phase");
       species = species->FirstChildElement("speciesArray");
 
       std::vector<std::string> species_names;
 
       std::cout << species->GetText() << std::endl;
 
       SplitString(std::string(species->GetText()),
       " ",
       species_names,
       false);
 
 
       if( n_species != species_names.size() )
       {
       std::cerr << "Error: Mismatch in n_species and the number of species specified in" << std::endl
       << "       the kinetics XML file " << filename << std::endl
       << "       Found species: " << species->GetText() << std::endl;
       antioch_error();
       }
     */
 
     std::map<std::string,KineticsModel::KineticsModel> kin_keyword;
     kin_keyword["Constant"]               = KineticsModel::CONSTANT;
     kin_keyword["HercourtEssen"]          = KineticsModel::HERCOURT_ESSEN;
     kin_keyword["Berthelot"]              = KineticsModel::BERTHELOT;
     kin_keyword["Arrhenius"]              = KineticsModel::ARRHENIUS;
     kin_keyword["BerthelotHercourtEssen"] = KineticsModel::BHE;
     kin_keyword["Kooij"]                  = KineticsModel::KOOIJ;
     kin_keyword["ModifiedArrhenius"]      = KineticsModel::KOOIJ;  //for Arrhenius fans
     kin_keyword["VantHoff"]               = KineticsModel::VANTHOFF;
     kin_keyword["photochemistry"]         = KineticsModel::PHOTOCHEM;
 
     std::map<KineticsModel::KineticsModel,unsigned int> kinetics_model_map;
     kinetics_model_map[KineticsModel::CONSTANT]       = 0;
     kinetics_model_map[KineticsModel::HERCOURT_ESSEN] = 1;
     kinetics_model_map[KineticsModel::BERTHELOT]      = 2;
     kinetics_model_map[KineticsModel::ARRHENIUS]      = 3;
     kinetics_model_map[KineticsModel::BHE]            = 4;
     kinetics_model_map[KineticsModel::KOOIJ]          = 5;
     kinetics_model_map[KineticsModel::VANTHOFF]       = 7;
     kinetics_model_map[KineticsModel::PHOTOCHEM]      = 8;
 
     std::vector<std::string> models;
     models.push_back("Constant");
     models.push_back("HercourtEssen");
     models.push_back("Berthelot");
     models.push_back("Arrhenius");
     models.push_back("BerthelotHercourtEssen");
     models.push_back("Kooij");
     models.push_back("ModifiedArrhenius");
     models.push_back("VantHoff");
     models.push_back("photochemistry");
 
     std::map<std::string,ReactionType::ReactionType> proc_keyword;
     proc_keyword["Elementary"]                 = ReactionType::ELEMENTARY;
     proc_keyword["Duplicate"]                  = ReactionType::DUPLICATE;
     proc_keyword["ThreeBody"]                  = ReactionType::THREE_BODY;
     proc_keyword["threeBody"]                  = ReactionType::THREE_BODY; // Cantera/backward compatiblity
     proc_keyword["LindemannFalloff"]           = ReactionType::LINDEMANN_FALLOFF;
     proc_keyword["TroeFalloff"]                = ReactionType::TROE_FALLOFF;
     proc_keyword["LindemannFalloffThreeBody"]  = ReactionType::LINDEMANN_FALLOFF_THREE_BODY;
     proc_keyword["TroeFalloffThreeBody"]       = ReactionType::TROE_FALLOFF_THREE_BODY;
 
     while (parser->reaction())
       {
         if (verbose) std::cout << "Reaction \"" << parser->reaction_id() << "\":\n"
                                << " eqn: " << parser->reaction_equation()
                                << std::endl;
 
         ReactionType::ReactionType typeReaction(ReactionType::ELEMENTARY);
         KineticsModel::KineticsModel kineticsModel(KineticsModel::HERCOURT_ESSEN); // = 0
 
         if (!parser->reaction_chemical_process().empty())
           {
             if (verbose) std::cout << " type: " << parser->reaction_chemical_process() << std::endl;
             if(!proc_keyword.count(parser->reaction_chemical_process()))
               {
                 std::cerr << "Implemented chemical processes are:\n"
                           << "  Elementary (default)\n"
                           << "  Duplicate\n"
                           << "  ThreeBody\n"
                           << "  LindemannFalloff\n"
                           << "  TroeFalloff\n"
                           << "  LindemannFalloffThreeBody\n"
                           << "  TroeFalloffThreeBody\n"
                           << "See Antioch documentation for more details."
                           << std::endl;
                 antioch_not_implemented();
               }
             typeReaction = proc_keyword[parser->reaction_chemical_process()];
           }
 
         bool reversible(parser->reaction_reversible());
         if (verbose) std::cout << "reversible: " << reversible << std::endl;
 
         kineticsModel = kin_keyword[parser->reaction_kinetics_model(models)];
         const std::string reading_kinetics_model = parser->reaction_kinetics_model(models);
 
         // usually Kooij is called Arrhenius, check here
         if(kineticsModel == KineticsModel::ARRHENIUS)
           {
             if(parser->verify_Kooij_in_place_of_Arrhenius())
               {
                 kineticsModel = KineticsModel::KOOIJ;
                 antioch_do_once(
                                 std::cout << "In reaction(s) including " << parser->reaction_id() << "\n"
                                 << "An equation of the form \"A * (T/Tref)^beta * exp(-Ea/(R*T))\" is a Kooij equation,\n"
                                 << "I guess a modified Arrhenius could be a name too.  Whatever, the correct label is\n"
                                 << "\"Kooij\", or, << à la limite >> \"ModifiedArrhenius\".  Please use those terms instead,\n"
                                 << "thanks and a good day to you, user." << std::endl;
                                 ); // antioch_do_once
               }
           }
 
         // construct a Reaction object
         Reaction<NumericType>* my_rxn = build_reaction<NumericType>(n_species, parser->reaction_equation(),
                                                                     reversible,typeReaction,kineticsModel);
         my_rxn->set_id(parser->reaction_id());
 
         // We will add the reaction, unless we do not have a
         // reactant or product
         bool relevant_reaction = true;
         NumericType order_reaction(0);
         std::vector<std::pair<std::string,int> > molecules_pairs;
 
         if(parser->reactants_pairs(molecules_pairs))
           {
 
             std::map<std::string,NumericType> orders = parser->reactants_orders();
             if (verbose)
               {
                 std::cout << "\n   reactants: ";
                 for(unsigned int ir = 0; ir < molecules_pairs.size(); ir++)
                 {
                   NumericType order = (orders.count(molecules_pairs[ir].first))?orders.at(molecules_pairs[ir].first):static_cast<NumericType>(molecules_pairs[ir].second);
                   std::cout << molecules_pairs[ir].first << ":" << molecules_pairs[ir].second << "," << order << ", ";
                 }
               }
 
             for( unsigned int p=0; p < molecules_pairs.size(); p++ )
               {
                 if(molecules_pairs[p].first == "e-") molecules_pairs[p].first = "e";
 
                 if(verbose) std::cout  << "\n    " << molecules_pairs[p].first << " " << molecules_pairs[p].second;
 
                 if( !chem_mixture.species_name_map().count( molecules_pairs[p].first ) )
                   {
                     relevant_reaction = false;
                     if (verbose) std::cout << "\n     -> skipping this reaction (no reactant " << molecules_pairs[p].first << ")";
                   }
                 else
                   {
                     NumericType order = (orders.count(molecules_pairs[p].first))?orders.at(molecules_pairs[p].first):static_cast<NumericType>(molecules_pairs[p].second);
                     my_rxn->add_reactant( molecules_pairs[p].first,
                                           chem_mixture.species_name_map().find( molecules_pairs[p].first )->second,
                                           molecules_pairs[p].second, order );
                     order_reaction += order;
                   }
               }
           }
 
         molecules_pairs.clear();
         if(parser->products_pairs(molecules_pairs))
           {
 
             std::map<std::string,NumericType> orders = parser->products_orders();
             if(verbose) std::cout << "\n   products: ";
             for(unsigned int ir = 0; ir < molecules_pairs.size(); ir++)
             {
               NumericType order = (orders.count(molecules_pairs[ir].first))?orders.at(molecules_pairs[ir].first):static_cast<NumericType>(molecules_pairs[ir].second);
               std::cout << molecules_pairs[ir].first << ":" << molecules_pairs[ir].second << "," << order << ", ";
             }
 
             for (unsigned int p=0; p < molecules_pairs.size(); p++)
               {
                 if(molecules_pairs[p].first == "e-") molecules_pairs[p].first = "e";
 
                 if(verbose) std::cout  << "\n    " << molecules_pairs[p].first << " " << molecules_pairs[p].second;
 
                 if( !chem_mixture.species_name_map().count( molecules_pairs[p].first ) )
                   {
                     relevant_reaction = false;
                     if (verbose) std::cout << "\n     -> skipping this reaction (no product " << molecules_pairs[p].first << ")";
                   }
                 else
                   {
                     NumericType order = (orders.count(molecules_pairs[p].first))?orders.at(molecules_pairs[p].first):static_cast<NumericType>(molecules_pairs[p].second);
                     my_rxn->add_product( molecules_pairs[p].first,
                                          chem_mixture.species_name_map().find( molecules_pairs[p].first )->second,
                                          molecules_pairs[p].second, order );
                   }
               }
             if(verbose) std::cout << std::endl;
           }
 
         if(!relevant_reaction)
           {
             if(verbose) std::cout << "skipped reaction\n\n";
             delete my_rxn;
             continue;
           }
 
         while(parser->rate_constant(reading_kinetics_model)) //for duplicate and falloff models, several kinetics rate to load, no mixing allowed
           {
 
             /* Any data is formatted by the parser method.
              * For any data required, parser sends back:
              *    - true/false if data is found
              *    - value of data
              *    - unit of data if found, empty string else
              *    - default unit of data
              *
              * The parser defines the defaults, note the special case
              * of the pre-exponential parameters:
              *  its unit is [quantity-1]^(order - 1)/s, thus the parser
              *  defines only the [quantity-1] unit (SI unit is m^3/mol)
              *  as default.
              */
 
             std::vector<NumericType> data; // for rate constant
 
             Units<NumericType> def_unit;
             int pow_unit(order_reaction - 1);
             bool is_falloff(false);
             bool is_k0(false);
             //threebody always
             if(my_rxn->type() == ReactionType::THREE_BODY)pow_unit++;
             //falloff for k0
             if(my_rxn->type() == ReactionType::LINDEMANN_FALLOFF ||
                my_rxn->type() == ReactionType::TROE_FALLOFF      ||
                my_rxn->type() == ReactionType::LINDEMANN_FALLOFF_THREE_BODY ||
                my_rxn->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
               {
                 is_falloff = verbose;
                 //k0 is either determined by an explicit name, or is the first of unnamed rate constants
                 if(parser->is_k0(my_rxn->n_rate_constants(),reading_kinetics_model))
                 {
                   pow_unit++;
                   is_k0 = verbose;
                 }
               }
 
             NumericType par_value(-1.);
             std::vector<NumericType> par_values;
             std::string par_unit;
             std::string default_unit;
             std::vector<std::string> accepted_unit;
 
             // verbose as we read along
             if(verbose)std::cout << " rate: " << models[kinetics_model_map[kineticsModel]] << " model\n";
             if(is_falloff){
               (is_k0)?std::cout << "  Low pressure limit rate constant\n":std::cout << "  High pressure limit rate constant\n";
             }
 
             // pre-exponential
             if(parser->rate_constant_preexponential_parameter(par_value, par_unit, default_unit))
               {
                 // using Units object to build accepted_unit
                 accepted_unit.clear();
                 def_unit.set_unit("m3/mol");
                 //to the m-1 power
                 if(pow_unit != 0)
                   {
                     def_unit *= pow_unit;
                   }else
                   {
                     def_unit.clear();
                   }
                 def_unit.substract("s");    // per second
                 accepted_unit.push_back(def_unit.get_symbol());
 
                 def_unit.set_unit(default_unit);
                 //to the m-1 power
                 if(pow_unit != 0)
                   {
                     def_unit *= pow_unit;
                   }else
                   {
                     def_unit.clear();
                   }
                 def_unit.substract("s");    // per second
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "A");
                 if(verbose)
                   {
                     std::cout  << "   A: " << par_value
                                << " "      << def_unit.get_symbol() << std::endl;
                   }
                 data.push_back(par_value * def_unit.get_SI_factor());
               }
 
             // beta
             if(parser->rate_constant_power_parameter(par_value,par_unit,default_unit))
               {
                 accepted_unit.clear();
                 accepted_unit.push_back("");
                 def_unit.set_unit(default_unit);
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "beta");
                 if(par_value == 0.)//if ARRHENIUS parameterized as KOOIJ, bad test, need to rethink it
                   {
                     std::cerr << "In reaction " << parser->reaction_id() << "\n"
                               << "An equation of the form \"A * exp(-Ea/(R*T))\" is an Arrhenius equation,\n"
                               << "and most certainly not a Kooij one\n"
                               << "it has been corrected, but please, change that in your file.\n"
                               << "Thanks and a good day to you, user." << std::endl;
                     kineticsModel = KineticsModel::ARRHENIUS;
                   }else
                   {
                     data.push_back(par_value * def_unit.get_SI_factor());
                   }
                 if(verbose)
                   {
                     std::cout << "   b: " << par_value << std::endl;
                   }
               }
 
             // activation energy
             if(parser->rate_constant_activation_energy_parameter(par_value,par_unit,default_unit))
               {
                 accepted_unit.clear();
                 accepted_unit.push_back("J/mol");
                 accepted_unit.push_back("K");
                 def_unit.set_unit(default_unit);
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "Ea");
                 data.push_back(par_value * def_unit.get_SI_factor());
                 if(verbose)
                   {
                     std::cout << "   E: " << par_value
                               << " "      << def_unit.get_symbol() << std::endl;
                   }
               }
 
 
             // Berthelot coefficient (D)
             if(parser->rate_constant_Berthelot_coefficient_parameter(par_value,par_unit,default_unit))
               {
                 accepted_unit.clear();
                 accepted_unit.push_back("K");
                 def_unit.set_unit(default_unit);
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "D");
                 data.push_back(par_value * def_unit.get_SI_factor());
                 if(verbose)
                   {
                     std::cout << "   D: " << par_value
                               << " "      << def_unit.get_symbol() << std::endl;
                   }
               }
 
             // Tref, not for everyone
             if(kineticsModel == KineticsModel::HERCOURT_ESSEN ||
                kineticsModel == KineticsModel::BHE            ||
                kineticsModel == KineticsModel::KOOIJ          ||
                kineticsModel == KineticsModel::VANTHOFF)
               {
                 par_value = 1.;
                 if(parser->rate_constant_Tref_parameter(par_value,par_unit,default_unit))
                   {
                     accepted_unit.clear();
                     accepted_unit.push_back("K");
                     def_unit.set_unit(default_unit);
                     verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "Tref");
                   }else
                   {
                     antioch_parameter_required("Tref","1 K");
                   }
                 data.push_back(par_value);
               }
 
             // scale E -> E/R
             if(kineticsModel == KineticsModel::ARRHENIUS ||
                kineticsModel == KineticsModel::KOOIJ     ||
                kineticsModel == KineticsModel::VANTHOFF)
               {
                 parser->rate_constant_activation_energy_parameter(par_value,par_unit,default_unit);
                 (par_unit.empty())?def_unit.set_unit(default_unit):def_unit.set_unit(par_unit);
                 // now finding R unit: [Ea] / [K]
                 def_unit.substract("K");
 
                 par_value = (def_unit.is_united())?
                   Antioch::Constants::R_universal<NumericType>() // Ea already tranformed in SI
                   :1.L;  // no unit, so Ea already in K
                 data.push_back(par_value);
               }
 
             //photochemistry
             // lambda is either a length (def nm) or cm-1
             // cross-section has several possibilities if given
             //   * cm2 per bin:
             //            - length (typically nm) or cm-1
             //   * cm2 no bin given:
             //            - if given, lambda unit
             //            - if not, nm
 
             // starting with lambda (for bin unit in cross-section)
             // lambda is not in SI (m is really to violent), it will be nm
             if(parser->rate_constant_lambda_parameter(par_values,par_unit,default_unit))
               {
                 antioch_assert_equal_to(kineticsModel,KineticsModel::PHOTOCHEM);
                 accepted_unit.clear();
                 accepted_unit.push_back("nm");
                 accepted_unit.push_back("cm-1");
                 def_unit.set_unit(default_unit);
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "lambda");
 
                 data.clear();
 
                 if(def_unit.is_homogeneous("nm"))// it's a length
                   {
                     for(unsigned int il = 0; il < par_values.size(); il++)
                       {
                         data.push_back(par_values[il] * def_unit.factor_to_some_unit("nm"));
                       }
                   }else // it's the inverse of a length
                   {
                     for(unsigned int il = 0; il < par_values.size(); il++)
                       {
                         data.push_back(1.L/(par_values[il] * def_unit.factor_to_some_unit("nm-1")));
                       }
                   }
 
                 //now the cross-section
 
                 NumericType bin_coefficient = (def_unit.is_homogeneous("nm"))?def_unit.factor_to_some_unit("nm"):
                   def_unit.factor_to_some_unit("nm-1");
                 if(!parser->rate_constant_cross_section_parameter(par_values,par_unit,default_unit))
                   {
                     std::cerr << "Where is the cross-section?  In what universe have you photochemistry with a wavelength grid and no cross-section on it?" << std::endl;
                     antioch_error();
                   }
                 //test length
                 if(par_values.size() != data.size())
                   {
                     std::cerr << "Your cross-section vector and your lambda vector don't have the same size!\n"
                               << "What am I supposed to do with that?"
                               << std::endl;
                     antioch_error();
                   }
 
                 /* here we will use two def unit:
                  * cs_unit, cm2 by default
                  * bin_unit, nm by default.
                  *
                  * strict rigorous unit is
                  *         - (cs_unit - bin_unit): cm2/nm
                  * correct unit is
                  *         - cs_unit: cm2
                  *
                  * so we need to test against those two possibilities.
                  * Now the funny part is that we test homogeneity, not
                  * equality, for generality purposes, so in case of strict
                  * rigorous unit, we need to decompose the read_unit into
                  * cross_section and bin units, so we can make the appropriate change.
                  *
                  * !TODO make the decomposition instead of strict equality
                  */
 
                 accepted_unit.clear();
                 accepted_unit.push_back("cm2");       // only cross-section
                 accepted_unit.push_back("cm2/nm");    // per bin, bin is length-like
                 accepted_unit.push_back("cm2/nm-1");  // per bin, bin is inverse length-like
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_rxn->equation(), "cross-section");
 
 
                 if(def_unit.is_homogeneous("cm2")) // gotta use the bin unit, real unit is [cs]/[provided bin unit]
                   {
                     for(unsigned int ics = 0; ics < par_values.size(); ics++)
                       {
                         data.push_back(par_values[ics] * def_unit.get_SI_factor() / bin_coefficient); //cs in SI, bin in nm or nm-1
                       }
                   }else                              // bin unit is provided
                   {
                     std::string target_unit = (def_unit.is_homogeneous("cm2/nm"))?"m2/nm":"m2/nm-1";
                     for(unsigned int ics = 0; ics < par_values.size(); ics++)
                       {
                         data.push_back(par_values[ics] * def_unit.factor_to_some_unit(target_unit));
                       }
                   }
 
               } //end photochemistry
 
             if(data.empty()) //replace the old "if no A parameters" as A is not required anymore
               {
                 std::cerr << "Somehow, I have a bad feeling about a chemical reaction without any data parameters...\n"
                           << "This is too sad, I give up...\n"
                           << "Please, check the reaction " << my_rxn->equation() << " before coming back to me." << std::endl;
                 antioch_error(); //HEY!!!
               }
 
             KineticsType<NumericType>* rate = build_rate<NumericType>(data,kineticsModel);
 
             my_rxn->add_forward_rate(rate);
 
           } //end of duplicate/falloff kinetics description loop
 
         // for falloff, we need a way to know which rate constant is the low pressure limit
         // and which is the high pressure limit
         // usually by calling the low pressure limite "k0". If nothing given, by default
         // the first rate constant encountered is the low limit,
         // so we need to change something only if the second rate constant has a "name" attribute
         // of value "k0"
         if(my_rxn->type() == ReactionType::LINDEMANN_FALLOFF            ||
            my_rxn->type() == ReactionType::TROE_FALLOFF                 ||
            my_rxn->type() == ReactionType::LINDEMANN_FALLOFF_THREE_BODY ||
            my_rxn->type() == ReactionType::TROE_FALLOFF_THREE_BODY)
           {
             antioch_assert_equal_to(my_rxn->n_rate_constants(),2);
             if(parser->where_is_k0(reading_kinetics_model) == 1) // second given is k0
               {
                 my_rxn->swap_forward_rates(0,1);
               }
           }
 
 
         std::vector<std::pair<std::string,NumericType> > efficiencies;
         //efficiencies are only for three body reactions
         if(parser->efficiencies(efficiencies))
           {
             antioch_assert(ReactionType::THREE_BODY == my_rxn->type()                   ||
                            ReactionType::LINDEMANN_FALLOFF_THREE_BODY == my_rxn->type() ||
                            ReactionType::TROE_FALLOFF_THREE_BODY == my_rxn->type());
 
             for(unsigned int p = 0; p < efficiencies.size(); p++)
               {
                 if(verbose)std::cout  << "\n" << efficiencies[p].first << " " << efficiencies[p].second;
 
                 if(efficiencies[p].first == "e-") efficiencies[p].first = "e";
 
                 // it is possible that the efficiency is specified for a species we are not
                 // modeling - so only add the efficiency if it is included in our list
                 if( chem_mixture.species_name_map().count( efficiencies[p].first ) )
                   {
                     my_rxn->set_efficiency( efficiencies[p].first,
                                             chem_mixture.species_name_map().find( efficiencies[p].first )->second,
                                             efficiencies[p].second );
                   }
               }
             if(verbose)std::cout << std::endl;
           }
 
         //F parameters only for Troe falloff
         if(parser->Troe())
           {
             antioch_assert(ReactionType::TROE_FALLOFF == my_rxn->type() ||
                            ReactionType::TROE_FALLOFF_THREE_BODY == my_rxn->type());
 
             FalloffReaction<NumericType,TroeFalloff<NumericType> > *my_fall_rxn =
               static_cast<FalloffReaction<NumericType,TroeFalloff<NumericType> > *> (my_rxn);
 
             Units<NumericType> def_unit;
             NumericType par_value(-1.);
             std::string par_unit;
             std::string default_unit;
             std::vector<std::string> accepted_unit;
 
             // alpha
             if(!parser->Troe_alpha_parameter(par_value,par_unit,default_unit))
               {
                 std::cerr << "alpha parameter of Troe falloff missing!" << std::endl;
                 antioch_error();
               }
             accepted_unit.clear();
             accepted_unit.push_back("");
             def_unit.set_unit(default_unit);
             verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_fall_rxn->equation(), "alpha");
             my_fall_rxn->F().set_alpha(par_value * def_unit.get_SI_factor());
 
             // T***
             if(!parser->Troe_T3_parameter(par_value,par_unit,default_unit))
               {
                 std::cerr << "T*** parameter of Troe falloff missing!" << std::endl;
                 antioch_error();
               }
             accepted_unit.clear();
             accepted_unit.push_back("K");
             def_unit.set_unit(default_unit);
             verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_fall_rxn->equation(), "T***");
             my_fall_rxn->F().set_T3(par_value * def_unit.get_SI_factor());
 
             // T*
             if(!parser->Troe_T1_parameter(par_value,par_unit,default_unit))
               {
                 std::cerr << "T* parameter of Troe falloff missing!" << std::endl;
                 antioch_error();
               }
             // accepted unit is the same
             def_unit.set_unit(default_unit);
             verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_fall_rxn->equation(), "T*");
             my_fall_rxn->F().set_T1(par_value * def_unit.get_SI_factor());
 
             // T** is optional
             if(parser->Troe_T2_parameter(par_value,par_unit,default_unit))
               {
                 def_unit.set_unit(default_unit);
                 verify_unit_of_parameter(def_unit, par_unit, accepted_unit, my_fall_rxn->equation(), "T**");
                 my_fall_rxn->F().set_T2(par_value * def_unit.get_SI_factor());
               }
           }
 
         reaction_set.add_reaction(my_rxn);
 
         if(verbose) std::cout << "\n\n";
       }
 
     if(parser)
       delete parser;
   }

template<class NumericType >

void Antioch::read_reaction_set_data_chemkin	(	const std::string &	filename,
		const bool	verbose,
		ReactionSet< NumericType > &	reaction_set
	)

inline

Definition at line 149 of file read_reaction_set_data.h.

References CHEMKIN.

   {
      read_reaction_set_data<NumericType>(filename,verbose,reaction_set,CHEMKIN);
   }

template<class NumericType >

void Antioch::read_reaction_set_data_xml	(	const std::string &	filename,
		const bool	verbose,
		ReactionSet< NumericType > &	reaction_set
	)

inline

Definition at line 140 of file read_reaction_set_data.h.

References XML.

   {
      read_reaction_set_data<NumericType >(filename,verbose,reaction_set,XML);
   }

template<class NumericType >

void Antioch::read_species_data	(	ParserBase< NumericType > *	parser,
		ChemicalMixture< NumericType > &	chem_mixture
	)

Definition at line 49 of file species_parsing.C.

References antioch_error, Antioch::ChemicalMixture< CoeffType >::chemical_species(), Antioch::ParserBase< NumericType >::file(), Antioch::ParserBase< NumericType >::read_chemical_species(), Antioch::ChemicalMixture< CoeffType >::species_inverse_name_map(), and Antioch::ChemicalMixture< CoeffType >::species_list().

   {
     parser->read_chemical_species(chem_mixture);
 
     // sanity check, we require these informations
     bool fail(false);
     for(unsigned int s = 0; s < chem_mixture.chemical_species().size(); s++)
       {
         if(!chem_mixture.chemical_species()[s])
           {
             fail = true;
             break;
           }
       }
     if(fail)
       {
         std::cerr << "Molecule(s) is(are) missing.  Please update the information."
                   << "  Currently using file " << parser->file() << ".\n"
                   << "Missing molecule(s) is(are):" << std::endl;
         for(unsigned int i = 0; i < chem_mixture.species_list().size(); i++)
           {
             if(!chem_mixture.chemical_species()[i])
               {
                 std::cerr << chem_mixture.species_inverse_name_map().at(i) << std::endl;
               }
           }
         antioch_error();
       }
   }

template<class NumericType >

void Antioch::read_species_electronic_data	(	ParserBase< NumericType > *	parser,
		ChemicalMixture< NumericType > &	chem_mixture
	)

Definition at line 103 of file species_parsing.C.

References Antioch::ChemicalMixture< CoeffType >::chemical_species(), Antioch::ParserBase< NumericType >::file(), and Antioch::ParserBase< NumericType >::read_electronic_data().

   {
     parser->read_electronic_data(chem_mixture);
 
     // sanity check, we check these informations
     std::vector<std::string> missing;
     for(unsigned int s = 0; s < chem_mixture.chemical_species().size(); s++)
       {
         if(chem_mixture.chemical_species()[s]->theta_e().empty())missing.push_back(chem_mixture.chemical_species()[s]->species());
       }
     if(!missing.empty())
       {
         std::cerr << "WARNING:\nElectronic levels are missing.  Please update the information."
                   << "  Currently using file " << parser->file() << ".\n"
                   << "Missing molecule(s) is(are):" << std::endl;
         for(unsigned int m = 0; m < missing.size(); m++)std::cerr << missing[m] << std::endl;
       }
   }

template<class NumericType >

void Antioch::read_species_vibrational_data	(	ParserBase< NumericType > *	parser,
		ChemicalMixture< NumericType > &	chem_mixture
	)

Definition at line 81 of file species_parsing.C.

References Antioch::ChemicalMixture< CoeffType >::chemical_species(), Antioch::ParserBase< NumericType >::file(), and Antioch::ParserBase< NumericType >::read_vibrational_data().

   {
     parser->read_vibrational_data(chem_mixture);
 
     // sanity check, we check these informations
     std::vector<std::string> missing;
     for(unsigned int s = 0; s < chem_mixture.chemical_species().size(); s++)
       {
         if(chem_mixture.chemical_species()[s]->theta_v().empty())missing.push_back(chem_mixture.chemical_species()[s]->species());
       }
     if(!missing.empty())
       {
         std::cout << "WARNING:\nVibrational levels are missing.  Please update the information."
                   << "  Currently using file " << parser->file() << ".\n"
                   << "Missing molecule(s) is(are):" << std::endl;
         for(unsigned int m = 0; m < missing.size(); m++)std::cerr << missing[m] << std::endl;
       }
   }

template<class NumericType >

void Antioch::read_sutherland_data_ascii	(	MixtureViscosity< SutherlandViscosity< NumericType >, NumericType > &	mu,
		const std::string &	filename
	)

Definition at line 42 of file sutherland_parsing.C.

References antioch_error, Antioch::ChemicalMixture< CoeffType >::chemical_mixture(), skip_comment_lines(), and Antioch::ChemicalMixture< CoeffType >::species_name_map().

Referenced by read_sutherland_data_ascii_default().

   {
     std::ifstream in(filename.c_str());
     if(!in.is_open())
       {
         std::cerr << "ERROR: unable to load file " << filename << std::endl;
         antioch_error();
       }
 
     // skip the header
     skip_comment_lines(in, '#');
 
     std::string name;
     NumericType a, b;
 
     while (in.good())
       {
         in >> name; // Species Name
         in >> a;    //
         in >> b;    //
 
         // If we are still good, we have a valid set of transport
         // data for this species. Otherwise, we read past end-of-file
         // in the section above
         if (in.good())
           {
             const ChemicalMixture<NumericType>& chem_mixture = mu.chemical_mixture();
 
             // Check if this is a species we want.
             if( chem_mixture.species_name_map().find(name) !=
                 chem_mixture.species_name_map().end() )
               {
                 // Pack up coefficients
                 std::vector<NumericType> coeffs(2);
                 coeffs[0] = a;
                 coeffs[1] = b;
                 mu.add(name, coeffs);
               }
           }
       }
     in.close();
   }

template<class NumericType >

void Antioch::read_sutherland_data_ascii_default ( MixtureViscosity< SutherlandViscosity< NumericType >, NumericType > & mu )

Definition at line 87 of file sutherland_parsing.C.

References read_sutherland_data_ascii(), and Antioch::DefaultSourceFilename::sutherland_data().

   {
     read_sutherland_data_ascii(mu, DefaultFilename::sutherland_data());
   }

template<typename NumericType >

void Antioch::read_transport_species_data	(	ParserBase< NumericType > *	parser,
		TransportMixture< NumericType > &	transport
	)

Definition at line 37 of file transport_species_parsing.C.

References Antioch::ParserBase< NumericType >::file(), Antioch::TransportMixture< CoeffType >::n_species(), Antioch::ParserBase< NumericType >::read_transport_data(), Antioch::TransportMixture< CoeffType >::species_inverse_name_map(), and Antioch::TransportMixture< CoeffType >::transport_species().

Referenced by read_transport_species_data_ascii(), and Antioch::TransportMixture< CoeffType >::TransportMixture().

   {
     parser->read_transport_data(transport);
 
     // sanity check, we may require these informations
     bool fail(false);
     for(unsigned int s = 0; s < transport.n_species(); s++)
       {
         if(!transport.transport_species()[s])
           {
             fail = true;
             break;
           }
       }
     if(fail)
       {
         std::cerr << "Molecule(s) is(are) missing in transport description.  Please update the information."
                   << "  Currently using file " << parser->file() << ".\n"
                   << "You might have some problem later if you need these description.  "
                   << "Missing molecule(s) is(are):" << std::endl;
         for(unsigned int i = 0; i < transport.n_species(); i++)
           {
             if(!transport.transport_species()[i])
               {
                 std::cerr << transport.species_inverse_name_map().at(i) << std::endl;
               }
           }
       }
   }

template void Antioch::read_transport_species_data< double >	(	ParserBase< double > *	,
		TransportMixture< double > &
	)

template void Antioch::read_transport_species_data< float >	(	ParserBase< float > *	,
		TransportMixture< float > &
	)

template void Antioch::read_transport_species_data< long double >	(	ParserBase< long double > *	,
		TransportMixture< long double > &
	)

template<typename NumericType >

void Antioch::read_transport_species_data_ascii	(	TransportMixture< NumericType > &	transport,
		const std::string &	filename
	)

Definition at line 68 of file transport_species_parsing.C.

References antioch_deprecated, and read_transport_species_data().

   {
     antioch_deprecated();
 
     ASCIIParser<NumericType> parser(filename,true);
 
     read_transport_species_data( &parser, transport);
   }

template void Antioch::read_transport_species_data_ascii< double >	(	TransportMixture< double > &	,
		const std::string &
	)

template void Antioch::read_transport_species_data_ascii< float >	(	TransportMixture< float > &	,
		const std::string &
	)

template void Antioch::read_transport_species_data_ascii< long double >	(	TransportMixture< long double > &	,
		const std::string &
	)

void Antioch::remove_newline_from_strings ( std::vector< std::string > & strings )

Strips newline characters from strings in the input vector, strings.

Note that if an element of the vector is only the newline character, that element will be removed from the vector.

Definition at line 56 of file string_utils.C.

Referenced by Antioch::XMLParser< NumericType >::read_thermodynamic_data_root(), Antioch::XMLParser< NumericType >::species_list(), and AntiochTesting::StringUtilitiesTest::test_strip_newlines().

   {
     std::string newline_str = "\n";
 
     // First, detect any elements that are purely newlines, cache their iterator position,
     // and them remove them.
     std::vector<std::vector<std::string>::iterator> its_to_be_removed;
 
     for( std::vector<std::string>::iterator it = strings.begin(); it != strings.end(); ++it )
       if( (*it) == newline_str )
         its_to_be_removed.push_back(it);
 
     for(  std::vector<std::vector<std::string>::iterator>::iterator it = its_to_be_removed.begin();
           it != its_to_be_removed.end(); ++it )
       strings.erase( *it );
 
     // Now, strip any newline characters in the remaining elements
     for( std::vector<std::string>::iterator it = strings.begin(); it != strings.end(); ++it )
       {
         std::string& elem = *it;
 
         // Compiler will not accept newline_str as the third argument to std::remove
         elem.erase( std::remove(elem.begin(), elem.end(), '\n'), elem.end() );
       }
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::reset_parameter_of_rate	(	KineticsType< CoeffType, VectorCoeffType > &	rate,
		KineticsModel::Parameters	parameter,
		const CoeffType	new_value,
		const std::string &	unit = `"SI"`
	)

The rate constant models derived from the Arrhenius model have an activation energy which is stored and used, for efficiency reasons, in the reduced $\frac{E_a}{\mathrm{R}}$ form in K.

This calls for a subtle management of the get/set function. This is done by a unit management, by default an activation energy is an energy by quantity, so the default is to consider the SI unit for an energy, (J/mol). Therefore if the provided value is in Kelvin, it should be explicitely provided.

Definition at line 235 of file kinetics_parsing.h.

References antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::E, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, Antioch::KineticsType< CoeffType, VectorCoeffType >::type(), and Antioch::KineticsModel::VANTHOFF.

Referenced by Antioch::Reaction< CoeffType, VectorCoeffType >::set_parameter_of_rate(), and tester().

   {
 
 // this is crude at the moment, no test
 // this will be replaced by a unit manager
 // at some point, to be able to have an explicit
 // custom internal unit system with appropriate testing
     CoeffType new_coef = (unit == "SI")?new_value:
                                         new_value * Units<typename value_type<CoeffType>::type>(unit).get_SI_factor();
 
 // Ea management, we want K, two possibilities now
 // 1 - Ea is already in K
 // 2 - Ea is in J.mol-1
    if(parameter == KineticsModel::Parameters::E)
    {
       if(unit != "K")
       {
          new_coef = new_coef / Constants::R_universal<typename value_type<CoeffType>::type>();
       }
    }
    
 
     switch(rate.type())
       {
       case(KineticsModel::CONSTANT):
         {
           static_cast<ConstantRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       case(KineticsModel::HERCOURT_ESSEN):
         {
           static_cast< HercourtEssenRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       case(KineticsModel::BERTHELOT):
         {
           static_cast< BerthelotRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       case(KineticsModel::ARRHENIUS):
         {
           static_cast< ArrheniusRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       case(KineticsModel::BHE):
         {
           static_cast< BerthelotHercourtEssenRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       case(KineticsModel::KOOIJ):
         {
           static_cast< KooijRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       case(KineticsModel::VANTHOFF):
         {
           static_cast< VantHoffRate<CoeffType>*>(&rate)->set_parameter(parameter,new_coef);
         }
         break;
 
       default:
         {
           antioch_error();
         }
 
       } // switch(kin.type())
   }

template<typename CoeffType , typename VectorCoeffType >

void Antioch::reset_parameter_of_rate	(	KineticsType< CoeffType, VectorCoeffType > &	rate,
		KineticsModel::Parameters	parameter,
		const CoeffType	new_value,
		int	l,
		const std::string &	unit = `"SI"`
	)

Definition at line 312 of file kinetics_parsing.h.

References antioch_error, Antioch::KineticsModel::PHOTOCHEM, and Antioch::KineticsType< CoeffType, VectorCoeffType >::type().

   {
 
 // this is crude at the moment, no test
 // this will be replaced by a unit manager
 // at some point, to be able to have an explicit
 // custom internal unit system with appropriate testing
     CoeffType new_coef = (unit == "SI")?new_value:
                                         new_value * Units<typename value_type<CoeffType>::type>(unit).get_SI_factor();
 
     switch(rate.type())
     {
       case(KineticsModel::PHOTOCHEM):
         {
           static_cast<PhotochemicalRate<CoeffType,VectorCoeffType>*>(&rate)->set_parameter(parameter,l,new_coef);
         }
         break;
 
       default:
         {
           antioch_error();
         }
 
       } // switch(kin.type())
   }

template<typename CoeffType , typename VectorCoeffType , typename VectorType >

void Antioch::reset_rate	(	KineticsType< CoeffType, VectorCoeffType > &	kin,
		const VectorType &	coefs
	)

Definition at line 172 of file kinetics_parsing.h.

References antioch_error, Antioch::KineticsModel::ARRHENIUS, Antioch::KineticsModel::BERTHELOT, Antioch::KineticsModel::BHE, Antioch::KineticsModel::CONSTANT, Antioch::KineticsModel::HERCOURT_ESSEN, Antioch::KineticsModel::KOOIJ, Antioch::KineticsModel::PHOTOCHEM, Antioch::KineticsType< CoeffType, VectorCoeffType >::type(), and Antioch::KineticsModel::VANTHOFF.

Referenced by tester().

   {
 
     switch(kin.type())
       {
       case(KineticsModel::CONSTANT):
         {
           static_cast<ConstantRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::HERCOURT_ESSEN):
         {
           static_cast< HercourtEssenRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::BERTHELOT):
         {
           static_cast< BerthelotRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::ARRHENIUS):
         {
           static_cast< ArrheniusRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::BHE):
         {
           static_cast< BerthelotHercourtEssenRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::KOOIJ):
         {
           static_cast< KooijRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::VANTHOFF):
         {
           static_cast< VantHoffRate<CoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       case(KineticsModel::PHOTOCHEM):
         {
           static_cast<PhotochemicalRate<CoeffType,VectorCoeffType>*>(&kin)->reset_coefs(coefs);
         }
         break;
 
       default:
         {
           antioch_error();
         }
 
       } // switch(kin.type())
   }

template<typename T >

void Antioch::set_zero ( T & output )

inline

Definition at line 103 of file metaprogramming.h.

103 { output = 0; }

template<typename T >

void Antioch::set_zero ( std::vector< T > & a )

inline

Definition at line 167 of file vector_utils.h.

References zero_clone().

 {
   if (a.size())
     std::fill(a.begin(), a.end(), zero_clone(a[0]));
 }

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>

void Antioch::set_zero ( _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > & a )

inline

Definition at line 217 of file eigen_utils.h.

References zero_clone().

Referenced by Antioch::Converter< T >::clear(), Antioch::DuplicateReaction< CoeffType >::compute_forward_rate_coefficient_and_derivatives(), Antioch::ElementaryReaction< CoeffType >::compute_forward_rate_coefficient_and_derivatives(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources(), Antioch::KineticsEvaluator< CoeffType, StateType >::compute_mole_sources_and_derivs(), Antioch::Reaction< CoeffType, VectorCoeffType >::compute_rate_of_progress_and_derivatives(), Antioch::LindemannFalloff< CoeffType >::F_and_derivatives(), Antioch::ReactionSet< CoeffType >::get_parameter_of_reaction(), Antioch::ConstantRate< CoeffType >::rate_and_derivative(), and tester().

 {
   // We can't just use setZero here with arbitrary value_types
   if (a.size())
     a.setConstant (zero_clone(a[0]));
 }

void Antioch::skip_comment_lines	(	std::istream &	in,
		const char	comment_start
	)

inline

Skip comment lines in the header of an ASCII text file prefixed with the comment character 'comment_start'.

This is put in Antioch namespace so we can reuse in a few classes where we are reading in text tables. Originally taken from FIN-S.

Definition at line 46 of file input_utils.h.

Referenced by read_blottner_data_ascii(), read_cea_thermo_data_ascii(), read_sutherland_data_ascii(), and Antioch::ParserBase< NumericType >::skip_comments().

   {
     char c, line[256];
 
     in.get(c);
     while(std::isblank(c))in.get(c);
 
     in.putback(c);
 
     while (in.get(c), c==comment_start)
        in.getline (line, 255);
 
     // put back first character of
     // first non-comment line
     in.putback (c);
   }

void Antioch::split_string	(	const std::string &	input,
		const std::string &	delimiter,
		std::vector< std::string > &	results
	)

All characters in delimiter will be treated as a delimiter.

Definition at line 34 of file string_utils.C.

Referenced by Antioch::XMLParser< NumericType >::efficiencies(), Antioch::XMLParser< NumericType >::get_parameter(), Antioch::XMLParser< NumericType >::molecules_pairs(), Antioch::XMLParser< NumericType >::read_thermodynamic_data_root(), Antioch::XMLParser< NumericType >::species_list(), and AntiochTesting::StringUtilitiesTest::test_split_string().

   {
     // Skip delimiters at beginning.
     std::string::size_type first_pos = input.find_first_not_of(delimiter, 0);
 
     std::string::size_type pos = input.find_first_of(delimiter, first_pos);
 
     while (std::string::npos != pos || std::string::npos != first_pos)
       {
         // Found a token, add it to the vector.
         results.push_back(input.substr(first_pos, pos - first_pos));
 
         // Skip delimiters.  Note the "not_of"
         first_pos = input.find_first_not_of(delimiter, pos);
 
         // Find next delimiter
         pos = input.find_first_of(delimiter, first_pos);
       }
   }

template<typename Type >

std::pair<std::string, Type> Antioch::split_string_on_colon ( const std::string & token )

inline

Definition at line 69 of file string_utils.h.

References antioch_assert.

   {
     std::pair<std::string, Type> ret = std::make_pair(std::string(), 0);
     std::string::size_type colon_position = token.find(":");
     antioch_assert (colon_position != std::string::npos);
     ret.first  = token.substr(0, colon_position);
     ret.second = string_to_T<Type>(token.substr(colon_position + 1));
     return ret;
   }

int Antioch::SplitString	(	const std::string &	input,
		const std::string &	delimiter,
		std::vector< std::string > &	results,
		bool	includeEmpties = `true`
	)

inline

Taken from FIN-S for XML parsing.

Definition at line 83 of file string_utils.h.

References std::int.

   {
     using std::vector;
     using std::string;
 
     int iPos = 0;
     int newPos = -1;
     int sizeS2 = (int)delimiter.size();
     int isize = (int)input.size();
 
     if(
        ( isize == 0 )
        ||
        ( sizeS2 == 0 )
         )
       {
         return 0;
       }
 
     vector<int> positions;
 
     newPos = input.find (delimiter, 0);
 
     if( newPos < 0 )
       {
         return 0;
       }
 
     int numFound = 0;
 
     while( newPos >= iPos )
       {
         numFound++;
         positions.push_back(newPos);
         iPos = newPos;
         newPos = input.find (delimiter, iPos+sizeS2);
       }
 
     if( numFound == 0 )
       {
         return 0;
       }
 
     for( int i=0; i <= static_cast<int>(positions.size()); ++i )
       {
         string s("");
         if( i == 0 )
           {
             s = input.substr( i, positions[i] );
           }
         else
           {
             int offset = positions[i-1] + sizeS2;
             if( offset < isize )
               {
                 if( i == static_cast<int>(positions.size()) )
                   {
                     s = input.substr(offset);
                   }
                 else if( i > 0 )
                   {
                     s = input.substr( positions[i-1] + sizeS2,
                                       positions[i] - positions[i-1] - sizeS2 );
                   }
               }
           }
         if( includeEmpties || ( s.size() > 0 ) )
           {
             results.push_back(s);
           }
       }
     return numFound;
   }

ReactionType::Parameters Antioch::string_to_chem_enum ( const std::string & str )

inline

Definition at line 232 of file string_utils.h.

References Antioch::ReactionType::EFFICIENCIES, Antioch::KineticsModel::NOT_FOUND, Antioch::ReactionType::TROE_ALPHA, Antioch::ReactionType::TROE_T1, Antioch::ReactionType::TROE_T2, and Antioch::ReactionType::TROE_T3.

Referenced by Antioch::ReactionSet< CoeffType >::get_parameter_of_reaction(), and Antioch::ReactionSet< CoeffType >::set_parameter_of_reaction().

   {
 // chemical
       if(str == "efficiencies")
       {
         return ReactionType::Parameters::EFFICIENCIES;
       }else if(str == "alpha")
       {
         return ReactionType::Parameters::TROE_ALPHA;
       }else if(str == "T1")
       {
         return ReactionType::Parameters::TROE_T1;
       }else if(str == "T2")
       {
         return ReactionType::Parameters::TROE_T2;
       }else if(str == "T3")
       {
         return ReactionType::Parameters::TROE_T3;
       }else
       {
         return ReactionType::Parameters::NOT_FOUND;
       }
   }

KineticsModel::Parameters Antioch::string_to_kin_enum ( const std::string & str )

inline

Definition at line 192 of file string_utils.h.

References Antioch::KineticsModel::A, Antioch::KineticsModel::B, Antioch::KineticsModel::D, Antioch::KineticsModel::E, Antioch::KineticsModel::HIGH_PRESSURE, Antioch::KineticsModel::LAMBDA, Antioch::KineticsModel::LOW_PRESSURE, Antioch::KineticsModel::NOT_FOUND, Antioch::KineticsModel::R_SCALE, Antioch::KineticsModel::SIGMA, and Antioch::KineticsModel::T_REF.

Referenced by Antioch::ReactionSet< CoeffType >::find_kinetics_model_parameter(), Antioch::ReactionSet< CoeffType >::get_parameter_of_reaction(), and Antioch::ReactionSet< CoeffType >::set_parameter_of_reaction().

   {
 // kinetics
       if(str == "A")
       {
         return KineticsModel::Parameters::A;
       }else if(str == "E")
       {
         return KineticsModel::Parameters::E;
       }else if(str == "B")
       {
         return KineticsModel::Parameters::B;
       }else if(str == "D")
       {
         return KineticsModel::Parameters::D;
       }else if(str == "Tref")
       {
         return KineticsModel::Parameters::T_REF;
       }else if(str == "Rscale")
       {
         return KineticsModel::Parameters::R_SCALE;
       }else if(str == "sigma")
       {
         return KineticsModel::Parameters::SIGMA;
       }else if(str == "lambda")
       {
         return KineticsModel::Parameters::LAMBDA;
       }else if(str == "0")
       {
         return KineticsModel::Parameters::LOW_PRESSURE;
       }else if(str == "inf")
       {
         return KineticsModel::Parameters::HIGH_PRESSURE;
       }else
       {
         return KineticsModel::Parameters::NOT_FOUND;
       }
    }

template<typename T >

T Antioch::string_to_T ( const std::string & input )

inline

Definition at line 57 of file string_utils.h.

References antioch_error.

   {
     std::istringstream converter(input);
     T returnval;
     converter >> returnval;
     if (converter.fail())
       antioch_error();
     return returnval;
   }

template<typename StateType >

const ANTIOCH_AUTO (StateType) EuckenThermalConductivity<ThermoEvaluator> return Antioch::trans	(	s	,
		mu_s
	)

Referenced by Antioch::KineticsTheoryThermalConductivity< ThermoEvaluator, CoeffType >::op_no_diff_impl().

template<typename NumericType >

void Antioch::verify_unit_of_parameter	(	Units< NumericType > &	default_unit,
		const std::string &	provided_unit,
		const std::vector< std::string > &	accepted_unit,
		const std::string &	equation,
		const std::string &	parameter_name
	)

Definition at line 44 of file read_reaction_set_data.C.

References antioch_unit_error, antioch_unit_required, Antioch::Units< T >::get_symbol(), Antioch::Units< T >::is_homogeneous(), Antioch::Units< T >::is_united(), and Antioch::Units< T >::set_unit().

Referenced by read_reaction_set_data().

   {
     if(provided_unit.empty() && default_unit.is_united()) //no unit provided and there is one
       {
         antioch_unit_required(parameter_name,default_unit.get_symbol());
       }else // test
       {
         bool found(false);
         for(unsigned int i = 0; i < accepted_unit.size(); i++)
           {
             if(Units<NumericType>(accepted_unit[i]).is_homogeneous(provided_unit))
               {
                 found = true;
                 break;
               }
           }
         if(!found)
           {
             std::string errorstring("Error in reaction " + equation);
             errorstring += "\n" + parameter_name + " parameter's unit should be homogeneous to \"" + accepted_unit[0] + "\"";
             for(unsigned int i = 1; i < accepted_unit.size(); i++)errorstring += ", or \"" + accepted_unit[i] + "\"";
             errorstring += " and you provided \"" + provided_unit + "\"";
             antioch_unit_error(errorstring);
           }
         default_unit.set_unit(provided_unit);
       }
   }

template<typename T >

T Antioch::zero_clone ( const T & )

inline

Definition at line 107 of file metaprogramming.h.

107 { return 0; }

template<typename T , typename T2 >

void Antioch::zero_clone	(	T &	output,
		const T2 &
	)

inline

Definition at line 111 of file metaprogramming.h.

111 { output = 0; }

template<typename T >

std::vector< T > Antioch::zero_clone ( const std::vector< T > & example )

inline

Definition at line 134 of file vector_utils.h.

References zero_clone().

 {
   if (example.size())
     return std::vector<T>(example.size(),zero_clone(example[0]));
 
   return std::vector<T>();
 }

template<typename T1 , typename T2 >

void Antioch::zero_clone	(	std::vector< T1 > &	output,
		const std::vector< T2 > &	example
	)

inline

Definition at line 145 of file vector_utils.h.

References zero_clone().

 {
   const std::size_t sz = example.size();
   output.resize(sz);
   for (std::size_t i=0; i != sz; ++i)
     Antioch::zero_clone(output[i], example[i]);
 }

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>

_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > Antioch::zero_clone ( const _Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > & ex )

inline

Definition at line 145 of file eigen_utils.h.

References zero_clone().

 {
   // We can't just use setZero here with arbitrary _Scalar types
   if (ex.size())
     return
       _Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>
         (ex.rows(), ex.cols()).setConstant(zero_clone(ex[0]));
 
   return
     _Matrix<_Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols>
       (ex.rows(), ex.cols());
 }

template<typename T , typename Scalar >

std::vector<T> Antioch::zero_clone	(	const std::vector< T > &	example,
		const Scalar &	value
	)

inline

Definition at line 156 of file vector_utils.h.

 {
   if (example.size())
     return std::vector<T>(example.size(),value);
 
   return std::vector<T>();
 }

template<typename T >

vex::vector< T > Antioch::zero_clone ( const vex::vector< T > & example )

inline

Definition at line 157 of file vexcl_utils.h.

 {
   vex::vector<T> returnval(example.queue_list(), example.size());
   returnval.clear();
   return returnval;
 }

template<typename T >

std::valarray< T > Antioch::zero_clone ( const std::valarray< T > & example )

inline

Definition at line 165 of file valarray_utils.h.

References zero_clone().

 {
   if (example.size())
     return std::valarray<T>(zero_clone(example[0]),example.size());
   else
     return std::valarray<T>();
 }

template<template< typename, int, int, int, int, int > class _Matrix, typename _Scalar , int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols, typename Scalar2 >

void Antioch::zero_clone	(	_Matrix< _Scalar, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	output,
		const _Matrix< Scalar2, _Rows, _Cols, _Options, _MaxRows, _MaxCols > &	ex
	)

inline

Definition at line 165 of file eigen_utils.h.

Referenced by set_zero(), and zero_clone().

 {
   // We can't just use setZero here with arbitrary _Scalar types
   output.resize(ex.rows(), ex.cols());
   output.setConstant(zero_clone(ex[0]));
 }

template<typename T1 , typename T2 >

void Antioch::zero_clone	(	T1 &	output,
		const T2 &	example
	)

inline

template<typename T1 , typename T2 >

void Antioch::zero_clone	(	vex::vector< T1 > &	output,
		const vex::vector< T2 > &	example
	)

inline

Definition at line 167 of file vexcl_utils.h.

Referenced by eval_index().

 {
   output.resize(example.queue_list(), example.size());
   output = 0;
 }

template<typename T1 , typename T2 >

void Antioch::zero_clone	(	std::valarray< T1 > &	output,
		const std::valarray< T2 > &	example
	)

inline

Definition at line 176 of file valarray_utils.h.

References zero_clone().

 {
   const std::size_t sz = example.size();
   output.resize(sz);
   for (std::size_t i=0; i != sz; ++i)
     Antioch::zero_clone(output[i], example[i]);
 }

Namespaces

Classes

Typedefs

Enumerations

Functions

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation