G4DNAScavengerMaterial Class Reference

#include <G4DNAScavengerMaterial.hh>

Inheritance diagram for G4DNAScavengerMaterial:

Public Types
using	NbMoleculeInTime
using	MolType = const G4MolecularConfiguration*
using	MaterialMap = std::map<MolType, int64_t>
using	ReactantList = std::vector<MolType>
using	CounterMapType = std::map<MolType, NbMoleculeInTime>

Public Member Functions
	G4DNAScavengerMaterial ()=default
	G4DNAScavengerMaterial (G4VChemistryWorld *)
	~G4DNAScavengerMaterial () override=default
	G4DNAScavengerMaterial (const G4DNAScavengerMaterial &right)=delete
G4DNAScavengerMaterial &	operator= (const G4DNAScavengerMaterial &)=delete
void	Initialize ()
void	ReduceNumberMoleculePerVolumeUnitForMaterialConf (MolType, G4double)
void	AddNumberMoleculePerVolumeUnitForMaterialConf (MolType, G4double)
G4double	GetNumberMoleculePerVolumeUnitForMaterialConf (MolType) const
void	AddAMoleculeAtTime (MolType, G4double time, const G4ThreeVector *position=nullptr, G4int number=1)
void	RemoveAMoleculeAtTime (MolType, G4double time, const G4ThreeVector *position=nullptr, G4int number=1)
void	Reset () override
void	PrintInfo ()
MaterialMap::iterator	end ()
MaterialMap::iterator	begin ()
size_t	size ()
G4bool	find (MolType type)
void	SetCounterAgainstTime ()
void	SetpH (const G4int &ph)
G4double	GetpH ()
std::vector< MolType >	GetScavengerList () const
void	Dump ()
int64_t	GetNMoleculesAtTime (MolType molecule, G4double time)
G4bool	SearchTimeMap (MolType molecule)
int64_t	SearchUpperBoundTime (G4double time, G4bool sameTypeOfMolecule)
void	ResetEquilibrium ()
G4bool	SetEquilibrium (const G4DNAMolecularReactionData *pReaction, G4double time)
G4bool	IsEquilibrium (const G4int &reactionType) const
Public Member Functions inherited from G4VScavengerMaterial
	G4VScavengerMaterial ()=default
virtual	~G4VScavengerMaterial ()=default

Detailed Description

Definition at line 42 of file G4DNAScavengerMaterial.hh.

Member Typedef Documentation

CounterMapType

using G4DNAScavengerMaterial::CounterMapType = std::map<MolType, NbMoleculeInTime>

Definition at line 50 of file G4DNAScavengerMaterial.hh.

MaterialMap

using G4DNAScavengerMaterial::MaterialMap = std::map<MolType, int64_t>

Definition at line 48 of file G4DNAScavengerMaterial.hh.

MolType

using G4DNAScavengerMaterial::MolType = const G4MolecularConfiguration*

Definition at line 47 of file G4DNAScavengerMaterial.hh.

NbMoleculeInTime

using G4DNAScavengerMaterial::NbMoleculeInTime

Initial value:

 
std::map<G4double, int64_t, G4::MoleculeCounter::FixedTimeComparer>

Definition at line 45 of file G4DNAScavengerMaterial.hh.

ReactantList

using G4DNAScavengerMaterial::ReactantList = std::vector<MolType>

Definition at line 49 of file G4DNAScavengerMaterial.hh.

Constructor & Destructor Documentation

G4DNAScavengerMaterial() [1/3]

G4DNAScavengerMaterial::G4DNAScavengerMaterial ( )

default

Referenced by G4DNAScavengerMaterial(), and operator=().

G4DNAScavengerMaterial() [2/3]

G4DNAScavengerMaterial::G4DNAScavengerMaterial ( G4VChemistryWorld * pChemistryInfo )

explicit

Definition at line 45 of file G4DNAScavengerMaterial.cc.

  : fpChemistryInfo(pChemistryInfo), fIsInitialized(false), fCounterAgainstTime(false), fVerbose(0)
{
  Initialize();
}

~G4DNAScavengerMaterial()

G4DNAScavengerMaterial::~G4DNAScavengerMaterial ( )

overridedefault

G4DNAScavengerMaterial() [3/3]

G4DNAScavengerMaterial::G4DNAScavengerMaterial ( const G4DNAScavengerMaterial & right )

delete

Member Function Documentation

AddAMoleculeAtTime()

void G4DNAScavengerMaterial::AddAMoleculeAtTime	(	MolType	molecule,
		G4double	time,
		const G4ThreeVector *	position = nullptr,
		G4int	number = 1 )

Definition at line 208 of file G4DNAScavengerMaterial.cc.

{
  if (fVerbose != 0) {
    G4cout << "G4DNAScavengerMaterial::AddAMoleculeAtTime : " << molecule->GetName()
           << " at time : " << G4BestUnit(time, "Time") << G4endl;
  }
 
  auto counterMap_i = fCounterMap.find(molecule);
 
  if (counterMap_i == fCounterMap.end()) {
    fCounterMap[molecule][time] = number;
  }
  else if (counterMap_i->second.empty()) {
    counterMap_i->second[time] = number;
  }
  else {
    auto end = counterMap_i->second.rbegin();
 
    if (end->first <= time
        || fabs(end->first - time) <= G4::MoleculeCounter::FixedTimeComparer::fPrecision) {
      G4double newValue = end->second + number;
      counterMap_i->second[time] = newValue;
      if (newValue != (floor)(fScavengerTable[molecule]))  // protection
      {
        G4String errMsg = "You are trying to add wrong molecule : ";
                        G4cout<< " newValue : "<<newValue<<" " << molecule->GetName()
                          << " at time : " << G4BestUnit(time, "Time")
                          << " with number : " << number
               <<" (floor)(fScavengerTable[molecule]) : "<<(floor)(fScavengerTable[molecule])
                          << " and the final number is not valid." << G4endl;
        G4Exception("AddAMoleculeAtTime", "", FatalErrorInArgument, errMsg);
      }
    }
  }
}

Referenced by AddNumberMoleculePerVolumeUnitForMaterialConf().

AddNumberMoleculePerVolumeUnitForMaterialConf()

void G4DNAScavengerMaterial::AddNumberMoleculePerVolumeUnitForMaterialConf	(	MolType	matConf,
		G4double	time )

Definition at line 125 of file G4DNAScavengerMaterial.cc.

{
  // no change these molecules
 
  if (fH2O == matConf || fH3Op == matConf ||  // pH has no change
      fHOm == matConf)
  {
    // G4cout<<"moletype : "<<matConf->GetName()<<G4endl;
    // kobs is already counted these molecule concentrations
    return;
  }
 
  auto it = fScavengerTable.find(matConf);
  if (it == fScavengerTable.end())  // matConf must be in fScavengerTable
  {
    return;
  }
  fScavengerTable[matConf]++;
 
  if (fCounterAgainstTime) {
    AddAMoleculeAtTime(matConf, time);
  }
}

begin()

MaterialMap::iterator G4DNAScavengerMaterial::begin ( )

inline

Definition at line 74 of file G4DNAScavengerMaterial.hh.

{ return fScavengerTable.begin(); }

Referenced by G4DNAGillespieDirectMethod::CreateEvents().

Dump()

void G4DNAScavengerMaterial::Dump

(

)

Definition at line 304 of file G4DNAScavengerMaterial.cc.

{
  auto pConfinedBox = fpChemistryInfo->GetChemistryBoundary();
  auto V = pConfinedBox->Volume();
  for (const auto& it : fCounterMap) {
    auto pReactant = it.first;
 
    G4cout << " --- > For " << pReactant->GetName() << G4endl;
 
    for (const auto& it2 : it.second) {
      G4cout << " " << G4BestUnit(it2.first, "Time") << "    "
             << it2.second / (Avogadro * V * 1.0e-6 /*mm3 to L*/) << G4endl;
    }
  }
}

Referenced by PrintInfo(), and RemoveAMoleculeAtTime().

end()

MaterialMap::iterator G4DNAScavengerMaterial::end ( )

inline

Definition at line 73 of file G4DNAScavengerMaterial.hh.

{ return fScavengerTable.end(); }

Referenced by AddAMoleculeAtTime().

find()

G4bool G4DNAScavengerMaterial::find ( MolType type )

inline

Definition at line 77 of file G4DNAScavengerMaterial.hh.

  {
    auto it = fScavengerTable.find(type);
    if(it != fScavengerTable.end())
    {
      return it->second > 0;
    }
    return false;
  }

Referenced by ReduceNumberMoleculePerVolumeUnitForMaterialConf().

GetNMoleculesAtTime()

int64_t G4DNAScavengerMaterial::GetNMoleculesAtTime	(	MolType	molecule,
		G4double	time )

Definition at line 320 of file G4DNAScavengerMaterial.cc.

{
  if (!fCounterAgainstTime) {
    G4cout << "fCounterAgainstTime == false" << G4endl;
    assert(false);
  }
 
  G4bool sameTypeOfMolecule = SearchTimeMap(molecule);
  auto output = SearchUpperBoundTime(time, sameTypeOfMolecule);
  if (output < 0) {
    G4ExceptionDescription errMsg;
    errMsg << "N molecules not valid < 0 : " << molecule->GetName() << " N : " << output << G4endl;
    G4Exception("G4DNAScavengerMaterial::GetNMoleculesAtTime", "", FatalErrorInArgument, errMsg);
  }
  return output;
}

GetNumberMoleculePerVolumeUnitForMaterialConf()

G4double G4DNAScavengerMaterial::GetNumberMoleculePerVolumeUnitForMaterialConf

(

MolType

matConf

)

const

Definition at line 80 of file G4DNAScavengerMaterial.cc.

{
  // no change these molecules
  if (fH2O == matConf) {
    return 0;
  }
 
  auto iter = fScavengerTable.find(matConf);
  if (iter == fScavengerTable.end()) {
    return 0;
  }
 
  if (iter->second >= 1) {
    return (floor)(iter->second);
  }
 
  return 0;
}

GetpH()

G4double G4DNAScavengerMaterial::GetpH

(

)

Definition at line 427 of file G4DNAScavengerMaterial.cc.

{
  G4double volumeInLiter = fpChemistryInfo->GetChemistryBoundary()->Volume() / liter;
  G4double Cion = (G4double)fScavengerTable[fH3Op] / (Avogadro * volumeInLiter);
  G4double pH = std::log10(Cion);
  // G4cout<<"OH- : "<<fScavengerTable[fHOm]<<"   H3O+ : "<<fScavengerTable[fH3Op]<<"   pH :
  // "<<-pH<<G4endl;
  if (fScavengerTable[fH3Op] < 0)  // protect me
  {
    G4Exception("G4DNAScavengerMaterial::GetpH()", "G4DNAScavengerMaterial001", JustWarning,
                "H3O+ < 0");
    fScavengerTable[fH3Op] = 0;
  }
  if (fScavengerTable[fHOm] < 0)  // protect me
  {
    G4Exception("G4DNAScavengerMaterial::GetpH()", "G4DNAScavengerMaterial001", JustWarning,
                "HO- < 0");
    fScavengerTable[fHOm] = 0;
  }
  return -pH;
}

GetScavengerList()

std::vector< MolType > G4DNAScavengerMaterial::GetScavengerList ( ) const

inline

Definition at line 91 of file G4DNAScavengerMaterial.hh.

  {
    std::vector<MolType> output;
    for(const auto& it : fScavengerTable)
    {
      output.push_back(it.first);
    }
    return output;
  }

Initialize()

void G4DNAScavengerMaterial::Initialize

(

)

Definition at line 53 of file G4DNAScavengerMaterial.cc.

{
  if (fIsInitialized) {
    return;
  }
 
  if (fpChemistryInfo->size() == 0) {
    G4cout << "G4DNAScavengerMaterial existed but empty" << G4endl;
  }
  Reset();
 
  fEquilibriumProcesses.emplace(
    std::make_pair(6, std::make_unique<G4ChemEquilibrium>(6, 10 * CLHEP::us)));//reactionType6 and 10 * us
  fEquilibriumProcesses.emplace(
    std::make_pair(7, std::make_unique<G4ChemEquilibrium>(7, 10 * CLHEP::us)));//reactionType6 and 10 * us
  fEquilibriumProcesses.emplace(
    std::make_pair(8, std::make_unique<G4ChemEquilibrium>(8, 10 * CLHEP::us)));//reactionType6 and 10 * us
  for(auto& it : fEquilibriumProcesses)
  {
    it.second->Initialize();
    it.second->SetVerbose(fVerbose);
  }
 
  fIsInitialized = true;
}

Referenced by G4DNAScavengerMaterial().

IsEquilibrium()

G4bool G4DNAScavengerMaterial::IsEquilibrium

(

const G4int &

reactionType

)

const

Definition at line 469 of file G4DNAScavengerMaterial.cc.

{
  auto reaction = fEquilibriumProcesses.find(reactionType);
  if(reaction == fEquilibriumProcesses.end())
  {
    return true;
  }else
  {
    return (reaction->second->GetEquilibriumStatus());
  }
 
}

operator=()

G4DNAScavengerMaterial & G4DNAScavengerMaterial::operator= ( const G4DNAScavengerMaterial & )

delete

PrintInfo()

void G4DNAScavengerMaterial::PrintInfo

(

)

Definition at line 150 of file G4DNAScavengerMaterial.cc.

{
  auto pConfinedBox = fpChemistryInfo->GetChemistryBoundary();
  auto iter = fpChemistryInfo->begin();
  G4cout << "**************************************************************" << G4endl;
  for (; iter != fpChemistryInfo->end(); iter++) {
    auto containedConf = iter->first;
    // auto concentration = iter->second;
    auto concentration = fScavengerTable[containedConf] / (Avogadro * pConfinedBox->Volume());
    G4cout << "Scavenger:" << containedConf->GetName() << "  : "
           << concentration / 1.0e-6 /*mm3 to L*/ << " (M)  with : "
           << fScavengerTable[containedConf] << " (molecules)"
           << "in: " << pConfinedBox->Volume() / (um * um * um) << " (um3)" << G4endl;
    if (fScavengerTable[containedConf] < 1) {
      G4cout << "!!!!!!!!!!!!! this molecule has less one molecule for "
                "considered volume"
             << G4endl;
      // assert(false);
    }
    if (fVerbose != 0) {
      Dump();
    }
  }
  G4cout << "**************************************************************" << G4endl;
}

Referenced by Reset().

ReduceNumberMoleculePerVolumeUnitForMaterialConf()

void G4DNAScavengerMaterial::ReduceNumberMoleculePerVolumeUnitForMaterialConf	(	MolType	matConf,
		G4double	time )

Definition at line 99 of file G4DNAScavengerMaterial.cc.

{
  // no change these molecules
  if (fH2O == matConf || fH3Op == matConf ||  // suppose that pH is not changed during simu
      fHOm == matConf)
  {
    // G4cout<<"moletype : "<<matConf->GetName()<<G4endl;
    // kobs is already counted these molecule concentrations
    return;
  }
  if (!find(matConf))  // matConf must greater than 0
  {
    return;
  }
  fScavengerTable[matConf]--;
  if (fScavengerTable[matConf] < 0)  // projection
  {
    assert(false);
  }
 
  if (fCounterAgainstTime) {
    RemoveAMoleculeAtTime(matConf, time);
  }
}

RemoveAMoleculeAtTime()

void G4DNAScavengerMaterial::RemoveAMoleculeAtTime	(	MolType	pMolecule,
		G4double	time,
		const G4ThreeVector *	position = nullptr,
		G4int	number = 1 )

Definition at line 247 of file G4DNAScavengerMaterial.cc.

{
  NbMoleculeInTime& nbMolPerTime = fCounterMap[pMolecule];
 
  if (fVerbose != 0) {
    auto it_ = nbMolPerTime.rbegin();
    G4cout << "G4DNAScavengerMaterial::RemoveAMoleculeAtTime : " << pMolecule->GetName()
           << " at time : " << G4BestUnit(time, "Time")
 
           << " form : " << it_->second << G4endl;
  }
 
  if (nbMolPerTime.empty()) {
    Dump();
    G4String errMsg = "You are trying to remove molecule " +
                      pMolecule->GetName() +
                      " from the counter while this kind of molecules has not "
                      "been registered yet";
    G4Exception("G4DNAScavengerMaterial::RemoveAMoleculeAtTime", "", FatalErrorInArgument, errMsg);
 
    return;
  }
 
  auto it = nbMolPerTime.rbegin();
 
  if (it == nbMolPerTime.rend()) {
    it--;
 
    G4String errMsg = "There was no " + pMolecule->GetName()
                      + " recorded at the time or even before the time asked";
    G4Exception("G4DNAScavengerMaterial::RemoveAMoleculeAtTime", "", FatalErrorInArgument, errMsg);
  }
 
  G4double finalN = it->second - number;
  if (finalN < 0) {
    Dump();
 
    G4cout << "fScavengerTable : " << pMolecule->GetName() << " : " << (fScavengerTable[pMolecule])
           << G4endl;
 
    G4ExceptionDescription errMsg;
    errMsg << "After removal of " << number << " species of "
           << " " << it->second << " " << pMolecule->GetName() << " the final number at time "
           << G4BestUnit(time, "Time") << " is less than zero and so not valid." << G4endl;
    G4cout << " Global time is " << G4BestUnit(G4Scheduler::Instance()->GetGlobalTime(), "Time")
           << ". Previous selected time is " << G4BestUnit(it->first, "Time") << G4endl;
    G4Exception("G4DNAScavengerMaterial::RemoveAMoleculeAtTime", "N_INF_0", FatalException, errMsg);
  }
  nbMolPerTime[time] = finalN;
 
  if (finalN != (floor)(fScavengerTable[pMolecule]))  // protection
  {
    assert(false);
  }
}

Referenced by ReduceNumberMoleculePerVolumeUnitForMaterialConf().

Reset()

void G4DNAScavengerMaterial::Reset ( )

overridevirtual

Implements G4VScavengerMaterial.

Definition at line 176 of file G4DNAScavengerMaterial.cc.

{
  if (fpChemistryInfo == nullptr) {
    return;
  }
 
  if (fpChemistryInfo->size() == 0) {
    return;
  }
 
  ResetEquilibrium();
 
  fScavengerTable.clear();
  fCounterMap.clear();
  fpLastSearch.reset(nullptr);
 
  auto pConfinedBox = fpChemistryInfo->GetChemistryBoundary();
  auto iter = fpChemistryInfo->begin();
  for (; iter != fpChemistryInfo->end(); iter++) {
    auto containedConf = iter->first;
    auto concentration = iter->second;
    fScavengerTable[containedConf] = floor(Avogadro * concentration * pConfinedBox->Volume());
    fCounterMap[containedConf][1 * picosecond] =
      floor(Avogadro * concentration * pConfinedBox->Volume());
  }
  if (fVerbose != 0) {
    PrintInfo();
  }
}

Referenced by Initialize().

ResetEquilibrium()

void G4DNAScavengerMaterial::ResetEquilibrium

(

)

Definition at line 461 of file G4DNAScavengerMaterial.cc.

{
  for(auto& it : fEquilibriumProcesses)
  {
    it.second->Reset();
  }
}

Referenced by Reset().

SearchTimeMap()

G4bool G4DNAScavengerMaterial::SearchTimeMap

(

MolType

molecule

)

Definition at line 337 of file G4DNAScavengerMaterial.cc.

{
  if (fpLastSearch == nullptr) {
    fpLastSearch = std::make_unique<Search>();
  }
  else {
    if (fpLastSearch->fLowerBoundSet && fpLastSearch->fLastMoleculeSearched->first == molecule) {
      return true;
    }
  }
 
  auto mol_it = fCounterMap.find(molecule);
  fpLastSearch->fLastMoleculeSearched = mol_it;
 
  if (mol_it != fCounterMap.end()) {
    fpLastSearch->fLowerBoundTime = fpLastSearch->fLastMoleculeSearched->second.end();
    fpLastSearch->fLowerBoundSet = true;
  }
  else {
    fpLastSearch->fLowerBoundSet = false;
  }
 
  return false;
}

Referenced by GetNMoleculesAtTime().

SearchUpperBoundTime()

int64_t G4DNAScavengerMaterial::SearchUpperBoundTime	(	G4double	time,
		G4bool	sameTypeOfMolecule )

Definition at line 364 of file G4DNAScavengerMaterial.cc.

{
  auto mol_it = fpLastSearch->fLastMoleculeSearched;
  if (mol_it == fCounterMap.end()) {
    return 0;
  }
 
  NbMoleculeInTime& timeMap = mol_it->second;
  if (timeMap.empty()) {
    return 0;
  }
 
  if (sameTypeOfMolecule) {
    if (fpLastSearch->fLowerBoundSet && fpLastSearch->fLowerBoundTime != timeMap.end()) {
      if (fpLastSearch->fLowerBoundTime->first < time) {
        auto upperToLast = fpLastSearch->fLowerBoundTime;
        upperToLast++;
 
        if (upperToLast == timeMap.end()) {
          return fpLastSearch->fLowerBoundTime->second;
        }
 
        if (upperToLast->first > time) {
          return fpLastSearch->fLowerBoundTime->second;
        }
      }
    }
  }
 
  auto up_time_it = timeMap.upper_bound(time);
 
  if (up_time_it == timeMap.end()) {
    auto last_time = timeMap.rbegin();
    return last_time->second;
  }
  if (up_time_it == timeMap.begin()) {
    return 0;
  }
 
  up_time_it--;
 
  fpLastSearch->fLowerBoundTime = up_time_it;
  fpLastSearch->fLowerBoundSet = true;
 
  return fpLastSearch->fLowerBoundTime->second;
}

Referenced by GetNMoleculesAtTime().

SetCounterAgainstTime()

void G4DNAScavengerMaterial::SetCounterAgainstTime ( )

inline

Definition at line 87 of file G4DNAScavengerMaterial.hh.

{ fCounterAgainstTime = true; }

SetEquilibrium()

G4bool G4DNAScavengerMaterial::SetEquilibrium	(	const G4DNAMolecularReactionData *	pReaction,
		G4double	time )

Definition at line 449 of file G4DNAScavengerMaterial.cc.

{
  for(auto& it : fEquilibriumProcesses)
  {
    it.second->SetGlobalTime(time);
    it.second->SetEquilibrium(pReaction);
    if(it.second->IsStatusChanged()) return true;
  }
  return false;
}

SetpH()

void G4DNAScavengerMaterial::SetpH

(

const G4int &

ph

)

Definition at line 420 of file G4DNAScavengerMaterial.cc.

{
  auto volume = fpChemistryInfo->GetChemistryBoundary()->Volume();
  fScavengerTable[fH3Op] = floor(Avogadro * std::pow(10, -ph) * volume / liter);
  fScavengerTable[fHOm] = floor(Avogadro * std::pow(10, -(14 - ph)) * volume / liter);
}

size()

size_t G4DNAScavengerMaterial::size ( )

inline

Definition at line 75 of file G4DNAScavengerMaterial.hh.

{ return fScavengerTable.size(); }

---

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

• G4DNAScavengerMaterial.hh
• G4DNAScavengerMaterial.cc