source: trunk/source/track/include/G4Step.icc @ 1340

//
// ********************************************************************
// * License and Disclaimer                                           *
// *                                                                  *
// * The  Geant4 software  is  copyright of the Copyright Holders  of *
// * the Geant4 Collaboration.  It is provided  under  the terms  and *
// * conditions of the Geant4 Software License,  included in the file *
// * LICENSE and available at  http://cern.ch/geant4/license .  These *
// * include a list of copyright holders.                             *
// *                                                                  *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work  make  any representation or  warranty, express or implied, *
// * regarding  this  software system or assume any liability for its *
// * use.  Please see the license in the file  LICENSE  and URL above *
// * for the full disclaimer and the limitation of liability.         *
// *                                                                  *
// * This  code  implementation is the result of  the  scientific and *
// * technical work of the GEANT4 collaboration.                      *
// * By using,  copying,  modifying or  distributing the software (or *
// * any work based  on the software)  you  agree  to acknowledge its *
// * use  in  resulting  scientific  publications,  and indicate your *
// * acceptance of all terms of the Geant4 Software license.          *
// ********************************************************************
//
//
// $Id: G4Step.icc,v 1.22 2010/10/18 23:52:04 kurasige Exp $
// GEANT4 tag $Name: track-V09-03-09 $
//
//
//---------------------------------------------------------------
//
//-----------------------------------------------------------------
//  In-line definitions
//-----------------------------------------------------------------

// Get/Set functions 
inline 
 G4StepPoint* G4Step::GetPreStepPoint() const 
 { 
   return fpPreStepPoint; 
 }

inline 
 void G4Step::SetPreStepPoint(G4StepPoint* value)
 { 
   fpPreStepPoint = value; 
 }

inline 
 G4StepPoint* G4Step::GetPostStepPoint() const
 { 
   return fpPostStepPoint; 
 }
   
inline 
 void G4Step::SetPostStepPoint(G4StepPoint* value)
 { 
   fpPostStepPoint = value; 
 }

inline 
 G4double G4Step::GetStepLength() const
 { 
   return fStepLength; 
 }

inline 
 void G4Step::SetStepLength(G4double value)
 { 
   fStepLength = value; 
 }

inline 
 G4ThreeVector G4Step::GetDeltaPosition() const
 { 
   return fpPostStepPoint->GetPosition()
            - fpPreStepPoint->GetPosition(); 
 }

inline 
 G4double G4Step::GetDeltaTime() const
 { 
   return fpPostStepPoint->GetLocalTime()
            - fpPreStepPoint->GetLocalTime(); 
 }


inline 
 G4double G4Step::GetTotalEnergyDeposit() const
 { 
   return fTotalEnergyDeposit; 
 }

inline 
 void G4Step::SetTotalEnergyDeposit(G4double value)
 { 
   fTotalEnergyDeposit = value;   
 }

inline 
 G4double G4Step::GetNonIonizingEnergyDeposit() const
 { 
   return fNonIonizingEnergyDeposit; 
 }

inline 
 void G4Step::SetNonIonizingEnergyDeposit(G4double value)
 { 
   fNonIonizingEnergyDeposit = value;   
 }

inline 
 void G4Step::AddTotalEnergyDeposit(G4double value)
 {
   fTotalEnergyDeposit += value;   
 }

inline 
 void G4Step::ResetTotalEnergyDeposit()
 { 
   fTotalEnergyDeposit = 0.; 
   fNonIonizingEnergyDeposit = 0.;   
 }

inline 
 void G4Step::AddNonIonizingEnergyDeposit(G4double value)
 { 
   fNonIonizingEnergyDeposit += value;   
 }

inline 
 void G4Step::ResetNonIonizingEnergyDeposit()
 { 
   fNonIonizingEnergyDeposit = 0.; 
 }

inline 
 void G4Step::SetControlFlag(G4SteppingControl value)
 {
   fpSteppingControlFlag = value;     
 }

inline 
 G4SteppingControl G4Step::GetControlFlag() const
 {
   return fpSteppingControlFlag;     
 }

inline 
 void G4Step::CopyPostToPreStepPoint( )
 {
   //This method is called at the beggining of each step 
   *(fpPreStepPoint) = *(fpPostStepPoint);
   fpPostStepPoint->SetStepStatus(fUndefined);
   // clear secondary in current
   fSecondary->secondaryInCurrent.clear();
}


//-------------------------------------------------------------
// To implement bi-directional association between G4Step and
// and G4Track, a combined usage of 'forward declaration' and
// 'include' is necessary.
//-------------------------------------------------------------
#include "G4Track.hh"

inline 
 G4Track* G4Step::GetTrack() const
 { 
   return fpTrack; 
 }
   
inline 
 void G4Step::SetTrack(G4Track* value)
 { 
   fpTrack = value; 
 }


// Other member functions
inline 
 void G4Step::InitializeStep( G4Track* aValue )
 {
   // Initialize G4Step attributes
   fStepLength = 0.;
   fTotalEnergyDeposit = 0.;
   fNonIonizingEnergyDeposit = 0.;
   fpTrack = aValue;
   fpTrack->SetStepLength(0.);
   
   // Initialize G4StepPoint attributes.
   // To avoid the circular dependency between G4Track, G4Step
   // and G4StepPoint, G4Step has to manage the copy actions.
   fpPreStepPoint->SetPosition(fpTrack->GetPosition());
   fpPreStepPoint->SetGlobalTime(fpTrack->GetGlobalTime());
   fpPreStepPoint->SetLocalTime(fpTrack->GetLocalTime());
   fpPreStepPoint->SetProperTime(fpTrack->GetProperTime());
   fpPreStepPoint->SetMomentumDirection(fpTrack->GetMomentumDirection());
   fpPreStepPoint->SetKineticEnergy(fpTrack->GetKineticEnergy());
   fpPreStepPoint->SetVelocity(fpTrack->GetVelocity());
   fpPreStepPoint->SetTouchableHandle(fpTrack->GetTouchableHandle());
   fpPreStepPoint->SetMaterial( fpTrack->GetTouchable()->GetVolume()->GetLogicalVolume()->GetMaterial());
   fpPreStepPoint->SetMaterialCutsCouple( fpTrack->GetTouchable()->GetVolume()->GetLogicalVolume()->GetMaterialCutsCouple());
   fpPreStepPoint->SetSensitiveDetector( fpTrack->GetTouchable()->GetVolume()->GetLogicalVolume()->GetSensitiveDetector());
   fpPreStepPoint->SetPolarization(fpTrack->GetPolarization());
   fpPreStepPoint->SetSafety(0.);
   fpPreStepPoint->SetStepStatus(fUndefined);
   fpPreStepPoint->SetProcessDefinedStep(0);
   fpPreStepPoint->SetMass(fpTrack->GetDynamicParticle()->GetMass());    
   fpPreStepPoint->SetCharge(fpTrack->GetDynamicParticle()->GetCharge()); 
   fpPreStepPoint->SetWeight(fpTrack->GetWeight());
   
   // clear secondary in current        
   fSecondary->secondaryInCurrent.clear();
 
   (*fpPostStepPoint) = (*fpPreStepPoint);
 }

inline 
 void G4Step::UpdateTrack( )
 { 
   // To avoid the circular dependency between G4Track, G4Step
   // and G4StepPoint, G4Step has to manage the update actions.
   //  position, time
   fpTrack->SetPosition(fpPostStepPoint->GetPosition());
   fpTrack->SetGlobalTime(fpPostStepPoint->GetGlobalTime());
   fpTrack->SetLocalTime(fpPostStepPoint->GetLocalTime());
   fpTrack->SetProperTime(fpPostStepPoint->GetProperTime());
   //  energy, momentum, polarization
   fpTrack->SetMomentumDirection(fpPostStepPoint->GetMomentumDirection());
   fpTrack->SetKineticEnergy(fpPostStepPoint->GetKineticEnergy());
   fpTrack->SetPolarization(fpPostStepPoint->GetPolarization());
   //  mass charge
   G4DynamicParticle* pParticle = (G4DynamicParticle*)(fpTrack->GetDynamicParticle());
   pParticle->SetMass(fpPostStepPoint->GetMass());
   pParticle->SetCharge(fpPostStepPoint->GetCharge());
   //  step length
   fpTrack->SetStepLength(fStepLength);
   // NextTouchable is updated 
   // (G4Track::Touchable points touchable of Pre-StepPoint)
   fpTrack->SetNextTouchableHandle(fpPostStepPoint->GetTouchableHandle());
   fpTrack->SetWeight(fpPostStepPoint->GetWeight());


   // set velocity 
   fpPostStepPoint->SetVelocity(fpTrack->GetVelocity());
}

inline   
 const std::vector<const G4Track*>* G4Step::GetSecondaryInCurrentStep() const 
{
  return  &fSecondary->secondaryInCurrent;
}

inline const G4TrackVector* G4Step::GetSecondary() const  
{
   return fSecondary;
}

inline G4TrackVector* G4Step::GetfSecondary()  
{
   return fSecondary;
}

inline void G4Step::SetSecondary(G4TrackVector* value)  
{
   fSecondary=value;
}

inline 
 G4TrackVector* G4Step::NewSecondaryVector()  
{
   fSecondary=new G4TrackVector();
   return fSecondary;
}

inline void G4Step::DeleteSecondaryVector()  {
   delete fSecondary;
    }

inline G4bool G4Step::IsFirstStepInVolume() const
{
   return fFirstStepInVolume;
}

inline G4bool G4Step::IsLastStepInVolume() const
{
   return fLastStepInVolume;
}


 inline  void G4Step::SetFirstStepFlag()
{
   fFirstStepInVolume = true;
}
  
 inline  void G4Step::ClearFirstStepFlag()
{
   fFirstStepInVolume = false;
}

 inline  void G4Step::SetLastStepFlag()
{
   fLastStepInVolume = true;
}
  
 inline  void G4Step::ClearLastStepFlag()
{
   fLastStepInVolume = false;
}