include/TMyRootEvent.hpp

Go to the documentation of this file.

/*
* 
* Copyright: Mathieu Trocme, mathieu.trocme@gmail.com (21 september 2009)
* 
* This software is a computer program whose purpose is to: provide a universal Hit/SD output method in Geant4 with a proper Root coupling 
* 
* This software is governed by the CeCILL license under French law and abiding by the rules of distribution of free software. 
* You can use, modify and/or redistribute the software under the terms of the CeCILL license as circulated by CEA, CNRS and INRIA at the following URL "http://www.cecill.info".
* As a counterpart to the access to the source code and rights to copy, modify and redistribute granted by the license, users are provided only with a limited warranty and the software's author, the holder of the economic rights, and the successive licensors have only limited liability. 
* In this respect, the user's attention is drawn to the risks associated with loading, using, modifying and/or developing or reproducing the software by the user in light of its specific status of free software, that may mean that it is complicated to manipulate, and that also therefore means that it is reserved for developers and experienced professionals having in-depth computer knowledge. 
* Users are therefore encouraged to load and test the software's suitability as regards their requirements in conditions enabling the security of their systems and/or data to be ensured and, more generally, to use and operate it in the same conditions as regards security. 
* 
* The fact that you are presently reading this means that you have had knowledge of the CeCILL license and that you accept its terms.
* 
*/


// 
// Documentation : See doc.html (readme, main.cc, ...)
// Convention    : Root coding convention: TMyClass for classes, fMyVariable for class data members, kMyVariable for constants, gMyVariable for global variables
// Help          : http://www.lcsim.org/software/geant4/doxygen/html/classes.html
// 


// Author: Mathieu Trocme
// Modified: Tues Sep 22, 2009
// Copyright: mtrocme


#ifndef TMyRootEvent_hpp
#define TMyRootEvent_hpp

#include "TObject.h"
#include "TString.h"

////////////////////////////////////////////////////////////////////////////////
//
// This class aims to record the properties of all the particles 
// passing through a sensitive cell
//
////////////////////////////////////////////////////////////////////////////////


class TMyRootEvent : public TObject  /// a class must derive from TObject to be put in a tree
{     

   protected :

      Int_t     fNCells             ; 

      Int_t     fEventNumber        ; 
      Int_t     fNParticlesPerEvent ; 

      TString   fParticleName       ; 
      Int_t     fZ                  ; 
      Int_t     fA                  ; 
      Int_t     fTrackID            ;  
      Int_t     fParentTrackID      ;  

      TString   fCreatorProcessName ;   
      Double_t  fEkin0              ;  /// initial kinetic energy     [MeV]
      Double_t  fRx0                ;  /// initial position           [mum]
      Double_t  fRy0                ;  /// initial position           [mum]
      Double_t  fRz0                ;  /// initial position           [mum]
      Double_t  fTheta0             ;  /// initial (u_z,u_r)   angle  [deg]
      Double_t  fPhi0               ;  /// initial (u_x,u_rho) angle  [deg]

      TString  *fVolumeName         ;  //[fNCells] sensitive volume name
      Double_t *fEkin               ;  //[fNCells] kinetic energy                                                           [MeV]
      Double_t *fEdep               ;  //[fNCells] deposited energy                                                         [keV]
      Double_t *fDose               ;  //[fNCells] dose                                                                     [gray]
      Double_t *fRangeTot           ;  //[fNCells] total range                                                              [mum]
      Double_t *fRangeProj          ;  //[fNCells] projected range wrt the particle incident momentum at the entrance cell  [mum]
      Double_t *fRangeProjZ         ;  //[fNCells] projected range on the z axis                                            [mum]
      Double_t *fRx                 ;  //[fNCells] position                                                                 [mum] 
      Double_t *fRy                 ;  //[fNCells] position                                                                 [mum] 
      Double_t *fRz                  ;  //[fNCells] position                                                                 [mum]
      Double_t *fTheta              ;  //[fNCells] (u_z,u_r)   angle at the entrance cell                                   [deg]
      Double_t *fPhi                ;  //[fNCells] (u_x,u_rho) angle at the entrance cell                                   [deg]
      Double_t *fGlobalTime         ;  //[fNCells] global time                                                              [ns] 
      Double_t *fLocalTime          ;  //[fNCells] local  time                                                              [ns] 
      Double_t *fWeight             ;  //[fNCells] weight (likely to change depending on the cell number (importance biasing))
      Int_t    *fNHits              ;  //[fNCells] number of hits per particle per cell
 

   public :
         
      TMyRootEvent  () ;
      ~TMyRootEvent () ;
               
      void      InitEvent                     (Int_t aNCells) ;
      void      ClearEvent                    () ;

      Int_t     GetEventNumber                ()                          const ;
      void      SetEventNumber                (Int_t aEventNumber)              ;
      Int_t*    GetEventNumber_pointer        ()                                ;
            
      Int_t     GetNParticlesPerEvent         ()                          const ;
      void      SetNParticlesPerEvent         (Int_t aNParticlesPerEvent)       ;
      Int_t*    GetNParticlesPerEvent_pointer ()                                ;
            
      Int_t     GetNCells                     ()                          const ;
      void      SetNCells                     (Int_t aNCells)                   ;
   
      TString*  GetParticleName_pointer       ()       ;
      Int_t*    GetZ_pointer                  ()       ;
      Int_t*    GetA_pointer                  ()       ;
      Int_t*    GetTrackID_pointer            ()       ;
      Int_t*    GetParentTrackID_pointer      ()       ;
      TString*  GetCreatorProcessName_pointer ()       ;
      Double_t* GetEkin0_pointer              ()       ;
      Double_t* GetRx0_pointer                ()       ;
      Double_t* GetRy0_pointer                ()       ;
      Double_t* GetRz0_pointer                ()       ;
      Double_t* GetTheta0_pointer             ()       ;
      Double_t* GetPhi0_pointer               ()       ;
      TString*  GetVolumeName_pointer         () const ;
      Double_t* GetEkin_pointer               () const ;
      Double_t* GetEdep_pointer               () const ;
      Double_t* GetDose_pointer               () const ;
      Double_t* GetRangeTot_pointer           () const ;
      Double_t* GetRangeProj_pointer          () const ;
      Double_t* GetRangeProjZ_pointer         () const ;
      Double_t* GetRx_pointer                 () const ;
      Double_t* GetRy_pointer                 () const ;
      Double_t* GetRz_pointer                 () const ;
      Double_t* GetTheta_pointer              () const ;
      Double_t* GetPhi_pointer                () const ;
      Double_t* GetGlobalTime_pointer         () const ;
      Double_t* GetLocalTime_pointer          () const ;
      Double_t* GetWeight_pointer             () const ;
      Int_t*    GetNHits_pointer              () const ;

      TString   GetParticleName               ()                 const ; 
      Int_t     GetZ                          ()                 const ; 
      Int_t     GetA                          ()                 const ; 
      Int_t     GetTrackID                    ()                 const ; 
      Int_t     GetParentTrackID              ()                 const ; 
      TString   GetCreatorProcessName         ()                 const ; 
      Double_t  GetEkin0                      ()                 const ; 
      Double_t  GetRx0                        ()                 const ; 
      Double_t  GetRy0                        ()                 const ; 
      Double_t  GetRz0                        ()                 const ; 
      Double_t  GetTheta0                     ()                 const ; 
      Double_t  GetPhi0                       ()                 const ; 
      TString   GetVolumeName                 (Int_t cellNumber) const ;
      Double_t  GetEkin                       (Int_t cellNumber) const ; Double_t  GetEkin        (Char_t* cellName) const ;  /// Has to be a Char_t*! (Using TString causes a seg.fault)
      Double_t  GetEdep                       (Int_t cellNumber) const ; Double_t  GetEdep        (Char_t* cellName) const ; 
      Double_t  GetDose                       (Int_t cellNumber) const ; Double_t  GetDose        (Char_t* cellName) const ; 
      Double_t  GetRangeTot                   (Int_t cellNumber) const ; Double_t  GetRangeTot    (Char_t* cellName) const ; 
      Double_t  GetRangeProj                  (Int_t cellNumber) const ; Double_t  GetRangeProj   (Char_t* cellName) const ; 
      Double_t  GetRangeProjZ                 (Int_t cellNumber) const ; Double_t  GetRangeProjZ  (Char_t* cellName) const ; 
      Double_t  GetRx                         (Int_t cellNumber) const ; Double_t  GetRx          (Char_t* cellName) const ; 
      Double_t  GetRy                         (Int_t cellNumber) const ; Double_t  GetRy          (Char_t* cellName) const ; 
      Double_t  GetRz                         (Int_t cellNumber) const ; Double_t  GetRz          (Char_t* cellName) const ; 
      Double_t  GetTheta                      (Int_t cellNumber) const ; Double_t  GetTheta       (Char_t* cellName) const ; 
      Double_t  GetPhi                        (Int_t cellNumber) const ; Double_t  GetPhi         (Char_t* cellName) const ; 
      Double_t  GetGlobalTime                 (Int_t cellNumber) const ; Double_t  GetGlobalTime  (Char_t* cellName) const ; 
      Double_t  GetLocalTime                  (Int_t cellNumber) const ; Double_t  GetLocalTime   (Char_t* cellName) const ; 
      Double_t  GetWeight                     (Int_t cellNumber) const ; Double_t  GetWeight      (Char_t* cellName) const ; 
      Int_t     GetNHits                      (Int_t cellNumber) const ; Int_t     GetNHits       (Char_t* cellName) const ; 

      void      SetParticleName               (TString  aParticleName                    ) ; 
      void      SetZ                          (Int_t    aZ                               ) ; 
      void      SetA                          (Int_t    aA                               ) ; 
      void      SetTrackID                    (Int_t    aTrackID                         ) ;
      void      SetParentTrackID              (Int_t    aParentTrackID                   ) ;  
      void      SetCreatorProcessName         (TString  aCreatorProcessName              ) ; 
      void      SetEkin0                      (Double_t aEkin0                           ) ; 
      void      SetRx0                        (Double_t aRx0                             ) ; 
      void      SetRy0                        (Double_t aRy0                             ) ; 
      void      SetRz0                        (Double_t aRz0                             ) ; 
      void      SetTheta0                     (Double_t aTheta0                          ) ; 
      void      SetPhi0                       (Double_t aPhi0                            ) ; 
      void      SetVolumeName                 (Int_t    cellNumber, TString  aVolumeName ) ;  
      void      SetEkin                       (Int_t    cellNumber, Double_t aEkin       ) ;  
      void      SetEdep                       (Int_t    cellNumber, Double_t aEdep       ) ;  
      void      SetDose                       (Int_t    cellNumber, Double_t aDose       ) ;  
      void      SetRangeTot                   (Int_t    cellNumber, Double_t aRangeTot   ) ;  
      void      SetRangeProj                  (Int_t    cellNumber, Double_t aRangeProj  ) ;  
      void      SetRangeProjZ                 (Int_t    cellNumber, Double_t aRangeProjZ ) ;  
      void      SetRx                         (Int_t    cellNumber, Double_t aRx         ) ;  
      void      SetRy                         (Int_t    cellNumber, Double_t aRy         ) ;  
      void      SetRz                         (Int_t    cellNumber, Double_t aRz         ) ; 
      void      SetTheta                      (Int_t    cellNumber, Double_t aTheta      ) ;  
      void      SetPhi                        (Int_t    cellNumber, Double_t aPhi        ) ;  
      void      SetGlobalTime                 (Int_t    cellNumber, Double_t aGlobalTime ) ;  
      void      SetLocalTime                  (Int_t    cellNumber, Double_t aLocalTime  ) ;
      void      SetWeight                     (Int_t    cellNumber, Double_t aWeight     ) ;
      void      SetNHits                      (Int_t    cellNumber, Int_t    aNHits      ) ;

      Int_t     GetCellNumber                 (TString aVolumeName) const ;

      void      PrintVolumeName               (Int_t cellNumber) ;
      void      PrintVolumeNames              ()                 ;


  ClassDef (TMyRootEvent,1) ;  
         
} ; 


///////////////////////////////////////////////////////////////////////


inline TMyRootEvent::TMyRootEvent ()
{  
   fNCells = -1 ;
   fEventNumber        = -1 ; 
   fNParticlesPerEvent = -1 ; 
   fParticleName       = "none" ;
   fZ                  = -999  ; 
   fA                  = -999  ; 
   fTrackID            = -999  ; 
   fParentTrackID      = -999  ; 
   fCreatorProcessName = "none" ; 
   fEkin0              = -999. ; 
   fRx0                = -999. ; 
   fRy0                = -999. ; 
   fRz0                = -999. ; 
   fTheta0             = -999. ; 
   fPhi0               = -999. ; 
   fVolumeName         = NULL ; 
   fEkin               = NULL ;
   fEdep               = NULL ;
   fDose               = NULL ;
   fRangeTot           = NULL ;
   fRangeProj          = NULL ;
   fRangeProjZ         = NULL ;
   fRx                 = NULL ;
   fRy                 = NULL ;
   fRz                 = NULL ; 
   fTheta              = NULL ; 
   fPhi                = NULL ; 
   fGlobalTime         = NULL ; 
   fLocalTime          = NULL ; 
   fWeight             = NULL ; 
   fNHits              = NULL ; 
}

//______________________________________________________________________________

inline TMyRootEvent::~TMyRootEvent ()
{
   ClearEvent() ; 
   delete fVolumeName ; fVolumeName = NULL ; 
   delete fEkin       ; fEkin       = NULL ;
   delete fEdep       ; fEdep       = NULL ;
   delete fDose       ; fDose       = NULL ;
   delete fRangeTot   ; fRangeTot   = NULL ;
   delete fRangeProj  ; fRangeProj  = NULL ;
   delete fRangeProjZ ; fRangeProjZ = NULL ;
   delete fRx         ; fRx         = NULL ;
   delete fRy         ; fRy         = NULL ;
   delete fRz         ; fRz         = NULL ;  
   delete fTheta      ; fTheta      = NULL ; 
   delete fPhi        ; fPhi        = NULL ;
   delete fGlobalTime ; fGlobalTime = NULL ; 
   delete fLocalTime  ; fLocalTime  = NULL ; 
   delete fWeight     ; fWeight     = NULL ; 
   delete fNHits      ; fNHits      = NULL ; 
}
               
//______________________________________________________________________________

inline void TMyRootEvent::InitEvent ( Int_t aNCells )
{
   fNCells     = aNCells ;
   fVolumeName = new TString  [fNCells] ; 
   fEkin       = new Double_t [fNCells] ;
   fEdep       = new Double_t [fNCells] ;
   fDose       = new Double_t [fNCells] ;
   fRangeTot   = new Double_t [fNCells] ;
   fRangeProj  = new Double_t [fNCells] ;
   fRangeProjZ = new Double_t [fNCells] ;
   fRx         = new Double_t [fNCells] ;
   fRy         = new Double_t [fNCells] ;
   fRz           = new Double_t [fNCells] ; 
   fTheta      = new Double_t [fNCells] ; 
   fPhi        = new Double_t [fNCells] ; 
   fGlobalTime = new Double_t [fNCells] ; 
   fLocalTime  = new Double_t [fNCells] ; 
   fWeight     = new Double_t [fNCells] ; 
   fNHits      = new Int_t    [fNCells] ; 
   ClearEvent() ; 
   return ; 
}
   
//______________________________________________________________________________

inline void TMyRootEvent::ClearEvent ()
{
   fEventNumber        = -1 ; 
   fNParticlesPerEvent = -1 ; 
   fParticleName       = "none" ;
   fZ                  = -999  ; 
   fA                  = -999  ; 
   fTrackID            = -999  ; 
   fParentTrackID      = -999  ; 
   fCreatorProcessName = "none" ; 
   fEkin0              = -999. ; 
   fTheta0             = -999. ; 
   fRx0                = -999. ; 
   fRy0                = -999. ; 
   fRz0                = -999. ; 
   for (Int_t cellNumber=0; cellNumber<fNCells; cellNumber++) 
   { 
      fVolumeName [cellNumber] = "none" ; 
      fEkin       [cellNumber] = -999. ; 
      fEdep       [cellNumber] = -999. ;  
      fDose       [cellNumber] = -999. ;  
      fRangeTot   [cellNumber] = -999. ;  
      fRangeProj  [cellNumber] = -999. ;  
      fRangeProjZ [cellNumber] = -999. ;  
      fRx         [cellNumber] = -999. ;  
      fRy         [cellNumber] = -999. ;  
      fRz         [cellNumber] = -999. ;  
      fTheta      [cellNumber] = -999. ;  
      fPhi        [cellNumber] = -999. ;  
      fGlobalTime [cellNumber] = -999. ;  
      fLocalTime  [cellNumber] = -999. ; 
      fWeight     [cellNumber] = -999. ; 
      fNHits      [cellNumber] = -999  ; 
   }
   return ; 
}

//______________________________________________________________________________

inline Int_t  TMyRootEvent::GetEventNumber                ()                          const {                                             return (fEventNumber)         ; }  
inline void   TMyRootEvent::SetEventNumber                (Int_t aEventNumber)              { fEventNumber        = aEventNumber        ; return                        ; } 
inline Int_t* TMyRootEvent::GetEventNumber_pointer        ()                                {                                             return (&fEventNumber)        ; } 
            
inline Int_t  TMyRootEvent::GetNParticlesPerEvent         ()                          const {                                             return (fNParticlesPerEvent)  ; }  
inline void   TMyRootEvent::SetNParticlesPerEvent         (Int_t aNParticlesPerEvent)       { fNParticlesPerEvent = aNParticlesPerEvent ; return                        ; } 
inline Int_t* TMyRootEvent::GetNParticlesPerEvent_pointer ()                                {                                             return (&fNParticlesPerEvent) ; } 
            
inline Int_t  TMyRootEvent::GetNCells                     ()                          const {                                             return (fNCells)              ; }  
inline void   TMyRootEvent::SetNCells                     (Int_t aNCells)                   { fNCells             = aNCells             ; return                        ; } 

//______________________________________________________________________________

inline TString*  TMyRootEvent::GetParticleName_pointer       ()       { return (&fParticleName       ) ; } 
inline Int_t*    TMyRootEvent::GetZ_pointer                  ()       { return (&fZ                  ) ; } 
inline Int_t*    TMyRootEvent::GetA_pointer                  ()       { return (&fA                  ) ; } 
inline Int_t*    TMyRootEvent::GetTrackID_pointer            ()       { return (&fTrackID            ) ; } 
inline Int_t*    TMyRootEvent::GetParentTrackID_pointer      ()       { return (&fParentTrackID      ) ; } 
inline TString*  TMyRootEvent::GetCreatorProcessName_pointer ()       { return (&fCreatorProcessName ) ; }  
inline Double_t* TMyRootEvent::GetEkin0_pointer              ()       { return (&fEkin0              ) ; } 
inline Double_t* TMyRootEvent::GetRx0_pointer                ()       { return (&fRx0                ) ; } 
inline Double_t* TMyRootEvent::GetRy0_pointer                ()       { return (&fRy0                ) ; } 
inline Double_t* TMyRootEvent::GetRz0_pointer                ()       { return (&fRz0                ) ; } 
inline Double_t* TMyRootEvent::GetTheta0_pointer             ()       { return (&fTheta0             ) ; } 
inline Double_t* TMyRootEvent::GetPhi0_pointer               ()       { return (&fPhi0               ) ; } 
inline TString*  TMyRootEvent::GetVolumeName_pointer         () const { return ( fVolumeName         ) ; } 
inline Double_t* TMyRootEvent::GetEkin_pointer               () const { return ( fEkin               ) ; } 
inline Double_t* TMyRootEvent::GetEdep_pointer               () const { return ( fEdep               ) ; } 
inline Double_t* TMyRootEvent::GetDose_pointer               () const { return ( fDose               ) ; } 
inline Double_t* TMyRootEvent::GetRangeTot_pointer           () const { return ( fRangeTot           ) ; } 
inline Double_t* TMyRootEvent::GetRangeProj_pointer          () const { return ( fRangeProj          ) ; } 
inline Double_t* TMyRootEvent::GetRangeProjZ_pointer         () const { return ( fRangeProjZ         ) ; } 
inline Double_t* TMyRootEvent::GetRx_pointer                 () const { return ( fRx                 ) ; } 
inline Double_t* TMyRootEvent::GetRy_pointer                 () const { return ( fRy                 ) ; } 
inline Double_t* TMyRootEvent::GetRz_pointer                 () const { return ( fRz                 ) ; } 
inline Double_t* TMyRootEvent::GetTheta_pointer              () const { return ( fTheta              ) ; } 
inline Double_t* TMyRootEvent::GetPhi_pointer                () const { return ( fPhi                ) ; } 
inline Double_t* TMyRootEvent::GetGlobalTime_pointer         () const { return ( fGlobalTime         ) ; } 
inline Double_t* TMyRootEvent::GetLocalTime_pointer          () const { return ( fLocalTime          ) ; } 
inline Double_t* TMyRootEvent::GetWeight_pointer             () const { return ( fWeight             ) ; } 
inline Int_t*    TMyRootEvent::GetNHits_pointer              () const { return ( fNHits              ) ; } 

//______________________________________________________________________________

inline TString   TMyRootEvent::GetParticleName       ()                 const { return (fParticleName      ) ; } 
inline Int_t     TMyRootEvent::GetZ                  ()                 const { return (fZ                 ) ; } 
inline Int_t     TMyRootEvent::GetA                  ()                 const { return (fA                 ) ; } 
inline Int_t     TMyRootEvent::GetTrackID            ()                 const { return (fTrackID           ) ; } 
inline Int_t     TMyRootEvent::GetParentTrackID      ()                 const { return (fParentTrackID     ) ; }  
inline TString   TMyRootEvent::GetCreatorProcessName ()                 const { return (fCreatorProcessName) ; } 
inline Double_t  TMyRootEvent::GetEkin0              ()                 const { return (fEkin0             ) ; }  
inline Double_t  TMyRootEvent::GetRx0                ()                 const { return (fRx0               ) ; }  
inline Double_t  TMyRootEvent::GetRy0                ()                 const { return (fRy0               ) ; }  
inline Double_t  TMyRootEvent::GetRz0                ()                 const { return (fRz0               ) ; }  
inline Double_t  TMyRootEvent::GetTheta0             ()                 const { return (fTheta0            ) ; }  
inline Double_t  TMyRootEvent::GetPhi0               ()                 const { return (fPhi0              ) ; }  
inline TString   TMyRootEvent::GetVolumeName         (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetVolumeName (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fVolumeName [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetEkin               (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetEkin       (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fEkin       [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetEdep               (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetEdep       (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fEdep       [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetDose               (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetDose       (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fDose       [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetRangeTot           (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetRange      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fRangeTot   [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetRangeProj          (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetRange      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fRangeProj  [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetRangeProjZ         (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetRange      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fRangeProjZ [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetRx                 (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetRx         (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fRx         [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetRy                 (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetRy         (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fRy         [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetRz                 (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetRz         (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fRz         [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetTheta              (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetTheta      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fTheta      [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetPhi                (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetPhi        (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fPhi        [cellNumber]) ; }  
inline Double_t  TMyRootEvent::GetGlobalTime         (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetGlobalTime (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fGlobalTime [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetLocalTime          (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetLocalTime  (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fLocalTime  [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetWeight             (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetWeight     (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fWeight     [cellNumber]) ; } 
inline Int_t     TMyRootEvent::GetNHits              (Int_t cellNumber) const { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetNHits      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } return (fNHits      [cellNumber]) ; } 
inline Double_t  TMyRootEvent::GetEkin               (Char_t* cellName) const { return ( GetEkin       (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetEdep               (Char_t* cellName) const { return ( GetEdep       (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetDose               (Char_t* cellName) const { return ( GetDose       (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetRangeTot           (Char_t* cellName) const { return ( GetRangeTot   (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetRangeProj          (Char_t* cellName) const { return ( GetRangeProj  (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetRangeProjZ         (Char_t* cellName) const { return ( GetRangeProjZ (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetRx                 (Char_t* cellName) const { return ( GetRx         (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetRy                 (Char_t* cellName) const { return ( GetRy         (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetRz                 (Char_t* cellName) const { return ( GetRz         (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetTheta              (Char_t* cellName) const { return ( GetTheta      (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetPhi                (Char_t* cellName) const { return ( GetPhi        (GetCellNumber(cellName)) ) ; }  
inline Double_t  TMyRootEvent::GetGlobalTime         (Char_t* cellName) const { return ( GetGlobalTime (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetLocalTime          (Char_t* cellName) const { return ( GetLocalTime  (GetCellNumber(cellName)) ) ; } 
inline Double_t  TMyRootEvent::GetWeight             (Char_t* cellName) const { return ( GetWeight     (GetCellNumber(cellName)) ) ; } 
inline Int_t     TMyRootEvent::GetNHits              (Char_t* cellName) const { return ( GetNHits      (GetCellNumber(cellName)) ) ; } 

//______________________________________________________________________________

inline void TMyRootEvent::SetParticleName       (TString  aParticleName                    ) { fParticleName       = aParticleName       ; return ; }
inline void TMyRootEvent::SetZ                  (Int_t    aZ                               ) { fZ                  = aZ                  ; return ; }
inline void TMyRootEvent::SetA                  (Int_t    aA                               ) { fA                  = aA                  ; return ; }
inline void TMyRootEvent::SetTrackID            (Int_t    aTrackID                         ) { fTrackID            = aTrackID            ; return ; }
inline void TMyRootEvent::SetParentTrackID      (Int_t    aParentTrackID                   ) { fParentTrackID      = aParentTrackID      ; return ; }
inline void TMyRootEvent::SetCreatorProcessName (TString  aCreatorProcessName              ) { fCreatorProcessName = aCreatorProcessName ; return ; }
inline void TMyRootEvent::SetEkin0              (Double_t aEkin0                           ) { fEkin0              = aEkin0              ; return ; }
inline void TMyRootEvent::SetRx0                (Double_t aRx0                             ) { fRx0                = aRx0                ; return ; }
inline void TMyRootEvent::SetRy0                (Double_t aRy0                             ) { fRy0                = aRy0                ; return ; }
inline void TMyRootEvent::SetRz0                (Double_t aRz0                             ) { fRz0                = aRz0                ; return ; }
inline void TMyRootEvent::SetTheta0             (Double_t aTheta0                          ) { fTheta0             = aTheta0             ; return ; }
inline void TMyRootEvent::SetPhi0               (Double_t aPhi0                            ) { fPhi0               = aPhi0               ; return ; }
inline void TMyRootEvent::SetVolumeName         (Int_t    cellNumber, TString  aVolumeName ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetVolumeName (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fVolumeName  [cellNumber] = aVolumeName  ; return ; }   
inline void TMyRootEvent::SetEkin               (Int_t    cellNumber, Double_t aEkin       ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetEkin       (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fEkin        [cellNumber] = aEkin        ; return ; }   
inline void TMyRootEvent::SetEdep               (Int_t    cellNumber, Double_t aEdep       ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetEdep       (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fEdep        [cellNumber] = aEdep        ; return ; }   
inline void TMyRootEvent::SetDose               (Int_t    cellNumber, Double_t aDose       ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetDose       (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fDose        [cellNumber] = aDose        ; return ; }   
inline void TMyRootEvent::SetRangeTot           (Int_t    cellNumber, Double_t aRangeTot   ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetRangeTot   (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fRangeTot    [cellNumber] = aRangeTot    ; return ; }   
inline void TMyRootEvent::SetRangeProj          (Int_t    cellNumber, Double_t aRangeProj  ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetRangeProj  (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fRangeProj   [cellNumber] = aRangeProj   ; return ; }   
inline void TMyRootEvent::SetRangeProjZ         (Int_t    cellNumber, Double_t aRangeProjZ ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetRangeProjZ (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fRangeProjZ  [cellNumber] = aRangeProjZ  ; return ; }   
inline void TMyRootEvent::SetRx                 (Int_t    cellNumber, Double_t aRx         ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetRx         (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fRx          [cellNumber] = aRx          ; return ; }   
inline void TMyRootEvent::SetRy                 (Int_t    cellNumber, Double_t aRy         ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetRy         (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fRy          [cellNumber] = aRy          ; return ; }   
inline void TMyRootEvent::SetRz                 (Int_t    cellNumber, Double_t aRz         ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetRz         (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fRz          [cellNumber] = aRz          ; return ; }  
inline void TMyRootEvent::SetTheta              (Int_t    cellNumber, Double_t aTheta      ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetTheta      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fTheta       [cellNumber] = aTheta       ; return ; }   
inline void TMyRootEvent::SetPhi                (Int_t    cellNumber, Double_t aPhi        ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetPhi        (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fPhi         [cellNumber] = aPhi         ; return ; }   
inline void TMyRootEvent::SetGlobalTime         (Int_t    cellNumber, Double_t aGlobalTime ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetGlobalTime (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fGlobalTime  [cellNumber] = aGlobalTime  ; return ; }   
inline void TMyRootEvent::SetLocalTime          (Int_t    cellNumber, Double_t aLocalTime  ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetLocalTime  (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fLocalTime   [cellNumber] = aLocalTime   ; return ; }   
inline void TMyRootEvent::SetWeight             (Int_t    cellNumber, Double_t aWeight     ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetWeight     (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fWeight      [cellNumber] = aWeight      ; return ; }   
inline void TMyRootEvent::SetNHits              (Int_t    cellNumber, Int_t    aNHits      ) { if (cellNumber<0 || cellNumber>fNCells) { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::SetNHits      (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } fNHits       [cellNumber] = aNHits       ; return ; }   

//______________________________________________________________________________

inline Int_t TMyRootEvent::GetCellNumber (TString aVolumeName) const 
{ 
   for (Int_t cellNumber=0; cellNumber<fNCells; cellNumber++) 
      if ( fVolumeName[cellNumber] == aVolumeName ) { return (cellNumber) ; }
   fprintf (stderr, "\n\n!!! Error in TMyRootEvent::GetCellNumber (), volumeName='%s' is not defined!\n\n",aVolumeName.Data()) ; getchar() ; exit(1) ; 
}

inline void TMyRootEvent::PrintVolumeName  (Int_t cellNumber) 
{ 
   if (cellNumber<0 || cellNumber>fNCells) 
      { fprintf (stderr, "\n\n!!! Error in TMyRootEvent::PrintVolumeName (), cellNumber=%d NOT IN [0;%d]\n\n",cellNumber,fNCells-1) ; getchar() ; exit(1) ; } 
   fprintf (stdout,"\n%s",fVolumeName[cellNumber].Data()) ; 
   return ;  
}

inline void TMyRootEvent::PrintVolumeNames ()                 
{ 
   fprintf (stdout,"\nVolumeNames:") ; 
   for (Int_t cellNumber=0; cellNumber<fNCells; cellNumber++)  
      { PrintVolumeName(cellNumber) ; } ; 
   fprintf (stdout,"\n") ; 
   return ; 
}


#endif

Copyright: Mathieu Trocmé, Sun 4 Oct 2009 (CeCILL license)