AnaSortMixVertex.h

Go to the documentation of this file.

#ifndef _ANA_SortMixVertex__H_
#define _ANA_SortMixVertex__H_
#include <fstream>
#include <ktracker/SRawEvent.h>
#include <ktracker/SRecEvent.h>
#include <ktracker/UtilSRawEvent.h>
#include <interface_main/SQEvent.h>
#include <interface_main/SQHitVector.h>
#include <ktracker/GFField.h>
#include <ktracker/GFTrack.h>
 
class TFile;
class TTree;
class SRecTrack;
class SQEvent;
class SQHitVector;
 
/*struct SRecDimuonData {
  int            trk_id_pos;
  int            trk_id_neg;
  std::string    origin;
  TVector3       pos;
  TLorentzVector mom;
  TLorentzVector mom_pos;
  TLorentzVector mom_neg;
  double         mass;
  double         pT;
  double         x1;
  double         x2;
  double         xF;
  double         costh;
  double         phi;
  
  SRecDimuonData();
  virtual ~SRecDimuonData() {;}
 
  ClassDef(SRecDimuonData, 1);
 
};*/
 
class AnaSortMixVertex
{
        std::string m_name;
        std::string m_dir_out;
        //std::string geom_file_name;
        std::string m_ds; 
        int  m_run_id; 
        bool m_use_raw; 
        bool m_use_rec; 
        unsigned int m_n_evt_max; 
        int m_verb; 
        SRawEvent* m_raw;
        SRecEvent* m_rec;
        SQEvent* sq_evt;
        SQHitVector* sq_htvec;
        std::ofstream m_ofs;
        TFile* m_file_out;
 
        //bool dumpfit;
        //int m_target_id;
 
        public:
        virtual ~AnaSortMixVertex();
        virtual void Init(const int run_id);
        virtual void End();
        virtual void Analyze(const int run_id, const std::vector<std::string> list_in);
        AnaSortMixVertex(const std::string name="ana_mixvertex");
 
 
        virtual void SortTree(TTree* tree_to_sort);
        virtual void MixTracks(TTree* sorted_tree);
        virtual void DoVertex(TTree* inputtree, const int run_id, bool mix);
        bool Target_Like(SRecTrack* trk_pos, SRecTrack* trk_neg);
        bool Dump_Like(SRecTrack* trk_pos, SRecTrack* trk_neg);
        bool UpStream_Like(SRecTrack* trk_pos, SRecTrack* trk_neg);
        //virtual void PrepareMC(char* file_mctree);
        virtual void EmbedMCSignal( char *file_mixed, char* file_mcsignal);
        void SetTargetPos( const int target_pos){m_target_pos = target_pos;}
 
        std::string Name() const { return m_name; }
        void SetOutputDir(const std::string dir_out) { m_dir_out = dir_out; }
        void SetOutputDir(const int dir_out) { m_dir_out = std::to_string(dir_out); }
        std::string GetOutputDir() const { return m_dir_out; }
        void SetDataset(const std::string ds) { m_ds = ds; } 
        std::string GetDataset() const { return m_ds; }      
        void SetRunID(const int run_id) { m_run_id = run_id; } 
        int  GetRunID() const { return m_run_id; }             
        void UseRawEvent(const bool value) { m_use_raw = value; } 
        void UseRecEvent(const bool value) { m_use_rec = value; } 
        void SetNumEventsAnalyzed(const unsigned int n_evt) { m_n_evt_max = n_evt; }
        void Verbosity(const int verb) { m_verb = verb; } 
        int  Verbosity() const  { return m_verb; }        
        std::ofstream& OFS() { return m_ofs; }
        TFile* OFile() { return m_file_out; }
 
 
        protected:
        SRawEvent* GetRawEvent() { return m_raw; } 
        SRecEvent* GetRecEvent() { return m_rec; } 
 
        TTree* ana_tree;
        TTree* sorted_tree;
        TTree* mixed_tree;
        TTree* save_sorted;
        TTree* save_mix;
 
 
        int   runID, m_target_pos;
        int spill_ID, plus_spill_ID, minus_spill_ID;
        int event_ID, plus_event_ID, minus_event_ID;
 
        //int rfp00; ///< RF+00
        float rfp00c; 
        float pot_p00; 
        float liveP; //Live PoT
 
        int DimMult;
        int occuD0, occuD1, occuD2, occuD3p, occuD3m;
        int TrkMult, PosTrkMult, NegTrkMult;
        int TargetPos;
        int fpga1, fpga2, fpga3, fpga4, fpga5;
 
        std::vector<SRecTrack> pos_tracks, neg_tracks;
        std::vector<SRecTrack> pos_tracks_mix, neg_tracks_mix;
        SRecEvent* recEvent;
        SRecEvent* recEvent_target_like;
        SRecEvent* recEvent_dump_like;
        SRecEvent* recEvent_upstream_like;
        SQGenFit::GFField* gfield_v2;
 
        int plus_fpga1, plus_occuD1, plus_occuD2, plus_occuD3p, plus_occuD3m, plus_TargetPos; 
        float plus_rfp00c, plus_pot_p00, plus_liveP;
 
        int minus_fpga1, minus_occuD1, minus_occuD2, minus_occuD3p, minus_occuD3m, minus_TargetPos;
        float minus_rfp00c, minus_pot_p00, minus_liveP;
 
 
};
#endif // _ANA_VERTEXFIT__H_