DPTriggerAnalyzer.h

Go to the documentation of this file.

#ifndef DPTriggerAnalyzer_H
#define DPTriggerAnalyzer_H
#include <vector>
#include <string>
#include <iostream>
#include <set>
#include <list>
#include <map>
#include <string>
#include <TString.h>
#include <fun4all/SubsysReco.h>
class SQRun;
class SQEvent;
class SQHitVector;

#define NTRPLANES 4

class DPTriggerRoad
{
public:
    DPTriggerRoad();
    DPTriggerRoad(const std::list<int>& path);

    void addTrElement(int uniqueID) { uniqueTrIDs.push_back(uniqueID); }
    void addTrElement(int detectorID, int elementID) { addTrElement(detectorID*1000 + elementID); }

    int getTB();

    void flipTB();


    int getRoadID() const { return roadID; }
    double getSigWeight() const { return sigWeight; }
    double getBkgRate() const { return bkgRate; }
    double getPxMin() const { return pXmin; }
    int getTrID(unsigned int i) const { return i < NTRPLANES ? uniqueTrIDs[i] : 0; }
    int getTrDetectorID(unsigned int i) const { return getTrID(i)/1000; }
    int getTrElementID(unsigned int i) const { return getTrID(i) % 1000; }
    TString getStringID();


    void setRoadID(int id) { roadID = id; }
    void setSigWeight(double weight) { sigWeight = weight; }
    void setBkgRate(double rate) { bkgRate = rate; }
    void setPxMin(double pxmin) { pXmin = pxmin; }


    bool operator == (const DPTriggerRoad& elem) const;
    bool operator <  (const DPTriggerRoad& elem) const;

    friend std::ostream& operator << (std::ostream& os, const DPTriggerRoad& road);

private:

    int roadID;

    double sigWeight;

    double bkgRate;

    double pXmin;

    std::vector<int> uniqueTrIDs;
};

class DPTriggerAnalyzer : public SubsysReco
{
public:
    class MatrixNode;

public:
    typedef enum { NIM_AND, NIM_OR } NimMode;
    DPTriggerAnalyzer(const std::string &name = "DPTriggerAnalyzer");
    virtual ~DPTriggerAnalyzer();

    int Init(PHCompositeNode *topNode);
    int InitRun(PHCompositeNode *topNode);
    int process_event(PHCompositeNode *topNode);
    int End(PHCompositeNode *topNode);

    const std::string& get_road_set_file_name() const {
      return _road_set_file_name;
    }
    
    void set_road_set_file_name(const std::string& roadSetFileName) {
      _road_set_file_name = roadSetFileName;
    }

    void set_nim_mode(const NimMode nim1, const NimMode nim2);
    
    void buildTriggerMatrix();

    //void analyzeTrigger(DPMCRawEvent* rawEvent);

    void searchMatrix(MatrixNode* node, int level, int index);

    void deleteMatrix(MatrixNode* node);

    std::list<DPTriggerRoad>& getRoadsFound(int index) { return roads_found[index]; }

    void printHitPattern();
    void printPath();

private:

    int GetNodes(PHCompositeNode *topNode);

    std::string _road_set_file_name;
    NimMode _mode_nim1;
    NimMode _mode_nim2;

    typedef std::vector<std::set<int> > TrHitPattern;
    TrHitPattern data;


    MatrixNode* matrix[2];
    std::map<TString, DPTriggerRoad> roads[2];

    std::list<DPTriggerRoad> roads_found[2];

    std::list<int> path;

    bool NIMONLY;

    SQRun* _run_header;
    SQEvent* _event_header;
    SQHitVector* _hit_vector;
};

class DPTriggerAnalyzer::MatrixNode
{
public:
    MatrixNode(int uID);

    void add(MatrixNode* child);

public:
    int uniqueID;
    std::list<MatrixNode*> children;
};

#endif