Trace.hpp

Go to the documentation of this file.

#ifndef __TRACE_HPP__
#define __TRACE_HPP__

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

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

#ifndef NAN
#include <limits>
#define NAN (numeric_limits<float>::quiet_NaN())
#endif

class TrapezoidalFilterParameters; 

namespace {
    typedef class TrapezoidalFilterParameters TFP;
}

class Trace : public std::vector<int> {
public:
    Trace() : std::vector<int>() {
        baselineLow = baselineHigh = pixie::U_DELIMITER;
    }

    Trace(const std::vector<int> &x) : std::vector<int>(x) {
        baselineLow = baselineHigh = pixie::U_DELIMITER;
    }

    void TrapezoidalFilter(Trace &filter, const TFP &parms,
                           unsigned int lo = 0) const {
        TrapezoidalFilter(filter, parms, lo, size());
    }


    void TrapezoidalFilter(Trace &filter, const TFP &parms,
                           unsigned int lo, unsigned int hi) const;

    void InsertValue(std::string name, double value) {
        doubleTraceData.insert(make_pair(name,value));
    }

    void InsertValue(std::string name, int value) {
        intTraceData.insert(make_pair(name,value));
    }

    void SetValue(std::string name, double value) {
        if(doubleTraceData.count(name) > 0)
            doubleTraceData[name] = value;
        else
            InsertValue(name,value);
    }

    void SetValue(std::string name, int value) {
        if(intTraceData.count(name) > 0)
            intTraceData[name] = value;
        else
            InsertValue(name,value);
    }

    bool HasValue(std::string name) const {
        return (doubleTraceData.count(name) > 0 ||
                intTraceData.count(name) > 0);
    }

    double GetValue(std::string name) const {
        if(doubleTraceData.count(name) > 0)
            return (*doubleTraceData.find(name)).second;
        if(intTraceData.count(name) > 0)
            return (*intTraceData.find(name)).second;
        return NAN;
    }

    std::vector<double> GetWaveform() {
        return waveform;
    };

    double DoBaseline(unsigned int lo = 0, unsigned int numBins = numBinsBaseline);

    double DoDiscrimination(unsigned int lo, unsigned int numBins);

    double DoQDC(unsigned int lo, unsigned int numBins);

    unsigned int FindMaxInfo(unsigned int lo = 5, unsigned int hi = 10, unsigned int numBins = 15);

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

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

    void Plot(int id);
    void Plot(int id, int row);
    void ScalePlot(int id, double scale);
    void ScalePlot(int id, int row, double scale);
    void OffsetPlot(int id, double offset);
    void OffsetPlot(int id, int row, double offset);

private:
    static const unsigned int numBinsBaseline = 15; 
    unsigned int baselineLow; 
    unsigned int baselineHigh;

    std::vector<double> waveform; 

    std::map<std::string, double> doubleTraceData; 
    std::map<std::string, int>    intTraceData;

    static Plots histo;
};

class TrapezoidalFilterParameters {
public:
    TrapezoidalFilterParameters(){};

    TrapezoidalFilterParameters(int gap, int rise, double t = NAN) :
        gapSamples(gap), riseSamples(rise), tau(t) {};

    TrapezoidalFilterParameters(const TFP &x) :
        gapSamples(x.gapSamples), riseSamples(x.riseSamples),
        tau(x.tau) {};

    const TFP& operator=(const TFP &right) {
        gapSamples = right.gapSamples;
        riseSamples = right.riseSamples;
        tau = right.tau;

        return (*this);
    }

    Trace::size_type GetGapSamples(void) const {return gapSamples;};

    Trace::size_type GetRiseSamples(void) const {return riseSamples;};

    Trace::size_type GetSize(void) const {return 2*riseSamples + gapSamples;};

    double GetTau(void) const {return tau;};
private:
    Trace::size_type gapSamples; 
    Trace::size_type riseSamples; 

    double tau; 
};

extern const Trace emptyTrace; 
#endif // __TRACE_H_