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