Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/advanced/composite_calorimeter/src/CCalMaterialFactory.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /examples/advanced/composite_calorimeter/src/CCalMaterialFactory.cc (Version 11.3.0) and /examples/advanced/composite_calorimeter/src/CCalMaterialFactory.cc (Version 9.6.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //////////////////////////////////////////////     26 ///////////////////////////////////////////////////////////////////////////////
 27 // File: CCalMaterialFactory.cc                    27 // File: CCalMaterialFactory.cc
 28 // Description: CCalMaterialFactory is a facto     28 // Description: CCalMaterialFactory is a factory class to vuild G4Material 
 29 //              from CCalMaterial and CCalAmat     29 //              from CCalMaterial and CCalAmaterial
 30 //////////////////////////////////////////////     30 ///////////////////////////////////////////////////////////////////////////////
 31 #include <fstream>                                 31 #include <fstream>
 32 #include <stdlib.h>                                32 #include <stdlib.h>
 33                                                    33 
 34 #include "CCalMaterialFactory.hh"                  34 #include "CCalMaterialFactory.hh"
 35 #include "CCalutils.hh"                            35 #include "CCalutils.hh"
 36                                                    36 
 37 #include "G4PhysicalConstants.hh"                  37 #include "G4PhysicalConstants.hh"
 38 #include "G4SystemOfUnits.hh"                      38 #include "G4SystemOfUnits.hh"
 39 #include "G4Material.hh"                           39 #include "G4Material.hh"
 40                                                    40 
 41 //#define ddebug                                   41 //#define ddebug
 42 //#define debug                                    42 //#define debug
 43                                                    43 
 44 typedef CCalMaterial*  ptrCCalMaterial;            44 typedef CCalMaterial*  ptrCCalMaterial;
 45 typedef CCalAMaterial* ptrCCalAMaterial;           45 typedef CCalAMaterial* ptrCCalAMaterial;
 46                                                    46 
 47                                                    47 
 48 CCalMaterialFactory * CCalMaterialFactory::ins     48 CCalMaterialFactory * CCalMaterialFactory::instance = 0;
 49 G4String CCalMaterialFactory::elementfile = ""     49 G4String CCalMaterialFactory::elementfile = "";
 50 G4String CCalMaterialFactory::mixturefile = ""     50 G4String CCalMaterialFactory::mixturefile = "";
 51                                                    51 
 52                                                    52 
 53 CCalMaterialFactory* CCalMaterialFactory::getI     53 CCalMaterialFactory* CCalMaterialFactory::getInstance(const G4String& matfile,
 54                                                <<  54                   const G4String& mixfile){
 55   if ((matfile=="" || matfile==elementfile) &&     55   if ((matfile=="" || matfile==elementfile) &&
 56       (mixfile=="" || mixfile==mixturefile))       56       (mixfile=="" || mixfile==mixturefile))
 57     return getInstance();                          57     return getInstance();
 58   else if ((matfile != "" && elementfile != ""     58   else if ((matfile != "" && elementfile != "" && matfile != elementfile) ||
 59            (mixfile != "" && mixturefile != ""     59            (mixfile != "" && mixturefile != "" && mixfile != mixturefile)) {
 60     G4cerr << "ERROR: Trying to get materials      60     G4cerr << "ERROR: Trying to get materials from " << matfile << " and " 
 61          << mixfile << " while previously were     61          << mixfile << " while previously were retrieved from " 
 62          << elementfile << " and " << mixturef     62          << elementfile << " and " << mixturefile << "." << G4endl;
 63     return 0;                                      63     return 0;
 64   } else {                                         64   } else {
 65     if (elementfile == "")                         65     if (elementfile == "") 
 66       elementfile=matfile;                         66       elementfile=matfile;
 67     if (mixturefile == "")                         67     if (mixturefile == "") 
 68       mixturefile=mixfile;                         68       mixturefile=mixfile;
 69     return getInstance();                          69     return getInstance();
 70   }                                                70   }
 71 }                                                  71 }
 72                                                    72 
 73                                                    73 
 74 CCalMaterialFactory* CCalMaterialFactory::getI     74 CCalMaterialFactory* CCalMaterialFactory::getInstance(const G4String& matfile){
 75   return getInstance(matfile,matfile);             75   return getInstance(matfile,matfile);
 76 }                                                  76 }
 77                                                    77 
 78                                                    78 
 79 CCalMaterialFactory* CCalMaterialFactory::getI     79 CCalMaterialFactory* CCalMaterialFactory::getInstance(){
 80   if (elementfile=="" || mixturefile=="") {        80   if (elementfile=="" || mixturefile=="") {
 81     G4cerr << "ERROR: You haven't defined file     81     G4cerr << "ERROR: You haven't defined files to be used for materials in "
 82          << "CCalMaterialFactory::getInstance( <<  82    << "CCalMaterialFactory::getInstance(const G4String&,const G4String&)"
 83          << G4endl;                            <<  83    << G4endl;
 84     return 0;                                      84     return 0;
 85   }                                                85   }
 86                                                    86 
 87   if (instance==0) {                               87   if (instance==0) {
 88     instance = new CCalMaterialFactory;            88     instance = new CCalMaterialFactory;
 89     return instance;                               89     return instance;
 90   }                                                90   }
 91   else                                             91   else
 92     return instance;                               92     return instance;
 93 }                                                  93 }
 94                                                    94 
 95                                                    95 
 96 CCalMaterialFactory::~CCalMaterialFactory(){       96 CCalMaterialFactory::~CCalMaterialFactory(){
 97   CCalMaterialTable::iterator ite;                 97   CCalMaterialTable::iterator ite;
 98   for(ite = theCCalMaterials.begin(); ite != t     98   for(ite = theCCalMaterials.begin(); ite != theCCalMaterials.end(); ite++ ){
 99     delete *ite;                                   99     delete *ite;
100   }                                               100   }
101   theCCalMaterials.clear();                       101   theCCalMaterials.clear();
102   CCalAMaterialTable::iterator itea;              102   CCalAMaterialTable::iterator itea;
103   for(itea = theCCalAMaterials.begin(); itea !    103   for(itea = theCCalAMaterials.begin(); itea != theCCalAMaterials.end(); 
104       itea++ ){                                   104       itea++ ){
105     delete *itea;                                 105     delete *itea;
106   }                                               106   }
107   theCCalAMaterials.clear();                      107   theCCalAMaterials.clear();
108 }                                                 108 }
109                                                   109 
110                                                   110   
111 G4Material* CCalMaterialFactory::findMaterial(    111 G4Material* CCalMaterialFactory::findMaterial(const G4String & mat) const {
112   G4Material* theMat=findG4Material(mat);         112   G4Material* theMat=findG4Material(mat);
113                                                   113 
114   if (theMat) {                                   114   if (theMat) {
115 #ifdef ddebug                                     115 #ifdef ddebug
116     G4cout << "Material " << mat << " already     116     G4cout << "Material " << mat << " already defined. Returning previous "
117          << "instance." << G4endl;             << 117    << "instance." << G4endl;
118 #endif                                            118 #endif
119     return theMat;                                119     return theMat;
120   } else {                                        120   } else { 
121     CCalMaterial* CCalmat=findCCalMaterial(mat    121     CCalMaterial* CCalmat=findCCalMaterial(mat);
122     if (CCalmat){                                 122     if (CCalmat){
123       G4Material* G4Mat = new G4Material(CCalm    123       G4Material* G4Mat = new G4Material(CCalmat->Name(),
124                                          CCalm << 124            CCalmat->Density()*g/cm3, 
125                                          CCalm << 125            CCalmat->NElements());
126       for(G4int i=0; i<CCalmat->NElements(); i    126       for(G4int i=0; i<CCalmat->NElements(); i++) {
127         G4Element* elem = findElement(CCalmat- << 127   G4Element* elem = findElement(CCalmat->Element(i));
128         if (!elem) {                           << 128   if (!elem) {
129           G4ExceptionDescription ed;           << 129     G4cerr << "       Could not build material " << mat << "." << G4endl;
130           ed << "   Could not build material " << 130     exit(-10);
131           G4Exception("CCalMaterialFactory::fi << 131   }
132                       FatalException,ed);      << 132   G4Mat->AddElement(elem, CCalmat->Weight(i));
133         }                                      << 
134         G4Mat->AddElement(elem, CCalmat->Weigh << 
135       }                                           133       }
136 #ifdef ddebug                                     134 #ifdef ddebug
137     G4cout << "Material " << mat << " has been    135     G4cout << "Material " << mat << " has been built successfully." << G4endl;
138 #endif                                            136 #endif
139       return G4Mat;                               137       return G4Mat;
140     } else {                                      138     } else {
141       G4cerr << "ERROR: Material " << mat << "    139       G4cerr << "ERROR: Material " << mat << " not found in CCal database!!!" 
142            << G4endl;                          << 140      << G4endl;
143       return 0;                                   141       return 0;
144     }                                             142     }
145   }                                               143   }
146 }                                                 144 }
147                                                   145 
148                                                   146 
149 G4Element* CCalMaterialFactory::findElement(co    147 G4Element* CCalMaterialFactory::findElement(const G4String & mat) const {
150   const G4ElementTable  theElements = *(G4Elem    148   const G4ElementTable  theElements = *(G4Element::GetElementTable());
151   for (unsigned int i=0; i<theElements.size();    149   for (unsigned int i=0; i<theElements.size(); i++)
152     if (theElements[i]->GetName()==mat){          150     if (theElements[i]->GetName()==mat){
153 #ifdef ddebug                                     151 #ifdef ddebug
154       G4cout << "Element " << mat << " found!"    152       G4cout << "Element " << mat << " found!" << G4endl;
155 #endif                                            153 #endif
156       return theElements[i];                      154       return theElements[i];
157     }                                             155     }
158   return 0;                                       156   return 0;
159 }                                                 157 }
160                                                   158 
161                                                   159 
162 G4Element* CCalMaterialFactory::addElement(con    160 G4Element* CCalMaterialFactory::addElement(const G4String & name,
163                                            con << 161              const G4String & symbol,
164                                            G4d << 162              G4double Z, G4double A,
165                                            G4d << 163              G4double density) {
166                                                   164 
167   G4Element* theEl = new G4Element(name, symbo    165   G4Element* theEl = new G4Element(name, symbol, Z, A*g/mole);
168   //Make it also as a material.                   166   //Make it also as a material.
169   CCalAMaterial* theMat = new CCalAMaterial(na    167   CCalAMaterial* theMat = new CCalAMaterial(name,A,density);
170   theCCalAMaterials.push_back(theMat);            168   theCCalAMaterials.push_back(theMat);
171                                                   169 
172 #ifdef ddebug                                     170 #ifdef ddebug
173   G4cout << "Element " << name << " created!"     171   G4cout << "Element " << name << " created!" << G4endl;
174 #endif                                            172 #endif
175   return theEl;                                   173   return theEl;
176 }                                                 174 }
177                                                   175 
178                                                   176 
179 G4Material* CCalMaterialFactory::addMaterial(c    177 G4Material* CCalMaterialFactory::addMaterial(const G4String& name,
180                                              G << 178                G4double density,
181                                              G << 179                G4int nconst,
182                                              G << 180                G4String mats[],
183                                              G << 181                G4double prop[],
184                                              M << 182                MatDescription md){
185   addCCalMaterial(name, density, nconst, mats,    183   addCCalMaterial(name, density, nconst, mats, prop, md);
186   return findMaterial(name);                      184   return findMaterial(name);
187 }                                                 185 }
188                                                   186 
189                                                   187 
190 void CCalMaterialFactory::readElements(const G    188 void CCalMaterialFactory::readElements(const G4String& matfile) {
191                                                   189 
192   G4String path = "NULL";                      << 190   G4String path = getenv("CCAL_GLOBALPATH");
193   if (std::getenv("CCAL_GLOBALPATH"))          << 
194     path = std::getenv("CCAL_GLOBALPATH");     << 
195                                                << 
196   G4cout << " ==> Opening file " << matfile <<    191   G4cout << " ==> Opening file " << matfile << " to read elements..." << G4endl;
197   std::ifstream is;                               192   std::ifstream is;
198   G4bool ok = openGeomFile(is, path, matfile); << 193   bool ok = openGeomFile(is, path, matfile);
199   if (!ok) {                                      194   if (!ok) {
200     G4cerr << "ERROR: Could not open file " <<    195     G4cerr << "ERROR: Could not open file " << matfile << G4endl;
201     return;                                       196     return;
202   }                                               197   }
203                                                   198 
204   // Find *DO GMAT                                199   // Find *DO GMAT
205   findDO(is, G4String("GMAT"));                   200   findDO(is, G4String("GMAT"));
206                                                   201   
207   readElements(is);                               202   readElements(is);
208                                                   203   
209   is.close();                                     204   is.close();
210 }                                                 205 }
211                                                   206 
212                                                   207 
213 void CCalMaterialFactory::readMaterials(const     208 void CCalMaterialFactory::readMaterials(const G4String& matfile) {
214                                                   209 
215   G4String path = "NULL";                      << 210   G4String path = getenv("CCAL_GLOBALPATH");
216   if (std::getenv("CCAL_GLOBALPATH"))          << 
217     path = std::getenv("CCAL_GLOBALPATH");     << 
218                                                << 
219   G4cout << " ==> Opening file " << matfile <<    211   G4cout << " ==> Opening file " << matfile << " to read materials..." << G4endl;
220   std::ifstream is;                               212   std::ifstream is;
221   bool ok = openGeomFile(is, path, matfile);      213   bool ok = openGeomFile(is, path, matfile);
222   if (!ok) {                                      214   if (!ok) {
223     G4cerr << "ERROR: Could not open file " <<    215     G4cerr << "ERROR: Could not open file " << matfile << G4endl;
224     return;                                       216     return;
225   }                                               217   }
226                                                   218 
227   // Find *DO GMIX                                219   // Find *DO GMIX
228   findDO(is, G4String("GMIX"));                   220   findDO(is, G4String("GMIX"));
229                                                   221 
230   readMaterials(is);                              222   readMaterials(is);
231                                                   223 
232   is.close();                                     224   is.close();
233 }                                                 225 }
234                                                   226 
235                                                   227 
236 //============================================    228 //===========================================================================
237 // Protected & private methods ===============    229 // Protected & private methods ==============================================
238                                                   230 
239                                                   231 
240 G4Material* CCalMaterialFactory::findG4Materia    232 G4Material* CCalMaterialFactory::findG4Material(const G4String & mat) const {
241   const G4MaterialTable theG4Materials = *(G4M    233   const G4MaterialTable theG4Materials = *(G4Material::GetMaterialTable());
242   for (unsigned int i=0; i<theG4Materials.size    234   for (unsigned int i=0; i<theG4Materials.size(); i++) {
243     if (theG4Materials[i]->GetName()==mat){       235     if (theG4Materials[i]->GetName()==mat){
244       return theG4Materials[i];                   236       return theG4Materials[i];
245     }                                             237     }
246   }                                               238   }
247   return 0;                                       239   return 0;
248 }                                                 240 }
249                                                   241 
250                                                   242 
251 CCalMaterial* CCalMaterialFactory::findCCalMat    243 CCalMaterial* CCalMaterialFactory::findCCalMaterial(const G4String & mat) 
252   const {                                         244   const {
253   for (unsigned int i=0; i<theCCalMaterials.si    245   for (unsigned int i=0; i<theCCalMaterials.size(); i++)
254     if (theCCalMaterials[i]->Name()==mat){        246     if (theCCalMaterials[i]->Name()==mat){
255 #ifdef ddebug                                     247 #ifdef ddebug
256       G4cout << "CCalMaterial " << mat << " fo    248       G4cout << "CCalMaterial " << mat << " found!" << G4endl;
257 #endif                                            249 #endif
258       return theCCalMaterials[i];                 250       return theCCalMaterials[i];
259     }                                             251     }
260   return (CCalMaterial*) findCCalAMaterial(mat    252   return (CCalMaterial*) findCCalAMaterial(mat);
261 }                                                 253 }
262                                                   254 
263                                                   255 
264 CCalAMaterial* CCalMaterialFactory::findCCalAM    256 CCalAMaterial* CCalMaterialFactory::findCCalAMaterial(const G4String & mat) 
265   const {                                         257   const {
266   for (unsigned int i=0; i<theCCalAMaterials.s    258   for (unsigned int i=0; i<theCCalAMaterials.size(); i++)
267     if (theCCalAMaterials[i]->Name()==mat){       259     if (theCCalAMaterials[i]->Name()==mat){
268 #ifdef ddebug                                     260 #ifdef ddebug
269       G4cout << "CCalMaterial " << mat << " fo    261       G4cout << "CCalMaterial " << mat << " found!" << G4endl;
270 #endif                                            262 #endif
271       return theCCalAMaterials[i];                263       return theCCalAMaterials[i];
272     }                                             264     }
273   return 0;                                       265   return 0;
274 }                                                 266 }
275                                                   267 
276                                                   268 
277 CCalMaterial* CCalMaterialFactory::addCCalMate    269 CCalMaterial* CCalMaterialFactory::addCCalMaterial(const G4String& name, 
278                                                << 270                G4double density,
279                                                << 271                G4int nconst,
280                                                << 272                G4String mats[], 
281                                                << 273                G4double prop[],
282                                                << 274                MatDescription md){
283   ptrCCalMaterial* matcol=0;                      275   ptrCCalMaterial* matcol=0;
284   ptrCCalAMaterial* amatcol=0;                    276   ptrCCalAMaterial* amatcol=0;
285                                                   277 
286   if (md==byAtomic)                               278   if (md==byAtomic)
287     amatcol = new ptrCCalAMaterial[nconst];       279     amatcol = new ptrCCalAMaterial[nconst];
288   else                                            280   else
289     matcol = new ptrCCalMaterial[nconst];         281     matcol = new ptrCCalMaterial[nconst];
290                                                   282 
291   for (G4int i=0; i<nconst; i++){                 283   for (G4int i=0; i<nconst; i++){
292     if (md==byAtomic) {                           284     if (md==byAtomic) {
293       CCalAMaterial* amat = findCCalAMaterial(    285       CCalAMaterial* amat = findCCalAMaterial(mats[i]);
294       if (amat)                                   286       if (amat)
295         amatcol[i]=amat;                       << 287   amatcol[i]=amat;
296       else {                                      288       else {
297         G4cerr << "ERROR: Trying to build" <<  << 289   G4cerr << "ERROR: Trying to build" << name << " out of unknown " 
298              << mats[i] << "." << G4endl       << 290        << mats[i] << "." << G4endl 
299              << "Skiping this material!" << G4 << 291        << "Skiping this material!" << G4endl;
300         delete[] amatcol;                      << 292   delete[] amatcol;
301         return 0;                              << 293   return 0;
302       }                                           294       }
303     } //by Atomic fractions                       295     } //by Atomic fractions
304     else {                                        296     else {
305       CCalMaterial* mat = findCCalMaterial(mat    297       CCalMaterial* mat = findCCalMaterial(mats[i]);
306       if (mat)                                    298       if (mat)
307         matcol[i]=mat;                         << 299   matcol[i]=mat;
308       else {                                      300       else {
309         G4cerr << "ERROR: Trying to build" <<n << 301   G4cerr << "ERROR: Trying to build" <<name << " out of unknown " 
310              << mats[i] << "." << G4endl       << 302        << mats[i] << "." << G4endl 
311              << "Skiping this material!" << G4 << 303        << "Skiping this material!" << G4endl;
312         delete[] matcol;                       << 304   delete[] matcol;
313         return 0;                              << 305   return 0;
314       }                                           306       }
315     }                                             307     }
316   } //for                                         308   } //for
317                                                   309 
318   //Let's do the CCalMaterial!                    310   //Let's do the CCalMaterial!
319   if (md==byAtomic) {                             311   if (md==byAtomic) {
320     CCalAMaterial* amaterial = new CCalAMateri    312     CCalAMaterial* amaterial = new CCalAMaterial(name, density, nconst, 
321                                                << 313              amatcol, prop);
322     delete[] amatcol;                             314     delete[] amatcol;
323     theCCalAMaterials.push_back(amaterial);       315     theCCalAMaterials.push_back(amaterial);
324 #ifdef ddebug                                     316 #ifdef ddebug
325     G4cout << *amaterial << G4endl;               317     G4cout << *amaterial << G4endl;
326 #endif                                            318 #endif
327     return amaterial;                             319     return amaterial;
328   } else {                                        320   } else {
329     CCalMaterial::FractionType ft;                321     CCalMaterial::FractionType ft;
330     if (md == byWeight)                           322     if (md == byWeight)
331       ft=CCalMaterial::FTWeight;                  323       ft=CCalMaterial::FTWeight;
332     else                                          324     else
333       ft=CCalMaterial::FTVolume;                  325       ft=CCalMaterial::FTVolume;
334     CCalMaterial* material = new CCalMaterial(    326     CCalMaterial* material = new CCalMaterial(name, density, nconst, 
335                                             ma << 327               matcol, prop, ft);
336     delete[] matcol;                              328     delete[] matcol;
337     theCCalMaterials.push_back(material);         329     theCCalMaterials.push_back(material);
338 #ifdef ddebug                                     330 #ifdef ddebug
339     G4cout << *material << G4endl;                331     G4cout << *material << G4endl;
340 #endif                                            332 #endif
341     return material;                              333     return material;
342   }                                               334   }  
343 }                                                 335 }
344                                                   336 
345                                                   337 
346 void CCalMaterialFactory::readElements(std::if    338 void CCalMaterialFactory::readElements(std::ifstream& is){
347   G4String name, symbol;                          339   G4String name, symbol;
348                                                   340   
349   G4cout << "     ==> Reading elements... " <<    341   G4cout << "     ==> Reading elements... " << G4endl;
350 #ifdef debug                                      342 #ifdef debug
351   G4cout << "       Element    \tsymbol\tA\tZ\    343   G4cout << "       Element    \tsymbol\tA\tZ\tdensity\tX_0          abs_l"<< G4endl;
352 #endif                                            344 #endif
353   //There should come the list of materials. #    345   //There should come the list of materials. #. Defines a comment
354   //*DO defines the beguining of the Mixes blo    346   //*DO defines the beguining of the Mixes block.
355                                                   347 
356   readName(is,name);                              348   readName(is,name);
357   while (name != "*ENDDO") {                      349   while (name != "*ENDDO") {
358     //It should be an element definition          350     //It should be an element definition
359     G4double A, Z, density;                       351     G4double A, Z, density;
360     is >> symbol >> A >> Z >> density >> jump;    352     is >> symbol >> A >> Z >> density >> jump;    
361 #ifdef debug                                      353 #ifdef debug
362     G4cout << "       " << name << "    \t" <<    354     G4cout << "       " << name << "    \t" << symbol << "\t" 
363          << A << "\t" << Z << "\t" << density  << 355    << A << "\t" << Z << "\t" << density << G4endl;
364 #endif                                            356 #endif    
365     addElement(name, symbol, Z, A, density);      357     addElement(name, symbol, Z, A, density);
366     readName(is,name);                            358     readName(is,name);
367   };                                              359   };
368   G4cout << "     " << G4Element::GetElementTa    360   G4cout << "     " << G4Element::GetElementTable()->size() 
369        << " elements read from file" << G4endl    361        << " elements read from file" << G4endl << G4endl;
370 }                                                 362 }
371                                                   363 
372                                                   364 
373 void CCalMaterialFactory::readMaterials(std::i    365 void CCalMaterialFactory::readMaterials(std::ifstream& is){
374   G4String name, matname;                         366   G4String name, matname;
375                                                   367 
376   G4cout << "     ==> Reading materials... " <    368   G4cout << "     ==> Reading materials... " << G4endl;
377                                                   369 
378   //Take into account the special case of vacu    370   //Take into account the special case of vacuum...
379 #ifdef debug                                      371 #ifdef debug
380   G4cout <<"       \"Vacuum\"" << G4endl;         372   G4cout <<"       \"Vacuum\"" << G4endl;
381 #endif                                            373 #endif
382   G4double density  = universe_mean_density;      374   G4double density  = universe_mean_density;   //from PhysicalConstants.h
383   G4double pressure = 1.E-19*pascal;              375   G4double pressure = 1.E-19*pascal;
384   G4double temperature = 0.1*kelvin;              376   G4double temperature = 0.1*kelvin;
385   new G4Material("Vacuum", /*Z=*/ 1., /*A=*/ 1    377   new G4Material("Vacuum", /*Z=*/ 1., /*A=*/ 1.01*g/mole,
386                  density, kStateGas, temperatu << 378      density, kStateGas, temperature, pressure);
387                                                   379 
388   //There should come the list of materials. #    380   //There should come the list of materials. #. Defines a comment
389   //*ENDDO defines the block.                     381   //*ENDDO defines the block.
390   readName(is,name);                              382   readName(is,name);
391   while (name != "*ENDDO") {                      383   while (name != "*ENDDO") {
392     //It should be a material definition          384     //It should be a material definition
393     matname=name;                                 385     matname=name;
394     G4int nElem;                                  386     G4int nElem;
395     G4double dens;                             << 387     G4double density;
396     is >> nElem >> dens >> jump;               << 388     is >> nElem >> density >> jump;
397                                                   389 
398 #ifdef debug                                      390 #ifdef debug
399     G4cout <<"       " << matname                 391     G4cout <<"       " << matname
400            << " made of " << nElem             << 392      << " made of " << nElem 
401            << " elements. Density=" << dens    << 393      << " elements. Density=" << density 
402            << G4endl;                          << 394      << G4endl;
403 #endif                                            395 #endif
404                                                   396 
405     G4int absnelem = std::abs(nElem);             397     G4int absnelem = std::abs(nElem);
406                                                   398 
407     G4String* mats    = new G4String[absnelem]    399     G4String* mats    = new G4String[absnelem];
408     G4double* weights = new G4double[absnelem]    400     G4double* weights = new G4double[absnelem];
409                                                   401     
410     G4double prop;                                402     G4double prop;
411     for(int i=0; i<absnelem; i++) {               403     for(int i=0; i<absnelem; i++) {
412       readName(is, name);                         404       readName(is, name);
413       is >> prop >> jump;                         405       is >> prop >> jump;
414       mats[i]=name;                               406       mats[i]=name;
415       weights[i]=std::abs(prop);                  407       weights[i]=std::abs(prop);
416     } //for...                                    408     } //for...
417     MatDescription md;                            409     MatDescription md;
418     if (nElem>0 && prop<0)                        410     if (nElem>0 && prop<0)
419       md = byAtomic;                              411       md = byAtomic;
420     else if (nElem>0)                             412     else if (nElem>0)
421       md = byWeight;                              413       md = byWeight;
422     else                                          414     else
423       md = byVolume;                              415       md = byVolume;
424                                                   416 
425     addCCalMaterial(matname, dens, absnelem, m << 417     addCCalMaterial(matname, density, absnelem, mats, weights, md);
426     delete[] mats;                                418     delete[] mats;
427     delete[] weights;                             419     delete[] weights;
428                                                   420     
429     readName(is,name);                            421     readName(is,name);
430   };  //while                                     422   };  //while
431                                                   423 
432   G4cout << "     " << theCCalMaterials.size()    424   G4cout << "     " << theCCalMaterials.size() << " materials read from " 
433        << mixturefile << G4endl << G4endl;        425        << mixturefile << G4endl << G4endl;
434 }                                                 426 }
435                                                   427 
436                                                   428 
437 CCalMaterialFactory::CCalMaterialFactory() {      429 CCalMaterialFactory::CCalMaterialFactory() {
438   readElements (elementfile);                     430   readElements (elementfile);
439   readMaterials(mixturefile);                     431   readMaterials(mixturefile);
440 }                                                 432 }
441                                                   433