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 9.5.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4Step class implementation                 << 
 27 //                                                 26 //
 28 // Authors:                                    <<  27 // $Id: G4Step.cc,v 1.11 2010-10-30 07:49:08 kurasige Exp $
 29 //   Katsuya Amako  (e-mail: Katsuya.Amako@kek <<  28 // GEANT4 tag $Name: not supported by cvs2svn $
 30 //   Takashi Sasaki (e-mail: Takashi.Sasaki@ke <<  29 //
 31 // Revisions:                                  <<  30 //
 32 //   Hisaya Kurashige, 1998-2007               <<  31 //---------------------------------------------------------------
 33 // ------------------------------------------- <<  32 //
                                                   >>  33 //  G4Step.cc
                                                   >>  34 //
                                                   >>  35 //  Description:
                                                   >>  36 //    This class represents the Step of a particle tracked.
                                                   >>  37 //    It includes information of 
                                                   >>  38 //      1) List of Step points which compose the Step,
                                                   >>  39 //      2) static information of particle which generated the 
                                                   >>  40 //         Step, 
                                                   >>  41 //      3) trackID and parent particle ID of the Step,
                                                   >>  42 //      4) termination condition of the Step,
                                                   >>  43 //
                                                   >>  44 // Contact:
                                                   >>  45 //   Questions and comments to this code should be sent to
                                                   >>  46 //     Katsuya Amako  (e-mail: Katsuya.Amako@kek.jp)
                                                   >>  47 //     Takashi Sasaki (e-mail: Takashi.Sasaki@kek.jp)
                                                   >>  48 //
                                                   >>  49 // ---------------------------------------------------------------
 34                                                    50 
 35 #include "G4Step.hh"                               51 #include "G4Step.hh"
 36                                                    52 
 37 // ------------------------------------------- <<  53 ////////////////
 38 G4Step::G4Step()                                   54 G4Step::G4Step()
                                                   >>  55 ////////////////
                                                   >>  56   :  fTotalEnergyDeposit(0.0),fNonIonizingEnergyDeposit(0.0),
                                                   >>  57      fStepLength(0.), fpTrack(0), 
                                                   >>  58      fpSteppingControlFlag(NormalCondition),
                                                   >>  59      fFirstStepInVolume(false),
                                                   >>  60      fLastStepInVolume(false),
                                                   >>  61      fSecondary(0),
                                                   >>  62      nSecondaryByLastStep(0), secondaryInCurrentStep(),
                                                   >>  63      fpVectorOfAuxiliaryPointsPointer(0)
 39 {                                                  64 {
 40   fpPreStepPoint  = new G4StepPoint();             65   fpPreStepPoint  = new G4StepPoint();
 41   fpPostStepPoint = new G4StepPoint();             66   fpPostStepPoint = new G4StepPoint();
 42                                                    67 
 43   secondaryInCurrentStep = new std::vector<con <<  68   secondaryInCurrentStep = new std::vector<CT>;
 44 }                                                  69 }
 45                                                    70 
 46 // ------------------------------------------- <<  71 /////////////////
 47 G4Step::~G4Step()                                  72 G4Step::~G4Step()
                                                   >>  73 /////////////////
 48 {                                                  74 {
 49   delete fpPreStepPoint;                           75   delete fpPreStepPoint;
 50   delete fpPostStepPoint;                          76   delete fpPostStepPoint;
 51                                                    77 
                                                   >>  78   secondaryInCurrentStep->clear();
 52   delete secondaryInCurrentStep;                   79   delete secondaryInCurrentStep;
 53   delete fSecondary;                           <<  80 
                                                   >>  81   if (fSecondary !=0 ) {
                                                   >>  82     fSecondary->clear();
                                                   >>  83     delete fSecondary;
                                                   >>  84   }
 54 }                                                  85 }
 55                                                    86 
 56 // ------------------------------------------- <<  87 // Copy Counstructor and assignment operator
                                                   >>  88 
                                                   >>  89 /////////////////
 57 G4Step::G4Step(const G4Step& right)                90 G4Step::G4Step(const G4Step& right)
 58   : fTotalEnergyDeposit(right.fTotalEnergyDepo <<  91 /////////////////
 59   , fNonIonizingEnergyDeposit(right.fNonIonizi <<  92   :  fTotalEnergyDeposit(right.fTotalEnergyDeposit),
 60   , fStepLength(right.fStepLength)             <<  93      fNonIonizingEnergyDeposit(right.fNonIonizingEnergyDeposit),
 61   , fpTrack(right.fpTrack)                     <<  94      fStepLength(right.fStepLength), 
 62   , fpSteppingControlFlag(right.fpSteppingCont <<  95      fpTrack(right.fpTrack), 
 63   , fFirstStepInVolume(right.fFirstStepInVolum <<  96      fpSteppingControlFlag(right.fpSteppingControlFlag),
 64   , fLastStepInVolume(right.fLastStepInVolume) <<  97      fFirstStepInVolume(right.fFirstStepInVolume),
 65   , nSecondaryByLastStep(right.nSecondaryByLas <<  98      fLastStepInVolume(right.fLastStepInVolume),
 66   , secondaryInCurrentStep(right.secondaryInCu <<  99      nSecondaryByLastStep(right.nSecondaryByLastStep), 
 67   , fpVectorOfAuxiliaryPointsPointer(right.fpV << 100      secondaryInCurrentStep(right.secondaryInCurrentStep),
                                                   >> 101      fpVectorOfAuxiliaryPointsPointer(right.fpVectorOfAuxiliaryPointsPointer)
 68 {                                                 102 {
 69   if(right.fpPreStepPoint != nullptr)          << 103   if (right.fpPreStepPoint !=0) {
 70   {                                            << 104     fpPreStepPoint  = new G4StepPoint(*(right.fpPreStepPoint));
 71     fpPreStepPoint = new G4StepPoint(*(right.f << 105   } else {
 72   }                                            << 106     fpPreStepPoint  = new G4StepPoint();
 73   else                                         << 107   }
 74   {                                            << 108   if (right.fpPostStepPoint !=0) {
 75     fpPreStepPoint = new G4StepPoint();        << 109     fpPostStepPoint  = new G4StepPoint(*(right.fpPostStepPoint));
 76   }                                            << 110   } else {
 77   if(right.fpPostStepPoint != nullptr)         << 111     fpPostStepPoint  = new G4StepPoint();
 78   {                                            << 
 79     fpPostStepPoint = new G4StepPoint(*(right. << 
 80   }                                            << 
 81   else                                         << 
 82   {                                            << 
 83     fpPostStepPoint = new G4StepPoint();       << 
 84   }                                               112   }
 85                                                   113 
 86   if(right.fSecondary != nullptr)              << 114   if (right.fSecondary !=0) {
 87   {                                            << 
 88     fSecondary = new G4TrackVector(*(right.fSe    115     fSecondary = new G4TrackVector(*(right.fSecondary));
 89   }                                            << 116   } else {
 90   else                                         << 
 91   {                                            << 
 92     fSecondary = new G4TrackVector();             117     fSecondary = new G4TrackVector();
 93   }                                               118   }
 94                                                << 119   secondaryInCurrentStep = new std::vector<CT>;
 95   // secondaryInCurrentStep is cleared         << 
 96   secondaryInCurrentStep = new std::vector<con << 
 97 }                                                 120 }
 98                                                   121 
 99 // ------------------------------------------- << 122 /////////////////
100 G4Step& G4Step::operator=(const G4Step& right) << 123 G4Step& G4Step::operator=(const G4Step & right)   
                                                   >> 124 /////////////////
101 {                                                 125 {
102   if(this != &right)                           << 126   if (this != &right){
103   {                                            << 127     fTotalEnergyDeposit  = right.fTotalEnergyDeposit;
104     fTotalEnergyDeposit              = right.f << 128     fNonIonizingEnergyDeposit = right.fNonIonizingEnergyDeposit;
105     fNonIonizingEnergyDeposit        = right.f << 129     fStepLength            = right.fStepLength; 
106     fStepLength                      = right.f << 130     fpTrack                = right.fpTrack; 
107     fpTrack                          = right.f << 131     fpSteppingControlFlag  = right.fpSteppingControlFlag;
108     fpSteppingControlFlag            = right.f << 132     fFirstStepInVolume     = right.fFirstStepInVolume;
109     fFirstStepInVolume               = right.f << 133     fLastStepInVolume      = right.fLastStepInVolume;
110     fLastStepInVolume                = right.f << 134     nSecondaryByLastStep   = right.nSecondaryByLastStep; 
111     nSecondaryByLastStep             = right.n << 135     secondaryInCurrentStep = right.secondaryInCurrentStep;
112     secondaryInCurrentStep           = right.s << 
113     fpVectorOfAuxiliaryPointsPointer = right.f    136     fpVectorOfAuxiliaryPointsPointer = right.fpVectorOfAuxiliaryPointsPointer;
114                                                   137 
115     delete fpPreStepPoint;                     << 138     if (fpPreStepPoint !=0 ) delete fpPreStepPoint;
116                                                << 139     if (right.fpPreStepPoint !=0) {
117     if(right.fpPreStepPoint != nullptr)        << 140       fpPreStepPoint  = new G4StepPoint(*(right.fpPreStepPoint));
118     {                                          << 141     } else {
119       fpPreStepPoint = new G4StepPoint(*(right << 142       fpPreStepPoint  = new G4StepPoint();
                                                   >> 143     }
                                                   >> 144     if (fpPostStepPoint !=0 ) delete fpPostStepPoint;
                                                   >> 145     if (right.fpPostStepPoint !=0) {
                                                   >> 146       fpPostStepPoint  = new G4StepPoint(*(right.fpPostStepPoint));
                                                   >> 147     } else {
                                                   >> 148       fpPostStepPoint  = new G4StepPoint();
120     }                                             149     }
121     else                                       << 150     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    151       fSecondary = new G4TrackVector(*(right.fSecondary));
145     }                                          << 152     } else {
146     else                                       << 
147     {                                          << 
148       fSecondary = new G4TrackVector();           153       fSecondary = new G4TrackVector();
149     }                                             154     }
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   }                                               155   }
159   return *this;                                   156   return *this;
160 }                                                 157 }
161                                                   158 
162 // ------------------------------------------- << 159 /////////////////
163 const std::vector<const G4Track*>* G4Step::Get << 160 G4ThreeVector G4Step::GetDeltaMomentum() const
                                                   >> 161 /////////////////
                                                   >> 162 { 
                                                   >> 163   static G4bool isFirstTime = true;
                                                   >> 164   if (isFirstTime) {
                                                   >> 165     isFirstTime = false;
                                                   >> 166 #ifdef G4VERBOSE
                                                   >> 167     G4Exception( "G4Step::GetDeltaMomentum()","Warning", JustWarning, 
                                                   >> 168      "This method is obsolete and will be removed soon");
                                                   >> 169 #endif
                                                   >> 170   }
                                                   >> 171 
                                                   >> 172   return fpPostStepPoint->GetMomentum()
                                                   >> 173     - fpPreStepPoint->GetMomentum(); 
                                                   >> 174 }
                                                   >> 175 
                                                   >> 176 /////////////////
                                                   >> 177 G4double G4Step::GetDeltaEnergy() const
                                                   >> 178 /////////////////
                                                   >> 179 { 
                                                   >> 180   static G4bool isFirstTime = true;
                                                   >> 181   if (isFirstTime) {
                                                   >> 182     isFirstTime = false;
                                                   >> 183 #ifdef G4VERBOSE
                                                   >> 184     G4Exception( "G4Step::GetDeltaEnergy()","Warning", JustWarning, 
                                                   >> 185      "This method is obsolete and will be removed soon");
                                                   >> 186 #endif
                                                   >> 187   }
                                                   >> 188 
                                                   >> 189   return fpPostStepPoint->GetKineticEnergy()
                                                   >> 190     - fpPreStepPoint->GetKineticEnergy(); 
                                                   >> 191 }
                                                   >> 192 
                                                   >> 193 /////////////////
                                                   >> 194 const std::vector<const G4Track*>* G4Step::GetSecondaryInCurrentStep() const 
                                                   >> 195 /////////////////
164 {                                                 196 {
165   secondaryInCurrentStep->clear();                197   secondaryInCurrentStep->clear();
166   std::size_t nSecondary = fSecondary->size(); << 198   G4int nSecondary = fSecondary->size();
167   for(std::size_t i = nSecondaryByLastStep; i  << 199   for (G4int i=nSecondaryByLastStep; i<nSecondary; i++) {
168   {                                            << 
169     secondaryInCurrentStep->push_back((*fSecon    200     secondaryInCurrentStep->push_back((*fSecondary)[i]);
170   }                                               201   }
171   return secondaryInCurrentStep;               << 202   return  secondaryInCurrentStep;
172 }                                                 203 }
                                                   >> 204 
173                                                   205