ReactionNetworkUtils Namespace Reference

Classes
struct	Reaction
struct	Term

Typedefs
using	TermList = std::vector< Term >
using	Metadata = std::map< std::string, std::string >

Functions
std::vector< Reaction >	parseReactionNetwork (const std::string &reaction_network_string, bool output_to_cout)
	Parses the reaction network from a string form to a vector a Reaction.

Typedef Documentation

Metadata

using ReactionNetworkUtils::Metadata = typedef std::map<std::string, std::string>

Definition at line 42 of file ReactionNetworkUtils.h.

TermList

using ReactionNetworkUtils::TermList = typedef std::vector<Term>

Definition at line 41 of file ReactionNetworkUtils.h.

Function Documentation

parseReactionNetwork()

std::vector< Reaction > ReactionNetworkUtils::parseReactionNetwork	(	const std::string &	reaction_network_string,
		bool	output_to_cout
	)

Parses the reaction network from a string form to a vector a Reaction.

Parameters

reaction_network_string

Returns

Definition at line 23 of file ReactionNetworkUtils.C.

{
  using namespace peg;
  parser parser(R"(
    Reactions     <- (_ Reaction _ Newline?)* _
    Reaction      <- TermList _ '->' _ TermList _ Metadata?
    TermList      <- Term (_ Term)*
    Term          <- Coefficient? Species
    Coefficient   <- Float
    Float         <- [+-]? (_)? ([0-9]+)? ('.' [0-9]+)?
    Species       <- BaseSpecies State? Charge?
    BaseSpecies   <- [a-zA-Z][a-zA-Z0-9_]*
    State         <- '(' [a-z]{1,3} ')'
    Charge        <- ('^'? [0-9]* [+-])
    Metadata      <- '[' _ Pair (_ ',' _ Pair)* _ ']'
    Pair          <- Key _ '=' _ Value
    Key           <- [A-Za-z_][A-Za-z0-9_]*
    Value         <- [A-Za-z0-9_.-]+
    Newline       <- [\r\n]+
    ~_            <- [ \t]*
  )");
  mooseAssert(parser, "Failed to build parser");
 
  // Rules for how to parse each type
  parser["Reactions"] = [](const SemanticValues & vs)
  {
    std::vector<Reaction> reactions;
    for (const auto & v : vs)
    {
      if (v.type() == typeid(Reaction))
      {
        reactions.push_back(std::any_cast<Reaction>(v));
      }
    }
    return reactions;
  };
 
  parser["Float"] = [](const SemanticValues & vs)
  {
    // We need to remove whitespace in case the reaction was A - B -> C
    std::string vs_str = std::string(std::any_cast<std::string_view>(vs.token()));
    vs_str.erase(std::remove(vs_str.begin(), vs_str.end(), ' '), vs_str.end());
    if (vs_str == "-")
      return -1.;
    else if (vs_str == "+" || vs_str == "")
      return 1.;
    else
      return std::stod(std::string(vs_str));
  };
 
  parser["Coefficient"] = [](const SemanticValues & vs) { return std::any_cast<double>(vs[0]); };
 
  parser["BaseSpecies"] = [](const SemanticValues & vs) { return vs.token(); };
 
  parser["State"] = [](const SemanticValues & vs) { return vs.token(); };
 
  parser["Charge"] = [](const SemanticValues & vs) { return vs.token(); };
 
  parser["Species"] = [](const SemanticValues & vs)
  {
    std::string base = std::string(std::any_cast<std::string_view>(vs[0]));
    std::optional<std::string> state;
    std::optional<std::string> charge;
 
    // Parse the state and charge
    if (vs.size() >= 2)
    {
      for (size_t i = 1; i < vs.size(); ++i)
        if (vs[i].type() == typeid(std::string_view))
        {
          std::string val = std::string(std::any_cast<std::string_view>(vs[i]));
          if (val.front() == '(' && val.back() == ')')
            state = val;
          else
            charge = val;
        }
    }
 
    return Term{1.0, base, state, charge}; // default coefficient = 1.0
  };
 
  parser["Term"] = [](const SemanticValues & vs)
  {
    mooseAssert(vs.size() <= 2, "Should only have a coefficient and a species");
    if (vs.size() == 2)
    {
      double coeff = std::any_cast<double>(vs[0]);
      Term term = std::any_cast<Term>(vs[1]);
      term.coefficient = coeff;
      return term;
    }
    else
      return std::any_cast<Term>(vs[0]);
  };
 
  parser["TermList"] = [](const SemanticValues & vs)
  {
    TermList terms;
    for (const auto & v : vs)
    {
      // One term
      if (v.type() == typeid(Term))
        terms.push_back(std::any_cast<Term>(v));
      // Multiple terms
      else if (v.type() == typeid(std::vector<Term>))
      {
        const auto & more = std::any_cast<std::vector<Term>>(v);
        terms.insert(terms.end(), more.begin(), more.end());
      }
    }
    return terms;
  };
 
  // Leaf types can just use 'vs.token()'
  parser["Key"] = [](const SemanticValues & vs) { return vs.token(); };
 
  parser["Value"] = [](const SemanticValues & vs) { return vs.token(); };
 
  parser["Pair"] = [](const SemanticValues & vs)
  {
    mooseAssert(vs.size() == 2, "Metadata entry should have exactly one key and one value");
    return std::make_pair(std::string(std::any_cast<std::string_view>(vs[0])),
                          std::string(std::any_cast<std::string_view>(vs[1])));
  };
 
  parser["Metadata"] = [](const SemanticValues & vs)
  {
    Metadata meta;
    for (const auto & v : vs)
    {
      if (v.type() == typeid(std::pair<std::string, std::string>))
      {
        const auto & [k, val] = std::any_cast<std::pair<std::string, std::string>>(v);
        meta[k] = val;
      }
      else if (v.type() == typeid(std::vector<std::pair<std::string, std::string>>))
      {
        const auto & pairs = std::any_cast<std::vector<std::pair<std::string, std::string>>>(v);
        for (const auto & [k, val] : pairs)
          meta[k] = val;
      }
    }
    return meta;
  };
 
  parser["Reaction"] = [](const SemanticValues & vs)
  {
    Reaction r;
    if (vs.size() != 2 && vs.size() != 3)
      mooseError("Reaction failed to read as 'reactors -> products [metadata]");
    r.reactants = std::any_cast<TermList>(vs[0]);
    r.products = std::any_cast<TermList>(vs[1]);
    if (vs.size() == 3)
      r.metadata = std::any_cast<Metadata>(vs[2]);
    return r;
  };
 
  parser.enable_packrat_parsing();
 
  std::vector<Reaction> reactions;
  if (!parser.parse(reaction_network_string, reactions))
    mooseError("Failed to parse reaction.");
 
  // Output the reaction network
  if (output_to_cout)
  {
    for (size_t i = 0; i < reactions.size(); ++i)
    {
      const auto & r = reactions[i];
      Moose::out << "Reaction " << i + 1 << ":\n";
      Moose::out << Moose::stringify(r) << std::endl;
    }
  }
 
  return reactions;
}

Referenced by TEST(), TEST(), TEST(), TEST(), TEST(), and TEST().