| 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 // G4GeometryWorkspace - implementation 26 // G4GeometryWorkspace - implementation
27 // 27 //
28 // Authors: John Apostolakis (CERN), Andrea Do 28 // Authors: John Apostolakis (CERN), Andrea Dotti (SLAC), July 2013
29 // ------------------------------------------- 29 // --------------------------------------------------------------------
30 30
31 #include "G4GeometryWorkspace.hh" 31 #include "G4GeometryWorkspace.hh"
32 #include "G4PhysicalVolumeStore.hh" 32 #include "G4PhysicalVolumeStore.hh"
33 #include "G4AutoLock.hh" 33 #include "G4AutoLock.hh"
34 34
35 namespace 35 namespace
36 { 36 {
37 G4Mutex mutex_init = G4MUTEX_INITIALIZER; 37 G4Mutex mutex_init = G4MUTEX_INITIALIZER;
38 G4GeometryWorkspace::pool_type thePool; 38 G4GeometryWorkspace::pool_type thePool;
39 } 39 }
40 40
41 // ------------------------------------------- 41 // ----------------------------------------------------------------------
42 // 42 //
43 G4GeometryWorkspace::pool_type* G4GeometryWork 43 G4GeometryWorkspace::pool_type* G4GeometryWorkspace::GetPool()
44 { 44 {
45 return &thePool; 45 return &thePool;
46 } 46 }
47 47
48 // ------------------------------------------- 48 // ----------------------------------------------------------------------
49 // 49 //
50 G4GeometryWorkspace::G4GeometryWorkspace() 50 G4GeometryWorkspace::G4GeometryWorkspace()
51 { 51 {
52 fpLogicalVolumeSIM= 52 fpLogicalVolumeSIM=
53 &const_cast<G4LVManager&>(G4LogicalVolum 53 &const_cast<G4LVManager&>(G4LogicalVolume::GetSubInstanceManager());
54 fpPhysicalVolumeSIM= 54 fpPhysicalVolumeSIM=
55 &const_cast<G4PVManager&>( G4VPhysicalVo 55 &const_cast<G4PVManager&>( G4VPhysicalVolume::GetSubInstanceManager() );
56 fpReplicaSIM= 56 fpReplicaSIM=
57 &const_cast<G4PVRManager&>(G4PVReplica:: 57 &const_cast<G4PVRManager&>(G4PVReplica::GetSubInstanceManager());
58 fpRegionSIM= 58 fpRegionSIM=
59 &const_cast<G4RegionManager&>(G4Region:: 59 &const_cast<G4RegionManager&>(G4Region::GetSubInstanceManager());
60 60
61 // Create a work area for Logical Volumes in 61 // Create a work area for Logical Volumes in this thread
62 // then capture its address 62 // then capture its address
63 // 63 //
64 InitialiseWorkspace(); 64 InitialiseWorkspace();
65 65
66 fLogicalVolumeOffset = fpLogicalVolumeSIM->G 66 fLogicalVolumeOffset = fpLogicalVolumeSIM->GetOffset();
67 67
68 fPhysicalVolumeOffset = fpPhysicalVolumeSIM- 68 fPhysicalVolumeOffset = fpPhysicalVolumeSIM->GetOffset();
69 69
70 fReplicaOffset = fpReplicaSIM->GetOffset(); 70 fReplicaOffset = fpReplicaSIM->GetOffset();
71 71
72 fRegionOffset = fpRegionSIM->GetOffset(); 72 fRegionOffset = fpRegionSIM->GetOffset();
73 } 73 }
74 74
75 // ------------------------------------------- 75 // ----------------------------------------------------------------------
76 // 76 //
77 void 77 void
78 G4GeometryWorkspace::UseWorkspace() 78 G4GeometryWorkspace::UseWorkspace()
79 { 79 {
80 // Geometry related, split classes mechanism 80 // Geometry related, split classes mechanism: instantiate sub-instance
81 // for this thread 81 // for this thread
82 // 82 //
83 fpLogicalVolumeSIM->UseWorkArea(fLogicalVolu 83 fpLogicalVolumeSIM->UseWorkArea(fLogicalVolumeOffset);
84 fpPhysicalVolumeSIM->UseWorkArea(fPhysicalVo 84 fpPhysicalVolumeSIM->UseWorkArea(fPhysicalVolumeOffset);
85 85
86 fpReplicaSIM->UseWorkArea(fReplicaOffset); 86 fpReplicaSIM->UseWorkArea(fReplicaOffset);
87 fpRegionSIM->UseWorkArea(fRegionOffset); 87 fpRegionSIM->UseWorkArea(fRegionOffset);
88 88
89 // When recycling a workspace 89 // When recycling a workspace
90 // - it must be a lightweight operation, t 90 // - it must be a lightweight operation, to reuse a valid work area
91 // - so it must NOT Initialise anything! 91 // - so it must NOT Initialise anything!
92 // Do not call InitialisePhysicalVolumes(); 92 // Do not call InitialisePhysicalVolumes();
93 } 93 }
94 94
95 // ------------------------------------------- 95 // ----------------------------------------------------------------------
96 // 96 //
97 void G4GeometryWorkspace::ReleaseWorkspace() 97 void G4GeometryWorkspace::ReleaseWorkspace()
98 { 98 {
99 fpLogicalVolumeSIM->UseWorkArea(nullptr); 99 fpLogicalVolumeSIM->UseWorkArea(nullptr);
100 fpPhysicalVolumeSIM->UseWorkArea(nullptr); 100 fpPhysicalVolumeSIM->UseWorkArea(nullptr);
101 101
102 fpReplicaSIM->UseWorkArea(nullptr); 102 fpReplicaSIM->UseWorkArea(nullptr);
103 fpRegionSIM->UseWorkArea(nullptr); 103 fpRegionSIM->UseWorkArea(nullptr);
104 } 104 }
105 105
106 // ------------------------------------------- 106 // ----------------------------------------------------------------------
107 // 107 //
108 void G4GeometryWorkspace::InitialisePhysicalVo 108 void G4GeometryWorkspace::InitialisePhysicalVolumes()
109 { 109 {
110 G4PhysicalVolumeStore* physVolStore = G4Phys 110 G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
111 for (auto physVol : *physVolStore) 111 for (auto physVol : *physVolStore)
112 { 112 {
113 G4LogicalVolume *logicalVol = physVol->Get 113 G4LogicalVolume *logicalVol = physVol->GetLogicalVolume();
114 114
115 // Use shadow pointer 115 // Use shadow pointer
116 // 116 //
117 G4VSolid* solid = logicalVol->GetMasterSol 117 G4VSolid* solid = logicalVol->GetMasterSolid();
118 auto g4PVReplica = dynamic_cast<G4PVReplic 118 auto g4PVReplica = dynamic_cast<G4PVReplica*>(physVol);
119 if (g4PVReplica == nullptr) 119 if (g4PVReplica == nullptr)
120 { 120 {
121 // Placement volume 121 // Placement volume
122 // 122 //
123 logicalVol->InitialiseWorker(logicalVol, 123 logicalVol->InitialiseWorker(logicalVol,solid,nullptr);
124 } 124 }
125 else 125 else
126 { 126 {
127 g4PVReplica->InitialiseWorker(g4PVReplic 127 g4PVReplica->InitialiseWorker(g4PVReplica);
128 logicalVol->InitialiseWorker(logicalVol, 128 logicalVol->InitialiseWorker(logicalVol,solid,nullptr);
129 129
130 // If the replica's solid (in LV) is cha 130 // If the replica's solid (in LV) is changed during navigation,
131 // it must be thread-private 131 // it must be thread-private
132 // 132 //
133 CloneReplicaSolid( g4PVReplica ); 133 CloneReplicaSolid( g4PVReplica );
134 } 134 }
135 } 135 }
136 } 136 }
137 137
138 // ------------------------------------------- 138 // ----------------------------------------------------------------------
139 // Create a clone of the solid for this replic 139 // Create a clone of the solid for this replica in this thread
140 // 140 //
141 G4bool G4GeometryWorkspace::CloneReplicaSolid( 141 G4bool G4GeometryWorkspace::CloneReplicaSolid( G4PVReplica* replicaPV )
142 { 142 {
143 G4LogicalVolume* logicalV = replicaPV->GetLo 143 G4LogicalVolume* logicalV = replicaPV->GetLogicalVolume();
144 G4VSolid* solid = logicalV->GetSolid(); 144 G4VSolid* solid = logicalV->GetSolid();
145 145
146 G4AutoLock aLock(&mutex_init); 146 G4AutoLock aLock(&mutex_init);
147 G4VSolid* workerSolid = solid->Clone(); 147 G4VSolid* workerSolid = solid->Clone();
148 aLock.unlock(); 148 aLock.unlock();
149 149
150 if( workerSolid != nullptr ) 150 if( workerSolid != nullptr )
151 { 151 {
152 logicalV->InitialiseWorker(logicalV,worker 152 logicalV->InitialiseWorker(logicalV,workerSolid,nullptr);
153 } 153 }
154 else 154 else
155 { 155 {
156 // In the case that not all solids support 156 // In the case that not all solids support(ed) the Clone()
157 // method, we do similar thing here to dyn 157 // method, we do similar thing here to dynamically cast
158 // and then get the clone method 158 // and then get the clone method
159 // 159 //
160 G4ExceptionDescription ed; 160 G4ExceptionDescription ed;
161 ed << "ERROR - Unable to initialise geomet 161 ed << "ERROR - Unable to initialise geometry for worker node." << "\n"
162 << "A solid lacks the Clone() method - 162 << "A solid lacks the Clone() method - or Clone() failed." << "\n"
163 << " Type of solid: " << solid->GetEn 163 << " Type of solid: " << solid->GetEntityType() << "\n"
164 << " Parameters: " << *solid; 164 << " Parameters: " << *solid;
165 G4Exception("G4GeometryWorkspace::CloneRep 165 G4Exception("G4GeometryWorkspace::CloneReplicaSolid()",
166 "GeomVol0003", FatalException, 166 "GeomVol0003", FatalException, ed);
167 return false; 167 return false;
168 } 168 }
169 return true; // It Worked 169 return true; // It Worked
170 } 170 }
171 171
172 // ------------------------------------------- 172 // ----------------------------------------------------------------------
173 // 173 //
174 void G4GeometryWorkspace::InitialiseWorkspace( 174 void G4GeometryWorkspace::InitialiseWorkspace()
175 { 175 {
176 // Geometry related, split classes mechanism 176 // Geometry related, split classes mechanism:
177 // Do *NOT* instantiate sub-instance for thi 177 // Do *NOT* instantiate sub-instance for this thread, just copy the contents!
178 // 178 //
179 fpLogicalVolumeSIM->SlaveCopySubInstanceArra 179 fpLogicalVolumeSIM->SlaveCopySubInstanceArray();
180 fpPhysicalVolumeSIM->SlaveCopySubInstanceArr 180 fpPhysicalVolumeSIM->SlaveCopySubInstanceArray();
181 fpReplicaSIM->SlaveCopySubInstanceArray(); 181 fpReplicaSIM->SlaveCopySubInstanceArray();
182 fpRegionSIM->SlaveInitializeSubInstance(); 182 fpRegionSIM->SlaveInitializeSubInstance();
183 183
184 InitialisePhysicalVolumes(); 184 InitialisePhysicalVolumes();
185 } 185 }
186 186
187 // ------------------------------------------- 187 // ----------------------------------------------------------------------
188 // 188 //
189 void G4GeometryWorkspace::DestroyWorkspace() 189 void G4GeometryWorkspace::DestroyWorkspace()
190 { 190 {
191 G4PhysicalVolumeStore* physVolStore = G4Phys 191 G4PhysicalVolumeStore* physVolStore = G4PhysicalVolumeStore::GetInstance();
192 for (auto physVol : *physVolStore) 192 for (auto physVol : *physVolStore)
193 { 193 {
194 G4LogicalVolume* logicalVol = physVol->Get 194 G4LogicalVolume* logicalVol = physVol->GetLogicalVolume();
195 auto g4PVReplica = dynamic_cast<G4PVReplic 195 auto g4PVReplica = dynamic_cast<G4PVReplica*>(physVol);
196 if (g4PVReplica != nullptr) 196 if (g4PVReplica != nullptr)
197 { 197 {
198 g4PVReplica->TerminateWorker(g4PVReplica 198 g4PVReplica->TerminateWorker(g4PVReplica);
199 } 199 }
200 logicalVol->TerminateWorker(logicalVol); 200 logicalVol->TerminateWorker(logicalVol);
201 } 201 }
202 202
203 // Threads may attempt to free memory simult 203 // Threads may attempt to free memory simultaneously.
204 // Need a lock to guarantee thread safety 204 // Need a lock to guarantee thread safety
205 // 205 //
206 G4AutoLock aLock(&mutex_init); 206 G4AutoLock aLock(&mutex_init);
207 fpLogicalVolumeSIM->FreeSlave(); 207 fpLogicalVolumeSIM->FreeSlave();
208 fpPhysicalVolumeSIM->FreeSlave(); 208 fpPhysicalVolumeSIM->FreeSlave();
209 fpReplicaSIM->FreeSlave(); 209 fpReplicaSIM->FreeSlave();
210 fpRegionSIM->FreeSlave(); 210 fpRegionSIM->FreeSlave();
211 aLock.unlock(); 211 aLock.unlock();
212 } 212 }
213 213