| 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 // ********************************************************************
>> 22 //
>> 23 //
>> 24 // $Id: G4PVParameterised.cc,v 1.5 2005/11/11 22:39:00 japost Exp $
>> 25 // GEANT4 tag $Name: geant4-08-00-patch-01 $
>> 26 //
25 // 27 //
26 // class G4PVParameterised implementation << 28 // class G4PVParameterised
>> 29 //
>> 30 // Implementation
27 // 31 //
28 // 29.07.95, P.Kent - first non-stub version <<
29 // ------------------------------------------- 32 // ----------------------------------------------------------------------
30 33
31 #include "G4PVParameterised.hh" 34 #include "G4PVParameterised.hh"
32 #include "G4VPVParameterisation.hh" 35 #include "G4VPVParameterisation.hh"
33 #include "G4AffineTransform.hh" 36 #include "G4AffineTransform.hh"
34 #include "G4UnitsTable.hh" <<
35 #include "G4VSolid.hh" 37 #include "G4VSolid.hh"
36 #include "G4LogicalVolume.hh" 38 #include "G4LogicalVolume.hh"
37 39
38 // ------------------------------------------- 40 // ----------------------------------------------------------------------
39 // Constructor 41 // Constructor
40 // 42 //
41 G4PVParameterised::G4PVParameterised( const G4 43 G4PVParameterised::G4PVParameterised( const G4String& pName,
42 G4 44 G4LogicalVolume* pLogical,
43 G4 << 45 G4VPhysicalVolume* pMother,
44 const EA 46 const EAxis pAxis,
45 const G4 47 const G4int nReplicas,
46 G4 << 48 G4VPVParameterisation *pParam,
47 G4 49 G4bool pSurfChk )
48 : G4PVReplica(pName, nReplicas, pAxis, pLogica << 50 : G4PVReplica(pName, pLogical, pMother, pAxis, nReplicas, 0, 0),
49 pMotherPhysical != nullptr ? pMo <<
50 fparam(pParam) 51 fparam(pParam)
51 { 52 {
52 G4LogicalVolume* motherLogical= pMotherPhysi <<
53 pMotherPhysical->GetLogicalVolume() : nu <<
54 <<
55 SetMotherLogical( motherLogical ); <<
56 if( motherLogical != nullptr ) <<
57 { <<
58 // Registration moved here to ensure that <<
59 motherLogical->AddDaughter(this); <<
60 } <<
61 <<
62 #ifdef G4VERBOSE 53 #ifdef G4VERBOSE
63 if ((pMotherPhysical != nullptr) && (pMother << 54 if ((pMother) && (pMother->IsParameterised()))
64 { 55 {
65 std::ostringstream message, hint; << 56 G4cout << "WARNING - G4PVParameterised::G4PVParameterised()" << G4endl
66 message << "A parameterised volume is bein << 57 << " A parameterised volume is being placed" << G4endl
67 << "inside another parameterised v << 58 << " inside another parameterised volume !" << G4endl
68 hint << "To make sure that no overlaps are << 59 << " To make sure that no overlaps are generated," << G4endl
69 << "you should verify the mother repl << 60 << " you should verify the mother replicated shapes" << G4endl
70 << "are of the same type and dimensio << 61 << " are of the same type and dimensions." << G4endl
71 << " Mother physical volume: " << p << 62 << " Mother physical volume: " << pMother->GetName() << G4endl
72 << " Parameterised volume: " << pNa << 63 << " Parameterised volume: " << pName << G4endl
73 << " (To switch this warning off, co << 64 << " (To switch this warning off, compile with G4_NO_VERBOSE)" << G4endl;
74 G4Exception("G4PVParameterised::G4PVParame <<
75 JustWarning, message, G4String <<
76 } 65 }
77 #endif 66 #endif
78 if (pSurfChk) { CheckOverlaps(); } 67 if (pSurfChk) { CheckOverlaps(); }
79 } 68 }
80 69
81 // ------------------------------------------- 70 // ----------------------------------------------------------------------
82 // Constructor 71 // Constructor
83 // 72 //
84 G4PVParameterised::G4PVParameterised( const G4 73 G4PVParameterised::G4PVParameterised( const G4String& pName,
85 G4 74 G4LogicalVolume* pLogical,
86 G4 75 G4LogicalVolume* pMotherLogical,
87 const EA 76 const EAxis pAxis,
88 const G4 77 const G4int nReplicas,
89 G4 << 78 G4VPVParameterisation *pParam,
90 G4 79 G4bool pSurfChk )
91 : G4PVReplica(pName, nReplicas, pAxis, pLogi << 80 : G4PVReplica(pName, pLogical, pMotherLogical, pAxis, nReplicas, 0, 0),
92 fparam(pParam) 81 fparam(pParam)
93 { 82 {
94 SetMotherLogical( pMotherLogical ); <<
95 if( pMotherLogical != nullptr ) <<
96 { <<
97 // Registration moved here to ensure that <<
98 pMotherLogical->AddDaughter(this); <<
99 } <<
100 if (pSurfChk) { CheckOverlaps(); } 83 if (pSurfChk) { CheckOverlaps(); }
101 } 84 }
102 85
103 // ------------------------------------------- 86 // ----------------------------------------------------------------------
104 // Fake default constructor - sets only member 87 // Fake default constructor - sets only member data and allocates memory
105 // for usage restri 88 // for usage restricted to object persistency.
106 // 89 //
107 G4PVParameterised::G4PVParameterised( __void__ 90 G4PVParameterised::G4PVParameterised( __void__& a )
108 : G4PVReplica(a) << 91 : G4PVReplica(a), fparam(0)
109 { 92 {
110 } 93 }
111 94
112 // ------------------------------------------- 95 // ----------------------------------------------------------------------
113 // Destructor 96 // Destructor
114 // 97 //
115 G4PVParameterised::~G4PVParameterised() = defa << 98 G4PVParameterised::~G4PVParameterised()
>> 99 {
>> 100 }
116 101
117 // ------------------------------------------- 102 // ----------------------------------------------------------------------
118 // GetParameterisation 103 // GetParameterisation
119 // 104 //
120 G4VPVParameterisation* G4PVParameterised::GetP 105 G4VPVParameterisation* G4PVParameterised::GetParameterisation() const
121 { 106 {
122 return fparam; 107 return fparam;
123 } 108 }
124 109
125 // ------------------------------------------- 110 // ----------------------------------------------------------------------
126 // IsParameterised 111 // IsParameterised
127 // 112 //
128 G4bool G4PVParameterised::IsParameterised() co 113 G4bool G4PVParameterised::IsParameterised() const
129 { 114 {
130 return true; 115 return true;
131 } 116 }
132 117
133 // ------------------------------------------- 118 // ----------------------------------------------------------------------
134 // VolumeType <<
135 // <<
136 EVolume G4PVParameterised::VolumeType() const <<
137 { <<
138 return kParameterised; <<
139 } <<
140 <<
141 // ------------------------------------------- <<
142 // GetReplicationData 119 // GetReplicationData
143 // 120 //
144 void G4PVParameterised::GetReplicationData( EA 121 void G4PVParameterised::GetReplicationData( EAxis& axis,
145 G4 122 G4int& nReplicas,
146 G4 123 G4double& width,
147 G4 124 G4double& offset,
148 G4 125 G4bool& consuming) const
149 { 126 {
150 axis = faxis; 127 axis = faxis;
151 nReplicas = fnReplicas; 128 nReplicas = fnReplicas;
152 width = fwidth; 129 width = fwidth;
153 offset = foffset; 130 offset = foffset;
154 consuming = false; 131 consuming = false;
155 } 132 }
156 133
157 // ------------------------------------------- 134 // ----------------------------------------------------------------------
158 // SetRegularStructureId 135 // SetRegularStructureId
159 // 136 //
160 void G4PVParameterised::SetRegularStructureId << 137 void G4PVParameterised::SetRegularStructureId( G4int Code )
161 { 138 {
162 G4PVReplica::SetRegularStructureId( code ); << 139 G4PVReplica::SetRegularStructureId( Code );
163 // To undertake additional preparation, a de 140 // To undertake additional preparation, a derived volume must
164 // redefine this method, while calling also << 141 // redefine this method, while calling also the above method.
165 } 142 }
166 143
167 144
168 // ------------------------------------------- 145 // ----------------------------------------------------------------------
169 // CheckOverlaps 146 // CheckOverlaps
170 // 147 //
171 G4bool << 148 G4bool G4PVParameterised::CheckOverlaps(G4int res)
172 G4PVParameterised::CheckOverlaps(G4int res, G4 <<
173 G4bool verbos <<
174 { 149 {
175 if (res<=0) { return false; } 150 if (res<=0) { return false; }
176 151
177 G4int trials = 0; << 152 G4VSolid *solidA = 0, *solidB = 0;
178 G4bool retval = false; << 153 G4LogicalVolume *motherLog = GetMotherLogical();
179 G4VSolid *solidA = nullptr, *solidB = nullpt <<
180 G4LogicalVolume* motherLog = GetMotherLogica <<
181 G4VSolid *motherSolid = motherLog->GetSolid( 154 G4VSolid *motherSolid = motherLog->GetSolid();
182 std::vector<G4ThreeVector> points; 155 std::vector<G4ThreeVector> points;
183 156
184 if (verbose) << 157 G4cout << "Checking overlaps for parameterised volume "
185 { << 158 << GetName() << " ... ";
186 G4cout << "Checking overlaps for parameter <<
187 << GetName() << " ... "; <<
188 } <<
189 159
190 for (auto i=0; i<GetMultiplicity(); ++i) << 160 for (G4int i=0; i<GetMultiplicity(); i++)
191 { 161 {
192 solidA = fparam->ComputeSolid(i, this); 162 solidA = fparam->ComputeSolid(i, this);
193 solidA->ComputeDimensions(fparam, i, this) 163 solidA->ComputeDimensions(fparam, i, this);
194 fparam->ComputeTransformation(i, this); 164 fparam->ComputeTransformation(i, this);
195 165
196 // Create the transformation from daughter 166 // Create the transformation from daughter to mother
197 // 167 //
198 G4AffineTransform Tm( GetRotation(), GetTr << 168 G4AffineTransform Tm( GetFrameRotation(), GetFrameTranslation() );
199 169
200 // Generate random points on surface accor 170 // Generate random points on surface according to the given resolution,
201 // transform them to the mother's coordina 171 // transform them to the mother's coordinate system and if no overlaps
202 // with the mother volume, cache them in a 172 // with the mother volume, cache them in a vector for later use with
203 // the daughters 173 // the daughters
204 // 174 //
205 for (auto n=0; n<res; ++n) << 175 for (G4int n=0; n<res; n++)
206 { 176 {
207 G4ThreeVector mp = Tm.TransformPoint(sol 177 G4ThreeVector mp = Tm.TransformPoint(solidA->GetPointOnSurface());
208 178
209 // Checking overlaps with the mother vol 179 // Checking overlaps with the mother volume
210 // 180 //
211 if (motherSolid->Inside(mp)==kOutside) 181 if (motherSolid->Inside(mp)==kOutside)
212 { 182 {
213 G4double distin = motherSolid->Distanc << 183 G4cout << G4endl;
214 if (distin > tol) << 184 G4cout << "WARNING - G4PVParameterised::CheckOverlaps()" << G4endl
215 { << 185 << " Overlap is detected for volume "
216 ++trials; retval = true; << 186 << GetName() << ", parameterised instance: " << i << G4endl
217 std::ostringstream message; << 187 << " with its mother volume "
218 message << "Overlap with mother volu << 188 << motherLog->GetName() << G4endl
219 << " Overlap is dete << 189 << " at point " << mp << G4endl;
220 << GetName() << ", parameter << 190 G4Exception("G4PVParameterised::CheckOverlaps()", "InvalidSetup",
221 << " with its mothe << 191 JustWarning, "Overlap with mother volume !");
222 << motherLog->GetName() << G << 192 return true;
223 << " at mother loca <<
224 << "overlapping by at least: <<
225 << G4BestUnit(distin, "Lengt <<
226 if (trials>=maxErr) <<
227 { <<
228 message << G4endl <<
229 << "NOTE: Reached maximum <<
230 << "- of overlaps reports <<
231 } <<
232 G4Exception("G4PVParameterised::Chec <<
233 "GeomVol1002", JustWarni <<
234 if (trials>=maxErr) { return true; <<
235 } <<
236 } 193 }
237 points.push_back(mp); 194 points.push_back(mp);
238 } 195 }
239 196
240 // Checking overlaps with each other param 197 // Checking overlaps with each other parameterised instance
241 // 198 //
242 for (auto j=i+1; j<GetMultiplicity(); ++j) << 199 std::vector<G4ThreeVector>::iterator pos;
>> 200 for (G4int j=i+1; j<GetMultiplicity(); j++)
243 { 201 {
244 solidB = fparam->ComputeSolid(j,this); 202 solidB = fparam->ComputeSolid(j,this);
245 solidB->ComputeDimensions(fparam, j, thi 203 solidB->ComputeDimensions(fparam, j, this);
246 fparam->ComputeTransformation(j, this); 204 fparam->ComputeTransformation(j, this);
247 205
248 // Create the transformation for daughte 206 // Create the transformation for daughter volume
249 // 207 //
250 G4AffineTransform Td( GetRotation(), Get << 208 G4AffineTransform Td( GetFrameRotation(), GetFrameTranslation() );
251 209
252 for (const auto & point : points) << 210 for (pos=points.begin(); pos!=points.end(); pos++)
253 { 211 {
254 // Transform each point according to d 212 // Transform each point according to daughter's frame
255 // 213 //
256 G4ThreeVector md = Td.InverseTransform << 214 G4ThreeVector md = Td.Invert().TransformPoint(*pos);
257 215
258 if (solidB->Inside(md)==kInside) 216 if (solidB->Inside(md)==kInside)
259 { 217 {
260 G4double distout = solidB->DistanceT << 218 G4cout << G4endl;
261 if (distout > tol) << 219 G4cout << "WARNING - G4PVParameterised::CheckOverlaps()" << G4endl
262 { << 220 << " Overlap is detected for volume "
263 ++trials; retval = true; << 221 << GetName() << ", parameterised instance: " << i << G4endl
264 std::ostringstream message; << 222 << " with parameterised volume instance: " << j
265 message << "Overlap within paramet << 223 << G4endl
266 << " Overlap is d << 224 << " at point " << md << G4endl;
267 << GetName() << ", paramet << 225 G4Exception("G4PVParameterised::CheckOverlaps()", "InvalidSetup",
268 << " with paramet << 226 JustWarning, "Overlap within parameterised volumes !");
269 << G4endl << 227 return true;
270 << " at local poi <<
271 << "overlapping by at leas <<
272 << G4BestUnit(distout, "Le <<
273 << ", related to volume in <<
274 if (trials>=maxErr) <<
275 { <<
276 message << G4endl <<
277 << "NOTE: Reached maximu <<
278 << "- of overlaps report <<
279 } <<
280 G4Exception("G4PVParameterised::Ch <<
281 "GeomVol1002", JustWar <<
282 if (trials>=maxErr) { return true <<
283 } <<
284 } 228 }
285 } 229 }
286 } 230 }
287 } 231 }
288 if (verbose) << 232 G4cout << "OK! " << G4endl;
289 { <<
290 G4cout << "OK! " << G4endl; <<
291 } <<
292 233
293 return retval; << 234 return false;
294 } 235 }
295 236