| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 ////////////////////////////////////////////// 23 ///////////////////////////////////////////////////////////////////////////////
27 // File: CCalMaterial.cc 24 // File: CCalMaterial.cc
28 // Description: CCalMaterial transient class t 25 // Description: CCalMaterial transient class to store information from
29 // material table (database) whic 26 // material table (database) which is used to make a G4Material
30 ////////////////////////////////////////////// 27 ///////////////////////////////////////////////////////////////////////////////
31 #include "CCalMaterial.hh" 28 #include "CCalMaterial.hh"
32 29
33 //#define debug 30 //#define debug
34 31
35 CCalMaterial::CCalMaterial(G4String mat, G4dou << 32 CCalMaterial::CCalMaterial(G4String mat, double dens, int nconst,
36 CCalMaterial** cons << 33 CCalMaterial** constituents, double* weights,
37 FractionType ft): n << 34 FractionType ft): name(mat), density(dens) {
38 nElem = 0; 35 nElem = 0;
39 36
40 G4int i=0; << 37 int i=0;
41 for (i=0; i<nconst; i++) 38 for (i=0; i<nconst; i++)
42 nElem += constituents[i]->NElements(); 39 nElem += constituents[i]->NElements();
43 40
44 theElements = new G4String[nElem]; 41 theElements = new G4String[nElem];
45 theWeights = new G4double[nElem]; << 42 theWeights = new double[nElem];
46 43
47 G4double factor; << 44 double factor;
48 G4int nelem=0; << 45 int nelem=0;
49 for (i=0; i<nconst; i++) { 46 for (i=0; i<nconst; i++) {
50 if (ft==FTWeight) 47 if (ft==FTWeight)
51 factor=1.0; 48 factor=1.0;
52 else 49 else
53 factor=constituents[i]->Density(); 50 factor=constituents[i]->Density();
54 for (G4int j=0; j<constituents[i]->NElemen << 51 for (int j=0; j<constituents[i]->NElements(); j++) {
55 theElements[nelem] = constituents[i]->El 52 theElements[nelem] = constituents[i]->Element(j);
56 theWeights[nelem] = constituents[i]->We 53 theWeights[nelem] = constituents[i]->Weight(j)* weights[i] * factor;
57 nelem++; 54 nelem++;
58 } 55 }
59 } 56 }
60 57
61 if (density<0) { //Let's compute density 58 if (density<0) { //Let's compute density
62 computeDensity(nconst, constituents, weigh 59 computeDensity(nconst, constituents, weights, ft);
63 } 60 }
64 closeMaterial(); 61 closeMaterial();
65 } 62 }
66 63
67 CCalMaterial::CCalMaterial(const CCalMaterial& 64 CCalMaterial::CCalMaterial(const CCalMaterial& mat):
68 name(mat.name), density(mat.density), nElem( 65 name(mat.name), density(mat.density), nElem(mat.nElem) {
69 theElements = new G4String[nElem]; 66 theElements = new G4String[nElem];
70 theWeights = new G4double[nElem]; << 67 theWeights = new double[nElem];
71 for (G4int i=0; i<nElem; i++){ << 68 for (int i=0; i<nElem; i++){
72 theElements[i]=mat.theElements[i]; 69 theElements[i]=mat.theElements[i];
73 theWeights[i]=mat.theWeights[i]; 70 theWeights[i]=mat.theWeights[i];
74 } 71 }
75 } 72 }
76 73
77 CCalMaterial::~CCalMaterial() { 74 CCalMaterial::~CCalMaterial() {
78 if (theElements) 75 if (theElements)
79 delete[] theElements; 76 delete[] theElements;
80 if (theWeights) 77 if (theWeights)
81 delete[] theWeights; 78 delete[] theWeights;
82 } 79 }
83 80
84 void CCalMaterial::computeDensity(G4int nconst << 81 void CCalMaterial::computeDensity(int nconst,
85 CCalMaterial << 82 CCalMaterial** constituents,
86 G4double* we << 83 double* weights, FractionType ft) {
87 G4double mass=0; << 84 double mass=0;
88 G4double volume=0; << 85 double volume=0;
89 for (G4int i=0; i<nconst; i++) { << 86 for (int i=0; i<nconst; i++) {
90 if (ft==FTWeight) { 87 if (ft==FTWeight) {
91 mass+=weights[i]; 88 mass+=weights[i];
92 volume+=(weights[i]/constituents[i]->Den 89 volume+=(weights[i]/constituents[i]->Density());
93 } 90 }
94 else { //by volume 91 else { //by volume
95 mass+=(weights[i]*constituents[i]->Densi 92 mass+=(weights[i]*constituents[i]->Density());
96 volume+=weights[i]; 93 volume+=weights[i];
97 } 94 }
98 } 95 }
99 density=mass/volume; 96 density=mass/volume;
100 } 97 }
101 98
102 CCalMaterial& CCalMaterial::operator=(const CC 99 CCalMaterial& CCalMaterial::operator=(const CCalMaterial& mat){
103 if(theElements) 100 if(theElements)
104 delete[] theElements; 101 delete[] theElements;
105 if(theWeights) 102 if(theWeights)
106 delete[] theWeights; 103 delete[] theWeights;
107 104
108 name=mat.name; 105 name=mat.name;
109 density=mat.density; 106 density=mat.density;
110 nElem=mat.nElem; 107 nElem=mat.nElem;
111 108
112 theElements = new G4String[nElem]; 109 theElements = new G4String[nElem];
113 theWeights = new G4double[nElem]; << 110 theWeights = new double[nElem];
114 for (G4int i=0; i<nElem; i++){ << 111 for (int i=0; i<nElem; i++){
115 theElements[i]=mat.theElements[i]; 112 theElements[i]=mat.theElements[i];
116 theWeights[i]=mat.theWeights[i]; 113 theWeights[i]=mat.theWeights[i];
117 } 114 }
118 return *this; 115 return *this;
119 } 116 }
120 117
121 G4bool CCalMaterial::operator==(const CCalMate 118 G4bool CCalMaterial::operator==(const CCalMaterial& mat) const{
122 return (name==mat.name); 119 return (name==mat.name);
123 } 120 }
124 121
125 G4bool CCalMaterial::operator!=(const CCalMate 122 G4bool CCalMaterial::operator!=(const CCalMaterial& mat) const{
126 return (name!=mat.name); 123 return (name!=mat.name);
127 } 124 }
128 125
129 void CCalMaterial::closeMaterial() { 126 void CCalMaterial::closeMaterial() {
130 G4int trueConst=0; << 127 int trueConst=0;
131 128
132 G4double norm=0; << 129 double norm=0;
133 130
134 for (G4int i=0; i<nElem; i++) { << 131 for (int i=0; i<nElem; i++) {
135 norm+=theWeights[i]; 132 norm+=theWeights[i];
136 if (theElements[i]!="") { 133 if (theElements[i]!="") {
137 trueConst++; 134 trueConst++;
138 for (G4int j=i+1; j<nElem; j++) { << 135 for (int j=i+1; j<nElem; j++) {
139 if(theElements[i]==theElements[j]){ << 136 if(theElements[i]==theElements[j]){
140 theWeights[i]+=theWeights[j]; << 137 theWeights[i]+=theWeights[j];
141 theElements[j]=""; << 138 theElements[j]="";
142 } << 139 }
143 }//for j 140 }//for j
144 } //if 141 } //if
145 }//for i 142 }//for i
146 143
147 if (trueConst != nElem) { 144 if (trueConst != nElem) {
148 G4String* newConst = new G4String[trueCons 145 G4String* newConst = new G4String[trueConst];
149 G4double* newWeight = new G4double[trueCon << 146 double* newWeight = new double[trueConst];
150 147
151 G4int newi=0; << 148 int newi=0;
152 for(G4int i=0; i<nElem; i++){ << 149 for(int i=0; i<nElem; i++){
153 if (theElements[i]!="") { 150 if (theElements[i]!="") {
154 newConst[newi] = theElements[i]; << 151 newConst[newi] = theElements[i];
155 newWeight[newi] = theWeights[i]/norm; << 152 newWeight[newi] = theWeights[i]/norm;
156 newi++; << 153 newi++;
157 } 154 }
158 } 155 }
159 156
160 #ifdef debug 157 #ifdef debug
161 G4cout << "\tGoing from " << nElem <<" con 158 G4cout << "\tGoing from " << nElem <<" constituents to " << trueConst << G4endl;
162 #endif 159 #endif
163 nElem=trueConst; 160 nElem=trueConst;
164 161
165 delete[] theElements; 162 delete[] theElements;
166 delete[] theWeights; 163 delete[] theWeights;
167 164
168 theElements=newConst; 165 theElements=newConst;
169 theWeights=newWeight; 166 theWeights=newWeight;
170 } 167 }
171 else { //Let's normalize the weights 168 else { //Let's normalize the weights
172 for (G4int i=0; i<nElem; i++) << 169 for (int i=0; i<nElem; i++)
173 theWeights[i] = theWeights[i]/norm; 170 theWeights[i] = theWeights[i]/norm;
174 } 171 }
175 } 172 }
176 173
177 std::ostream& operator<<(std::ostream& os, con 174 std::ostream& operator<<(std::ostream& os, const CCalMaterial& mat) {
178 os << mat.name << G4endl; 175 os << mat.name << G4endl;
179 os << "Density= " << mat.density << " g/cm3. 176 os << "Density= " << mat.density << " g/cm3. Number of Elements: "
180 << mat.nElem << G4endl; 177 << mat.nElem << G4endl;
181 for (G4int i=0; i<mat.nElem; i++) << 178 for (int i=0; i<mat.nElem; i++)
182 os << '\t' << mat.theElements[i] << '\t' < 179 os << '\t' << mat.theElements[i] << '\t' << mat.theWeights[i] << G4endl;
183 return os; 180 return os;
184 } 181 }
185 182