DetectorDriver.hpp

Go to the documentation of this file.

#ifndef __DETECTORDRIVER_HPP_
#define __DETECTORDRIVER_HPP_ 1

#include <set>
#include <string>
#include <utility>
#include <vector>

#include "Calibrator.hpp"
#include "ChanEvent.hpp"
#include "Globals.hpp"
#include "Messenger.hpp"
#include "Plots.hpp"
#include "WalkCorrector.hpp"

class Calibration;
class RawEvent;
class EventProcessor;
class TraceAnalyzer;

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

    WalkCorrector walk; 
    Calibrator cali;
    Plots histo;

    virtual void plot(int dammId, double val1, double val2 = -1,
                      double val3 = -1, const char* name="h") {
        histo.Plot(dammId, val1, val2, val3, name);
    }

    int ProcessEvent(RawEvent& rawev);

    int ThreshAndCal(ChanEvent *chan, RawEvent& rawev);

    int Init(RawEvent& rawev);

    int PlotRaw(const ChanEvent *);

    int PlotCal(const ChanEvent *);

    void DeclarePlots();

    void SanityCheck(void) const {};

    void CorrelateClock(double d, time_t t) {
        pixieToWallClock=std::make_pair(d, t);
    }

    time_t GetWallTime(double d) const {
        return (time_t)((d - pixieToWallClock.first) *
                        Globals::get()->clockInSeconds() +
                        pixieToWallClock.second);
    }

    const std::vector<EventProcessor *>& GetProcessors(void) const {
        return vecProcess;
    }

    std::vector<EventProcessor *> GetProcessors(const std::string &type) const;

    const std::set<std::string> &GetUsedDetectors(void) const;

    virtual ~DetectorDriver();
private:
    DetectorDriver();
    DetectorDriver(const DetectorDriver&); 
    DetectorDriver& operator= (DetectorDriver const&);
    static DetectorDriver* instance;

    std::vector<EventProcessor*> vecProcess; 
    std::vector<TraceAnalyzer*> vecAnalyzer; 
    std::set<std::string> knownDetectors; 
    std::pair<double, time_t> pixieToWallClock; 
    virtual void DeclareHistogram1D(int dammId, int xSize, const char* title) {
        histo.DeclareHistogram1D(dammId, xSize, title);
    }

    virtual void DeclareHistogram2D(int dammId, int xSize, int ySize,
                                    const char* title) {
        histo.DeclareHistogram2D(dammId, xSize, ySize, title);
    }

    void LoadProcessors(Messenger& m);

    void ReadCalXml();
    void ReadWalkXml();
};

#endif // __DETECTORDRIVER_HPP_