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