| Geant4 Cross Reference |
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 // G4tgrSolid implementation 26 // G4tgrSolid implementation
27 // 27 //
28 // Author: P.Arce, CIEMAT (November 2007) 28 // Author: P.Arce, CIEMAT (November 2007)
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include <map> 31 #include <map>
32 #include <set> 32 #include <set>
33 33
34 #include "G4tgrSolid.hh" 34 #include "G4tgrSolid.hh"
35 35
36 #include "G4SystemOfUnits.hh" 36 #include "G4SystemOfUnits.hh"
37 #include "G4tgrUtils.hh" 37 #include "G4tgrUtils.hh"
38 #include "G4tgrMessenger.hh" 38 #include "G4tgrMessenger.hh"
39 #include "G4tgrVolumeMgr.hh" 39 #include "G4tgrVolumeMgr.hh"
40 40
41 // ------------------------------------------- 41 // --------------------------------------------------------------------
42 G4tgrSolid::G4tgrSolid() 42 G4tgrSolid::G4tgrSolid()
43 { 43 {
44 } 44 }
45 45
46 // ------------------------------------------- 46 // --------------------------------------------------------------------
47 G4tgrSolid::~G4tgrSolid() 47 G4tgrSolid::~G4tgrSolid()
48 { 48 {
49 } 49 }
50 50
51 // ------------------------------------------- 51 // --------------------------------------------------------------------
52 G4tgrSolid::G4tgrSolid(const std::vector<G4Str 52 G4tgrSolid::G4tgrSolid(const std::vector<G4String>& wl)
53 { 53 {
54 //---------- set name 54 //---------- set name
55 theName = G4tgrUtils::GetString(wl[1]); 55 theName = G4tgrUtils::GetString(wl[1]);
56 56
57 //---------- set solid type 57 //---------- set solid type
58 theType = G4tgrUtils::GetString(wl[2]); 58 theType = G4tgrUtils::GetString(wl[2]);
59 59
60 //---------- create only vector<double> of t 60 //---------- create only vector<double> of theSolidParams
61 FillSolidParams(wl); 61 FillSolidParams(wl);
62 62
63 G4tgrVolumeMgr::GetInstance()->RegisterMe(th 63 G4tgrVolumeMgr::GetInstance()->RegisterMe(this);
64 64
65 #ifdef G4VERBOSE 65 #ifdef G4VERBOSE
66 if(G4tgrMessenger::GetVerboseLevel() >= 1) 66 if(G4tgrMessenger::GetVerboseLevel() >= 1)
67 { 67 {
68 G4cout << " Created " << *this << G4endl; 68 G4cout << " Created " << *this << G4endl;
69 } 69 }
70 #endif 70 #endif
71 } 71 }
72 72
73 // ------------------------------------------- 73 // --------------------------------------------------------------------
74 const std::vector<std::vector<G4double>*> G4tg 74 const std::vector<std::vector<G4double>*> G4tgrSolid::GetSolidParams() const
75 { 75 {
76 return theSolidParams; 76 return theSolidParams;
77 } 77 }
78 78
79 // ------------------------------------------- 79 // --------------------------------------------------------------------
80 const G4String& G4tgrSolid::GetRelativeRotMatN 80 const G4String& G4tgrSolid::GetRelativeRotMatName() const
81 { 81 {
82 return theName; // Dummy ... 82 return theName; // Dummy ...
83 } 83 }
84 84
85 // ------------------------------------------- 85 // --------------------------------------------------------------------
86 G4ThreeVector G4tgrSolid::GetRelativePlace() c 86 G4ThreeVector G4tgrSolid::GetRelativePlace() const
87 { 87 {
88 return G4ThreeVector(0, 0, 0); // Dummy... 88 return G4ThreeVector(0, 0, 0); // Dummy...
89 } 89 }
90 90
91 // ------------------------------------------- 91 // --------------------------------------------------------------------
92 void G4tgrSolid::FillSolidParams(const std::ve 92 void G4tgrSolid::FillSolidParams(const std::vector<G4String>& wl)
93 { 93 {
94 //---- Setting which are angle parameters (f 94 //---- Setting which are angle parameters (for dimensions...)
95 std::map<G4String, std::set<G4int>> anglePar 95 std::map<G4String, std::set<G4int>> angleParams;
96 std::set<G4int> apar; 96 std::set<G4int> apar;
97 apar.clear(); 97 apar.clear();
98 apar.insert(3); 98 apar.insert(3);
99 apar.insert(4); 99 apar.insert(4);
100 angleParams["TUBS"] = apar; 100 angleParams["TUBS"] = apar;
101 apar.clear(); 101 apar.clear();
102 apar.insert(5); 102 apar.insert(5);
103 apar.insert(6); 103 apar.insert(6);
104 angleParams["CONS"] = apar; 104 angleParams["CONS"] = apar;
105 apar.clear(); 105 apar.clear();
106 apar.insert(3); 106 apar.insert(3);
107 apar.insert(4); 107 apar.insert(4);
108 apar.insert(5); 108 apar.insert(5);
109 angleParams["PARA"] = apar; 109 angleParams["PARA"] = apar;
110 apar.clear(); 110 apar.clear();
111 apar.insert(1); 111 apar.insert(1);
112 apar.insert(2); 112 apar.insert(2);
113 apar.insert(6); 113 apar.insert(6);
114 apar.insert(10); 114 apar.insert(10);
115 angleParams["TRAP"] = apar; 115 angleParams["TRAP"] = apar;
116 apar.clear(); 116 apar.clear();
117 apar.insert(2); 117 apar.insert(2);
118 apar.insert(3); 118 apar.insert(3);
119 apar.insert(4); 119 apar.insert(4);
120 apar.insert(5); 120 apar.insert(5);
121 angleParams["SPHERE"] = apar; 121 angleParams["SPHERE"] = apar;
122 apar.clear(); 122 apar.clear();
123 apar.insert(3); 123 apar.insert(3);
124 apar.insert(4); 124 apar.insert(4);
125 angleParams["TORUS"] = apar; 125 angleParams["TORUS"] = apar;
126 apar.clear(); 126 apar.clear();
127 apar.insert(0); 127 apar.insert(0);
128 apar.insert(1); 128 apar.insert(1);
129 angleParams["POLYCONE"] = apar; 129 angleParams["POLYCONE"] = apar;
130 apar.clear(); 130 apar.clear();
131 apar.insert(0); 131 apar.insert(0);
132 apar.insert(1); 132 apar.insert(1);
133 angleParams["POLYHEDRA"] = apar; 133 angleParams["POLYHEDRA"] = apar;
134 apar.clear(); 134 apar.clear();
135 apar.insert(2); 135 apar.insert(2);
136 apar.insert(3); 136 apar.insert(3);
137 angleParams["HYPE"] = apar; 137 angleParams["HYPE"] = apar;
138 apar.clear(); 138 apar.clear();
139 apar.insert(0); 139 apar.insert(0);
140 angleParams["TWISTED_BOX"] = apar; 140 angleParams["TWISTED_BOX"] = apar;
141 apar.clear(); 141 apar.clear();
142 apar.insert(0); 142 apar.insert(0);
143 apar.insert(2); 143 apar.insert(2);
144 apar.insert(3); 144 apar.insert(3);
145 apar.insert(10); 145 apar.insert(10);
146 angleParams["TWISTED_TRAP"] = apar; 146 angleParams["TWISTED_TRAP"] = apar;
147 apar.clear(); 147 apar.clear();
148 apar.insert(5); 148 apar.insert(5);
149 angleParams["TWISTED_TRD"] = apar; 149 angleParams["TWISTED_TRD"] = apar;
150 apar.clear(); 150 apar.clear();
151 apar.insert(0); 151 apar.insert(0);
152 apar.insert(4); 152 apar.insert(4);
153 angleParams["TWISTED_TUBS"] = std::move(apar << 153 angleParams["TWISTED_TUBS"] = apar;
154 154
155 std::vector<G4double>* vd = new std::vector< 155 std::vector<G4double>* vd = new std::vector<G4double>;
156 theSolidParams.push_back(vd); 156 theSolidParams.push_back(vd);
157 std::size_t noParRead = wl.size() - 3; 157 std::size_t noParRead = wl.size() - 3;
158 158
159 G4String solidType = wl[2]; 159 G4String solidType = wl[2];
160 //--- Default unit (mm) if length, deg if an 160 //--- Default unit (mm) if length, deg if angle
161 for(G4int ii = 0; ii < (G4int)noParRead; ++i << 161 for(std::size_t ii = 0; ii < noParRead; ++ii)
162 { 162 {
163 G4bool isAngle = 0; 163 G4bool isAngle = 0;
164 std::map<G4String, std::set<G4int>>::const 164 std::map<G4String, std::set<G4int>>::const_iterator ite =
165 angleParams.find(solidType); 165 angleParams.find(solidType);
166 if(ite != angleParams.cend()) 166 if(ite != angleParams.cend())
167 { 167 {
168 std::set<G4int> apar2 = (*ite).second; 168 std::set<G4int> apar2 = (*ite).second;
169 if(apar2.find(ii) != apar2.cend()) 169 if(apar2.find(ii) != apar2.cend())
170 { 170 {
171 isAngle = 1; 171 isAngle = 1;
172 vd->push_back(G4tgrUtils::GetDouble(wl 172 vd->push_back(G4tgrUtils::GetDouble(wl[3 + ii], deg));
173 #ifdef G4VERBOSE 173 #ifdef G4VERBOSE
174 if(G4tgrMessenger::GetVerboseLevel() > 174 if(G4tgrMessenger::GetVerboseLevel() >= 3)
175 { 175 {
176 G4cout << " G4tgrSolid::FillSolidPar 176 G4cout << " G4tgrSolid::FillSolidParams() - Angle param found "
177 << solidType << " " << ii << 177 << solidType << " " << ii << G4endl;
178 } 178 }
179 #endif 179 #endif
180 } 180 }
181 } 181 }
182 if(!isAngle) 182 if(!isAngle)
183 { 183 {
184 vd->push_back(G4tgrUtils::GetDouble(wl[3 184 vd->push_back(G4tgrUtils::GetDouble(wl[3 + ii]));
185 } 185 }
186 } 186 }
187 } 187 }
188 188
189 // ------------------------------------------- 189 // --------------------------------------------------------------------
190 std::ostream& operator<<(std::ostream& os, con 190 std::ostream& operator<<(std::ostream& os, const G4tgrSolid& sol)
191 { 191 {
192 os << "G4tgrSolid= " << sol.theName << " of 192 os << "G4tgrSolid= " << sol.theName << " of type " << sol.theType
193 << " PARAMS: "; 193 << " PARAMS: ";
194 if(sol.theSolidParams.size() != 0) 194 if(sol.theSolidParams.size() != 0)
195 { 195 {
196 std::vector<G4double> solpar = *(sol.theSo 196 std::vector<G4double> solpar = *(sol.theSolidParams[0]);
197 for(std::size_t ii = 0; ii < solpar.size() 197 for(std::size_t ii = 0; ii < solpar.size(); ++ii)
198 { 198 {
199 os << solpar[ii] << " "; 199 os << solpar[ii] << " ";
200 } 200 }
201 } 201 }
202 os << G4endl; 202 os << G4endl;
203 203
204 return os; 204 return os;
205 } 205 }
206 206