G4ProductionCutsTable Class Reference

#include <G4ProductionCutsTable.hh>

Public Member Functions
	G4ProductionCutsTable (const G4ProductionCutsTable &)=delete
G4ProductionCutsTable &	operator= (const G4ProductionCutsTable &)=delete
virtual	~G4ProductionCutsTable ()
void	UpdateCoupleTable (G4VPhysicalVolume *currentWorld)
void	SetEnergyRange (G4double lowedge, G4double highedge)
G4double	GetLowEdgeEnergy () const
G4double	GetHighEdgeEnergy () const
G4double	GetMaxEnergyCut ()
void	SetMaxEnergyCut (G4double value)
void	DumpCouples () const
const G4MCCIndexConversionTable *	GetMCCIndexConversionTable () const
const std::vector< G4double > *	GetRangeCutsVector (std::size_t pcIdx) const
const std::vector< G4double > *	GetEnergyCutsVector (std::size_t pcIdx) const
std::size_t	GetTableSize () const
const G4MaterialCutsCouple *	GetMaterialCutsCouple (G4int i) const
const G4MaterialCutsCouple *	GetMaterialCutsCouple (const G4Material *aMat, const G4ProductionCuts *aCut) const
G4int	GetCoupleIndex (const G4MaterialCutsCouple *aCouple) const
G4int	GetCoupleIndex (const G4Material *aMat, const G4ProductionCuts *aCut) const
G4bool	IsModified () const
void	PhysicsTableUpdated ()
G4ProductionCuts *	GetDefaultProductionCuts () const
G4double	ConvertRangeToEnergy (const G4ParticleDefinition *particle, const G4Material *material, G4double range)
void	ResetConverters ()
G4bool	StoreCutsTable (const G4String &directory, G4bool ascii=false)
G4bool	RetrieveCutsTable (const G4String &directory, G4bool ascii=false)
G4bool	CheckForRetrieveCutsTable (const G4String &directory, G4bool ascii=false)
G4double *	GetRangeCutsDoubleVector (std::size_t pcIdx) const
G4double *	GetEnergyCutsDoubleVector (std::size_t pcIdx) const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Static Public Member Functions
static G4ProductionCutsTable *	GetProductionCutsTable ()

Protected Member Functions
	G4ProductionCutsTable ()
virtual G4bool	StoreMaterialInfo (const G4String &directory, G4bool ascii=false)
virtual G4bool	CheckMaterialInfo (const G4String &directory, G4bool ascii=false)
virtual G4bool	StoreMaterialCutsCoupleInfo (const G4String &directory, G4bool ascii=false)
virtual G4bool	CheckMaterialCutsCoupleInfo (const G4String &directory, G4bool ascii=false)
virtual G4bool	StoreCutsInfo (const G4String &directory, G4bool ascii=false)
virtual G4bool	RetrieveCutsInfo (const G4String &directory, G4bool ascii=false)

Detailed Description

Definition at line 56 of file G4ProductionCutsTable.hh.

Constructor & Destructor Documentation

G4ProductionCutsTable() [1/2]

G4ProductionCutsTable::G4ProductionCutsTable ( const G4ProductionCutsTable &  )

delete

~G4ProductionCutsTable()

G4ProductionCutsTable::~G4ProductionCutsTable ( )

virtual

Definition at line 87 of file G4ProductionCutsTable.cc.

{
  delete defaultProductionCuts;
  defaultProductionCuts = nullptr;
 
  for(auto itr=coupleTable.cbegin(); itr!=coupleTable.cend(); ++itr)
  {
    delete (*itr); 
  }
  coupleTable.clear();
 
  for(std::size_t i=0; i< NumberOfG4CutIndex; ++i)
  {
    delete rangeCutTable[i];
    delete energyCutTable[i];
    delete converters[i];
    if(rangeDoubleVector[i] != nullptr) delete [] rangeDoubleVector[i];
    if(energyDoubleVector[i] != nullptr) delete [] energyDoubleVector[i];
    rangeCutTable[i] = nullptr;
    energyCutTable[i] = nullptr;
    converters[i] = nullptr;
    rangeDoubleVector[i] = nullptr;
    energyDoubleVector[i] = nullptr;
  }
  fProductionCutsTable = nullptr;
 
  delete fMessenger;
  fMessenger = nullptr;
}

G4ProductionCutsTable() [2/2]

G4ProductionCutsTable::G4ProductionCutsTable ( )

protected

Definition at line 69 of file G4ProductionCutsTable.cc.

{
  for(std::size_t i=0; i< NumberOfG4CutIndex; ++i)
  {
    rangeCutTable.push_back(new std::vector<G4double>);
    energyCutTable.push_back(new std::vector<G4double>);
    rangeDoubleVector[i] = nullptr;
    energyDoubleVector[i] = nullptr;
    converters[i] = nullptr;
  }
  fG4RegionStore = G4RegionStore::GetInstance();
  defaultProductionCuts = new G4ProductionCuts();
 
  // add messenger for UI 
  fMessenger = new G4ProductionCutsTableMessenger(this);
}

Member Function Documentation

CheckForRetrieveCutsTable()

G4bool G4ProductionCutsTable::CheckForRetrieveCutsTable	(	const G4String &	directory,
		G4bool	ascii = false
	)

Definition at line 510 of file G4ProductionCutsTable.cc.

{
  // check stored material and cut values are consistent
  // with the current detector setup
 
  G4cerr << "G4ProductionCutsTable::CheckForRetrieveCutsTable()"<< G4endl;
  //  isNeedForRestoreCoupleInfo = false;
  if (!CheckMaterialInfo(directory, ascii)) return false;
  if (verboseLevel >2)
  {
      G4cerr << "G4ProductionCutsTable::CheckMaterialInfo passed !!"<< G4endl;
  }
  if (!CheckMaterialCutsCoupleInfo(directory, ascii)) return false;
  if (verboseLevel >2)
  {
    G4cerr << "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo passed !!"
           << G4endl;
  }
  return true;
}

Referenced by RetrieveCutsTable().

CheckMaterialCutsCoupleInfo()

G4bool G4ProductionCutsTable::CheckMaterialCutsCoupleInfo ( const G4String &  directory, G4bool  ascii = false  )

protectedvirtual

Definition at line 921 of file G4ProductionCutsTable.cc.

{
  // Check stored materialCutsCouple is consistent
  // with the current detector setup. 
 
  const G4String fileName = directory + "/" + "couple.dat";
  const G4String key = "COUPLE-V3.0";
  std::ifstream fIn;  
 
  // open input file
  if (!ascii ) fIn.open(fileName,std::ios::in|std::ios::binary);
  else         fIn.open(fileName,std::ios::in);
 
  // check if the file has been opened successfully 
  if (!fIn)
  {
#ifdef G4VERBOSE
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo() - ";
      G4cerr << "Cannot open file!" << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo()",
                 "ProcCuts102", JustWarning, "Cannot open file!");
    return false;
  }
  
  char temp[FixedStringLengthForStore];
 
   // key word
  G4String keyword;    
  if (ascii)
  {
    fIn >> keyword;
  }
  else
  {
    fIn.read(temp, FixedStringLengthForStore);
    keyword = (const char*)(temp);
  }
  if (key!=keyword)
  {
#ifdef G4VERBOSE
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo() - ";
      G4cerr << "Key word in " << fileName << "= " << keyword ;
      G4cerr <<"( should be   "<< key << ")" << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo()",
                 "ProcCuts103", JustWarning, "Bad Data Format");
    fIn.close();
    return false;
  }
 
  // numberOfCouples
  G4int numberOfCouples;    
  if (ascii)
  {
    fIn >> numberOfCouples;
  }
  else
  {
    fIn.read( (char*)(&numberOfCouples), sizeof(G4int));
  }
 
  // Reset MCCIndexConversionTable
  mccConversionTable.Reset(numberOfCouples);  
 
  // Read in couple information
  for (G4int idx=0; idx<numberOfCouples; ++idx)
  {
    // read in index
    G4int index; 
    if (ascii)
    {
      fIn >> index;
    }
    else
    {
      fIn.read( (char*)(&index), sizeof(G4int));
    }
    // read in index material name
    char mat_name[FixedStringLengthForStore];
    if (ascii)
    {
      fIn >> mat_name;
    }
    else
    {
      fIn.read(mat_name, FixedStringLengthForStore);
    }
    // read in index and region name
    char region_name[FixedStringLengthForStore];
    if (ascii)
    {
      fIn >> region_name;
    }
    else
    {
      fIn.read(region_name, FixedStringLengthForStore);
    }
    // cut value
    G4double cutValues[NumberOfG4CutIndex];
    for (std::size_t i=0; i< NumberOfG4CutIndex; ++i)
    {
      if (ascii)
      {
        fIn >>  cutValues[i];
        cutValues[i] *= (mm);
      }
      else
      {
        fIn.read( (char*)(&(cutValues[i])), sizeof(G4double));
      }
    }
 
    // Loop over all couples
    G4bool fOK = false;
    G4MaterialCutsCouple* aCouple = nullptr;
    for (auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
    {
      aCouple = (*cItr);
      // check material name
      if ( mat_name !=  aCouple->GetMaterial()->GetName() ) continue;
      // check cut values
      G4ProductionCuts* aCut = aCouple->GetProductionCuts();
      G4bool fRatio = true;
      for (std::size_t j=0; j< NumberOfG4CutIndex; ++j)
      {
        // check ratio only if values are not the same
        if (cutValues[j] != aCut->GetProductionCut((G4int)j))
        {  
          G4double ratio =  cutValues[j]/aCut->GetProductionCut((G4int)j);
          fRatio = fRatio && (0.999<ratio) && (ratio<1.001) ;
        }
      } 
      if (!fRatio) continue; 
      // MCC matched 
      fOK = true;
      mccConversionTable.SetNewIndex(index, aCouple->GetIndex()); 
      break;
    }
 
    if (fOK)
    {
#ifdef G4VERBOSE
      // debug information 
      if (verboseLevel >1)
      {
        G4String regionname(region_name);
        G4Region* fRegion = nullptr;
        if ( regionname != "NONE" )
        {
          fRegion = fG4RegionStore->GetRegion(region_name);
          if (fRegion == nullptr)
          {
            G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo() - ";
            G4cout << "Region " << regionname << " is not found ";            
            G4cout << index << ": in " << fileName  << G4endl;
          } 
        }
        if  (((regionname == "NONE") && (aCouple->IsUsed()))
         || ((fRegion!=nullptr) && !IsCoupleUsedInTheRegion(aCouple, fRegion)))
        {
          G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo()"
                 << G4endl;
          G4cout << "A Couple is used different region in the current setup ";
          G4cout << index << ": in " << fileName  << G4endl;
          G4cout << " material: " << mat_name ;
          G4cout << " region: " << region_name << G4endl;
          for (std::size_t ii=0; ii< NumberOfG4CutIndex; ++ii)
          {
            G4cout << "cut[" << ii << "]=" << cutValues[ii]/mm;
            G4cout << " mm   :  ";
          } 
          G4cout << G4endl;
        }
        else if ( index !=  aCouple->GetIndex() )
        {
          G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo() - ";
          G4cout << "Index of couples was modified "<< G4endl;
          G4cout << aCouple->GetIndex() << ":"
                 << aCouple->GetMaterial()->GetName();
          G4cout <<" is defined as " ;
          G4cout << index << ":"  << mat_name << " in " << fileName << G4endl;
        }
        else
        {
          G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo() - ";
          G4cout << index << ":"  << mat_name << " in " << fileName ;
          G4cout << " is consistent with current setup" << G4endl;
        }
      }
#endif
    }
    else
    {
#ifdef G4VERBOSE
      if (verboseLevel >0)
      {
        G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo()"
               << G4endl;
        G4cout << "Couples are not defined in the current detector setup ";
        G4cout << index << ": in " << fileName  << G4endl;
        G4cout << " material: " << mat_name ;
        G4cout << " region: " << region_name << G4endl;
        for (std::size_t ii=0; ii< NumberOfG4CutIndex; ++ii)
        {
          G4cout << "cut[" << ii << "]=" << cutValues[ii]/mm;
          G4cout << " mm   :  ";
        }
        G4cout << G4endl;
      }
#endif
    }
  }
  fIn.close();
  return true;
}

Referenced by CheckForRetrieveCutsTable().

CheckMaterialInfo()

G4bool G4ProductionCutsTable::CheckMaterialInfo ( const G4String &  directory, G4bool  ascii = false  )

protectedvirtual

Definition at line 627 of file G4ProductionCutsTable.cc.

{
  // Check stored material is consistent with the current detector setup
 
  const G4String fileName = directory + "/" + "material.dat";
  const G4String key = "MATERIAL-V3.0";
  std::ifstream fIn;  
 
  // open input file
  if (!ascii ) fIn.open(fileName,std::ios::in|std::ios::binary);
  else         fIn.open(fileName,std::ios::in);
 
  // check if the file has been opened successfully 
  if (!fIn)
  {
#ifdef G4VERBOSE
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutsTable::CheckMaterialInfo() - ";
      G4cerr << "Cannot open file: " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
                 "ProcCuts102", JustWarning, "Cannot open file!");
    return false;
  }
  
  char temp[FixedStringLengthForStore];
 
  // key word
  G4String keyword;    
  if (ascii)
  {
    fIn >> keyword;
  }
  else
  {
    fIn.read(temp, FixedStringLengthForStore);
    keyword = (const char*)(temp);
  }
  if (key!=keyword)
  {
#ifdef G4VERBOSE
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutsTable::CheckMaterialInfo() - ";
      G4cerr << "Key word in " << fileName << "= " << keyword ;
      G4cerr <<"( should be   "<< key << ")" <<G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
                 "ProcCuts103", JustWarning, "Bad Data Format");
    return false;
  }
 
  // number of materials in the table
  G4int nmat;
  if (ascii)
  {
    fIn >> nmat;
  }
  else
  {
    fIn.read( (char*)(&nmat), sizeof(G4int));
  }
  if ((nmat<=0) || (nmat >100000))
  {
    G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
                 "ProcCuts108", JustWarning, 
                 "Number of materials is less than zero or too big");
    return false;
  }
 
  // list of material
  for (G4int idx=0; idx<nmat ; ++idx)
  {
    // check eof
    if(fIn.eof())
    {
#ifdef G4VERBOSE
      if (verboseLevel >0)
      {
        G4cout << "G4ProductionCutsTable::CheckMaterialInfo() - ";
        G4cout << "Encountered End of File " ;
        G4cout << " at " << idx+1 << "th  material "<< G4endl;
      }
#endif
      fIn.close();
      return false;
    }
 
    // check material name and density
    char name[FixedStringLengthForStore];
    G4double density;
    if (ascii)
    {
      fIn >> name >> density;
      density *= (g/cm3);
      
    }
    else
    {
      fIn.read(name, FixedStringLengthForStore);
      fIn.read((char*)(&density), sizeof(G4double));
    }
    if (fIn.fail())
    {
#ifdef G4VERBOSE
      if (verboseLevel >0)
      {
        G4cerr << "G4ProductionCutsTable::CheckMaterialInfo() - ";
        G4cerr << "Bad data format ";
        G4cerr << " at " << idx+1 << "th  material "<< G4endl;        
      }
#endif
      G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
                   "ProcCuts103", JustWarning, "Bad Data Format");
      fIn.close();
      return false;
    }
 
    G4Material* aMaterial = G4Material::GetMaterial(name);
    if (aMaterial == nullptr ) continue;
 
    G4double ratio = std::fabs(density/aMaterial->GetDensity() );
    if ((0.999>ratio) || (ratio>1.001) )
    {
#ifdef G4VERBOSE
      if (verboseLevel >0)
      {
        G4cerr << "G4ProductionCutsTable::CheckMaterialInfo() - ";
        G4cerr << "Inconsistent material density" << G4endl;;
        G4cerr << " at " << idx+1 << "th  material "<< G4endl;        
        G4cerr << "Name:   " << name << G4endl;
        G4cerr << "Density:" << std::setiosflags(std::ios::scientific)
               << density / (g/cm3) ;
        G4cerr << "(should be " << aMaterial->GetDensity()/(g/cm3)<< ")"
               << " [g/cm3]"<< G4endl;      
        G4cerr << std::resetiosflags(std::ios::scientific);
      }
#endif
      G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
                   "ProcCuts104", JustWarning, "Inconsistent material density");
      fIn.close();
      return false;
    }
  }
 
  fIn.close();
  return true;
}

Referenced by CheckForRetrieveCutsTable().

ConvertRangeToEnergy()

G4double G4ProductionCutsTable::ConvertRangeToEnergy	(	const G4ParticleDefinition *	particle,
		const G4Material *	material,
		G4double	range
	)

Definition at line 299 of file G4ProductionCutsTable.cc.

{
  // This method gives energy corresponding to range value  
 
  // protection against premature call
  if(firstUse)
  {
#ifdef G4VERBOSE
    if(verboseLevel>0)
    {
      G4ExceptionDescription ed;
      ed << "Invoked prematurely before it is fully initialized.";
      G4Exception("G4ProductionCutsTable::ConvertRangeToEnergy()",
                  "CUTS0100", JustWarning, ed);
    }
#endif
    return -1.0;
  }
 
  // check material
  if (material == nullptr) return -1.0;
 
  // check range
  if (range == 0.0) return 0.0;
  if (range <0.0) return -1.0;
 
  // check particle
  G4int index = G4ProductionCuts::GetIndex(particle);
 
  if (index<0 || converters[index] == nullptr)
  {
#ifdef G4VERBOSE
    if(verboseLevel>0)
    {
      G4ExceptionDescription ed;
      ed << "Invoked ";
      if(particle != nullptr)
      { ed << "for particle <" << particle->GetParticleName() << ">."; }
      else
      { ed << "without valid particle pointer."; }
      G4Exception("G4ProductionCutsTable::ConvertRangeToEnergy()",
                  "CUTS0101", JustWarning, ed);
    }
#endif
    return -1.0;
  }
 
  return converters[index]->Convert(range, material);
}

Referenced by G4GDMLWriteStructure::ExportEnergyCuts().

DumpCouples()

void G4ProductionCutsTable::DumpCouples

(

)

const

Definition at line 400 of file G4ProductionCutsTable.cc.

{
  G4cout << G4endl;
  G4cout << "========= Table of registered couples ============================"
         << G4endl;
  for(auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
  {
    G4MaterialCutsCouple* aCouple = (*cItr);
    G4ProductionCuts* aCut = aCouple->GetProductionCuts();
    G4cout << G4endl;
    G4cout << "Index : " << aCouple->GetIndex() 
           << "     used in the geometry : ";
    if(aCouple->IsUsed()) G4cout << "Yes";
    else                  G4cout << "No ";
////    G4cout << "     recalculation needed : ";
////    if(aCouple->IsRecalcNeeded()) G4cout << "Yes";
////    else                          G4cout << "No ";
    G4cout << G4endl;
    G4cout << " Material : " << aCouple->GetMaterial()->GetName() << G4endl;
    G4cout << " Range cuts        : " 
           << " gamma  " << G4BestUnit(aCut->GetProductionCut("gamma"),"Length")
           << "    e-  " << G4BestUnit(aCut->GetProductionCut("e-"),"Length")
           << "    e+  " << G4BestUnit(aCut->GetProductionCut("e+"),"Length")
           << " proton " << G4BestUnit(aCut->GetProductionCut("proton"),"Length")
           << G4endl;
    G4cout << " Energy thresholds : " ;
////    if(aCouple->IsRecalcNeeded()) {
////      G4cout << " is not ready to print";
////    } else {
    G4cout << " gamma  " << G4BestUnit((*(energyCutTable[0]))[aCouple->GetIndex()],"Energy")
           << "    e-  " << G4BestUnit((*(energyCutTable[1]))[aCouple->GetIndex()],"Energy")
           << "    e+  " << G4BestUnit((*(energyCutTable[2]))[aCouple->GetIndex()],"Energy") 
           << " proton " << G4BestUnit((*(energyCutTable[3]))[aCouple->GetIndex()],"Energy");
////    }
    G4cout << G4endl;
 
    if(aCouple->IsUsed())
    {
      G4cout << " Region(s) which use this couple : " << G4endl;
      for(auto rItr=fG4RegionStore->cbegin();
               rItr!=fG4RegionStore->cend(); ++rItr)
      {
        if (IsCoupleUsedInTheRegion(aCouple, *rItr) )
        {
          G4cout << "    " << (*rItr)->GetName() << G4endl;
        }
      }
    }
  }
  G4cout << G4endl;
  G4cout << "==================================================================" << G4endl;
  G4cout << G4endl;
}

Referenced by G4VUserPhysicsList::DumpCutValuesTableIfRequested(), and G4RunMessenger::SetNewValue().

GetCoupleIndex() [1/2]

G4int G4ProductionCutsTable::GetCoupleIndex ( const G4Material *  aMat, const G4ProductionCuts *  aCut  ) const

inline

Definition at line 340 of file G4ProductionCutsTable.hh.

{
  const G4MaterialCutsCouple* aCouple = GetMaterialCutsCouple(aMat,aCut);
  return GetCoupleIndex(aCouple);
}

GetCoupleIndex() [2/2]

G4int G4ProductionCutsTable::GetCoupleIndex ( const G4MaterialCutsCouple *  aCouple ) const

inline

Definition at line 328 of file G4ProductionCutsTable.hh.

{ 
  G4int idx = 0;
  for(auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
  {
    if((*cItr)==aCouple) return idx;
    ++idx;
  }
  return -1;
}

Referenced by G4ITStepProcessor::ApplyProductionCut(), and GetCoupleIndex().

GetDefaultProductionCuts()

G4ProductionCuts * G4ProductionCutsTable::GetDefaultProductionCuts ( ) const

inline

Definition at line 289 of file G4ProductionCutsTable.hh.

{
  return defaultProductionCuts;
}

Referenced by G4RunManagerKernel::CheckRegions().

GetEnergyCutsDoubleVector()

G4double * G4ProductionCutsTable::GetEnergyCutsDoubleVector ( std::size_t  pcIdx ) const

inline

Definition at line 283 of file G4ProductionCutsTable.hh.

{
  return energyDoubleVector[pcIdx];
}

GetEnergyCutsVector()

const std::vector< G4double > * G4ProductionCutsTable::GetEnergyCutsVector ( std::size_t  pcIdx ) const

inline

Definition at line 233 of file G4ProductionCutsTable.hh.

{
  return energyCutTable[pcIdx]; 
}

Referenced by G4VAtomDeexcitation::AlongStepDeexcitation(), G4ITStepProcessor::ApplyProductionCut(), G4hImpactIonisation::BuildPhysicsTable(), G4ForwardXrayTR::BuildXrayTRtables(), G4AdjointCSManager::ComputeTotalAdjointCS(), G4VEmAdjointModel::DefineCurrentMaterial(), G4VAtomDeexcitation::GenerateParticles(), G4PAIPhotData::Initialise(), G4EmModelManager::Initialise(), G4GoudsmitSaundersonTable::InitSCPCorrection(), G4eDPWAElasticDCS::InitSCPCorrection(), G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), and StoreCutsInfo().

GetHighEdgeEnergy()

G4double G4ProductionCutsTable::GetHighEdgeEnergy

(

)

const

Definition at line 369 of file G4ProductionCutsTable.cc.

{
  return G4VRangeToEnergyConverter::GetHighEdgeEnergy();
}

Referenced by G4ProductionCutsTableMessenger::GetCurrentValue(), and G4ProductionCutsTableMessenger::SetNewValue().

GetLowEdgeEnergy()

G4double G4ProductionCutsTable::GetLowEdgeEnergy

(

)

const

Definition at line 363 of file G4ProductionCutsTable.cc.

{
  return G4VRangeToEnergyConverter::GetLowEdgeEnergy();
}

Referenced by G4ProductionCutsTableMessenger::GetCurrentValue(), and G4ProductionCutsTableMessenger::SetNewValue().

GetMaterialCutsCouple() [1/2]

const G4MaterialCutsCouple * G4ProductionCutsTable::GetMaterialCutsCouple ( const G4Material *  aMat, const G4ProductionCuts *  aCut  ) const

inline

Definition at line 315 of file G4ProductionCutsTable.hh.

{
  for(auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
  { 
    if((*cItr)->GetMaterial()!=aMat) continue;
    if((*cItr)->GetProductionCuts()==aCut) return (*cItr);
  }
  return nullptr;
}

GetMaterialCutsCouple() [2/2]

const G4MaterialCutsCouple * G4ProductionCutsTable::GetMaterialCutsCouple ( G4int  i ) const

inline

Definition at line 246 of file G4ProductionCutsTable.hh.

{ 
  return coupleTable[std::size_t(i)]; 
}

Referenced by G4eIonisationCrossSectionHandler::BuildCrossSectionsForMaterials(), G4CrossSectionHandler::BuildCrossSectionsForMaterials(), G4EmTableUtil::BuildDEDXTable(), G4EmTableUtil::BuildLambdaTable(), G4GammaGeneralProcess::BuildPhysicsTable(), G4MicroElecSurface::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4LossTableBuilder::BuildTableForModel(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4hRDEnergyLoss::CutsWhereModified(), G4EmCalculator::FindCouple(), G4EmUtility::FindCrossSectionMax(), G4DNAELSEPAElasticModel::G4DNAELSEPAElasticModel(), G4ForwardXrayTR::G4ForwardXrayTR(), GetCoupleIndex(), G4ForwardXrayTR::GetEnergyTR(), G4PAIPhotData::Initialise(), G4EmBiasingManager::Initialise(), G4BoldyshevTripletModel::Initialise(), G4mplIonisationModel::Initialise(), G4mplIonisationWithDeltaModel::Initialise(), G4IonParametrisedLossModel::Initialise(), G4JAEAElasticScatteringModel::Initialise(), G4JAEAPolarizedElasticScatteringModel::Initialise(), G4LivermoreGammaConversion5DModel::Initialise(), G4LivermoreNuclearGammaConversionModel::Initialise(), G4LivermorePolarizedComptonModel::Initialise(), G4LivermorePolarizedGammaConversionModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LowEPPolarizedComptonModel::Initialise(), G4MicroElecElasticModel_new::Initialise(), G4MicroElecInelasticModel_new::Initialise(), G4PenelopeBremsstrahlungModel::Initialise(), G4PenelopeGammaConversionModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeRayleighModel::Initialise(), G4PenelopeRayleighModelMI::Initialise(), G4eDPWACoulombScatteringModel::Initialise(), G4WentzelVIModel::Initialise(), G4DNAQuinnPlasmonExcitationModel::Initialise(), G4DNARelativisticIonisationModel::Initialise(), G4EmModelManager::Initialise(), G4DNAELSEPAElasticModel::Initialise(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4LossTableBuilder::InitialiseBaseMaterials(), G4EmUtility::InitialiseElementSelectors(), G4EmCorrections::InitialiseForNewRun(), G4PenelopeBremsstrahlungModel::InitialiseLocal(), G4ElasticHadrNucleusHE::InitialiseModel(), G4GoudsmitSaundersonTable::InitSCPCorrection(), G4eDPWAElasticDCS::InitSCPCorrection(), G4ITTransportation::PostStepDoIt(), G4PhysicsTableHelper::PreparePhysicsTable(), G4hImpactIonisation::PrintInfoDefinition(), G4Transportation::SetTouchableInformation(), and G4ParallelWorldProcess::SwitchMaterial().

GetMaxEnergyCut()

G4double G4ProductionCutsTable::GetMaxEnergyCut

(

)

Definition at line 1359 of file G4ProductionCutsTable.cc.

{
  return G4VRangeToEnergyConverter::GetMaxEnergyCut();
}

Referenced by G4ProductionCutsTableMessenger::GetCurrentValue().

GetMCCIndexConversionTable()

const G4MCCIndexConversionTable * G4ProductionCutsTable::GetMCCIndexConversionTable ( ) const

inline

Definition at line 355 of file G4ProductionCutsTable.hh.

{
  return &mccConversionTable;
}

Referenced by G4PhysicsTableHelper::RetrievePhysicsTable().

GetProductionCutsTable()

G4ProductionCutsTable * G4ProductionCutsTable::GetProductionCutsTable ( )

static

Definition at line 58 of file G4ProductionCutsTable.cc.

{ 
   static G4ProductionCutsTable theProductionCutsTable;
   if(fProductionCutsTable == nullptr)
   {
     fProductionCutsTable = &theProductionCutsTable;
   }
  return fProductionCutsTable;
}

Referenced by G4ITStepProcessor::ApplyProductionCut(), G4eIonisationCrossSectionHandler::BuildCrossSectionsForMaterials(), G4CrossSectionHandler::BuildCrossSectionsForMaterials(), G4hRDEnergyLoss::BuildDEDXTable(), G4EmTableUtil::BuildDEDXTable(), G4EmTableUtil::BuildLambdaTable(), G4VCrossSectionHandler::BuildMeanFreePathForMaterials(), G4GammaGeneralProcess::BuildPhysicsTable(), G4GammaConversionToMuons::BuildPhysicsTable(), G4MicroElecSurface::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4RunManagerKernel::BuildPhysicsTables(), G4LossTableBuilder::BuildTableForModel(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4RunManagerKernel::CheckRegions(), G4EmCalculator::ComputeEnergyCutFromRangeCut(), G4AdjointCSManager::ComputeTotalAdjointCS(), G4TheRayTracer::CreateBitMap(), G4PenelopeRayleighModelMI::CrossSectionPerVolume(), G4hRDEnergyLoss::CutsWhereModified(), G4VEmAdjointModel::DefineCurrentMaterial(), G4VUserPhysicsList::DumpCutValuesTableIfRequested(), G4RunManagerKernel::DumpRegion(), G4GDMLWriteStructure::ExportEnergyCuts(), G4EmCalculator::FindCouple(), G4EmUtility::FindCrossSectionMax(), G4DNAELSEPAElasticModel::G4DNAELSEPAElasticModel(), G4ForwardXrayTR::G4ForwardXrayTR(), G4RunManagerKernel::G4RunManagerKernel(), G4VUserPhysicsList::G4VUserPhysicsList(), G4ForwardXrayTR::GetEnergyTR(), G4PAIPhotData::Initialise(), G4EmBiasingManager::Initialise(), G4BoldyshevTripletModel::Initialise(), G4mplIonisationModel::Initialise(), G4mplIonisationWithDeltaModel::Initialise(), G4IonParametrisedLossModel::Initialise(), G4JAEAElasticScatteringModel::Initialise(), G4JAEAPolarizedElasticScatteringModel::Initialise(), G4LivermoreGammaConversion5DModel::Initialise(), G4LivermoreNuclearGammaConversionModel::Initialise(), G4LivermorePolarizedComptonModel::Initialise(), G4LivermorePolarizedGammaConversionModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LowEPPolarizedComptonModel::Initialise(), G4MicroElecElasticModel_new::Initialise(), G4MicroElecInelasticModel_new::Initialise(), G4PenelopeBremsstrahlungModel::Initialise(), G4PenelopeGammaConversionModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeRayleighModel::Initialise(), G4PenelopeRayleighModelMI::Initialise(), G4eDPWACoulombScatteringModel::Initialise(), G4SeltzerBergerModel::Initialise(), G4WentzelVIModel::Initialise(), G4WentzelVIRelModel::Initialise(), G4DNAQuinnPlasmonExcitationModel::Initialise(), G4DNARelativisticIonisationModel::Initialise(), G4EmModelManager::Initialise(), G4DNAELSEPAElasticModel::Initialise(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4LossTableBuilder::InitialiseBaseMaterials(), G4EmUtility::InitialiseElementSelectors(), G4EmCorrections::InitialiseForNewRun(), G4PenelopeBremsstrahlungModel::InitialiseLocal(), G4ElasticHadrNucleusHE::InitialiseModel(), G4GammaGeneralProcess::InitialiseProcess(), G4GoudsmitSaundersonTable::InitSCPCorrection(), G4eDPWAElasticDCS::InitSCPCorrection(), G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), G4TauNeutrinoNucleusProcess::PostStepDoIt(), G4ITTransportation::PostStepDoIt(), G4VEmProcess::PreparePhysicsTable(), G4PhysicsTableHelper::PreparePhysicsTable(), G4hImpactIonisation::PrintInfoDefinition(), G4PhysicsTableHelper::RetrievePhysicsTable(), G4RunManagerKernel::RunTermination(), LBE::SetCuts(), G4RunMessenger::SetNewValue(), G4VUserPhysicsList::SetParticleCuts(), G4ProductionCuts::SetProductionCuts(), G4Transportation::SetTouchableInformation(), G4ParallelWorldProcess::SwitchMaterial(), and G4RunManagerKernel::UpdateRegion().

GetRangeCutsDoubleVector()

G4double * G4ProductionCutsTable::GetRangeCutsDoubleVector ( std::size_t  pcIdx ) const

inline

Definition at line 276 of file G4ProductionCutsTable.hh.

{
  return rangeDoubleVector[pcIdx];
}

GetRangeCutsVector()

const std::vector< G4double > * G4ProductionCutsTable::GetRangeCutsVector ( std::size_t  pcIdx ) const

inline

Definition at line 226 of file G4ProductionCutsTable.hh.

{ 
  return rangeCutTable[pcIdx]; 
}

Referenced by StoreCutsInfo().

GetTableSize()

std::size_t G4ProductionCutsTable::GetTableSize ( ) const

inline

Definition at line 239 of file G4ProductionCutsTable.hh.

{
  return coupleTable.size(); 
}

Referenced by G4eIonisationCrossSectionHandler::BuildCrossSectionsForMaterials(), G4CrossSectionHandler::BuildCrossSectionsForMaterials(), G4hRDEnergyLoss::BuildDEDXTable(), G4EmTableUtil::BuildDEDXTable(), G4EmTableUtil::BuildLambdaTable(), G4VCrossSectionHandler::BuildMeanFreePathForMaterials(), G4GammaGeneralProcess::BuildPhysicsTable(), G4GammaConversionToMuons::BuildPhysicsTable(), G4MicroElecSurface::BuildPhysicsTable(), G4hImpactIonisation::BuildPhysicsTable(), G4LossTableBuilder::BuildTableForModel(), G4AdjointCSManager::BuildTotalSigmaTables(), G4ForwardXrayTR::BuildXrayTRtables(), G4hRDEnergyLoss::CutsWhereModified(), G4EmUtility::FindCrossSectionMax(), G4DNAELSEPAElasticModel::G4DNAELSEPAElasticModel(), G4ForwardXrayTR::G4ForwardXrayTR(), G4ForwardXrayTR::GetEnergyTR(), G4PAIPhotData::Initialise(), G4EmBiasingManager::Initialise(), G4BoldyshevTripletModel::Initialise(), G4mplIonisationModel::Initialise(), G4mplIonisationWithDeltaModel::Initialise(), G4IonParametrisedLossModel::Initialise(), G4JAEAElasticScatteringModel::Initialise(), G4JAEAPolarizedElasticScatteringModel::Initialise(), G4LivermoreGammaConversion5DModel::Initialise(), G4LivermoreNuclearGammaConversionModel::Initialise(), G4LivermorePolarizedComptonModel::Initialise(), G4LivermorePolarizedGammaConversionModel::Initialise(), G4LowEPComptonModel::Initialise(), G4LowEPPolarizedComptonModel::Initialise(), G4MicroElecElasticModel_new::Initialise(), G4MicroElecInelasticModel_new::Initialise(), G4PenelopeBremsstrahlungModel::Initialise(), G4PenelopeGammaConversionModel::Initialise(), G4PenelopeIonisationModel::Initialise(), G4PenelopePhotoElectricModel::Initialise(), G4PenelopeRayleighModel::Initialise(), G4PenelopeRayleighModelMI::Initialise(), G4eDPWACoulombScatteringModel::Initialise(), G4WentzelVIModel::Initialise(), G4WentzelVIRelModel::Initialise(), G4DNAQuinnPlasmonExcitationModel::Initialise(), G4EmModelManager::Initialise(), G4DNAELSEPAElasticModel::Initialise(), G4VAtomDeexcitation::InitialiseAtomicDeexcitation(), G4LossTableBuilder::InitialiseBaseMaterials(), G4EmUtility::InitialiseElementSelectors(), G4EmCorrections::InitialiseForNewRun(), G4PenelopeBremsstrahlungModel::InitialiseLocal(), G4ElasticHadrNucleusHE::InitialiseModel(), G4GammaGeneralProcess::InitialiseProcess(), G4GoudsmitSaundersonTable::InitSCPCorrection(), G4eDPWAElasticDCS::InitSCPCorrection(), G4PhysicsTableHelper::PreparePhysicsTable(), and G4hImpactIonisation::PrintInfoDefinition().

GetVerboseLevel()

G4int G4ProductionCutsTable::GetVerboseLevel ( ) const

inline

Definition at line 348 of file G4ProductionCutsTable.hh.

{
  return verboseLevel;
}

Referenced by G4ProductionCutsTableMessenger::GetCurrentValue(), G4ProductionCuts::SetProductionCuts(), and UpdateCoupleTable().

IsModified()

G4bool G4ProductionCutsTable::IsModified ( ) const

inline

Definition at line 252 of file G4ProductionCutsTable.hh.

{ 
  if(firstUse) return true;
  for(auto itr=coupleTable.cbegin(); itr!=coupleTable.cend(); ++itr)
  { 
    if((*itr)->IsRecalcNeeded())
    {
      return true; 
    }
  }
  return false;
}

operator=()

G4ProductionCutsTable & G4ProductionCutsTable::operator= ( const G4ProductionCutsTable &  )

delete

PhysicsTableUpdated()

void G4ProductionCutsTable::PhysicsTableUpdated ( )

inline

Definition at line 266 of file G4ProductionCutsTable.hh.

{ 
  for(auto itr=coupleTable.cbegin(); itr!=coupleTable.cend(); ++itr)
  { 
    (*itr)->PhysicsTableUpdated(); 
  }
}

Referenced by G4RunManagerKernel::RunTermination().

ResetConverters()

void G4ProductionCutsTable::ResetConverters

(

)

Definition at line 353 of file G4ProductionCutsTable.cc.

{}

RetrieveCutsInfo()

G4bool G4ProductionCutsTable::RetrieveCutsInfo ( const G4String &  directory, G4bool  ascii = false  )

protectedvirtual

Definition at line 1229 of file G4ProductionCutsTable.cc.

{
  // Retrieve cut values information in files under the specified directory
 
  const G4String fileName = directory + "/" + "cut.dat";
  const G4String key = "CUT-V3.0";
  std::ifstream fIn;  
 
  // open input file
  if (!ascii ) fIn.open(fileName,std::ios::in|std::ios::binary);
  else         fIn.open(fileName,std::ios::in);
 
  // check if the file has been opened successfully 
  if (!fIn)
  {
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutTable::RetrieveCutsInfo() - ";
      G4cerr << "Cannot open file: " << fileName << G4endl;
    }
    G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
                 "ProcCuts102", JustWarning, "Cannot open file!");
    return false;
  }
  
  char temp[FixedStringLengthForStore];
 
   // key word
  G4String keyword;    
  if (ascii)
  {
    fIn >> keyword;
  }
  else
  {
    fIn.read(temp, FixedStringLengthForStore);
    keyword = (const char*)(temp);
  }
  if (key!=keyword)
  {
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutTable::RetrieveCutsInfo() - ";
      G4cerr << "Key word in " << fileName << "= " << keyword ;
      G4cerr <<"( should be   "<< key << ")" << G4endl;
    }
    G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
                 "ProcCuts103", JustWarning, "Bad Data Format");
    return false;
  }
 
  // numberOfCouples
  G4int numberOfCouples;    
  if (ascii)
  {
    fIn >> numberOfCouples;
    if (fIn.fail())
    {
      G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
                   "ProcCuts103", JustWarning, "Bad Data Format");
      return false;
    }
  }
  else
  {
    fIn.read( (char*)(&numberOfCouples), sizeof(G4int));
  }
 
  if (numberOfCouples > static_cast<G4int>(mccConversionTable.size()) )
  {
    G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
                 "ProcCuts109", JustWarning, 
                 "Number of Couples in the file exceeds defined couples");
  }
  numberOfCouples = (G4int)mccConversionTable.size();
  
  for (std::size_t idx=0; static_cast<G4int>(idx) <NumberOfG4CutIndex; ++idx)
  {
    std::vector<G4double>* fRange  = rangeCutTable[idx];
    std::vector<G4double>* fEnergy = energyCutTable[idx];
    fRange->clear();
    fEnergy->clear();
 
    // Loop over all couples
    for (std::size_t i=0; static_cast<G4int>(i)< numberOfCouples; ++i)
    {      
      G4double rcut, ecut;
      if (ascii)
      {
        fIn >> rcut >> ecut;
        if (fIn.fail())
        {
          G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
                       "ProcCuts103", JustWarning, "Bad Data Format");
          return false;
        }
        rcut *= mm;
        ecut *= keV;
      }
      else
      {
        fIn.read((char*)(&rcut), sizeof(G4double));
        fIn.read((char*)(&ecut), sizeof(G4double));
      }
      if (!mccConversionTable.IsUsed(i)) continue;
      std::size_t new_index = mccConversionTable.GetIndex(i);
      (*fRange)[new_index]  = rcut;
      (*fEnergy)[new_index] = ecut;
    }
  }
  return true;
}

Referenced by RetrieveCutsTable().

RetrieveCutsTable()

G4bool G4ProductionCutsTable::RetrieveCutsTable	(	const G4String &	directory,
		G4bool	ascii = false
	)

Definition at line 484 of file G4ProductionCutsTable.cc.

{
  if (!CheckForRetrieveCutsTable(dir, ascii)) return false;
  if (!RetrieveCutsInfo(dir, ascii)) return false;
#ifdef G4VERBOSE  
  if (verboseLevel >2)
  {
    G4cout << "G4ProductionCutsTable::RetrieveCutsTable()" << G4endl;
    G4cout << " Material/Cuts information have been successfully retrieved ";
    if (ascii)
    {
      G4cout << " in Ascii mode ";
    }
    else
    {
      G4cout << " in Binary mode ";
    }
    G4cout << " under " << dir << G4endl;  
  }  
#endif
  return true;
}

Referenced by G4VUserPhysicsList::BuildPhysicsTable().

SetEnergyRange()

void G4ProductionCutsTable::SetEnergyRange	(	G4double	lowedge,
		G4double	highedge
	)

Definition at line 357 of file G4ProductionCutsTable.cc.

{
  G4VRangeToEnergyConverter::SetEnergyRange(lowedge,highedge);
}

Referenced by G4VUserPhysicsList::G4VUserPhysicsList(), LBE::SetCuts(), and G4ProductionCutsTableMessenger::SetNewValue().

SetMaxEnergyCut()

void G4ProductionCutsTable::SetMaxEnergyCut

(

G4double

value

)

Definition at line 1365 of file G4ProductionCutsTable.cc.

{
  G4VRangeToEnergyConverter::SetMaxEnergyCut(value);
}

Referenced by G4ProductionCutsTableMessenger::SetNewValue().

SetVerboseLevel()

void G4ProductionCutsTable::SetVerboseLevel

(

G4int

value

)

Definition at line 1344 of file G4ProductionCutsTable.cc.

{
  // Set same verbosity to all registered RangeToEnergyConverters  
 
  verboseLevel = value;
  for (G4int ip=0; ip< NumberOfG4CutIndex; ++ip)
  {
    if (converters[ip] != nullptr )
    {
      converters[ip]->SetVerboseLevel(value);
    }
  }
}

Referenced by G4ProductionCutsTableMessenger::SetNewValue(), and G4VUserPhysicsList::SetVerboseLevel().

StoreCutsInfo()

G4bool G4ProductionCutsTable::StoreCutsInfo ( const G4String &  directory, G4bool  ascii = false  )

protectedvirtual

Definition at line 1146 of file G4ProductionCutsTable.cc.

{
  // Store cut values information in files under the specified directory
 
  const G4String fileName = directory + "/" + "cut.dat";
  const G4String key = "CUT-V3.0";
  std::ofstream fOut;  
  char temp[FixedStringLengthForStore];
  
  // open output file
  if (!ascii ) fOut.open(fileName,std::ios::out|std::ios::binary);
  else         fOut.open(fileName,std::ios::out);
 
  // check if the file has been opened successfully 
  if (!fOut)
  {
    if(verboseLevel>0)
    {         
      G4cerr << "G4ProductionCutsTable::StoreCutsInfo() - ";
      G4cerr << "Cannot open file: " << fileName << G4endl;
    }
    G4Exception( "G4ProductionCutsTable::StoreCutsInfo()",
                 "ProcCuts102", JustWarning, "Cannot open file!");
    return false;
  }
 
  G4int numberOfCouples = (G4int)coupleTable.size();
  if (ascii)
  {
    /////////////// ASCII mode  /////////////////
    // key word
    fOut << key << G4endl;
    
    // number of couples in the table
    fOut << numberOfCouples << G4endl;
  }
  else
  {
    /////////////// Binary mode  /////////////////
    // key word
    std::size_t i;
    for (i=0; i<FixedStringLengthForStore; ++i)
      temp[i] = '\0'; 
    for (i=0; i<key.length() && i<FixedStringLengthForStore-1; ++i)
      temp[i]=key[(G4int)i];
    fOut.write(temp, FixedStringLengthForStore);
    
    // number of couples in the table   
    fOut.write( (char*)(&numberOfCouples), sizeof(G4int));
  }
 
  for (std::size_t idx=0; idx <NumberOfG4CutIndex; ++idx)
  {
    const std::vector<G4double>* fRange  = GetRangeCutsVector(idx);
    const std::vector<G4double>* fEnergy = GetEnergyCutsVector(idx);
    std::size_t i=0;
    // Loop over all couples
    for (auto cItr=coupleTable.cbegin();cItr!=coupleTable.cend(); ++cItr, ++i)
    {      
      if (ascii)
      {
        /////////////// ASCII mode  /////////////////
        fOut.setf(std::ios::scientific);
        fOut << std::setw(20) << (*fRange)[i]/mm  ;
        fOut << std::setw(20) << (*fEnergy)[i]/keV << G4endl;
        fOut.unsetf(std::ios::scientific);
      }
      else
      {
        /////////////// Binary mode  /////////////////
        G4double cut =  (*fRange)[i];
        fOut.write((char*)(&cut), sizeof(G4double));
        cut =  (*fEnergy)[i];
        fOut.write((char*)(&cut), sizeof(G4double));
      }
    }
  }
  fOut.close();
  return true;
}

Referenced by StoreCutsTable().

StoreCutsTable()

G4bool G4ProductionCutsTable::StoreCutsTable	(	const G4String &	directory,
		G4bool	ascii = false
	)

Definition at line 455 of file G4ProductionCutsTable.cc.

{
  // Store cuts and material information in files under the specified directory
 
  if (!StoreMaterialInfo(dir, ascii)) return false;
  if (!StoreMaterialCutsCoupleInfo(dir, ascii)) return false;
  if (!StoreCutsInfo(dir, ascii)) return false;
  
#ifdef G4VERBOSE  
  if (verboseLevel >2)
  {
    G4cout << "G4ProductionCutsTable::StoreCutsTable()" << G4endl;
    G4cout << " Material/Cuts information have been successfully stored ";
    if (ascii)
    {
      G4cout << " in Ascii mode ";
    }
    else
    {
      G4cout << " in Binary mode ";
    }
    G4cout << " under " << dir << G4endl;  
  }  
#endif
  return true;
}

Referenced by G4VUserPhysicsList::StorePhysicsTable().

StoreMaterialCutsCoupleInfo()

G4bool G4ProductionCutsTable::StoreMaterialCutsCoupleInfo ( const G4String &  directory, G4bool  ascii = false  )

protectedvirtual

Definition at line 782 of file G4ProductionCutsTable.cc.

{  
  // Store materialCutsCouple information in files under the specified directory
 
  const G4String fileName = directory + "/" + "couple.dat";
  const G4String key = "COUPLE-V3.0";
  std::ofstream fOut;  
  char temp[FixedStringLengthForStore];
 
  // open output file
  if (!ascii ) fOut.open(fileName,std::ios::out|std::ios::binary);
  else         fOut.open(fileName,std::ios::out);
  
  
  // check if the file has been opened successfully 
  if (!fOut)
  {
#ifdef G4VERBOSE
    if (verboseLevel >0)
    {
      G4cerr << "G4ProductionCutsTable::StoreMaterialCutsCoupleInfo() - ";
      G4cerr << "Cannot open file: " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::StoreMaterialCutsCoupleInfo()",
                 "ProcCuts102",
                 JustWarning, "Cannot open file!");
     return false;
  }
  G4int numberOfCouples = (G4int)coupleTable.size();
  if (ascii)
  {
    /////////////// ASCII mode  /////////////////
    // key word
    fOut << std::setw(FixedStringLengthForStore) <<  key << G4endl;
    
    // number of couples in the table
    fOut  << numberOfCouples << G4endl;
  }
  else
  {
    /////////////// Binary mode  /////////////////
    // key word
    std::size_t i;
    for (i=0; i<FixedStringLengthForStore; ++i)
      temp[i] = '\0'; 
    for (i=0; i<key.length() && i<FixedStringLengthForStore-1; ++i)
      temp[i]=key[(G4int)i];
    fOut.write(temp, FixedStringLengthForStore);
    
    // number of couples in the table   
    fOut.write( (char*)(&numberOfCouples), sizeof(G4int));
  }
 
  // Loop over all couples
  for (auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
  {
    G4MaterialCutsCouple* aCouple = (*cItr);
    G4int index = aCouple->GetIndex(); 
    // cut value
    G4ProductionCuts* aCut = aCouple->GetProductionCuts();
    G4double cutValues[NumberOfG4CutIndex];
    for (std::size_t idx=0; idx <NumberOfG4CutIndex; ++idx)
    {
      cutValues[idx] = aCut->GetProductionCut((G4int)idx);
    }
    // material/region info
    G4String materialName = aCouple->GetMaterial()->GetName();
    G4String regionName = "NONE";
    if (aCouple->IsUsed())
    {
      for(auto rItr=fG4RegionStore->cbegin();
               rItr!=fG4RegionStore->cend(); ++rItr)
      {
        if (IsCoupleUsedInTheRegion(aCouple, *rItr))
        {
          regionName = (*rItr)->GetName();
          break;
        }
      }
    }
 
    if (ascii)
    {
      /////////////// ASCII mode  /////////////////
      // index number
      fOut  << index << G4endl; 
  
      // material name 
      fOut << std::setw(FixedStringLengthForStore) << materialName<< G4endl;
  
      // region name 
      fOut << std::setw(FixedStringLengthForStore) << regionName<< G4endl;
 
      fOut.setf(std::ios::scientific);
      // cut values
      for (std::size_t idx=0; idx< NumberOfG4CutIndex; ++idx)
      {
        fOut << std::setw(FixedStringLengthForStore) << cutValues[idx]/(mm)
             << G4endl;
      }
      fOut.unsetf(std::ios::scientific);
 
    }
    else
    {
      /////////////// Binary mode  /////////////////
      // index
      fOut.write( (char*)(&index), sizeof(G4int));
    
      // material name
      std::size_t i;
      for (i=0; i<FixedStringLengthForStore; ++i)
        temp[i] = '\0'; 
      for (i=0; i<materialName.length() && i<FixedStringLengthForStore-1; ++i)
        temp[i]=materialName[(G4int)i];
      fOut.write(temp, FixedStringLengthForStore);
 
      // region name
      for (i=0; i<FixedStringLengthForStore; ++i)
        temp[i] = '\0'; 
      for (i=0; i<regionName.length() && i<FixedStringLengthForStore-1; ++i)
        temp[i]=regionName[(G4int)i];
      fOut.write(temp, FixedStringLengthForStore);
 
      // cut values
      for (std::size_t idx=0; idx< NumberOfG4CutIndex; ++idx)
      {
         fOut.write( (char*)(&(cutValues[idx])), sizeof(G4double));
      }    
    }
  }
  fOut.close();
  return true;
}

Referenced by StoreCutsTable().

StoreMaterialInfo()

G4bool G4ProductionCutsTable::StoreMaterialInfo ( const G4String &  directory, G4bool  ascii = false  )

protectedvirtual

Definition at line 533 of file G4ProductionCutsTable.cc.

{
  // Store material information in files under the specified directory
 
  const G4String fileName = directory + "/" + "material.dat";
  const G4String key = "MATERIAL-V3.0";
  std::ofstream fOut;  
 
  // open output file
  if (!ascii )  fOut.open(fileName,std::ios::out|std::ios::binary);
  else          fOut.open(fileName,std::ios::out);
 
  // check if the file has been opened successfully 
  if (!fOut)
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cerr << "G4ProductionCutsTable::StoreMaterialInfo() - ";
      G4cerr << "Cannot open file: " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::StoreMaterialInfo()",
                 "ProcCuts102", JustWarning, "Cannot open file!");
    return false;
  }
  
  const G4MaterialTable* matTable = G4Material::GetMaterialTable(); 
  // number of materials in the table
  G4int numberOfMaterial = (G4int)matTable->size();
 
  if (ascii)
  {
    /////////////// ASCII mode  /////////////////
    // key word
    fOut  << key << G4endl;
    
    // number of materials in the table
    fOut  << numberOfMaterial << G4endl;
    
    fOut.setf(std::ios::scientific);
  
    // material name and density
    for (std::size_t idx=0; static_cast<G4int>(idx)<numberOfMaterial; ++idx)
    {
      fOut << std::setw(FixedStringLengthForStore)
           << ((*matTable)[idx])->GetName();
      fOut << std::setw(FixedStringLengthForStore)
           << ((*matTable)[idx])->GetDensity()/(g/cm3) << G4endl;
    }
    
    fOut.unsetf(std::ios::scientific);
 
  }
  else
  {
    /////////////// Binary mode  /////////////////
    char temp[FixedStringLengthForStore];
    std::size_t i;
 
    // key word
    for (i=0; i<FixedStringLengthForStore; ++i)
    {
      temp[i] = '\0'; 
    }
    for (i=0; i<key.length() && i<FixedStringLengthForStore-1; ++i)
    {
      temp[i]=key[(G4int)i];
    }
    fOut.write(temp, FixedStringLengthForStore);
 
    // number of materials in the table
    fOut.write( (char*)(&numberOfMaterial), sizeof(G4int));
    
    // material name and density
    for (std::size_t imat=0; static_cast<G4int>(imat)<numberOfMaterial; ++imat)
    {
      G4String name =  ((*matTable)[imat])->GetName();
      G4double density = ((*matTable)[imat])->GetDensity();
      for (i=0; i<FixedStringLengthForStore; ++i)
        temp[i] = '\0'; 
      for (i=0; i<name.length() && i<FixedStringLengthForStore-1; ++i)
        temp[i]=name[(G4int)i];
      fOut.write(temp, FixedStringLengthForStore);
      fOut.write( (char*)(&density), sizeof(G4double));
    }    
  }    
 
  fOut.close();
  return true;
}

Referenced by StoreCutsTable().

UpdateCoupleTable()

void G4ProductionCutsTable::UpdateCoupleTable

(

G4VPhysicalVolume *

currentWorld

)

Definition at line 118 of file G4ProductionCutsTable.cc.

{
  if(firstUse)
  {
    if(G4ParticleTable::GetParticleTable()->FindParticle("gamma"))
    {
      converters[0] = new G4RToEConvForGamma(); 
      converters[0]->SetVerboseLevel(GetVerboseLevel());
    }
    if(G4ParticleTable::GetParticleTable()->FindParticle("e-"))
    {
      converters[1] = new G4RToEConvForElectron(); 
      converters[1]->SetVerboseLevel(GetVerboseLevel());
    }
    if(G4ParticleTable::GetParticleTable()->FindParticle("e+"))
    {
      converters[2] = new G4RToEConvForPositron(); 
      converters[2]->SetVerboseLevel(GetVerboseLevel());
    }
    if(G4ParticleTable::GetParticleTable()->FindParticle("proton"))
    {
      converters[3] = new G4RToEConvForProton(); 
      converters[3]->SetVerboseLevel(GetVerboseLevel());
    }
    firstUse = false;
  }
 
  // Reset "used" flags of all couples
  for(auto CoupleItr=coupleTable.cbegin();
           CoupleItr!=coupleTable.cend(); ++CoupleItr) 
  {
    (*CoupleItr)->SetUseFlag(false); 
  }
 
  // Update Material-Cut-Couple
  for(auto rItr=fG4RegionStore->cbegin(); rItr!=fG4RegionStore->cend(); ++rItr)
  {
    // Material scan is to be done only for the regions appear in the 
    // current tracking world.
    //    if((*rItr)->GetWorldPhysical()!=currentWorld) continue;
 
    if( (*rItr)->IsInMassGeometry() || (*rItr)->IsInParallelGeometry() )
    {
      G4ProductionCuts* fProductionCut = (*rItr)->GetProductionCuts();
      auto mItr = (*rItr)->GetMaterialIterator();
      std::size_t nMaterial = (*rItr)->GetNumberOfMaterials();
      (*rItr)->ClearMap();
 
      for(std::size_t iMate=0; iMate<nMaterial; ++iMate)
      {
        //check if this material cut couple has already been made
        G4bool coupleAlreadyDefined = false;
        G4MaterialCutsCouple* aCouple;
        for(auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
        {
          if( (*cItr)->GetMaterial()==(*mItr)
           && (*cItr)->GetProductionCuts()==fProductionCut)
          { 
            coupleAlreadyDefined = true;
            aCouple = *cItr;
            break;
          }
        }
      
        // If this combination is new, cleate and register a couple
        if(!coupleAlreadyDefined)
        {
          aCouple = new G4MaterialCutsCouple((*mItr),fProductionCut);
          coupleTable.push_back(aCouple);
          aCouple->SetIndex(G4int(coupleTable.size()-1));
        }
 
        // Register this couple to the region
        (*rItr)->RegisterMaterialCouplePair((*mItr),aCouple);
 
        // Set the couple to the proper logical volumes in that region
        aCouple->SetUseFlag();
 
        auto rootLVItr = (*rItr)->GetRootLogicalVolumeIterator();
        std::size_t nRootLV = (*rItr)->GetNumberOfRootVolumes();
        for(std::size_t iLV=0; iLV<nRootLV; ++iLV)
        {
          // Set the couple to the proper logical volumes in that region
          G4LogicalVolume* aLV = *rootLVItr;
          G4Region* aR = *rItr;
 
          ScanAndSetCouple(aLV,aCouple,aR);
 
          // Proceed to the next root logical volume in this region
          ++rootLVItr;
        }
 
        // Proceed to next material in this region
        ++mItr;
      }
    }
  }
 
  // Check if sizes of Range/Energy cuts tables are equal to the size of
  // the couple table. If new couples are made during the previous procedure,
  // nCouple becomes larger then nTable
 
  std::size_t nCouple = coupleTable.size();
  std::size_t nTable = energyCutTable[0]->size();
  G4bool newCoupleAppears = nCouple>nTable;
  if(newCoupleAppears)
  {
    for(std::size_t n=nCouple-nTable; n>0; --n)
    {
      for(std::size_t nn=0; nn< NumberOfG4CutIndex; ++nn)
      {
        rangeCutTable[nn]->push_back(-1.);
        energyCutTable[nn]->push_back(-1.);
      }
    }
  }
 
  // Update RangeEnergy cuts tables
  std::size_t idx = 0;
  G4Timer timer;
  if (verboseLevel>2)
  {
    timer.Start();
  }
  for(auto cItr=coupleTable.cbegin(); cItr!=coupleTable.cend(); ++cItr)
  {
    G4ProductionCuts* aCut = (*cItr)->GetProductionCuts();
    const G4Material* aMat = (*cItr)->GetMaterial();
    if((*cItr)->IsRecalcNeeded())
    {
      for(std::size_t ptcl=0; ptcl< NumberOfG4CutIndex; ++ptcl)
      {
        G4double rCut = aCut->GetProductionCut((G4int)ptcl);
        (*(rangeCutTable[ptcl]))[idx] = rCut;
        // if(converters[ptcl] && (*cItr)->IsUsed())
        if(converters[ptcl])
        {
          (*(energyCutTable[ptcl]))[idx] = converters[ptcl]->Convert(rCut,aMat);
        }
        else
        {
          (*(energyCutTable[ptcl]))[idx] = -1.; 
        }
      }
    }
    ++idx;  
  }
  if (verboseLevel>2)
  {
    timer.Stop();
    G4cout << "G4ProductionCutsTable::UpdateCoupleTable() - "
           << "Elapsed time for calculation of energy cuts: " << G4endl;
    G4cout << timer << G4endl;
  }
 
  // resize Range/Energy cuts double vectors if new couple is made
  if(newCoupleAppears)
  {
    for(std::size_t ix=0; ix<NumberOfG4CutIndex; ++ix)
    {
      G4double* rangeVOld = rangeDoubleVector[ix];
      G4double* energyVOld = energyDoubleVector[ix];
      if(rangeVOld) delete [] rangeVOld;
      if(energyVOld) delete [] energyVOld;
      rangeDoubleVector[ix] = new G4double[(*(rangeCutTable[ix])).size()];
      energyDoubleVector[ix] = new G4double[(*(energyCutTable[ix])).size()];
    }
  }
 
  // Update Range/Energy cuts double vectors
  for(std::size_t ix=0; ix<NumberOfG4CutIndex; ++ix)
  {
    for(std::size_t ixx=0; ixx<(*(rangeCutTable[ix])).size(); ++ixx)
    {
      rangeDoubleVector[ix][ixx] = (*(rangeCutTable[ix]))[ixx];
      energyDoubleVector[ix][ixx] = (*(energyCutTable[ix]))[ixx];
    }
  }
}

Referenced by G4TheRayTracer::CreateBitMap(), and G4RunManagerKernel::UpdateRegion().

---

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

• G4ProductionCutsTable.hh
• G4ProductionCutsTable.cc