ahdcSignal.h

#ifndef AHDC_SIGNAL_H
#define AHDC_SIGNAL_H
 
 
class ahdcSignal {
    // MHit or wires identifiers
    public : 
        int hitn; 
        int sector; 
        int layer; 
        int component; 
        int nsteps; 
    // vectors
    private :
        std::vector<double> Edep; 
        std::vector<double> G4Time; 
        std::vector<double> Doca; 
        std::vector<double> DriftTime; 
        
        void ComputeDocaAndTime(MHit * aHit);
        std::vector<short> Dgtz; 
        std::vector<short> Noise; 
    // setting parameters for digitization
    private : 
        const double tmin; 
        const double tmax; 
        const double timeOffset; 
        const double samplingTime; 
        const double Landau_width; 
        double electronYield = 9500;   
        static const int ADC_LIMIT = 4095; 
    // public methods
    public :
        ahdcSignal() = default;
        
        ahdcSignal(MHit * aHit, int _hitn, double _tmin, double _tmax, double _timeOffset, double _samplingTime, double _Landau_width) 
        : tmin(_tmin), tmax(_tmax), timeOffset(_timeOffset), samplingTime(_samplingTime), Landau_width(_Landau_width) {
            // read identifiers
            hitn = _hitn;
            vector<identifier> identity = aHit->GetId();
            sector = 0;
            layer = 10 * identity[0].id + identity[1].id ; // 10*superlayer + layer
            component = identity[2].id;
            // fill vectors
            Edep = aHit->GetEdep();
            nsteps = Edep.size();
            for (int s=0;s<nsteps;s++){Edep.at(s) = Edep.at(s)*1000;} // convert MeV to keV
            G4Time = aHit->GetTime();
            this->ComputeDocaAndTime(aHit); // fills Doca and DriftTime
        }
        
        ~ahdcSignal(){;}
        
        double GetElectronYield() {return electronYield;}
        
        std::vector<double>                     GetEdep()       {return Edep;}
        
        std::vector<double>                     GetG4Time()     {return G4Time;}
        
        std::vector<double>                     GetDoca()       {return Doca;}
        
        std::vector<double>                     GetDriftTime()      {return DriftTime;}
        
        std::vector<short>                     GetNoise()              {return Noise;}
        
        std::vector<short>          GetDgtz()       {return Dgtz;}
        
        void SetElectronYield(double electronYield_)        {electronYield = electronYield_;}
        
        double operator()(double timePoint){
            using namespace Genfun;
            double signalValue = 0;
            for (int s=0; s<nsteps; s++){
                // setting Landau's parameters
                Landau L;
                L.peak() = Parameter("Peak",DriftTime.at(s),tmin,tmax); 
                L.width() = Parameter("Width",Landau_width,0,400); 
                signalValue += Edep.at(s)*L(timePoint-timeOffset);
            }
            return signalValue;
        }
        
        void Digitize();
 
        void GenerateNoise(double mean, double stdev);
        
        double GetMCTime(); // tmp
        double GetMCEtot(); // tmp
        
        std::map<std::string,double> Extract(bool expression = true);
 
        void PrintBeforeProcessing(bool expression = true); // e.g : this->PrintBeforeProcessing(this->nsteps > 10)
        void PrintAllShapes(bool expression = true);
        void PrintAfterProcessing(bool expression = true);
        void PrintNoise(bool expression = true);
        void PrintSignal(bool expression = true);
};
 
 
 
#endif