Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/dna/management/src/G4ITSafetyHelper.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/G4ITSafetyHelper.cc (Version 11.3.0) and /processes/electromagnetic/dna/management/src/G4ITSafetyHelper.cc (Version 10.3)


  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: G4ITSafetyHelper.cc 72309 2013-07-15 15:52:17Z gcosmo $
 26 // GEANT4 tag $ Name:  $                           27 // GEANT4 tag $ Name:  $
 27 //                                                 28 // 
 28 // class G4ITSafetyHelper Implementation           29 // class G4ITSafetyHelper Implementation
 29 //                                                 30 //
 30 // Original author: John Apostolakis, 2006         31 // Original author: John Apostolakis, 2006
 31 //                                                 32 //
 32 // -------------------------------------------     33 // --------------------------------------------------------------------
 33                                                    34 
 34 #include "G4ITSafetyHelper.hh"                     35 #include "G4ITSafetyHelper.hh"
 35 #include "G4ITPathFinder.hh"                       36 #include "G4ITPathFinder.hh"
 36 #include "G4ITTransportationManager.hh"            37 #include "G4ITTransportationManager.hh"
 37 #include "G4ITNavigator.hh"                        38 #include "G4ITNavigator.hh"
 38 #include "G4PathFinder.hh"                         39 #include "G4PathFinder.hh"
 39 #include "globals.hh"                              40 #include "globals.hh"
 40                                                    41 
 41 G4ITSafetyHelper::G4ITSafetyHelper()           <<  42 G4ITSafetyHelper::G4ITSafetyHelper() :
                                                   >>  43     G4TrackStateDependent<G4ITSafetyHelper>(), fUseParallelGeometries(false), // By default, one geometry only
                                                   >>  44     fFirstCall(true), fVerbose(0)
                                                   >>  45 // fRecomputeFactor(0.0)
 42 {                                                  46 {
 43   fpPathFinder = nullptr; //  Cannot initialis <<  47   fpPathFinder = 0; //  Cannot initialise this yet - a loop results
 44                                                    48 
 45   // Initialization of the Navigator pointer i     49   // Initialization of the Navigator pointer is postponed, and must
 46   // be undertaken by another class calling In     50   // be undertaken by another class calling InitialiseHelper()
 47   //                                               51   //
 48   fpMassNavigator = nullptr;                   <<  52   fpMassNavigator = 0;
 49   fMassNavigatorId = -1;                           53   fMassNavigatorId = -1;
 50 }                                                  54 }
 51                                                    55 
 52 void G4ITSafetyHelper::InitialiseNavigator()       56 void G4ITSafetyHelper::InitialiseNavigator()
 53 {                                                  57 {
 54   fpPathFinder = G4PathFinder::GetInstance();      58   fpPathFinder = G4PathFinder::GetInstance();
 55                                                    59 
 56   G4ITTransportationManager* pTransportMgr =       60   G4ITTransportationManager* pTransportMgr =
 57       G4ITTransportationManager::GetTransporta     61       G4ITTransportationManager::GetTransportationManager();
 58                                                    62 
 59   fpMassNavigator = pTransportMgr->GetNavigato     63   fpMassNavigator = pTransportMgr->GetNavigatorForTracking();
 60                                                    64 
 61   if(fpMassNavigator == nullptr) abort();      <<  65   if(fpMassNavigator == 0) abort();
 62                                                    66 
 63   // Check                                         67   // Check
 64   //                                               68   //
 65   G4VPhysicalVolume* worldPV = fpMassNavigator     69   G4VPhysicalVolume* worldPV = fpMassNavigator->GetWorldVolume();
 66   if (worldPV == nullptr)                      <<  70   if (worldPV == 0)
 67   {                                                71   {
 68     G4Exception("G4ITSafetyHelper::InitialiseN     72     G4Exception("G4ITSafetyHelper::InitialiseNavigator",
 69                 "InvalidNavigatorWorld", Fatal     73                 "InvalidNavigatorWorld", FatalException,
 70                 "Found that existing tracking      74                 "Found that existing tracking Navigator has NULL world");
 71   }                                                75   }
 72                                                    76 
 73   // fMassNavigatorId = pTransportMgr->Activat     77   // fMassNavigatorId = pTransportMgr->ActivateNavigator( fpMassNavigator );
 74 }                                                  78 }
 75                                                    79 
 76 void G4ITSafetyHelper::InitialiseHelper()          80 void G4ITSafetyHelper::InitialiseHelper()
 77 {                                                  81 {
 78   NewTrackState();                                 82   NewTrackState();
 79   if (fFirstCall)                                  83   if (fFirstCall)
 80   {                                                84   {
 81     InitialiseNavigator();                         85     InitialiseNavigator();
 82   }                                                86   }
 83   fFirstCall = false;                              87   fFirstCall = false;
 84 }                                                  88 }
 85                                                    89 
 86 G4ITSafetyHelper::~G4ITSafetyHelper()              90 G4ITSafetyHelper::~G4ITSafetyHelper()
 87 = default;                                     <<  91 {
                                                   >>  92 }
 88                                                    93 
 89 G4double G4ITSafetyHelper::CheckNextStep(const     94 G4double G4ITSafetyHelper::CheckNextStep(const G4ThreeVector &position,
 90                                          const     95                                          const G4ThreeVector &direction,
 91                                          const     96                                          const G4double currentMaxStep,
 92                                          G4dou     97                                          G4double& newSafety)
 93 {                                                  98 {
 94   // Distance in the Mass geometry                 99   // Distance in the Mass geometry
 95   //                                              100   //
 96   G4double linstep = fpMassNavigator->CheckNex    101   G4double linstep = fpMassNavigator->CheckNextStep(position, direction,
 97                                                   102                                                     currentMaxStep, newSafety);
 98   fpTrackState->fLastSafetyPosition = position    103   fpTrackState->fLastSafetyPosition = position;
 99   fpTrackState->fLastSafety = newSafety;          104   fpTrackState->fLastSafety = newSafety;
100                                                   105 
101   // TODO: Can replace this with a call to Pat    106   // TODO: Can replace this with a call to PathFinder
102   //        giving id of Mass Geometry --> thi    107   //        giving id of Mass Geometry --> this avoid doing the work twice
103                                                   108 
104   return linstep;                                 109   return linstep;
105 }                                                 110 }
106                                                   111 
107 G4double G4ITSafetyHelper::ComputeSafety(const    112 G4double G4ITSafetyHelper::ComputeSafety(const G4ThreeVector& position,
108                                          G4dou    113                                          G4double maxLength)
109 {                                                 114 {
110   G4double newSafety;                             115   G4double newSafety;
111                                                   116 
112   // Only recompute (calling Navigator/PathFin    117   // Only recompute (calling Navigator/PathFinder) if 'position'
113   // is  *not* the safety location and has mov    118   // is  *not* the safety location and has moved 'significantly'
114   //                                              119   //
115   G4double moveLengthSq = (position - fpTrackS    120   G4double moveLengthSq = (position - fpTrackState->fLastSafetyPosition).mag2();
116   if ((moveLengthSq > 0.0))                       121   if ((moveLengthSq > 0.0))
117   {                                               122   {
118     if (!fUseParallelGeometries)                  123     if (!fUseParallelGeometries)
119     {                                             124     {
120       // Safety for mass geometry                 125       // Safety for mass geometry
121       newSafety = fpMassNavigator->ComputeSafe    126       newSafety = fpMassNavigator->ComputeSafety(position, maxLength, true);
122     }                                             127     }
123     else                                          128     else
124     {                                             129     {
125       // Safety for all geometries                130       // Safety for all geometries
126       newSafety = fpPathFinder->ComputeSafety(    131       newSafety = fpPathFinder->ComputeSafety(position);
127     }                                             132     }
128                                                   133 
129     // We can only store a 'true' safety - one    134     // We can only store a 'true' safety - one that was not restricted by maxLength
130     if (newSafety < maxLength)                    135     if (newSafety < maxLength)
131     {                                             136     {
132       fpTrackState->fLastSafety = newSafety;      137       fpTrackState->fLastSafety = newSafety;
133       fpTrackState->fLastSafetyPosition = posi    138       fpTrackState->fLastSafetyPosition = position;
134     }                                             139     }
135   }                                               140   }
136   else                                            141   else
137   {                                               142   {
138     // return last value if position is not (s    143     // return last value if position is not (significantly) changed
139     //                                            144     //
140     // G4double moveLength = 0;                   145     // G4double moveLength = 0;
141     // if( moveLengthSq > 0.0 ) { moveLength=     146     // if( moveLengthSq > 0.0 ) { moveLength= std::sqrt(moveLengthSq); }
142     newSafety = fpTrackState->fLastSafety; //     147     newSafety = fpTrackState->fLastSafety; // -moveLength;
143   }                                               148   }
144   return newSafety;                               149   return newSafety;
145 }                                                 150 }
146                                                   151 
147 void G4ITSafetyHelper::ReLocateWithinVolume(co    152 void G4ITSafetyHelper::ReLocateWithinVolume(const G4ThreeVector &newPosition)
148 {                                                 153 {
149 #ifdef G4VERBOSE                                  154 #ifdef G4VERBOSE
150   if (fVerbose > 0)                               155   if (fVerbose > 0)
151   {                                               156   {
152     // There is an opportunity - and need - to    157     // There is an opportunity - and need - to check whether the proposed move is safe
153     G4ThreeVector moveVec = newPosition - fpTr    158     G4ThreeVector moveVec = newPosition - fpTrackState->fLastSafetyPosition;
154     if (moveVec.mag2() > sqr(fpTrackState->fLa    159     if (moveVec.mag2() > sqr(fpTrackState->fLastSafety))
155     {                                             160     {
156       // A problem exists - we are proposing t    161       // A problem exists - we are proposing to move outside 'Safety Sphere'
157       G4ExceptionDescription ed;                  162       G4ExceptionDescription ed;
158       ed << " Safety Sphere:  Radius = " << fp    163       ed << " Safety Sphere:  Radius = " << fpTrackState->fLastSafety;
159       ed << " Center   = " << fpTrackState->fL    164       ed << " Center   = " << fpTrackState->fLastSafetyPosition << G4endl;
160       ed << " New Location :  Move   = " << mo    165       ed << " New Location :  Move   = " << moveVec.mag2();
161       ed << " Position = " << newPosition << G    166       ed << " Position = " << newPosition << G4endl;
162       G4Exception("G4ITSafetyHelper::ReLocateW    167       G4Exception("G4ITSafetyHelper::ReLocateWithinVolume", "GeomNav999",
163                   JustWarning,                    168                   JustWarning,
164                   "Unsafe Move> Asked to reloc    169                   "Unsafe Move> Asked to relocate beyond 'Safety sphere'.");
165     }                                             170     }
166   }                                               171   }
167 #endif                                            172 #endif
168                                                   173 
169   if (!fUseParallelGeometries)                    174   if (!fUseParallelGeometries)
170   {                                               175   {
171     fpMassNavigator->LocateGlobalPointWithinVo    176     fpMassNavigator->LocateGlobalPointWithinVolume(newPosition);
172   }                                               177   }
173   else                                            178   else
174   {                                               179   {
175     fpPathFinder->ReLocate(newPosition);          180     fpPathFinder->ReLocate(newPosition);
176   }                                               181   }
177 }                                                 182 }
178                                                   183 
179 void G4ITSafetyHelper::Locate(const G4ThreeVec    184 void G4ITSafetyHelper::Locate(const G4ThreeVector& newPosition,
180                               const G4ThreeVec    185                               const G4ThreeVector& newDirection)
181 {                                                 186 {
182   if (!fUseParallelGeometries)                    187   if (!fUseParallelGeometries)
183   {                                               188   {
184     fpMassNavigator->LocateGlobalPointAndSetup    189     fpMassNavigator->LocateGlobalPointAndSetup(newPosition, &newDirection, true,
185                                                   190                                                false);
186   }                                               191   }
187   else                                            192   else
188   {                                               193   {
189     fpPathFinder->Locate(newPosition, newDirec    194     fpPathFinder->Locate(newPosition, newDirection);
190   }                                               195   }
191 }                                                 196 }
192                                                   197