QIGUICoSessionHandler.hh

#ifndef _QIGUI_CO_SESSION_HANDLER__H_
#define _QIGUI_CO_SESSION_HANDLER__H_

#include <QObject>
#include <QCoincidence.hh>
#include <map>
#include <string>
#include <TMutex.h>

class QIGUISession;
class QCoincidenceFiller;
class QIGUICoCut;
class QIGUIPlotData;
class TThread;
class QProgressBar;
class QTimer;
class QCoProjector;


class QIGUICoSessionHandler: public QObject
{
   Q_OBJECT

  public:
    enum Status 
    {
      CoToDoEventList = 0,
      CoToDoCoCut,
      CoDone
    };
    Status fStatus;

  private:

    QCoincidenceFiller* fFiller;
    QIGUICoCut * fCoCut;

    QIGUISession * fSession;
    QIGUIPlotData * fPlotData;

    QString fName;
    std::string fEnergyVar;
    std::string fTimeVar;

    // Time coincidence type (kind of filler)
    std::string fType;
    double fTimeWindow;

    TThread * fCoThread;
    TMutex  fCoMutex; // protect CoStatus
    int fNEvents; 
    int fNCoincidences;
    QProgressBar * fProgressBar;
    QTimer * fTimer;

    // Projector
    QCoProjector * fCoProjector;

  public:
    // Ctr, Dtr, initialization
    QIGUICoSessionHandler (QString name, QObject * parent=0);
    QIGUICoSessionHandler (QString name, QIGUISession * session, QObject * parent=0);
    virtual ~QIGUICoSessionHandler();
    void Init();

    int BuildCoincidences(QProgressBar * bar);
    int CreateFiller();
    int BuildTimeCoincidences();
    int BuildCoCutCoincidences();
    void CoAnalysisEnd();
    // Apply cut and generate a new list with the coincidences that pass the filter
    std::list<QCoincidence> Filter (const std::list<QCoincidence>& coincList);
    


    // Setters, getters
    QString        GetName() {return fName;}
    QIGUISession * GetSession() { return fSession;}
    QIGUIPlotData *GetPlotData() { return fPlotData;}
    QCoincidenceFiller * GetFiller () {return fFiller;}
    std::string    GetType() {return fType;}
    double         GetTimeWindow () {return fTimeWindow;}
    QTimer *       GetTimer() {return fTimer;}
    std::string    GetEnergyVar() {return fEnergyVar;}
    std::string    GetTimeVar() {return fTimeVar;}
    QIGUICoCut *   GetCoCut () {return fCoCut;}
    int            GetNEvents() {return fNEvents;}
    int            GetNCoincidences() {return fNCoincidences;}
    QProgressBar * GetProgressBar() {return fProgressBar;}

    void SetSession (QIGUISession * session) {fSession = session;fStatus=CoToDoEventList;}
    void SetPlotData(QIGUIPlotData * plotdata) {fPlotData = plotdata;fStatus=CoToDoEventList;}

    // These functions modify Status = CoToDoEventList 
    void SetType (std::string type);
    void SetTimeWindow(double timeWindow);
    void SetEnergyVar(std::string energy);
    void SetTimeVar(std::string time);

    // These functions dont modify Status. Status is modified by signals
    void SetCoCut (QIGUICoCut * coCut) {fCoCut = coCut;}

    void SetNEvents(int nev) {fNEvents=nev;}
    void SetNCoincidences(int nc) {fNCoincidences=nc;}

    // get pointer to projector. If CoSessionHandler Status is different form CoDone, 
    // regenerate coincidence list
    QCoProjector * GetCoProjector();

    // Get and Set Status(protected by Mutex)
    void SetStatus (Status st); 
    Status GetStatus (); 

    // Lock and UnLock Mutex that protects fStatus.
    void LockCoMutex();
    void UnLockCoMutex();

    // Fill two vectors with the event index in coincidence with event ev
    // (first vector: events in temporal coincidence
    // second vector: events in spatial coincidence)
    void GetCoincidentEvents(unsigned int ev, std::vector<QCoincidentEvent> &tempCoin, std::vector<QCoincidentEvent> &spatialCoin);
    
  private:
    // Thread function
    static void *LaunchCoAnalysis(void * coSessionHandler);


  public slots:
    void UpdateProgressBar();
    void DeleteProgressBar();
    void DeleteTimer();

  signals:
    void UpdateProgressBar(int );
    void CoAnalysisEnd(QString, int);

};

#endif

---