| 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 // This example is provided by the Geant4-DNA 26 // This example is provided by the Geant4-DNA collaboration
27 // Any report or published results obtained us 27 // Any report or published results obtained using the Geant4-DNA software
28 // shall cite the following Geant4-DNA collabo 28 // shall cite the following Geant4-DNA collaboration publication:
29 // Med. Phys. 37 (2010) 4692-4708 29 // Med. Phys. 37 (2010) 4692-4708
30 // and papers 30 // and papers
31 // M. Batmunkh et al. J Radiat Res Appl Sci 8 31 // M. Batmunkh et al. J Radiat Res Appl Sci 8 (2015) 498-507
32 // O. Belov et al. Physica Medica 32 (2016) 15 32 // O. Belov et al. Physica Medica 32 (2016) 1510-1520
33 // The Geant4-DNA web site is available at htt 33 // The Geant4-DNA web site is available at http://geant4-dna.org
34 // << 34 //
35 // ------------------------------------------- 35 // -------------------------------------------------------------------
36 // November 2016 36 // November 2016
37 // ------------------------------------------- 37 // -------------------------------------------------------------------
38 // 38 //
39 // 39 //
40 /// \file ITTrackingInteractivity.hh 40 /// \file ITTrackingInteractivity.hh
41 /// \brief Implementation of the ITTrackingInt 41 /// \brief Implementation of the ITTrackingInteractivity class
42 42
43 #include "ITTrackingInteractivity.hh" 43 #include "ITTrackingInteractivity.hh"
44 <<
45 #include "G4Event.hh" <<
46 #include "G4EventManager.hh" <<
47 #include "G4IT.hh" <<
48 #include "G4RichTrajectory.hh" <<
49 #include "G4SmoothTrajectory.hh" <<
50 #include "G4TrackingInformation.hh" 44 #include "G4TrackingInformation.hh"
>> 45 #include "G4VTrajectory.hh"
51 #include "G4Trajectory.hh" 46 #include "G4Trajectory.hh"
52 #include "G4UserSteppingAction.hh" << 47 #include "G4SmoothTrajectory.hh"
>> 48 #include "G4RichTrajectory.hh"
53 #include "G4UserTrackingAction.hh" 49 #include "G4UserTrackingAction.hh"
>> 50 #include "G4UserSteppingAction.hh"
>> 51 #include "G4IT.hh"
>> 52 #include "G4EventManager.hh"
>> 53 #include "G4Event.hh"
54 #include "G4VSteppingVerbose.hh" 54 #include "G4VSteppingVerbose.hh"
55 #include "G4VTrajectory.hh" <<
56 #include "G4VisManager.hh" 55 #include "G4VisManager.hh"
57 56
58 class G4Trajectory_Lock 57 class G4Trajectory_Lock
59 { 58 {
60 friend class ITTrackingInteractivity; << 59 friend class ITTrackingInteractivity;
61 60
62 G4Trajectory_Lock() : fpTrajectory(0) { ; << 61 G4Trajectory_Lock(): fpTrajectory(0)
>> 62 {;}
63 63
64 ~G4Trajectory_Lock() { ; } << 64 ~G4Trajectory_Lock()
>> 65 {;}
65 66
66 G4VTrajectory* fpTrajectory; << 67 G4VTrajectory* fpTrajectory;
67 }; 68 };
68 69
69 ITTrackingInteractivity::ITTrackingInteractivi 70 ITTrackingInteractivity::ITTrackingInteractivity()
70 { 71 {
71 fStoreTrajectory = 0; 72 fStoreTrajectory = 0;
72 fVerboseLevel = 0; 73 fVerboseLevel = 0;
73 74
74 fpUserTrackingAction = 0; << 75 fpUserTrackingAction = 0;
75 fpUserSteppingAction = 0; 76 fpUserSteppingAction = 0;
76 77
77 //////////////////////////// 78 ////////////////////////////
78 // In case you want to use same tracking/ste 79 // In case you want to use same tracking/stepping action
79 // for normal and IT stepping 80 // for normal and IT stepping
80 /* 81 /*
81 fpUserTrackingAction = 82 fpUserTrackingAction =
82 trackingManager->GetUserTrackingAction() 83 trackingManager->GetUserTrackingAction();
83 fpUserSteppingAction = 84 fpUserSteppingAction =
84 G4EventManager::GetEventManager()->GetUs 85 G4EventManager::GetEventManager()->GetUserSteppingAction();
85 */ 86 */
86 //////////////////////////// 87 ////////////////////////////
87 } 88 }
88 89
89 //....oooOO0OOooo........oooOO0OOooo........oo 90 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
90 91
91 ITTrackingInteractivity::~ITTrackingInteractiv 92 ITTrackingInteractivity::~ITTrackingInteractivity()
92 { 93 {
93 G4EventManager* eventManager = G4EventManage << 94 G4EventManager* eventManager =
>> 95 G4EventManager::GetEventManager();
94 96
95 if (eventManager) { << 97 if (eventManager)
96 G4UserTrackingAction* std_trackAct = event << 98 {
97 if (fpUserTrackingAction != std_trackAct & << 99 G4UserTrackingAction* std_trackAct =
98 << 100 eventManager->GetUserTrackingAction();
99 G4UserSteppingAction* std_stepAct = eventM << 101 if(fpUserTrackingAction != std_trackAct && fpUserTrackingAction)
100 if (fpUserSteppingAction != std_stepAct && << 102 delete fpUserTrackingAction;
>> 103
>> 104 G4UserSteppingAction* std_stepAct =
>> 105 eventManager->GetUserSteppingAction();
>> 106 if(fpUserSteppingAction != std_stepAct && fpUserSteppingAction)
>> 107 delete fpUserSteppingAction;
101 } 108 }
102 else { << 109 else
103 if (fpUserSteppingAction) { << 110 {
>> 111 if(fpUserSteppingAction)
>> 112 {
104 delete fpUserSteppingAction; 113 delete fpUserSteppingAction;
105 } 114 }
106 << 115
107 if (fpUserTrackingAction) { << 116 if(fpUserTrackingAction)
>> 117 {
108 delete fpUserTrackingAction; 118 delete fpUserTrackingAction;
109 } 119 }
110 } 120 }
111 } 121 }
112 122
113 //....oooOO0OOooo........oooOO0OOooo........oo 123 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
114 124
115 void ITTrackingInteractivity::Initialize() 125 void ITTrackingInteractivity::Initialize()
116 { 126 {
117 G4TrackingManager* trackingManager = G4Event << 127 G4TrackingManager* trackingManager =
>> 128 G4EventManager::GetEventManager()->GetTrackingManager();
118 fStoreTrajectory = trackingManager->GetStore 129 fStoreTrajectory = trackingManager->GetStoreTrajectory();
119 fVerboseLevel = trackingManager->GetVerboseL 130 fVerboseLevel = trackingManager->GetVerboseLevel();
120 } 131 }
121 132
122 //....oooOO0OOooo........oooOO0OOooo........oo 133 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
123 134
124 void ITTrackingInteractivity::StartTracking(G4 135 void ITTrackingInteractivity::StartTracking(G4Track* track)
125 { 136 {
126 #ifdef G4VERBOSE 137 #ifdef G4VERBOSE
127 if (fVerboseLevel) { << 138 if(fVerboseLevel)
>> 139 {
128 TrackBanner(track, "G4ITTrackingManager::S 140 TrackBanner(track, "G4ITTrackingManager::StartTracking : ");
129 } 141 }
130 #endif 142 #endif
131 143
132 if (fVerboseLevel > 0 && (G4VSteppingVerbose << 144 if(fVerboseLevel>0 && (G4VSteppingVerbose::GetSilent()!=1) )
>> 145 TrackBanner(track);
133 146
134 // Pre tracking user intervention process. 147 // Pre tracking user intervention process.
135 if (fpUserTrackingAction != 0) { << 148 if( fpUserTrackingAction != 0 ) {
136 fpUserTrackingAction->PreUserTrackingActio 149 fpUserTrackingAction->PreUserTrackingAction(track);
137 } 150 }
138 // #ifdef G4_STORE_TRAJECTORY << 151 //#ifdef G4_STORE_TRAJECTORY
139 G4TrackingInformation* trackingInfo = GetIT( 152 G4TrackingInformation* trackingInfo = GetIT(track)->GetTrackingInfo();
140 G4Trajectory_Lock* trajectory_lock = trackin << 153 G4Trajectory_Lock* trajectory_lock =
>> 154 trackingInfo->GetTrajectory_Lock();
141 155
142 // Construct a trajectory if it is requested 156 // Construct a trajectory if it is requested
143 if (fStoreTrajectory && (!trajectory_lock)) << 157 if(fStoreTrajectory&&(!trajectory_lock))
>> 158 {
144 trajectory_lock = new G4Trajectory_Lock(); 159 trajectory_lock = new G4Trajectory_Lock();
145 trackingInfo->SetTrajectory_Lock(trajector 160 trackingInfo->SetTrajectory_Lock(trajectory_lock);
146 G4VTrajectory* trajectory = 0; 161 G4VTrajectory* trajectory = 0;
147 // default trajectory concrete class objec 162 // default trajectory concrete class object
148 switch (fStoreTrajectory) { 163 switch (fStoreTrajectory) {
149 default: 164 default:
150 case 1: << 165 case 1: trajectory = new G4Trajectory(track); break;
151 trajectory = new G4Trajectory(track); << 166 case 2: trajectory = new G4SmoothTrajectory(track); break;
152 break; << 167 case 3: trajectory = new G4RichTrajectory(track); break;
153 case 2: <<
154 trajectory = new G4SmoothTrajectory(tr <<
155 break; <<
156 case 3: <<
157 trajectory = new G4RichTrajectory(trac <<
158 break; <<
159 } 168 }
160 trajectory_lock->fpTrajectory = trajectory 169 trajectory_lock->fpTrajectory = trajectory;
161 } 170 }
162 // #endif << 171 //#endif
163 } 172 }
164 173
165 //....oooOO0OOooo........oooOO0OOooo........oo 174 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
166 175
167 void ITTrackingInteractivity::AppendStep(G4Tra << 176 void
>> 177 ITTrackingInteractivity::AppendStep(G4Track* track, G4Step* step)
168 { 178 {
169 //////////////////////////// 179 ////////////////////////////
170 // If you want to use sensitive detector 180 // If you want to use sensitive detector
171 /* 181 /*
172 G4VPhysicalVolume* currentVolume = 182 G4VPhysicalVolume* currentVolume =
173 step->GetPreStepPoint()->GetPhysicalVolume 183 step->GetPreStepPoint()->GetPhysicalVolume();
174 G4SteppingControl stepControlFlag = step- 184 G4SteppingControl stepControlFlag = step->GetControlFlag();
175 185
176 if( currentVolume != 0 && stepControlFlag 186 if( currentVolume != 0 && stepControlFlag != AvoidHitInvocation)
177 { 187 {
178 G4VSensitiveDetector* sensitive = step 188 G4VSensitiveDetector* sensitive = step->GetPreStepPoint()->
179 GetSensitiveDetector(); 189 GetSensitiveDetector();
180 if( sensitive != 0 ) 190 if( sensitive != 0 )
181 { 191 {
182 sensitive->Hit(fpStep); 192 sensitive->Hit(fpStep);
183 } 193 }
184 } 194 }
185 */ 195 */
186 //////////////////////////// 196 ////////////////////////////
187 197
188 if (fpUserSteppingAction) fpUserSteppingActi << 198 if(fpUserSteppingAction)
>> 199 fpUserSteppingAction->UserSteppingAction(step);
189 200
190 //////////////////////////// 201 ////////////////////////////
191 // If you want to use regional stepping acti 202 // If you want to use regional stepping action
192 /* 203 /*
193 G4UserSteppingAction* regionalAction 204 G4UserSteppingAction* regionalAction
194 = fpStep->GetPreStepPoint()->GetPh 205 = fpStep->GetPreStepPoint()->GetPhysicalVolume()->
195 GetLogicalVolume()->GetRegio 206 GetLogicalVolume()->GetRegion()->
196 GetRegionalSteppingAction(); 207 GetRegionalSteppingAction();
197 if( regionalAction ) regionalAction->UserS 208 if( regionalAction ) regionalAction->UserSteppingAction(fpStep);
198 */ 209 */
199 //////////////////////////// 210 ////////////////////////////
200 211
201 if (fStoreTrajectory) { << 212 if(fStoreTrajectory)
202 G4TrackingInformation* trackingInfo = GetI << 213 {
203 G4Trajectory_Lock* trajectory_lock = track << 214 G4TrackingInformation* trackingInfo =
>> 215 GetIT(track)->GetTrackingInfo();
>> 216 G4Trajectory_Lock* trajectory_lock =
>> 217 trackingInfo->GetTrajectory_Lock();
204 trajectory_lock->fpTrajectory->AppendStep( 218 trajectory_lock->fpTrajectory->AppendStep(step);
205 } 219 }
206 } 220 }
207 221
208 //....oooOO0OOooo........oooOO0OOooo........oo 222 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
209 223
210 void ITTrackingInteractivity::EndTracking(G4Tr 224 void ITTrackingInteractivity::EndTracking(G4Track* track)
211 { 225 {
212 #ifdef G4VERBOSE 226 #ifdef G4VERBOSE
213 if (fVerboseLevel) { << 227 if(fVerboseLevel)
>> 228 {
214 TrackBanner(track, "G4ITTrackingManager::E 229 TrackBanner(track, "G4ITTrackingManager::EndTracking : ");
215 } 230 }
216 #endif 231 #endif
217 // Post tracking user intervention process. 232 // Post tracking user intervention process.
218 if (fpUserTrackingAction != 0) { << 233 if( fpUserTrackingAction != 0 ) {
219 fpUserTrackingAction->PostUserTrackingActi 234 fpUserTrackingAction->PostUserTrackingAction(track);
220 } 235 }
221 236
222 // #ifdef G4_STORE_TRAJECTORY << 237 //#ifdef G4_STORE_TRAJECTORY
223 G4TrackingInformation* trackingInfo = GetIT( << 238 G4TrackingInformation* trackingInfo =
224 G4Trajectory_Lock* trajectory_lock = trackin << 239 GetIT(track)->GetTrackingInfo();
>> 240 G4Trajectory_Lock* trajectory_lock =
>> 241 trackingInfo->GetTrajectory_Lock();
225 242
226 if (trajectory_lock) { << 243 if(trajectory_lock)
>> 244 {
227 G4VTrajectory*& trajectory = trajectory_lo 245 G4VTrajectory*& trajectory = trajectory_lock->fpTrajectory;
228 246
229 if (fStoreTrajectory && trajectory) { << 247 if(fStoreTrajectory && trajectory)
>> 248 {
>> 249
230 #ifdef G4VERBOSE 250 #ifdef G4VERBOSE
231 if (fVerboseLevel > 10) trajectory->Show << 251 if(fVerboseLevel>10) trajectory->ShowTrajectory();
232 #endif 252 #endif
233 G4TrackStatus istop = track->GetTrackSta 253 G4TrackStatus istop = track->GetTrackStatus();
234 254
235 if (trajectory && (istop != fStopButAliv << 255 if (trajectory && (istop != fStopButAlive) && (istop != fSuspend))
236 G4Event* currentEvent = G4EventManager << 256 {
>> 257 G4Event* currentEvent = G4EventManager::GetEventManager()
>> 258 ->GetNonconstCurrentEvent();
237 259
238 if (currentEvent) { << 260 if (currentEvent)
239 G4TrajectoryContainer* trajectoryCon << 261 {
>> 262 G4TrajectoryContainer* trajectoryContainer = currentEvent
>> 263 ->GetTrajectoryContainer();
240 264
241 if (!trajectoryContainer) { << 265 if (!trajectoryContainer)
>> 266 {
242 trajectoryContainer = new G4Trajec 267 trajectoryContainer = new G4TrajectoryContainer;
243 currentEvent->SetTrajectoryContain 268 currentEvent->SetTrajectoryContainer(trajectoryContainer);
244 } 269 }
245 trajectoryContainer->insert(trajecto 270 trajectoryContainer->insert(trajectory);
246 } 271 }
247 else { << 272 else
>> 273 {
248 fTrajectories.push_back(trajectory); 274 fTrajectories.push_back(trajectory);
249 } 275 }
250 } 276 }
251 } 277 }
252 // Destruct the trajectory if it was creat 278 // Destruct the trajectory if it was created
253 else if ((!fStoreTrajectory) && trajectory << 279 else if( (!fStoreTrajectory)&&trajectory ) {
254 delete trajectory; 280 delete trajectory;
255 trajectory = 0; 281 trajectory = 0;
256 } 282 }
257 delete trajectory_lock; 283 delete trajectory_lock;
258 trackingInfo->SetTrajectory_Lock(0); 284 trackingInfo->SetTrajectory_Lock(0);
259 } 285 }
260 // #endif << 286 //#endif
261 } 287 }
262 288
263 void ITTrackingInteractivity::Finalize() 289 void ITTrackingInteractivity::Finalize()
264 { 290 {
265 for (std::vector<G4VTrajectory*>::iterator i << 291 for (std::vector<G4VTrajectory*>::iterator it = fTrajectories.begin();
266 it++) << 292 it != fTrajectories.end(); it++)
267 { 293 {
268 G4VisManager::GetConcreteInstance()->Draw( 294 G4VisManager::GetConcreteInstance()->Draw(**it);
269 } 295 }
270 } 296 }
271 297