Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/biasing/importance/src/G4ImportanceProcess.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/biasing/importance/src/G4ImportanceProcess.cc (Version 11.3.0) and /processes/biasing/importance/src/G4ImportanceProcess.cc (Version 10.6.p2)


  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 // G4ImportanceProcess                         << 
 27 //                                                 26 //
 28 // Author: Michael Dressel, 2002               <<  27 //
 29 // ------------------------------------------- <<  28 // ----------------------------------------------------------------------
                                                   >>  29 // GEANT 4 class source file
                                                   >>  30 //
                                                   >>  31 // G4ImportanceProcess.cc
                                                   >>  32 //
                                                   >>  33 // ----------------------------------------------------------------------
 30                                                    34 
 31 #include "G4ImportanceProcess.hh"                  35 #include "G4ImportanceProcess.hh"
 32 #include "G4VImportanceAlgorithm.hh"               36 #include "G4VImportanceAlgorithm.hh"
 33 #include "G4GeometryCell.hh"                       37 #include "G4GeometryCell.hh"
 34 #include "G4SamplingPostStepAction.hh"             38 #include "G4SamplingPostStepAction.hh"
 35 #include "G4VTrackTerminator.hh"                   39 #include "G4VTrackTerminator.hh"
 36 #include "G4VIStore.hh"                            40 #include "G4VIStore.hh"
 37                                                    41 
 38 #include "G4Step.hh"                               42 #include "G4Step.hh"
 39 #include "G4Navigator.hh"                          43 #include "G4Navigator.hh"
 40 #include "G4VTouchable.hh"                         44 #include "G4VTouchable.hh"
 41 #include "G4VPhysicalVolume.hh"                    45 #include "G4VPhysicalVolume.hh"
 42 #include "G4ParticleChange.hh"                     46 #include "G4ParticleChange.hh"
 43 #include "G4PathFinder.hh"                         47 #include "G4PathFinder.hh"
 44 #include "G4TransportationManager.hh"              48 #include "G4TransportationManager.hh"
 45 #include "G4StepPoint.hh"                          49 #include "G4StepPoint.hh"
 46 #include "G4FieldTrackUpdator.hh"                  50 #include "G4FieldTrackUpdator.hh"
 47                                                    51 
 48                                                    52 
 49 G4ImportanceProcess::                              53 G4ImportanceProcess::
 50 G4ImportanceProcess(const G4VImportanceAlgorit     54 G4ImportanceProcess(const G4VImportanceAlgorithm &aImportanceAlgorithm,
 51                     const G4VIStore &aIstore,  <<  55                         const G4VIStore &aIstore,
 52                     const G4VTrackTerminator * <<  56                         const G4VTrackTerminator *TrackTerminator,
 53                     const G4String &aName, G4b <<  57                         const G4String &aName, G4bool para)
 54  : G4VProcess(aName, fParallel),               <<  58  : G4VProcess(aName),
 55    fParticleChange(new G4ParticleChange),          59    fParticleChange(new G4ParticleChange),
 56    fImportanceAlgorithm(aImportanceAlgorithm),     60    fImportanceAlgorithm(aImportanceAlgorithm),
 57    fIStore(aIstore),                               61    fIStore(aIstore),
 58    fParaflag(para)                             <<  62    fPostStepAction(0),
                                                   >>  63    fGhostWorldName("NoParallelWorld"),fGhostWorld(0),
                                                   >>  64    fGhostNavigator(0), fNavigatorID(-1), fFieldTrack('0'),
                                                   >>  65    fParaflag(para), fEndTrack('0'), feLimited(kDoNot)  
 59 {                                                  66 {
 60   G4cout << "### G4ImportanceProcess:: Creatin <<  67   G4cout << G4endl << G4endl << G4endl;
 61   if (TrackTerminator != nullptr)              <<  68   G4cout << "G4ImportanceProcess:: Creating " << G4endl;
                                                   >>  69   if (TrackTerminator)
 62   {                                                70   {
 63     fPostStepAction = new G4SamplingPostStepAc     71     fPostStepAction = new G4SamplingPostStepAction(*TrackTerminator);
 64   }                                                72   }
 65   else                                             73   else
 66   {                                                74   {
 67     fPostStepAction = new G4SamplingPostStepAc     75     fPostStepAction = new G4SamplingPostStepAction(*this);
 68   }                                                76   }
 69   if (fParticleChange == nullptr)              <<  77   if (!fParticleChange)
 70   {                                                78   {
 71     G4Exception("G4ImportanceProcess::G4Import     79     G4Exception("G4ImportanceProcess::G4ImportanceProcess()",
 72                 "FatalError", FatalException,      80                 "FatalError", FatalException,
 73                 "Failed allocation of G4Partic     81                 "Failed allocation of G4ParticleChange !");
 74   }                                                82   }
 75   G4VProcess::pParticleChange = fParticleChang     83   G4VProcess::pParticleChange = fParticleChange;
 76                                                    84 
 77                                                    85 
 78   fGhostStep = new G4Step();                       86   fGhostStep = new G4Step();
 79   fGhostPreStepPoint = fGhostStep->GetPreStepP     87   fGhostPreStepPoint = fGhostStep->GetPreStepPoint();
 80   fGhostPostStepPoint = fGhostStep->GetPostSte     88   fGhostPostStepPoint = fGhostStep->GetPostStepPoint();
 81                                                    89 
 82   fTransportationManager = G4TransportationMan     90   fTransportationManager = G4TransportationManager::GetTransportationManager();
 83   fPathFinder = G4PathFinder::GetInstance();       91   fPathFinder = G4PathFinder::GetInstance();
 84                                                    92 
 85   if (verboseLevel>0)                              93   if (verboseLevel>0)
 86   {                                                94   {
 87     G4cout << GetProcessName() << " is created     95     G4cout << GetProcessName() << " is created " << G4endl;
 88   }                                                96   }
 89                                                    97 
 90   G4cout << "G4ImportanceProcess:: importance      98   G4cout << "G4ImportanceProcess:: importance process paraflag is: " << fParaflag << G4endl;
 91                                                    99 
 92 }                                                 100 }
 93                                                   101 
 94 G4ImportanceProcess::~G4ImportanceProcess()       102 G4ImportanceProcess::~G4ImportanceProcess()
 95 {                                                 103 {
                                                   >> 104 
 96   delete fPostStepAction;                         105   delete fPostStepAction;
 97   delete fParticleChange;                         106   delete fParticleChange;
                                                   >> 107   //  delete fGhostStep;
                                                   >> 108   // delete fGhostWorld;
                                                   >> 109   // delete fGhostNavigator;
                                                   >> 110 
 98 }                                                 111 }
 99                                                   112 
                                                   >> 113 
                                                   >> 114 
100 //--------------------------------------------    115 //------------------------------------------------------
101 //                                                116 //
102 // SetParallelWorld                               117 // SetParallelWorld 
103 //                                                118 //
104 //--------------------------------------------    119 //------------------------------------------------------
105 void G4ImportanceProcess::SetParallelWorld(con << 120 void G4ImportanceProcess::
                                                   >> 121 SetParallelWorld(const G4String &parallelWorldName)
106 {                                                 122 {
107   G4cout << G4endl << G4endl << G4endl;           123   G4cout << G4endl << G4endl << G4endl;
108   G4cout << "G4ImportanceProcess:: SetParallel    124   G4cout << "G4ImportanceProcess:: SetParallelWorld name = " << parallelWorldName << G4endl;
109 //++++++++++++++++++++++++++++++++++++++++++++    125 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
110 // Get pointers of the parallel world and its     126 // Get pointers of the parallel world and its navigator
111 //++++++++++++++++++++++++++++++++++++++++++++    127 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
112   fGhostWorldName = parallelWorldName;            128   fGhostWorldName = parallelWorldName;
113   fGhostWorld = fTransportationManager->GetPar    129   fGhostWorld = fTransportationManager->GetParallelWorld(fGhostWorldName);
114   fGhostNavigator = fTransportationManager->Ge    130   fGhostNavigator = fTransportationManager->GetNavigator(fGhostWorld);
115 //++++++++++++++++++++++++++++++++++++++++++++    131 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
116 }                                                 132 }
117                                                   133 
                                                   >> 134 // void G4ImportanceProcess::
                                                   >> 135 // SetParallelWorld(const G4VPhysicalVolume* parallelWorld)
                                                   >> 136 // {
                                                   >> 137 // //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                                   >> 138 // // Get pointer of navigator
                                                   >> 139 // //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                                   >> 140 //   // G4cout << " G4ImportanceProcess:: Got here 1 " << G4endl;
                                                   >> 141 //   // fGhostWorldName = parallelWorld->GetName();
                                                   >> 142 //   // G4cout << " G4ImportanceProcess:: Got here 2 ghostName:" << fGhostWorldName << G4endl;
                                                   >> 143 //   fGhostWorld = parallelWorld;
                                                   >> 144 //   G4cout << " G4ImportanceProcess:: Got here 3 " << G4endl;
                                                   >> 145 //   fGhostNavigator = fTransportationManager->GetNavigator(parallelWorld);
                                                   >> 146 //   G4cout << " G4ImportanceProcess:: Got here 4 " << G4endl;
                                                   >> 147 // //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                                   >> 148 // }
                                                   >> 149 
118 //--------------------------------------------    150 //------------------------------------------------------
119 //                                                151 //
120 // StartTracking                                  152 // StartTracking
121 //                                                153 //
122 //--------------------------------------------    154 //------------------------------------------------------
123 void G4ImportanceProcess::StartTracking(G4Trac    155 void G4ImportanceProcess::StartTracking(G4Track* trk)
124 {                                                 156 {
125 //++++++++++++++++++++++++++++++++++++++++++++    157 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
126 // Activate navigator and get the navigator ID    158 // Activate navigator and get the navigator ID
127 //++++++++++++++++++++++++++++++++++++++++++++    159 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                                   >> 160 // G4cout << " G4ParallelWorldScoringProcess::StartTracking" << G4endl;
128                                                   161 
129   if(fParaflag)                                << 162   if(fParaflag) {
130   {                                            << 163     if(fGhostNavigator)
131     if(fGhostNavigator != nullptr)             << 164       { fNavigatorID = fTransportationManager->ActivateNavigator(fGhostNavigator); }
132     {                                          << 
133       fNavigatorID = fTransportationManager->A << 
134     }                                          << 
135     else                                          165     else
136     {                                          << 166       {
137       G4Exception("G4ImportanceProcess::StartT << 167   G4Exception("G4ImportanceProcess::StartTracking",
138                   "ProcParaWorld000",FatalExce << 168         "ProcParaWorld000",FatalException,
139                   "G4ImportanceProcess is used << 169         "G4ImportanceProcess is used for tracking without having a parallel world assigned");
140     }                                          << 170       }
                                                   >> 171 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
141                                                   172 
                                                   >> 173 // G4cout << "G4ParallelWorldScoringProcess::StartTracking <<<<<<<<<<<<<<<<<< " << G4endl;
142 //++++++++++++++++++++++++++++++++++++++++++++    174 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
143 // Let PathFinder initialize                      175 // Let PathFinder initialize
144 //++++++++++++++++++++++++++++++++++++++++++++    176 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
145     fPathFinder->PrepareNewTrack(trk->GetPosit    177     fPathFinder->PrepareNewTrack(trk->GetPosition(),trk->GetMomentumDirection());
                                                   >> 178 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
146                                                   179 
147 //++++++++++++++++++++++++++++++++++++++++++++    180 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
148 // Setup initial touchables for the first step    181 // Setup initial touchables for the first step
149 //++++++++++++++++++++++++++++++++++++++++++++    182 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
150     fOldGhostTouchable = fPathFinder->CreateTo    183     fOldGhostTouchable = fPathFinder->CreateTouchableHandle(fNavigatorID);
151     fGhostPreStepPoint->SetTouchableHandle(fOl    184     fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
152     fNewGhostTouchable = fOldGhostTouchable;      185     fNewGhostTouchable = fOldGhostTouchable;
153     fGhostPostStepPoint->SetTouchableHandle(fN    186     fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
154                                                   187 
155   // Initialize                                   188   // Initialize 
156     fGhostSafety = -1.;                           189     fGhostSafety = -1.;
157     fOnBoundary = false;                          190     fOnBoundary = false;
158   }                                               191   }
                                                   >> 192 
159 }                                                 193 }
160                                                   194 
                                                   >> 195 
161 G4double G4ImportanceProcess::                    196 G4double G4ImportanceProcess::
162 PostStepGetPhysicalInteractionLength(const G4T << 197 PostStepGetPhysicalInteractionLength(const G4Track& ,
                                                   >> 198                                      G4double   ,
163                                      G4ForceCo    199                                      G4ForceCondition* condition)
164 {                                                 200 {
                                                   >> 201 //   *condition = Forced;
                                                   >> 202 //   return kInfinity;
                                                   >> 203 
                                                   >> 204 //  *condition = StronglyForced;
165   *condition = Forced;                            205   *condition = Forced;
166   return DBL_MAX;                                 206   return DBL_MAX;
167 }                                                 207 }
168                                                   208   
169 G4VParticleChange *                               209 G4VParticleChange *
170 G4ImportanceProcess::PostStepDoIt(const G4Trac    210 G4ImportanceProcess::PostStepDoIt(const G4Track &aTrack,
171                                       const G4    211                                       const G4Step &aStep)
172 {                                                 212 {
173   fParticleChange->Initialize(aTrack);            213   fParticleChange->Initialize(aTrack);
174                                                   214 
175   if(aTrack.GetNextVolume() == nullptr)        << 215   if(fParaflag) {
176   {                                            << 
177     return fParticleChange;                    << 
178   }                                            << 
179                                                << 
180   if(fParaflag)                                << 
181   {                                            << 
182     fOldGhostTouchable = fGhostPostStepPoint->    216     fOldGhostTouchable = fGhostPostStepPoint->GetTouchableHandle();
183     //xbug?    fOnBoundary = false;               217     //xbug?    fOnBoundary = false;
184     CopyStep(aStep);                              218     CopyStep(aStep);
185                                                   219     
186     if(fOnBoundary)                               220     if(fOnBoundary)
187     {                                          << 221       {
188 //++++++++++++++++++++++++++++++++++++++++++++    222 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
189 // Locate the point and get new touchable         223 // Locate the point and get new touchable
190 //++++++++++++++++++++++++++++++++++++++++++++    224 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
191   //??  fPathFinder->Locate(step.GetPostStepPo    225   //??  fPathFinder->Locate(step.GetPostStepPoint()->GetPosition(),
192   //??                      step.GetPostStepPo    226   //??                      step.GetPostStepPoint()->GetMomentumDirection());
193   fNewGhostTouchable = fPathFinder->CreateTouc    227   fNewGhostTouchable = fPathFinder->CreateTouchableHandle(fNavigatorID);
194     }                                          << 228   //AH  G4cout << " on boundary " << G4endl;
                                                   >> 229 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                                   >> 230       }
195     else                                          231     else
196     {                                          << 232       {
197       // reuse the touchable                   << 233   // Do I need this ??????????????????????????????????????????????????????????
198       fNewGhostTouchable = fOldGhostTouchable; << 234   // fGhostNavigator->LocateGlobalPointWithinVolume(track.GetPosition());
199     }                                          << 235   // ?????????????????????????????????????????????????????????????????????????
                                                   >> 236   
                                                   >> 237   // fPathFinder->ReLocate(track.GetPosition());
                                                   >> 238   
                                                   >> 239   // reuse the touchable
                                                   >> 240   fNewGhostTouchable = fOldGhostTouchable;
                                                   >> 241   //AH  G4cout << " NOT on boundary " << G4endl;
                                                   >> 242       }
200                                                   243     
201     fGhostPreStepPoint->SetTouchableHandle(fOl    244     fGhostPreStepPoint->SetTouchableHandle(fOldGhostTouchable);
202     fGhostPostStepPoint->SetTouchableHandle(fN    245     fGhostPostStepPoint->SetTouchableHandle(fNewGhostTouchable);
203                                                   246     
                                                   >> 247 //   if ( (aStep.GetPostStepPoint()->GetStepStatus() == fGeomBoundary)
                                                   >> 248 //     && (aStep.GetStepLength() > kCarTolerance) )
                                                   >> 249 //   {
                                                   >> 250 //     if (aTrack.GetTrackStatus()==fStopAndKill)
                                                   >> 251 //     {
                                                   >> 252 //       G4cout << "WARNING - G4ImportanceProcess::PostStepDoIt()"
                                                   >> 253 //              << "          StopAndKill track." << G4endl;
                                                   >> 254 //     }
                                                   >> 255 
                                                   >> 256 //     G4StepPoint *prepoint  = aStep.GetPreStepPoint();
                                                   >> 257 //     G4StepPoint *postpoint = aStep.GetPostStepPoint();
                                                   >> 258 //     G4GeometryCell prekey(*(prepoint->GetPhysicalVolume()), 
                                                   >> 259 //                          prepoint->GetTouchable()->GetReplicaNumber());
                                                   >> 260 //     G4GeometryCell postkey(*(postpoint->GetPhysicalVolume()), 
                                                   >> 261 //                           postpoint->GetTouchable()->GetReplicaNumber());
                                                   >> 262 
                                                   >> 263 
204     if ( (fGhostPostStepPoint->GetStepStatus()    264     if ( (fGhostPostStepPoint->GetStepStatus() == fGeomBoundary)
205    && (aStep.GetStepLength() > kCarTolerance)     265    && (aStep.GetStepLength() > kCarTolerance) )
206     {                                          << 
207       if (aTrack.GetTrackStatus()==fStopAndKil << 
208       {                                           266       {
209         G4cout << "WARNING - G4ImportanceProce << 267   if (aTrack.GetTrackStatus()==fStopAndKill)
210                << "          StopAndKill track << 268     {
                                                   >> 269       G4cout << "WARNING - G4ImportanceProcess::PostStepDoIt()"
                                                   >> 270        << "          StopAndKill track. on boundary" << G4endl;
                                                   >> 271     }
                                                   >> 272   
                                                   >> 273   G4GeometryCell prekey(*(fGhostPreStepPoint->GetPhysicalVolume()), 
                                                   >> 274             fGhostPreStepPoint->GetTouchable()->GetReplicaNumber());
                                                   >> 275   G4GeometryCell postkey(*(fGhostPostStepPoint->GetPhysicalVolume()), 
                                                   >> 276              fGhostPostStepPoint->GetTouchable()->GetReplicaNumber());
                                                   >> 277   
                                                   >> 278   //AH
                                                   >> 279   /*
                                                   >> 280   G4cout << G4endl;
                                                   >> 281   G4cout << G4endl;
                                                   >> 282   G4cout << " inside parallel importance process " << aTrack.GetCurrentStepNumber() << G4endl;
                                                   >> 283   G4cout << G4endl;
                                                   >> 284   G4cout << G4endl;
                                                   >> 285   G4cout << " prekey: " << fGhostPreStepPoint->GetPhysicalVolume()->GetName() << " replica:" 
                                                   >> 286          << fGhostPreStepPoint->GetTouchable()->GetReplicaNumber() << G4endl;
                                                   >> 287   G4cout << " prekey ISTORE: " << fIStore.GetImportance(prekey) << G4endl;
                                                   >> 288   G4cout << " postkey: " << G4endl;
                                                   >> 289   G4cout << " postkey ISTORE: " << fIStore.GetImportance(postkey) << G4endl;
                                                   >> 290   */
                                                   >> 291   //AH
                                                   >> 292   G4Nsplit_Weight nw = fImportanceAlgorithm.
                                                   >> 293     Calculate(fIStore.GetImportance(prekey),
                                                   >> 294         fIStore.GetImportance(postkey), 
                                                   >> 295         aTrack.GetWeight());
                                                   >> 296   //AH
                                                   >> 297   /*
                                                   >> 298   G4cout << " prekey weight: " << fIStore.GetImportance(prekey) 
                                                   >> 299          << " postkey weight: " << fIStore.GetImportance(postkey) 
                                                   >> 300          << " split weight: " << nw << G4endl;
                                                   >> 301   G4cout << " before poststepaction " << G4endl;
                                                   >> 302   */
                                                   >> 303   //AH
                                                   >> 304   fPostStepAction->DoIt(aTrack, fParticleChange, nw);
                                                   >> 305   //AH  G4cout << " after post step do it " << G4endl;
211       }                                           306       }
212                                                << 307   } else {
213       G4GeometryCell prekey(*(fGhostPreStepPoi << 
214                             fGhostPreStepPoint << 
215       G4GeometryCell postkey(*(fGhostPostStepP << 
216                              fGhostPostStepPoi << 
217                                                << 
218       G4Nsplit_Weight nw =                     << 
219           fImportanceAlgorithm.Calculate(fISto << 
220                              fIStore.GetImport << 
221                              aTrack.GetWeight( << 
222       fPostStepAction->DoIt(aTrack, fParticleC << 
223     }                                          << 
224   }                                            << 
225   else                                         << 
226   {                                            << 
227     if ( (aStep.GetPostStepPoint()->GetStepSta    308     if ( (aStep.GetPostStepPoint()->GetStepStatus() == fGeomBoundary)
228          && (aStep.GetStepLength() > kCarToler << 309    && (aStep.GetStepLength() > kCarTolerance) )
229     {                                          << 
230       if (aTrack.GetTrackStatus()==fStopAndKil << 
231       {                                           310       {
232         G4cout << "WARNING - G4ImportanceProce << 311   //AH  G4cout << " inside non-parallel importance process " << G4endl;
233                << "          StopAndKill track << 312   if (aTrack.GetTrackStatus()==fStopAndKill)
234                << G4endl;                      << 313     {
235       }                                        << 314       G4cout << "WARNING - G4ImportanceProcess::PostStepDoIt()"
                                                   >> 315        << "          StopAndKill track. on boundary non-parallel" << G4endl;
                                                   >> 316     }
236                                                   317   
237       G4StepPoint *prepoint  = aStep.GetPreSte << 318   G4StepPoint *prepoint  = aStep.GetPreStepPoint();
238       G4StepPoint *postpoint = aStep.GetPostSt << 319   G4StepPoint *postpoint = aStep.GetPostStepPoint();
239                                                << 320   
240       G4GeometryCell prekey(*(prepoint->GetPhy << 321   G4GeometryCell prekey(*(prepoint->GetPhysicalVolume()), 
241                             prepoint->GetTouch << 322             prepoint->GetTouchable()->GetReplicaNumber());
242       G4GeometryCell postkey(*(postpoint->GetP << 323   G4GeometryCell postkey(*(postpoint->GetPhysicalVolume()), 
243                              postpoint->GetTou << 324              postpoint->GetTouchable()->GetReplicaNumber());
244                                                << 325   
245       G4Nsplit_Weight nw =                     << 326   G4Nsplit_Weight nw = fImportanceAlgorithm.
246           fImportanceAlgorithm.Calculate(fISto << 327     Calculate(fIStore.GetImportance(prekey),
247                                          fISto << 328         fIStore.GetImportance(postkey), 
248                                          aTrac << 329         aTrack.GetWeight());
                                                   >> 330   //AH
                                                   >> 331   /*
                                                   >> 332   G4cout << " prekey weight: " << fIStore.GetImportance(prekey) 
                                                   >> 333          << " postkey weight: " << fIStore.GetImportance(postkey) 
                                                   >> 334          << " split weight: " << nw << G4endl;
                                                   >> 335   G4cout << " before poststepaction 2 " << G4endl;
                                                   >> 336   */
                                                   >> 337   //AH
249   fPostStepAction->DoIt(aTrack, fParticleChang    338   fPostStepAction->DoIt(aTrack, fParticleChange, nw);
250     }                                          << 339   //AH  G4cout << " after poststepaction 2 " << G4endl;
                                                   >> 340       }
251   }                                               341   }
252   return fParticleChange;                         342   return fParticleChange;
253 }                                                 343 }
254                                                   344 
255 void G4ImportanceProcess::KillTrack() const       345 void G4ImportanceProcess::KillTrack() const
256 {                                                 346 {
257   fParticleChange->ProposeTrackStatus(fStopAnd    347   fParticleChange->ProposeTrackStatus(fStopAndKill);
258 }                                                 348 }
259                                                   349 
260 const G4String& G4ImportanceProcess::GetName() << 350 const G4String &G4ImportanceProcess::GetName() const
261 {                                                 351 {
262   return theProcessName;                          352   return theProcessName;
263 }                                                 353 }
264                                                   354 
265 G4double G4ImportanceProcess::                    355 G4double G4ImportanceProcess::
266 AlongStepGetPhysicalInteractionLength(            356 AlongStepGetPhysicalInteractionLength(
267                     const G4Track& track, G4do << 357             const G4Track& track, G4double  previousStepSize, G4double  currentMinimumStep,
268                     G4double currentMinimumSte << 358             G4double& proposedSafety, G4GPILSelection* selection)
269                     G4double& proposedSafety,  << 
270 {                                                 359 {
271   if(fParaflag)                                << 360   if(fParaflag) {    
272   {                                            << 
273     *selection = NotCandidateForSelection;        361     *selection = NotCandidateForSelection;
274     G4double returnedStep = DBL_MAX;              362     G4double returnedStep = DBL_MAX;
275                                                   363     
276     if (previousStepSize > 0.)                    364     if (previousStepSize > 0.)
277       { fGhostSafety -= previousStepSize; }       365       { fGhostSafety -= previousStepSize; }
278     //  else                                      366     //  else
279     //  { fGhostSafety = -1.; }                   367     //  { fGhostSafety = -1.; }
280     if (fGhostSafety < 0.) { fGhostSafety = 0. << 368     if (fGhostSafety < 0.) fGhostSafety = 0.0;
281                                                   369     
282     // ---------------------------------------    370     // ------------------------------------------
283     // Determination of the proposed STEP LENG    371     // Determination of the proposed STEP LENGTH:
284     // ---------------------------------------    372     // ------------------------------------------
285     if (currentMinimumStep <= fGhostSafety &&     373     if (currentMinimumStep <= fGhostSafety && currentMinimumStep > 0.)
286     {                                          << 
287       // I have no chance to limit             << 
288       returnedStep = currentMinimumStep;       << 
289       fOnBoundary = false;                     << 
290       proposedSafety = fGhostSafety - currentM << 
291     }                                          << 
292     else // (currentMinimumStep > fGhostSafety << 
293     {                                          << 
294       G4FieldTrackUpdator::Update(&fFieldTrack << 
295       //++++++++++++++++++++++++++++++++++++++ << 
296       // ComputeStep                           << 
297       //++++++++++++++++++++++++++++++++++++++ << 
298       returnedStep                             << 
299     = fPathFinder->ComputeStep(fFieldTrack,cur << 
300                                      track.Get << 
301                                      fEndTrack << 
302       //++++++++++++++++++++++++++++++++++++++ << 
303       if(feLimited == kDoNot)                  << 
304       {                                        << 
305         // Track is not on the boundary        << 
306         fOnBoundary = false;                   << 
307         fGhostSafety = fGhostNavigator->Comput << 
308       }                                        << 
309       else                                     << 
310       {                                           374       {
311         // Track is on the boundary            << 375   // I have no chance to limit
312         fOnBoundary = true;                    << 376   returnedStep = currentMinimumStep;
                                                   >> 377   fOnBoundary = false;
                                                   >> 378   proposedSafety = fGhostSafety - currentMinimumStep;
                                                   >> 379   //AH  G4cout << " step not limited, why? " << G4endl;
313       }                                           380       }
314       proposedSafety = fGhostSafety;           << 381     else // (currentMinimumStep > fGhostSafety: I may limit the Step)
315       if(feLimited == kUnique || feLimited ==  << 
316       {                                           382       {
317         *selection = CandidateForSelection;    << 383   G4FieldTrackUpdator::Update(&fFieldTrack,&track);
318       }                                        << 384   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
319       else if (feLimited == kSharedTransport)  << 385   // ComputeStep
320       {                                        << 386   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
321         returnedStep *= (1.0 + 1.0e-9);        << 387   returnedStep
322         // Expand to disable its selection in  << 388     = fPathFinder->ComputeStep(fFieldTrack,currentMinimumStep,fNavigatorID,
                                                   >> 389              track.GetCurrentStepNumber(),fGhostSafety,feLimited,
                                                   >> 390              fEndTrack,track.GetVolume());
                                                   >> 391   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
                                                   >> 392   if(feLimited == kDoNot)
                                                   >> 393     {
                                                   >> 394       //AH      G4cout << " computestep came back with not-boundary " << G4endl;
                                                   >> 395       // Track is not on the boundary
                                                   >> 396       fOnBoundary = false;
                                                   >> 397       fGhostSafety = fGhostNavigator->ComputeSafety(fEndTrack.GetPosition());
                                                   >> 398     }
                                                   >> 399   else
                                                   >> 400     {
                                                   >> 401       // Track is on the boundary
                                                   >> 402       //AH      G4cout << " FOUND A BOUNDARY ! " << track.GetCurrentStepNumber() << G4endl;
                                                   >> 403       fOnBoundary = true;
                                                   >> 404       // proposedSafety = fGhostSafety;
                                                   >> 405     }
                                                   >> 406   proposedSafety = fGhostSafety;
                                                   >> 407   if(feLimited == kUnique || feLimited == kSharedOther) {
                                                   >> 408     *selection = CandidateForSelection;
                                                   >> 409   }else if (feLimited == kSharedTransport) { 
                                                   >> 410     returnedStep *= (1.0 + 1.0e-9);  
                                                   >> 411     // Expand to disable its selection in Step Manager comparison
                                                   >> 412   }
                                                   >> 413   
323       }                                           414       }
324     }                                          << 
325                                                   415 
326     // --------------------------------------- << 416   // ----------------------------------------------
327     // Returns the fGhostSafety as the propose << 417   // Returns the fGhostSafety as the proposedSafety
328     // The SteppingManager will take care of k << 418   // The SteppingManager will take care of keeping
329     // the smallest one.                       << 419   // the smallest one.
330     // --------------------------------------- << 420   // ----------------------------------------------
331     return returnedStep;                          421     return returnedStep;
332   }                                            << 422 
333   else                                         << 423   } else {
334   {                                            << 424 
335     return DBL_MAX;                               425     return DBL_MAX;
                                                   >> 426 
336   }                                               427   }
                                                   >> 428 
337 }                                                 429 }
338                                                   430 
339 G4double G4ImportanceProcess::                    431 G4double G4ImportanceProcess::
340 AtRestGetPhysicalInteractionLength(const G4Tra    432 AtRestGetPhysicalInteractionLength(const G4Track& ,
341                                    G4ForceCond    433                                    G4ForceCondition*) 
342 {                                                 434 {
343   return -1.0;                                    435   return -1.0;
344 }                                                 436 }
345                                                   437   
346 G4VParticleChange* G4ImportanceProcess::          438 G4VParticleChange* G4ImportanceProcess::
347 AtRestDoIt(const G4Track&, const G4Step&)         439 AtRestDoIt(const G4Track&, const G4Step&) 
348 {                                                 440 {
349   return nullptr;                              << 441   return 0;
350 }                                                 442 }
351                                                   443 
352 G4VParticleChange* G4ImportanceProcess::          444 G4VParticleChange* G4ImportanceProcess::
353 AlongStepDoIt(const G4Track& aTrack, const G4S    445 AlongStepDoIt(const G4Track& aTrack, const G4Step& )
354 {                                                 446 {
355   // Dummy ParticleChange ie: does nothing        447   // Dummy ParticleChange ie: does nothing
356   // Expecting G4Transportation to move the tr    448   // Expecting G4Transportation to move the track
                                                   >> 449   //AH  G4cout << " along step do it " << G4endl;
357   pParticleChange->Initialize(aTrack);            450   pParticleChange->Initialize(aTrack);
358   return pParticleChange;                         451   return pParticleChange; 
                                                   >> 452   //  return 0;
359 }                                                 453 }
360                                                   454 
361 void G4ImportanceProcess::CopyStep(const G4Ste << 455 void G4ImportanceProcess::CopyStep(const G4Step & step)
362 {                                                 456 {
363   fGhostStep->SetTrack(step.GetTrack());          457   fGhostStep->SetTrack(step.GetTrack());
364   fGhostStep->SetStepLength(step.GetStepLength    458   fGhostStep->SetStepLength(step.GetStepLength());
365   fGhostStep->SetTotalEnergyDeposit(step.GetTo    459   fGhostStep->SetTotalEnergyDeposit(step.GetTotalEnergyDeposit());
366   fGhostStep->SetControlFlag(step.GetControlFl    460   fGhostStep->SetControlFlag(step.GetControlFlag());
367                                                   461 
368   *fGhostPreStepPoint = *(step.GetPreStepPoint    462   *fGhostPreStepPoint = *(step.GetPreStepPoint());
369   *fGhostPostStepPoint = *(step.GetPostStepPoi    463   *fGhostPostStepPoint = *(step.GetPostStepPoint());
370                                                   464 
371 //++++++++++++++++++++++++++++++++++++++++++++    465 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
372 // Set StepStatus for ghost world                 466 // Set StepStatus for ghost world
373 //++++++++++++++++++++++++++++++++++++++++++++    467 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
374   if(fOnBoundary)                                 468   if(fOnBoundary)
375   { fGhostPostStepPoint->SetStepStatus(fGeomBo    469   { fGhostPostStepPoint->SetStepStatus(fGeomBoundary); }
376   else if(fGhostPostStepPoint->GetStepStatus()    470   else if(fGhostPostStepPoint->GetStepStatus()==fGeomBoundary)
377   { fGhostPostStepPoint->SetStepStatus(fPostSt    471   { fGhostPostStepPoint->SetStepStatus(fPostStepDoItProc); }
378 //++++++++++++++++++++++++++++++++++++++++++++    472 //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
379 }                                                 473 }
380                                                   474