#include <G4ProductionCutsTable.hh>

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)

Detailed Description

Definition at line 71 of file G4ProductionCutsTable.hh.

Constructor & Destructor Documentation

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::~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

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:

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:

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:

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:

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:

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:

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:

G4ProductionCuts * G4ProductionCutsTable::GetDefaultProductionCuts ( ) const

inline

Definition at line 298 of file G4ProductionCutsTable.hh.

299 { return defaultProductionCuts; }

G4double * G4ProductionCutsTable::GetEnergyCutsDoubleVector ( size_t pcIdx ) const

inline

Definition at line 294 of file G4ProductionCutsTable.hh.

295 { return energyDoubleVector[pcIdx]; }

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:

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:

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:

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

inline

Definition at line 262 of file G4ProductionCutsTable.hh.

 { 
   return coupleTable[size_t(i)]; 
 }

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

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:

const G4MCCIndexConversionTable * G4ProductionCutsTable::GetMCCIndexConversionTable ( ) const

inline

Definition at line 359 of file G4ProductionCutsTable.hh.

 {
   return &mccConversionTable;
 }

Here is the caller graph for this function:

G4ProductionCutsTable * G4ProductionCutsTable::GetProductionCutsTable ( )

static

Definition at line 63 of file G4ProductionCutsTable.cc.

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

G4double * G4ProductionCutsTable::GetRangeCutsDoubleVector ( size_t pcIdx ) const

inline

Definition at line 290 of file G4ProductionCutsTable.hh.

291 { return rangeDoubleVector[pcIdx]; }

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:

size_t G4ProductionCutsTable::GetTableSize ( ) const

inline

Definition at line 256 of file G4ProductionCutsTable.hh.

 {
   return coupleTable.size(); 
 }

G4int G4ProductionCutsTable::GetVerboseLevel ( ) const

inline

Definition at line 352 of file G4ProductionCutsTable.hh.

 {
    return verboseLevel;
 }

Here is the caller graph for this function:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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:

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

source/geant4.10.03.p03/source/processes/cuts/include/G4ProductionCutsTable.hh
source/geant4.10.03.p03/source/processes/cuts/src/G4ProductionCutsTable.cc

Public Member Functions

Static Public Member Functions

Protected Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation