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;
    }
 
    const std::string& get_output_node_name() const { return _output_node_name; }
    void set_output_node_name(const std::string& name) { _output_node_name = name; }
 
    void use_trigger_hit() { _use_trig_hit = true; }
    void require_in_time(const bool val) { _req_intime = val; }
    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;
    std::string _output_node_name;
    bool    _use_trig_hit;
    bool    _req_intime;
    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;
    SQEvent* _event_header_out; //< Node for output
    SQHitVector* _hit_vector;
};
 
class DPTriggerAnalyzer::MatrixNode
{
public:
    MatrixNode(int uID);
 
    void add(MatrixNode* child);
 
public:
    int uniqueID;
    std::list<MatrixNode*> children;
};
 
#endif