| 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 // class G4GeomTestVolume implementation << 26 //
>> 27 // $Id: G4GeomTestVolume.cc 73253 2013-08-22 13:24:02Z gcosmo $
>> 28 //
>> 29 // --------------------------------------------------------------------
>> 30 // GEANT 4 class source file
>> 31 //
>> 32 // G4GeomTestVolume
27 // 33 //
28 // Author: G.Cosmo, CERN 34 // Author: G.Cosmo, CERN
29 // ------------------------------------------- 35 // --------------------------------------------------------------------
30 36
31 #include <queue> <<
32 #include <set> 37 #include <set>
33 38
34 #include "G4GeomTestVolume.hh" 39 #include "G4GeomTestVolume.hh"
>> 40
35 #include "G4PhysicalConstants.hh" 41 #include "G4PhysicalConstants.hh"
36 #include "G4VPhysicalVolume.hh" 42 #include "G4VPhysicalVolume.hh"
37 #include "G4LogicalVolume.hh" 43 #include "G4LogicalVolume.hh"
38 #include "G4VSolid.hh" 44 #include "G4VSolid.hh"
39 45
40 // 46 //
41 // Constructor 47 // Constructor
42 // 48 //
43 G4GeomTestVolume::G4GeomTestVolume( G4VPhysica 49 G4GeomTestVolume::G4GeomTestVolume( G4VPhysicalVolume *theTarget,
44 G4double t 50 G4double theTolerance,
45 G4int numb 51 G4int numberOfPoints,
46 G4bool the 52 G4bool theVerbosity )
47 : target(theTarget), tolerance(theTolerance) 53 : target(theTarget), tolerance(theTolerance),
48 resolution(numberOfPoints), verbosity(theV << 54 resolution(numberOfPoints), maxErr(1), verbosity(theVerbosity)
49 {;} 55 {;}
50 56
51 // 57 //
52 // Destructor 58 // Destructor
53 // 59 //
54 G4GeomTestVolume::~G4GeomTestVolume() {;} 60 G4GeomTestVolume::~G4GeomTestVolume() {;}
55 61
56 // 62 //
57 // Get error tolerance 63 // Get error tolerance
58 // 64 //
59 G4double G4GeomTestVolume::GetTolerance() cons 65 G4double G4GeomTestVolume::GetTolerance() const
60 { 66 {
61 return tolerance; 67 return tolerance;
62 } 68 }
63 69
64 // 70 //
65 // Set error tolerance 71 // Set error tolerance
66 // 72 //
67 void G4GeomTestVolume::SetTolerance(G4double t 73 void G4GeomTestVolume::SetTolerance(G4double tol)
68 { 74 {
69 tolerance = tol; 75 tolerance = tol;
70 } 76 }
71 77
72 // 78 //
73 // Get number of points to check (resolution) 79 // Get number of points to check (resolution)
74 // 80 //
75 G4int G4GeomTestVolume::GetResolution() const 81 G4int G4GeomTestVolume::GetResolution() const
76 { 82 {
77 return resolution; 83 return resolution;
78 } 84 }
79 85
80 // 86 //
81 // Set number of points to check (resolution) 87 // Set number of points to check (resolution)
82 // 88 //
83 void G4GeomTestVolume::SetResolution(G4int np) 89 void G4GeomTestVolume::SetResolution(G4int np)
84 { 90 {
85 resolution = np; 91 resolution = np;
86 } 92 }
87 93
88 // 94 //
89 // Get verbosity 95 // Get verbosity
90 // 96 //
91 G4bool G4GeomTestVolume::GetVerbosity() const 97 G4bool G4GeomTestVolume::GetVerbosity() const
92 { 98 {
93 return verbosity; 99 return verbosity;
94 } 100 }
95 101
96 // 102 //
97 // Set verbosity 103 // Set verbosity
98 // 104 //
99 void G4GeomTestVolume::SetVerbosity(G4bool ver 105 void G4GeomTestVolume::SetVerbosity(G4bool verb)
100 { 106 {
101 verbosity = verb; 107 verbosity = verb;
102 } 108 }
103 109
104 // 110 //
105 // Get errors reporting threshold 111 // Get errors reporting threshold
106 // 112 //
107 G4int G4GeomTestVolume::GetErrorsThreshold() c 113 G4int G4GeomTestVolume::GetErrorsThreshold() const
108 { 114 {
109 return maxErr; 115 return maxErr;
110 } 116 }
111 117
112 // 118 //
113 // Set maximum number of errors to report 119 // Set maximum number of errors to report
114 // 120 //
115 void G4GeomTestVolume::SetErrorsThreshold(G4in 121 void G4GeomTestVolume::SetErrorsThreshold(G4int max)
116 { 122 {
117 maxErr = max; 123 maxErr = max;
118 } 124 }
119 125
120 // 126 //
121 // Test overlap in tree <<
122 // <<
123 void G4GeomTestVolume::TestOverlapInTree() con <<
124 { <<
125 std::queue<G4VPhysicalVolume*> volumes; <<
126 std::set<G4LogicalVolume*> checked; <<
127 <<
128 volumes.push(target); <<
129 while (!volumes.empty()) <<
130 { <<
131 G4VPhysicalVolume* current = volumes.front <<
132 volumes.pop(); <<
133 <<
134 // check overlaps for daughters <<
135 G4LogicalVolume* logical = current->GetLog <<
136 std::size_t ndaughters = logical->GetNoDau <<
137 for (std::size_t i=0; i<ndaughters; ++i) <<
138 { <<
139 G4VPhysicalVolume* daughter = logical->G <<
140 daughter->CheckOverlaps(resolution, tole <<
141 } <<
142 <<
143 // append the queue of volumes <<
144 G4LogicalVolume* previousLogical = nullptr <<
145 for (std::size_t i=0; i<ndaughters; ++i) <<
146 { <<
147 G4VPhysicalVolume* daughter = logical->G <<
148 G4LogicalVolume* daughterLogical = daugh <<
149 if (daughterLogical->GetNoDaughters() == <<
150 G4bool found = (daughterLogical == previ <<
151 if (!found) { found = (checked.find(daug <<
152 if (!found) <<
153 { <<
154 checked.emplace(daughterLogical); <<
155 previousLogical = daughterLogical; <<
156 volumes.push(daughter); <<
157 } <<
158 else <<
159 { <<
160 if (verbosity) <<
161 { <<
162 G4cout << "Checking overlaps in tree <<
163 << " (" << daughterLogical->G <<
164 << " is omitted, to avoid dup <<
165 } <<
166 } <<
167 } <<
168 } <<
169 } <<
170 <<
171 // <<
172 // TestRecursiveOverlap 127 // TestRecursiveOverlap
173 // 128 //
174 void G4GeomTestVolume::TestRecursiveOverlap( G 129 void G4GeomTestVolume::TestRecursiveOverlap( G4int slevel, G4int depth )
175 { 130 {
176 // If reached requested level of depth (i.e. 131 // If reached requested level of depth (i.e. set to 0), exit.
177 // If not depth specified (i.e. set to -1), 132 // If not depth specified (i.e. set to -1), visit the whole tree.
178 // If requested initial level of depth is no 133 // If requested initial level of depth is not zero, visit from beginning
179 // 134 //
180 if (depth == 0) { return; } << 135 if (depth == 0) return;
181 if (depth != -1) { depth--; } << 136 if (depth != -1) depth--;
182 if (slevel != 0) { slevel--; } << 137 if (slevel != 0) slevel--;
183 138
184 // 139 //
185 // As long as we reached the requested 140 // As long as we reached the requested
186 // initial level of depth, test ourselves 141 // initial level of depth, test ourselves
187 // 142 //
188 if ( slevel==0 ) 143 if ( slevel==0 )
189 { 144 {
190 target->CheckOverlaps(resolution, toleranc 145 target->CheckOverlaps(resolution, tolerance, verbosity, maxErr);
191 } 146 }
192 147
193 // 148 //
194 // Loop over unique daughters 149 // Loop over unique daughters
195 // 150 //
196 std::set<const G4LogicalVolume *> tested; 151 std::set<const G4LogicalVolume *> tested;
197 152
198 const G4LogicalVolume *logical = target->Get 153 const G4LogicalVolume *logical = target->GetLogicalVolume();
199 auto nDaughter = (G4int)logical->GetNoDaugh << 154 G4int nDaughter = logical->GetNoDaughters();
200 for( auto iDaughter=0; iDaughter<nDaughter; << 155 G4int iDaughter;
>> 156 for( iDaughter=0; iDaughter<nDaughter; ++iDaughter )
201 { 157 {
202 G4VPhysicalVolume *daughter = logical->Get 158 G4VPhysicalVolume *daughter = logical->GetDaughter(iDaughter);
>> 159 const G4LogicalVolume *daughterLogical =
>> 160 daughter->GetLogicalVolume();
203 161
>> 162 //
204 // Tested already? 163 // Tested already?
205 // 164 //
206 // const G4LogicalVolume *daughterLogical << 165 std::pair<std::set<const G4LogicalVolume *>::iterator, G4bool>
207 // daughter->GetLogicalVolume(); << 166 there = tested.insert(daughterLogical);
208 // std::pair<std::set<const G4LogicalVolum << 167 if (!there.second) continue;
209 // there = tested.insert(daughterLog <<
210 // if (!there.second) continue; <<
211 168
212 // 169 //
213 // Recurse 170 // Recurse
214 // 171 //
215 G4GeomTestVolume vTest( daughter, toleranc 172 G4GeomTestVolume vTest( daughter, tolerance, resolution, verbosity );
216 vTest.SetErrorsThreshold(maxErr); 173 vTest.SetErrorsThreshold(maxErr);
217 vTest.TestRecursiveOverlap( slevel,depth ) 174 vTest.TestRecursiveOverlap( slevel,depth );
218 } 175 }
219 } 176 }
220 177