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 8.1.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.6 2006/06/29 21:15:13 gunter Exp $
 29 //   Katsuya Amako  (e-mail: Katsuya.Amako@kek <<  28 // GEANT4 tag $Name: geant4-08-01-patch-01 $
 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 ////////////////
 39 {                                                  56 {
 40   fpPreStepPoint  = new G4StepPoint();             57   fpPreStepPoint  = new G4StepPoint();
 41   fpPostStepPoint = new G4StepPoint();             58   fpPostStepPoint = new G4StepPoint();
 42                                                << 
 43   secondaryInCurrentStep = new std::vector<con << 
 44 }                                                  59 }
 45                                                    60 
 46 // ------------------------------------------- <<  61 /////////////////
 47 G4Step::~G4Step()                                  62 G4Step::~G4Step()
                                                   >>  63 /////////////////
 48 {                                                  64 {
 49   delete fpPreStepPoint;                           65   delete fpPreStepPoint;
 50   delete fpPostStepPoint;                          66   delete fpPostStepPoint;
 51                                                << 
 52   delete secondaryInCurrentStep;               << 
 53   delete fSecondary;                           << 
 54 }                                              << 
 55                                                << 
 56 // ------------------------------------------- << 
 57 G4Step::G4Step(const G4Step& right)            << 
 58   : fTotalEnergyDeposit(right.fTotalEnergyDepo << 
 59   , fNonIonizingEnergyDeposit(right.fNonIonizi << 
 60   , fStepLength(right.fStepLength)             << 
 61   , fpTrack(right.fpTrack)                     << 
 62   , fpSteppingControlFlag(right.fpSteppingCont << 
 63   , fFirstStepInVolume(right.fFirstStepInVolum << 
 64   , fLastStepInVolume(right.fLastStepInVolume) << 
 65   , nSecondaryByLastStep(right.nSecondaryByLas << 
 66   , secondaryInCurrentStep(right.secondaryInCu << 
 67   , fpVectorOfAuxiliaryPointsPointer(right.fpV << 
 68 {                                              << 
 69   if(right.fpPreStepPoint != nullptr)          << 
 70   {                                            << 
 71     fpPreStepPoint = new G4StepPoint(*(right.f << 
 72   }                                            << 
 73   else                                         << 
 74   {                                            << 
 75     fpPreStepPoint = new G4StepPoint();        << 
 76   }                                            << 
 77   if(right.fpPostStepPoint != nullptr)         << 
 78   {                                            << 
 79     fpPostStepPoint = new G4StepPoint(*(right. << 
 80   }                                            << 
 81   else                                         << 
 82   {                                            << 
 83     fpPostStepPoint = new G4StepPoint();       << 
 84   }                                            << 
 85                                                << 
 86   if(right.fSecondary != nullptr)              << 
 87   {                                            << 
 88     fSecondary = new G4TrackVector(*(right.fSe << 
 89   }                                            << 
 90   else                                         << 
 91   {                                            << 
 92     fSecondary = new G4TrackVector();          << 
 93   }                                            << 
 94                                                << 
 95   // secondaryInCurrentStep is cleared         << 
 96   secondaryInCurrentStep = new std::vector<con << 
 97 }                                              << 
 98                                                << 
 99 // ------------------------------------------- << 
100 G4Step& G4Step::operator=(const G4Step& right) << 
101 {                                              << 
102   if(this != &right)                           << 
103   {                                            << 
104     fTotalEnergyDeposit              = right.f << 
105     fNonIonizingEnergyDeposit        = right.f << 
106     fStepLength                      = right.f << 
107     fpTrack                          = right.f << 
108     fpSteppingControlFlag            = right.f << 
109     fFirstStepInVolume               = right.f << 
110     fLastStepInVolume                = right.f << 
111     nSecondaryByLastStep             = right.n << 
112     secondaryInCurrentStep           = right.s << 
113     fpVectorOfAuxiliaryPointsPointer = right.f << 
114                                                << 
115     delete fpPreStepPoint;                     << 
116                                                << 
117     if(right.fpPreStepPoint != nullptr)        << 
118     {                                          << 
119       fpPreStepPoint = new G4StepPoint(*(right << 
120     }                                          << 
121     else                                       << 
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 << 
145     }                                          << 
146     else                                       << 
147     {                                          << 
148       fSecondary = new G4TrackVector();        << 
149     }                                          << 
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   }                                            << 
159   return *this;                                << 
160 }                                              << 
161                                                << 
162 // ------------------------------------------- << 
163 const std::vector<const G4Track*>* G4Step::Get << 
164 {                                              << 
165   secondaryInCurrentStep->clear();             << 
166   std::size_t nSecondary = fSecondary->size(); << 
167   for(std::size_t i = nSecondaryByLastStep; i  << 
168   {                                            << 
169     secondaryInCurrentStep->push_back((*fSecon << 
170   }                                            << 
171   return secondaryInCurrentStep;               << 
172 }                                                  67 }
173                                                    68