Correlator.hpp

Go to the documentation of this file.

#ifndef __CORRELATOR_PROCESSOR_HPP_
#define __CORRELATOR_PROCESSOR_HPP_

#include <utility>
#include <vector>

#include <cmath>

#include "Plots.hpp"
#include "DammPlotIds.hpp"
#include "Globals.hpp"

class LogicProcessor;
class RawEvent;

struct EventInfo
{
    enum EEventTypes {IMPLANT_EVENT, ALPHA_EVENT, BETA_EVENT, FISSION_EVENT,
              PROTON_EVENT, DECAY_EVENT, PROJECTILE_EVENT, GAMMA_EVENT,
              UNKNOWN_EVENT};

    EEventTypes type; 
    double time;     
    double dtime;    
    double energy;   
    double energyBox; 
    double offTime;  
    double foilTime; 
    double tof;      
    double position; 
    short  boxMult;  
    short  boxMax;   
    short  impMult;  
    short  mcpMult;  
    short  generation; 
    bool   flagged;  
    bool   hasTof;   
    bool   hasVeto;  
    bool   beamOn;   
    bool   pileUp;   

    unsigned long clockCount;
    unsigned char logicBits[dammIds::logic::MAX_LOGIC+1];

    EventInfo();
    EventInfo(double t, double e, LogicProcessor *lp);
};

class CorrelationList : public std::vector<EventInfo> {
private:
    bool flagged;
public:
    CorrelationList();
    double GetDecayTime(void) const;
    double GetImplantTime(void) const;
    void Flag(void);
    bool IsFlagged(void) const;
    void clear(void);
    void PrintDecayList(void) const;
};

class Correlator {
public:
    enum EConditions {INVALID_LOCATION     = 4,
              VALID_IMPLANT        = 12,
              VALID_DECAY          = 16,
              BACK_TO_BACK_IMPLANT = 32,
              DECAY_TOO_LATE       = 48,
              IMPLANT_TOO_SOON     = 52,
              UNKNOWN_CONDITION    = 100};
    Correlator();
    virtual ~Correlator();

    void DeclarePlots(void);
    void Init(RawEvent &rawev) {};
    void Correlate(EventInfo &event, unsigned int fch, unsigned int bch);
    void CorrelateAll(EventInfo &event);
    void CorrelateAllX(EventInfo &event, unsigned int bch);
    void CorrelateAllY(EventInfo &event, unsigned int fch);
    void PrintDecayList(unsigned int fch, unsigned int bch) const;

    double GetDecayTime(void) const;
    double GetDecayTime(int fch, int bch) const;
    double GetImplantTime(void) const;
    double GetImplantTime(int fch, int bch) const;

    void Flag(int fch, int bch);

    bool IsFlagged(int fch, int bch);

    EConditions GetCondition(void) const {
        return condition;
    }

private:
    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);
    }

    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);
    }

    static const size_t arraySize = 40; 
    static const double minImpTime; 
    static const double corrTime;   
    static const double fastTime;   
    EventInfo   *lastImplant;  
    EventInfo   *lastDecay;    

    EConditions condition;     
    CorrelationList decaylist[arraySize][arraySize]; 
};
#endif // __CORRELATOR_PROCESSOR_HPP_