GeProcessor.hpp

Go to the documentation of this file.

#ifndef __GEPROCESSOR_HPP_
#define __GEPROCESSOR_HPP_

#include <map>
#include <vector>
#include <utility>
#include <cmath>

#include "EventProcessor.hpp"
#include "RawEvent.hpp"

namespace dammIds {
    namespace ge {
        const unsigned int MAX_CLOVERS = 4; 
        const unsigned int MAX_TIMEX = 5; 

        const int D_ENERGY = 0;
        const int D_ENERGY_CLOVERX = 2; 
        const int D_ENERGY_MOVE = 6;
        const int D_MULT = 9;
        const int D_ADD_ENERGY = 50; 
        const int D_ADD_ENERGY_CLOVERX = 55;
        const int D_ADD_ENERGY_TOTAL = 59;

        const int DD_ENERGY = 100;
        const int DD_ENERGY_PROMPT = 101;
        const int DD_ENERGY_CGATE1 = 102;
        const int DD_ENERGY_CGATE2 = 103;

        const int DD_TDIFF__GATEX = 105;
        const int DD_ENERGY__GATEX = 106;
        const int DD_ANGLE__GATEX = 107;

        const int DD_ENERGY__TIMEX = 120;

        const int DD_ADD_ENERGY = 150;

        const int DD_TDIFF__GAMMA_GAMMA_ENERGY = 155;
        const int DD_TDIFF__GAMMA_GAMMA_ENERGY_SUM = 156;

        const int DD_ADD_ENERGY__TIMEX = 170;

        namespace betaGated {
            const int D_ENERGY = 10;
            const int D_ENERGY_PROMPT = 11;
            const int D_ENERGY_CLOVERX = 12;
            const int D_ENERGY_MOVE = 16;
            const int D_ENERGY_BETA0 = 17;
            const int D_ENERGY_BETA1 = 18;
            const int DD_ENERGY__BETAGAMMALOC = 19;

            const int D_ADD_ENERGY = 60;
            const int D_ADD_ENERGY_PROMPT = 61;
            const int D_ADD_ENERGY_CLOVERX = 65;
            const int D_ADD_ENERGY_TOTAL = 69;

            const int DD_ENERGY = 110;
            const int DD_ENERGY_PROMPT = 111;
            const int DD_ENERGY_CGATE1 = 112;
            const int DD_ENERGY_CGATE2 = 113;
            const int DD_ENERGY_BDELAYED = 114;

            const int DD_TDIFF__GATEX = 115;
            const int DD_ENERGY__GATEX = 116;
            const int DD_ANGLE__GATEX = 117;

            const int DD_TDIFF__GAMMA_ENERGY = 118; 
            const int DD_TDIFF__BETA_ENERGY = 119;

            const int DD_ENERGY__TIMEX = 130;
            const int DD_ENERGY__TIMEX_GROW = 135;
            const int DD_ENERGY__TIMEX_DECAY = 140;

            const int DD_ADD_ENERGY = 160;
            const int DD_ADD_ENERGY_PROMPT = 161;
            const int DD_ADD_ENERGY__TIMEX = 180;
        }

        namespace multi {
            const int D_ADD_ENERGY = 52;
            const int D_ADD_ENERGY_TOTAL = 54;
            const int DD_ADD_ENERGY = 152;
            namespace betaGated {
                const int D_ADD_ENERGY = 62;
                const int D_ADD_ENERGY_PROMPT = 63;
                const int D_ADD_ENERGY_TOTAL = 64;
                const int DD_ADD_ENERGY = 162;
                const int DD_ADD_ENERGY_PROMPT = 163;
            }
        }
    } // end namespace ge
}

#ifdef GGATES

class LineGate {
    public:
        LineGate() {min = max = -1;};

        LineGate(double emin, double emax) {
            min = emin;
            max = emax;
        }

        bool Check() {
            if (min > 0 && max > min)
                return true;
            else
                return false;
        }

        bool IsWithin(double x) {
            if (x >= min && x <= max)
                return true;
            else
                return false;
        }

        bool operator< (const LineGate& other) const {
            return (min < other.min);
        }

        double min; 
        double max; 
};
#endif

class AddBackEvent {
    public:
        AddBackEvent() {
            energy = time = multiplicity = 0;
        }

        AddBackEvent(double ienergy, double itime, unsigned imultiplicity) {
            energy = ienergy;
            time = itime;
            multiplicity = imultiplicity;
        }

        double energy;
        double time;
        unsigned multiplicity;
};

class GeProcessor : public EventProcessor {
public:
    GeProcessor(double gammaThreshold, double lowRatio,
                double highRatio, double subEventWindow,
                double gammaBetaLimit, double gammaGammaLimit,
                double cycle_gate1_min, double cycle_gate1_max,
                double cycle_gate2_min, double cycle_gate2_max);
     virtual bool PreProcess(RawEvent &event);
     virtual bool Process(RawEvent &event);
    virtual void DeclarePlots(void);
protected:
    static const unsigned int chansPerClover = 4; 
    std::map<int, int> leafToClover;   
    std::vector<float> timeResolution; 
    unsigned int numClovers;           
    EventData BestBetaForGamma(double gTime);

    bool GoodGammaBeta(double gTime);

    std::vector<ChanEvent*> geEvents_;

    void DeclareHistogramGranY(int dammId, int xsize, int ysize,
                   const char *title, int halfWordsPerChan,
                   const std::vector<float> &granularity, const char *units );
    void granploty(int dammId, double x, double y,
                   const std::vector<float> &granularity);
    void symplot(int dammID, double bin1, double bin2);

    std::vector< std::vector<AddBackEvent> > addbackEvents_;
    std::vector<AddBackEvent> tas_;
#ifdef GGATES
    std::vector< std::vector<LineGate> > gGates; 
#endif

    double gammaThreshold_;

    double lowRatio_; 
    double highRatio_; 

    double subEventWindow_;

    double gammaBetaLimit_;

    double gammaGammaLimit_;

    double cycle_gate1_min_; 
    double cycle_gate1_max_;
    double cycle_gate2_min_;
    double cycle_gate2_max_;
};
#endif // __GEPROCESSOR_HPP_