QTrigger.hh

Go to the documentation of this file.

#ifndef _Q_TRIGGER_HH_
#define _Q_TRIGGER_HH_
 
#include "QDiana.hh"
#include <vector>
#include "QBaseModule.hh"
#include <string>
#include "TString.h"
 
using std::vector;
using Diana::QBaseModule;
using std::string;
 
Q_BEGIN_NAMESPACE
 
class QBaseModule;
 
class QTrigger{
    public:
        virtual ~QTrigger() {};
        
            QTrigger(const QBaseModule* Reader){reader=Reader;SetTriggerLabel("");triggerAlgo="NotAssigned";}
 
        QTrigger(const QBaseModule* Reader,const string triglab){
                    reader=Reader;
                    SetTriggerLabel(triglab);
            triggerAlgo="NotAssigned";
            }
        
        QTrigger() {SetTriggerLabel("");triggerAlgo="NotAssigned";}
 
        virtual void TriggerStream(const vector<double>& stream) = 0; //trigger stream
        
        void TriggerStream(const vector<int>& stream){TriggerStream(vector<double>(stream.begin(),stream.end()));}
        void TriggerStream(const vector<float>& stream){TriggerStream(vector<double>(stream.begin(),stream.end()));}
        
        virtual void Reset()=0;
        
        void SetReader(const QBaseModule* Reader){reader=Reader;}
        
        void SetSamplingFrequency(const double freq){samplingFrequency=freq;}
        
        void SetWindow(const int windowLength){windowsize = windowLength;}
        
        void SetDebounce(const int Debounce){debounce = Debounce;}
 
            void SetTriggerLabel(const string triglab){
                    if(triglab.compare("")!=0){
                        triggerLabel="_"+triglab;
                    }else{
                        triggerLabel="";
                    }
            }
 
            void SetChannel(const int ch){chan=ch;}
 
        virtual void SetCFGParameters(vector<TString> params) = 0;
        virtual string GetParameters(const bool useDesc=false)const = 0;
        
        double GetRMS(){return rms;}
        
        double GetSamplingFrequency(){ return samplingFrequency;}
        
        int GetWindow(){return windowsize;}
        
        int GetDebounce(){return debounce;}
        
            string GetTriggerLabel(){return triggerLabel;}
            
        string GetTriggerAlgo(){return triggerAlgo;}
        
            int GetChannel(){return chan;}
        
        const vector<int>& GetTriggers(){return triggers;}
        const vector<double>& GetTriggerHeights(){return triggerHeights;}
            const vector<double>& GetFilteredStream(){return filteredStream;}
            size_t GetFilteredStreamSize(){return filteredStream.size();}
            std::vector<double>::iterator GetFilteredStreamBegin(){return filteredStream.begin();}
            std::vector<double>::iterator GetFilteredStreamEnd(){return filteredStream.end();}
        
        void Clear(){
            triggers.clear();
            triggerHeights.clear();
            filteredStream.clear();
        }
    protected:
    
        vector<int> triggers;
        vector<double> triggerHeights;
            vector<double> filteredStream;
        
        double samplingFrequency;
        
        int windowsize;
        
        int debounce;
        
        double rms;
        
        const QBaseModule* reader;
 
            string triggerLabel;
 
        string triggerAlgo;
 
            int chan;
        
        ClassDef(QTrigger,2);
};
 
 
Q_END_NAMESPACE
 
#endif