#include <G4Material.hh>

Inheritance diagram for G4Material:

Public Member Functions
	G4Material (const G4String &name, G4double z, G4double a, G4double density, G4State state=kStateUndefined, G4double temp=NTP_Temperature, G4double pressure=CLHEP::STP_Pressure)

	G4Material (const G4String &name, G4double density, G4int nComponents, G4State state=kStateUndefined, G4double temp=NTP_Temperature, G4double pressure=CLHEP::STP_Pressure)

	G4Material (const G4String &name, G4double density, const G4Material *baseMaterial, G4State state=kStateUndefined, G4double temp=NTP_Temperature, G4double pressure=CLHEP::STP_Pressure)

void	AddElement (G4Element *element, G4int nAtoms)

void	AddElement (G4Element *element, G4double fraction)

void	AddMaterial (G4Material *material, G4double fraction)

virtual	~G4Material ()

void	SetChemicalFormula (const G4String &chF)

const G4String &	GetName () const

const G4String &	GetChemicalFormula () const

G4double	GetDensity () const

G4State	GetState () const

G4double	GetTemperature () const

G4double	GetPressure () const

size_t	GetNumberOfElements () const

const G4ElementVector *	GetElementVector () const

const G4double *	GetFractionVector () const

const G4int *	GetAtomsVector () const

const G4Element *	GetElement (G4int iel) const

const G4double *	GetVecNbOfAtomsPerVolume () const

G4double	GetTotNbOfAtomsPerVolume () const

G4double	GetTotNbOfElectPerVolume () const

const G4double *	GetAtomicNumDensityVector () const

G4double	GetElectronDensity () const

G4double	GetRadlen () const

G4double	GetNuclearInterLength () const

G4IonisParamMat *	GetIonisation () const

G4SandiaTable *	GetSandiaTable () const

const G4Material *	GetBaseMaterial () const

const std::map< G4Material *, G4double > &	GetMatComponents () const

G4double	GetMassOfMolecule () const

G4double	GetZ () const

G4double	GetA () const

void	SetMaterialPropertiesTable (G4MaterialPropertiesTable *anMPT)

G4MaterialPropertiesTable *	GetMaterialPropertiesTable () const

size_t	GetIndex () const

	G4Material (__void__ &)

void	SetName (const G4String &name)

virtual G4bool	IsExtended () const

Static Public Member Functions
static G4MaterialTable *	GetMaterialTable ()

static size_t	GetNumberOfMaterials ()

static G4Material *	GetMaterial (const G4String &name, G4bool warning=true)

Friends
std::ostream &	operator<< (std::ostream &, const G4Material *)

std::ostream &	operator<< (std::ostream &, const G4Material &)

std::ostream &	operator<< (std::ostream &, G4MaterialTable)

Detailed Description

Definition at line 120 of file G4Material.hh.

Constructor & Destructor Documentation

G4Material::G4Material	(	const G4String &	name,
		G4double	z,
		G4double	a,
		G4double	density,
		G4State	state = `kStateUndefined`,
		G4double	temp = `NTP_Temperature`,
		G4double	pressure = `CLHEP::STP_Pressure`
	)

Definition at line 90 of file G4Material.cc.

   : fName(name)            
 {
   InitializePointers();
     
   if (density < universe_mean_density)
     { 
       G4cout << " G4Material WARNING:"
          << " define a material with density=0 is not allowed. \n"
          << " The material " << name << " will be constructed with the"
          << " default minimal density: " << universe_mean_density/(g/cm3) 
          << "g/cm3" << G4endl;
       density = universe_mean_density;
     } 
 
   fDensity  = density;
   fState    = state;
   fTemp     = temp;
   fPressure = pressure;
 
   // Initialize theElementVector allocating one
   // element corresponding to this material
   maxNbComponents        = fNumberOfComponents = fNumberOfElements = 1;
   fArrayLength           = maxNbComponents;
   theElementVector       = new G4ElementVector();
 
   const std::vector<G4String> elmnames = 
     G4NistManager::Instance()->GetNistElementNames();
   G4String enam, snam;
   G4int iz = G4lrint(z);
   if(iz < (G4int)elmnames.size()) { 
     snam = elmnames[iz]; 
     enam = snam; 
   } else { 
     enam = "ELM_" + name; 
     snam = name;
   }
   theElementVector->push_back(new G4Element(enam, snam, z, a));  
 
   fMassFractionVector    = new G4double[1];
   fMassFractionVector[0] = 1. ;
   fMassOfMolecule        = a/CLHEP::Avogadro;
   
   if (fState == kStateUndefined)
     {
       if (fDensity > kGasThreshold) { fState = kStateSolid; }
       else                          { fState = kStateGas; }
     }
 
   ComputeDerivedQuantities();
 }

Here is the call graph for this function:

G4Material::G4Material	(	const G4String &	name,
		G4double	density,
		G4int	nComponents,
		G4State	state = `kStateUndefined`,
		G4double	temp = `NTP_Temperature`,
		G4double	pressure = `CLHEP::STP_Pressure`
	)

Definition at line 149 of file G4Material.cc.

   : fName(name)            
 {
   InitializePointers();
     
   if (density < universe_mean_density)
     {
       G4cout << "--- Warning from G4Material::G4Material()"
          << " define a material with density=0 is not allowed. \n"
          << " The material " << name << " will be constructed with the"
          << " default minimal density: " << universe_mean_density/(g/cm3) 
          << "g/cm3" << G4endl;
       density = universe_mean_density;
     }
         
   fDensity  = density;
   fState    = state;
   fTemp     = temp;
   fPressure = pressure;
     
   maxNbComponents     = nComponents;
   fArrayLength        = maxNbComponents;
   fNumberOfComponents = fNumberOfElements = 0;
   theElementVector    = new G4ElementVector();
   theElementVector->reserve(maxNbComponents);  
     
   if (fState == kStateUndefined) 
     {
       if (fDensity > kGasThreshold) { fState = kStateSolid; }
       else                          { fState = kStateGas; }
     }
 }

Here is the call graph for this function:

G4Material::G4Material	(	const G4String &	name,
		G4double	density,
		const G4Material *	baseMaterial,
		G4State	state = `kStateUndefined`,
		G4double	temp = `NTP_Temperature`,
		G4double	pressure = `CLHEP::STP_Pressure`
	)

Definition at line 188 of file G4Material.cc.

   : fName(name)            
 {
   InitializePointers();
     
   if (density < universe_mean_density)
     {
       G4cout << "--- Warning from G4Material::G4Material()"
          << " define a material with density=0 is not allowed. \n"
          << " The material " << name << " will be constructed with the"
          << " default minimal density: " << universe_mean_density/(g/cm3) 
          << "g/cm3" << G4endl;
       density = universe_mean_density;
     }
 
   fDensity  = density;
   fState    = state;
   fTemp     = temp;
   fPressure = pressure;
 
   fBaseMaterial = bmat;
   fChemicalFormula = fBaseMaterial->GetChemicalFormula();
   fMassOfMolecule  = fBaseMaterial->GetMassOfMolecule();
 
   fNumberOfElements = fBaseMaterial->GetNumberOfElements();     
   maxNbComponents = fNumberOfElements;
   fNumberOfComponents = fNumberOfElements;
 
   CopyPointersOfBaseMaterial();
 }

Here is the call graph for this function:

G4Material::~G4Material ( )

virtual

Definition at line 234 of file G4Material.cc.

 {
   //  G4cout << "### Destruction of material " << fName << " started" <<G4endl;
   if(fBaseMaterial == nullptr) {
     delete theElementVector;  
     delete fSandiaTable; 
     //delete fMaterialPropertiesTable;
     if(fMassFractionVector) { delete [] fMassFractionVector; } 
     if(fAtomsVector)        { delete [] fAtomsVector; } 
   }
   delete fIonisation; 
   if(VecNbOfAtomsPerVolume) { delete [] VecNbOfAtomsPerVolume; } 
 
   // Remove this material from theMaterialTable.
   //
   theMaterialTable[fIndexInTable] = nullptr;
 }

G4Material::G4Material ( __void__ & )

Definition at line 226 of file G4Material.cc.

   : fName("")
 {
   InitializePointers();
 }

Member Function Documentation

void G4Material::AddElement	(	G4Element *	element,
		G4int	nAtoms
	)

Definition at line 362 of file G4Material.cc.

 {   
   // initialization
   if ( fNumberOfElements == 0 ) {
      fAtomsVector        = new G4int   [fArrayLength];
      fMassFractionVector = new G4double[fArrayLength];
   }
 
   // filling ...
   if ( fNumberOfElements < maxNbComponents ) {
      theElementVector->push_back(element);     
      fAtomsVector[fNumberOfElements] = nAtoms;
      fNumberOfComponents = ++fNumberOfElements;
   } else {
     G4cout << "G4Material::AddElement ERROR for " << fName << " nElement= " 
        <<  fNumberOfElements << G4endl;
     G4Exception ("G4Material::AddElement()", "mat031", FatalException, 
            "Attempt to add more than the declared number of elements.");
   } 
   // filled.
   if ( fNumberOfElements == maxNbComponents ) {     
     // compute proportion by mass
     G4int i=0;
     G4double Amol = 0.;
     for (i=0; i<fNumberOfElements; ++i) {
       G4double w = fAtomsVector[i]*(*theElementVector)[i]->GetA(); 
       Amol += w;
       fMassFractionVector[i] = w;
     }
     for (i=0; i<fNumberOfElements; ++i) {
       fMassFractionVector[i] /= Amol;
     }
 
     fMassOfMolecule = Amol/Avogadro;
     ComputeDerivedQuantities();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4Material::AddElement	(	G4Element *	element,
		G4double	fraction
	)

Definition at line 404 of file G4Material.cc.

 {
   if(fraction < 0.0 || fraction > 1.0) {
     G4cout << "G4Material::AddElement ERROR for " << fName << " and " 
        << element->GetName() << "  mass fraction= " << fraction 
        << " is wrong " << G4endl;
     G4Exception ("G4Material::AddElement()", "mat032", FatalException,     
                  "Attempt to add element with wrong mass fraction");
   }
   // initialization
   if (fNumberOfComponents == 0) {
     fMassFractionVector = new G4double[fArrayLength];
     fAtomsVector        = new G4int   [fArrayLength];
   }
   // filling ...
   if (fNumberOfComponents < maxNbComponents) {
     G4int el = 0;
     // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
     while ((el<fNumberOfElements)&&(element!=(*theElementVector)[el])) { ++el; }
     if (el<fNumberOfElements) fMassFractionVector[el] += fraction;
     else {
       theElementVector->push_back(element); 
       fMassFractionVector[el] = fraction;
       ++fNumberOfElements;
     }
     ++fNumberOfComponents;  
   } else {
     G4cout << "G4Material::AddElement ERROR for " << fName << " nElement= " 
        <<  fNumberOfElements << G4endl;
     G4Exception ("G4Material::AddElement()", "mat033", FatalException, 
            "Attempt to add more than the declared number of elements.");
   }    
 
   // filled.
   if (fNumberOfComponents == maxNbComponents) {
 
     G4int i=0;
     G4double Zmol(0.), Amol(0.);
     // check sum of weights -- OK?
     G4double wtSum(0.0);
     for (i=0; i<fNumberOfElements; ++i) {
       wtSum += fMassFractionVector[i];
       Zmol +=  fMassFractionVector[i]*(*theElementVector)[i]->GetZ();
       Amol +=  fMassFractionVector[i]*(*theElementVector)[i]->GetA();
     }
     if (std::fabs(1.-wtSum) > perThousand) {
       G4cerr << "WARNING !! for " << fName << " sum of fractional masses "
          <<  wtSum << " is not 1 - results may be wrong" 
          << G4endl;
     }
     for (i=0; i<fNumberOfElements; ++i) {
       fAtomsVector[i] = 
     G4lrint(fMassFractionVector[i]*Amol/(*theElementVector)[i]->GetA());
     }
      
     ComputeDerivedQuantities();
   }
 }

Here is the call graph for this function:

void G4Material::AddMaterial	(	G4Material *	material,
		G4double	fraction
	)

store massFraction of material component

Definition at line 467 of file G4Material.cc.

 {
   if(fraction < 0.0 || fraction > 1.0) {
     G4cout << "G4Material::AddMaterial ERROR for " << fName << " and " 
        << material->GetName() << "  mass fraction= " << fraction 
        << " is wrong ";
     G4Exception ("G4Material::AddMaterial()", "mat034", FatalException,
                  "Attempt to add material with wrong mass fraction");      
   }
   // initialization
   if (fNumberOfComponents == 0) {
     fMassFractionVector = new G4double[fArrayLength];
     fAtomsVector        = new G4int   [fArrayLength];
   }
 
   G4int nelm = material->GetNumberOfElements();
 
   // arrays should be extended
   if(nelm > 1) {
     G4int nold    = fArrayLength;
     fArrayLength += nelm - 1;
     G4double* v1 = new G4double[fArrayLength];
     G4int* i1    = new G4int[fArrayLength];
     for(G4int i=0; i<nold; ++i) {
       v1[i] = fMassFractionVector[i];
       i1[i] = fAtomsVector[i];
     }
     delete [] fAtomsVector;
     delete [] fMassFractionVector;
     fMassFractionVector = v1;
     fAtomsVector = i1;
   }
 
   // filling ...
   if (fNumberOfComponents < maxNbComponents) {
     for (G4int elm=0; elm<nelm; ++elm)
       {
         G4Element* element = (*(material->GetElementVector()))[elm];
         G4int el = 0;
     // Loop checking, 07-Aug-2015, Vladimir Ivanchenko
         while ((el<fNumberOfElements)&&(element!=(*theElementVector)[el])) el++;
         if (el < fNumberOfElements) fMassFractionVector[el] += fraction
                                           *(material->GetFractionVector())[elm];
         else {
       theElementVector->push_back(element); 
           fMassFractionVector[el] = fraction
                                       *(material->GetFractionVector())[elm];
           ++fNumberOfElements;
         }
       } 
     ++fNumberOfComponents;
     fMatComponents[material] = fraction;
       
   } else {
     G4cout << "G4Material::AddMaterial ERROR for " << fName << " nElement= " 
        <<  fNumberOfElements << G4endl;
     G4Exception ("G4Material::AddMaterial()", "mat035", FatalException, 
            "Attempt to add more than the declared number of components.");
   }    
 
   // filled.
   if (fNumberOfComponents == maxNbComponents) {
     G4int i=0;
     G4double Zmol(0.), Amol(0.);
     // check sum of weights -- OK?
     G4double wtSum(0.0);
     for (i=0; i<fNumberOfElements; ++i) {
       wtSum += fMassFractionVector[i];
       Zmol +=  fMassFractionVector[i]*(*theElementVector)[i]->GetZ();
       Amol +=  fMassFractionVector[i]*(*theElementVector)[i]->GetA();
     }
     if (std::fabs(1.-wtSum) > perThousand) {
       G4cout << "G4Material::AddMaterial WARNING !! for " << fName 
          << " sum of fractional masses "
          <<  wtSum << " is not 1 - results may be wrong" 
          << G4endl;
     }
     for (i=0; i<fNumberOfElements; ++i) {
       fAtomsVector[i] = 
     G4lrint(fMassFractionVector[i]*Amol/(*theElementVector)[i]->GetA());
     }
      
     ComputeDerivedQuantities();
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4double G4Material::GetA ( ) const

Definition at line 636 of file G4Material.cc.

 { 
   if (fNumberOfElements > 1) { 
     G4cout << "G4Material ERROR in GetA. The material: " << fName 
        << " is a mixture.";
     G4Exception ("G4Material::GetA()", "mat037", FatalException,  
          "the Atomic mass is not well defined." );
   } 
   return  (*theElementVector)[0]->GetA();      
 }

Here is the call graph for this function:

Here is the caller graph for this function:

const G4double* G4Material::GetAtomicNumDensityVector ( ) const

inline

Definition at line 216 of file G4Material.hh.

216 {return VecNbOfAtomsPerVolume;}

Here is the caller graph for this function:

const G4int* G4Material::GetAtomsVector ( ) const

inline

Definition at line 198 of file G4Material.hh.

198 {return fAtomsVector;}

Here is the caller graph for this function:

const G4Material* G4Material::GetBaseMaterial ( ) const

inline

Definition at line 233 of file G4Material.hh.

233 {return fBaseMaterial;}

Here is the caller graph for this function:

const G4String& G4Material::GetChemicalFormula ( ) const

inline

Definition at line 179 of file G4Material.hh.

179 {return fChemicalFormula;}

Here is the caller graph for this function:

G4double G4Material::GetDensity ( ) const

inline

Definition at line 180 of file G4Material.hh.

180 {return fDensity;}

G4double G4Material::GetElectronDensity ( ) const

inline

Definition at line 217 of file G4Material.hh.

217 {return TotNbOfElectPerVolume;}

Here is the caller graph for this function:

const G4Element* G4Material::GetElement ( G4int iel ) const

inline

Definition at line 202 of file G4Material.hh.

202 {return (*theElementVector)[iel];}

Here is the caller graph for this function:

const G4ElementVector* G4Material::GetElementVector ( ) const

inline

Definition at line 190 of file G4Material.hh.

190 {return theElementVector;}

const G4double* G4Material::GetFractionVector ( ) const

inline

Definition at line 194 of file G4Material.hh.

194 {return fMassFractionVector;}

Here is the caller graph for this function:

size_t G4Material::GetIndex ( ) const

inline

Definition at line 262 of file G4Material.hh.

262 {return fIndexInTable;}

G4IonisParamMat* G4Material::GetIonisation ( ) const

inline

Definition at line 226 of file G4Material.hh.

226 {return fIonisation;}

Here is the caller graph for this function:

G4double G4Material::GetMassOfMolecule ( ) const

inline

Definition at line 242 of file G4Material.hh.

242 {return fMassOfMolecule;}

Here is the caller graph for this function:

const std::map<G4Material*,G4double>& G4Material::GetMatComponents ( ) const

inline

Definition at line 237 of file G4Material.hh.

238 {return fMatComponents;}

Here is the caller graph for this function:

G4Material * G4Material::GetMaterial	(	const G4String &	name,
		G4bool	warning = `true`
	)

static

Definition at line 602 of file G4Material.cc.

 {  
   // search the material by its name 
   for (size_t J=0 ; J<theMaterialTable.size() ; ++J)
     {
       if (theMaterialTable[J]->GetName() == materialName)
     { return theMaterialTable[J]; }
     }
    
   // the material does not exist in the table
   if (warning) {
     G4cout << "G4Material::GetMaterial() WARNING: The material: "
        << materialName 
        << " does not exist in the table. Return NULL pointer."
        << G4endl;
   }  
   return nullptr;
 }

Here is the call graph for this function:

G4MaterialPropertiesTable* G4Material::GetMaterialPropertiesTable ( ) const

inline

Definition at line 252 of file G4Material.hh.

253 {return fMaterialPropertiesTable;}

Here is the caller graph for this function:

G4MaterialTable * G4Material::GetMaterialTable ( )

static

Definition at line 587 of file G4Material.cc.

 {
   return &theMaterialTable;
 }

const G4String& G4Material::GetName ( void ) const

inline

Definition at line 178 of file G4Material.hh.

178 {return fName;}

G4double G4Material::GetNuclearInterLength ( ) const

inline

Definition at line 223 of file G4Material.hh.

223 {return fNuclInterLen;}

Here is the caller graph for this function:

size_t G4Material::GetNumberOfElements ( ) const

inline

Definition at line 186 of file G4Material.hh.

186 {return fNumberOfElements;}

size_t G4Material::GetNumberOfMaterials ( )

static

Definition at line 594 of file G4Material.cc.

 {
   return theMaterialTable.size();
 }

Here is the caller graph for this function:

G4double G4Material::GetPressure ( ) const

inline

Definition at line 183 of file G4Material.hh.

183 {return fPressure;}

Here is the caller graph for this function:

G4double G4Material::GetRadlen ( ) const

inline

Definition at line 220 of file G4Material.hh.

220 {return fRadlen;}

Here is the caller graph for this function:

G4SandiaTable* G4Material::GetSandiaTable ( ) const

inline

Definition at line 229 of file G4Material.hh.

229 {return fSandiaTable;}

Here is the caller graph for this function:

G4State G4Material::GetState ( ) const

inline

Definition at line 181 of file G4Material.hh.

181 {return fState;}

Here is the caller graph for this function:

G4double G4Material::GetTemperature ( ) const

inline

Definition at line 182 of file G4Material.hh.

182 {return fTemp;}

Here is the caller graph for this function:

G4double G4Material::GetTotNbOfAtomsPerVolume ( ) const

inline

Definition at line 209 of file G4Material.hh.

209 {return TotNbOfAtomsPerVolume;}

Here is the caller graph for this function:

G4double G4Material::GetTotNbOfElectPerVolume ( ) const

inline

Definition at line 212 of file G4Material.hh.

212 {return TotNbOfElectPerVolume;}

Here is the caller graph for this function:

const G4double* G4Material::GetVecNbOfAtomsPerVolume ( ) const

inline

Definition at line 206 of file G4Material.hh.

206 {return VecNbOfAtomsPerVolume;}

Here is the caller graph for this function:

G4double G4Material::GetZ ( ) const

Definition at line 623 of file G4Material.cc.

 { 
   if (fNumberOfElements > 1) {
      G4cout << "G4Material ERROR in GetZ. The material: " << fName 
         << " is a mixture.";
      G4Exception ("G4Material::GetZ()", "mat036", FatalException, 
                   "the Atomic number is not well defined." );
   } 
   return (*theElementVector)[0]->GetZ();      
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4bool G4Material::IsExtended ( ) const

virtual

Reimplemented in G4ExtendedMaterial.

Definition at line 724 of file G4Material.cc.

725 { return false; }

Here is the caller graph for this function:

void G4Material::SetChemicalFormula ( const G4String & chF )

inline

Definition at line 173 of file G4Material.hh.

173 {fChemicalFormula=chF;}

Here is the caller graph for this function:

void G4Material::SetMaterialPropertiesTable ( G4MaterialPropertiesTable * anMPT )

inline

Definition at line 249 of file G4Material.hh.

250 {fMaterialPropertiesTable = anMPT;}

Here is the caller graph for this function:

void G4Material::SetName ( const G4String & name )

inline

Definition at line 279 of file G4Material.hh.

279 {fName=name;}

name

const XML_Char * name

Definition: expat.h:151

Here is the caller graph for this function:

Friends And Related Function Documentation

std::ostream& operator<<	(	std::ostream &	flux,
		const G4Material *	material
	)

friend

Definition at line 650 of file G4Material.cc.

 {
   std::ios::fmtflags mode = flux.flags();
   flux.setf(std::ios::fixed,std::ios::floatfield);
   G4long prec = flux.precision(3);
   
   flux
     << " Material: "         << std::setw(8) <<  material->fName
     << " " << material->fChemicalFormula << " "
     << "  density: "         << std::setw(6) << std::setprecision(3)  
     << G4BestUnit(material->fDensity,"Volumic Mass") 
     << "  RadL: "            << std::setw(7)  << std::setprecision(3)  
     << G4BestUnit(material->fRadlen,"Length")
     << "  Nucl.Int.Length: " << std::setw(7)  << std::setprecision(3)  
     << G4BestUnit(material->fNuclInterLen,"Length") 
     << "\n" << std::setw(30)   
     << "  Imean: "           << std::setw(7)  << std::setprecision(3)  
     << G4BestUnit(material->GetIonisation()->GetMeanExcitationEnergy(),
           "Energy");
     
   if(material->fState == kStateGas) {
     flux
       << "  temperature: " << std::setw(6) << std::setprecision(2)  
       << (material->fTemp)/kelvin << " K"
       << "  pressure: "    << std::setw(6) << std::setprecision(2)   
       << (material->fPressure)/atmosphere << " atm";
   }
   flux << "\n";
   
   for (G4int i=0; i<material->fNumberOfElements; i++) {
     flux 
       << "\n   ---> " << (*(material->theElementVector))[i] 
       << "\n          ElmMassFraction: " 
       << std::setw(6)<< std::setprecision(2) 
       << (material->fMassFractionVector[i])/perCent << " %" 
       << "  ElmAbundance "     << std::setw(6)<< std::setprecision(2) 
       << 100*(material->VecNbOfAtomsPerVolume[i])
       /(material->TotNbOfAtomsPerVolume)
       << " % \n";
   }
   flux.precision(prec);    
   flux.setf(mode,std::ios::floatfield);
 
   if(material->IsExtended())
   { static_cast<const G4ExtendedMaterial*>(material)->Print(flux); }
 
   return flux;
 }

std::ostream& operator<<	(	std::ostream &	flux,
		const G4Material &	material
	)

friend

Definition at line 701 of file G4Material.cc.

 {
   flux << &material;        
   return flux;
 }

std::ostream& operator<<	(	std::ostream &	flux,
		G4MaterialTable	MaterialTable
	)

friend

Definition at line 709 of file G4Material.cc.

 {
   //Dump info for all known materials
   flux << "\n***** Table : Nb of materials = " << MaterialTable.size() 
        << " *****\n" << G4endl;
         
   for (size_t i=0; i<MaterialTable.size(); ++i) { 
     flux << MaterialTable[i] << G4endl << G4endl; 
   }
 
   return flux;
 }      

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

source/geant4.10.03.p03/source/materials/include/G4Material.hh
source/geant4.10.03.p03/source/materials/src/G4Material.cc

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation