#include <G4DNAScavengerMaterial.hh>

Inheritance diagram for G4DNAScavengerMaterial:

Data Structures
struct	Search

Public Types
using	CounterMapType = std::map< MolType, NbMoleculeAgainstTime >

using	MaterialMap = std::map< MolType, G4double >

using	MolType = const G4MolecularConfiguration *

using	ReactantList = std::vector< MolType >

Public Member Functions
void	AddAMoleculeAtTime (MolType, G4double time, const G4ThreeVector *position=nullptr, G4int number=1)

void	AddNumberMoleculePerVolumeUnitForMaterialConf (MolType, G4double)

MaterialMap::iterator	begin ()

void	Dump ()

MaterialMap::iterator	end ()

G4bool	find (MolType type)

	G4DNAScavengerMaterial ()=default

	G4DNAScavengerMaterial (const G4DNAScavengerMaterial &right)=delete

	G4DNAScavengerMaterial (G4VChemistryWorld *)

G4int	GetNMoleculesAtTime (MolType molecule, G4double time)

G4double	GetNumberMoleculePerVolumeUnitForMaterialConf (MolType) const

std::vector< MolType >	GetScavengerList () const

void	Initialize ()

G4DNAScavengerMaterial &	operator= (const G4DNAScavengerMaterial &)=delete

void	PrintInfo ()

void	ReduceNumberMoleculePerVolumeUnitForMaterialConf (MolType, G4double)

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

void	Reset () override

G4bool	SearchTimeMap (MolType molecule)

G4int	SearchUpperBoundTime (G4double time, G4bool sameTypeOfMolecule)

void	SetCounterAgainstTime ()

size_t	size ()

	~G4DNAScavengerMaterial () override=default

Private Attributes
G4bool	fCounterAgainstTime

CounterMapType	fCounterMap

G4bool	fIsInitialized

G4VChemistryWorld *	fpChemistryInfo

std::unique_ptr< Search >	fpLastSearch

std::map< MolType, G4double >	fScavengerTable

G4int	fVerbose

Detailed Description

Definition at line 42 of file G4DNAScavengerMaterial.hh.

Member Typedef Documentation

◆ CounterMapType

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

Definition at line 48 of file G4DNAScavengerMaterial.hh.

◆ MaterialMap

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

Definition at line 46 of file G4DNAScavengerMaterial.hh.

◆ MolType

using G4DNAScavengerMaterial::MolType = const G4MolecularConfiguration*

Definition at line 45 of file G4DNAScavengerMaterial.hh.

◆ ReactantList

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

Definition at line 47 of file G4DNAScavengerMaterial.hh.

Constructor & Destructor Documentation

◆ G4DNAScavengerMaterial() [1/3]

G4DNAScavengerMaterial::G4DNAScavengerMaterial ( )

default

◆ G4DNAScavengerMaterial() [2/3]

G4DNAScavengerMaterial::G4DNAScavengerMaterial ( G4VChemistryWorld * pChemistryInfo )

explicit

Definition at line 44 of file G4DNAScavengerMaterial.cc.

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

References 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 226 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::TimePrecision::fPrecision)
    {
      G4double newValue            = end->second + number;
      counterMap_i->second[time] = newValue;
      if(newValue != (floor)(fScavengerTable[molecule]))  // protection
      {
        assert(false);
      }
      // G4cout<<" AddAMoleculeAtTime : "<<molecule->GetName()<< " :
      // "<<newValue<<G4endl;
    }
    //        else
    //        {
    //
    //            G4ExceptionDescription errMsg;
    //            errMsg << "Time of species "
    //                   << molecule->GetName() << " is "
    //                   << G4BestUnit(time, "Time") << " while "
    //                   << " global time is "
    //                   <<" end->first : "<<end->first
    //                   //<<
    //                   G4BestUnit(G4Scheduler::Instance()->GetGlobalTime(),
    //                   "Time")
    //                   << G4endl;
    //            G4Exception("G4DNAScavengerMaterial::AddAMoleculeAtTime",
    //                        "TIME_DONT_MATCH",
    //                        FatalException, errMsg);
    //        }
  }
}

References end(), fCounterMap, G4::MoleculeCounter::TimePrecision::fPrecision, fScavengerTable, fVerbose, G4BestUnit, G4cout, G4endl, and G4MolecularConfiguration::GetName().

Referenced by AddNumberMoleculePerVolumeUnitForMaterialConf().

◆ AddNumberMoleculePerVolumeUnitForMaterialConf()

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

Definition at line 133 of file G4DNAScavengerMaterial.cc.

{
  // no change these molecules
 
  if(G4MoleculeTable::Instance()->GetConfiguration("H2O") == matConf ||
     G4MoleculeTable::Instance()->GetConfiguration("H3Op(B)") ==
       matConf ||  // pH has no change
     G4MoleculeTable::Instance()->GetConfiguration("OHm(B)") == 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);
  }
}

References AddAMoleculeAtTime(), fCounterAgainstTime, fScavengerTable, and G4MoleculeTable::Instance().

Referenced by G4DNAUpdateSystemModel::CreateMolecule().

◆ begin()

MaterialMap::iterator G4DNAScavengerMaterial::begin ( )

inline

Definition at line 72 of file G4DNAScavengerMaterial.hh.

72{ return fScavengerTable.begin(); }

References fScavengerTable.

◆ Dump()

void G4DNAScavengerMaterial::Dump ( )

Definition at line 355 of file G4DNAScavengerMaterial.cc.

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

References source.hepunit::Avogadro, fCounterMap, fpChemistryInfo, G4BestUnit, G4cout, G4endl, G4VChemistryWorld::GetChemistryBoundary(), and G4DNABoundingBox::Volume().

Referenced by PrintInfo(), and RemoveAMoleculeAtTime().

◆ end()

MaterialMap::iterator G4DNAScavengerMaterial::end ( )

inline

Definition at line 71 of file G4DNAScavengerMaterial.hh.

71{ return fScavengerTable.end(); }

References fScavengerTable.

Referenced by AddAMoleculeAtTime().

◆ find()

G4bool G4DNAScavengerMaterial::find ( MolType type )

inline

Definition at line 75 of file G4DNAScavengerMaterial.hh.

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

References fScavengerTable.

Referenced by ReduceNumberMoleculePerVolumeUnitForMaterialConf().

◆ GetNMoleculesAtTime()

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

Definition at line 373 of file G4DNAScavengerMaterial.cc.

{
  if(!fCounterAgainstTime)
  {
    G4cout << "fCounterAgainstTime == false" << G4endl;
    assert(false);
  }
 
  G4bool sameTypeOfMolecule = SearchTimeMap(molecule);
  return SearchUpperBoundTime(time, sameTypeOfMolecule);
}

References fCounterAgainstTime, G4cout, G4endl, SearchTimeMap(), and SearchUpperBoundTime().

◆ GetNumberMoleculePerVolumeUnitForMaterialConf()

G4double G4DNAScavengerMaterial::GetNumberMoleculePerVolumeUnitForMaterialConf ( MolType matConf ) const

Definition at line 72 of file G4DNAScavengerMaterial.cc.

{
  // no change these molecules
  if(G4MoleculeTable::Instance()->GetConfiguration("H2O") == matConf)
  {
    G4ExceptionDescription exceptionDescription;
    exceptionDescription << "matConf : "<<matConf->GetName();
    G4Exception("G4DNAScavengerMaterial::GetNumberMoleculePerVolumeUnitForMaterialConf", "G4DNAScavengerMaterial001",
                FatalErrorInArgument, exceptionDescription);
  }
 
  auto iter = fScavengerTable.find(matConf);
  if(iter == fScavengerTable.end())
  {
    // G4cout<<matConf->GetName()<<G4endl;
    // throw std::runtime_error("this material is not existed");
    return 0;
  }
  else
  {
    if(iter->second >= 1)
    {
      return (floor)(iter->second);
    }
    else
    {
      return 0;
    }
  }
}

References FatalErrorInArgument, fScavengerTable, G4Exception(), G4MolecularConfiguration::GetName(), and G4MoleculeTable::Instance().

Referenced by G4DNAGillespieDirectMethod::FindScavenging(), and G4DNAScavengerProcess::PostStepGetPhysicalInteractionLength().

◆ GetScavengerList()

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

inline

Definition at line 90 of file G4DNAScavengerMaterial.hh.

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

References fScavengerTable.

◆ Initialize()

void G4DNAScavengerMaterial::Initialize ( )

Definition at line 57 of file G4DNAScavengerMaterial.cc.

{
  if(fIsInitialized)
  {
    return;
  }
 
  if(fpChemistryInfo->size() == 0)
  {
    G4cout << "G4DNAScavengerMaterial existed but empty" << G4endl;
  }
  Reset();
  fIsInitialized = true;
}

References fIsInitialized, fpChemistryInfo, G4cout, G4endl, Reset(), and G4VChemistryWorld::size().

Referenced by G4DNAScavengerMaterial().

◆ operator=()

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

delete

◆ PrintInfo()

void G4DNAScavengerMaterial::PrintInfo ( )

Definition at line 161 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;
}

References source.hepunit::Avogadro, G4VChemistryWorld::begin(), Dump(), G4VChemistryWorld::end(), fpChemistryInfo, fScavengerTable, fVerbose, G4cout, G4endl, G4VChemistryWorld::GetChemistryBoundary(), and um.

Referenced by Reset().

◆ ReduceNumberMoleculePerVolumeUnitForMaterialConf()

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

Definition at line 104 of file G4DNAScavengerMaterial.cc.

{
  // no change these molecules
  if(G4MoleculeTable::Instance()->GetConfiguration("H2O") == matConf ||
     G4MoleculeTable::Instance()->GetConfiguration("H3Op(B)") ==
       matConf ||  // suppose that pH is not changed during simu
     G4MoleculeTable::Instance()->GetConfiguration("OHm(B)") == 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);
  }
}

References fCounterAgainstTime, find(), fScavengerTable, G4MoleculeTable::Instance(), and RemoveAMoleculeAtTime().

Referenced by G4DNAUpdateSystemModel::KillMolecule(), and G4DNAScavengerProcess::PostStepDoIt().

◆ RemoveAMoleculeAtTime()

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

Definition at line 285 of file G4DNAScavengerMaterial.cc.

{
  NbMoleculeAgainstTime& 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;
  }
  else
  {
    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);
    }
  }
}

References Dump(), FatalErrorInArgument, FatalException, fCounterMap, fScavengerTable, fVerbose, G4BestUnit, G4cout, G4endl, G4Exception(), G4MolecularConfiguration::GetName(), and G4Scheduler::Instance().

Referenced by ReduceNumberMoleculePerVolumeUnitForMaterialConf().

◆ Reset()

void G4DNAScavengerMaterial::Reset ( )

overridevirtual

Implements G4VScavengerMaterial.

Definition at line 194 of file G4DNAScavengerMaterial.cc.

{
  if(fpChemistryInfo == nullptr)
  {
    return;
  }
 
  if(fpChemistryInfo->size() == 0)
  {
    return;
  }
 
  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());
  }
  PrintInfo();
}

References source.hepunit::Avogadro, G4VChemistryWorld::begin(), G4VChemistryWorld::end(), fCounterMap, fpChemistryInfo, fpLastSearch, fScavengerTable, G4VChemistryWorld::GetChemistryBoundary(), picosecond, PrintInfo(), and G4VChemistryWorld::size().

Referenced by Initialize().

◆ SearchTimeMap()

G4bool G4DNAScavengerMaterial::SearchTimeMap ( MolType molecule )

Definition at line 385 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;
}

References fCounterMap, and fpLastSearch.

Referenced by GetNMoleculesAtTime().

◆ SearchUpperBoundTime()

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

Definition at line 419 of file G4DNAScavengerMaterial.cc.

{
  auto mol_it = fpLastSearch->fLastMoleculeSearched;
  if(mol_it == fCounterMap.end())
  {
    return 0;
  }
 
  NbMoleculeAgainstTime& 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;
}

References fCounterMap, and fpLastSearch.

Referenced by GetNMoleculesAtTime().

◆ SetCounterAgainstTime()

void G4DNAScavengerMaterial::SetCounterAgainstTime ( )

inline

Definition at line 88 of file G4DNAScavengerMaterial.hh.

88{ fCounterAgainstTime = true; }

References fCounterAgainstTime.

◆ size()

size_t G4DNAScavengerMaterial::size ( )

inline

Definition at line 73 of file G4DNAScavengerMaterial.hh.

73{ return fScavengerTable.size(); }

References fScavengerTable.

Field Documentation

◆ fCounterAgainstTime

G4bool G4DNAScavengerMaterial::fCounterAgainstTime

private

Definition at line 110 of file G4DNAScavengerMaterial.hh.

Referenced by AddNumberMoleculePerVolumeUnitForMaterialConf(), GetNMoleculesAtTime(), ReduceNumberMoleculePerVolumeUnitForMaterialConf(), and SetCounterAgainstTime().

◆ fCounterMap

CounterMapType G4DNAScavengerMaterial::fCounterMap

private

Definition at line 109 of file G4DNAScavengerMaterial.hh.

Referenced by AddAMoleculeAtTime(), Dump(), RemoveAMoleculeAtTime(), Reset(), SearchTimeMap(), and SearchUpperBoundTime().

◆ fIsInitialized

G4bool G4DNAScavengerMaterial::fIsInitialized

private

Definition at line 107 of file G4DNAScavengerMaterial.hh.

Referenced by Initialize().

◆ fpChemistryInfo

G4VChemistryWorld* G4DNAScavengerMaterial::fpChemistryInfo

private

Definition at line 106 of file G4DNAScavengerMaterial.hh.

Referenced by Dump(), Initialize(), PrintInfo(), and Reset().

◆ fpLastSearch

std::unique_ptr<Search> G4DNAScavengerMaterial::fpLastSearch

private

Definition at line 120 of file G4DNAScavengerMaterial.hh.

Referenced by Reset(), SearchTimeMap(), and SearchUpperBoundTime().

◆ fScavengerTable

std::map<MolType, G4double> G4DNAScavengerMaterial::fScavengerTable

private

Definition at line 108 of file G4DNAScavengerMaterial.hh.

Referenced by AddAMoleculeAtTime(), AddNumberMoleculePerVolumeUnitForMaterialConf(), begin(), end(), find(), GetNumberMoleculePerVolumeUnitForMaterialConf(), GetScavengerList(), PrintInfo(), ReduceNumberMoleculePerVolumeUnitForMaterialConf(), RemoveAMoleculeAtTime(), Reset(), and size().

◆ fVerbose

G4int G4DNAScavengerMaterial::fVerbose

private

Definition at line 111 of file G4DNAScavengerMaterial.hh.

Referenced by AddAMoleculeAtTime(), PrintInfo(), and RemoveAMoleculeAtTime().

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

source/processes/electromagnetic/dna/utils/include/G4DNAScavengerMaterial.hh
source/processes/electromagnetic/dna/utils/src/G4DNAScavengerMaterial.cc

Data Structures

Public Types

Public Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ CounterMapType

◆ MaterialMap

◆ MolType

◆ ReactantList

Constructor & Destructor Documentation

◆ G4DNAScavengerMaterial() [1/3]

◆ G4DNAScavengerMaterial() [2/3]

◆ ~G4DNAScavengerMaterial()

◆ G4DNAScavengerMaterial() [3/3]

Member Function Documentation

◆ AddAMoleculeAtTime()

◆ AddNumberMoleculePerVolumeUnitForMaterialConf()

◆ begin()

◆ Dump()

◆ end()

◆ find()

◆ GetNMoleculesAtTime()

◆ GetNumberMoleculePerVolumeUnitForMaterialConf()

◆ GetScavengerList()

◆ Initialize()

◆ operator=()

◆ PrintInfo()

◆ ReduceNumberMoleculePerVolumeUnitForMaterialConf()

◆ RemoveAMoleculeAtTime()

◆ Reset()

◆ SearchTimeMap()

◆ SearchUpperBoundTime()

◆ SetCounterAgainstTime()

◆ size()

Field Documentation

◆ fCounterAgainstTime

◆ fCounterMap

◆ fIsInitialized

◆ fpChemistryInfo

◆ fpLastSearch

◆ fScavengerTable

◆ fVerbose