G4ProductionCutsTable Class Reference

#include <G4ProductionCutsTable.hh>

Collaboration diagram for G4ProductionCutsTable:

Public Member Functions
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 (size_t pcIdx) const
const std::vector< G4double > *	GetEnergyCutsVector (size_t pcIdx) const
G4double *	GetRangeCutsDoubleVector (size_t pcIdx) const
G4double *	GetEnergyCutsDoubleVector (size_t pcIdx) const
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)
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)

Private Types
enum	{ FixedStringLengthForStore = 32 }
typedef std::vector< G4MaterialCutsCouple * >	G4CoupleTable
typedef std::vector< G4MaterialCutsCouple * >::const_iterator	CoupleTableIterator
typedef std::vector< G4double >	G4CutVectorForAParticle
typedef std::vector< G4CutVectorForAParticle * >	G4CutTable

Private Member Functions
	G4ProductionCutsTable (const G4ProductionCutsTable &right)
void	ScanAndSetCouple (G4LogicalVolume *aLV, G4MaterialCutsCouple *aCouple, G4Region *aRegion)
bool	IsCoupleUsedInTheRegion (const G4MaterialCutsCouple *aCouple, const G4Region *aRegion) const

Private Attributes
G4CoupleTable	coupleTable
G4CutTable	rangeCutTable
G4CutTable	energyCutTable
G4RegionStore *	fG4RegionStore
G4VRangeToEnergyConverter *	converters [NumberOfG4CutIndex]
G4ProductionCuts *	defaultProductionCuts
G4MCCIndexConversionTable	mccConversionTable
G4double *	rangeDoubleVector [NumberOfG4CutIndex]
G4double *	energyDoubleVector [NumberOfG4CutIndex]
G4bool	firstUse
G4int	verboseLevel
G4ProductionCutsTableMessenger *	fMessenger

Static Private Attributes
static G4ProductionCutsTable *	fG4ProductionCutsTable = 0

Detailed Description

Definition at line 71 of file G4ProductionCutsTable.hh.

Member Typedef Documentation

CoupleTableIterator

typedef std::vector<G4MaterialCutsCouple*>::const_iterator G4ProductionCutsTable::CoupleTableIterator

private

Definition at line 113 of file G4ProductionCutsTable.hh.

G4CoupleTable

typedef std::vector<G4MaterialCutsCouple*> G4ProductionCutsTable::G4CoupleTable

private

Definition at line 112 of file G4ProductionCutsTable.hh.

G4CutTable

typedef std::vector<G4CutVectorForAParticle*> G4ProductionCutsTable::G4CutTable

private

Definition at line 115 of file G4ProductionCutsTable.hh.

G4CutVectorForAParticle

typedef std::vector<G4double> G4ProductionCutsTable::G4CutVectorForAParticle

private

Definition at line 114 of file G4ProductionCutsTable.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

private

Enumerator
FixedStringLengthForStore

Definition at line 227 of file G4ProductionCutsTable.hh.

{ FixedStringLengthForStore = 32 }; 

Constructor & Destructor Documentation

G4ProductionCutsTable() [1/2]

G4ProductionCutsTable::G4ProductionCutsTable ( )

protected

Definition at line 73 of file G4ProductionCutsTable.cc.

  : firstUse(true),verboseLevel(1),fMessenger(0)
{
  for(size_t i=0;i< NumberOfG4CutIndex;i++)
  {
    rangeCutTable.push_back(new G4CutVectorForAParticle);
    energyCutTable.push_back(new G4CutVectorForAParticle);
    rangeDoubleVector[i] = 0;
    energyDoubleVector[i] = 0;
    converters[i] = 0;
  }
  fG4RegionStore = G4RegionStore::GetInstance();
  defaultProductionCuts = new G4ProductionCuts();

  // add messenger for UI 
  fMessenger = new G4ProductionCutsTableMessenger(this);
}

Here is the call graph for this function:

G4ProductionCutsTable() [2/2]

G4ProductionCutsTable::G4ProductionCutsTable ( const G4ProductionCutsTable &  right )

private

Definition at line 92 of file G4ProductionCutsTable.cc.

{ 
  fMessenger=0;
  defaultProductionCuts=0; 
  fG4RegionStore =0;
}

~G4ProductionCutsTable()

G4ProductionCutsTable::~G4ProductionCutsTable ( )

virtual

Definition at line 100 of file G4ProductionCutsTable.cc.

{
  if (defaultProductionCuts !=0) {
    delete defaultProductionCuts;
    defaultProductionCuts =0;
  }

  for(CoupleTableIterator itr=coupleTable.begin();itr!=coupleTable.end();itr++){
    delete (*itr); 
  }
  coupleTable.clear();

  for(size_t i=0;i< NumberOfG4CutIndex;i++){
    delete rangeCutTable[i];
    delete energyCutTable[i];
    delete converters[i];
    if(rangeDoubleVector[i]!=0) delete [] rangeDoubleVector[i];
    if(energyDoubleVector[i]!=0) delete [] energyDoubleVector[i];
  }
  fG4ProductionCutsTable =0;

  if (fMessenger !=0) delete fMessenger;
  fMessenger = 0;
}

Member Function Documentation

CheckForRetrieveCutsTable()

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

Definition at line 474 of file G4ProductionCutsTable.cc.

{
  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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckMaterialCutsCoupleInfo()

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

protectedvirtual

Definition at line 852 of file G4ProductionCutsTable.cc.

{
  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 << " Can not open file " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::CheckMaterialCutsCoupleInfo()",
         "ProcCuts102",
         JustWarning, "Can not 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+=1){
    // 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 (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
    CoupleTableIterator cItr;
    G4bool fOK = false;
    G4MaterialCutsCouple* aCouple =0;
    for (cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++){
      aCouple = (*cItr);
      // check material name
      if ( mat_name !=  aCouple->GetMaterial()->GetName() ) continue;
      // check cut values
      G4ProductionCuts* aCut = aCouple->GetProductionCuts();
      G4bool fRatio = true;
      for (size_t j=0; j< NumberOfG4CutIndex; j++) {
        // check ratio only if values are not the same
        if (cutValues[j] != aCut->GetProductionCut(j)) {  
          G4double ratio =  cutValues[j]/aCut->GetProductionCut(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 = 0;
    if ( regionname != "NONE" ) {
      fRegion = fG4RegionStore->GetRegion(region_name);
      if (fRegion==0) {
        G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
        G4cout << "Region " << regionname << " is not found ";      
        G4cout << index << ": in " << fileName  << G4endl;
      } 
    }
    if ( ( (regionname == "NONE") && (aCouple->IsUsed()) )  ||
         ( (fRegion !=0) && !IsCoupleUsedInTheRegion(aCouple, fRegion) ) ) {
      G4cout << "G4ProductionCutTable::CheckMaterialCutsCoupleInfo ";
      G4cout << "A Couple is used differnt region in the current setup  ";
      G4cout << index << ": in " << fileName  << G4endl;
      G4cout << " material: " << mat_name ;
      G4cout << " region: " << region_name << G4endl;
      for (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 ";
        G4cout << "Couples is not defined in the current detector setup  ";
        G4cout << index << ": in " << fileName  << G4endl;
        G4cout << " material: " << mat_name ;
        G4cout << " region: " << region_name << G4endl;
        for (size_t ii=0; ii< NumberOfG4CutIndex; ii++) {
      G4cout << "cut[" << ii << "]=" << cutValues[ii]/mm;
      G4cout << " mm   :  ";
        }
        G4cout << G4endl;
      }
#endif
    }

  }
  fIn.close();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckMaterialInfo()

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

protectedvirtual

Definition at line 580 of file G4ProductionCutsTable.cc.

{
  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 << " Can not open file " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::CheckMaterialInfo()",
         "ProcCuts102",
         JustWarning, "Can not 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];
    double 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 ==0 ) 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, "Inconsitent matrial density");
      fIn.close();
      return false;
    }

  }

  fIn.close();
  return true;

}

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertRangeToEnergy()

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

Definition at line 288 of file G4ProductionCutsTable.cc.

{
  // This method gives energy corresponding to range value  
  // check material
  if (material ==0) 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) {
#ifdef G4VERBOSE  
    if (verboseLevel >1) {
      G4cout << "G4ProductionCutsTable::ConvertRangeToEnergy" ;
      G4cout << particle->GetParticleName() << " has no cut value " << G4endl;
    }  
#endif
    return -1.0;
  }

  return converters[index]->Convert(range, material);
   
}

Here is the call graph for this function:

Here is the caller graph for this function:

DumpCouples()

void G4ProductionCutsTable::DumpCouples

(

)

const

Definition at line 371 of file G4ProductionCutsTable.cc.

{
  G4cout << G4endl;
  G4cout << "========= Table of registered couples =============================="
         << G4endl;
  for(CoupleTableIterator cItr=coupleTable.begin();
      cItr!=coupleTable.end();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 << 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 : " ;
      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;
      typedef std::vector<G4Region*>::iterator regionIterator;
      for(regionIterator rItr=fG4RegionStore->begin();
          rItr!=fG4RegionStore->end();rItr++) {
        if (IsCoupleUsedInTheRegion(aCouple, *rItr) ){
          G4cout << "    " << (*rItr)->GetName() << G4endl;
        }
      }
    }
  }
  G4cout << G4endl;
  G4cout << "====================================================================" << G4endl;
  G4cout << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCoupleIndex() [1/2]

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

inline

Definition at line 332 of file G4ProductionCutsTable.hh.

{ 
  G4int idx = 0;
  for(CoupleTableIterator cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++)
  {
    if((*cItr)==aCouple) return idx;
    idx++;
  }
  return -1;
}

Here is the caller graph for this function:

GetCoupleIndex() [2/2]

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

inline

Definition at line 344 of file G4ProductionCutsTable.hh.

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

Here is the call graph for this function:

GetDefaultProductionCuts()

G4ProductionCuts * G4ProductionCutsTable::GetDefaultProductionCuts ( ) const

inline

Definition at line 298 of file G4ProductionCutsTable.hh.

{ return defaultProductionCuts; }

GetEnergyCutsDoubleVector()

G4double * G4ProductionCutsTable::GetEnergyCutsDoubleVector ( size_t  pcIdx ) const

inline

Definition at line 294 of file G4ProductionCutsTable.hh.

{ return energyDoubleVector[pcIdx]; }

GetEnergyCutsVector()

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

inline

Definition at line 250 of file G4ProductionCutsTable.hh.

{
 return energyCutTable[pcIdx]; 
}

Here is the caller graph for this function:

GetHighEdgeEnergy()

G4double G4ProductionCutsTable::GetHighEdgeEnergy

(

)

const

Definition at line 341 of file G4ProductionCutsTable.cc.

{
  return G4VRangeToEnergyConverter::GetHighEdgeEnergy();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetLowEdgeEnergy()

G4double G4ProductionCutsTable::GetLowEdgeEnergy

(

)

const

Definition at line 335 of file G4ProductionCutsTable.cc.

{
  return G4VRangeToEnergyConverter::GetLowEdgeEnergy();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMaterialCutsCouple() [1/2]

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

inline

Definition at line 262 of file G4ProductionCutsTable.hh.

{ 
  return coupleTable[size_t(i)]; 
}

GetMaterialCutsCouple() [2/2]

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

inline

Definition at line 320 of file G4ProductionCutsTable.hh.

{ 
  for(CoupleTableIterator cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++)
  { 
    if((*cItr)->GetMaterial()!=aMat) continue;
    if((*cItr)->GetProductionCuts()==aCut) return (*cItr);
  }
  return 0;
}

GetMaxEnergyCut()

G4double G4ProductionCutsTable::GetMaxEnergyCut

(

)

Definition at line 1231 of file G4ProductionCutsTable.cc.

{
  return G4VRangeToEnergyConverter::GetMaxEnergyCut();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetMCCIndexConversionTable()

const G4MCCIndexConversionTable * G4ProductionCutsTable::GetMCCIndexConversionTable ( ) const

inline

Definition at line 359 of file G4ProductionCutsTable.hh.

{
  return &mccConversionTable;
}

Here is the caller graph for this function:

GetProductionCutsTable()

G4ProductionCutsTable * G4ProductionCutsTable::GetProductionCutsTable ( )

static

Definition at line 63 of file G4ProductionCutsTable.cc.

{ 
   static G4ProductionCutsTable theProductionCutsTable;
   if(!fG4ProductionCutsTable){
     fG4ProductionCutsTable = &theProductionCutsTable;
   }
  return fG4ProductionCutsTable;
}

GetRangeCutsDoubleVector()

G4double * G4ProductionCutsTable::GetRangeCutsDoubleVector ( size_t  pcIdx ) const

inline

Definition at line 290 of file G4ProductionCutsTable.hh.

{ return rangeDoubleVector[pcIdx]; }

GetRangeCutsVector()

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

inline

Definition at line 244 of file G4ProductionCutsTable.hh.

{ 
  return rangeCutTable[pcIdx]; 
}

Here is the caller graph for this function:

GetTableSize()

size_t G4ProductionCutsTable::GetTableSize ( ) const

inline

Definition at line 256 of file G4ProductionCutsTable.hh.

{
  return coupleTable.size(); 
}

GetVerboseLevel()

G4int G4ProductionCutsTable::GetVerboseLevel ( ) const

inline

Definition at line 352 of file G4ProductionCutsTable.hh.

{
   return verboseLevel;
}

Here is the caller graph for this function:

IsCoupleUsedInTheRegion()

bool G4ProductionCutsTable::IsCoupleUsedInTheRegion ( const G4MaterialCutsCouple *  aCouple, const G4Region *  aRegion  ) const

inlineprivate

Definition at line 302 of file G4ProductionCutsTable.hh.

{
  G4ProductionCuts* fProductionCut = aRegion->GetProductionCuts();
  std::vector<G4Material*>::const_iterator mItr = aRegion->GetMaterialIterator();
  size_t nMaterial = aRegion->GetNumberOfMaterials();
  for(size_t iMate=0;iMate<nMaterial;iMate++, mItr++){
    if(aCouple->GetMaterial()==(*mItr) &&
       aCouple->GetProductionCuts()==fProductionCut){
      return true;
    }
  }
  return false;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsModified()

G4bool G4ProductionCutsTable::IsModified ( ) const

inline

Definition at line 268 of file G4ProductionCutsTable.hh.

{ 
  if(firstUse) return true;
  for(G4ProductionCutsTable::CoupleTableIterator itr=coupleTable.begin();
    itr!=coupleTable.end();itr++){ 
    if((*itr)->IsRecalcNeeded())
    {
      return true; 
    }
  }
  return false;
}

Here is the caller graph for this function:

PhysicsTableUpdated()

void G4ProductionCutsTable::PhysicsTableUpdated ( )

inline

Definition at line 282 of file G4ProductionCutsTable.hh.

{ 
  for(G4ProductionCutsTable::CoupleTableIterator itr=coupleTable.begin();itr!=coupleTable.end();itr++){ 
    (*itr)->PhysicsTableUpdated(); 
  }
}

Here is the caller graph for this function:

ResetConverters()

void G4ProductionCutsTable::ResetConverters

(

)

Definition at line 320 of file G4ProductionCutsTable.cc.

{
  for(size_t i=0;i< NumberOfG4CutIndex;i++){
    if (converters[i]!=0) converters[i]->Reset();
  }
}

Here is the call graph for this function:

RetrieveCutsInfo()

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

protectedvirtual

Definition at line 1117 of file G4ProductionCutsTable.cc.

{
  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 << " Can not open file " << fileName << G4endl;
    }
    G4Exception( "G4ProductionCutsTable::RetrieveCutsInfo()",
         "ProcCuts102",
         JustWarning, "Can not 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 = mccConversionTable.size();
  
  for (size_t idx=0; static_cast<G4int>(idx) <NumberOfG4CutIndex; idx++) {
    G4CutVectorForAParticle* fRange  = rangeCutTable[idx];
    G4CutVectorForAParticle* fEnergy = energyCutTable[idx];
    fRange->clear();
    fEnergy->clear();

    // Loop over all couples
    for (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;
      size_t new_index = mccConversionTable.GetIndex(i);
      (*fRange)[new_index]  = rcut;
      (*fEnergy)[new_index] = ecut;
    }
  }
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RetrieveCutsTable()

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

Definition at line 449 of file G4ProductionCutsTable.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

ScanAndSetCouple()

void G4ProductionCutsTable::ScanAndSetCouple ( G4LogicalVolume *  aLV, G4MaterialCutsCouple *  aCouple, G4Region *  aRegion  )

private

Definition at line 348 of file G4ProductionCutsTable.cc.

{
  //Check whether or not this logical volume belongs to the same region
  if((aRegion!=0) && aLV->GetRegion()!=aRegion) return;

  //Check if this particular volume has a material matched to the couple
  if(aLV->GetMaterial()==aCouple->GetMaterial()) {
    aLV->SetMaterialCutsCouple(aCouple);
  }

  size_t noDaughters = aLV->GetNoDaughters();
  if(noDaughters==0) return;

  //Loop over daughters with same region
  for(size_t i=0;i<noDaughters;i++){
    G4LogicalVolume* daughterLVol = aLV->GetDaughter(i)->GetLogicalVolume();
    ScanAndSetCouple(daughterLVol,aCouple,aRegion);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetEnergyRange()

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

Definition at line 329 of file G4ProductionCutsTable.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetMaxEnergyCut()

void G4ProductionCutsTable::SetMaxEnergyCut

(

G4double

value

)

Definition at line 1238 of file G4ProductionCutsTable.cc.

{
  G4VRangeToEnergyConverter::SetMaxEnergyCut(value);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetVerboseLevel()

void G4ProductionCutsTable::SetVerboseLevel

(

G4int

value

)

Definition at line 1220 of file G4ProductionCutsTable.cc.

{
  verboseLevel = value;
  for (int ip=0; ip< NumberOfG4CutIndex; ip++) {
    if (converters[ip] !=0 ){
      converters[ip]->SetVerboseLevel(value);
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

StoreCutsInfo()

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

protectedvirtual

Definition at line 1039 of file G4ProductionCutsTable.cc.

{
  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 << " Can not open file " << fileName << G4endl;
    }
    G4Exception( "G4ProductionCutsTable::StoreCutsInfo()",
         "ProcCuts102",
         JustWarning, "Can not open file");
    return false;
  }

  G4int numberOfCouples = coupleTable.size();
  if (ascii) {
    // key word
    fOut  << key << G4endl;
    
    // number of couples in the table
    fOut  << numberOfCouples << G4endl;
  } else {
    // key word
    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[i];
    fOut.write(temp, FixedStringLengthForStore);
    
    // number of couples in the table   
    fOut.write( (char*)(&numberOfCouples), sizeof (G4int));
  }

  
  for (size_t idx=0; idx <NumberOfG4CutIndex; idx++) {
    const std::vector<G4double>* fRange  = GetRangeCutsVector(idx);
    const std::vector<G4double>* fEnergy = GetEnergyCutsVector(idx);
    size_t i=0;
    // Loop over all couples
    CoupleTableIterator cItr;
    for (cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++, i++){      
      if (ascii) {
        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 {
        G4double cut =  (*fRange)[i];
        fOut.write((char*)(&cut), sizeof (G4double));
        cut =  (*fEnergy)[i];
        fOut.write((char*)(&cut), sizeof (G4double));
      }
    }
  }
  fOut.close();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

StoreCutsTable()

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

Definition at line 426 of file G4ProductionCutsTable.cc.

{
  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 " ;
    G4cout << " Material/Cuts information have been succesfully stored ";
    if (ascii) {
      G4cout << " in Ascii mode ";
    }else{
      G4cout << " in Binary mode ";
    }
    G4cout << " under " << dir << G4endl;  
  }  
#endif
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

StoreMaterialCutsCoupleInfo()

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

protectedvirtual

Definition at line 721 of file G4ProductionCutsTable.cc.

{  
  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 << " Can not open file " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::StoreMaterialCutsCoupleInfo()",
         "ProcCuts102",
         JustWarning, "Can not open file ");
     return false;
  }
  G4int numberOfCouples = coupleTable.size();
  if (ascii) {
    // key word
    fOut << std::setw(FixedStringLengthForStore) <<  key << G4endl;
    
    // number of couples in the table
    fOut  << numberOfCouples << G4endl;
  } else {
    // key word
    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[i];
    fOut.write(temp, FixedStringLengthForStore);
    
    // number of couples in the table   
    fOut.write( (char*)(&numberOfCouples), sizeof (G4int));
  }

 
  // Loop over all couples
  CoupleTableIterator cItr;
  for (cItr=coupleTable.begin();cItr!=coupleTable.end();cItr++){
    G4MaterialCutsCouple* aCouple = (*cItr);
    G4int index = aCouple->GetIndex(); 
    // cut value
    G4ProductionCuts* aCut = aCouple->GetProductionCuts();
    G4double cutValues[NumberOfG4CutIndex];
    for (size_t idx=0; idx <NumberOfG4CutIndex; idx++) {
      cutValues[idx] = aCut->GetProductionCut(idx);
    }
    // material/region info
    G4String materialName = aCouple->GetMaterial()->GetName();
    G4String regionName = "NONE";
    if (aCouple->IsUsed()){
      typedef std::vector<G4Region*>::iterator regionIterator;
      for(regionIterator rItr=fG4RegionStore->begin();
          rItr!=fG4RegionStore->end();rItr++){
        if (IsCoupleUsedInTheRegion(aCouple, *rItr) ){
          regionName = (*rItr)->GetName();
          break;
        }
      }
    }

    if (ascii) {
      // 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 (size_t idx=0; idx< NumberOfG4CutIndex; idx++) {
        fOut << std::setw(FixedStringLengthForStore) << cutValues[idx]/(mm)
             << G4endl;
      }
      fOut.unsetf(std::ios::scientific);

    } else {
      // index
      fOut.write( (char*)(&index), sizeof (G4int));
    
      // material name
      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[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[i];
      }
      fOut.write(temp, FixedStringLengthForStore);

      // cut values
      for (size_t idx=0; idx< NumberOfG4CutIndex; idx++) {
         fOut.write( (char*)(&(cutValues[idx])), sizeof (G4double));
      }    
    }
   }    

  fOut.close();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

StoreMaterialInfo()

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

protectedvirtual

Definition at line 493 of file G4ProductionCutsTable.cc.

{
  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 << " Can not open file " << fileName << G4endl;
    }
#endif
    G4Exception( "G4ProductionCutsTable::StoreMaterialInfo()",
         "ProcCuts102",
         JustWarning, "Can not open file ");
    return false;
  }
  
  const G4MaterialTable* matTable = G4Material::GetMaterialTable(); 
  // number of materials in the table
  G4int numberOfMaterial = matTable->size();

 if (ascii) {
    // key word
    fOut  << key << G4endl;
    
    // number of materials in the table
    fOut  << numberOfMaterial << G4endl;
    
    fOut.setf(std::ios::scientific);
  
    // material name and density
    for (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 {
    char temp[FixedStringLengthForStore];
    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[i];
    }
    fOut.write(temp, FixedStringLengthForStore);

    // number of materials in the table
    fOut.write( (char*)(&numberOfMaterial), sizeof (G4int));
    
    // material name and density
    for (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[i];
      fOut.write(temp, FixedStringLengthForStore);
      fOut.write( (char*)(&density), sizeof (G4double));
    }    
   }    

  fOut.close();
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateCoupleTable()

void G4ProductionCutsTable::UpdateCoupleTable

(

G4VPhysicalVolume *

currentWorld

)

Definition at line 125 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(CoupleTableIterator CoupleItr=coupleTable.begin();
        CoupleItr!=coupleTable.end();CoupleItr++) 
  {
    (*CoupleItr)->SetUseFlag(false); 
  }

  // Update Material-Cut-Couple
  typedef std::vector<G4Region*>::iterator regionIterator;
  for(regionIterator rItr=fG4RegionStore->begin();
                rItr!=fG4RegionStore->end();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();
    std::vector<G4Material*>::const_iterator mItr =
      (*rItr)->GetMaterialIterator();
    size_t nMaterial = (*rItr)->GetNumberOfMaterials();
    (*rItr)->ClearMap();

    for(size_t iMate=0;iMate<nMaterial;iMate++){
      //check if this material cut couple has already been made
      G4bool coupleAlreadyDefined = false;
      G4MaterialCutsCouple* aCouple;
      for(CoupleTableIterator cItr=coupleTable.begin();
          cItr!=coupleTable.end();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(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();

      std::vector<G4LogicalVolume*>::iterator rootLVItr
                         = (*rItr)->GetRootLogicalVolumeIterator();
      size_t nRootLV = (*rItr)->GetNumberOfRootVolumes();
      for(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
  size_t nCouple = coupleTable.size();
  size_t nTable = energyCutTable[0]->size();
  G4bool newCoupleAppears = nCouple>nTable;
  if(newCoupleAppears) {
    for(size_t n=nCouple-nTable;n>0;n--) {
      for(size_t nn=0;nn< NumberOfG4CutIndex;nn++){
        rangeCutTable[nn]->push_back(-1.);
        energyCutTable[nn]->push_back(-1.);
      }
    }
  }

  // Update RangeEnergy cuts tables
  size_t idx = 0;
  G4Timer timer;
  if (verboseLevel>2) {
    timer.Start();
  }
  for(CoupleTableIterator cItr=coupleTable.begin();
      cItr!=coupleTable.end();cItr++){
    G4ProductionCuts* aCut = (*cItr)->GetProductionCuts();
    const G4Material* aMat = (*cItr)->GetMaterial();
    if((*cItr)->IsRecalcNeeded()) {
      for(size_t ptcl=0;ptcl< NumberOfG4CutIndex;ptcl++){
        G4double rCut = aCut->GetProductionCut(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(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(size_t ix=0;ix<NumberOfG4CutIndex;ix++) {
    for(size_t ixx=0;ixx<(*(rangeCutTable[ix])).size();ixx++) {
      rangeDoubleVector[ix][ixx] = (*(rangeCutTable[ix]))[ixx];
      energyDoubleVector[ix][ixx] = (*(energyCutTable[ix]))[ixx];
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

converters

G4VRangeToEnergyConverter* G4ProductionCutsTable::converters[NumberOfG4CutIndex]

private

Definition at line 121 of file G4ProductionCutsTable.hh.

coupleTable

G4CoupleTable G4ProductionCutsTable::coupleTable

private

Definition at line 116 of file G4ProductionCutsTable.hh.

defaultProductionCuts

G4ProductionCuts* G4ProductionCutsTable::defaultProductionCuts

private

Definition at line 123 of file G4ProductionCutsTable.hh.

energyCutTable

G4CutTable G4ProductionCutsTable::energyCutTable

private

Definition at line 118 of file G4ProductionCutsTable.hh.

energyDoubleVector

G4double* G4ProductionCutsTable::energyDoubleVector[NumberOfG4CutIndex]

private

Definition at line 129 of file G4ProductionCutsTable.hh.

fG4ProductionCutsTable

G4ProductionCutsTable * G4ProductionCutsTable::fG4ProductionCutsTable = 0

staticprivate

Definition at line 110 of file G4ProductionCutsTable.hh.

fG4RegionStore

G4RegionStore* G4ProductionCutsTable::fG4RegionStore

private

Definition at line 120 of file G4ProductionCutsTable.hh.

firstUse

G4bool G4ProductionCutsTable::firstUse

private

Definition at line 226 of file G4ProductionCutsTable.hh.

fMessenger

G4ProductionCutsTableMessenger* G4ProductionCutsTable::fMessenger

private

Definition at line 239 of file G4ProductionCutsTable.hh.

mccConversionTable

G4MCCIndexConversionTable G4ProductionCutsTable::mccConversionTable

private

Definition at line 125 of file G4ProductionCutsTable.hh.

rangeCutTable

G4CutTable G4ProductionCutsTable::rangeCutTable

private

Definition at line 117 of file G4ProductionCutsTable.hh.

rangeDoubleVector

G4double* G4ProductionCutsTable::rangeDoubleVector[NumberOfG4CutIndex]

private

Definition at line 128 of file G4ProductionCutsTable.hh.

verboseLevel

G4int G4ProductionCutsTable::verboseLevel

private

Definition at line 238 of file G4ProductionCutsTable.hh.

---

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

• G4ProductionCutsTable.hh
• G4ProductionCutsTable.cc