In This Package:

GiGaTrajectoryPoint.h

Go to the documentation of this file.

// $Id: GiGaTrajectoryPoint.h,v 1.13 2004/02/22 19:01:51 ibelyaev Exp $ 
// ============================================================================
// CVS tag $Name: v19r4 $ 
// ============================================================================
// $Log: GiGaTrajectoryPoint.h,v $
// Revision 1.13  2004/02/22 19:01:51  ibelyaev
//  add new data fields to GiGaTrajectoryPoint
//
// Revision 1.12  2002/12/07 21:36:30  ibelyaev
//  trivial fix
//
// Revision 1.11  2002/12/07 21:05:30  ibelyaev
//  see $GIGAROOT/doc/release.notes 2002-12-07
//
// Revision 1.10  2002/12/07 14:27:51  ibelyaev
//  see $GIGAROOT/cmt/requirements file
//
// ============================================================================
#ifndef     GIGA_GIGATRAJECTORYPOINT_H
#define     GIGA_GIGATRAJECTORYPOINT_H 1 
// ============================================================================
// CLHEP 
#include "CLHEP/Vector/LorentzVector.h"
// GiGa 
#include "GiGa/GiGaUtil.h"
// G4 
#include "G4TrajectoryPoint.hh" 
#include "G4VTrajectoryPoint.hh" 

class G4VProcess ;

class GiGaTrajectoryPoint: public G4TrajectoryPoint
{
public:

  GiGaTrajectoryPoint ();
  
  GiGaTrajectoryPoint 
  ( const CLHEP::Hep3Vector&       Pos                       , 
    const double            Time                      , 
    const CLHEP::HepLorentzVector& Mom  = CLHEP::HepLorentzVector() , 
    const G4VProcess*       Proc = 0                  );
  
  GiGaTrajectoryPoint 
  ( const double            Time                      , 
    const CLHEP::Hep3Vector&       Pos                       , 
    const CLHEP::HepLorentzVector& Mom  = CLHEP::HepLorentzVector() , 
    const G4VProcess*       Proc = 0                  );
  
  GiGaTrajectoryPoint 
  ( const CLHEP::HepLorentzVector& right                     ,
    const CLHEP::HepLorentzVector& Mom  = CLHEP::HepLorentzVector() , 
    const G4VProcess*       Proc = 0                  );
  
  GiGaTrajectoryPoint 
  ( const G4TrajectoryPoint& Point                      , 
    const double             Time                       ,
    const CLHEP::HepLorentzVector&  Mom   = CLHEP::HepLorentzVector() , 
    const G4VProcess*        Proc  = 0                  );

  GiGaTrajectoryPoint 
  ( const G4VTrajectoryPoint& Point                      , 
    const double              Time                       ,
    const CLHEP::HepLorentzVector&   Mom   = CLHEP::HepLorentzVector() , 
    const G4VProcess*         Proc  = 0                  );
    
  GiGaTrajectoryPoint ( const GiGaTrajectoryPoint& right ); 
  
  virtual ~GiGaTrajectoryPoint();

  GiGaTrajectoryPoint*    clone      () const ;
  
  void* operator new    ( size_t );
  
  void  operator delete ( void*  );
  
  bool operator==( const GiGaTrajectoryPoint& right ) 
  { return (&right) == this ; } 
  
  const double    time () const { return m_time   ; } 
  const double GetTime () const { return   time() ; }
  void setTime    ( double Time ) { m_time = Time ; }  
  const CLHEP::HepLorentzVector    fourVector () const        
  { return CLHEP::HepLorentzVector ( GetPosition() , GetTime() ) ; };  
  
  const CLHEP::HepLorentzVector GetFourVector () const { return fourVector ()  ; };  
  
  const CLHEP::HepLorentzVector&    momentum() const { return m_momentum    ; }
  
  const CLHEP::HepLorentzVector& GetMomentum() const { return   momentum () ; }
  
  void setMomentum ( const CLHEP::HepLorentzVector& value ) {  m_momentum = value   ; }
  
  void SetMomentum ( const CLHEP::HepLorentzVector& value ) { setMomentum ( value ) ; }
  
  const G4VProcess*    process() const { return m_process    ; }
  
  const G4VProcess* GetProcess() const { return   process () ; }
  
  void setProcess ( const G4VProcess* value ) {  m_process = value   ; }
  void SetProcess ( const G4VProcess* value ) { setProcess ( value ) ; }
  
private:
  
  // assigmenet oprator is disabled 
  GiGaTrajectoryPoint& operator=
  ( const GiGaTrajectoryPoint& right ) ;
  
private:
  double m_time; 
  CLHEP::HepLorentzVector  m_momentum ;
  const G4VProcess* m_process  ;
};
// ============================================================================

// ============================================================================
// ============================================================================
inline GiGaTrajectoryPoint* gigaTrajectoryPoint( G4TrajectoryPoint* g4 )
{
  GiGaUtil::FastCast<G4TrajectoryPoint,GiGaTrajectoryPoint> cast ;
  return cast( g4 );
};
// ============================================================================

// ============================================================================
// ============================================================================
inline GiGaTrajectoryPoint* gigaTrajectoryPoint( G4VTrajectoryPoint* g4 )
{
  GiGaUtil::FastCast<G4VTrajectoryPoint,GiGaTrajectoryPoint> cast ;
  return cast( g4 );
};
// ============================================================================

// ============================================================================
// ============================================================================
inline const GiGaTrajectoryPoint* gigaTrajectoryPoint
( const G4TrajectoryPoint* g4 )
{
  GiGaUtil::FastCast<const G4TrajectoryPoint,const GiGaTrajectoryPoint> cast ;
  return cast( g4 );
};
// ============================================================================

// ============================================================================
// ============================================================================
inline const GiGaTrajectoryPoint* gigaTrajectoryPoint
( const G4VTrajectoryPoint* g4 )
{
  GiGaUtil::FastCast<const G4VTrajectoryPoint,const GiGaTrajectoryPoint> cast ;
  return cast( g4 );
};
// ============================================================================


// ============================================================================
#endif  
// ============================================================================

---