Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/track/include/G4ParticleChangeForLoss.hh

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 /track/include/G4ParticleChangeForLoss.hh (Version 11.3.0) and /track/include/G4ParticleChangeForLoss.hh (Version 9.2.p3)


  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 // G4ParticleChangeForLoss                     << 
 27 //                                                 26 //
 28 // Class description:                          <<  27 // $Id: G4ParticleChangeForLoss.hh,v 1.20 2008/01/11 19:57:12 vnivanch Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-02-patch-03 $
 29 //                                                 29 //
 30 // Concrete class for ParticleChange for Energ <<  30 //
 31                                                <<  31 // ------------------------------------------------------------
 32 // Author: Hisaya Kurashige, 23 March 1998     <<  32 //  GEANT 4 class header file
 33 // Revision: Vladimir Ivantchenko, 16 January  <<  33 //
 34 //                                 24 August 2 <<  34 //
 35 // ------------------------------------------- <<  35 // ------------------------------------------------------------
 36 #ifndef G4ParticleChangeForLoss_hh             <<  36 //   Implemented for the new scheme                 23 Mar. 1998  H.Kurahige
 37 #define G4ParticleChangeForLoss_hh 1           <<  37 //
                                                   >>  38 //   Modified:
                                                   >>  39 //   16.01.04 V.Ivanchenko update for model variant of energy loss
                                                   >>  40 //   15.04.05 V.Ivanchenko inline update methods
                                                   >>  41 //   30.01.06 V.Ivanchenko add ProposedMomentumDirection for AlongStep
                                                   >>  42 //                         and ProposeWeight for PostStep
                                                   >>  43 //   07.06.06 V.Ivanchenko RemoveProposedMomentumDirection from AlongStep
                                                   >>  44 //   28.08.06 V.Ivanchenko Add access to current track and polarizaion
                                                   >>  45 //
                                                   >>  46 // ------------------------------------------------------------
                                                   >>  47 //
                                                   >>  48 //  Class Description
                                                   >>  49 //  This class is a concrete class for ParticleChange for EnergyLoss
                                                   >>  50 //
                                                   >>  51 #ifndef G4ParticleChangeForLoss_h
                                                   >>  52 #define G4ParticleChangeForLoss_h 1
 38                                                    53 
                                                   >>  54 #include "globals.hh"
                                                   >>  55 #include "G4ios.hh"
 39 #include "G4VParticleChange.hh"                    56 #include "G4VParticleChange.hh"
 40 #include "G4DynamicParticle.hh"                << 
 41                                                    57 
 42 class G4ParticleChangeForLoss final : public G <<  58 class G4DynamicParticle;
                                                   >>  59 
                                                   >>  60 class G4ParticleChangeForLoss: public G4VParticleChange
 43 {                                                  61 {
 44 public:                                            62 public:
 45                                                <<  63   // default constructor
 46   G4ParticleChangeForLoss();                       64   G4ParticleChangeForLoss();
 47                                                    65 
 48   ~G4ParticleChangeForLoss() override = defaul <<  66   // destructor
 49                                                <<  67   virtual ~G4ParticleChangeForLoss();
 50   G4ParticleChangeForLoss(const G4ParticleChan << 
 51   G4ParticleChangeForLoss& operator=(const G4P << 
 52                                                    68 
                                                   >>  69   // with description
                                                   >>  70   // ----------------------------------------------------
 53   // --- the following methods are for updatin     71   // --- the following methods are for updating G4Step -----
 54                                                    72 
 55   G4Step* UpdateStepForAlongStep(G4Step* step) <<  73   G4Step* UpdateStepForAlongStep(G4Step* Step);
 56   G4Step* UpdateStepForPostStep(G4Step* step)  <<  74   G4Step* UpdateStepForPostStep(G4Step* Step);
 57                                                <<  75   // A physics process gives the final state of the particle
 58   // Initialize all used properties            <<  76   // based on information of G4Track
 59   inline void InitializeForAlongStep(const G4T <<  77 
 60   inline void InitializeForPostStep(const G4Tr <<  78   void InitializeForAlongStep(const G4Track&);
 61                                                <<  79   void InitializeForPostStep(const G4Track&);
 62   // Get/Set dynamic charge                    <<  80   //Initialize all propoerties by using G4Track information
 63   inline G4double GetProposedCharge() const;   <<  81 
 64   inline void SetProposedCharge(G4double theCh <<  82   void AddSecondary(G4DynamicParticle* aParticle);
 65                                                <<  83   // Add next secondary
 66   // Get/Set the final kinetic energy of the c <<  84 
 67   inline G4double GetProposedKineticEnergy() c <<  85   G4double GetProposedCharge() const;
 68   inline void SetProposedKineticEnergy(G4doubl <<  86   void SetProposedCharge(G4double theCharge);
 69                                                <<  87   //   Get/Set theCharge
 70   // Get/Propose the MomentumDirection vector: <<  88 
 71   // direction                                 <<  89   G4double GetCharge() const;
 72   inline const G4ThreeVector& GetProposedMomen <<  90   void ProposeCharge(G4double finalCharge);
 73   inline void SetProposedMomentumDirection(con <<  91   //   Get/Propose the final dynamical Charge in G4DynamicParticle
 74   inline void ProposeMomentumDirection(const G <<  92 
 75                                                <<  93   G4double GetProposedKineticEnergy() const;
 76   inline const G4ThreeVector& GetProposedPolar <<  94   void SetProposedKineticEnergy(G4double proposedKinEnergy);
 77   inline void ProposePolarization(const G4Thre <<  95   // Get/Set the final kinetic energy of the current particle.
 78   inline void ProposePolarization(G4double Px, <<  96 
 79                                                <<  97   const G4ThreeVector& GetProposedMomentumDirection() const;
 80   void DumpInfo() const final;                 <<  98   void SetProposedMomentumDirection(const G4ThreeVector& dir);
                                                   >>  99   const G4ThreeVector& GetMomentumDirection() const;
                                                   >> 100   void ProposeMomentumDirection(G4double Px, G4double Py, G4double Pz);
                                                   >> 101   void ProposeMomentumDirection(const G4ThreeVector& Pfinal);
                                                   >> 102   // Get/Propose the MomentumDirection vector: it is the final momentum direction.
                                                   >> 103 
                                                   >> 104   const G4ThreeVector& GetProposedPolarization() const;
                                                   >> 105   void ProposePolarization(const G4ThreeVector& dir);
                                                   >> 106   void ProposePolarization(G4double Px, G4double Py, G4double Pz);
                                                   >> 107 
                                                   >> 108   const G4Track* GetCurrentTrack() const;
                                                   >> 109 
                                                   >> 110   virtual void DumpInfo() const;
                                                   >> 111 
                                                   >> 112   // for Debug
                                                   >> 113   virtual G4bool CheckIt(const G4Track&);
                                                   >> 114 
                                                   >> 115 protected:
                                                   >> 116   // hide copy constructor and assignment operaor as protected
                                                   >> 117   G4ParticleChangeForLoss(const G4ParticleChangeForLoss &right);
                                                   >> 118   G4ParticleChangeForLoss & operator=(const G4ParticleChangeForLoss &right);
 81                                                   119 
 82 private:                                          120 private:
 83                                                   121 
 84   G4double proposedKinEnergy = 0.0;            << 122   const G4Track* currentTrack;
 85   // The final kinetic energy of the current p << 123   // The pointer to G4Track
 86                                                   124 
 87   G4double currentCharge = 0.0;                << 125   G4double proposedKinEnergy;
 88       // The final charge of the current parti << 126   //  The final kinetic energy of the current particle.
                                                   >> 127 
                                                   >> 128   G4double currentCharge;
                                                   >> 129   //  The final charge of the current particle.
 89                                                   130 
 90   G4ThreeVector proposedMomentumDirection;        131   G4ThreeVector proposedMomentumDirection;
 91   // The final momentum direction of the curre << 132   //  The final momentum direction of the current particle.
 92                                                   133 
 93   G4ThreeVector proposedPolarization;             134   G4ThreeVector proposedPolarization;
 94   // The final polarization of the current par << 135   //  The final polarization of the current particle.
 95 };                                                136 };
 96                                                   137 
 97 // ----------------------                      << 138 // ------------------------------------------------------------
 98 // Inline methods                              << 
 99 // ----------------------                      << 
100                                                   139 
101 inline                                         << 140 inline G4double G4ParticleChangeForLoss::GetProposedKineticEnergy() const
102 G4double G4ParticleChangeForLoss::GetProposedK << 
103 {                                                 141 {
104   return proposedKinEnergy;                       142   return proposedKinEnergy;
105 }                                                 143 }
106                                                   144 
107 inline                                         << 145 inline void G4ParticleChangeForLoss::SetProposedKineticEnergy(G4double energy)
108 void G4ParticleChangeForLoss::SetProposedKinet << 
109 {                                                 146 {
110   proposedKinEnergy = energy;                     147   proposedKinEnergy = energy;
111 }                                                 148 }
112                                                   149 
113 inline G4double G4ParticleChangeForLoss::GetPr    150 inline G4double G4ParticleChangeForLoss::GetProposedCharge() const
114 {                                                 151 {
115   return currentCharge;                           152   return currentCharge;
116 }                                                 153 }
117                                                   154 
118 inline                                         << 155 inline G4double G4ParticleChangeForLoss::GetCharge() const
119 void G4ParticleChangeForLoss::SetProposedCharg << 156 {
                                                   >> 157   return currentCharge;
                                                   >> 158 }
                                                   >> 159 
                                                   >> 160 inline void G4ParticleChangeForLoss::SetProposedCharge(G4double theCharge)
                                                   >> 161 {
                                                   >> 162   currentCharge = theCharge;
                                                   >> 163 }
                                                   >> 164 
                                                   >> 165 inline void G4ParticleChangeForLoss::ProposeCharge(G4double theCharge)
120 {                                                 166 {
121   currentCharge = theCharge;                      167   currentCharge = theCharge;
122 }                                                 168 }
123                                                   169 
124 inline                                            170 inline
125 const G4ThreeVector&                           << 171  const G4ThreeVector& G4ParticleChangeForLoss::GetProposedMomentumDirection() const
126 G4ParticleChangeForLoss::GetProposedMomentumDi << 
127 {                                                 172 {
128   return proposedMomentumDirection;               173   return proposedMomentumDirection;
129 }                                                 174 }
130                                                   175 
131 inline                                            176 inline
132 void G4ParticleChangeForLoss::ProposeMomentumD << 177  const G4ThreeVector& G4ParticleChangeForLoss::GetMomentumDirection() const
                                                   >> 178 {
                                                   >> 179   return proposedMomentumDirection;
                                                   >> 180 }
                                                   >> 181 
                                                   >> 182 inline
                                                   >> 183  void G4ParticleChangeForLoss::ProposeMomentumDirection(const G4ThreeVector& dir)
133 {                                                 184 {
134   proposedMomentumDirection = dir;                185   proposedMomentumDirection = dir;
135 }                                                 186 }
136                                                   187 
137 inline                                            188 inline
138 void                                           << 189  void G4ParticleChangeForLoss::SetProposedMomentumDirection(const G4ThreeVector& dir)
139 G4ParticleChangeForLoss::SetProposedMomentumDi << 
140 {                                                 190 {
141   proposedMomentumDirection = dir;                191   proposedMomentumDirection = dir;
142 }                                                 192 }
143                                                   193 
144 inline                                            194 inline
145 const G4ThreeVector& G4ParticleChangeForLoss:: << 195  void G4ParticleChangeForLoss::ProposeMomentumDirection(G4double Px, G4double Py, G4double Pz)
                                                   >> 196 {
                                                   >> 197   proposedMomentumDirection.setX(Px);
                                                   >> 198   proposedMomentumDirection.setY(Py);
                                                   >> 199   proposedMomentumDirection.setZ(Pz);
                                                   >> 200 }
                                                   >> 201 
                                                   >> 202 inline const G4Track* G4ParticleChangeForLoss::GetCurrentTrack() const
                                                   >> 203 {
                                                   >> 204   return currentTrack;
                                                   >> 205 }
                                                   >> 206 
                                                   >> 207 inline
                                                   >> 208  const G4ThreeVector& G4ParticleChangeForLoss::GetProposedPolarization() const
146 {                                                 209 {
147   return proposedPolarization;                    210   return proposedPolarization;
148 }                                                 211 }
149                                                   212 
150 inline                                            213 inline
151 void G4ParticleChangeForLoss::ProposePolarizat << 214  void G4ParticleChangeForLoss::ProposePolarization(const G4ThreeVector& dir)
152 {                                                 215 {
153   proposedPolarization = dir;                     216   proposedPolarization = dir;
154 }                                                 217 }
155                                                   218 
156 inline void G4ParticleChangeForLoss::ProposePo << 219 inline
157                                                << 220  void G4ParticleChangeForLoss::ProposePolarization(G4double Px, G4double Py, G4double Pz)
158                                                << 
159 {                                                 221 {
160   proposedPolarization.set(Px, Py, Pz);        << 222   proposedPolarization.setX(Px);
                                                   >> 223   proposedPolarization.setY(Py);
                                                   >> 224   proposedPolarization.setZ(Pz);
161 }                                                 225 }
162                                                   226 
163 inline                                         << 227 inline void G4ParticleChangeForLoss::InitializeForAlongStep(const G4Track& track)
164 void G4ParticleChangeForLoss::InitializeForAlo << 
165 {                                                 228 {
166   InitializeSecondaries();                     << 229   theStatusChange = track.GetTrackStatus();
167   InitializeLocalEnergyDeposit();              << 230   theLocalEnergyDeposit = 0.0;
168   InitializeParentWeight(track);               << 231   theNonIonizingEnergyDeposit = 0.0;
169   InitializeStatusChange(track);               << 232   InitializeSecondaries(track);
                                                   >> 233   theParentWeight = track.GetWeight();
170   proposedKinEnergy = track.GetKineticEnergy()    234   proposedKinEnergy = track.GetKineticEnergy();
171   currentCharge = track.GetDynamicParticle()->    235   currentCharge = track.GetDynamicParticle()->GetCharge();
172 }                                                 236 }
173                                                   237 
174 inline                                         << 238 inline void G4ParticleChangeForLoss::InitializeForPostStep(const G4Track& track)
175 void G4ParticleChangeForLoss::InitializeForPos << 
176 {                                                 239 {
177   InitializeForAlongStep(track);               << 240   theStatusChange = track.GetTrackStatus();
                                                   >> 241   theLocalEnergyDeposit = 0.0;
                                                   >> 242   theNonIonizingEnergyDeposit = 0.0;
                                                   >> 243   InitializeSecondaries(track);
                                                   >> 244   theParentWeight = track.GetWeight();
                                                   >> 245   proposedKinEnergy = track.GetKineticEnergy();
                                                   >> 246   currentCharge = track.GetDynamicParticle()->GetCharge();
178   proposedMomentumDirection = track.GetMomentu    247   proposedMomentumDirection = track.GetMomentumDirection();
179   proposedPolarization = track.GetPolarization    248   proposedPolarization = track.GetPolarization();
                                                   >> 249   currentTrack = &track;
                                                   >> 250 }
                                                   >> 251 
                                                   >> 252 //----------------------------------------------------------------
                                                   >> 253 // methods for updating G4Step
                                                   >> 254 //
                                                   >> 255 
                                                   >> 256 inline G4Step* G4ParticleChangeForLoss::UpdateStepForAlongStep(G4Step* pStep)
                                                   >> 257 {
                                                   >> 258   G4StepPoint* pPostStepPoint = pStep->GetPostStepPoint();
                                                   >> 259 
                                                   >> 260   // accumulate change of the kinetic energy
                                                   >> 261   G4double kinEnergy = pPostStepPoint->GetKineticEnergy() +
                                                   >> 262     (proposedKinEnergy - pStep->GetPreStepPoint()->GetKineticEnergy());
                                                   >> 263 
                                                   >> 264   // update kinetic energy and charge
                                                   >> 265   if (kinEnergy < DBL_MIN) {
                                                   >> 266     theLocalEnergyDeposit += kinEnergy;
                                                   >> 267     kinEnergy = 0.0;
                                                   >> 268   } else {
                                                   >> 269     pPostStepPoint->SetCharge( currentCharge );
                                                   >> 270   }
                                                   >> 271   pPostStepPoint->SetKineticEnergy( kinEnergy );
                                                   >> 272 
                                                   >> 273   // update weight 
                                                   >> 274   // this feature is commented out, it should be overwritten in case
                                                   >> 275   // if energy loss processes will use biasing
                                                   >> 276   //  G4double newWeight = theParentWeight*(pPostStepPoint->GetWeight())
                                                   >> 277   //  /(pPreStepPoint->GetWeight());
                                                   >> 278   // pPostStepPoint->SetWeight( newWeight );
                                                   >> 279   pStep->AddTotalEnergyDeposit( theLocalEnergyDeposit );
                                                   >> 280   pStep->AddNonIonizingEnergyDeposit( theNonIonizingEnergyDeposit );
                                                   >> 281   return pStep;
                                                   >> 282 }
                                                   >> 283 
                                                   >> 284 inline G4Step* G4ParticleChangeForLoss::UpdateStepForPostStep(G4Step* pStep)
                                                   >> 285 {
                                                   >> 286   G4StepPoint* pPostStepPoint = pStep->GetPostStepPoint();
                                                   >> 287   pPostStepPoint->SetCharge( currentCharge );
                                                   >> 288   pPostStepPoint->SetMomentumDirection( proposedMomentumDirection );
                                                   >> 289   pPostStepPoint->SetKineticEnergy( proposedKinEnergy );
                                                   >> 290   pPostStepPoint->SetPolarization( proposedPolarization );
                                                   >> 291   // update weight if process cannot do that
                                                   >> 292   if (!fSetParentWeightByProcess)
                                                   >> 293     pPostStepPoint->SetWeight( theParentWeight );
                                                   >> 294 
                                                   >> 295   pStep->AddTotalEnergyDeposit( theLocalEnergyDeposit );
                                                   >> 296   pStep->AddNonIonizingEnergyDeposit( theNonIonizingEnergyDeposit );
                                                   >> 297   return pStep;
                                                   >> 298 }
                                                   >> 299 
                                                   >> 300 inline void G4ParticleChangeForLoss::AddSecondary(G4DynamicParticle* aParticle)
                                                   >> 301 {
                                                   >> 302   //  create track
                                                   >> 303   G4Track* aTrack = new G4Track(aParticle, currentTrack->GetGlobalTime(),
                                                   >> 304                                            currentTrack->GetPosition());
                                                   >> 305 
                                                   >> 306   //   Touchable handle is copied to keep the pointer
                                                   >> 307   aTrack->SetTouchableHandle(currentTrack->GetTouchableHandle());
                                                   >> 308 
                                                   >> 309   //  add a secondary
                                                   >> 310   G4VParticleChange::AddSecondary(aTrack);
180 }                                                 311 }
181                                                   312 
182 #endif                                            313 #endif
                                                   >> 314 
183                                                   315