| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // class G4GeomTestVolume implementation
27 //
28 // Author: G.Cosmo, CERN
29 // -------------------------------------------
30
31 #include <queue>
32 #include <set>
33
34 #include "G4GeomTestVolume.hh"
35 #include "G4PhysicalConstants.hh"
36 #include "G4VPhysicalVolume.hh"
37 #include "G4LogicalVolume.hh"
38 #include "G4VSolid.hh"
39
40 //
41 // Constructor
42 //
43 G4GeomTestVolume::G4GeomTestVolume( G4VPhysica
44 G4double t
45 G4int numb
46 G4bool the
47 : target(theTarget), tolerance(theTolerance)
48 resolution(numberOfPoints), verbosity(theV
49 {;}
50
51 //
52 // Destructor
53 //
54 G4GeomTestVolume::~G4GeomTestVolume() {;}
55
56 //
57 // Get error tolerance
58 //
59 G4double G4GeomTestVolume::GetTolerance() cons
60 {
61 return tolerance;
62 }
63
64 //
65 // Set error tolerance
66 //
67 void G4GeomTestVolume::SetTolerance(G4double t
68 {
69 tolerance = tol;
70 }
71
72 //
73 // Get number of points to check (resolution)
74 //
75 G4int G4GeomTestVolume::GetResolution() const
76 {
77 return resolution;
78 }
79
80 //
81 // Set number of points to check (resolution)
82 //
83 void G4GeomTestVolume::SetResolution(G4int np)
84 {
85 resolution = np;
86 }
87
88 //
89 // Get verbosity
90 //
91 G4bool G4GeomTestVolume::GetVerbosity() const
92 {
93 return verbosity;
94 }
95
96 //
97 // Set verbosity
98 //
99 void G4GeomTestVolume::SetVerbosity(G4bool ver
100 {
101 verbosity = verb;
102 }
103
104 //
105 // Get errors reporting threshold
106 //
107 G4int G4GeomTestVolume::GetErrorsThreshold() c
108 {
109 return maxErr;
110 }
111
112 //
113 // Set maximum number of errors to report
114 //
115 void G4GeomTestVolume::SetErrorsThreshold(G4in
116 {
117 maxErr = max;
118 }
119
120 //
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
173 //
174 void G4GeomTestVolume::TestRecursiveOverlap( G
175 {
176 // If reached requested level of depth (i.e.
177 // If not depth specified (i.e. set to -1),
178 // If requested initial level of depth is no
179 //
180 if (depth == 0) { return; }
181 if (depth != -1) { depth--; }
182 if (slevel != 0) { slevel--; }
183
184 //
185 // As long as we reached the requested
186 // initial level of depth, test ourselves
187 //
188 if ( slevel==0 )
189 {
190 target->CheckOverlaps(resolution, toleranc
191 }
192
193 //
194 // Loop over unique daughters
195 //
196 std::set<const G4LogicalVolume *> tested;
197
198 const G4LogicalVolume *logical = target->Get
199 auto nDaughter = (G4int)logical->GetNoDaugh
200 for( auto iDaughter=0; iDaughter<nDaughter;
201 {
202 G4VPhysicalVolume *daughter = logical->Get
203
204 // Tested already?
205 //
206 // const G4LogicalVolume *daughterLogical
207 // daughter->GetLogicalVolume();
208 // std::pair<std::set<const G4LogicalVolum
209 // there = tested.insert(daughterLog
210 // if (!there.second) continue;
211
212 //
213 // Recurse
214 //
215 G4GeomTestVolume vTest( daughter, toleranc
216 vTest.SetErrorsThreshold(maxErr);
217 vTest.TestRecursiveOverlap( slevel,depth )
218 }
219 }
220