CCalMaterialFactory Class Reference

#include <CCalMaterialFactory.hh>

Public Types
enum	MatDescription { byWeight, byVolume, byAtomic }

Public Member Functions
	~CCalMaterialFactory ()
G4Material *	findMaterial (const G4String &) const
G4Element *	findElement (const G4String &) const
G4Element *	addElement (const G4String &, const G4String &, G4double, G4double, G4double)
G4Material *	addMaterial (const G4String &nam, G4double density, G4int nconst, G4String mats[], G4double prop[], MatDescription md=byWeight)
void	readElements (const G4String &)
void	readMaterials (const G4String &)

Static Public Member Functions
static CCalMaterialFactory *	getInstance (const G4String &, const G4String &)
static CCalMaterialFactory *	getInstance (const G4String &)
static CCalMaterialFactory *	getInstance ()

Protected Member Functions
void	readElements (std::ifstream &)
void	readMaterials (std::ifstream &)

Detailed Description

Definition at line 47 of file CCalMaterialFactory.hh.

Member Enumeration Documentation

enum CCalMaterialFactory::MatDescription

Enumerator
byWeight
byVolume
byAtomic

Definition at line 49 of file CCalMaterialFactory.hh.

{byWeight, byVolume, byAtomic};

Constructor & Destructor Documentation

CCalMaterialFactory::~CCalMaterialFactory

(

)

Definition at line 96 of file CCalMaterialFactory.cc.

                                         {
  CCalMaterialTable::iterator ite;
  for(ite = theCCalMaterials.begin(); ite != theCCalMaterials.end(); ite++ ){
    delete *ite;
  }
  theCCalMaterials.clear();
  CCalAMaterialTable::iterator itea;
  for(itea = theCCalAMaterials.begin(); itea != theCCalAMaterials.end(); 
      itea++ ){
    delete *itea;
  }
  theCCalAMaterials.clear();
}

Member Function Documentation

G4Element * CCalMaterialFactory::addElement	(	const G4String &	name,
		const G4String &	symbol,
		G4double	Z,
		G4double	A,
		G4double	density
	)

Definition at line 160 of file CCalMaterialFactory.cc.

References g(), G4cout, G4endl, and python.hepunit::mole.

Referenced by readElements().

                                         {

  G4Element* theEl = new G4Element(name, symbol, Z, A*g/mole);
  //Make it also as a material.
  CCalAMaterial* theMat = new CCalAMaterial(name,A,density);
  theCCalAMaterials.push_back(theMat);

#ifdef ddebug
  G4cout << "Element " << name << " created!" << G4endl;
#endif
  return theEl;
}

G4Material * CCalMaterialFactory::addMaterial	(	const G4String &	nam,
		G4double	density,
		G4int	nconst,
		G4String	mats[],
		G4double	prop[],
		MatDescription	md = byWeight
	)

Definition at line 177 of file CCalMaterialFactory.cc.

References findMaterial().

                                           {
  addCCalMaterial(name, density, nconst, mats, prop, md);
  return findMaterial(name);
}

G4Element * CCalMaterialFactory::findElement

(

const G4String &

mat

)

const

Definition at line 147 of file CCalMaterialFactory.cc.

References G4cout, G4endl, and G4Element::GetElementTable().

Referenced by findMaterial().

                                                                      {
  const G4ElementTable  theElements = *(G4Element::GetElementTable());
  for (unsigned int i=0; i<theElements.size(); i++)
    if (theElements[i]->GetName()==mat){
#ifdef ddebug
      G4cout << "Element " << mat << " found!" << G4endl;
#endif
      return theElements[i];
    }
  return 0;
}

G4Material * CCalMaterialFactory::findMaterial

(

const G4String &

mat

)

const

Definition at line 111 of file CCalMaterialFactory.cc.

References G4Material::AddElement(), python.hepunit::cm3, CCalMaterial::Density(), CCalMaterial::Element(), findElement(), g(), G4cerr, G4cout, G4endl, CCalMaterial::Name(), CCalMaterial::NElements(), and CCalMaterial::Weight().

Referenced by addMaterial(), CCalG4Hcal::constructAbsorberLayer(), CCalG4Hall::constructIn(), CCalG4Hcal::constructIn(), and CCalG4Hcal::constructScintillatorLayer().

                                                                        {
  G4Material* theMat=findG4Material(mat);

  if (theMat) {
#ifdef ddebug
    G4cout << "Material " << mat << " already defined. Returning previous "
     << "instance." << G4endl;
#endif
    return theMat;
  } else { 
    CCalMaterial* CCalmat=findCCalMaterial(mat);
    if (CCalmat){
      G4Material* G4Mat = new G4Material(CCalmat->Name(),
                     CCalmat->Density()*g/cm3, 
                     CCalmat->NElements());
      for(G4int i=0; i<CCalmat->NElements(); i++) {
    G4Element* elem = findElement(CCalmat->Element(i));
    if (!elem) {
      G4cerr << "       Could not build material " << mat << "." << G4endl;
      exit(-10);
    }
    G4Mat->AddElement(elem, CCalmat->Weight(i));
      }
#ifdef ddebug
    G4cout << "Material " << mat << " has been built successfully." << G4endl;
#endif
      return G4Mat;
    } else {
      G4cerr << "ERROR: Material " << mat << " not found in CCal database!!!" 
       << G4endl;
      return 0;
    }
  }
}

CCalMaterialFactory * CCalMaterialFactory::getInstance ( const G4String &  matfile, const G4String &  mixfile  )

static

Definition at line 53 of file CCalMaterialFactory.cc.

References G4cerr, G4endl, and getInstance().

                                                      {
  if ((matfile=="" || matfile==elementfile) &&
      (mixfile=="" || mixfile==mixturefile))
    return getInstance();
  else if ((matfile != "" && elementfile != "" && matfile != elementfile) ||
           (mixfile != "" && mixturefile != "" && mixfile != mixturefile)) {
    G4cerr << "ERROR: Trying to get materials from " << matfile << " and " 
         << mixfile << " while previously were retrieved from " 
         << elementfile << " and " << mixturefile << "." << G4endl;
    return 0;
  } else {
    if (elementfile == "") 
      elementfile=matfile;
    if (mixturefile == "") 
      mixturefile=mixfile;
    return getInstance();
  }
}

CCalMaterialFactory * CCalMaterialFactory::getInstance ( const G4String &  matfile )

static

Definition at line 74 of file CCalMaterialFactory.cc.

References getInstance().

                                                                            {
  return getInstance(matfile,matfile);
}

CCalMaterialFactory * CCalMaterialFactory::getInstance ( )

static

Definition at line 79 of file CCalMaterialFactory.cc.

References G4cerr, and G4endl.

Referenced by CCalDetectorConstruction::Construct(), CCalG4Hcal::constructAbsorberLayer(), CCalG4Hall::constructIn(), CCalG4Hcal::constructIn(), CCalG4Hcal::constructScintillatorLayer(), and getInstance().

                                                     {
  if (elementfile=="" || mixturefile=="") {
    G4cerr << "ERROR: You haven't defined files to be used for materials in "
     << "CCalMaterialFactory::getInstance(const G4String&,const G4String&)"
     << G4endl;
    return 0;
  }

  if (instance==0) {
    instance = new CCalMaterialFactory;
    return instance;
  }
  else
    return instance;
}

void CCalMaterialFactory::readElements

(

const G4String &

matfile

)

Definition at line 188 of file CCalMaterialFactory.cc.

References findDO(), G4cerr, G4cout, G4endl, and openGeomFile().

                                                              {

  G4String path = getenv("CCAL_GLOBALPATH");
  G4cout << " ==> Opening file " << matfile << " to read elements..." << G4endl;
  std::ifstream is;
  bool ok = openGeomFile(is, path, matfile);
  if (!ok) {
    G4cerr << "ERROR: Could not open file " << matfile << G4endl;
    return;
  }

  // Find *DO GMAT
  findDO(is, G4String("GMAT"));
  
  readElements(is);
  
  is.close();
}

void CCalMaterialFactory::readElements ( std::ifstream &  is )

protected

Definition at line 338 of file CCalMaterialFactory.cc.

References addElement(), density, G4cout, G4endl, G4Element::GetElementTable(), jump(), readName(), and symbol.

                                                     {
  G4String name, symbol;
  
  G4cout << "     ==> Reading elements... " << G4endl;
#ifdef debug
  G4cout << "       Element    \tsymbol\tA\tZ\tdensity\tX_0          abs_l"<< G4endl;
#endif
  //There should come the list of materials. #. Defines a comment
  //*DO defines the beguining of the Mixes block.

  readName(is,name);
  while (name != "*ENDDO") {
    //It should be an element definition
    G4double A, Z, density;
    is >> symbol >> A >> Z >> density >> jump;    
#ifdef debug
    G4cout << "       " << name << "    \t" << symbol << "\t" 
     << A << "\t" << Z << "\t" << density << G4endl;
#endif    
    addElement(name, symbol, Z, A, density);
    readName(is,name);
  };
  G4cout << "     " << G4Element::GetElementTable()->size() 
       << " elements read from file" << G4endl << G4endl;
}

void CCalMaterialFactory::readMaterials

(

const G4String &

matfile

)

Definition at line 208 of file CCalMaterialFactory.cc.

References findDO(), G4cerr, G4cout, G4endl, and openGeomFile().

                                                               {

  G4String path = getenv("CCAL_GLOBALPATH");
  G4cout << " ==> Opening file " << matfile << " to read materials..." << G4endl;
  std::ifstream is;
  bool ok = openGeomFile(is, path, matfile);
  if (!ok) {
    G4cerr << "ERROR: Could not open file " << matfile << G4endl;
    return;
  }

  // Find *DO GMIX
  findDO(is, G4String("GMIX"));

  readMaterials(is);

  is.close();
}

void CCalMaterialFactory::readMaterials ( std::ifstream &  is )

protected

Definition at line 365 of file CCalMaterialFactory.cc.

References byAtomic, byVolume, byWeight, g(), G4cout, G4endl, jump(), python.hepunit::kelvin, kStateGas, python.hepunit::mole, pascal, readName(), and python.hepunit::universe_mean_density.

                                                      {
  G4String name, matname;

  G4cout << "     ==> Reading materials... " << G4endl;

  //Take into account the special case of vacuum...
#ifdef debug
  G4cout <<"       \"Vacuum\"" << G4endl;
#endif
  G4double density  = universe_mean_density;   //from PhysicalConstants.h
  G4double pressure = 1.E-19*pascal;
  G4double temperature = 0.1*kelvin;
  new G4Material("Vacuum", /*Z=*/ 1., /*A=*/ 1.01*g/mole,
         density, kStateGas, temperature, pressure);

  //There should come the list of materials. #. Defines a comment
  //*ENDDO defines the block.
  readName(is,name);
  while (name != "*ENDDO") {
    //It should be a material definition
    matname=name;
    G4int nElem;
    G4double dens;
    is >> nElem >> dens >> jump;

#ifdef debug
    G4cout <<"       " << matname
       << " made of " << nElem 
       << " elements. Density=" << dens
       << G4endl;
#endif

    G4int absnelem = std::abs(nElem);

    G4String* mats    = new G4String[absnelem];
    G4double* weights = new G4double[absnelem];
    
    G4double prop;
    for(int i=0; i<absnelem; i++) {
      readName(is, name);
      is >> prop >> jump;
      mats[i]=name;
      weights[i]=std::abs(prop);
    } //for...
    MatDescription md;
    if (nElem>0 && prop<0)
      md = byAtomic;
    else if (nElem>0)
      md = byWeight;
    else
      md = byVolume;

    addCCalMaterial(matname, dens, absnelem, mats, weights, md);
    delete[] mats;
    delete[] weights;
    
    readName(is,name);
  };  //while

  G4cout << "     " << theCCalMaterials.size() << " materials read from " 
       << mixturefile << G4endl << G4endl;
}

---

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

• CCalMaterialFactory.hh
• CCalMaterialFactory.cc