TimingCalibrator.hpp

Go to the documentation of this file.

#ifndef __TIMINGCALIBRATOR_HPP__
#define __TIMINGCALIBRATOR_HPP__

#include <vector>
#include <map>
#include <string>

#include "Globals.hpp"
#include "Messenger.hpp"

class TimingCalibration {
public:
    TimingCalibration(){SetDefaults();};
    ~TimingCalibration(){};

    double GetLeftRightTimeOffset(void)const {return(lrtOffset_);};
    double GetTofOffset(const unsigned int &a) const {
        if(tofOffsets_.find(a) == tofOffsets_.end())
            return(0.0);
        return((*tofOffsets_.find(a)).second);
    };
    double GetXOffset(void) const {return(xOffset_);};
    double GetZ0(void) const {return(z0_);};
    double GetZOffset(void) const {return(zOffset_);};

    unsigned int GetNumTofOffsets(void) const {return(tofOffsets_.size());};

    void SetLeftRightTimeOffset(const double &a) {lrtOffset_ = a;};
    void SetTofOffset(const unsigned int &a, const double &b)
        {tofOffsets_.insert(std::make_pair(a,b));};
    void SetXOffset(const double &a) {xOffset_ = a;};
    void SetZ0(const double &a) {z0_ = a;};
    void SetZOffset(const double &a) {zOffset_ = a;};
private:
    double lrtOffset_;
    double xOffset_;
    double z0_;
    double zOffset_;

    std::map<unsigned int, double> tofOffsets_; 

    void SetDefaults(void) {
        lrtOffset_ = xOffset_ = z0_ = zOffset_ = 0.0;
    };
};

class TimingCalibrator {
public:
    static TimingCalibrator* get();

    TimingCalibration GetCalibration(const TimingDefs::TimingIdentifier &id);
private:
    TimingCalibrator() {ReadTimingCalXml();}; 
    TimingCalibrator (const TimingCalibrator&);
    TimingCalibrator& operator = (TimingCalibrator const&);
    static TimingCalibrator* instance; 

    void ReadTimingCalXml(); 

    Messenger m_; 
    std::map <TimingDefs::TimingIdentifier, TimingCalibration> calibrations_; 
    TimingCalibration default_; 
    bool isVerbose_; 
};
#endif // __TIMINGCALIBRATOR_HPP__