Antioch::XMLParser< NumericType > Class Template Reference

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

#include <read_reaction_set_data.h>

Inheritance diagram for Antioch::XMLParser< NumericType >:

Public Member Functions
	XMLParser (const std::string &filename, bool verbose=true)
	~XMLParser ()
void	change_file (const std::string &filename)
bool	initialize ()
	Read header of file, go to interesting part. More...
const std::vector< std::string >	species_list ()
	reads the species set More...
void	read_thermodynamic_data (NASAThermoMixture< NumericType, NASA7CurveFit< NumericType > > &thermo)
	reads the thermo, NASA generalist, no templates for virtual More...
void	read_thermodynamic_data (NASAThermoMixture< NumericType, NASA9CurveFit< NumericType > > &thermo)
	reads the thermo, NASA generalist, no templates for virtual More...
void	read_thermodynamic_data (NASAThermoMixture< NumericType, CEACurveFit< NumericType > > &)
	reads the thermo, NASA generalist, no templates for virtual More...
void	read_thermodynamic_data (CEAThermodynamics< NumericType > &)
	reads the thermo, CEA deprecated More...
bool	reaction ()
	reaction More...
bool	rate_constant (const std::string &kinetics_model)
	go to next rate constant More...
bool	Troe () const
	return true if there's a Troe block More...
const std::string	reaction_id () const
	return reaction id, 0 if not provided More...
const std::string	reaction_equation () const
	return reaction equation More...
const std::string	reaction_chemical_process () const
	return reaction chemical process More...
const std::string	reaction_kinetics_model (const std::vector< std::string > &kinetics_models) const
	return reaction kinetics model More...
bool	reaction_reversible () const
	return reversible state More...
bool	reactants_pairs (std::vector< std::pair< std::string, int > > &reactants_pair) const
	return pairs of reactants and stoichiometric coefficients More...
bool	products_pairs (std::vector< std::pair< std::string, int > > &products_pair) const
	return pairs of products and stoichiometric coefficients More...
const std::map< std::string, NumericType >	reactants_orders () const
	return a map between reactants' name and found partial orders More...
const std::map< std::string, NumericType >	products_orders () const
	return a map between products' name and found partial orders More...
bool	is_k0 (unsigned int nrc, const std::string &kin_model) const
	return true if the concerned reaction rate is the low pressure limit More...
unsigned int	where_is_k0 (const std::string &kin_model) const
	return index of k0 (0 or 1) More...
bool	rate_constant_preexponential_parameter (NumericType &A, std::string &A_unit, std::string &def_unit) const
	return true if pre exponentiel coefficient More...
bool	rate_constant_power_parameter (NumericType &b, std::string &b_unit, std::string &def_unit) const
	return true if beta coefficient More...
bool	rate_constant_activation_energy_parameter (NumericType &Ea, std::string &Ea_unit, std::string &def_unit) const
	return true if activation energie More...
bool	rate_constant_Berthelot_coefficient_parameter (NumericType &D, std::string &D_unit, std::string &def_unit) const
	return true if D coefficient More...
bool	rate_constant_Tref_parameter (NumericType &Tref, std::string &Tref_unit, std::string &def_unit) const
	return true if Tref More...
bool	rate_constant_lambda_parameter (std::vector< NumericType > &lambda, std::string &lambda_unit, std::string &def_unit) const
	return true if lambda More...
bool	rate_constant_cross_section_parameter (std::vector< NumericType > &sigma, std::string &sigma_unit, std::string &def_unit) const
	return true if sigma More...
bool	verify_Kooij_in_place_of_Arrhenius () const
	return true if a Kooij is called Arrhenuis More...
bool	efficiencies (std::vector< std::pair< std::string, NumericType > > &par_values) const
	return true if efficiencies are found More...
bool	Troe_alpha_parameter (NumericType &alpha, std::string &alpha_unit, std::string &def_unit) const
	return true is alpha More...
bool	Troe_T1_parameter (NumericType &T1, std::string &T1_unit, std::string &def_unit) const
	return true is alpha More...
bool	Troe_T2_parameter (NumericType &T2, std::string &T2_unit, std::string &def_unit) const
	return true is alpha More...
bool	Troe_T3_parameter (NumericType &T3, std::string &T3_unit, std::string &def_unit) const
	return true is alpha More...
virtual void	read_chemical_species (ChemicalMixture< NumericType > &)
	reads the mandatory data, not valid in xml && chemkin More...
virtual void	read_vibrational_data (ChemicalMixture< NumericType > &)
	reads the vibrational data, not valid in xml && chemkin More...
virtual void	read_electronic_data (ChemicalMixture< NumericType > &)
	reads the electronic data, not valid in xml && chemkin More...
virtual void	read_transport_data (TransportMixture< NumericType > &)
	reads the transport data, not valid in xml && chemkin More...
const std::string	file () const
const std::string	type () const
bool	verbose () const
ParsingType	enum_type () const

Protected Member Functions
void	skip_comments (std::istream &doc)

Protected Attributes
std::string	_type
std::string	_file
bool	_verbose
std::string	_comments
std::string	_not_implemented

Private Member Functions
template<typename ThermoType >
void	read_thermodynamic_data_root (ThermoType &thermo)
	reads the thermo, NASA generalist More...
template<typename PairedType >
bool	molecules_pairs (tinyxml2::XMLElement *molecules, std::vector< std::pair< std::string, PairedType > > &products_pair) const
	return pairs of molecules and stoichiometric coefficients More...
bool	get_parameter (const tinyxml2::XMLElement *ptr, const std::string &par, NumericType &par_value, std::string &par_unit) const
	return a parameter's value More...
bool	get_parameter (const tinyxml2::XMLElement *ptr, const std::string &par, std::vector< NumericType > &numpar, std::string &par_unit) const
	return a parameter's values More...
const std::string	unit (tinyxml2::XMLElement *parameter) const
	return the unit of current pointer More...
tinyxml2::XMLElement *	find_element_with_attribute (const tinyxml2::XMLElement *element, const std::string &elem_name, const std::string &attribute, const std::string &attr_value) const
	Search the siblings of the element to find the element with the given value for the given attribute. More...
std::string	nasa_xml_section (NASAThermoMixture< NumericType, NASA7CurveFit< NumericType > > &)
	For the given thermo type, return the string for the corresponding XML section. More...
std::string	nasa_xml_section (NASAThermoMixture< NumericType, NASA9CurveFit< NumericType > > &)
	For the given thermo type, return the string for the corresponding XML section. More...
std::string	nasa_xml_section (NASAThermoMixture< NumericType, CEACurveFit< NumericType > > &)
	For the given thermo type, return the string for the corresponding XML section. More...
std::string	nasa_xml_section (CEAThermodynamics< NumericType > &)
	For the given thermo type, return the string for the corresponding XML section. More...
	XMLParser ()
	Never use default constructor. More...

Private Attributes
tinyxml2::XMLDocument *	_doc
tinyxml2::XMLElement *	_species_block
tinyxml2::XMLElement *	_thermo_block
tinyxml2::XMLElement *	_reaction_block
tinyxml2::XMLElement *	_reaction
tinyxml2::XMLElement *	_rate_constant
tinyxml2::XMLElement *	_Troe
std::map< ParsingKey, std::string >	_map
std::map< ParsingKey, std::string >	_default_unit

Detailed Description

template<typename NumericType = double>
class Antioch::XMLParser< NumericType >

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

Please note that no other file should include the `tinyxml2_imp.h' header.

The defaults units are based and derived on Cantera:

• pre-exponential parameters in (m3/kmol)^(m-1)/s
• activation energy in cal/mol,
• power parameter without unit
• cross-section typically in cm2/nm,
• lambda typically in nm,

Definition at line 50 of file read_reaction_set_data.h.

Constructor & Destructor Documentation

template<typename NumericType >

Antioch::XMLParser< NumericType >::XMLParser	(	const std::string &	filename,
		bool	verbose = true
	)

Definition at line 49 of file xml_parser.C.

References Antioch::XMLParser< NumericType >::_default_unit, Antioch::XMLParser< NumericType >::_doc, Antioch::XMLParser< NumericType >::_map, Antioch::ACTIVATION_ENERGY, antioch_error, Antioch::BACKWARD_ORDER, Antioch::BERTHELOT_COEFFICIENT, Antioch::CHEMICAL_PROCESS, Antioch::EFFICIENCY, Antioch::EQUATION, tinyxml2::XMLDocument::ErrorID(), Antioch::FALLOFF_LOW, Antioch::FALLOFF_LOW_NAME, Antioch::FORWARD_ORDER, tinyxml2::XMLDocument::GetErrorStr1(), tinyxml2::XMLDocument::GetErrorStr2(), Antioch::HV_CROSS_SECTION, Antioch::HV_LAMBDA, Antioch::ID, Antioch::XMLParser< NumericType >::initialize(), Antioch::KINETICS_MODEL, tinyxml2::XMLDocument::LoadFile(), Antioch::NASA7, Antioch::NASA9, Antioch::NASADATA, Antioch::PHASE_BLOCK, Antioch::POWER, Antioch::PREEXP, Antioch::PRODUCTS, Antioch::REACTANTS, Antioch::REACTION, Antioch::REACTION_DATA, Antioch::REVERSIBLE, Antioch::SPECIES, Antioch::SPECIES_DATA, Antioch::SPECIES_SET, Antioch::THERMO, Antioch::TMAX, Antioch::TMIN, Antioch::TREF, Antioch::TROE_F_ALPHA, Antioch::TROE_F_TS, Antioch::TROE_F_TSS, Antioch::TROE_F_TSSS, Antioch::ReactionType::TROE_FALLOFF, Antioch::UNIT, and Antioch::ParserBase< NumericType >::verbose().

                                                                          :
    ParserBase<NumericType>("XML",filename,verbose),
    _species_block(NULL),
    _reaction_block(NULL),
    _reaction(NULL),
    _rate_constant(NULL),
    _Troe(NULL)
  {
    _doc = new tinyxml2::XMLDocument;
    if(_doc->LoadFile(filename.c_str()))
      {
        std::cerr << "ERROR: unable to load xml file " << filename << std::endl;
        std::cerr << "Error of tinyxml2 library:\n"
                  << "\tID = "            << _doc->ErrorID() << "\n"
                  << "\tError String1 = " << _doc->GetErrorStr1() << "\n"
                  << "\tError String2 = " << _doc->GetErrorStr2() << std::endl;
        antioch_error();
      }

    if(this->verbose())std::cout << "Having opened file " << filename << std::endl;


    // XML block/section names
    _map[ParsingKey::PHASE_BLOCK]           = "phase";
    _map[ParsingKey::SPECIES_SET]           = "speciesArray";
    _map[ParsingKey::SPECIES_DATA]          = "speciesData";
    _map[ParsingKey::SPECIES]               = "species";
    _map[ParsingKey::THERMO]                = "thermo"; // thermo in ,<speciesData> <species> <thermo> <NASA> <floatArray> </floatArray></NASA> </thermo> </species> </speciesData>

    // Thermo parameters
    _map[ParsingKey::TMIN]                  = "Tmin";
    _map[ParsingKey::TMAX]                  = "Tmax";
    _map[ParsingKey::NASADATA]              = "floatArray";
    _map[ParsingKey::NASA7]                 = "NASA";
    _map[ParsingKey::NASA9]                 = "NASA9";

    // Kinetics parameters
    _map[ParsingKey::REACTION_DATA]         = "reactionData";
    _map[ParsingKey::REACTION]              = "reaction";
    _map[ParsingKey::REVERSIBLE]            = "reversible";
    _map[ParsingKey::ID]                    = "id";
    _map[ParsingKey::EQUATION]              = "equation";
    _map[ParsingKey::CHEMICAL_PROCESS]      = "type";
    _map[ParsingKey::KINETICS_MODEL]        = "rateCoeff";
    _map[ParsingKey::REACTANTS]             = "reactants";
    _map[ParsingKey::PRODUCTS]              = "products";
    _map[ParsingKey::FORWARD_ORDER]         = "ford";
    _map[ParsingKey::BACKWARD_ORDER]        = "rord";
    _map[ParsingKey::PREEXP]                = "A";
    _map[ParsingKey::POWER]                 = "b";
    _map[ParsingKey::ACTIVATION_ENERGY]     = "E";
    _map[ParsingKey::BERTHELOT_COEFFICIENT] = "D";
    _map[ParsingKey::TREF]                  = "Tref";
    _map[ParsingKey::HV_LAMBDA]             = "lambda";
    _map[ParsingKey::HV_CROSS_SECTION]      = "cross_section";
    _map[ParsingKey::UNIT]                  = "units";
    _map[ParsingKey::EFFICIENCY]            = "efficiencies";
    _map[ParsingKey::FALLOFF_LOW]           = "k0";
    _map[ParsingKey::FALLOFF_LOW_NAME]      = "name";
    _map[ParsingKey::TROE_FALLOFF]          = "Troe";
    _map[ParsingKey::TROE_F_ALPHA]          = "alpha";
    _map[ParsingKey::TROE_F_TS]             = "T1";
    _map[ParsingKey::TROE_F_TSS]            = "T2";
    _map[ParsingKey::TROE_F_TSSS]           = "T3";

    // typically Cantera files list
    //      pre-exponential parameters in (m3/kmol)^(m-1)/s
    //      activation energy in cal/mol, but we want it in K.
    //      power parameter without unit
    // if falloff, we need to know who's k0 and kinfty
    // if photochemistry, we have a cross-section on a lambda grid
    //      cross-section typically in cm2/nm (cross-section on a resolution bin,
    //                                          if bin unit not given, it is lambda unit (supposed to anyway), and a warning message)
    //      lambda typically in nm, sometimes in ang, default considered here is nm
    //                         you can also have cm-1, conversion is done with
    //                         formulae nm = cm-1 * / * adapted factor
    _default_unit[ParsingKey::PREEXP]                = "m3/kmol";
    _default_unit[ParsingKey::POWER]                 = "";
    _default_unit[ParsingKey::ACTIVATION_ENERGY]    = "cal/mol";
    _default_unit[ParsingKey::BERTHELOT_COEFFICIENT] = "K-1";
    _default_unit[ParsingKey::TREF]                  = "K";
    _default_unit[ParsingKey::HV_LAMBDA]             = "nm";
    _default_unit[ParsingKey::HV_CROSS_SECTION]      = "cm2/nm";
    _default_unit[ParsingKey::EFFICIENCY]            = "";
    _default_unit[ParsingKey::TROE_F_ALPHA]          = "";
    _default_unit[ParsingKey::TROE_F_TS]             = "K";
    _default_unit[ParsingKey::TROE_F_TSS]            = "K";
    _default_unit[ParsingKey::TROE_F_TSSS]           = "K";

    this->initialize();
  }

template<typename NumericType >

Antioch::XMLParser< NumericType >::~XMLParser

(

)

Definition at line 142 of file xml_parser.C.

  {
     delete _doc;
  }

template<typename NumericType = double>

Antioch::XMLParser< NumericType >::XMLParser ( )

private

Never use default constructor.

Member Function Documentation

template<typename NumericType >

void Antioch::XMLParser< NumericType >::change_file ( const std::string &  filename )

virtual

Implements Antioch::ParserBase< NumericType >.

Definition at line 148 of file xml_parser.C.

References antioch_error, and tinyxml2::XMLDocument::ErrorID().

  {
    ParserBase<NumericType>::_file = filename;
    _species_block  = NULL;
    _reaction_block = NULL;
    _reaction       = NULL;
    _rate_constant  = NULL;
    _Troe           = NULL;

    delete _doc;
    _doc = new tinyxml2::XMLDocument;
    if(_doc->LoadFile(filename.c_str()))
      {
        std::cerr << "ERROR: unable to load xml file " << filename << std::endl;
        std::cerr << "Error of tinyxml2 library:\n"
                  << "\tID = "            << _doc->ErrorID() << "\n"
                  << "\tError String1 = " << _doc->GetErrorStr1() << "\n"
                  << "\tError String2 = " << _doc->GetErrorStr2() << std::endl;
        antioch_error();
      }

    if(this->verbose())std::cout << "Having opened file " << filename << std::endl;

    this->initialize();
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::efficiencies ( std::vector< std::pair< std::string, NumericType > > &  par_values ) const

virtual

return true if efficiencies are found

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 620 of file xml_parser.C.

References Antioch::EFFICIENCY, tinyxml2::XMLNode::FirstChildElement(), Antioch::KINETICS_MODEL, and Antioch::split_string().

  {
    bool out = false;
    if(_reaction)
      {
        tinyxml2::XMLElement * rate_constant = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str());
        if(rate_constant)
          {
            if(rate_constant->FirstChildElement(_map.at(ParsingKey::EFFICIENCY).c_str()))
              {
                std::vector<std::string> values;
                std::string value_string = std::string((rate_constant->FirstChildElement(_map.at(ParsingKey::EFFICIENCY).c_str())->GetText())?rate_constant->FirstChildElement(_map.at(ParsingKey::EFFICIENCY).c_str())->GetText():"");

                split_string(value_string, " ", values);

                for(unsigned int i = 0; i < values.size(); i++)
                    par_values.push_back(split_string_on_colon<NumericType>(values[i]));

                out = true;
              }
          }
      }
    return out;
  }

template<typename NumericType >

ParsingType Antioch::ParserBase< NumericType >::enum_type ( ) const

inherited

Returns

enum

Definition at line 63 of file parser_base.C.

References antioch_parsing_error, Antioch::ASCII, Antioch::CHEMKIN, and Antioch::XML.

  {
    ParsingType PType(ASCII);
    if(_type == "ascii")
      {
        PType = ASCII;
      }
    else if(_type == "ChemKin")
      {
        PType = CHEMKIN;
      }
    else if(_type == "XML")
      {
        PType = XML;
      }
    else
      {
        antioch_parsing_error(std::string("unknown parser type!!! " + _type));
      }

    return PType;
  }

template<typename NumericType>

const std::string Antioch::ParserBase< NumericType >::file ( ) const

inlineinherited

Returns

name of file

Definition at line 242 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_file.

Referenced by Antioch::read_species_data(), Antioch::read_species_electronic_data(), Antioch::read_species_vibrational_data(), and Antioch::read_transport_species_data().

{return _file;}

template<typename NumericType >

tinyxml2::XMLElement * Antioch::XMLParser< NumericType >::find_element_with_attribute ( const tinyxml2::XMLElement *  element, const std::string &  elem_name, const std::string &  attribute, const std::string &  attr_value  ) const

private

Search the siblings of the element to find the element with the given value for the given attribute.

Return pointer to that element.

Definition at line 511 of file xml_parser.C.

References antioch_assert, antioch_error_msg, tinyxml2::XMLElement::Attribute(), and tinyxml2::XMLNode::NextSiblingElement().

  {
    antioch_assert(element);

    const tinyxml2::XMLElement * elem_with_attr = NULL;

    if( !element->Attribute(attribute.c_str()) )
      antioch_error_msg("ERROR: Could not find attribute "+attribute+" for current element!");

    // First check if the first element has the attribute we're looking for
    if( std::string( element->Attribute(attribute.c_str()) ) == attr_value )
      elem_with_attr = element;

    // Otherwise, look at all the siblings
    else
      {
        elem_with_attr = element->NextSiblingElement(elem_name.c_str());

        while( elem_with_attr )
          {
            std::string curr_attr;
            if( elem_with_attr->Attribute(attribute.c_str()) )
              curr_attr = std::string(elem_with_attr->Attribute(attribute.c_str()));

            if( curr_attr == attr_value )
              break;

            elem_with_attr = elem_with_attr->NextSiblingElement(elem_name.c_str());
          }

        // Error out if we couldn't find the attribute with the correct value
        if( !elem_with_attr )
          antioch_error_msg("ERROR: Could not find XMLElement with attribute = "+attribute+" whose value is "+attr_value+"!");

      }

    return const_cast<tinyxml2::XMLElement*>(elem_with_attr);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::get_parameter ( const tinyxml2::XMLElement *  ptr, const std::string &  par, NumericType &  par_value, std::string &  par_unit  ) const

private

return a parameter's value

Definition at line 468 of file xml_parser.C.

References antioch_assert, tinyxml2::XMLNode::FirstChildElement(), and Antioch::UNIT.

  {
    antioch_assert(ptr);

    bool out(false);
    par_unit.clear();
    if(ptr->FirstChildElement(par.c_str()))
      {
        par_value = std::atof(ptr->FirstChildElement(par.c_str())->GetText());
        if(ptr->FirstChildElement(par.c_str())->Attribute(_map.at(ParsingKey::UNIT).c_str()))
          par_unit = ptr->FirstChildElement(par.c_str())->Attribute(_map.at(ParsingKey::UNIT).c_str());
        out = true;
      }

    return out;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::get_parameter ( const tinyxml2::XMLElement *  ptr, const std::string &  par, std::vector< NumericType > &  numpar, std::string &  par_unit  ) const

private

return a parameter's values

Definition at line 486 of file xml_parser.C.

References antioch_assert, tinyxml2::XMLNode::FirstChildElement(), Antioch::split_string(), and Antioch::UNIT.

  {
    antioch_assert(ptr);

    bool out(false);
    par_unit.clear();
    if(ptr->FirstChildElement(par.c_str()))
      {
        std::vector<std::string> values;
        split_string(ptr->FirstChildElement(par.c_str())->GetText()," ",values);

        par_values.resize(values.size());
        for(unsigned int i = 0; i < values.size(); i++)
          par_values[i] =  string_to_T<NumericType>(values[i].c_str());

        if(ptr->FirstChildElement(par.c_str())->Attribute(_map.at(ParsingKey::UNIT).c_str()))
          par_unit = ptr->FirstChildElement(par.c_str())->Attribute(_map.at(ParsingKey::UNIT).c_str());

        out = true;
      }

    return out;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::initialize ( )

virtual

Read header of file, go to interesting part.

Implements Antioch::ParserBase< NumericType >.

Definition at line 175 of file xml_parser.C.

References antioch_error, Antioch::PHASE_BLOCK, Antioch::REACTION_DATA, Antioch::SPECIES_DATA, and Antioch::SPECIES_SET.

Referenced by Antioch::XMLParser< NumericType >::XMLParser().

  {
    //we start here
    _reaction_block = _doc->FirstChildElement("ctml");
    if (!_reaction_block)
      {
        std::cerr << "ERROR:  no <ctml> tag found in input file"
                  << std::endl;
        antioch_error();
      }

    _species_block = _reaction_block->FirstChildElement(_map.at(ParsingKey::PHASE_BLOCK).c_str());
    if(_species_block)
        _species_block = _species_block->FirstChildElement(_map.at(ParsingKey::SPECIES_SET).c_str());

    _thermo_block = _reaction_block->FirstChildElement(_map.at(ParsingKey::SPECIES_DATA).c_str());

    _reaction_block = _reaction_block->FirstChildElement(_map.at(ParsingKey::REACTION_DATA).c_str());

    _reaction = NULL;
    _rate_constant = NULL;

    return _reaction_block;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::is_k0 ( unsigned int  nrc, const std::string &  kin_model  ) const

virtual

return true if the concerned reaction rate is the low pressure limit

In the case of falloff reactions, there is the attribute "name" to specify which rate constant is the low pressure limit. This attribute should have "k0" as value, and nothing else.

If no "name" attribute is provided, the first rate constant is the low pressure limit, if two "name" attribute are provided, or if the value is not "k0", an exception is thrown.

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 404 of file xml_parser.C.

References antioch_assert, antioch_parsing_error, Antioch::FALLOFF_LOW, and Antioch::FALLOFF_LOW_NAME.

  {
    bool k0(false);
    if(_rate_constant->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str()))
      {
        if(std::string(_rate_constant->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str())) == _map.at(ParsingKey::FALLOFF_LOW))
        {
          k0 = true;
        // now verifying the second one
          if(nrc == 0) // first reaction rate block
          {
            antioch_assert(_rate_constant->NextSiblingElement(kin_model.c_str()));
            if(_rate_constant->NextSiblingElement(kin_model.c_str())->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str())) // HAHA
            {
               std::string error = "I can understand the need to put attributes everywhere, really, but in this case, I'm ";
               error += "afraid that it's not a good idea to have two \'name\' attributes: only the low pressure limit should have it.";
               antioch_parsing_error(error);
            }
          }
        }else
        {
          std::string error = "The keyword associated with the \'name\' attribute within the description of a falloff should be, and only be, ";
          error += "\'k0\' to specify the low pressure limit.  It seems that the one you provided, \'";
          error += std::string(_rate_constant->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str()));
          error += "\' is not this one.  Please correct it at reaction";
          error += this->reaction_id();
          error += ": ";
          error += this->reaction_equation();
          error += ".";
          antioch_parsing_error(error);
        }
      }else if(nrc == 0) // if we're indeed at the first reading
      {
        antioch_assert(_rate_constant->NextSiblingElement(kin_model.c_str()));
        if(!_rate_constant->NextSiblingElement(kin_model.c_str())->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str())) // and the next doesn't have a name
          {
            k0 = true;
          }else
          {
            if(std::string(_rate_constant->NextSiblingElement(kin_model.c_str())->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str())) == _map.at(ParsingKey::FALLOFF_LOW))k0 = false;
          }
      }
    return k0;
  }

template<typename NumericType >

template<typename PairedType >

bool Antioch::XMLParser< NumericType >::molecules_pairs ( tinyxml2::XMLElement *  molecules, std::vector< std::pair< std::string, PairedType > > &  products_pair  ) const

private

return pairs of molecules and stoichiometric coefficients

Definition at line 377 of file xml_parser.C.

References tinyxml2::XMLElement::GetText(), and Antioch::split_string().

  {
    bool out(true);
    if(molecules)
      {

        std::vector<std::string> mol_pairs;

        // Split the reactant string on whitespace. If no entries were found,
        // there is no whitespace - and assume then only one reactant is listed.
        split_string(std::string(molecules->GetText()), " ", mol_pairs);

        for( unsigned int p=0; p < mol_pairs.size(); p++ )
          {
            std::pair<std::string,PairedType> pair( split_string_on_colon<PairedType>(mol_pairs[p]) );

            molecules_pairs.push_back(pair);
          }
      }else
      {
        out = false;
      }

    return out;
  }

template<typename NumericType = double>

std::string Antioch::XMLParser< NumericType >::nasa_xml_section ( NASAThermoMixture< NumericType, NASA7CurveFit< NumericType > > &  )

inlineprivate

For the given thermo type, return the string for the corresponding XML section.

Definition at line 230 of file xml_parser.h.

References Antioch::XMLParser< NumericType >::_map, and Antioch::NASA7.

    { return _map.at(ParsingKey::NASA7); }

template<typename NumericType = double>

std::string Antioch::XMLParser< NumericType >::nasa_xml_section ( NASAThermoMixture< NumericType, NASA9CurveFit< NumericType > > &  )

inlineprivate

For the given thermo type, return the string for the corresponding XML section.

Definition at line 234 of file xml_parser.h.

References Antioch::XMLParser< NumericType >::_map, and Antioch::NASA9.

    { return _map.at(ParsingKey::NASA9); }

template<typename NumericType = double>

std::string Antioch::XMLParser< NumericType >::nasa_xml_section ( NASAThermoMixture< NumericType, CEACurveFit< NumericType > > &  )

inlineprivate

For the given thermo type, return the string for the corresponding XML section.

Definition at line 238 of file xml_parser.h.

References antioch_error_msg.

    { antioch_error_msg("ERROR: Only supported for NASA7CurveFit and NASA9CurveFit!"); return "";}

template<typename NumericType = double>

std::string Antioch::XMLParser< NumericType >::nasa_xml_section ( CEAThermodynamics< NumericType > &  )

inlineprivate

For the given thermo type, return the string for the corresponding XML section.

Definition at line 242 of file xml_parser.h.

References antioch_error_msg.

    { antioch_error_msg("ERROR: Only supported for NASA7CurveFit and NASA9CurveFit!"); return "";}

template<typename NumericType >

const std::map< std::string, NumericType > Antioch::XMLParser< NumericType >::products_orders ( ) const

virtual

return a map between products' name and found partial orders

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 357 of file xml_parser.C.

References Antioch::BACKWARD_ORDER, and tinyxml2::XMLNode::FirstChildElement().

  {
    tinyxml2::XMLElement* orders = _reaction->FirstChildElement(_map.at(ParsingKey::BACKWARD_ORDER).c_str());
    std::map<std::string,NumericType> map;
    if(orders){
      std::vector<std::pair<std::string,NumericType> > pairs;
      if(this->molecules_pairs(orders,pairs))
      {
         for(unsigned int s = 0; s < pairs.size(); s++)
         {
            map.insert(pairs[s]);
         }
      }
    }
    return map;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::products_pairs ( std::vector< std::pair< std::string, int > > &  products_pair ) const

virtual

return pairs of products and stoichiometric coefficients

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 331 of file xml_parser.C.

References tinyxml2::XMLNode::FirstChildElement(), and Antioch::PRODUCTS.

  {
    tinyxml2::XMLElement* products = _reaction->FirstChildElement(_map.at(ParsingKey::PRODUCTS).c_str());
    return this->molecules_pairs(products, products_pair);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant ( const std::string &  kinetics_model )

virtual

go to next rate constant

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 231 of file xml_parser.C.

References antioch_assert, Antioch::KINETICS_MODEL, and Antioch::ReactionType::TROE_FALLOFF.

  {
    // if in a reaction
    if(_reaction)
      {
        // not the first one
        if(_rate_constant)
          {
            _rate_constant = _rate_constant->NextSiblingElement(kinetics_model.c_str());
          }else
          {
            // first one, we need to set _rate_constant and _Troe, because they contain environments
            // we suppose that there is a rateCoeff environement
            // _rate_constant => <rateCoeff> <kin model> </kin model> </rateCoeff>
            // _Troe          => <rateCoeff> <Troe> </Troe> </rateCoeff>
            antioch_assert(_reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str()));
            _rate_constant = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str())->FirstChildElement(kinetics_model.c_str());
            _Troe          = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str())->FirstChildElement(_map[ParsingKey::TROE_FALLOFF].c_str());
          }
      }else
      {
        _rate_constant = NULL;
      }

    return _rate_constant;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_activation_energy_parameter ( NumericType &  Ea, std::string &  Ea_unit, std::string &  def_unit  ) const

virtual

return true if activation energie

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 569 of file xml_parser.C.

References Antioch::ACTIVATION_ENERGY.

  {
    def_unit = _default_unit.at(ParsingKey::ACTIVATION_ENERGY);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::ACTIVATION_ENERGY).c_str(),Ea,Ea_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_Berthelot_coefficient_parameter ( NumericType &  D, std::string &  D_unit, std::string &  def_unit  ) const

virtual

return true if D coefficient

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 576 of file xml_parser.C.

References Antioch::BERTHELOT_COEFFICIENT, and Antioch::KineticsModel::D.

  {
    def_unit = _default_unit.at(ParsingKey::BERTHELOT_COEFFICIENT);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::BERTHELOT_COEFFICIENT).c_str(),D,D_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_cross_section_parameter ( std::vector< NumericType > &  sigma, std::string &  sigma_unit, std::string &  def_unit  ) const

virtual

return true if sigma

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 590 of file xml_parser.C.

References Antioch::HV_CROSS_SECTION.

  {
    def_unit = _default_unit.at(ParsingKey::HV_CROSS_SECTION);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::HV_CROSS_SECTION).c_str(),sigma,sigma_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_lambda_parameter ( std::vector< NumericType > &  lambda, std::string &  lambda_unit, std::string &  def_unit  ) const

virtual

return true if lambda

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 583 of file xml_parser.C.

References Antioch::HV_LAMBDA.

  {
    def_unit = _default_unit.at(ParsingKey::HV_LAMBDA);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::HV_LAMBDA).c_str(),lambda,lambda_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_power_parameter ( NumericType &  b, std::string &  b_unit, std::string &  def_unit  ) const

virtual

return true if beta coefficient

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 562 of file xml_parser.C.

References Antioch::POWER.

  {
    def_unit = _default_unit.at(ParsingKey::POWER);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::POWER).c_str(),b,b_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_preexponential_parameter ( NumericType &  A, std::string &  A_unit, std::string &  def_unit  ) const

virtual

return true if pre exponentiel coefficient

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 554 of file xml_parser.C.

References Antioch::KineticsModel::A, and Antioch::PREEXP.

  {
    def_unit = _default_unit.at(ParsingKey::PREEXP);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::PREEXP).c_str(),A,A_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::rate_constant_Tref_parameter ( NumericType &  Tref, std::string &  Tref_unit, std::string &  def_unit  ) const

virtual

return true if Tref

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 597 of file xml_parser.C.

References Antioch::TREF, and Antioch::KineticsModel::Tref().

  {
    def_unit = _default_unit.at(ParsingKey::TREF);
    return this->get_parameter(_rate_constant,_map.at(ParsingKey::TREF).c_str(),Tref,Tref_unit);
  }

template<typename NumericType >

const std::map< std::string, NumericType > Antioch::XMLParser< NumericType >::reactants_orders ( ) const

virtual

return a map between reactants' name and found partial orders

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 338 of file xml_parser.C.

References tinyxml2::XMLNode::FirstChildElement(), and Antioch::FORWARD_ORDER.

  {
    tinyxml2::XMLElement* orders = _reaction->FirstChildElement(_map.at(ParsingKey::FORWARD_ORDER).c_str());
    std::map<std::string,NumericType> map;
    if(orders){
      std::vector<std::pair<std::string,NumericType> > pairs;
      if(this->molecules_pairs(orders,pairs))
      {
         for(unsigned int s = 0; s < pairs.size(); s++)
         {
            map.insert(pairs[s]);
         }
      }
    }

    return map;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::reactants_pairs ( std::vector< std::pair< std::string, int > > &  reactants_pair ) const

virtual

return pairs of reactants and stoichiometric coefficients

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 324 of file xml_parser.C.

References tinyxml2::XMLNode::FirstChildElement(), and Antioch::REACTANTS.

  {
    tinyxml2::XMLElement* reactants = _reaction->FirstChildElement(_map.at(ParsingKey::REACTANTS).c_str());
    return this->molecules_pairs(reactants, reactants_pair);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::reaction ( )

virtual

reaction

go to next reaction

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 217 of file xml_parser.C.

References antioch_assert, and Antioch::REACTION.

  {
    antioch_assert(_reaction_block);
    _reaction = (_reaction)?
      _reaction->NextSiblingElement(_map.at(ParsingKey::REACTION).c_str()):
      _reaction_block->FirstChildElement(_map.at(ParsingKey::REACTION).c_str());

    _rate_constant = NULL;
    _Troe          = NULL;

    return _reaction;
  }

template<typename NumericType >

const std::string Antioch::XMLParser< NumericType >::reaction_chemical_process ( ) const

virtual

return reaction chemical process

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 279 of file xml_parser.C.

References Antioch::CHEMICAL_PROCESS.

  {
    const char * chem_proc = _reaction->Attribute(_map.at(ParsingKey::CHEMICAL_PROCESS).c_str());

    return (chem_proc)?
      std::string(chem_proc):
      std::string();
  }

template<typename NumericType >

const std::string Antioch::XMLParser< NumericType >::reaction_equation ( ) const

virtual

return reaction equation

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 273 of file xml_parser.C.

References Antioch::EQUATION.

  {
    return _reaction->FirstChildElement(_map.at(ParsingKey::EQUATION).c_str())->GetText();
  }

template<typename NumericType >

const std::string Antioch::XMLParser< NumericType >::reaction_id ( ) const

virtual

return reaction id, 0 if not provided

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 265 of file xml_parser.C.

References Antioch::ID.

  {
    std::stringstream id;
    id << _reaction->Attribute(_map.at(ParsingKey::ID).c_str());
    return id.str();
  }

template<typename NumericType >

const std::string Antioch::XMLParser< NumericType >::reaction_kinetics_model ( const std::vector< std::string > &  kinetics_models ) const

virtual

return reaction kinetics model

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 298 of file xml_parser.C.

References antioch_not_implemented, tinyxml2::XMLNode::FirstChildElement(), and Antioch::KINETICS_MODEL.

  {
    unsigned int imod(0);
    tinyxml2::XMLElement * rate_constant = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str())->FirstChildElement(kinetics_models[imod].c_str());
    while(!rate_constant)
      {
        if(imod == kinetics_models.size() - 1)
          {
            std::cerr << "Could not find a suitable kinetics model.\n"
                      << "Implemented kinetics models are:\n";

            for(unsigned int m = 0; m < kinetics_models.size(); m++)
              std::cerr << "  " << kinetics_models[m] << "\n";

            std::cerr << "See Antioch documentation for more details."
                      << std::endl;
            antioch_not_implemented();
          }
        imod++;
        rate_constant = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str())->FirstChildElement(kinetics_models[imod].c_str());
      }

    return kinetics_models[imod];
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::reaction_reversible ( ) const

virtual

return reversible state

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 289 of file xml_parser.C.

References Antioch::REVERSIBLE.

  {
    return (_reaction->Attribute(_map.at(ParsingKey::REVERSIBLE).c_str()))?
      (std::string(_reaction->Attribute(_map.at(ParsingKey::REVERSIBLE).c_str())) == std::string("no"))?false:true //explicit
      :
      true; //default
  }

template<typename NumericType>

virtual void Antioch::ParserBase< NumericType >::read_chemical_species ( ChemicalMixture< NumericType > &  )

inlinevirtualinherited

reads the mandatory data, not valid in xml && chemkin

Reimplemented in Antioch::ASCIIParser< NumericType >.

Definition at line 127 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_not_implemented, and antioch_not_implemented_msg.

Referenced by Antioch::read_species_data().

{antioch_not_implemented_msg(_not_implemented);}

template<typename NumericType>

virtual void Antioch::ParserBase< NumericType >::read_electronic_data ( ChemicalMixture< NumericType > &  )

inlinevirtualinherited

reads the electronic data, not valid in xml && chemkin

Reimplemented in Antioch::ASCIIParser< NumericType >.

Definition at line 133 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_not_implemented, and antioch_not_implemented_msg.

Referenced by Antioch::read_species_electronic_data().

{antioch_not_implemented_msg(_not_implemented);}

template<typename NumericType = double>

void Antioch::XMLParser< NumericType >::read_thermodynamic_data ( NASAThermoMixture< NumericType, NASA7CurveFit< NumericType > > &  thermo )

inlinevirtual

reads the thermo, NASA generalist, no templates for virtual

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 96 of file xml_parser.h.

References Antioch::XMLParser< NumericType >::read_thermodynamic_data_root().

Referenced by AntiochTesting::NASA7XMLParsingTest< long double >::test_parsed_species_list().

                {this->read_thermodynamic_data_root(thermo);}

template<typename NumericType = double>

void Antioch::XMLParser< NumericType >::read_thermodynamic_data ( NASAThermoMixture< NumericType, NASA9CurveFit< NumericType > > &  thermo )

inlinevirtual

reads the thermo, NASA generalist, no templates for virtual

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 100 of file xml_parser.h.

References Antioch::XMLParser< NumericType >::read_thermodynamic_data_root().

                {this->read_thermodynamic_data_root(thermo);}

template<typename NumericType = double>

void Antioch::XMLParser< NumericType >::read_thermodynamic_data ( NASAThermoMixture< NumericType, CEACurveFit< NumericType > > &  )

inlinevirtual

reads the thermo, NASA generalist, no templates for virtual

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 104 of file xml_parser.h.

References antioch_error_msg.

    {antioch_error_msg("ERROR: XML Parsing only supports parsing for NASA7CurveFit and NASA9CurveFit!");}

template<typename NumericType = double>

void Antioch::XMLParser< NumericType >::read_thermodynamic_data ( CEAThermodynamics< NumericType > &  )

inlinevirtual

reads the thermo, CEA deprecated

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 108 of file xml_parser.h.

References antioch_error_msg.

    {antioch_error_msg("ERROR: XML Parsing only supports parsing for NASA7CurveFit and NASA9CurveFit!");}

template<typename NumericType >

template<typename ThermoType >

void Antioch::XMLParser< NumericType >::read_thermodynamic_data_root ( ThermoType &  thermo )

private

reads the thermo, NASA generalist

Definition at line 676 of file xml_parser.C.

References antioch_error_msg, tinyxml2::XMLElement::Attribute(), Antioch::ChemicalMixture< CoeffType >::chemical_mixture(), tinyxml2::XMLNode::FirstChildElement(), tinyxml2::XMLElement::GetText(), Antioch::NASADATA, tinyxml2::XMLNode::NextSiblingElement(), Antioch::remove_newline_from_strings(), Antioch::SPECIES, Antioch::SPECIES_DATA, Antioch::split_string(), Antioch::THERMO, Antioch::TMAX, and Antioch::TMIN.

Referenced by Antioch::XMLParser< NumericType >::read_thermodynamic_data().

  {
    if(!_thermo_block)
      antioch_error_msg("ERROR: No "+_map.at(ParsingKey::SPECIES_DATA)+" section found! Cannot parse thermo!");

    const ChemicalMixture<NumericType> & chem_mixture = thermo.chemical_mixture();
    const std::vector<ChemicalSpecies<NumericType>*>& chem_species = chem_mixture.chemical_species();

    // Based on the ThermoType, namely the CurveFit, we deduce what the section name is.
    std::string nasa_xml_section = this->nasa_xml_section(thermo);

    for(unsigned int s = 0; s < chem_mixture.n_species(); s++)
      {
        // Step to first species block
        tinyxml2::XMLElement * species_block = _thermo_block->FirstChildElement(_map.at(ParsingKey::SPECIES).c_str());

        if(!species_block)
          antioch_error_msg("ERROR: No "+_map.at(ParsingKey::SPECIES)+" block found within "+_map.at(ParsingKey::SPECIES_DATA)+" section! Cannot parse thermo!");


        const std::string& name = chem_species[s]->species();

        tinyxml2::XMLElement * spec = NULL;
        spec = this->find_element_with_attribute( species_block,
                                                  _map.at(ParsingKey::SPECIES),
                                                  "name",
                                                  name );

        if(!spec)
          antioch_error_msg("ERROR: Species "+name+" has not been found in the "+_map.at(ParsingKey::SPECIES_DATA)+" section! Cannot parse thermo!");

        else
          {
            spec = spec->FirstChildElement(_map.at(ParsingKey::THERMO).c_str());

            if(!spec)
              antioch_error_msg("ERROR: No "+_map.at(ParsingKey::THERMO)+" block found for species "+name+"! Cannot parse thermo!");

            // containers for parsing thermo data
            std::vector<NumericType> temps;
            std::vector<NumericType> values;
            tinyxml2::XMLElement * coeffs;
            std::vector<std::string> coeffs_str;

            // looping for each of the temperature intervals for this species
            tinyxml2::XMLElement * nasa = spec->FirstChildElement(nasa_xml_section.c_str());
            if(!nasa)
              antioch_error_msg("ERROR: Could not find "+nasa_xml_section+" thermo section!");

            while(nasa)
              {
                if( !(nasa->Attribute(_map.at(ParsingKey::TMIN).c_str())) )
                  antioch_error_msg("ERROR: Could not find "+_map.at(ParsingKey::TMIN)+" attribute for species "+name+"!");

                if( !(nasa->Attribute(_map.at(ParsingKey::TMAX).c_str())) )
                  antioch_error_msg("ERROR: Could not find "+_map.at(ParsingKey::TMAX)+" attribute for species "+name+"!");
                // By convention, we put the first TMIN in, and then only the TMAX thereafter
                // We have a consistency check below to make sure the TMIN's in the input are consistent
                if( temps.empty() )
                  temps.push_back(string_to_T<NumericType>(nasa->Attribute(_map.at(ParsingKey::TMIN).c_str())));

                // temperatures, only Tmax as Tmin is suppose to be last Tmax
                temps.push_back(string_to_T<NumericType>(nasa->Attribute(_map.at(ParsingKey::TMAX).c_str())));

                // now coeffs
                if( !(nasa->FirstChildElement(_map.at(ParsingKey::NASADATA).c_str())) )
                  antioch_error_msg("ERROR: Could not find "+_map.at(ParsingKey::NASADATA)+" data for species "+name+"!");

                coeffs = nasa->FirstChildElement(_map.at(ParsingKey::NASADATA).c_str());
                split_string(std::string(coeffs->GetText())," ",coeffs_str);
                remove_newline_from_strings(coeffs_str);

                for(unsigned int d = 0; d < coeffs_str.size(); d++)
                  values.push_back(string_to_T<NumericType>(coeffs_str[d]));

                // If we have more than one interval, make sure the temperature intervals match up
                if( temps.size() > 1 )
                  {
                    NumericType prev_Tmax = *(temps.end()-2);
                    NumericType Tmin = string_to_T<NumericType>(nasa->Attribute(_map.at(ParsingKey::TMIN).c_str()));
                    NumericType diff = (Tmin - prev_Tmax)/prev_Tmax;

                    const NumericType tol = std::numeric_limits<NumericType>::epsilon() * 10.;

                    if(std::abs(diff) > tol)
                      antioch_error_msg("ERROR: Tmax/Tmin mismatch for species "+name+"!");
                  }

                // This is meant to store only data one interval at a time, so we must clear at each iteration
                coeffs_str.clear();

                // Move onto next interval of data
                nasa = nasa->NextSiblingElement(nasa_xml_section.c_str());

              } // end while loop

            thermo.add_curve_fit(name, values, temps);
          }

      } // end species loop
  }

template<typename NumericType>

virtual void Antioch::ParserBase< NumericType >::read_transport_data ( TransportMixture< NumericType > &  )

inlinevirtualinherited

reads the transport data, not valid in xml && chemkin

Reimplemented in Antioch::ASCIIParser< NumericType >.

Definition at line 138 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_not_implemented, and antioch_not_implemented_msg.

Referenced by Antioch::read_transport_species_data().

{antioch_not_implemented_msg(_not_implemented);}

template<typename NumericType>

virtual void Antioch::ParserBase< NumericType >::read_vibrational_data ( ChemicalMixture< NumericType > &  )

inlinevirtualinherited

reads the vibrational data, not valid in xml && chemkin

Reimplemented in Antioch::ASCIIParser< NumericType >.

Definition at line 130 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_not_implemented, and antioch_not_implemented_msg.

Referenced by Antioch::read_species_vibrational_data().

{antioch_not_implemented_msg(_not_implemented);}

template<typename NumericType >

void Antioch::ParserBase< NumericType >::skip_comments ( std::istream &  doc )

protectedinherited

Definition at line 54 of file parser_base.C.

References Antioch::skip_comment_lines().

Referenced by Antioch::ASCIIParser< NumericType >::ASCIIParser().

  {
    for(unsigned int c = 0; c < _comments.size(); c++)
      {
        skip_comment_lines(doc, _comments[c]);
      }
  }

template<typename NumericType >

const std::vector< std::string > Antioch::XMLParser< NumericType >::species_list ( )

virtual

reads the species set

species

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 203 of file xml_parser.C.

References antioch_error_msg, Antioch::remove_newline_from_strings(), Antioch::SPECIES_SET, and Antioch::split_string().

Referenced by AntiochTesting::NASA7XMLParsingTest< long double >::test_parsed_species_list().

  {
    if(!_species_block)
      antioch_error_msg("ERROR: Could not find "+_map.at(ParsingKey::SPECIES_SET)+" section in input file!");

    std::vector<std::string> molecules;

    split_string(std::string(_species_block->GetText())," ",molecules);
    remove_newline_from_strings(molecules);

    return molecules;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::Troe ( ) const

virtual

return true if there's a Troe block

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 259 of file xml_parser.C.

  {
    return _Troe;
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::Troe_alpha_parameter ( NumericType &  alpha, std::string &  alpha_unit, std::string &  def_unit  ) const

virtual

return true is alpha

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 646 of file xml_parser.C.

References Antioch::TROE_F_ALPHA.

  {
    def_unit = _default_unit.at(ParsingKey::TROE_F_ALPHA);
    return this->get_parameter(_Troe,_map.at(ParsingKey::TROE_F_ALPHA),alpha,alpha_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::Troe_T1_parameter ( NumericType &  T1, std::string &  T1_unit, std::string &  def_unit  ) const

virtual

return true is alpha

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 653 of file xml_parser.C.

References Antioch::TROE_F_TS.

  {
    def_unit = _default_unit.at(ParsingKey::TROE_F_TS);
    return this->get_parameter(_Troe,_map.at(ParsingKey::TROE_F_TS),T1,T1_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::Troe_T2_parameter ( NumericType &  T2, std::string &  T2_unit, std::string &  def_unit  ) const

virtual

return true is alpha

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 660 of file xml_parser.C.

References Antioch::TROE_F_TSS.

  {
    def_unit = _default_unit.at(ParsingKey::TROE_F_TSS);
    return this->get_parameter(_Troe,_map.at(ParsingKey::TROE_F_TSS),T2,T2_unit);
  }

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::Troe_T3_parameter ( NumericType &  T3, std::string &  T3_unit, std::string &  def_unit  ) const

virtual

return true is alpha

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 667 of file xml_parser.C.

References Antioch::TROE_F_TSSS.

  {
    def_unit = _default_unit.at(ParsingKey::TROE_F_TSSS);
    return this->get_parameter(_Troe,_map.at(ParsingKey::TROE_F_TSSS),T3,T3_unit);
  }

template<typename NumericType>

const std::string Antioch::ParserBase< NumericType >::type ( ) const

inlineinherited

Returns

type of parser

Definition at line 245 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_type.

{return _type;}

template<typename NumericType = double>

const std::string Antioch::XMLParser< NumericType >::unit ( tinyxml2::XMLElement *  parameter ) const

private

return the unit of current pointer

template<typename NumericType>

bool Antioch::ParserBase< NumericType >::verbose ( ) const

inlineinherited

Returns

verbosity

Definition at line 248 of file parser_base.h.

References Antioch::ParserBase< NumericType >::_verbose.

Referenced by Antioch::ASCIIParser< NumericType >::ASCIIParser(), Antioch::ChemKinParser< NumericType >::ChemKinParser(), and Antioch::XMLParser< NumericType >::XMLParser().

{return _verbose;}

template<typename NumericType >

bool Antioch::XMLParser< NumericType >::verify_Kooij_in_place_of_Arrhenius ( ) const

virtual

return true if a Kooij is called Arrhenuis

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 604 of file xml_parser.C.

References antioch_assert, tinyxml2::XMLNode::FirstChildElement(), Antioch::KINETICS_MODEL, and Antioch::POWER.

  {
    bool out(false);
    tinyxml2::XMLElement * rate_constant = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str());
    antioch_assert(rate_constant->FirstChildElement("Arrhenius"));
    rate_constant = rate_constant->FirstChildElement("Arrhenius");
    if(rate_constant->FirstChildElement(_map.at(ParsingKey::POWER).c_str()))
      {
        if(std::atof(rate_constant->FirstChildElement(_map.at(ParsingKey::POWER).c_str())->GetText()) != 0.) //not a very good test
          out = true;
      }

    return out;
  }

template<typename NumericType >

unsigned int Antioch::XMLParser< NumericType >::where_is_k0 ( const std::string &  kin_model ) const

virtual

return index of k0 (0 or 1)

Reimplemented from Antioch::ParserBase< NumericType >.

Definition at line 450 of file xml_parser.C.

References antioch_assert, tinyxml2::XMLElement::Attribute(), Antioch::FALLOFF_LOW, Antioch::FALLOFF_LOW_NAME, tinyxml2::XMLNode::FirstChildElement(), Antioch::KINETICS_MODEL, and tinyxml2::XMLNode::NextSiblingElement().

  {
    antioch_assert(!_rate_constant); //should be done exterior to rate constant block
    antioch_assert(_reaction);       //should be done interior to reaction block

    tinyxml2::XMLElement * rate_constant = _reaction->FirstChildElement(_map.at(ParsingKey::KINETICS_MODEL).c_str());
    antioch_assert(rate_constant);
    rate_constant = rate_constant->FirstChildElement(kin_model.c_str());
    unsigned int k0(0);
    if(rate_constant->NextSiblingElement()->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str()))
      {
        if(std::string(rate_constant->NextSiblingElement()->Attribute(_map.at(ParsingKey::FALLOFF_LOW_NAME).c_str())) == _map.at(ParsingKey::FALLOFF_LOW))k0=1;
      }

    return k0;
  }

Member Data Documentation

template<typename NumericType>

std::string Antioch::ParserBase< NumericType >::_comments

protectedinherited

Definition at line 261 of file parser_base.h.

template<typename NumericType = double>

std::map<ParsingKey,std::string> Antioch::XMLParser< NumericType >::_default_unit

private

Definition at line 261 of file xml_parser.h.

Referenced by Antioch::XMLParser< NumericType >::XMLParser().

template<typename NumericType = double>

tinyxml2::XMLDocument* Antioch::XMLParser< NumericType >::_doc

private

Definition at line 249 of file xml_parser.h.

Referenced by Antioch::XMLParser< NumericType >::XMLParser().

template<typename NumericType>

std::string Antioch::ParserBase< NumericType >::_file

protectedinherited

Definition at line 259 of file parser_base.h.

Referenced by Antioch::ParserBase< NumericType >::file(), and Antioch::ParserBase< NumericType >::ParserBase().

template<typename NumericType = double>

std::map<ParsingKey,std::string> Antioch::XMLParser< NumericType >::_map

private

Definition at line 260 of file xml_parser.h.

Referenced by Antioch::XMLParser< NumericType >::nasa_xml_section(), and Antioch::XMLParser< NumericType >::XMLParser().

template<typename NumericType>

std::string Antioch::ParserBase< NumericType >::_not_implemented

protectedinherited

Definition at line 263 of file parser_base.h.

Referenced by Antioch::ParserBase< NumericType >::efficiencies(), Antioch::ParserBase< NumericType >::is_k0(), Antioch::ParserBase< NumericType >::ParserBase(), Antioch::ParserBase< NumericType >::products_orders(), Antioch::ParserBase< NumericType >::products_pairs(), Antioch::ParserBase< NumericType >::rate_constant(), Antioch::ParserBase< NumericType >::rate_constant_activation_energy_parameter(), Antioch::ParserBase< NumericType >::rate_constant_Berthelot_coefficient_parameter(), Antioch::ParserBase< NumericType >::rate_constant_cross_section_parameter(), Antioch::ParserBase< NumericType >::rate_constant_lambda_parameter(), Antioch::ParserBase< NumericType >::rate_constant_power_parameter(), Antioch::ParserBase< NumericType >::rate_constant_preexponential_parameter(), Antioch::ParserBase< NumericType >::rate_constant_Tref_parameter(), Antioch::ParserBase< NumericType >::reactants_orders(), Antioch::ParserBase< NumericType >::reactants_pairs(), Antioch::ParserBase< NumericType >::reaction(), Antioch::ParserBase< NumericType >::reaction_chemical_process(), Antioch::ParserBase< NumericType >::reaction_equation(), Antioch::ParserBase< NumericType >::reaction_id(), Antioch::ParserBase< NumericType >::reaction_kinetics_model(), Antioch::ParserBase< NumericType >::reaction_reversible(), Antioch::ParserBase< NumericType >::read_chemical_species(), Antioch::ParserBase< NumericType >::read_electronic_data(), Antioch::ParserBase< NumericType >::read_thermodynamic_data(), Antioch::ParserBase< NumericType >::read_transport_data(), Antioch::ParserBase< NumericType >::read_vibrational_data(), Antioch::ParserBase< NumericType >::species_list(), Antioch::ParserBase< NumericType >::Troe(), Antioch::ParserBase< NumericType >::Troe_alpha_parameter(), Antioch::ParserBase< NumericType >::Troe_T1_parameter(), Antioch::ParserBase< NumericType >::Troe_T2_parameter(), Antioch::ParserBase< NumericType >::Troe_T3_parameter(), Antioch::ParserBase< NumericType >::verify_Kooij_in_place_of_Arrhenius(), and Antioch::ParserBase< NumericType >::where_is_k0().

template<typename NumericType = double>

tinyxml2::XMLElement* Antioch::XMLParser< NumericType >::_rate_constant

private

Definition at line 257 of file xml_parser.h.

template<typename NumericType = double>

tinyxml2::XMLElement* Antioch::XMLParser< NumericType >::_reaction

private

Definition at line 255 of file xml_parser.h.

template<typename NumericType = double>

tinyxml2::XMLElement* Antioch::XMLParser< NumericType >::_reaction_block

private

Definition at line 254 of file xml_parser.h.

template<typename NumericType = double>

tinyxml2::XMLElement* Antioch::XMLParser< NumericType >::_species_block

private

Definition at line 252 of file xml_parser.h.

template<typename NumericType = double>

tinyxml2::XMLElement* Antioch::XMLParser< NumericType >::_thermo_block

private

Definition at line 253 of file xml_parser.h.

template<typename NumericType = double>

tinyxml2::XMLElement* Antioch::XMLParser< NumericType >::_Troe

private

Definition at line 258 of file xml_parser.h.

template<typename NumericType>

std::string Antioch::ParserBase< NumericType >::_type

protectedinherited

Definition at line 258 of file parser_base.h.

Referenced by Antioch::ParserBase< NumericType >::ParserBase(), and Antioch::ParserBase< NumericType >::type().

template<typename NumericType>

bool Antioch::ParserBase< NumericType >::_verbose

protectedinherited

Definition at line 260 of file parser_base.h.

Referenced by Antioch::ParserBase< NumericType >::verbose().

---

The documentation for this class was generated from the following files:

• src/parsing/include/antioch/read_reaction_set_data.h
• src/parsing/include/antioch/xml_parser.h
• src/parsing/src/xml_parser.C