GammaTracker.h

Go to the documentation of this file.

#ifndef GW_GAMMATRACKER_H
#define GW_GAMMATRACKER_H

#ifndef ROOT_Rtypes
#include "Rtypes.h"
#endif

#ifndef ROOT_TNamed
#include "TNamed.h"
#endif


namespace Gw {

class GammaTracker : public TNamed
{       
private:
        UInt_t MaxImpacts;      
                
        Double_t DistFactor;    
        Double_t EnerFactor;    

protected:
        UInt_t    InputN;       
        Double_t *InputE;       
        Double_t *InputDE;      

        Double_t *InputX;       
        Double_t *InputY;       
        Double_t *InputZ;       
        Double_t *InputDX;      
        Double_t *InputDY;      
        Double_t *InputDZ;      
        
        UInt_t    OutputN;      
        Double_t *OutputE;      
        Double_t *OutputTheta1; 
        Double_t *OutputPhi1;   
        Double_t *OutputTheta2; 
        Double_t *OutputPhi2;   

//      Bool_t fDoPacking;      // true if  packing must be done (data comes from Geant)
//      Bool_t fDoSmearing;     // true if smearing must be done (data comes from Geant)
        
public:
        GammaTracker(const char *name = "GammaTracker", const char *title = "Base to track gamma-rays") ;
        virtual ~GammaTracker();
        
        static bool Load(const char *classname, const char *pathtopackage, const char *libraryname); 
        

        static bool IsTracker(const char *classname) { return GetTracker(classname) != NULL; }
        
        /*
        Trackers are external programs that should be linked. According to DAQ specifications, any tracking 
        algorithm must be compiled in a single dynamic library 
        */
        static GammaTracker *GetTracker(const char *classname);
        

        Double_t GetDistFactor() const { return DistFactor; } 
        Double_t GetEnerFactor() const { return EnerFactor; }
        
        virtual void SetDistFactor(Double_t f) { DistFactor = f; } 
        virtual void SetEnerFactor(Double_t f) { EnerFactor = f; }
        
        Double_t GetMaxImpacts() const { return MaxImpacts; } 
        
//      virtual Int_t Expand(Int_t);

        virtual UInt_t    GetInputN()  const { return InputN; }
        virtual const Double_t *GetInputE()  const { return InputE; }
        virtual const Double_t *GetInputDE() const { return InputDE;}
        virtual const Double_t *GetInputX()  const { return InputX; }
        virtual const Double_t *GetInputY()  const { return InputY; }
        virtual const Double_t *GetInputZ()  const { return InputZ; }
        virtual const Double_t *GetInputDX() const { return InputDX; }
        virtual const Double_t *GetInputDY() const { return InputDY; }
        virtual const Double_t *GetInputDZ() const { return InputDZ; }
        
        /*
        Energies and Positions are copied, multiplied by a factor to take into account the tracking may work with units 
        different from the ones given by the data flow.
        */
        virtual UInt_t SetEvent(UInt_t n, const Double_t *e, const Double_t *x, const Double_t *y, const Double_t *z, Double_t efactor = 1.0, Double_t pfactor = 1.0);
        
        void ShowCurrentEvent();

        virtual UInt_t    GetOutputN() const { return OutputN; }
        virtual const Double_t *GetOutputE() const { return OutputE;  }
        virtual const Double_t *GetOutputTheta1() const { return OutputTheta1;  }
        virtual const Double_t *GetOutputPhi1()   const { return OutputPhi1;  }
        virtual const Double_t *GetOutputTheta2() const { return OutputTheta2;  }
        virtual const Double_t *GetOutputPhi2()   const { return OutputPhi2;  }

        virtual void SetPacking()  {;}
        virtual void SetSmearing() {;}


        virtual Int_t DoTracking();

        ClassDef(GammaTracker,0); // Base class for tracking algorithms
};

/*
Must be used in conjonction with SetInput(UInt_t i, Double_t ...)
*/      
// virtual UInt_t SetInput(UInt_t ninput) { InputN=(ninput>MaxImpacts)?MaxImpacts:ninput; return InputN; }
        
/*
virtual void SetInput(UInt_t i, Double_t e, Double_t x, Double_t y, Double_t z, Double_t de = 0.0, Double_t dx = 0.0, Double_t dy = 0.0, Double_t dz = 0.0) 
{ if ( i > InputN && i < MaxImpacts ) {InputN=i+1; InputE[i]=e; InputDE[i]=de; InputX[i]=x; InputDX[i]=dx; InputY[i]=y; InputDY[i]=dy; InputZ[i]=z; InputDZ[i]=dz;} }
*/
        
}
#endif