G4PhysicsTableHelper Class Reference

#include <G4PhysicsTableHelper.hh>

Public Member Functions
	G4PhysicsTableHelper (const G4PhysicsTableHelper &)=delete
G4PhysicsTableHelper &	operator= (const G4PhysicsTableHelper &)=delete

Static Public Member Functions
static G4PhysicsTable *	PreparePhysicsTable (G4PhysicsTable *physTable)
static G4bool	RetrievePhysicsTable (G4PhysicsTable *physTable, const G4String &fileName, G4bool ascii, G4bool spline)
static void	SetPhysicsVector (G4PhysicsTable *physTable, std::size_t idx, G4PhysicsVector *vec)
static void	SetVerboseLevel (G4int value)
static G4int	GetVerboseLevel ()

Protected Member Functions
	G4PhysicsTableHelper ()
	~G4PhysicsTableHelper ()

Static Protected Attributes
static G4int	verboseLevel = 1

Detailed Description

Definition at line 42 of file G4PhysicsTableHelper.hh.

Constructor & Destructor Documentation

G4PhysicsTableHelper() [1/2]

G4PhysicsTableHelper::G4PhysicsTableHelper ( const G4PhysicsTableHelper & )

delete

G4PhysicsTableHelper() [2/2]

G4PhysicsTableHelper::G4PhysicsTableHelper ( )

protected

Definition at line 40 of file G4PhysicsTableHelper.cc.

{
}

~G4PhysicsTableHelper()

G4PhysicsTableHelper::~G4PhysicsTableHelper ( )

protected

Definition at line 45 of file G4PhysicsTableHelper.cc.

{
}

Member Function Documentation

GetVerboseLevel()

G4int G4PhysicsTableHelper::GetVerboseLevel ( )

static

Definition at line 213 of file G4PhysicsTableHelper.cc.

{
  return verboseLevel;
}

operator=()

G4PhysicsTableHelper & G4PhysicsTableHelper::operator= ( const G4PhysicsTableHelper & )

delete

PreparePhysicsTable()

G4PhysicsTable * G4PhysicsTableHelper::PreparePhysicsTable ( G4PhysicsTable * physTable )

static

Definition at line 51 of file G4PhysicsTableHelper.cc.

{
  G4ProductionCutsTable* cutTable
    = G4ProductionCutsTable::GetProductionCutsTable();
  std::size_t numberOfMCC = cutTable->GetTableSize(); 
 
  if ( physTable != nullptr )
  {
    // compare size of physics table and number of material-cuts-couple
    if ( physTable->size() < numberOfMCC )
    {
#ifdef G4VERBOSE  
      if (verboseLevel>2)
      {
        G4cout << "G4PhysicsTableHelper::PreparePhysicsTable: "
               << " the table " << physTable << " size="
           << physTable->size()
               << " will be is resized to " << numberOfMCC << G4endl;
      }
#endif 
      // enlarge physics table
      physTable->resize(numberOfMCC, nullptr);
    }
    else if ( physTable->size() > numberOfMCC )
    {
      // ERROR: this situation should not occur  
      // size of physics table is larger than number of material-cuts-couple
      G4ExceptionDescription ed;
      ed << "table " << physTable << " size=" << physTable->size()
     << " is longer than number of material-cuts-couple " << numberOfMCC; 
      G4Exception( "G4PhysicsTableHelper::PreparePhysicsTable()",
                   "ProcCuts001", FatalException, ed);
    } 
  }
  else
  {
    // create PhysicsTable is given poitner is null
    physTable = new G4PhysicsTable();
    physTable->resize(numberOfMCC, nullptr);
  }
 
#ifdef G4VERBOSE  
  if (verboseLevel>2)
  {
    G4cout << "G4PhysicsTableHelper::PreparePhysicsTable: "
       << " the table "<< physTable
       << " size=" << numberOfMCC << G4endl;
  }
#endif 
 
  // Reset recal-needed flag for all physics vectors
  physTable->ResetFlagArray();
 
  for (std::size_t idx = 0; idx <numberOfMCC; ++idx)
  {
    const G4MaterialCutsCouple* mcc = cutTable->GetMaterialCutsCouple((G4int)idx);
 
    // check if re-calculation of the physics vector is needed 
    // MCC is not used
    if ( !mcc->IsUsed() ) physTable->ClearFlag(idx);
 
    // RecalcNeeded flag of MCC is not asserted 
    if ( !mcc->IsRecalcNeeded() ) physTable->ClearFlag(idx);
  }
  
  return physTable;
}

Referenced by G4LossTableBuilder::BuildTableForModel(), G4WentzelVIModel::Initialise(), G4EmDataHandler::MakeTable(), and G4EmDataHandler::MakeTable().

RetrievePhysicsTable()

G4bool G4PhysicsTableHelper::RetrievePhysicsTable ( G4PhysicsTable * physTable, const G4String & fileName, G4bool ascii, G4bool spline )

static

Definition at line 120 of file G4PhysicsTableHelper.cc.

{
  if (physTable == nullptr ) return false;
  
  // retrieve physics table from the given file
  G4PhysicsTable* tempTable = new G4PhysicsTable();
  if (! tempTable->RetrievePhysicsTable(fileName,ascii,spline) )
  {
    G4ExceptionDescription ed;
    ed << "Cannot retrieve physics table from the file <" << fileName << ">";
    G4Exception( "G4ProductionCutsTable::RetrievePhysicsTable()",
                 "ProcCuts105", JustWarning, ed);
    delete tempTable;
    return false;
  } 
 
  G4ProductionCutsTable* cutTable
    = G4ProductionCutsTable::GetProductionCutsTable();  
  const G4MCCIndexConversionTable* converter
    = cutTable->GetMCCIndexConversionTable();
 
  // check physics table size
  if ( tempTable->size() != converter->size())
  {
    G4ExceptionDescription ed;
    ed << "Physics table in " << fileName
       << "\n   size=" << tempTable->size() << " "
       << " is inconsistent with material-cut-couple "
       << "size=" << converter->size() << " the table is not retrieved!";
    G4Exception("G4ProductionCutsTable::RetrievePhysicsTable()",
                "ProcCuts106", JustWarning, ed);
    delete tempTable;
    return false;
  }
  
  // fill the given physics table with retrieved physics vectors 
  for (std::size_t idx=0; idx<converter->size(); ++idx)
  {
    if (converter->IsUsed(idx))
    {
      G4int i = converter->GetIndex(idx);
      if(i < 0) 
      {
        tempTable->clearAndDestroy();
    delete tempTable;
    return false;
      } 
      G4PhysicsVector* vec = (*physTable)[i];
      if (vec != nullptr ) delete vec;
      (*physTable)[i] = (*tempTable)[idx];
      physTable->ClearFlag(i);
    }
  }
  tempTable->clear();
  delete tempTable;
 
  return true;
}

Referenced by G4EmDataHandler::RetrievePhysicsTable(), and G4EmTableUtil::RetrieveTable().

SetPhysicsVector()

void G4PhysicsTableHelper::SetPhysicsVector ( G4PhysicsTable * physTable, std::size_t idx, G4PhysicsVector * vec )

static

Definition at line 182 of file G4PhysicsTableHelper.cc.

{
  if ( physTable == nullptr) {  return;  }
 
  if ( physTable->size() <= idx)
  {
    G4ExceptionDescription ed;
    ed << "Given index (" << idx << ")  exceeds "
       << "the size of the physics table "
       << "( size =" << physTable->size() << ") the vector is not added!";
    G4Exception("G4ProductionCutsTable::SetPhysicsVector()",
                "ProcCuts107",
                JustWarning, ed);
    return;
  } 
 
  // set physics vector 
  (*physTable)[idx] = vec;
  // clear flag
  physTable->ClearFlag(idx);
}

Referenced by G4EmTableUtil::BuildDEDXTable(), G4LossTableBuilder::BuildDEDXTable(), G4LossTableBuilder::BuildInverseRangeTable(), G4EmTableUtil::BuildLambdaTable(), G4EmTableUtil::BuildLambdaTable(), G4TransportationWithMsc::BuildPhysicsTable(), G4LossTableBuilder::BuildRangeTable(), G4LossTableBuilder::BuildTableForModel(), G4GammaGeneralProcess::InitialiseProcess(), and G4NeutronGeneralProcess::PreparePhysicsTable().

SetVerboseLevel()

void G4PhysicsTableHelper::SetVerboseLevel ( G4int value )

static

Definition at line 207 of file G4PhysicsTableHelper.cc.

{
  if( !G4Threading::IsWorkerThread() ) verboseLevel = value;
}

Member Data Documentation

verboseLevel

G4int G4PhysicsTableHelper::verboseLevel = 1

staticprotected

Definition at line 77 of file G4PhysicsTableHelper.hh.

Referenced by GetVerboseLevel(), PreparePhysicsTable(), and SetVerboseLevel().

---

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

• G4PhysicsTableHelper.hh
• G4PhysicsTableHelper.cc