G4EmDataHandler Class Reference

#include <G4EmDataHandler.hh>

Public Member Functions
	G4EmDataHandler (std::size_t nTable, const G4String &nam="")
	~G4EmDataHandler ()
std::size_t	SetTable (G4PhysicsTable *)
void	UpdateTable (G4PhysicsTable *, std::size_t idx)
void	SaveTable (G4PhysicsTable *, std::size_t idx)
G4PhysicsTable *	MakeTable (std::size_t idx)
G4PhysicsTable *	MakeTable (G4PhysicsTable *, std::size_t idx)
void	CleanTable (std::size_t idx)
G4bool	StorePhysicsTable (std::size_t idx, const G4ParticleDefinition *part, const G4String &fname, G4bool ascii)
G4bool	RetrievePhysicsTable (std::size_t idx, const G4ParticleDefinition *part, const G4String &fname, G4bool ascii, G4bool spline)
void	SetMasterProcess (const G4VEmProcess *)
const G4VEmProcess *	GetMasterProcess (size_t idx) const
const G4PhysicsTable *	GetTable (std::size_t idx) const
G4PhysicsTable *	Table (std::size_t idx) const
const G4PhysicsVector *	GetVector (std::size_t itable, std::size_t ivec) const
const std::vector< G4PhysicsTable * > &	GetTables () const
std::vector< G4double > *	EnergyOfCrossSectionMax () const
void	SetEnergyOfCrossSectionMax (std::vector< G4double > *p)
std::vector< G4TwoPeaksXS * > *	TwoPeaksXS () const
void	SetTwoPeaksXS (std::vector< G4TwoPeaksXS * > *p)
std::vector< G4EmElementSelector * > *	GetElementSelectors (std::size_t i)
void	SetElementSelectors (std::vector< G4EmElementSelector * > *, std::size_t)
G4CrossSectionType	CrossSectionType () const
void	SetCrossSectionType (G4CrossSectionType val)
const G4String &	GetName () const
void	SetUseBaseParticleTable (G4bool val)
G4EmDataHandler &	operator= (const G4EmDataHandler &right)=delete
	G4EmDataHandler (const G4EmDataHandler &)=delete

Detailed Description

Definition at line 65 of file G4EmDataHandler.hh.

Constructor & Destructor Documentation

G4EmDataHandler() [1/2]

G4EmDataHandler::G4EmDataHandler ( std::size_t nTable, const G4String & nam = "" )

explicit

Definition at line 53 of file G4EmDataHandler.cc.

  : tLength(n), fName(nam)
{
  data.resize(n, nullptr);
  fMaxXS = new std::vector<G4double>;
  fXSpeaks = new std::vector<G4TwoPeaksXS*>;
  G4EmDataRegistry::Instance()->Register(this);
}

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

~G4EmDataHandler()

G4EmDataHandler::~G4EmDataHandler

(

)

Definition at line 64 of file G4EmDataHandler.cc.

{
  if (!fUseBaseParticleTable) {
    for (std::size_t i=0; i<tLength; ++i) {
      CleanTable(i);
    }
    delete fMaxXS;
    delete fXSpeaks;
  }
  if (!fElemSelectors.empty()) {
    for (auto const & ptr : fElemSelectors) {
      if (nullptr != ptr) {
    for (auto const & p : *ptr) { delete p; }
      }
    }
  }
  
}

G4EmDataHandler() [2/2]

G4EmDataHandler::G4EmDataHandler ( const G4EmDataHandler & )

delete

Member Function Documentation

CleanTable()

void G4EmDataHandler::CleanTable

(

std::size_t

idx

)

Definition at line 155 of file G4EmDataHandler.cc.

{
  if (i < tLength && nullptr != data[i]) {
    auto ptr = data[i];
    ptr->clearAndDestroy();
    delete ptr;
    for (std::size_t j=0; j<tLength; ++j) {
      if (ptr == data[j]) { data[j] = nullptr; }
    }
  }
}

Referenced by MakeTable(), and ~G4EmDataHandler().

CrossSectionType()

G4CrossSectionType G4EmDataHandler::CrossSectionType ( ) const

inline

Definition at line 149 of file G4EmDataHandler.hh.

                                              {
    return fXSType;
  }

EnergyOfCrossSectionMax()

std::vector< G4double > * G4EmDataHandler::EnergyOfCrossSectionMax ( ) const

inline

Definition at line 121 of file G4EmDataHandler.hh.

                                                       {
    return fMaxXS;
  }

GetElementSelectors()

std::vector< G4EmElementSelector * > * G4EmDataHandler::GetElementSelectors ( std::size_t i )

inline

Definition at line 143 of file G4EmDataHandler.hh.

                                                                    {
    return (i < eLength) ? fElemSelectors[i] : nullptr;
  }

GetMasterProcess()

const G4VEmProcess * G4EmDataHandler::GetMasterProcess

(

size_t

idx

)

const

Definition at line 225 of file G4EmDataHandler.cc.

{
  return (idx < masterProcess.size()) ? masterProcess[idx] : nullptr;
}

GetName()

const G4String & G4EmDataHandler::GetName ( ) const

inline

Definition at line 157 of file G4EmDataHandler.hh.

                                  {
    return fName;
  }

GetTable()

const G4PhysicsTable * G4EmDataHandler::GetTable ( std::size_t idx ) const

inline

Definition at line 105 of file G4EmDataHandler.hh.

                                                      { 
    return (idx < tLength) ? data[idx] : nullptr; 
  }

GetTables()

const std::vector< G4PhysicsTable * > & G4EmDataHandler::GetTables ( ) const

inline

Definition at line 117 of file G4EmDataHandler.hh.

                                                      {
    return data;
  }

GetVector()

const G4PhysicsVector * G4EmDataHandler::GetVector ( std::size_t itable, std::size_t ivec ) const

inline

Definition at line 113 of file G4EmDataHandler.hh.

                                                                           {
    return (*(data[itable]))[ivec];
  }

MakeTable() [1/2]

G4PhysicsTable * G4EmDataHandler::MakeTable	(	G4PhysicsTable *	ptr,
		std::size_t	idx )

Definition at line 134 of file G4EmDataHandler.cc.

{
  std::size_t idx = i; 
  // create new table only if index corresponds to the
  // position in the vector
  if (idx < tLength) { 
    if (ptr != data[idx]) { 
      CleanTable(idx);
      data[idx] = ptr;
    }
  } else {
    data.push_back(ptr);
    idx = tLength;
    ++tLength;
  }
  data[idx] = G4PhysicsTableHelper::PreparePhysicsTable(data[idx]);
  return data[idx];
}

MakeTable() [2/2]

G4PhysicsTable * G4EmDataHandler::MakeTable

(

std::size_t

idx

)

Definition at line 120 of file G4EmDataHandler.cc.

{
  std::size_t idx = i; 
  if (idx >= tLength) { 
    data.push_back(nullptr);
    idx = tLength;
    ++tLength;
  }
  data[idx] = G4PhysicsTableHelper::PreparePhysicsTable(data[idx]);
  return data[idx];
}

operator=()

G4EmDataHandler & G4EmDataHandler::operator= ( const G4EmDataHandler & right )

delete

RetrievePhysicsTable()

G4bool G4EmDataHandler::RetrievePhysicsTable	(	std::size_t	idx,
		const G4ParticleDefinition *	part,
		const G4String &	fname,
		G4bool	ascii,
		G4bool	spline )

Definition at line 193 of file G4EmDataHandler.cc.

{
  G4PhysicsTable* table = Table(idx);
  G4bool yes = G4PhysicsTableHelper::RetrievePhysicsTable(table, fname, ascii, spline);
  G4EmParameters* param = G4EmParameters::Instance();
  if ( yes ) {
    if (0 < param->Verbose()) {
      G4cout << "### Physics table " << idx << " for "  
         << part->GetParticleName()
         << " is retrieved from <" << fname << ">"
         << G4endl;
    }
  } else if (1 < param->Verbose()) {
    G4cout << "### Fail to retrieve physics table " << idx << " for " 
       << part->GetParticleName() << " from <"
       << fname << ">" << G4endl;
  }
  return yes;
}

SaveTable()

void G4EmDataHandler::SaveTable	(	G4PhysicsTable *	ptr,
		std::size_t	idx )

Definition at line 111 of file G4EmDataHandler.cc.

{
  if (idx < tLength) { 
    data[idx] = ptr;
  }
}

SetCrossSectionType()

void G4EmDataHandler::SetCrossSectionType ( G4CrossSectionType val )

inline

Definition at line 153 of file G4EmDataHandler.hh.

                                                   {
    fXSType = val; 
  }

SetElementSelectors()

void G4EmDataHandler::SetElementSelectors	(	std::vector< G4EmElementSelector * > *	p,
		std::size_t	i )

Definition at line 232 of file G4EmDataHandler.cc.

{
  if (i < eLength) {
    if (fElemSelectors[i] != p) {
      delete fElemSelectors[i];
    }
    fElemSelectors[i] = p;
  } else {
    fElemSelectors.push_back(p);
    ++eLength;
  }
}

SetEnergyOfCrossSectionMax()

void G4EmDataHandler::SetEnergyOfCrossSectionMax ( std::vector< G4double > * p )

inline

Definition at line 125 of file G4EmDataHandler.hh.

                                                          {
    if (p != fMaxXS) {
      delete fMaxXS;
      fMaxXS = p;
    }
  }

SetMasterProcess()

void G4EmDataHandler::SetMasterProcess

(

const G4VEmProcess *

ptr

)

Definition at line 218 of file G4EmDataHandler.cc.

{
  masterProcess.push_back(ptr);
}

SetTable()

std::size_t G4EmDataHandler::SetTable

(

G4PhysicsTable *

ptr

)

Definition at line 85 of file G4EmDataHandler.cc.

{
  for (std::size_t i=0; i<tLength; ++i) {
    if (ptr == data[i]) { return i; }
  }
  data.push_back(ptr);
  ++tLength;
  return tLength-1; 
}

SetTwoPeaksXS()

void G4EmDataHandler::SetTwoPeaksXS ( std::vector< G4TwoPeaksXS * > * p )

inline

Definition at line 136 of file G4EmDataHandler.hh.

                                                  {
    if (p != fXSpeaks) {
      delete fXSpeaks;
      fXSpeaks = p;
    }
  }

SetUseBaseParticleTable()

void G4EmDataHandler::SetUseBaseParticleTable ( G4bool val )

inline

Definition at line 161 of file G4EmDataHandler.hh.

                                           {
    fUseBaseParticleTable = val;
  }

StorePhysicsTable()

G4bool G4EmDataHandler::StorePhysicsTable	(	std::size_t	idx,
		const G4ParticleDefinition *	part,
		const G4String &	fname,
		G4bool	ascii )

Definition at line 169 of file G4EmDataHandler.cc.

{
  G4bool yes = true;
  if(nullptr != data[idx]) {
    yes = data[idx]->StorePhysicsTable(fname, ascii);
 
    if ( yes ) {
      G4cout << "### Physics table is stored for " 
         << part->GetParticleName()
             << " <" << fname << "> " << G4endl;
    } else {
      G4cout << "### Fail to store Physics Table for " 
             << part->GetParticleName()
             << " <" << fname << "> " << G4endl;
    }
  }
  return yes;
}

Table()

G4PhysicsTable * G4EmDataHandler::Table ( std::size_t idx ) const

inline

Definition at line 109 of file G4EmDataHandler.hh.

                                             {
    return (idx < tLength) ? data[idx] : nullptr; 
  }

Referenced by RetrievePhysicsTable().

TwoPeaksXS()

std::vector< G4TwoPeaksXS * > * G4EmDataHandler::TwoPeaksXS ( ) const

inline

Definition at line 132 of file G4EmDataHandler.hh.

                                               {
    return fXSpeaks;
  }

UpdateTable()

void G4EmDataHandler::UpdateTable	(	G4PhysicsTable *	ptr,
		std::size_t	idx )

Definition at line 97 of file G4EmDataHandler.cc.

{
  // update table pointer but not delete previous
  if (idx < tLength) { 
    if (ptr != data[idx]) { data[idx] = ptr; }
    data[idx] = G4PhysicsTableHelper::PreparePhysicsTable(data[idx]);
  } else {
    G4cout << "### G4EmDataHandler::UpdateTable fail for idx=" << idx 
           << " length=" << tLength << G4endl;
  }
}

---

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

• G4EmDataHandler.hh
• G4EmDataHandler.cc