Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/management/src/G4ITStepProcessor.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/dna/management/src/G4ITStepProcessor.cc (Version 11.3.0) and /processes/electromagnetic/dna/management/src/G4ITStepProcessor.cc (Version 10.0.p1)


  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 // $Id: G4ITStepProcessor.cc 74551 2013-10-14 12:59:14Z gcosmo $
 26 //                                                 27 //
 27 // Author: Mathieu Karamitros (kara (AT) cenbg     28 // Author: Mathieu Karamitros (kara (AT) cenbg . in2p3 . fr) 
 28 //                                                 29 //
 29 // History:                                        30 // History:
 30 // -----------                                     31 // -----------
 31 // 10 Oct 2011 M.Karamitros created                32 // 10 Oct 2011 M.Karamitros created
 32 //                                                 33 //
 33 // -------------------------------------------     34 // -------------------------------------------------------------------
 34                                                    35 
 35 #include "G4ITStepProcessor.hh"                    36 #include "G4ITStepProcessor.hh"
 36                                                <<  37 #include "G4UImanager.hh"
 37 #include "G4ForceCondition.hh"                     38 #include "G4ForceCondition.hh"
 38 #include "G4GPILSelection.hh"                      39 #include "G4GPILSelection.hh"
 39 #include "G4GeometryTolerance.hh"              << 
 40 #include "G4IT.hh"                             << 
 41 #include "G4ITNavigator.hh"             // Inc << 
 42 #include "G4ITSteppingVerbose.hh"              << 
 43 #include "G4ITTrackHolder.hh"                  << 
 44 #include "G4ITTrackingInteractivity.hh"        << 
 45 #include "G4ITTrackingManager.hh"              << 
 46 #include "G4ITTransportation.hh"               << 
 47 #include "G4ITTransportationManager.hh"            40 #include "G4ITTransportationManager.hh"
                                                   >>  41 // #include "G4VSensitiveDetector.hh"    // Include from 'hits/digi'
                                                   >>  42 #include "G4GeometryTolerance.hh"
 48 #include "G4ParticleTable.hh"                      43 #include "G4ParticleTable.hh"
                                                   >>  44 #include "G4ITTrackingManager.hh"
 49 #include "G4TrackingInformation.hh"                45 #include "G4TrackingInformation.hh"
 50 #include "G4UImanager.hh"                      <<  46 #include "G4IT.hh"
                                                   >>  47 #include "G4ITNavigator.hh"             // Include from 'geometry'
                                                   >>  48 
 51 #include "G4VITProcess.hh"                         49 #include "G4VITProcess.hh"
 52 #include "G4VITSteppingVerbose.hh"             << 
 53 #include "G4VProcess.hh"                           50 #include "G4VProcess.hh"
                                                   >>  51 #include "G4ITTransportation.hh"
 54                                                    52 
 55 #include <iomanip>              // Include fro     53 #include <iomanip>              // Include from 'system'
 56 #include <vector>               // Include fro     54 #include <vector>               // Include from 'system'
 57                                                    55 
 58 using namespace std;                               56 using namespace std;
 59                                                    57 
 60 static const std::size_t SizeOfSelectedDoItVec <<  58 static const size_t SizeOfSelectedDoItVector=100;
                                                   >>  59 //static const size_t& gMaxNProcesses(G4VITProcess::GetMaxProcessIndex());
 61                                                    60 
 62 template<typename T>                           <<  61 //____________________________________________________________________________________
 63   inline bool IsInf(T value)                   << 
 64   {                                            << 
 65     return std::numeric_limits<T>::has_infinit << 
 66         && value == std::numeric_limits<T>::in << 
 67   }                                            << 
 68                                                << 
 69 //____________________________________________ << 
 70                                                    62 
 71 G4ITStepProcessor::G4ITStepProcessor()             63 G4ITStepProcessor::G4ITStepProcessor()
 72 {                                                  64 {
 73   fpVerbose = nullptr;                         <<  65     verboseLevel = 0 ;
 74   // fpUserSteppingAction = 0 ;                <<  66     //    fpUserSteppingAction = 0 ;
 75   fStoreTrajectory = 0;                        <<  67     fStoreTrajectory = 0;
 76   fpTrackingManager = nullptr;                 <<  68     fpTrackingManager = 0;
 77   fpNavigator = nullptr;                       <<  69     fpNavigator = 0;
 78   kCarTolerance = -1.;                         <<  70     kCarTolerance = -1.;
 79   fInitialized = false;                        <<  71     fInitialized = false;
 80   fPreviousTimeStep = DBL_MAX;                 <<  72     fPreviousTimeStep = DBL_MAX;
 81   fILTimeStep = DBL_MAX;                       <<  73     CleanProcessor();
 82   fpTrackContainer = nullptr;                  <<  74     ResetSecondaries();
 83                                                << 
 84   CleanProcessor();                            << 
 85   ResetSecondaries();                          << 
 86 }                                                  75 }
 87                                                    76 
 88 //____________________________________________ <<  77 G4ITStepProcessor::G4ITStepProcessorState::G4ITStepProcessorState() :
 89                                                << 
 90 //G4ITStepProcessor::                          << 
 91 G4ITStepProcessorState::G4ITStepProcessorState << 
 92     G4ITStepProcessorState_Lock(),                 78     G4ITStepProcessorState_Lock(),
 93     fSelectedAtRestDoItVector(G4VITProcess::Ge <<  79 //    fSelectedAtRestDoItVector (gMaxNProcesses,0),
 94     fSelectedPostStepDoItVector(G4VITProcess:: <<  80 //    fSelectedPostStepDoItVector (gMaxNProcesses,0)
                                                   >>  81     fSelectedAtRestDoItVector (G4VITProcess::GetMaxProcessIndex(),0),
                                                   >>  82     fSelectedPostStepDoItVector (G4VITProcess::GetMaxProcessIndex(),0)
 95 {                                                  83 {
 96   fPhysicalStep = -1.;                         <<  84     fPhysicalStep = -1.;
 97   fPreviousStepSize = -1.;                     <<  85     fPreviousStepSize = -1.;
 98                                                    86 
 99   fSafety = -1.;                               <<  87     fSafety = -1.;
100   fProposedSafety = -1.;                       <<  88     proposedSafety = -1.;
101   fEndpointSafety = -1;                        <<  89     endpointSafety = -1;
102                                                    90 
103   fStepStatus = fUndefined;                    <<  91     fStepStatus = fUndefined;
104                                                    92 
105   fTouchableHandle = nullptr;                  <<  93     fTouchableHandle = 0;
106 }                                                  94 }
107                                                    95 
108 //____________________________________________ <<  96 // should not be used
109                                                <<  97 G4ITStepProcessor::G4ITStepProcessorState::G4ITStepProcessorState(const G4ITStepProcessorState& ) :
110 //G4ITStepProcessor::                          << 
111 G4ITStepProcessorState::G4ITStepProcessorState << 
112     G4ITStepProcessorState_Lock(),                 98     G4ITStepProcessorState_Lock(),
113     fSelectedAtRestDoItVector(right.fSelectedA <<  99 //    fSelectedAtRestDoItVector (gMaxNProcesses,0),
114     fSelectedPostStepDoItVector(right.fSelecte << 100 //    fSelectedPostStepDoItVector (gMaxNProcesses,0)
                                                   >> 101     fSelectedAtRestDoItVector (G4VITProcess::GetMaxProcessIndex(),0),
                                                   >> 102     fSelectedPostStepDoItVector (G4VITProcess::GetMaxProcessIndex(),0)
115 {                                                 103 {
116   fPhysicalStep = right.fPhysicalStep;         << 104     fPhysicalStep = -1.;
117   fPreviousStepSize = right.fPreviousStepSize; << 105     fPreviousStepSize = -1.;
118                                                   106 
119   fSafety = right.fSafety;                     << 107     fSafety = -1.;
120   fProposedSafety = right.fProposedSafety;     << 108     proposedSafety = -1.;
121   fEndpointSafety = right.fEndpointSafety;     << 109     endpointSafety = -1;
122                                                   110 
123   fStepStatus = right.fStepStatus;             << 111     fStepStatus = fUndefined;
124                                                   112 
125   fTouchableHandle = right.fTouchableHandle;   << 113     fTouchableHandle = 0;
126 }                                                 114 }
127                                                   115 
128 //____________________________________________ << 116 // should not be used
129                                                << 117 G4ITStepProcessor::G4ITStepProcessorState&  G4ITStepProcessor::G4ITStepProcessorState::operator=(const G4ITStepProcessorState& rhs)
130 //G4ITStepProcessor::                          << 
131 G4ITStepProcessorState&                        << 
132 //G4ITStepProcessor::                          << 
133 G4ITStepProcessorState::operator=(const G4ITSt << 
134 {                                                 118 {
135   if(this == &right) return *this;             << 119     if(this == &rhs) return *this;
136                                                   120 
137   fSelectedAtRestDoItVector.clear();           << 121     fSelectedAtRestDoItVector.clear();
138   fSelectedAtRestDoItVector = right.fSelectedA << 122 //    fSelectedAtRestDoItVector.resize(gMaxNProcesses,0);
139   fSelectedPostStepDoItVector.clear();         << 123     fSelectedAtRestDoItVector.resize(G4VITProcess::GetMaxProcessIndex(),0);
140   fSelectedPostStepDoItVector = right.fSelecte << 124     fSelectedPostStepDoItVector.clear();
                                                   >> 125 //    fSelectedPostStepDoItVector.resize(gMaxNProcesses,0);
                                                   >> 126     fSelectedPostStepDoItVector.resize(G4VITProcess::GetMaxProcessIndex(),0);
141                                                   127 
142   fPhysicalStep = right.fPhysicalStep;         << 128     fPhysicalStep = -1.;
143   fPreviousStepSize = right.fPreviousStepSize; << 129     fPreviousStepSize = -1.;
144                                                   130 
145   fSafety = right.fSafety;                     << 131     fSafety = -1.;
146   fProposedSafety = right.fProposedSafety;     << 132     proposedSafety = -1.;
147   fEndpointSafety = right.fEndpointSafety;     << 133     endpointSafety = -1;
148                                                   134 
149   fStepStatus = right.fStepStatus;             << 135     fStepStatus = fUndefined;
150                                                   136 
151   fTouchableHandle = right.fTouchableHandle;   << 137     fTouchableHandle = 0;
152   return *this;                                << 138     return *this;
153 }                                                 139 }
                                                   >> 140 //____________________________________________________________________________________
154                                                   141 
155 //____________________________________________ << 142 G4ITStepProcessor::G4ITStepProcessorState::~G4ITStepProcessorState()
156                                                << 143 {;}
157 //G4ITStepProcessor::                          << 144 //____________________________________________________________________________________
158 G4ITStepProcessorState::~G4ITStepProcessorStat << 
159 {                                              << 
160   ;                                            << 
161 }                                              << 
162                                                << 
163 //____________________________________________ << 
164                                                   145 
165 void G4ITStepProcessor::ClearProcessInfo()        146 void G4ITStepProcessor::ClearProcessInfo()
166 {                                                 147 {
167   std::map<const G4ParticleDefinition*, Proces << 148     std::map<const G4ParticleDefinition*, ProcessGeneralInfo*> ::iterator it;
168                                                   149 
169   for(it = fProcessGeneralInfoMap.begin(); it  << 150     for(it = fProcessGeneralInfoMap.begin();it != fProcessGeneralInfoMap.end();it++)
170       it++)                                    << 
171   {                                            << 
172     if(it->second != nullptr)                  << 
173     {                                             151     {
174       delete it->second;                       << 152         if(it->second)
175       it->second = 0;                          << 153         {
                                                   >> 154             delete it->second;
                                                   >> 155             it->second = 0;
                                                   >> 156         }
176     }                                             157     }
177   }                                            << 
178                                                   158 
179   fProcessGeneralInfoMap.clear();              << 159     fProcessGeneralInfoMap.clear();
180 }                                                 160 }
181                                                   161 
182 //____________________________________________ << 162 //____________________________________________________________________________________
183                                                   163 
184 void G4ITStepProcessor::ForceReInitialization(    164 void G4ITStepProcessor::ForceReInitialization()
185 {                                                 165 {
186   fInitialized = false;                        << 166     fInitialized = false;
187   ClearProcessInfo();                          << 167     ClearProcessInfo();
188   Initialize();                                << 168     Initialize();
189 }                                                 169 }
190                                                   170 
191 //____________________________________________ << 171 //____________________________________________________________________________________
192                                                   172 
193 void G4ITStepProcessor::Initialize()              173 void G4ITStepProcessor::Initialize()
194 {                                                 174 {
195   CleanProcessor();                            << 175     CleanProcessor();
196   if(fInitialized) return;                     << 176     if(fInitialized) return;
197   //    ActiveOnlyITProcess();                 << 177     //    ActiveOnlyITProcess();
198                                                << 
199   SetNavigator(G4ITTransportationManager::GetT << 
200       ->GetNavigatorForTracking());            << 
201                                                << 
202   fPhysIntLength = DBL_MAX;                    << 
203   kCarTolerance = 0.5                          << 
204       * G4GeometryTolerance::GetInstance()->Ge << 
205                                                << 
206   if(fpVerbose == nullptr)                     << 
207   {                                            << 
208     G4ITTrackingInteractivity* interactivity = << 
209                                                   178 
210     if(interactivity != nullptr)               << 179     SetNavigator(G4ITTransportationManager::GetTransportationManager()
211     {                                          << 180                  ->GetNavigatorForTracking());
212       fpVerbose = interactivity->GetSteppingVe << 
213       fpVerbose->SetStepProcessor(this);       << 
214     }                                          << 
215   }                                            << 
216                                                   181 
217   fpTrackContainer = G4ITTrackHolder::Instance << 182     fPhysIntLength = DBL_MAX;
                                                   >> 183     kCarTolerance = 0.5*G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
218                                                   184 
219   fInitialized = true;                         << 185     fInitialized = true;
220 }                                                 186 }
221 //____________________________________________    187 //______________________________________________________________________________
222                                                   188 
223 G4ITStepProcessor::~G4ITStepProcessor()           189 G4ITStepProcessor::~G4ITStepProcessor()
224 {                                                 190 {
225   if(fpStep != nullptr)                        << 191     if(fpStep)
226   {                                            << 192     {
227     fpStep->DeleteSecondaryVector();           << 193         fpStep->DeleteSecondaryVector();
228     delete fpStep;                             << 194         delete fpStep;
229   }                                            << 195     }
230                                                << 
231   delete fpSecondary;                          << 
232   ClearProcessInfo();                          << 
233   //G4ITTransportationManager::DeleteInstance( << 
234                                                   196 
235   //    if(fpUserSteppingAction)             d << 197     if(fpSecondary)                      delete fpSecondary;
                                                   >> 198     ClearProcessInfo();
                                                   >> 199     G4ITTransportationManager::DeleteInstance();
                                                   >> 200 
                                                   >> 201     //    if(fpUserSteppingAction)             delete fpUserSteppingAction;
236 }                                                 202 }
237 //____________________________________________    203 //______________________________________________________________________________
238 // should not be used                             204 // should not be used
239 G4ITStepProcessor::G4ITStepProcessor(const G4I    205 G4ITStepProcessor::G4ITStepProcessor(const G4ITStepProcessor& rhs)
240 {                                                 206 {
241   fpVerbose = rhs.fpVerbose;                   << 207     verboseLevel = rhs.verboseLevel ;
242   fStoreTrajectory = rhs.fStoreTrajectory;     << 208     fStoreTrajectory = rhs.fStoreTrajectory ;
243                                                << 
244   //    fpUserSteppingAction = 0 ;             << 
245   fpTrackingManager = nullptr;                 << 
246   fpNavigator = nullptr;                       << 
247   fInitialized = false;                        << 
248                                                << 
249   kCarTolerance = rhs.kCarTolerance;           << 
250   fInitialized = false;                        << 
251   fPreviousTimeStep = DBL_MAX;                 << 
252                                                << 
253   CleanProcessor();                            << 
254   ResetSecondaries();                          << 
255   fpTrackContainer = nullptr;                  << 
256   fILTimeStep = DBL_MAX;                       << 
257 }                                              << 
258                                                   209 
259 //____________________________________________ << 210     //    fpUserSteppingAction = 0 ;
260                                                << 211     fpTrackingManager = 0;
261 void G4ITStepProcessor::ResetLeadingTracks()   << 212     fpNavigator = 0;
262 {                                              << 213     fInitialized = false;
263   fLeadingTracks.Reset();                      << 214 
264 }                                              << 215     kCarTolerance = rhs.kCarTolerance;
265                                                << 216     fInitialized = false;
266 //____________________________________________ << 217     fPreviousTimeStep = DBL_MAX;
267                                                   218 
268 void G4ITStepProcessor::PrepareLeadingTracks() << 219     CleanProcessor();
269 {                                              << 220     ResetSecondaries();
270   fLeadingTracks.PrepareLeadingTracks();       << 
271 }                                                 221 }
272                                                << 
273 //____________________________________________    222 //______________________________________________________________________________
274                                                   223 
275 G4ITStepProcessor& G4ITStepProcessor::operator    224 G4ITStepProcessor& G4ITStepProcessor::operator=(const G4ITStepProcessor& rhs)
276 {                                                 225 {
277   if(this == &rhs) return *this; // handle sel << 226     if (this == &rhs) return *this; // handle self assignment
278   //assignment operator                        << 227     //assignment operator
279   return *this;                                << 228     return *this;
280 }                                                 229 }
281                                                << 230 // ******************************************************************
282 //____________________________________________ << 
283                                                   231 
284 void G4ITStepProcessor::ActiveOnlyITProcess()     232 void G4ITStepProcessor::ActiveOnlyITProcess()
285 {                                                 233 {
286   // Method not used for the time being        << 234     // Method not used for the time being
287 #ifdef debug                                      235 #ifdef debug
288   G4cout<<"G4ITStepProcessor::CloneProcesses:  << 236     G4cout<<"G4ITStepProcessor::CloneProcesses: is called"<<G4endl;
289 #endif                                            237 #endif
290                                                   238 
291   G4ParticleTable* theParticleTable = G4Partic << 239     G4ParticleTable* theParticleTable = G4ParticleTable::GetParticleTable();
292   G4ParticleTable::G4PTblDicIterator* theParti << 240     G4ParticleTable::G4PTblDicIterator* theParticleIterator = theParticleTable->GetIterator();
293       ->GetIterator();                         << 
294                                                << 
295   theParticleIterator->reset();                << 
296   // TODO : Ne faire la boucle que sur les IT  << 
297   while((*theParticleIterator)())              << 
298   {                                            << 
299     G4ParticleDefinition* particle = thePartic << 
300     G4ProcessManager* pm = particle->GetProces << 
301                                                << 
302     if(pm == nullptr)                          << 
303     {                                          << 
304       G4cerr << "ERROR - G4ITStepProcessor::Ge << 
305       << particle->GetParticleName() << ", PDG << 
306       << particle->GetPDGEncoding() << G4endl; << 
307       G4Exception("G4ITStepProcessor::GetProce << 
308           FatalException, "Process Manager is  << 
309       return;                                  << 
310     }                                          << 
311                                                   241 
312     ActiveOnlyITProcess(pm);                   << 242     theParticleIterator->reset();
313   }                                            << 243     // TODO : Ne faire la boucle que sur les IT **** !!!
314 }                                              << 244     while( (*theParticleIterator)() )
                                                   >> 245     {
                                                   >> 246         G4ParticleDefinition* particle = theParticleIterator->value();
                                                   >> 247         G4ProcessManager* pm= particle->GetProcessManager();
315                                                   248 
316 //____________________________________________ << 249         if(!pm)
                                                   >> 250         {
                                                   >> 251             G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
                                                   >> 252                    << "        ProcessManager is NULL for particle = "
                                                   >> 253                    << particle->GetParticleName() << ", PDG_code = "
                                                   >> 254                    << particle->GetPDGEncoding() << G4endl;
                                                   >> 255             G4Exception("G4ITStepProcessor::GetProcessNumber()", "ITStepProcessor0001",
                                                   >> 256                         FatalException, "Process Manager is not found.");
                                                   >> 257             return;
                                                   >> 258         }
                                                   >> 259 
                                                   >> 260         ActiveOnlyITProcess(pm);
                                                   >> 261     }
                                                   >> 262 }
                                                   >> 263 // ******************************************************************
317                                                   264 
318 void G4ITStepProcessor::ActiveOnlyITProcess(G4    265 void G4ITStepProcessor::ActiveOnlyITProcess(G4ProcessManager* processManager)
319 {                                                 266 {
320   // Method not used for the time being        << 267     // Method not used for the time being
321   G4ProcessVector* processVector = processMana << 268     G4ProcessVector* processVector = processManager->GetProcessList();
322                                                << 
323   G4VITProcess* itProcess = nullptr;           << 
324   for(G4int i = 0; i < (G4int)processVector->s << 
325   {                                            << 
326     G4VProcess* base_process = (*processVector << 
327     itProcess = dynamic_cast<G4VITProcess*>(ba << 
328                                                   269 
329     if(itProcess == nullptr)                   << 270     G4VITProcess* itProcess = 0 ;
                                                   >> 271     for(int i = 0 ; i < processVector->size() ; i++)
330     {                                             272     {
331       processManager->SetProcessActivation(bas << 273         G4VProcess* base_process = (*processVector)[i];
                                                   >> 274         itProcess = dynamic_cast<G4VITProcess*>(base_process);
                                                   >> 275 
                                                   >> 276         if(!itProcess)
                                                   >> 277         {
                                                   >> 278             processManager->SetProcessActivation(base_process, false);
                                                   >> 279         }
332     }                                             280     }
333   }                                            << 
334 }                                                 281 }
335                                                << 282 // ******************************************************************
336 //____________________________________________ << 
337                                                << 
338 void G4ITStepProcessor::SetupGeneralProcessInf    283 void G4ITStepProcessor::SetupGeneralProcessInfo(G4ParticleDefinition* particle,
339                                                   284                                                 G4ProcessManager* pm)
340 {                                                 285 {
341                                                   286 
342 #ifdef debug                                      287 #ifdef debug
343   G4cout<<"G4ITStepProcessor::GetProcessNumber << 288     G4cout<<"G4ITStepProcessor::GetProcessNumber: is called track"<<G4endl;
344 #endif                                            289 #endif
345   if(pm == nullptr)                            << 290     if(!pm)
346   {                                            << 291     {
347     G4cerr << "ERROR - G4SteppingManager::GetP << 292         G4cerr << "ERROR - G4SteppingManager::GetProcessNumber()" << G4endl
348     << particle->GetParticleName() << ", PDG_c << 293                << "        ProcessManager is NULL for particle = "
349     << particle->GetPDGEncoding() << G4endl;   << 294                << particle->GetParticleName() << ", PDG_code = "
350     G4Exception("G4SteppingManager::GetProcess << 295                << particle->GetPDGEncoding() << G4endl;
351         FatalException, "Process Manager is no << 296         G4Exception("G4SteppingManager::GetProcessNumber()", "ITStepProcessor0002",
352     return;                                    << 297                     FatalException, "Process Manager is not found.");
353   }                                            << 298         return;
354                                                << 299     }
355   auto it =                                    << 300 
356   fProcessGeneralInfoMap.find(particle);       << 301     std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it = fProcessGeneralInfoMap.find(particle);
357   if(it != fProcessGeneralInfoMap.end())       << 302     if(it != fProcessGeneralInfoMap.end())
358   {                                            << 303     {
359     G4Exception("G4SteppingManager::SetupGener << 304         G4Exception("G4SteppingManager::SetupGeneralProcessInfo()", "ITStepProcessor0003",
360         "ITStepProcessor0003",                 << 305                     FatalException, "Process info already registered.");
361         FatalException, "Process info already  << 306         return;
362     return;                                    << 307     }
363   }                                            << 308 
364                                                << 309     // here used as temporary
365   // here used as temporary                    << 310     fpProcessInfo = new ProcessGeneralInfo();
366   fpProcessInfo = new ProcessGeneralInfo();    << 311 
367                                                << 312     // AtRestDoits
368   // AtRestDoits                               << 313     fpProcessInfo->MAXofAtRestLoops =        pm->GetAtRestProcessVector()->entries();
369   fpProcessInfo->MAXofAtRestLoops = pm->GetAtR << 314     fpProcessInfo->fpAtRestDoItVector =       pm->GetAtRestProcessVector(typeDoIt);
370   fpProcessInfo->fpAtRestDoItVector = pm->GetA << 315     fpProcessInfo->fpAtRestGetPhysIntVector = pm->GetAtRestProcessVector(typeGPIL);
371   fpProcessInfo->fpAtRestGetPhysIntVector =    << 
372   pm->GetAtRestProcessVector(typeGPIL);        << 
373 #ifdef debug                                      316 #ifdef debug
374   G4cout << "G4ITStepProcessor::GetProcessNumb << 317     G4cout << "G4ITStepProcessor::GetProcessNumber: #ofAtRest="
375   << fpProcessInfo->MAXofAtRestLoops << G4endl << 318            << fpProcessInfo->MAXofAtRestLoops << G4endl;
376 #endif                                            319 #endif
377                                                   320 
378   // AlongStepDoits                            << 321     // AlongStepDoits
379   fpProcessInfo->MAXofAlongStepLoops =         << 322     fpProcessInfo->MAXofAlongStepLoops = pm->GetAlongStepProcessVector()->entries();
380   pm->GetAlongStepProcessVector()->entries();  << 323     fpProcessInfo->fpAlongStepDoItVector = pm->GetAlongStepProcessVector(typeDoIt);
381   fpProcessInfo->fpAlongStepDoItVector =       << 324     fpProcessInfo->fpAlongStepGetPhysIntVector = pm->GetAlongStepProcessVector(typeGPIL);
382   pm->GetAlongStepProcessVector(typeDoIt);     << 
383   fpProcessInfo->fpAlongStepGetPhysIntVector = << 
384   pm->GetAlongStepProcessVector(typeGPIL);     << 
385 #ifdef debug                                      325 #ifdef debug
386   G4cout << "G4ITStepProcessor::GetProcessNumb << 326     G4cout << "G4ITStepProcessor::GetProcessNumber:#ofAlongStp="
387   << fpProcessInfo->MAXofAlongStepLoops << G4e << 327            << fpProcessInfo->MAXofAlongStepLoops << G4endl;
388 #endif                                            328 #endif
389                                                   329 
390   // PostStepDoits                             << 330     // PostStepDoits
391   fpProcessInfo->MAXofPostStepLoops =          << 331     fpProcessInfo->MAXofPostStepLoops = pm->GetPostStepProcessVector()->entries();
392   pm->GetPostStepProcessVector()->entries();   << 332     fpProcessInfo->fpPostStepDoItVector = pm->GetPostStepProcessVector(typeDoIt);
393   fpProcessInfo->fpPostStepDoItVector = pm->Ge << 333     fpProcessInfo->fpPostStepGetPhysIntVector = pm->GetPostStepProcessVector(typeGPIL);
394   fpProcessInfo->fpPostStepGetPhysIntVector =  << 
395   pm->GetPostStepProcessVector(typeGPIL);      << 
396 #ifdef debug                                      334 #ifdef debug
397   G4cout << "G4ITStepProcessor::GetProcessNumb << 335     G4cout << "G4ITStepProcessor::GetProcessNumber: #ofPostStep="
398   << fpProcessInfo->MAXofPostStepLoops << G4en << 336            << fpProcessInfo->MAXofPostStepLoops << G4endl;
399 #endif                                            337 #endif
400                                                   338 
401   if (SizeOfSelectedDoItVector<fpProcessInfo-> << 339     if (SizeOfSelectedDoItVector<fpProcessInfo->MAXofAtRestLoops    ||
402       SizeOfSelectedDoItVector<fpProcessInfo-> << 340             SizeOfSelectedDoItVector<fpProcessInfo->MAXofAlongStepLoops ||
403       SizeOfSelectedDoItVector<fpProcessInfo-> << 341             SizeOfSelectedDoItVector<fpProcessInfo->MAXofPostStepLoops  )
404   {                                            << 342     {
405     G4cerr << "ERROR - G4ITStepProcessor::GetP << 343         G4cerr << "ERROR - G4ITStepProcessor::GetProcessNumber()" << G4endl
406     << "        SizeOfSelectedDoItVector= " << << 344                << "        SizeOfSelectedDoItVector= " << SizeOfSelectedDoItVector
407     << " ; is smaller then one of MAXofAtRestL << 345                << " ; is smaller then one of MAXofAtRestLoops= "
408     << fpProcessInfo->MAXofAtRestLoops << G4en << 346                << fpProcessInfo->MAXofAtRestLoops << G4endl
409     << "        or MAXofAlongStepLoops= " << f << 347                << "        or MAXofAlongStepLoops= " << fpProcessInfo->MAXofAlongStepLoops
410     << " or MAXofPostStepLoops= " << fpProcess << 348                << " or MAXofPostStepLoops= " << fpProcessInfo->MAXofPostStepLoops << G4endl;
411     G4Exception("G4ITStepProcessor::GetProcess << 349         G4Exception("G4ITStepProcessor::GetProcessNumber()",
412         "ITStepProcessor0004", FatalException, << 350                     "ITStepProcessor0004", FatalException,
413         "The array size is smaller than the ac << 351                     "The array size is smaller than the actual No of processes.");
414   }                                            << 352     }
415                                                << 353 
416   if((fpProcessInfo->fpAtRestDoItVector == nul << 354     if(!fpProcessInfo->fpAtRestDoItVector   &&
417       (fpProcessInfo->fpAlongStepDoItVector == << 355             !fpProcessInfo->fpAlongStepDoItVector    &&
418       (fpProcessInfo->fpPostStepDoItVector ==  << 356             !fpProcessInfo->fpPostStepDoItVector)
419   {                                            << 357     {
420     G4ExceptionDescription exceptionDescriptio << 358         G4ExceptionDescription exceptionDescription ;
421     exceptionDescription << "No DoIt process f << 359         exceptionDescription << "No DoIt process found " ;
422     G4Exception("G4ITStepProcessor::DoStepping << 360         G4Exception("G4ITStepProcessor::DoStepping","ITStepProcessor0005",
423         FatalErrorInArgument,exceptionDescript << 361                     FatalErrorInArgument,exceptionDescription);
424     return;                                    << 362         return ;
425   }                                            << 363     }
426                                                << 364 
427   if((fpProcessInfo->fpAlongStepGetPhysIntVect << 365     if(fpProcessInfo->fpAlongStepGetPhysIntVector && fpProcessInfo->MAXofAlongStepLoops>0)
428       && fpProcessInfo->MAXofAlongStepLoops>0) << 366     {
429   {                                            << 367         fpProcessInfo->fpTransportation = dynamic_cast<G4ITTransportation*>
430     fpProcessInfo->fpTransportation = dynamic_ << 368                 ((*fpProcessInfo->fpAlongStepGetPhysIntVector)[fpProcessInfo->MAXofAlongStepLoops-1]);
431     ((*fpProcessInfo->fpAlongStepGetPhysIntVec << 369 
432         [G4int(fpProcessInfo->MAXofAlongStepLo << 370         if(fpProcessInfo->fpTransportation == 0)
433                                                << 371         {
434     if(fpProcessInfo->fpTransportation == null << 372             G4ExceptionDescription exceptionDescription ;
435     {                                          << 373             exceptionDescription << "No transportation process found " ;
436       G4ExceptionDescription exceptionDescript << 374             G4Exception("G4ITStepProcessor::SetupGeneralProcessInfo","ITStepProcessor0006",
437       exceptionDescription << "No transportati << 375                         FatalErrorInArgument,exceptionDescription);
438       G4Exception("G4ITStepProcessor::SetupGen << 376         }
439           "ITStepProcessor0006",               << 377     }
440           FatalErrorInArgument,exceptionDescri << 378     fProcessGeneralInfoMap[particle] = fpProcessInfo;
441     }                                          << 379     //    fpProcessInfo = 0;
442   }                                            << 
443   fProcessGeneralInfoMap[particle] = fpProcess << 
444   //    fpProcessInfo = 0;                     << 
445 }                                                 380 }
446                                                   381 
447 //____________________________________________ << 382 // ******************************************************************
448                                                   383 
449 void G4ITStepProcessor::SetTrack(G4Track* trac    384 void G4ITStepProcessor::SetTrack(G4Track* track)
450 {                                                 385 {
451   fpTrack = track;                             << 386     fpTrack = track ;
452   if(fpTrack != nullptr)                       << 387     if(fpTrack)
453   {                                            << 
454     fpITrack = GetIT(fpTrack);                 << 
455     fpStep = const_cast<G4Step*>(fpTrack->GetS << 
456                                                << 
457     if(fpITrack != nullptr)                    << 
458     {                                             388     {
459       fpTrackingInfo = fpITrack->GetTrackingIn << 389         fpITrack = GetIT(fpTrack) ;
                                                   >> 390         fpStep = const_cast<G4Step*>(fpTrack -> GetStep());
                                                   >> 391 
                                                   >> 392         if(fpITrack)
                                                   >> 393         {
                                                   >> 394             fpTrackingInfo = fpITrack->GetTrackingInfo() ;
                                                   >> 395         }
                                                   >> 396         else
                                                   >> 397         {
                                                   >> 398             fpTrackingInfo = 0;
                                                   >> 399             G4cerr << "Track ID : " << fpTrack->GetTrackID() << G4endl;
                                                   >> 400 
                                                   >> 401             G4ExceptionDescription exceptionDescription ("No IT pointer was attached to the track you try to process.");
                                                   >> 402             G4Exception("G4ITStepProcessor::SetTrack","ITStepProcessor0007",
                                                   >> 403                         FatalErrorInArgument,exceptionDescription);
                                                   >> 404         }
460     }                                             405     }
461     else                                          406     else
462     {                                             407     {
463       fpTrackingInfo = nullptr;                << 408         fpITrack = 0;
464       G4cerr << "Track ID : " << fpTrack->GetT << 409         fpStep = 0 ;
465                                                << 410     }
466       G4ExceptionDescription errMsg;           << 
467       errMsg << "No IT pointer was attached to << 
468       G4Exception("G4ITStepProcessor::SetTrack << 
469                   "ITStepProcessor0007",       << 
470                   FatalErrorInArgument,        << 
471                   errMsg);                     << 
472     }                                          << 
473   }                                            << 
474   else                                         << 
475   {                                            << 
476     fpITrack = nullptr;                        << 
477     fpStep = nullptr;                          << 
478   }                                            << 
479 }                                                 411 }
480 //____________________________________________    412 //______________________________________________________________________________
481                                                   413 
482 void G4ITStepProcessor::GetProcessInfo()          414 void G4ITStepProcessor::GetProcessInfo()
483 {                                                 415 {
484   G4ParticleDefinition* particle = fpTrack->Ge << 416     G4ParticleDefinition* particle = fpTrack->GetDefinition();
485   auto it =                                    << 417     std::map<const G4ParticleDefinition*, ProcessGeneralInfo*>::iterator it = fProcessGeneralInfoMap.find(particle);
486       fProcessGeneralInfoMap.find(particle);   << 
487                                                << 
488   if(it == fProcessGeneralInfoMap.end())       << 
489   {                                            << 
490     SetupGeneralProcessInfo(particle,          << 
491                             fpTrack->GetDefini << 
492     if(fpProcessInfo == nullptr)               << 
493     {                                          << 
494       G4ExceptionDescription exceptionDescript << 
495       G4Exception("G4ITStepProcessor::GetProce << 
496                   "ITStepProcessor0008",       << 
497                   FatalErrorInArgument,        << 
498                   exceptionDescription);       << 
499       return;                                  << 
500     }                                          << 
501   }                                            << 
502   else                                         << 
503   {                                            << 
504     fpProcessInfo = it->second;                << 
505   }                                            << 
506 }                                              << 
507                                                   418 
                                                   >> 419     if(it == fProcessGeneralInfoMap.end())
                                                   >> 420     {
                                                   >> 421         SetupGeneralProcessInfo(particle,fpTrack->GetDefinition()->GetProcessManager());
                                                   >> 422         if(fpProcessInfo == 0)
                                                   >> 423         {
                                                   >> 424             G4ExceptionDescription exceptionDescription ("...");
                                                   >> 425             G4Exception("G4ITStepProcessor::GetProcessNumber","ITStepProcessor0008",
                                                   >> 426                         FatalErrorInArgument,exceptionDescription);
                                                   >> 427             return;
                                                   >> 428         }
                                                   >> 429     }
                                                   >> 430     else
                                                   >> 431     {
                                                   >> 432         fpProcessInfo = it->second;
                                                   >> 433     }
                                                   >> 434 }
508 //____________________________________________    435 //______________________________________________________________________________
509                                                   436 
510 void G4ITStepProcessor::SetupMembers()            437 void G4ITStepProcessor::SetupMembers()
511 {                                                 438 {
512   fpSecondary = fpStep->GetfSecondary();       << 439     fpSecondary      = fpStep->GetfSecondary();
513   fpPreStepPoint = fpStep->GetPreStepPoint();  << 440     fpPreStepPoint   = fpStep->GetPreStepPoint();
514   fpPostStepPoint = fpStep->GetPostStepPoint() << 441     fpPostStepPoint  = fpStep->GetPostStepPoint();
515                                                   442 
516   fpState = (G4ITStepProcessorState*) fpITrack << 443     fpState = (G4ITStepProcessorState*) fpITrack->GetTrackingInfo()->GetStepProcessorState();
517       ->GetStepProcessorState();               << 
518                                                   444 
519   GetProcessInfo();                            << 445     GetProcessInfo();
520   ResetSecondaries();                          << 446     ResetSecondaries();
521 }                                                 447 }
522                                                << 
523 //____________________________________________    448 //______________________________________________________________________________
524                                                   449 
525 void G4ITStepProcessor::ResetSecondaries()        450 void G4ITStepProcessor::ResetSecondaries()
526 {                                                 451 {
527   // Reset the secondary particles             << 452     // Reset the secondary particles
528   fN2ndariesAtRestDoIt = 0;                    << 453     fN2ndariesAtRestDoIt    = 0;
529   fN2ndariesAlongStepDoIt = 0;                 << 454     fN2ndariesAlongStepDoIt = 0;
530   fN2ndariesPostStepDoIt = 0;                  << 455     fN2ndariesPostStepDoIt  = 0;
531 }                                                 456 }
532                                                << 
533 //____________________________________________    457 //______________________________________________________________________________
534                                                   458 
535 void G4ITStepProcessor::GetAtRestIL()             459 void G4ITStepProcessor::GetAtRestIL()
536 {                                                 460 {
537   // Select the rest process which has the sho << 461     // Select the rest process which has the shortest time before
538   // it is invoked. In rest processes, GPIL()  << 462     // it is invoked. In rest processes, GPIL()
539   // returns the time before a process occurs. << 463     // returns the time before a process occurs.
540   G4double lifeTime(DBL_MAX), shortestLifeTime << 464     G4double lifeTime (DBL_MAX), shortestLifeTime (DBL_MAX);
541                                                   465 
542   fAtRestDoItProcTriggered = 0;                << 466     fAtRestDoItProcTriggered = 0;
543   shortestLifeTime = DBL_MAX;                  << 467     shortestLifeTime = DBL_MAX;
544                                                   468 
545   unsigned int NofInactiveProc=0;              << 469     unsigned int NofInactiveProc=0;
546                                                   470 
547   for( G4int ri=0; ri < (G4int)fpProcessInfo-> << 471     for( size_t ri=0 ; ri < fpProcessInfo->MAXofAtRestLoops ; ri++ )
548   {                                            << 
549     fpCurrentProcess = dynamic_cast<G4VITProce << 
550     if (fpCurrentProcess== nullptr)            << 
551     {                                             472     {
552       (fpState->fSelectedAtRestDoItVector)[ri] << 473         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAtRestGetPhysIntVector)[ri];
553       NofInactiveProc++;                       << 474         if (fpCurrentProcess== 0)
554       continue;                                << 475         {
555     } // NULL means the process is inactivated << 476             (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
                                                   >> 477             NofInactiveProc++;
                                                   >> 478             continue;
                                                   >> 479         }   // NULL means the process is inactivated by a user on fly.
                                                   >> 480 
                                                   >> 481         fCondition=NotForced;
                                                   >> 482         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
                                                   >> 483         lifeTime = fpCurrentProcess->AtRestGPIL( *fpTrack, &fCondition );
                                                   >> 484         fpCurrentProcess->SetProcessState(0);
556                                                   485 
557     fCondition=NotForced;                      << 486         if(fCondition==Forced)
558     fpCurrentProcess->SetProcessState(         << 487         {
559         fpTrackingInfo->GetProcessState(fpCurr << 488             (fpState->fSelectedAtRestDoItVector)[ri] = Forced;
                                                   >> 489         }
                                                   >> 490         else
                                                   >> 491         {
                                                   >> 492             (fpState->fSelectedAtRestDoItVector)[ri] = InActivated;
                                                   >> 493             if(lifeTime < shortestLifeTime )
                                                   >> 494             {
                                                   >> 495                 shortestLifeTime = lifeTime;
                                                   >> 496                 fAtRestDoItProcTriggered =  G4int(ri);
                                                   >> 497                 (fpState->fSelectedAtRestDoItVector)[fAtRestDoItProcTriggered] = NotForced;
                                                   >> 498             }
                                                   >> 499         }
                                                   >> 500     }
560                                                   501 
561     lifeTime = fpCurrentProcess->AtRestGPIL( * << 502     fTimeStep = shortestLifeTime ;
562     fpCurrentProcess->ResetProcessState();     << 
563                                                   503 
564     if(fCondition==Forced)                     << 504     // at least one process is necessary to destroy the particle
                                                   >> 505     // exit with warning
                                                   >> 506     if(NofInactiveProc==fpProcessInfo->MAXofAtRestLoops)
565     {                                             507     {
566       (fpState->fSelectedAtRestDoItVector)[ri] << 508         G4cerr << "ERROR - G4ITStepProcessor::InvokeAtRestDoItProcs()" << G4endl
                                                   >> 509                << "        No AtRestDoIt process is active!" << G4endl;
567     }                                             510     }
568     else                                       << 
569     {                                          << 
570       (fpState->fSelectedAtRestDoItVector)[ri] << 
571       if(lifeTime < shortestLifeTime )         << 
572       {                                        << 
573         shortestLifeTime = lifeTime;           << 
574         fAtRestDoItProcTriggered = G4int(ri);  << 
575       }                                        << 
576     }                                          << 
577   }                                            << 
578                                                << 
579   (fpState->fSelectedAtRestDoItVector)[fAtRest << 
580                                                << 
581 //  G4cout << " --> Selected at rest process : << 
582 //         << (*fpProcessInfo->fpAtRestGetPhys << 
583 //            ->GetProcessName()               << 
584 //         << G4endl;                          << 
585                                                << 
586   fTimeStep = shortestLifeTime;                << 
587                                                << 
588   // at least one process is necessary to dest << 
589   // exit with warning                         << 
590   if(NofInactiveProc==fpProcessInfo->MAXofAtRe << 
591   {                                            << 
592     G4cerr << "ERROR - G4ITStepProcessor::Invo << 
593     << "        No AtRestDoIt process is activ << 
594   }                                            << 
595 }                                                 511 }
                                                   >> 512 //___________________________________________________________________________
596                                                   513 
597 //____________________________________________ << 514 void G4ITStepProcessor::DefinePhysicalStepLength(G4Track* track)
598 G4double G4ITStepProcessor::ComputeInteraction << 
599 {                                                 515 {
600   G4TrackManyList* mainList = fpTrackContainer << 516     SetTrack(track);
601   G4TrackManyList::iterator it = mainList ->be << 517     DoDefinePhysicalStepLength();
602   G4TrackManyList::iterator end = mainList ->e << 518 }
                                                   >> 519 //______________________________________________________________________________
603                                                   520 
604   SetPreviousStepTime(previousTimeStep);       << 
605                                                   521 
606   fILTimeStep = DBL_MAX;                       << 522 void G4ITStepProcessor::SetInitialStep()
                                                   >> 523 {
                                                   >> 524     // DEBUG
                                                   >> 525     //    G4cout << "SetInitialStep for : " << fpITrack-> GetName() << G4endl;
                                                   >> 526     //________________________________________________________
                                                   >> 527     // Initialize geometry
607                                                   528 
608   for (; it != end; )                          << 
609   {                                            << 
610     G4Track * track = *it;                     << 
611                                                   529 
612 #ifdef DEBUG                                   << 530     if ( ! fpTrack->GetTouchableHandle())
613     G4cout << "*CIL* " << GetIT(track)->GetNam << 531     {
614         << " ID: " << track->GetTrackID()      << 532         G4ThreeVector direction= fpTrack->GetMomentumDirection();
615         <<  " at time : " << track->GetGlobalT << 533         fpNavigator->LocateGlobalPointAndSetup( fpTrack->GetPosition(),
616         << G4endl;                             << 534                                                 &direction, false, false );
617 #endif                                         << 535         fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
618                                                   536 
619     ++it;                                      << 537         fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
620     DefinePhysicalStepLength(track);           << 538         fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
                                                   >> 539     }
                                                   >> 540     else
                                                   >> 541     {
                                                   >> 542         fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
                                                   >> 543         fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
                                                   >> 544         G4VPhysicalVolume* oldTopVolume= fpTrack->GetTouchableHandle()->GetVolume();
                                                   >> 545         G4VPhysicalVolume* newTopVolume=
                                                   >> 546                 fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
                                                   >> 547                                                       fpTrack->GetMomentumDirection(),
                                                   >> 548                                                       *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
                                                   >> 549         if(newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId() == 1 )
                                                   >> 550         {
                                                   >> 551             fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
                                                   >> 552             fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
                                                   >> 553             fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
                                                   >> 554         }
                                                   >> 555     }
621                                                   556 
622     ExtractILData();                           << 557     fpCurrentVolume = fpState->fTouchableHandle->GetVolume();
623   }                                            << 
624                                                   558 
625   return fILTimeStep;                          << 559     //________________________________________________________
626 }                                              << 560     // If the primary track has 'Suspend' or 'PostponeToNextEvent' state,
                                                   >> 561     // set the track state to 'Alive'.
                                                   >> 562     if( (fpTrack->GetTrackStatus()==fSuspend) ||
                                                   >> 563             (fpTrack->GetTrackStatus()==fPostponeToNextEvent) )
                                                   >> 564     {
                                                   >> 565         fpTrack->SetTrackStatus(fAlive);
                                                   >> 566     }
627                                                   567 
628 //____________________________________________ << 568     // If the primary track has 'zero' kinetic energy, set the track
                                                   >> 569     // state to 'StopButAlive'.
                                                   >> 570     if(fpTrack->GetKineticEnergy() <= 0.0)
                                                   >> 571     {
                                                   >> 572         fpTrack->SetTrackStatus( fStopButAlive );
                                                   >> 573     }
                                                   >> 574     //________________________________________________________
                                                   >> 575     // Set vertex information of G4Track at here
                                                   >> 576     if ( fpTrack->GetCurrentStepNumber() == 0 )
                                                   >> 577     {
                                                   >> 578         fpTrack->SetVertexPosition( fpTrack->GetPosition() );
                                                   >> 579         fpTrack->SetVertexMomentumDirection( fpTrack->GetMomentumDirection() );
                                                   >> 580         fpTrack->SetVertexKineticEnergy( fpTrack->GetKineticEnergy() );
                                                   >> 581         fpTrack->SetLogicalVolumeAtVertex( fpTrack->GetVolume()->GetLogicalVolume() );
                                                   >> 582     }
                                                   >> 583     //________________________________________________________
                                                   >> 584     // If track is already outside the world boundary, kill it
                                                   >> 585     if( fpCurrentVolume==0 )
                                                   >> 586     {
                                                   >> 587         // If the track is a primary, stop processing
                                                   >> 588         if(fpTrack->GetParentID()==0)
                                                   >> 589         {
                                                   >> 590             G4cerr << "ERROR - G4ITStepProcessor::SetInitialStep()" << G4endl
                                                   >> 591                    << "        Primary particle starting at - "
                                                   >> 592                    << fpTrack->GetPosition()
                                                   >> 593                    << " - is outside of the world volume." << G4endl;
                                                   >> 594             G4Exception("G4ITStepProcessor::SetInitialStep()", "ITStepProcessor0011",
                                                   >> 595                         FatalException, "Primary vertex outside of the world!");
                                                   >> 596         }
629                                                   597 
630 void G4ITStepProcessor::ExtractILData()        << 598         fpTrack->SetTrackStatus( fStopAndKill );
631 {                                              << 599         G4cout << "WARNING - G4ITStepProcessor::SetInitialStep()" << G4endl
632   assert(fpTrack != 0);                        << 600                << "          Initial track position is outside world! - "
633   if (fpTrack == nullptr)                      << 601                << fpTrack->GetPosition() << G4endl;
634   {                                            << 602     }
635     CleanProcessor();                          << 603     else{
636     return;                                    << 604         // Initial set up for attribues of 'Step'
637   }                                            << 605         fpStep->InitializeStep( fpTrack );
                                                   >> 606     }
638                                                   607 
639   // assert(fpTrack->GetTrackStatus() != fStop << 
640                                                   608 
641   if (fpTrack->GetTrackStatus() == fStopAndKil << 609     if( fpTrack->GetTrackStatus() == fStopAndKill ) return ;
642   {                                            << 
643 //    trackContainer->GetMainList()->pop(fpTra << 
644     fpTrackingManager->EndTracking(fpTrack);   << 
645     CleanProcessor();                          << 
646     return;                                    << 
647   }                                            << 
648                                                   610 
649   if (IsInf(fTimeStep))                        << 611     fpTrackingManager->StartTracking(fpTrack);
650   {                                            << 
651     // G4cout << "!!!!!!!!!!!! IS INF " << tra << 
652     CleanProcessor();                          << 
653     return;                                    << 
654   }                                            << 
655   if (fTimeStep < fILTimeStep - DBL_EPSILON)   << 
656   {                                            << 
657     // G4cout << "!!!!!!!!!!!! TEMPS DIFFERENT << 
658     //    << track->GetTrackID() << G4endl;    << 
659                                                << 
660     fLeadingTracks.Reset();                    << 
661                                                << 
662     fILTimeStep = GetInteractionTime();        << 
663                                                << 
664 //    G4cout << "Will set leading step to true << 
665 //           << SP -> GetInteractionTime() <<  << 
666 //           << G4BestUnit(fILTimeStep, "Time" << 
667 //           << G4endl;                        << 
668                                                << 
669 //    GetIT(fpTrack)->GetTrackingInfo()->SetLe << 
670     fLeadingTracks.Push(fpTrack);              << 
671   }                                            << 
672   else if(fabs(fILTimeStep - fTimeStep) < DBL_ << 
673   {                                            << 
674                                                << 
675     // G4cout << "!!!!!!!!!!!! MEME TEMPS " << << 
676     // G4cout << "Will set leading step to tru << 
677     //        << SP -> GetInteractionTime() << << 
678     //        << fTimeStep << " the trackID is << 
679 //    GetIT(fpTrack)->GetTrackingInfo()->SetLe << 
680     fLeadingTracks.Push(fpTrack);              << 
681   }                                            << 
682   // else                                      << 
683   // {                                         << 
684   //     G4cout << "!!!! Bigger time : " << "c << 
685   //  << " proposedTime : " << SP -> GetIntera << 
686   // }                                         << 
687                                                   612 
688   CleanProcessor();                            << 613     fpState->fStepStatus = fUndefined;
689 }                                                 614 }
                                                   >> 615 //______________________________________________________________________________
690                                                   616 
691 //____________________________________________ << 617 void G4ITStepProcessor::InitDefineStep()
692                                                << 
693 void G4ITStepProcessor::DefinePhysicalStepLeng << 
694 {                                                 618 {
695   SetTrack(track);                             << 
696   DoDefinePhysicalStepLength();                << 
697 }                                              << 
698                                                   619 
699 //____________________________________________ << 620     if(!fpStep)
                                                   >> 621     {
700                                                   622 
701 void G4ITStepProcessor::SetInitialStep()       << 623         // Create new Step and give it to the track
702 {                                              << 624         fpStep = new G4Step();
703   // DEBUG                                     << 625         fpTrack->SetStep(fpStep);
704   //    G4cout << "SetInitialStep for : " << f << 626         fpSecondary = fpStep->NewSecondaryVector();
705   //__________________________________________ << 627 
706   // Initialize geometry                       << 628         // Create new state and set it in the trackingInfo
707                                                << 629         fpState = new G4ITStepProcessorState();
708   if(!fpTrack->GetTouchableHandle())           << 630         fpITrack->GetTrackingInfo()->SetStepProcessorState((G4ITStepProcessorState_Lock*)fpState);
709   {                                            << 631 
710     //======================================== << 632         SetupMembers();
711     // Create navigator state and Locate parti << 633         fpNavigator->NewNavigatorState();
712     //======================================== << 634 
713     /*                                         << 635         SetInitialStep();
714      fpNavigator->NewNavigatorStateAndLocate(f << 
715      fpTrack->GetMomentumDirection());         << 
716                                                << 
717      fpITrack->GetTrackingInfo()->             << 
718      SetNavigatorState(fpNavigator->GetNavigat << 
719      */                                        << 
720     fpNavigator->NewNavigatorState();          << 
721     fpITrack->GetTrackingInfo()->SetNavigatorS << 
722         ->GetNavigatorState());                << 
723                                                << 
724     G4ThreeVector direction = fpTrack->GetMome << 
725     fpNavigator->LocateGlobalPointAndSetup(fpT << 
726                                            &di << 
727                                            fal << 
728                                            fal << 
729                                                << 
730     fpState->fTouchableHandle = fpNavigator->C << 
731                                                << 
732     fpTrack->SetTouchableHandle(fpState->fTouc << 
733     fpTrack->SetNextTouchableHandle(fpState->f << 
734   }                                            << 
735   else                                         << 
736   {                                            << 
737     fpState->fTouchableHandle = fpTrack->GetTo << 
738     fpTrack->SetNextTouchableHandle(fpState->f << 
739                                                << 
740     //======================================== << 
741     // Create OR set navigator state           << 
742     //======================================== << 
743                                                << 
744     if(fpITrack->GetTrackingInfo()->GetNavigat << 
745     {                                          << 
746       fpNavigator->SetNavigatorState(fpITrack- << 
747           ->GetNavigatorState());              << 
748       fpITrack->GetTrackingInfo()->SetNavigato << 
749           ->GetNavigatorState());              << 
750     }                                             636     }
751     else                                          637     else
752     {                                             638     {
753       fpNavigator->NewNavigatorState(*((G4Touc << 639         SetupMembers();
754           ->fTouchableHandle()));              << 
755       fpITrack->GetTrackingInfo()->SetNavigato << 
756           ->GetNavigatorState());              << 
757     }                                          << 
758                                                << 
759     G4VPhysicalVolume* oldTopVolume =          << 
760         fpTrack->GetTouchableHandle()->GetVolu << 
761                                                << 
762     //======================================== << 
763     // Locate particle in geometry             << 
764     //======================================== << 
765                                                << 
766 //    G4VPhysicalVolume* newTopVolume =        << 
767 //        fpNavigator->LocateGlobalPointAndSet << 
768 //            fpTrack->GetPosition(),          << 
769 //            &fpTrack->GetMomentumDirection() << 
770 //            true, false);                    << 
771                                                << 
772     G4VPhysicalVolume* newTopVolume =          << 
773         fpNavigator->ResetHierarchyAndLocate(f << 
774                                              f << 
775                                              * << 
776                                                << 
777                                                << 
778     if(newTopVolume != oldTopVolume || oldTopV << 
779         == 1)                                  << 
780     {                                          << 
781       fpState->fTouchableHandle = fpNavigator- << 
782       fpTrack->SetTouchableHandle(fpState->fTo << 
783       fpTrack->SetNextTouchableHandle(fpState- << 
784     }                                          << 
785   }                                            << 
786                                                << 
787   fpCurrentVolume = fpState->fTouchableHandle- << 
788                                                << 
789   //__________________________________________ << 
790   // If the primary track has 'Suspend' or 'Po << 
791   // set the track state to 'Alive'.           << 
792   if((fpTrack->GetTrackStatus() == fSuspend) | << 
793       == fPostponeToNextEvent))                << 
794   {                                            << 
795     fpTrack->SetTrackStatus(fAlive);           << 
796   }                                            << 
797                                                << 
798   //HoangTRAN: it's better to check the status << 
799   if(fpTrack->GetTrackStatus() == fStopAndKill << 
800                                                << 
801   // If the primary track has 'zero' kinetic e << 
802   // state to 'StopButAlive'.                  << 
803   if(fpTrack->GetKineticEnergy() <= 0.0)       << 
804   {                                            << 
805     fpTrack->SetTrackStatus(fStopButAlive);    << 
806   }                                            << 
807   //__________________________________________ << 
808   // Set vertex information of G4Track at here << 
809   if(fpTrack->GetCurrentStepNumber() == 0)     << 
810   {                                            << 
811     fpTrack->SetVertexPosition(fpTrack->GetPos << 
812     fpTrack->SetVertexMomentumDirection(fpTrac << 
813     fpTrack->SetVertexKineticEnergy(fpTrack->G << 
814     fpTrack->SetLogicalVolumeAtVertex(fpTrack- << 
815   }                                            << 
816   //__________________________________________ << 
817   // If track is already outside the world bou << 
818   if(fpCurrentVolume == nullptr)               << 
819   {                                            << 
820     // If the track is a primary, stop process << 
821     if(fpTrack->GetParentID() == 0)            << 
822     {                                          << 
823       G4cerr << "ERROR - G4ITStepProcessor::Se << 
824       << fpTrack->GetPosition()                << 
825       << " - is outside of the world volume."  << 
826       G4Exception("G4ITStepProcessor::SetIniti << 
827           FatalException, "Primary vertex outs << 
828     }                                          << 
829                                                << 
830     fpTrack->SetTrackStatus( fStopAndKill );   << 
831     G4cout << "WARNING - G4ITStepProcessor::Se << 
832     << "          Initial track position is ou << 
833     << fpTrack->GetPosition() << G4endl;       << 
834   }                                            << 
835   else                                         << 
836   {                                            << 
837     // Initial set up for attribues of 'Step'  << 
838     fpStep->InitializeStep( fpTrack );         << 
839   }                                            << 
840                                                   640 
841   fpState->fStepStatus = fUndefined;           << 641         fpState->fPreviousStepSize = fpTrack->GetStepLength();
842 }                                              << 642 /***
843 //____________________________________________ << 643         // Send G4Step information to Hit/Dig if the volume is sensitive
                                                   >> 644         fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
                                                   >> 645         StepControlFlag =  fpStep->GetControlFlag();
                                                   >> 646         if( fpCurrentVolume != 0 && StepControlFlag != AvoidHitInvocation)
                                                   >> 647         {
                                                   >> 648             fpSensitive = fpStep->GetPreStepPoint()->
                                                   >> 649                     GetSensitiveDetector();
844                                                   650 
845 void G4ITStepProcessor::InitDefineStep()       << 651             //            if( fSensitive != 0 ) {
846 {                                              << 652             //              fSensitive->Hit(fStep);
                                                   >> 653             //            }
                                                   >> 654         }
                                                   >> 655 ***/
                                                   >> 656         // Store last PostStepPoint to PreStepPoint, and swap current and next
                                                   >> 657         // volume information of G4Track. Reset total energy deposit in one Step.
                                                   >> 658         fpStep->CopyPostToPreStepPoint();
                                                   >> 659         fpStep->ResetTotalEnergyDeposit();
                                                   >> 660 
                                                   >> 661         //JA Set the volume before it is used (in DefineStepLength() for User Limit)
                                                   >> 662         fpCurrentVolume = fpStep->GetPreStepPoint()->GetPhysicalVolume();
                                                   >> 663 /*
                                                   >> 664         G4cout << G4endl;
                                                   >> 665         G4cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" << G4endl;
                                                   >> 666         G4cout << "PreStepPoint Volume : " << fpCurrentVolume->GetName() << G4endl;
                                                   >> 667         G4cout << "Track Touchable : " << fpTrack->GetTouchableHandle()->GetVolume()->GetName() << G4endl;
                                                   >> 668         G4cout << "Track NextTouchable : " << fpTrack->GetNextTouchableHandle()->GetVolume()->GetName() << G4endl;
                                                   >> 669 */
                                                   >> 670         // Reset the step's auxiliary points vector pointer
                                                   >> 671         fpStep->SetPointerToVectorOfAuxiliaryPoints(0);
                                                   >> 672 
                                                   >> 673         // Switch next touchable in track to current one
                                                   >> 674         fpTrack->SetTouchableHandle(fpTrack->GetNextTouchableHandle());
                                                   >> 675         fpState->fTouchableHandle = fpTrack->GetTouchableHandle();
                                                   >> 676         fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
                                                   >> 677         G4VPhysicalVolume* oldTopVolume= fpTrack->GetTouchableHandle()->GetVolume();
                                                   >> 678         fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
                                                   >> 679 
                                                   >> 680         G4VPhysicalVolume* newTopVolume=
                                                   >> 681                 fpNavigator->ResetHierarchyAndLocate( fpTrack->GetPosition(),
                                                   >> 682                                                       fpTrack->GetMomentumDirection(),
                                                   >> 683                                                       *((G4TouchableHistory*)fpTrack->GetTouchableHandle()()) );
847                                                   684 
848   if(fpStep == nullptr)                        << 685         //        G4cout << "New Top Volume : " << newTopVolume->GetName() << G4endl;
849   {                                            << 
850     // Create new Step and give it to the trac << 
851     fpStep = new G4Step();                     << 
852     fpTrack->SetStep(fpStep);                  << 
853     fpSecondary = fpStep->NewSecondaryVector() << 
854                                                << 
855     // Create new state and set it in the trac << 
856     fpState = new G4ITStepProcessorState();    << 
857     fpITrack->GetTrackingInfo()->SetStepProces << 
858                                                   686 
859     SetupMembers();                            << 687         if(newTopVolume != oldTopVolume || oldTopVolume->GetRegularStructureId() == 1 )
860     SetInitialStep();                          << 688         {
                                                   >> 689             fpState->fTouchableHandle = fpNavigator->CreateTouchableHistory();
                                                   >> 690             fpTrack->SetTouchableHandle( fpState->fTouchableHandle );
                                                   >> 691             fpTrack->SetNextTouchableHandle( fpState->fTouchableHandle );
                                                   >> 692         }
861                                                   693 
862     fpTrackingManager->StartTracking(fpTrack); << 694         fpNavigator->SetNavigatorState(fpITrack->GetTrackingInfo()->GetNavigatorState());
863   }                                            << 695     }
864   else                                         << 
865   {                                            << 
866     SetupMembers();                            << 
867                                                << 
868     fpState->fPreviousStepSize = fpTrack->GetS << 
869     /***                                       << 
870      // Send G4Step information to Hit/Dig if  << 
871      fpCurrentVolume = fpStep->GetPreStepPoint << 
872      StepControlFlag =  fpStep->GetControlFlag << 
873      if( fpCurrentVolume != 0 && StepControlFl << 
874      {                                         << 
875      fpSensitive = fpStep->GetPreStepPoint()-> << 
876      GetSensitiveDetector();                   << 
877                                                << 
878      //            if( fSensitive != 0 ) {     << 
879      //              fSensitive->Hit(fStep);   << 
880      //            }                           << 
881      }                                         << 
882      ***/                                      << 
883     // Store last PostStepPoint to PreStepPoin << 
884     // volume information of G4Track. Reset to << 
885     fpStep->CopyPostToPreStepPoint();          << 
886     fpStep->ResetTotalEnergyDeposit();         << 
887                                                << 
888     //JA Set the volume before it is used (in  << 
889     fpCurrentVolume = fpStep->GetPreStepPoint( << 
890     /*                                         << 
891      G4cout << G4endl;                         << 
892      G4cout << "!!!!!!!!!!!!!!!!!!!!!!!!!!!" < << 
893      G4cout << "PreStepPoint Volume : "        << 
894      << fpCurrentVolume->GetName() << G4endl;  << 
895      G4cout << "Track Touchable : "            << 
896      << fpTrack->GetTouchableHandle()->GetVolu << 
897      G4cout << "Track NextTouchable : "        << 
898      << fpTrack->GetNextTouchableHandle()->Get << 
899      << G4endl;                                << 
900      */                                        << 
901     // Reset the step's auxiliary points vecto << 
902     fpStep->SetPointerToVectorOfAuxiliaryPoint << 
903                                                << 
904     // Switch next touchable in track to curre << 
905     fpTrack->SetTouchableHandle(fpTrack->GetNe << 
906     fpState->fTouchableHandle = fpTrack->GetTo << 
907     fpTrack->SetNextTouchableHandle(fpState->f << 
908                                                << 
909     //! ADDED BACK                             << 
910     /*                                         << 
911      G4VPhysicalVolume* oldTopVolume =         << 
912      fpTrack->GetTouchableHandle()->GetVolume( << 
913      fpNavigator->SetNavigatorState(           << 
914      fpITrack->GetTrackingInfo()->GetNavigator << 
915                                                << 
916      G4VPhysicalVolume* newTopVolume = fpNavig << 
917      fpTrack->GetPosition(), fpTrack->GetMomen << 
918      *((G4TouchableHistory*) fpTrack->GetTouch << 
919                                                << 
920      //  G4VPhysicalVolume* newTopVolume=      << 
921      //     fpNavigator->LocateGlobalPointAndS << 
922      //                                        << 
923      //                                        << 
924                                                << 
925      //        G4cout << "New Top Volume : " < << 
926                                                << 
927      if (newTopVolume != oldTopVolume || oldTo << 
928      == 1)                                     << 
929      {                                         << 
930      fpState->fTouchableHandle = fpNavigator-> << 
931      fpTrack->SetTouchableHandle(fpState->fTou << 
932      fpTrack->SetNextTouchableHandle(fpState-> << 
933      }                                         << 
934                                                << 
935      */                                        << 
936     //! ADDED BACK                             << 
937     //======================================== << 
938     // Only reset navigator state + reset volu << 
939     // No need to relocate                     << 
940     //======================================== << 
941     fpNavigator->SetNavigatorState(fpITrack->G << 
942         ->GetNavigatorState());                << 
943   }                                            << 
944 }                                                 696 }
945                                                   697 
946 //____________________________________________    698 //______________________________________________________________________________
947                                                   699 
948 // ------------------------------------------- << 700 
                                                   >> 701 // ************************************************************************
949 //  Compute Interaction Length                    702 //  Compute Interaction Length
950 // ------------------------------------------- << 703 // ************************************************************************
951 void G4ITStepProcessor::DoDefinePhysicalStepLe    704 void G4ITStepProcessor::DoDefinePhysicalStepLength()
952 {                                                 705 {
953                                                   706 
954   InitDefineStep();                            << 707     InitDefineStep();
955                                                   708 
956 #ifdef G4VERBOSE                               << 709     G4TrackStatus trackStatus = fpTrack -> GetTrackStatus()  ;
957   // !!!!! Verbose                             << 
958   if(fpVerbose != nullptr) fpVerbose->DPSLStar << 
959 #endif                                         << 
960                                                   710 
961   G4TrackStatus trackStatus = fpTrack->GetTrac << 711     if(trackStatus == fStopAndKill)
                                                   >> 712     {
                                                   >> 713         return ;
                                                   >> 714     }
962                                                   715 
963   if(trackStatus == fStopAndKill)              << 716     if(trackStatus == fStopButAlive)
964   {                                            << 717     {
965     return;                                    << 718         fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
966   }                                            << 719         fpNavigator->SetNavigatorState(0);
967                                                << 720         return GetAtRestIL() ;
968   if(trackStatus == fStopButAlive)             << 721     }
969   {                                            << 
970     fpITrack->GetTrackingInfo()->SetNavigatorS << 
971         ->GetNavigatorState());                << 
972     fpNavigator->ResetNavigatorState();        << 
973     return GetAtRestIL();                      << 
974   }                                            << 
975                                                << 
976   // Find minimum Step length and correspondin << 
977   // demanded by active disc./cont. processes  << 
978                                                << 
979   // ReSet the counter etc.                    << 
980   fpState->fPhysicalStep = DBL_MAX; // Initial << 
981   fPhysIntLength = DBL_MAX; // Initialize by a << 
982                                                << 
983   G4double proposedTimeStep = DBL_MAX;         << 
984   G4VProcess* processWithPostStepGivenByTimeSt << 
985                                                << 
986   // GPIL for PostStep                         << 
987   fPostStepDoItProcTriggered = fpProcessInfo-> << 
988   fPostStepAtTimeDoItProcTriggered = fpProcess << 
989                                                << 
990   //  G4cout << "fpProcessInfo->MAXofPostStepL << 
991   //         << fpProcessInfo->MAXofPostStepLo << 
992   //         << " mol : " << fpITrack -> GetNa << 
993   //         << " id : " << fpTrack->GetTrackI << 
994   //         << G4endl;                        << 
995                                                << 
996   for(std::size_t np = 0; np < fpProcessInfo-> << 
997   {                                            << 
998     fpCurrentProcess = dynamic_cast<G4VITProce << 
999         ->fpPostStepGetPhysIntVector)[(G4int)n << 
1000     if(fpCurrentProcess == nullptr)           << 
1001     {                                         << 
1002       (fpState->fSelectedPostStepDoItVector)[ << 
1003       continue;                               << 
1004     } // NULL means the process is inactivate << 
1005                                               << 
1006     fCondition = NotForced;                   << 
1007     fpCurrentProcess->SetProcessState(fpTrack << 
1008         ->GetProcessID()));                   << 
1009                                               << 
1010     // G4cout << "Is going to call : "        << 
1011     //        << fpCurrentProcess -> GetProce << 
1012     //        << G4endl;                      << 
1013     fPhysIntLength = fpCurrentProcess->PostSt << 
1014                                               << 
1015                                               << 
1016                                               << 
1017 #ifdef G4VERBOSE                              << 
1018     // !!!!! Verbose                          << 
1019     if(fpVerbose != nullptr) fpVerbose->DPSLP << 
1020 #endif                                        << 
1021                                                  722 
1022     fpCurrentProcess->ResetProcessState();    << 
1023     //fpCurrentProcess->SetProcessState(0);   << 
1024                                                  723 
1025     switch(fCondition)                        << 724     // Find minimum Step length and corresponding time
1026     {                                         << 725     // demanded by active disc./cont. processes
1027       case ExclusivelyForced: // Will need sp << 
1028         (fpState->fSelectedPostStepDoItVector << 
1029         fpState->fStepStatus = fExclusivelyFo << 
1030         fpStep->GetPostStepPoint()->SetProces << 
1031         break;                                << 
1032                                               << 
1033       case Conditionally:                     << 
1034         //       (fpState->fSelectedPostStepD << 
1035         G4Exception("G4ITStepProcessor::Defin << 
1036                     "ITStepProcessor0008",    << 
1037                     FatalException,           << 
1038                     "This feature is no more  << 
1039         break;                                << 
1040                                               << 
1041       case Forced:                            << 
1042         (fpState->fSelectedPostStepDoItVector << 
1043         break;                                << 
1044                                               << 
1045       case StronglyForced:                    << 
1046         (fpState->fSelectedPostStepDoItVector << 
1047         break;                                << 
1048                                               << 
1049       default:                                << 
1050         (fpState->fSelectedPostStepDoItVector << 
1051         break;                                << 
1052     }                                         << 
1053                                               << 
1054     if(fCondition == ExclusivelyForced)       << 
1055     {                                         << 
1056       for(std::size_t nrest = np + 1; nrest < << 
1057           ++nrest)                            << 
1058       {                                       << 
1059         (fpState->fSelectedPostStepDoItVector << 
1060       }                                       << 
1061       return; // Please note the 'return' at  << 
1062     }                                         << 
1063                                               << 
1064     if(fPhysIntLength < fpState->fPhysicalSte << 
1065     {                                         << 
1066       // To avoid checking whether the proces << 
1067       // proposing a time step, the returned  << 
1068       // negative (just for tagging)          << 
1069       if(fpCurrentProcess->ProposesTimeStep() << 
1070       {                                       << 
1071         fPhysIntLength *= -1;                 << 
1072         if(fPhysIntLength < proposedTimeStep) << 
1073         {                                     << 
1074           proposedTimeStep = fPhysIntLength;  << 
1075           fPostStepAtTimeDoItProcTriggered =  << 
1076           processWithPostStepGivenByTimeStep  << 
1077         }                                     << 
1078       }                                       << 
1079       else                                    << 
1080       {                                       << 
1081         fpState->fPhysicalStep = fPhysIntLeng << 
1082         fpState->fStepStatus = fPostStepDoItP << 
1083         fPostStepDoItProcTriggered = G4int(np << 
1084         fpStep->GetPostStepPoint()->SetProces << 
1085       }                                       << 
1086     }                                         << 
1087   }                                           << 
1088                                               << 
1089   // GPIL for AlongStep                       << 
1090   fpState->fProposedSafety = DBL_MAX;         << 
1091   G4double safetyProposedToAndByProcess = fpS << 
1092                                               << 
1093   for(std::size_t kp = 0; kp < fpProcessInfo- << 
1094   {                                           << 
1095     fpCurrentProcess = dynamic_cast<G4VITProc << 
1096         ->fpAlongStepGetPhysIntVector)[(G4int << 
1097     if(fpCurrentProcess == nullptr) continue; << 
1098     // NULL means the process is inactivated  << 
1099                                               << 
1100     fpCurrentProcess->SetProcessState(        << 
1101         fpTrackingInfo->GetProcessState(fpCur << 
1102     fPhysIntLength =                          << 
1103         fpCurrentProcess->AlongStepGPIL(*fpTr << 
1104                                         fpSta << 
1105                                         fpSta << 
1106                                         safet << 
1107                                         &fGPI << 
1108                                               << 
1109 #ifdef G4VERBOSE                              << 
1110     // !!!!! Verbose                          << 
1111     if(fpVerbose != nullptr) fpVerbose->DPSLA << 
1112 #endif                                        << 
1113                                                  726 
1114     if(fPhysIntLength < fpState->fPhysicalSte << 727     // ReSet the counter etc.
1115     {                                         << 728     fpState->fPhysicalStep  = DBL_MAX;          // Initialize by a huge number
1116       fpState->fPhysicalStep = fPhysIntLength << 729     fPhysIntLength = DBL_MAX;          // Initialize by a huge number
1117       // Should save PS and TS in IT          << 
1118                                                  730 
1119       // Check if the process wants to be the << 731     double proposedTimeStep = DBL_MAX;
1120       // multi-scattering proposes Step limit << 732     G4VProcess* processWithPostStepGivenByTimeStep(0);
1121       if(fGPILSelection == CandidateForSelect << 
1122       {                                       << 
1123         fpState->fStepStatus = fAlongStepDoIt << 
1124         fpStep->GetPostStepPoint()->SetProces << 
1125       }                                       << 
1126                                               << 
1127       // Transportation is assumed to be the  << 
1128       if(kp == fpProcessInfo->MAXofAlongStepL << 
1129       {                                       << 
1130         fpTransportation = dynamic_cast<G4ITT << 
1131                                               << 
1132         if(fpTransportation == nullptr)       << 
1133         {                                     << 
1134           G4ExceptionDescription exceptionDes << 
1135           exceptionDescription << "No transpo << 
1136           G4Exception("G4ITStepProcessor::DoD << 
1137                       "ITStepProcessor0009",  << 
1138                       FatalErrorInArgument,   << 
1139                       exceptionDescription);  << 
1140         }                                     << 
1141                                                  733 
1142         fTimeStep = fpTransportation->GetInte << 734     // GPIL for PostStep
                                                   >> 735     fPostStepDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
                                                   >> 736     fPostStepAtTimeDoItProcTriggered = fpProcessInfo->MAXofPostStepLoops;
1143                                                  737 
1144         if(fpTrack->GetNextVolume() != nullpt << 738     //    G4cout << "fpProcessInfo->MAXofPostStepLoops : " << fpProcessInfo->MAXofPostStepLoops
1145         else fpState->fStepStatus = fWorldBou << 739     //           << " mol : " << fpITrack -> GetName() << " id : " << fpTrack->GetTrackID()
1146       }                                       << 740     //           << G4endl;
1147     }                                         << 741 
1148     else                                      << 742     for(size_t np=0; np < fpProcessInfo->MAXofPostStepLoops; np++)
1149     {                                            743     {
1150       if(kp == fpProcessInfo->MAXofAlongStepL << 744         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpPostStepGetPhysIntVector)[np];
1151       {                                       << 745         if (fpCurrentProcess== 0)
1152         fpTransportation = dynamic_cast<G4ITT << 746         {
1153                                               << 747             (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
1154         if(fpTransportation == nullptr)       << 748             continue;
1155         {                                     << 749         }   // NULL means the process is inactivated by a user on fly.
1156           G4ExceptionDescription exceptionDes << 750 
1157           exceptionDescription << "No transpo << 751         fCondition=NotForced;
1158           G4Exception("G4ITStepProcessor::DoD << 752         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
1159                       "ITStepProcessor0010",  << 753 
1160                       FatalErrorInArgument,   << 754         //        G4cout << "Is going to call : " << fpCurrentProcess -> GetProcessName() << G4endl;
1161                       exceptionDescription);  << 755         fPhysIntLength = fpCurrentProcess->
                                                   >> 756                 PostStepGPIL( *fpTrack,
                                                   >> 757                               fpState->fPreviousStepSize,
                                                   >> 758                               &fCondition );
                                                   >> 759         fpCurrentProcess->SetProcessState(0);
                                                   >> 760 
                                                   >> 761         switch (fCondition)
                                                   >> 762         {
                                                   >> 763         case ExclusivelyForced: // Will need special treatment
                                                   >> 764             (fpState->fSelectedPostStepDoItVector)[np] = ExclusivelyForced;
                                                   >> 765             fpState->fStepStatus = fExclusivelyForcedProc;
                                                   >> 766             fpStep->GetPostStepPoint()
                                                   >> 767                     ->SetProcessDefinedStep(fpCurrentProcess);
                                                   >> 768             break;
                                                   >> 769 
                                                   >> 770         case Conditionally:
                                                   >> 771             //       (fpState->fSelectedPostStepDoItVector)[np] = Conditionally;
                                                   >> 772             G4Exception("G4ITStepProcessor::DefinePhysicalStepLength()", "ITStepProcessor0008",
                                                   >> 773                         FatalException, "This feature is no more supported");
                                                   >> 774             break;
                                                   >> 775 
                                                   >> 776         case Forced:
                                                   >> 777             (fpState->fSelectedPostStepDoItVector)[np] = Forced;
                                                   >> 778             break;
                                                   >> 779 
                                                   >> 780         case StronglyForced:
                                                   >> 781             (fpState->fSelectedPostStepDoItVector)[np] = StronglyForced;
                                                   >> 782             break;
                                                   >> 783 
                                                   >> 784         default:
                                                   >> 785             (fpState->fSelectedPostStepDoItVector)[np] = InActivated;
                                                   >> 786             break;
1162         }                                        787         }
1163                                                  788 
1164         fTimeStep = fpTransportation->GetInte << 789         if (fCondition==ExclusivelyForced)
1165       }                                       << 790         {
                                                   >> 791             for(size_t nrest=np+1; nrest < fpProcessInfo->MAXofPostStepLoops; nrest++)
                                                   >> 792             {
                                                   >> 793                 (fpState->fSelectedPostStepDoItVector)[nrest] = InActivated;
                                                   >> 794             }
                                                   >> 795             return;  // Please note the 'return' at here !!!
                                                   >> 796         }
                                                   >> 797         else
                                                   >> 798         {
                                                   >> 799             if(fPhysIntLength < fpState->fPhysicalStep )
                                                   >> 800             {
                                                   >> 801                 // To avoid checking whether the process is actually
                                                   >> 802                 // proposing a time step, the returned time steps are
                                                   >> 803                 // negative (just for tagging)
                                                   >> 804                 if(fpCurrentProcess->ProposesTimeStep())
                                                   >> 805                 {
                                                   >> 806                     fPhysIntLength *= -1;
                                                   >> 807                     if(fPhysIntLength < proposedTimeStep)
                                                   >> 808                     {
                                                   >> 809                         proposedTimeStep = fPhysIntLength;
                                                   >> 810                         fPostStepAtTimeDoItProcTriggered = np;
                                                   >> 811                         processWithPostStepGivenByTimeStep = fpCurrentProcess;
                                                   >> 812                     }
                                                   >> 813                 }
                                                   >> 814                 else
                                                   >> 815                 {
                                                   >> 816                     fpState->fPhysicalStep = fPhysIntLength;
                                                   >> 817                     fpState->fStepStatus = fPostStepDoItProc;
                                                   >> 818                     fPostStepDoItProcTriggered = G4int(np);
                                                   >> 819                     fpStep->GetPostStepPoint()
                                                   >> 820                             ->SetProcessDefinedStep(fpCurrentProcess);
                                                   >> 821                 }
                                                   >> 822             }
                                                   >> 823         }
1166     }                                            824     }
1167                                                  825 
1168     // Handle PostStep processes sending back << 826     // GPIL for AlongStep
1169     if(proposedTimeStep < fTimeStep)          << 827     fpState->proposedSafety = DBL_MAX;
1170     {                                         << 828     G4double safetyProposedToAndByProcess = fpState->proposedSafety;
1171       if(fPostStepAtTimeDoItProcTriggered < f << 829 
1172       {                                       << 830     for(size_t kp=0; kp < fpProcessInfo->MAXofAlongStepLoops; kp++)
1173         if((fpState->fSelectedPostStepDoItVec << 831     {
                                                   >> 832         fpCurrentProcess = (G4VITProcess*) (*fpProcessInfo->fpAlongStepGetPhysIntVector)[kp];
                                                   >> 833         if (fpCurrentProcess== 0) continue;
                                                   >> 834         // NULL means the process is inactivated by a user on fly.
                                                   >> 835 
                                                   >> 836         fpCurrentProcess->SetProcessState(fpTrackingInfo->GetProcessState(fpCurrentProcess->GetProcessID()));
                                                   >> 837         fPhysIntLength = fpCurrentProcess-> AlongStepGPIL( *fpTrack,
                                                   >> 838                                                            fpState->fPreviousStepSize,
                                                   >> 839                                                            fpState->fPhysicalStep,
                                                   >> 840                                                            safetyProposedToAndByProcess,
                                                   >> 841                                                            &fGPILSelection );
                                                   >> 842 
                                                   >> 843         if(fPhysIntLength < fpState->fPhysicalStep)
1174         {                                        844         {
1175           (fpState->fSelectedPostStepDoItVect << 845             fpState->fPhysicalStep  = fPhysIntLength;
1176               NotForced;                      << 846             // Should save PS and TS in IT
1177           // (fpState->fSelectedPostStepDoItV << 
1178                                                  847 
1179           fpState->fStepStatus = fPostStepDoI << 848             // Check if the process wants to be the GPIL winner. For example,
1180           fpStep->GetPostStepPoint()->SetProc << 849             // multi-scattering proposes Step limit, but won't be the winner.
                                                   >> 850             if(fGPILSelection==CandidateForSelection)
                                                   >> 851             {
                                                   >> 852                 fpState->fStepStatus = fAlongStepDoItProc;
                                                   >> 853                 fpStep->GetPostStepPoint()
                                                   >> 854                         ->SetProcessDefinedStep(fpCurrentProcess);
                                                   >> 855             }
                                                   >> 856 
                                                   >> 857             // Transportation is assumed to be the last process in the vector
                                                   >> 858             if(kp == fpProcessInfo->MAXofAlongStepLoops-1)
                                                   >> 859             {
                                                   >> 860                 fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
                                                   >> 861 
                                                   >> 862                 if(! fpTransportation)
                                                   >> 863                 {
                                                   >> 864                     G4ExceptionDescription exceptionDescription ;
                                                   >> 865                     exceptionDescription << "No transportation process found " ;
                                                   >> 866                     G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength","ITStepProcessor0009",
                                                   >> 867                                 FatalErrorInArgument,exceptionDescription);
                                                   >> 868                 }
                                                   >> 869 
                                                   >> 870                 fTimeStep     = fpTransportation->GetInteractionTimeLeft();
                                                   >> 871 
                                                   >> 872 
                                                   >> 873                 if (fpTrack->GetNextVolume() != 0)
                                                   >> 874                     fpState->fStepStatus = fGeomBoundary;
                                                   >> 875                 else
                                                   >> 876                     fpState->fStepStatus = fWorldBoundary;
                                                   >> 877             }
                                                   >> 878         }
                                                   >> 879         else
                                                   >> 880         {
                                                   >> 881             if(kp == fpProcessInfo->MAXofAlongStepLoops-1)
                                                   >> 882             {
                                                   >> 883                 fpTransportation = dynamic_cast<G4ITTransportation*>(fpCurrentProcess);
                                                   >> 884 
                                                   >> 885                 if(! fpTransportation)
                                                   >> 886                 {
                                                   >> 887                     G4ExceptionDescription exceptionDescription ;
                                                   >> 888                     exceptionDescription << "No transportation process found " ;
                                                   >> 889                     G4Exception("G4ITStepProcessor::DoDefinePhysicalStepLength","ITStepProcessor0010",
                                                   >> 890                                 FatalErrorInArgument,exceptionDescription);
                                                   >> 891                 }
1181                                                  892 
1182           fTimeStep = proposedTimeStep;       << 893                 fTimeStep     = fpTransportation->GetInteractionTimeLeft();
                                                   >> 894             }
                                                   >> 895         }
1183                                                  896 
1184           fpTransportation->ComputeStep(*fpTr << 897         if(proposedTimeStep < fTimeStep)
1185                                         *fpSt << 898         {
1186                                         fTime << 899             if(fPostStepAtTimeDoItProcTriggered<fpProcessInfo->MAXofPostStepLoops)
1187                                         fpSta << 900             {
                                                   >> 901                 if ((fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] ==
                                                   >> 902                         InActivated)
                                                   >> 903                 {
                                                   >> 904                     (fpState->fSelectedPostStepDoItVector)[fPostStepAtTimeDoItProcTriggered] = NotForced;
                                                   >> 905                     //                    (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] = InActivated;
                                                   >> 906 
                                                   >> 907                     fpState->fStepStatus = fPostStepDoItProc;
                                                   >> 908                     fpStep->GetPostStepPoint()->SetProcessDefinedStep(processWithPostStepGivenByTimeStep);
                                                   >> 909 
                                                   >> 910                     fTimeStep = proposedTimeStep;
                                                   >> 911 
                                                   >> 912                     fpTransportation->ComputeStep(*fpTrack,*fpStep,fTimeStep,fpState->fPhysicalStep);
                                                   >> 913                 }
                                                   >> 914             }
1188         }                                        915         }
1189       }                                       << 916         else
1190     }                                         << 
1191     else                                      << 
1192     {                                         << 
1193       if(fPostStepDoItProcTriggered < fpProce << 
1194       {                                       << 
1195         if((fpState->fSelectedPostStepDoItVec << 
1196         {                                        917         {
1197           (fpState->fSelectedPostStepDoItVect << 918             if (fPostStepDoItProcTriggered<fpProcessInfo->MAXofPostStepLoops)
1198               NotForced;                      << 919             {
                                                   >> 920                 if ((fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] ==
                                                   >> 921                         InActivated)
                                                   >> 922                 {
                                                   >> 923                     (fpState->fSelectedPostStepDoItVector)[fPostStepDoItProcTriggered] =
                                                   >> 924                             NotForced;
                                                   >> 925                 }
                                                   >> 926             }
1199         }                                        927         }
1200       }                                       << 
1201     }                                         << 
1202                                                  928 
1203 //  fpCurrentProcess->SetProcessState(0);     << 929         fpCurrentProcess->SetProcessState(0);
1204     fpCurrentProcess->ResetProcessState();    << 
1205                                                  930 
1206     // Make sure to check the safety, even if << 931         // Make sure to check the safety, even if Step is not limited
1207     //  by this process.                      << 932         //  by this process.                      J. Apostolakis, June 20, 1998
1208     //                                        << 933         //
1209     if(safetyProposedToAndByProcess < fpState << 934         if (safetyProposedToAndByProcess < fpState->proposedSafety)
1210     // proposedSafety keeps the smallest valu << 935             // proposedSafety keeps the smallest value:
1211     fpState->fProposedSafety = safetyProposed << 936             fpState->proposedSafety               = safetyProposedToAndByProcess;
1212     else                                      << 937         else
1213     // safetyProposedToAndByProcess always pr << 938             // safetyProposedToAndByProcess always proposes a valid safety:
1214     safetyProposedToAndByProcess = fpState->f << 939             safetyProposedToAndByProcess = fpState->proposedSafety;
1215                                                  940 
1216   }                                           << 941     }
1217                                                  942 
1218   fpITrack->GetTrackingInfo()->SetNavigatorSt << 943     fpITrack->GetTrackingInfo()->SetNavigatorState(fpNavigator->GetNavigatorState());
1219   fpNavigator->ResetNavigatorState();         << 944     fpNavigator->SetNavigatorState(0);
1220 }                                                945 }
1221                                                  946 
1222 //___________________________________________    947 //______________________________________________________________________________
1223                                                  948