scavenger::ParserChemReaction Class Reference

Parser to read user files defining chemical reactions and scavengers (reaction with background) More...

#include <Doxymodules_medical.h>

Public Member Functions
	ParserChemReaction ()=default
	~ParserChemReaction ()=default
void	ReadReactionFile (const G4String &fileName)
auto	GetListReactant1 ()
auto	GetListReactant2 ()
auto	GetListProduct ()
auto	GetListRate ()

Private Member Functions
void	AddReaction (const G4String &reactionString, const G4String &type)
void	ReadReservoir (const G4String &reservoirString)
G4double	GetScavengerConcentration (const G4String &name)
void	ImplementReaction (const G4String &reactant1, const G4String &reactant2, const std::vector< G4String > &product, const G4double &reactionRate, const G4String &type)

Static Private Member Functions
static void	ReadReaction (const G4String &reactionString, std::vector< G4String > &reactant, std::vector< G4String > &product, G4double &reactionRate)
static void	ReplaceString (G4String &aString, const G4String &from, const G4String &to)

Private Attributes
std::array< std::vector< G4String >, 5 >	fListReactant1
std::array< std::vector< G4String >, 5 >	fListReactant2
std::array< std::vector< std::vector< G4String > >, 5 >	fListProduct
std::array< std::vector< G4double >, 5 >	fListRate
std::map< G4String, G4double >	fReservoirConcentrationMap

Detailed Description

Parser to read user files defining chemical reactions and scavengers (reaction with background)

Definition at line 347 of file Doxymodules_medical.h.

Constructor & Destructor Documentation

ParserChemReaction()

scavenger::ParserChemReaction::ParserChemReaction ( )

default

~ParserChemReaction()

scavenger::ParserChemReaction::~ParserChemReaction ( )

default

Member Function Documentation

ReadReactionFile()

void scavenger::ParserChemReaction::ReadReactionFile

(

const G4String &

fileName

)

Definition at line 319 of file ParserChemReaction.cc.

                                                                  {
  G4String line;
  std::ifstream myFile(fileName);
 
  if (myFile.is_open()) {
    while (getline(myFile, line)) {
      if (G4StrUtil::contains(line,"type_1")) {
        AddReaction(line, "I");
      } else if (G4StrUtil::contains(line,"type_2")) {
        AddReaction(line, "II");
      } else if (G4StrUtil::contains(line,"type_3")) {
        AddReaction(line, "III");
      } else if (G4StrUtil::contains(line,"type_4")) {
        AddReaction(line, "IV");
      } else if (G4StrUtil::contains(line,"type_6")) {
        AddReaction(line, "VI");
      } else if (G4StrUtil::contains(line,"scavenger:")) {
        ReadReservoir(line);
      } else if (!G4StrUtil::contains(line,"#") && !line.empty()) {
        G4ExceptionDescription exception;
        exception << "Unknown declaration: "
                  << "reaction or scavenger will not be registered.\n"
                  << "Verify the writing of chemical reactions or scavengers!";
        G4Exception("ParserChemReaction::ReadReactionFile", "parchem08",
                    JustWarning, exception);
      }
    }
 
    myFile.close();
  } else {
    G4ExceptionDescription exception;
    exception << "Chemical reaction file not found.";
    G4Exception("ParserChemReaction::ReadReactionFile", "parchem09",
                JustWarning, exception);
  }
}

GetListReactant1()

auto scavenger::ParserChemReaction::GetListReactant1 ( )

inline

Definition at line 51 of file ParserChemReaction.hh.

{ return fListReactant1; }

GetListReactant2()

auto scavenger::ParserChemReaction::GetListReactant2 ( )

inline

Definition at line 53 of file ParserChemReaction.hh.

{ return fListReactant2; }

GetListProduct()

auto scavenger::ParserChemReaction::GetListProduct ( )

inline

Definition at line 55 of file ParserChemReaction.hh.

{ return fListProduct; }

GetListRate()

auto scavenger::ParserChemReaction::GetListRate ( )

inline

Definition at line 57 of file ParserChemReaction.hh.

{ return fListRate; }

AddReaction()

void scavenger::ParserChemReaction::AddReaction ( const G4String &  reactionString, const G4String &  type  )

private

Definition at line 233 of file ParserChemReaction.cc.

                                                           {
  std::vector<G4String> reactant;
  std::vector<G4String> product;
  G4double reactionRate = -1;
 
  G4bool reservoir = false;
 
  if (type == "VI") {
    reservoir = true;
  }
 
  ReadReaction(reactionString, reactant, product, reactionRate);
 
  if (!reactant.empty() && (reactionRate <= 0)) {
    G4ExceptionDescription exception;
    exception << "Null or negative reaction rate: "
              << "reaction will not be registered!";
    G4Exception("ParserChemReaction::AddReaction", "parchem04",
                JustWarning, exception);
    return;
  }
 
  G4double concentration;
 
  if (reservoir && (reactant.size() >= 2)) {
    if (G4StrUtil::contains(reactant[0],"[") && G4StrUtil::contains(reactant[0],"]")) {
      ReplaceString(reactant[0], G4String("["), G4String(""));
      ReplaceString(reactant[0], G4String("]"), G4String(""));
 
      concentration = GetScavengerConcentration(reactant[0]);
 
      if (concentration != -1) {
        reactionRate *= concentration;
        reactant[0].append("(B)");
        ImplementReaction(reactant[1], reactant[0], product,
                          reactionRate, type);
      }
    } else if (G4StrUtil::contains(reactant[1],"[") && G4StrUtil::contains(reactant[1],"]")) {
      ReplaceString(reactant[1], G4String("["), G4String(""));
      ReplaceString(reactant[1], G4String("]"), G4String(""));
 
      concentration = GetScavengerConcentration(reactant[1]);
 
      if (concentration != -1) {
        reactionRate *= concentration;
        reactant[1].append("(B)");
        ImplementReaction(reactant[0], reactant[1], product,
                          reactionRate, type);
      }
    } else if (reactant[1] == "NoneM") {
      // First-order reaction
      ImplementReaction(reactant[0], reactant[1], product, reactionRate, type);
    } else {
      G4ExceptionDescription exception;
      exception << "Missing or unsuitable square brackets:\n"
                << "reaction will not be registered.\n"
                << "Verify the writing of chemical reactions!";
      G4Exception("ParserChemReaction::AddReaction", "parchem05",
                  JustWarning, exception);
    }
  } else if (reactant.size() >= 2) {
    if (!G4StrUtil::contains(reactant[0],"[") && !G4StrUtil::contains(reactant[0],"]")
        && !G4StrUtil::contains(reactant[1],"[") && !G4StrUtil::contains(reactant[1],"]")
        && (reactant[1] != "NoneM")) {
      ImplementReaction(reactant[0], reactant[1], product, reactionRate, type);
    } else if (reactant[1] == "NoneM") {
      G4ExceptionDescription exception;
      exception << "Unsuitable reaction type: "
                << "reaction will not be registered.\n"
                << "For first-order reaction, use reaction type 6.";
      G4Exception("ParserChemReaction::AddReaction", "parchem06",
                  JustWarning, exception);
    } else {
      G4ExceptionDescription exception;
      exception << "Unsuitable square brackets: "
                << "reaction will not be registered.\n"
                << "Verify the writing of chemical reactions!";
      G4Exception("ParserChemReaction::AddReaction", "parchem07",
                  JustWarning, exception);
    }
  }
}

ReadReservoir()

void scavenger::ParserChemReaction::ReadReservoir ( const G4String &  reservoirString )

private

Definition at line 176 of file ParserChemReaction.cc.

                                                                      {
  G4double concentration = 0.;
  G4String name = "";
 
  G4bool readScavenger = true;
  G4bool readName = false;
  G4bool readConcentration = false;
 
  std::stringstream aStream;
  aStream << reservoirString;
 
  while (!aStream.eof() && readScavenger) {
    G4String aString;
    aStream >> aString;
 
    if (G4StrUtil::contains(aString,"#")) {
      readScavenger = false;
    } else if (aString == G4String("scavenger:")) {
      readName = true;
    } else if (readName) {
      name = G4String(aString);
      ReplaceString(name, G4String("+"), G4String("p"));
      ReplaceString(name, G4String("-"), G4String("m"));
 
      readName = false;
      readConcentration = true;
    } else if (readConcentration) {
      std::stringstream aStreamTmp;
      aStreamTmp << aString;
      aStreamTmp >> concentration;
      concentration *= (mole / (1e-3 * m3));
      readConcentration = false;
      readScavenger = false;
    }
  }
 
  if (concentration > 0.) {
    if (fReservoirConcentrationMap.count(name) < 1) {
      fReservoirConcentrationMap[name] = concentration;
    } else {
      G4ExceptionDescription exception;
      exception << "Scavenger already defined previously:\n"
                << "scavenger will not be registered!";
      G4Exception("ParserChemReaction::ReadReservoir", "parchem02",
                  JustWarning, exception);
    }
  } else {
    G4ExceptionDescription exception;
    exception << "Null or negative scavenger concentration:\n"
              << "scavenger will not be registered!";
    G4Exception("ParserChemReaction::ReadReservoir", "parchem03",
                JustWarning, exception);
  }
}

GetScavengerConcentration()

G4double scavenger::ParserChemReaction::GetScavengerConcentration ( const G4String &  name )

private

Definition at line 155 of file ParserChemReaction.cc.

                                                                           {
  G4double concentration = -1.;
 
  std::map<G4String, G4double>::iterator it;
  it = fReservoirConcentrationMap.find(name);
 
  if (it != fReservoirConcentrationMap.end()) {
    concentration = it->second;
  } else {
    G4ExceptionDescription exception;
    exception << "Scavenger is not defined: "
              << "reaction will not be registered!";
    G4Exception("ParserChemReaction::GetScavengerConcentration", "parchem01",
                JustWarning, exception);
  }
 
  return concentration;
}

ReadReaction()

void scavenger::ParserChemReaction::ReadReaction ( const G4String &  reactionString, std::vector< G4String > &  reactant, std::vector< G4String > &  product, G4double &  reactionRate  )

staticprivate

Definition at line 87 of file ParserChemReaction.cc.

                                                              {
  reactant.clear();
  product.clear();
 
  G4bool readReaction = true;
  G4bool readReactant = true;
  G4bool readProduct = false;
  G4bool readRate = false;
 
  std::stringstream aStream;
  aStream << reactionString;
 
  while (!aStream.eof() && readReaction) {
    G4String aString;
    aStream >> aString;
 
    if (G4StrUtil::contains(aString,"#")) {
      readReaction = false;
    } else if (readReactant) {
      if (aString == G4String("->")) {
        readReactant = false;
        readProduct = true;
      } else if (aString != G4String("+")) {
        ReplaceString(aString, G4String("+"), G4String("p"));
        ReplaceString(aString, G4String("-"), G4String("m"));
 
        if (reactant.size() < 2) {
          reactant.push_back(aString);
        }
      }
    } else if (readProduct) {
      if (aString == G4String(",")) {
        readProduct = false;
        readRate = true;
      } else if (aString != G4String("+") && !G4StrUtil::contains(aString,"[")
                 && !G4StrUtil::contains(aString,"]")) {
        ReplaceString(aString, G4String("+"), G4String("p"));
        ReplaceString(aString, G4String("-"), G4String("m"));
        product.push_back(aString);
      }
    } else if (readRate) {
      std::stringstream aStreamTmp;
      aStreamTmp << aString;
      aStreamTmp >> reactionRate;
 
      if (reactant.size() == 1) {
        // For first-order reactions
        reactionRate *= (1 * 1 / s);
      } else {
        reactionRate *= (1e-3 * m3 / (mole * s));
      }
 
      readRate = false;
      readReaction = false;
    }
  }
 
  // For first-order reactions
  if (reactant.size() == 1) {
    reactant.emplace_back("NoneM");
  }
}

ImplementReaction()

void scavenger::ParserChemReaction::ImplementReaction ( const G4String &  reactant1, const G4String &  reactant2, const std::vector< G4String > &  product, const G4double &  reactionRate, const G4String &  type  )

private

Definition at line 52 of file ParserChemReaction.cc.

                                                                 {
  if (type == "I") {
    fListReactant1[0].push_back(reactant1);
    fListReactant2[0].push_back(reactant2);
    fListProduct[0].push_back(product);
    fListRate[0].push_back(reactionRate);
  } else if (type == "II") {
    fListReactant1[1].push_back(reactant1);
    fListReactant2[1].push_back(reactant2);
    fListProduct[1].push_back(product);
    fListRate[1].push_back(reactionRate);
  } else if (type == "III") {
    fListReactant1[2].push_back(reactant1);
    fListReactant2[2].push_back(reactant2);
    fListProduct[2].push_back(product);
    fListRate[2].push_back(reactionRate);
  } else if (type == "IV") {
    fListReactant1[3].push_back(reactant1);
    fListReactant2[3].push_back(reactant2);
    fListProduct[3].push_back(product);
    fListRate[3].push_back(reactionRate);
  } else if (type == "VI") {
    fListReactant1[4].push_back(reactant1);
    fListReactant2[4].push_back(reactant2);
    fListProduct[4].push_back(product);
    fListRate[4].push_back(reactionRate);
  }
}

ReplaceString()

void scavenger::ParserChemReaction::ReplaceString ( G4String &  aString, const G4String &  from, const G4String &  to  )

staticprivate

Definition at line 38 of file ParserChemReaction.cc.

                                                           {
  if (G4StrUtil::contains(aString, from)) {
    size_t startPosition = 0;
    while ((startPosition = aString.find(from, startPosition))
           != std::string::npos) {
      aString.replace(startPosition, from.length(), to);
      startPosition += to.length();
    }
  }
}

Member Data Documentation

fListReactant1

std::array<std::vector<G4String>, 5> scavenger::ParserChemReaction::fListReactant1

private

Definition at line 81 of file ParserChemReaction.hh.

fListReactant2

std::array<std::vector<G4String>, 5> scavenger::ParserChemReaction::fListReactant2

private

Definition at line 82 of file ParserChemReaction.hh.

fListProduct

std::array<std::vector<std::vector<G4String> >, 5> scavenger::ParserChemReaction::fListProduct

private

Definition at line 83 of file ParserChemReaction.hh.

fListRate

std::array<std::vector<G4double>, 5> scavenger::ParserChemReaction::fListRate

private

Definition at line 84 of file ParserChemReaction.hh.

fReservoirConcentrationMap

std::map<G4String, G4double> scavenger::ParserChemReaction::fReservoirConcentrationMap

private

Definition at line 85 of file ParserChemReaction.hh.

---

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

• .doxygen/Doxymodules_medical.h
• extended/medical/dna/scavenger/include/ParserChemReaction.hh
• extended/medical/dna/scavenger/src/ParserChemReaction.cc