Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/advanced/composite_calorimeter/src/CCalMaterial.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/CCalMaterial.cc (Version 11.3.0) and /examples/advanced/composite_calorimeter/src/CCalMaterial.cc (Version 9.1.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: CCalMaterial.cc                           27 // File: CCalMaterial.cc
 28 // Description: CCalMaterial transient class t     28 // Description: CCalMaterial transient class to store information from 
 29 //              material table (database) whic     29 //              material table (database) which is used to make a G4Material
 30 //////////////////////////////////////////////     30 ///////////////////////////////////////////////////////////////////////////////
 31 #include "CCalMaterial.hh"                         31 #include "CCalMaterial.hh"
 32                                                    32 
 33 //#define debug                                    33 //#define debug
 34                                                    34 
 35 CCalMaterial::CCalMaterial(G4String mat, G4dou <<  35 CCalMaterial::CCalMaterial(G4String mat, double dens, int nconst, 
 36                            CCalMaterial** cons <<  36          CCalMaterial** constituents, double* weights,
 37                            FractionType ft): n <<  37          FractionType ft): name(mat), density(dens) {
 38   nElem = 0;                                       38   nElem = 0;
 39                                                    39   
 40   G4int i=0;                                   <<  40   int i=0;
 41   for (i=0; i<nconst; i++)                         41   for (i=0; i<nconst; i++)
 42     nElem += constituents[i]->NElements();         42     nElem += constituents[i]->NElements();
 43                                                    43 
 44   theElements = new G4String[nElem];               44   theElements = new G4String[nElem];
 45   theWeights  = new G4double[nElem];           <<  45   theWeights  = new double[nElem];
 46                                                    46 
 47   G4double factor;                             <<  47   double factor;
 48   G4int nelem=0;                               <<  48   int nelem=0;
 49   for (i=0; i<nconst; i++) {                       49   for (i=0; i<nconst; i++) {
 50     if (ft==FTWeight)                              50     if (ft==FTWeight)
 51       factor=1.0;                                  51       factor=1.0;
 52     else                                           52     else
 53       factor=constituents[i]->Density();           53       factor=constituents[i]->Density();
 54     for (G4int j=0; j<constituents[i]->NElemen <<  54     for (int j=0; j<constituents[i]->NElements(); j++) {
 55       theElements[nelem] = constituents[i]->El     55       theElements[nelem] = constituents[i]->Element(j);
 56       theWeights[nelem]  = constituents[i]->We     56       theWeights[nelem]  = constituents[i]->Weight(j)* weights[i] * factor;
 57       nelem++;                                     57       nelem++;
 58     }                                              58     }
 59   }                                                59   }
 60                                                    60 
 61   if (density<0) { //Let's compute density         61   if (density<0) { //Let's compute density
 62     computeDensity(nconst, constituents, weigh     62     computeDensity(nconst, constituents, weights, ft);
 63   }                                                63   }
 64   closeMaterial();                                 64   closeMaterial();
 65 }                                                  65 }
 66                                                    66 
 67 CCalMaterial::CCalMaterial(const CCalMaterial&     67 CCalMaterial::CCalMaterial(const CCalMaterial& mat):
 68   name(mat.name), density(mat.density), nElem(     68   name(mat.name), density(mat.density), nElem(mat.nElem) {
 69   theElements = new G4String[nElem];               69   theElements = new G4String[nElem];
 70   theWeights  = new G4double[nElem];           <<  70   theWeights  = new double[nElem];
 71   for (G4int i=0; i<nElem; i++){               <<  71   for (int i=0; i<nElem; i++){
 72     theElements[i]=mat.theElements[i];             72     theElements[i]=mat.theElements[i];
 73     theWeights[i]=mat.theWeights[i];               73     theWeights[i]=mat.theWeights[i];
 74   }                                                74   }
 75 }                                                  75 }
 76                                                    76 
 77 CCalMaterial::~CCalMaterial() {                    77 CCalMaterial::~CCalMaterial() {
 78   if (theElements)                                 78   if (theElements)
 79     delete[] theElements;                          79     delete[] theElements;
 80   if (theWeights)                                  80   if (theWeights)
 81     delete[] theWeights;                           81     delete[] theWeights;
 82 }                                                  82 }
 83                                                    83 
 84 void CCalMaterial::computeDensity(G4int nconst <<  84 void CCalMaterial::computeDensity(int nconst, 
 85                                   CCalMaterial <<  85           CCalMaterial** constituents, 
 86                                   G4double* we <<  86           double* weights, FractionType ft) {
 87   G4double mass=0;                             <<  87   double mass=0;
 88   G4double volume=0;                           <<  88   double volume=0;
 89   for (G4int i=0; i<nconst; i++) {             <<  89   for (int i=0; i<nconst; i++) {
 90     if (ft==FTWeight) {                            90     if (ft==FTWeight) {
 91       mass+=weights[i];                            91       mass+=weights[i];
 92       volume+=(weights[i]/constituents[i]->Den     92       volume+=(weights[i]/constituents[i]->Density());
 93     }                                              93     }
 94     else { //by volume                             94     else { //by volume
 95       mass+=(weights[i]*constituents[i]->Densi     95       mass+=(weights[i]*constituents[i]->Density());
 96       volume+=weights[i];                          96       volume+=weights[i];
 97     }                                              97     }
 98   }                                                98   }
 99   density=mass/volume;                             99   density=mass/volume;
100 }                                                 100 }
101                                                   101 
102 CCalMaterial& CCalMaterial::operator=(const CC    102 CCalMaterial& CCalMaterial::operator=(const CCalMaterial& mat){
103   if(theElements)                                 103   if(theElements)
104     delete[] theElements;                         104     delete[] theElements;
105   if(theWeights)                                  105   if(theWeights)
106     delete[] theWeights;                          106     delete[] theWeights;
107                                                   107 
108   name=mat.name;                                  108   name=mat.name;
109   density=mat.density;                            109   density=mat.density;
110   nElem=mat.nElem;                                110   nElem=mat.nElem;
111                                                   111   
112   theElements = new G4String[nElem];              112   theElements = new G4String[nElem];
113   theWeights  = new G4double[nElem];           << 113   theWeights  = new double[nElem];
114   for (G4int i=0; i<nElem; i++){               << 114   for (int i=0; i<nElem; i++){
115     theElements[i]=mat.theElements[i];            115     theElements[i]=mat.theElements[i];
116     theWeights[i]=mat.theWeights[i];              116     theWeights[i]=mat.theWeights[i];
117   }                                               117   }
118   return *this;                                   118   return *this;
119 }                                                 119 }
120                                                   120 
121 G4bool CCalMaterial::operator==(const CCalMate    121 G4bool CCalMaterial::operator==(const CCalMaterial& mat) const{
122   return (name==mat.name);                        122   return (name==mat.name);
123 }                                                 123 }
124                                                   124 
125 G4bool CCalMaterial::operator!=(const CCalMate    125 G4bool CCalMaterial::operator!=(const CCalMaterial& mat) const{
126   return (name!=mat.name);                        126   return (name!=mat.name);
127 }                                                 127 }
128                                                   128 
129 void CCalMaterial::closeMaterial() {              129 void CCalMaterial::closeMaterial() {
130   G4int trueConst=0;                           << 130   int trueConst=0;
131                                                   131 
132   G4double norm=0;                             << 132   double norm=0;
133                                                   133 
134   for (G4int i=0; i<nElem; i++) {              << 134   for (int i=0; i<nElem; i++) {
135     norm+=theWeights[i];                          135     norm+=theWeights[i];
136     if (theElements[i]!="") {                     136     if (theElements[i]!="") {
137       trueConst++;                                137       trueConst++;
138       for (G4int j=i+1; j<nElem; j++) {        << 138       for (int j=i+1; j<nElem; j++) {
139         if(theElements[i]==theElements[j]){    << 139   if(theElements[i]==theElements[j]){
140           theWeights[i]+=theWeights[j];        << 140     theWeights[i]+=theWeights[j];
141           theElements[j]="";                   << 141     theElements[j]="";
142         }                                      << 142   }
143       }//for j                                    143       }//for j
144     } //if                                        144     } //if
145   }//for i                                        145   }//for i
146                                                   146 
147   if (trueConst != nElem) {                       147   if (trueConst != nElem) {
148     G4String* newConst = new G4String[trueCons    148     G4String* newConst = new G4String[trueConst];
149     G4double* newWeight = new G4double[trueCon << 149     double* newWeight = new double[trueConst];
150                                                   150     
151     G4int newi=0;                              << 151     int newi=0;
152     for(G4int i=0; i<nElem; i++){              << 152     for(int i=0; i<nElem; i++){
153       if (theElements[i]!="") {                   153       if (theElements[i]!="") {
154         newConst[newi]  = theElements[i];      << 154   newConst[newi]  = theElements[i];
155         newWeight[newi] = theWeights[i]/norm;  << 155   newWeight[newi] = theWeights[i]/norm;
156         newi++;                                << 156   newi++;
157       }                                           157       }
158     }                                             158     }
159                                                   159 
160 #ifdef debug                                      160 #ifdef debug    
161     G4cout << "\tGoing from " << nElem <<" con    161     G4cout << "\tGoing from " << nElem <<" constituents to " << trueConst << G4endl;
162 #endif                                            162 #endif
163     nElem=trueConst;                              163     nElem=trueConst;
164                                                   164     
165     delete[] theElements;                         165     delete[] theElements;
166     delete[] theWeights;                          166     delete[] theWeights;
167                                                   167 
168     theElements=newConst;                         168     theElements=newConst;
169     theWeights=newWeight;                         169     theWeights=newWeight;
170   }                                               170   }
171   else { //Let's normalize the weights            171   else { //Let's normalize the weights
172     for (G4int i=0; i<nElem; i++)              << 172     for (int i=0; i<nElem; i++)
173       theWeights[i] = theWeights[i]/norm;         173       theWeights[i] = theWeights[i]/norm;
174   }                                               174   }
175 }                                                 175 }
176                                                   176 
177 std::ostream& operator<<(std::ostream& os, con    177 std::ostream& operator<<(std::ostream& os, const CCalMaterial& mat) {
178   os << mat.name << G4endl;                       178   os << mat.name << G4endl;
179   os << "Density= " << mat.density << " g/cm3.    179   os << "Density= " << mat.density << " g/cm3. Number of Elements: "
180      << mat.nElem << G4endl;                      180      << mat.nElem << G4endl;
181   for (G4int i=0; i<mat.nElem; i++)            << 181   for (int i=0; i<mat.nElem; i++)
182     os << '\t' << mat.theElements[i] << '\t' <    182     os << '\t' << mat.theElements[i] << '\t' << mat.theWeights[i] << G4endl;
183   return os;                                      183   return os;
184 }                                                 184 }
185                                                   185