scope.hpp

Go to the documentation of this file.

#ifndef OSCILLOSCOPE_HPP
#define OSCILLOSCOPE_HPP

#include <ctime>
#include <vector>
#include <deque>
#include <cmath>
#include <string>

#include "Unpacker.hpp"

#include "RootScanner.hpp"

class ChannelEvent;
class TGraph;
class TH2F;
class TF1;
class TLine;
class TProfile;

// class scopeUnpacker

class scopeUnpacker : public Unpacker {
  public:
    scopeUnpacker(const unsigned int &mod=0, const unsigned int &chan=0);
    
    ~scopeUnpacker(){  }

    int SetMod(const unsigned int &mod){ return(mod >= 0 ? (mod_ = mod) : (mod_ = 0)); }
    
    int SetChan(const unsigned int &chan){ return(chan >= 0 ? (chan_ = chan) : (chan_ = 0)); }
    
    void SetThreshLow(const int &threshLow){ threshLow_ = threshLow; }
    
    void SetThreshHigh(const int &threshHigh){ threshHigh_ = threshHigh; }

    unsigned int GetMod(){ return mod_; }
    
    unsigned int GetChan(){ return chan_; }
    
    int GetThreshLow(){ return threshLow_; }
    
    int GetThreshHigh(){ return threshHigh_; }

  private:
    unsigned int mod_; 
    unsigned int chan_; 
    int threshLow_;
    int threshHigh_;

    virtual void ProcessRawEvent(ScanInterface *addr_=NULL);
    
    virtual void RawStats(XiaData *event_, ScanInterface *addr_=NULL){  }
};

// class scopeScanner

class scopeScanner : public RootScanner {
  public:
    scopeScanner(int mod = 0, int chan = 0);
    
    ~scopeScanner();
    
    int GetDelay(){ return delay_; }
    
    size_t GetNumEvents(){ return numEvents; }

    void SetDelay(int delay){ delay_ = (delay>1)?delay:1; }

    void SetNumEvents(size_t num_){ numEvents = num_; }

    void StopACQ(){ running = false; }
    
    void StartACQ(){ running = true; }

    virtual bool ExtraCommands(const std::string &cmd_, std::vector<std::string> &args_);
    
    virtual void ExtraArguments();
    
    virtual void CmdHelp(const std::string &prefix_="");
    
    virtual void ArgHelp();
    
    virtual void SyntaxStr(char *name_);

    virtual bool Initialize(std::string prefix_="");
    
    virtual void FinalInitialization(){  }
    
    virtual bool InitRootOutput(std::string fname_, bool overwrite_=true){ return false; }

    virtual void Notify(const std::string &code_="");

    virtual Unpacker *GetCore();

    virtual bool AddEvent(XiaData *event_);
    
    virtual bool ProcessEvents();

    void ClearEvents();

  private:
    unsigned int numAvgWaveforms_;
    unsigned int num_displayed; 
    
    size_t numEvents; 
    
    float cfdF_;
    int cfdD_;
    int cfdL_;
    int fitLow_;
    int fitHigh_;
    int delay_; 
    
    bool need_graph_update; 
    bool resetGraph_;
    bool acqRun_;
    bool singleCapture_;
    bool init;  
    bool running;
    bool performFit_;
    bool performCfd_;
  
    std::vector<int> x_vals;
    std::deque<ChannelEvent*> chanEvents_; 

    time_t last_trace; 
    
    std::string saveFile_; 

    TGraph *graph; 
    TLine *cfdLine;
    TF1 *cfdPol3;
    TF1 *cfdPol2;
    TH2F *hist; 
    TProfile *prof; 

    TF1 *paulauskasFunc; 

    TF1 *SetupFunc();

    void ResetGraph(unsigned int size_);
    
    void Plot();
};

#endif