Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/track/src/G4Step.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 /track/src/G4Step.cc (Version 11.3.0) and /track/src/G4Step.cc (Version 10.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 // G4Step class implementation                 << 
 27 //                                                 26 //
 28 // Authors:                                    <<  27 // $Id: G4Step.cc 68795 2013-04-05 13:24:46Z gcosmo $
 29 //   Katsuya Amako  (e-mail: Katsuya.Amako@kek <<  28 //
 30 //   Takashi Sasaki (e-mail: Takashi.Sasaki@ke <<  29 //
 31 // Revisions:                                  <<  30 //---------------------------------------------------------------
 32 //   Hisaya Kurashige, 1998-2007               <<  31 //
 33 // ------------------------------------------- <<  32 //  G4Step.cc
                                                   >>  33 //
                                                   >>  34 //  Description:
                                                   >>  35 //    This class represents the Step of a particle tracked.
                                                   >>  36 //    It includes information of 
                                                   >>  37 //      1) List of Step points which compose the Step,
                                                   >>  38 //      2) static information of particle which generated the 
                                                   >>  39 //         Step, 
                                                   >>  40 //      3) trackID and parent particle ID of the Step,
                                                   >>  41 //      4) termination condition of the Step,
                                                   >>  42 //
                                                   >>  43 // Contact:
                                                   >>  44 //   Questions and comments to this code should be sent to
                                                   >>  45 //     Katsuya Amako  (e-mail: Katsuya.Amako@kek.jp)
                                                   >>  46 //     Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
                                                   >>  47 //
                                                   >>  48 // ---------------------------------------------------------------
 34                                                    49 
 35 #include "G4Step.hh"                               50 #include "G4Step.hh"
 36                                                    51 
 37 // ------------------------------------------- <<  52 ////////////////
 38 G4Step::G4Step()                                   53 G4Step::G4Step()
                                                   >>  54 ////////////////
                                                   >>  55   :  fTotalEnergyDeposit(0.0),fNonIonizingEnergyDeposit(0.0),
                                                   >>  56      fStepLength(0.), fpTrack(0), 
                                                   >>  57      fpSteppingControlFlag(NormalCondition),
                                                   >>  58      fFirstStepInVolume(false),
                                                   >>  59      fLastStepInVolume(false),
                                                   >>  60      fSecondary(0),
                                                   >>  61      nSecondaryByLastStep(0), secondaryInCurrentStep(),
                                                   >>  62      fpVectorOfAuxiliaryPointsPointer(0)
 39 {                                                  63 {
 40   fpPreStepPoint  = new G4StepPoint();             64   fpPreStepPoint  = new G4StepPoint();
 41   fpPostStepPoint = new G4StepPoint();             65   fpPostStepPoint = new G4StepPoint();
 42                                                    66 
 43   secondaryInCurrentStep = new std::vector<con <<  67   secondaryInCurrentStep = new std::vector<CT>;
 44 }                                                  68 }
 45                                                    69 
 46 // ------------------------------------------- <<  70 /////////////////
 47 G4Step::~G4Step()                                  71 G4Step::~G4Step()
                                                   >>  72 /////////////////
 48 {                                                  73 {
 49   delete fpPreStepPoint;                           74   delete fpPreStepPoint;
 50   delete fpPostStepPoint;                          75   delete fpPostStepPoint;
 51                                                    76 
                                                   >>  77   secondaryInCurrentStep->clear();
 52   delete secondaryInCurrentStep;                   78   delete secondaryInCurrentStep;
 53   delete fSecondary;                           <<  79 
                                                   >>  80   if (fSecondary !=0 ) {
                                                   >>  81     fSecondary->clear();
                                                   >>  82     delete fSecondary;
                                                   >>  83   }
 54 }                                                  84 }
 55                                                    85 
 56 // ------------------------------------------- <<  86 // Copy Counstructor and assignment operator
                                                   >>  87 
                                                   >>  88 /////////////////
 57 G4Step::G4Step(const G4Step& right)                89 G4Step::G4Step(const G4Step& right)
 58   : fTotalEnergyDeposit(right.fTotalEnergyDepo <<  90 /////////////////
 59   , fNonIonizingEnergyDeposit(right.fNonIonizi <<  91   :  fTotalEnergyDeposit(right.fTotalEnergyDeposit),
 60   , fStepLength(right.fStepLength)             <<  92      fNonIonizingEnergyDeposit(right.fNonIonizingEnergyDeposit),
 61   , fpTrack(right.fpTrack)                     <<  93      fStepLength(right.fStepLength), 
 62   , fpSteppingControlFlag(right.fpSteppingCont <<  94      fpTrack(right.fpTrack), 
 63   , fFirstStepInVolume(right.fFirstStepInVolum <<  95      fpSteppingControlFlag(right.fpSteppingControlFlag),
 64   , fLastStepInVolume(right.fLastStepInVolume) <<  96      fFirstStepInVolume(right.fFirstStepInVolume),
 65   , nSecondaryByLastStep(right.nSecondaryByLas <<  97      fLastStepInVolume(right.fLastStepInVolume),
 66   , secondaryInCurrentStep(right.secondaryInCu <<  98      nSecondaryByLastStep(right.nSecondaryByLastStep), 
 67   , fpVectorOfAuxiliaryPointsPointer(right.fpV <<  99      secondaryInCurrentStep(right.secondaryInCurrentStep),
                                                   >> 100      fpVectorOfAuxiliaryPointsPointer(right.fpVectorOfAuxiliaryPointsPointer)
 68 {                                                 101 {
 69   if(right.fpPreStepPoint != nullptr)          << 102   if (right.fpPreStepPoint !=0) {
 70   {                                            << 103     fpPreStepPoint  = new G4StepPoint(*(right.fpPreStepPoint));
 71     fpPreStepPoint = new G4StepPoint(*(right.f << 104   } else {
 72   }                                            << 105     fpPreStepPoint  = new G4StepPoint();
 73   else                                         << 106   }
 74   {                                            << 107   if (right.fpPostStepPoint !=0) {
 75     fpPreStepPoint = new G4StepPoint();        << 108     fpPostStepPoint  = new G4StepPoint(*(right.fpPostStepPoint));
 76   }                                            << 109   } else {
 77   if(right.fpPostStepPoint != nullptr)         << 110     fpPostStepPoint  = new G4StepPoint();
 78   {                                            << 
 79     fpPostStepPoint = new G4StepPoint(*(right. << 
 80   }                                            << 
 81   else                                         << 
 82   {                                            << 
 83     fpPostStepPoint = new G4StepPoint();       << 
 84   }                                               111   }
 85                                                   112 
 86   if(right.fSecondary != nullptr)              << 113   if (right.fSecondary !=0) {
 87   {                                            << 
 88     fSecondary = new G4TrackVector(*(right.fSe    114     fSecondary = new G4TrackVector(*(right.fSecondary));
 89   }                                            << 115   } else {
 90   else                                         << 
 91   {                                            << 
 92     fSecondary = new G4TrackVector();             116     fSecondary = new G4TrackVector();
 93   }                                               117   }
 94                                                << 118   secondaryInCurrentStep = new std::vector<CT>;
 95   // secondaryInCurrentStep is cleared         << 
 96   secondaryInCurrentStep = new std::vector<con << 
 97 }                                                 119 }
 98                                                   120 
 99 // ------------------------------------------- << 121 /////////////////
100 G4Step& G4Step::operator=(const G4Step& right) << 122 G4Step& G4Step::operator=(const G4Step & right)   
                                                   >> 123 /////////////////
101 {                                                 124 {
102   if(this != &right)                           << 125   if (this != &right){
103   {                                            << 126     fTotalEnergyDeposit  = right.fTotalEnergyDeposit;
104     fTotalEnergyDeposit              = right.f << 127     fNonIonizingEnergyDeposit = right.fNonIonizingEnergyDeposit;
105     fNonIonizingEnergyDeposit        = right.f << 128     fStepLength            = right.fStepLength; 
106     fStepLength                      = right.f << 129     fpTrack                = right.fpTrack; 
107     fpTrack                          = right.f << 130     fpSteppingControlFlag  = right.fpSteppingControlFlag;
108     fpSteppingControlFlag            = right.f << 131     fFirstStepInVolume     = right.fFirstStepInVolume;
109     fFirstStepInVolume               = right.f << 132     fLastStepInVolume      = right.fLastStepInVolume;
110     fLastStepInVolume                = right.f << 133     nSecondaryByLastStep   = right.nSecondaryByLastStep; 
111     nSecondaryByLastStep             = right.n << 134     secondaryInCurrentStep = right.secondaryInCurrentStep;
112     secondaryInCurrentStep           = right.s << 
113     fpVectorOfAuxiliaryPointsPointer = right.f    135     fpVectorOfAuxiliaryPointsPointer = right.fpVectorOfAuxiliaryPointsPointer;
114                                                   136 
115     delete fpPreStepPoint;                     << 137     if (fpPreStepPoint !=0 ) delete fpPreStepPoint;
116                                                << 138     if (right.fpPreStepPoint !=0) {
117     if(right.fpPreStepPoint != nullptr)        << 139       fpPreStepPoint  = new G4StepPoint(*(right.fpPreStepPoint));
118     {                                          << 140     } else {
119       fpPreStepPoint = new G4StepPoint(*(right << 141       fpPreStepPoint  = new G4StepPoint();
                                                   >> 142     }
                                                   >> 143     if (fpPostStepPoint !=0 ) delete fpPostStepPoint;
                                                   >> 144     if (right.fpPostStepPoint !=0) {
                                                   >> 145       fpPostStepPoint  = new G4StepPoint(*(right.fpPostStepPoint));
                                                   >> 146     } else {
                                                   >> 147       fpPostStepPoint  = new G4StepPoint();
120     }                                             148     }
121     else                                       << 149     if (right.fSecondary !=0) {
122     {                                          << 
123       fpPreStepPoint = new G4StepPoint();      << 
124     }                                          << 
125                                                << 
126     delete fpPostStepPoint;                    << 
127                                                << 
128     if(right.fpPostStepPoint != nullptr)       << 
129     {                                          << 
130       fpPostStepPoint = new G4StepPoint(*(righ << 
131     }                                          << 
132     else                                       << 
133     {                                          << 
134       fpPostStepPoint = new G4StepPoint();     << 
135     }                                          << 
136                                                << 
137     if(fSecondary != nullptr)                  << 
138     {                                          << 
139       fSecondary->clear();                     << 
140       delete fSecondary;                       << 
141     }                                          << 
142     if(right.fSecondary != nullptr)            << 
143     {                                          << 
144       fSecondary = new G4TrackVector(*(right.f    150       fSecondary = new G4TrackVector(*(right.fSecondary));
145     }                                          << 151     } else {
146     else                                       << 
147     {                                          << 
148       fSecondary = new G4TrackVector();           152       fSecondary = new G4TrackVector();
149     }                                             153     }
150                                                << 
151     // secondaryInCurrentStep is not copied    << 
152     if(secondaryInCurrentStep != nullptr)      << 
153     {                                          << 
154       secondaryInCurrentStep->clear();         << 
155       delete secondaryInCurrentStep;           << 
156     }                                          << 
157     secondaryInCurrentStep = new std::vector<c << 
158   }                                               154   }
159   return *this;                                   155   return *this;
160 }                                                 156 }
161                                                   157 
162 // ------------------------------------------- << 158 /////////////////
163 const std::vector<const G4Track*>* G4Step::Get << 159 G4ThreeVector G4Step::GetDeltaMomentum() const
                                                   >> 160 /////////////////
                                                   >> 161 { 
                                                   >> 162   static G4ThreadLocal G4bool isFirstTime = true;
                                                   >> 163   if (isFirstTime) {
                                                   >> 164     isFirstTime = false;
                                                   >> 165 #ifdef G4VERBOSE
                                                   >> 166     G4Exception( "G4Step::GetDeltaMomentum()","Warning", JustWarning, 
                                                   >> 167      "This method is obsolete and will be removed soon");
                                                   >> 168 #endif
                                                   >> 169   }
                                                   >> 170 
                                                   >> 171   return fpPostStepPoint->GetMomentum()
                                                   >> 172     - fpPreStepPoint->GetMomentum(); 
                                                   >> 173 }
                                                   >> 174 
                                                   >> 175 /////////////////
                                                   >> 176 G4double G4Step::GetDeltaEnergy() const
                                                   >> 177 /////////////////
                                                   >> 178 { 
                                                   >> 179   static G4ThreadLocal G4bool isFirstTime = true;
                                                   >> 180   if (isFirstTime) {
                                                   >> 181     isFirstTime = false;
                                                   >> 182 #ifdef G4VERBOSE
                                                   >> 183     G4Exception( "G4Step::GetDeltaEnergy()","Warning", JustWarning, 
                                                   >> 184      "This method is obsolete and will be removed soon");
                                                   >> 185 #endif
                                                   >> 186   }
                                                   >> 187 
                                                   >> 188   return fpPostStepPoint->GetKineticEnergy()
                                                   >> 189     - fpPreStepPoint->GetKineticEnergy(); 
                                                   >> 190 }
                                                   >> 191 
                                                   >> 192 /////////////////
                                                   >> 193 const std::vector<const G4Track*>* G4Step::GetSecondaryInCurrentStep() const 
                                                   >> 194 /////////////////
164 {                                                 195 {
165   secondaryInCurrentStep->clear();                196   secondaryInCurrentStep->clear();
166   std::size_t nSecondary = fSecondary->size(); << 197   G4int nSecondary = fSecondary->size();
167   for(std::size_t i = nSecondaryByLastStep; i  << 198   for (G4int i=nSecondaryByLastStep; i<nSecondary; i++) {
168   {                                            << 
169     secondaryInCurrentStep->push_back((*fSecon    199     secondaryInCurrentStep->push_back((*fSecondary)[i]);
170   }                                               200   }
171   return secondaryInCurrentStep;               << 201   return  secondaryInCurrentStep;
172 }                                                 202 }
                                                   >> 203 
173                                                   204