Hall-D Software  alpha
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
JEventProcessor_PSPair_online.cc
Go to the documentation of this file.
1 // $Id$
2 //
3 // File: JEventProcessor_PSPair_online.cc
4 // Created: Fri Mar 20 16:32:04 EDT 2015
5 // Creator: nsparks (on Linux cua2.jlab.org 2.6.32-431.5.1.el6.x86_64 x86_64)
6 //
7 #include <iostream>
8 #include <sstream>
9 #include "JEventProcessor_PSPair_online.h"
10 
11 using namespace std;
12 using namespace jana;
13 
14 #include <PAIR_SPECTROMETER/DPSCPair.h>
15 #include <PAIR_SPECTROMETER/DPSPair.h>
16 #include <PAIR_SPECTROMETER/DPSGeometry.h>
17 #include <TAGGER/DTAGHHit.h>
18 #include <TAGGER/DTAGHGeometry.h>
19 #include <TAGGER/DTAGMHit.h>
20 #include <TAGGER/DTAGMGeometry.h>
21 #include <TPOL/DTPOLHit.h>
22 #include <TPOL/DTPOLHit_factory.h>
23 
24 #include <JANA/JApplication.h>
25 #include <JANA/JFactory.h>
26 #include <TDirectory.h>
27 #include <TH1.h>
28 #include <TH2.h>
29 
30 
31 const int Narms = DPSGeometry::NUM_ARMS; // 2
32 const int NC_PSC = DPSGeometry::NUM_COARSE_COLUMNS; // 8: number of PSC modules (counters) per arm
33 const int NC_PS = DPSGeometry::NUM_FINE_COLUMNS; // 145: number of PS columns (tiles) per arm
34 const int NC_TAGH = DTAGHGeometry::kCounterCount; // 274: number of TAGH counters
35 const int NC_TAGM = DTAGMGeometry::kColumnCount; // 102: number of TAGM columns
36 const int NS_TPOL = DTPOLHit_factory::NSECTORS; // 32: number of TPOL sectors
37 // root hist pointers
38 static TH1I *hPSC_NHitPairs;
39 static TH1I *hPS_NHitPairs;
40 // PSC pairs
41 static TH2F *hPSC_PSCIDLeftVsIDRight;
42 static TH2I *hPSC_tdiffVsPSCIDLeft[NC_PSC];
43 static TH2I *hPSC_tdiffVsPSCIDRight[NC_PSC];
44 // PSC,PS pairs
45 static TH1I *pspair_num_events;
46 static TH2F *hPS_PSCIDLeftVsIDRight;
47 static TH2F *hPS_PSIDLeftVsIDRight;
48 static TH2F *hPS_ElVsEr;
49 static TH1F *hPS_E;
50 static TH1F *hPS_Ediff;
51 static TH2F *hPS_tdiffVsE;
52 static TH2F *hPS_PStdiffVsE;
53 static TH2F *hPS_PSCPStdiffVsE;
54 static TH2I *hPS_PSIDLeftVsPSCIDLeft;
55 static TH2I *hPS_PSIDRightVsPSCIDRight;
56 static TH2I *hPS_ElVsPSCIDLeft;
57 static TH2I *hPS_ErVsPSCIDRight;
58 // TAGX occupancies, all hits for events with PSC,PS pairs
59 static TH1F *hPS_TAGHCounterID;
60 static TH1F *hPS_Etagh;
61 static TH2F *hPS_timeVsEtagh;
62 static TH1F *hPS_TAGMColumn;
63 static TH1F *hPS_Etagm;
64 static TH2F *hPS_timeVsEtagm;
65 // PSC,PS,TAGH coincidences
66 static TH2F *hPSTAGH_tdiffVsEdiff;
67 static TH2I *hPSTAGH_EVsEtagh;
68 static TH2F *hPSTAGH_PSCIDLeftVsIDRight;
69 static TH2F *hPSTAGH_PSIDLeftVsIDRight;
70 static TH2F *hPSTAGH_ElVsEr;
71 static TH1F *hPSTAGH_E;
72 static TH2F *hPSTAGH_timeVsE;
73 static TH1F *hPSTAGH_TAGHCounterID;
74 static TH1F *hPSTAGH_Etagh;
75 static TH2F *hPSTAGH_timeVsEtagh;
76 static TH2I *hPSTAGH_EdiffVsTAGHCounterID;
77 static TH2I *hPSTAGH_EdiffVsEtagh;
78 static TH2I *hPSTAGH_tdiffVsTAGHCounterID_L[NC_PSC];
79 static TH2I *hPSTAGH_tdiffVsTAGHCounterID_R[NC_PSC];
80 // PSC,PS,TAGM coincidences
81 static TH2F *hPSTAGM_tdiffVsEdiff;
82 static TH2I *hPSTAGM_EVsEtagm;
83 static TH2F *hPSTAGM_PSCIDLeftVsIDRight;
84 static TH2F *hPSTAGM_PSIDLeftVsIDRight;
85 static TH2F *hPSTAGM_ElVsEr;
86 static TH1F *hPSTAGM_E;
87 static TH2F *hPSTAGM_timeVsE;
88 static TH1F *hPSTAGM_TAGMColumn;
89 static TH1F *hPSTAGM_Etagm;
90 static TH2F *hPSTAGM_timeVsEtagm;
91 static TH2I *hPSTAGM_EdiffVsTAGMColumn;
92 static TH2I *hPSTAGM_EdiffVsEtagm;
93 static TH2I *hPSTAGM_tdiffVsTAGMColumn_L[NC_PSC];
94 static TH2I *hPSTAGM_tdiffVsTAGMColumn_R[NC_PSC];
95 // PSC,PS,TPOL coincidences
96 static TH1I *hPSTPOL_NHits;
97 static TH1I *hPSTPOL_sector;
98 static TH1F *hPSTPOL_phi;
99 static TH1I *hPSTPOL_peak;
100 static TH2I *hPSTPOL_peakVsSector;
101 static TH1I *hPSTPOL_time;
102 static TH2I *hPSTPOL_timeVsSector;
103 static TH2F *hPSTPOL_timeVsPhi;
104 static TH2I *hPSTPOL_timeVsPeak;
105 //-------------------------
106 // Routine used to create our JEventProcessor
107 extern "C"{
108  void InitPlugin(JApplication *app){
109  InitJANAPlugin(app);
110  app->AddProcessor(new JEventProcessor_PSPair_online());
111 
112  }
113 } // "C"
114 
115 
116 //------------------
117 // JEventProcessor_PSPair_online (Constructor)
118 //------------------
119 JEventProcessor_PSPair_online::JEventProcessor_PSPair_online()
120 {
121 
122 }
123 
124 //------------------
125 // ~JEventProcessor_PSPair_online (Destructor)
126 //------------------
127 JEventProcessor_PSPair_online::~JEventProcessor_PSPair_online()
128 {
129 
130 }
131 
132 //------------------
133 // init
134 //------------------
135 jerror_t JEventProcessor_PSPair_online::init(void)
136 {
137  // energy binning
138  const double Ebw_PS = 0.1;
139  const double Ebl_PS = 5.0; const double Ebl_PSarm = 2.0;
140  const double Ebh_PS = 13.0; const double Ebh_PSarm = 7.0;
141  const int NEb_PS = int((Ebh_PS-Ebl_PS)/Ebw_PS); const int NEb_PSarm = int((Ebh_PSarm-Ebl_PSarm)/Ebw_PS);
142  const double Ebw_TAG = 0.1;
143  const double Ebl_TAG = 2.5;
144  const double Ebh_TAG = 10.5;
145  const int NEb_TAG = int((Ebh_TAG-Ebl_TAG)/Ebw_TAG);
146  // time binning
147  const double Tbw = 0.06;
148  const double Tbl_PS = -4.5;
149  const double Tbh_PS = 4.5;
150  const int NTb_PS = int((Tbh_PS-Tbl_PS)/Tbw);
151  const double Tbl_TAG = -200.0;
152  const double Tbh_TAG = 200.0;
153  const int NTb_TAG = 1000;
154  // energy difference binning
155  const int NEdb = 200; const double Edbl = -1.0; const double Edbh = 1.0;
156 
157  // create root folder for pspair and cd to it, store main dir
158  TDirectory *mainDir = gDirectory;
159  TDirectory *psPairDir = gDirectory->mkdir("PSPair");
160  psPairDir->cd();
161  // book hists
162  pspair_num_events = new TH1I("pspair_num_events","PS pair number of events",1,0.5,1.5);
163  hPSC_NHitPairs = new TH1I("PSC_NHitPairs","PSC pair multiplicity",8,0.5,8.5);
164  hPS_NHitPairs = new TH1I("PS_NHitPairs","PS pair multiplicity",8,0.5,8.5);
165  //
166  gDirectory->mkdir("PSC")->cd();
167  hPSC_PSCIDLeftVsIDRight = new TH2F("PSC_PSCIDLeftVsIDRight","PSC pair: Coarse PS ID left arm vs. ID right arm;module(right arm);module(left arm)",NC_PSC,0.5,0.5+NC_PSC,NC_PSC,0.5,0.5+NC_PSC);
168  gDirectory->mkdir("PSCRightArmTimeOffsets")->cd();
169  for (int i=0;i<NC_PSC;i++) {
170  stringstream ss; ss << i+1;
171  TString id = ss.str();
172  TString strN = "_L" + id;
173  hPSC_tdiffVsPSCIDRight[i] = new TH2I("PSC_tdiffVsPSCIDRight"+strN,"PSC pair: TDC time difference vs. right arm module, fixed left arm module "+id+";module(right arm);time(module "+id+", left arm) - time(right arm) [ns]",NC_PSC,0.5,0.5+NC_PSC,NTb_PS,Tbl_PS,Tbh_PS);
174  }
175  gDirectory->cd("../");
176  gDirectory->mkdir("PSCLeftArmTimeOffsets")->cd();
177  for (int i=0;i<NC_PSC;i++) {
178  stringstream ss; ss << i+1;
179  TString id = ss.str();
180  TString strN = "_R" + id;
181  hPSC_tdiffVsPSCIDLeft[i] = new TH2I("PSC_tdiffVsPSCIDLeft"+strN,"PSC pair: TDC time difference vs. left arm module, fixed right arm module "+id+";module(left arm);time(left arm) - time(module "+id+", right arm) [ns]",NC_PSC,0.5,0.5+NC_PSC,NTb_PS,Tbl_PS,Tbh_PS);
182  }
183  psPairDir->cd();
184  //
185  gDirectory->mkdir("PSC_PS")->cd();
186  hPS_PSCIDLeftVsIDRight = new TH2F("PS_PSCIDLeftVsIDRight","PS pair: Coarse PS ID left arm vs. ID right arm;module(right arm);module(left arm)",NC_PSC,0.5,0.5+NC_PSC,NC_PSC,0.5,0.5+NC_PSC);
187  hPS_PSIDLeftVsIDRight = new TH2F("PS_PSIDLeftVsIDRight","PS pair: Fine PS ID left arm vs. ID right arm;column(right arm);column(left arm)",NC_PS,0.5,0.5+NC_PS,NC_PS,0.5,0.5+NC_PS);
188  hPS_ElVsEr = new TH2F("PS_ElVsEr","PS pair: left-arm energy vs. right-arm energy;energy(right arm) [GeV];energy(left arm) [GeV]",NEb_PSarm,Ebl_PSarm,Ebh_PSarm,NEb_PSarm,Ebl_PSarm,Ebh_PSarm);
189  hPS_E = new TH1F("PS_E","PS pair energy;PS pair energy [GeV];events",NEb_PS,Ebl_PS,Ebh_PS);
190  hPS_Ediff = new TH1F("PS_Ediff","PS pair energy difference;PS pair energy difference [GeV];events",80,-4.0,4.0);
191  hPS_tdiffVsE = new TH2F("PS_tdiffVsE","PSC pair time difference vs. PS pair energy;PS pair energy [GeV];PSC pair time difference [ns]",NEb_PS,Ebl_PS,Ebh_PS,200,-10.0,10.0);
192  hPS_PStdiffVsE = new TH2F("PS_PStdiffVsE","PS pair time difference vs. PS pair energy;PS pair energy [GeV];PS pair time difference [ns]",NEb_PS,Ebl_PS,Ebh_PS,200,-10.0,10.0);
193  hPS_PSCPStdiffVsE = new TH2F("PS_PSCPStdiffVsE","PSC/PS pair time difference of differences vs. PS pair energy;PS pair energy [GeV];PSC/PS pair time difference of differences [ns]",NEb_PS,Ebl_PS,Ebh_PS,200,-10.0,10.0);
194  //
195  hPS_PSIDLeftVsPSCIDLeft = new TH2I("PS_PSIDLeftVsPSCIDLeft","PS pair: Fine PS ID left arm vs. Coarse PS ID left arm;coarse PS module(left arm);fine PS column(left arm)",NC_PSC,0.5,0.5+NC_PSC,NC_PS,0.5,0.5+NC_PS);
196  hPS_PSIDRightVsPSCIDRight = new TH2I("PS_PSIDRightVsPSCIDRight","PS pair: Fine PS ID right arm vs. Coarse PS ID right arm;coarse PS module(right arm);fine PS column(right arm)",NC_PSC,0.5,0.5+NC_PSC,NC_PS,0.5,0.5+NC_PS);
197  hPS_ElVsPSCIDLeft = new TH2I("PS_ElVsPSCIDLeft","PS pair: PS left-arm energy vs. Coarse PS ID left arm;coarse PS module(left arm);PS energy(left arm)",NC_PSC,0.5,0.5+NC_PSC,NEb_PSarm,Ebl_PSarm,Ebh_PSarm);
198  hPS_ErVsPSCIDRight = new TH2I("PS_ErVsPSCIDRight","PS pair: PS right-arm energy vs. Coarse PS ID right arm;coarse PS module(right arm);PS energy(right arm)",NC_PSC,0.5,0.5+NC_PSC,NEb_PSarm,Ebl_PSarm,Ebh_PSarm);
199  //
200  gDirectory->mkdir("TAGX_AllHits")->cd();
201  hPS_TAGHCounterID = new TH1F("PS_TAGHCounterID","PS pair: TAGH counter ID, all hits;TAGH counter ID;hits",NC_TAGH,0.5,0.5+NC_TAGH);
202  hPS_Etagh = new TH1F("PS_Etagh","PS pair: TAGH photon energy, all hits;TAGH photon energy [GeV];hits",NEb_TAG,Ebl_TAG,Ebh_TAG);
203  hPS_timeVsEtagh = new TH2F("PS_timeVsEtagh","PS pair: TAGH time vs. photon energy, all hits;TAGH photon energy [GeV];time [ns]",NEb_TAG,Ebl_TAG,Ebh_TAG,NTb_TAG,Tbl_TAG,Tbh_TAG);
204  hPS_TAGMColumn = new TH1F("PS_TAGMColumn","PS pair: TAGM column, all hits;TAGM column;hits",NC_TAGM,0.5,0.5+NC_TAGM);
205  hPS_Etagm = new TH1F("PS_Etagm","PS pair: TAGM photon energy, all hits;TAGM photon energy [GeV];hits",NEb_PS,Ebl_PS,Ebh_PS);
206  hPS_timeVsEtagm = new TH2F("PS_timeVsEtagm","PS pair: TAGM time vs. photon energy, all hits;TAGM photon energy [GeV];time [ns]",NEb_PS,Ebl_PS,Ebh_PS,NTb_TAG,Tbl_TAG,Tbh_TAG);
207  psPairDir->cd();
208  //
209  gDirectory->mkdir("PSC_PS_TAGH")->cd();
210  hPSTAGH_tdiffVsEdiff = new TH2F("PSTAGH_tdiffVsEdiff","PS pair - TAGH: PS-TAGH time difference vs. PS-TAGH energy difference;E(PS) - E(TAGH) [GeV];PSC/TAGH time difference [ns]",NEdb,Edbl,Edbh,NTb_TAG,Tbl_TAG,Tbh_TAG);
211  hPSTAGH_TAGHCounterID = new TH1F("PSTAGH_TAGHCounterID","PS pair - TAGH: TAGH counter ID;TAGH counter ID;events",NC_TAGH,0.5,0.5+NC_TAGH);
212  hPSTAGH_Etagh = new TH1F("PSTAGH_Etagh","PS pair - TAGH: TAGH photon energy;TAGH photon energy [GeV];events",NEb_TAG,Ebl_TAG,Ebh_TAG);
213  hPSTAGH_timeVsEtagh = new TH2F("PSTAGH_timeVsEtagh","PS pair - TAGH: TAGH time vs. photon energy;TAGH photon energy [GeV];time [ns]",NEb_TAG,Ebl_TAG,Ebh_TAG,NTb_TAG,Tbl_TAG,Tbh_TAG);
214  hPSTAGH_EVsEtagh = new TH2I("PSTAGH_EVsEtagh","PS pair - TAGH: PS energy vs. TAGH energy;TAGH energy [GeV];PS energy [GeV]",NEb_PS,Ebl_PS,Ebh_PS,NEb_PS,Ebl_PS,Ebh_PS);
215  hPSTAGH_EdiffVsEtagh = new TH2I("PSTAGH_EdiffVsEtagh","PS pair - TAGH: PS-TAGH energy difference vs. TAGH energy;TAGH energy [GeV];E(PS) - E(TAGH) [GeV]",NEb_TAG,Ebl_TAG,Ebh_TAG,NEdb,Edbl,Edbh);
216  hPSTAGH_EdiffVsTAGHCounterID = new TH2I("PSTAGH_EdiffVsTAGHCounterID","PS pair - TAGH: PS-TAGH energy difference vs. TAGH counter ID;TAGH counter ID;E(PS) - E(TAGH) [GeV]",NC_TAGH,0.5,0.5+NC_TAGH,NEdb,Edbl,Edbh);
217  hPSTAGH_PSCIDLeftVsIDRight = new TH2F("PSTAGH_PSCIDLeftVsIDRight","PS pair - TAGH: Coarse PS ID left arm vs. ID right arm;module(right arm);module(left arm)",NC_PSC,0.5,0.5+NC_PSC,NC_PSC,0.5,0.5+NC_PSC);
218  hPSTAGH_PSIDLeftVsIDRight = new TH2F("PSTAGH_PSIDLeftVsIDRight","PS pair - TAGH: Fine PS ID left arm vs. ID right arm;column(right arm);column(left arm)",NC_PS,0.5,0.5+NC_PS,NC_PS,0.5,0.5+NC_PS);
219  hPSTAGH_ElVsEr = new TH2F("PSTAGH_ElVsEr","PS pair - TAGH: left-arm energy vs. right-arm energy;energy(right arm) [GeV];energy(left arm) [GeV]",NEb_PSarm,Ebl_PSarm,Ebh_PSarm,NEb_PSarm,Ebl_PSarm,Ebh_PSarm);
220  hPSTAGH_E = new TH1F("PSTAGH_E","PS pair - TAGH: PS pair energy;PS pair energy [GeV];events",NEb_PS,Ebl_PS,Ebh_PS);
221  hPSTAGH_timeVsE = new TH2F("PSTAGH_timeVsE","PSC/TAGH time difference vs. PS pair energy;PS pair energy [GeV];PSC/TAGH time difference [ns]",NEb_PS,Ebl_PS,Ebh_PS,NTb_TAG,Tbl_TAG,Tbh_TAG);
222  gDirectory->mkdir("PSTAGHTimeOffsets_L")->cd();
223  for (int i=0; i<NC_PSC; i++) {
224  stringstream ss; ss << i+1;
225  TString id = ss.str();
226  hPSTAGH_tdiffVsTAGHCounterID_L[i] = new TH2I("PSTAGH_tdiffVsTAGHCounterID_L"+id,"PS-TAGH TDC time difference vs. TAGH counter ID, fixed left arm PSC module "+id+";TAGH counter ID;time(PSC module "+id+", left arm) - time(TAGH) [ns]",NC_TAGH,0.5,0.5+NC_TAGH,NTb_TAG,Tbl_TAG,Tbh_TAG);
227  }
228  gDirectory->cd("../");
229  gDirectory->mkdir("PSTAGHTimeOffsets_R")->cd();
230  for (int i=0; i<NC_PSC; i++) {
231  stringstream ss; ss << i+1;
232  TString id = ss.str();
233  hPSTAGH_tdiffVsTAGHCounterID_R[i] = new TH2I("PSTAGH_tdiffVsTAGHCounterID_R"+id,"PS-TAGH TDC time difference vs. TAGH counter ID, fixed right arm PSC module "+id+";TAGH counter ID;time(PSC module "+id+", right arm) - time(TAGH) [ns]",NC_TAGH,0.5,0.5+NC_TAGH,NTb_TAG,Tbl_TAG,Tbh_TAG);
234  }
235  psPairDir->cd();
236  //
237  gDirectory->mkdir("PSC_PS_TAGM")->cd();
238  hPSTAGM_tdiffVsEdiff = new TH2F("PSTAGM_tdiffVsEdiff","PS pair - TAGM: PS-TAGM time difference vs. PS-TAGM energy difference;E(PS) - E(TAGM) [GeV];PSC/TAGM time difference [ns]",NEdb,Edbl,Edbh,NTb_TAG,Tbl_TAG,Tbh_TAG);
239  hPSTAGM_TAGMColumn = new TH1F("PSTAGM_TAGMColumn","PS pair - TAGM: TAGM column;TAGM column;events",NC_TAGM,0.5,0.5+NC_TAGM);
240  hPSTAGM_Etagm = new TH1F("PSTAGM_Etagm","PS pair - TAGM: TAGM photon energy;TAGM photon energy [GeV];events",NEb_PS,Ebl_PS,Ebh_PS);
241  hPSTAGM_timeVsEtagm = new TH2F("PSTAGM_timeVsEtagm","PS pair - TAGM: TAGM time vs. photon energy;TAGM photon energy [GeV];time [ns]",NEb_PS,Ebl_PS,Ebh_PS,NTb_TAG,Tbl_TAG,Tbh_TAG);
242  hPSTAGM_EVsEtagm = new TH2I("PSTAGM_EVsEtagm","PS pair - TAGM: PS energy vs. TAGM energy;TAGM energy [GeV];PS energy [GeV]",NEb_PS,Ebl_PS,Ebh_PS,NEb_PS,Ebl_PS,Ebh_PS);
243  hPSTAGM_EdiffVsEtagm = new TH2I("PSTAGM_EdiffVsEtagm","PS pair - TAGM: PS-TAGM energy difference vs. TAGM energy;TAGM energy [GeV];E(PS) - E(TAGM) [GeV]",NEb_PS,Ebl_PS,Ebh_PS,NEdb,Edbl,Edbh);
244  hPSTAGM_EdiffVsTAGMColumn = new TH2I("PSTAGM_EdiffVsTAGMColumn","PS pair - TAGM: PS-TAGM energy difference vs. TAGM column;TAGM column;E(PS) - E(TAGM) [GeV]",NC_TAGM,0.5,0.5+NC_TAGM,NEdb,Edbl,Edbh);
245  hPSTAGM_PSCIDLeftVsIDRight = new TH2F("PSTAGM_PSCIDLeftVsIDRight","PS pair - TAGM: Coarse PS ID left arm vs. ID right arm;module(right arm);module(left arm)",NC_PSC,0.5,0.5+NC_PSC,NC_PSC,0.5,0.5+NC_PSC);
246  hPSTAGM_PSIDLeftVsIDRight = new TH2F("PSTAGM_PSIDLeftVsIDRight","PS pair - TAGM: Fine PS ID left arm vs. ID right arm;column(right arm);column(left arm)",NC_PS,0.5,0.5+NC_PS,NC_PS,0.5,0.5+NC_PS);
247  hPSTAGM_ElVsEr = new TH2F("PSTAGM_ElVsEr","PS pair - TAGM: left-arm energy vs. right-arm energy;energy(right arm) [GeV];energy(left arm) [GeV]",NEb_PSarm,Ebl_PSarm,Ebh_PSarm,NEb_PSarm,Ebl_PSarm,Ebh_PSarm);
248  hPSTAGM_E = new TH1F("PSTAGM_E","PS pair - TAGM: PS pair energy;PS pair energy [GeV];events",NEb_PS,Ebl_PS,Ebh_PS);
249  hPSTAGM_timeVsE = new TH2F("PSTAGM_timeVsE","PSC/TAGM time difference vs. PS pair energy;PS pair energy [GeV];PSC/TAGM time difference [ns]",NEb_PS,Ebl_PS,Ebh_PS,NTb_TAG,Tbl_TAG,Tbh_TAG);
250  gDirectory->mkdir("PSTAGMTimeOffsets_L")->cd();
251  for (int i=0; i<NC_PSC; i++) {
252  stringstream ss; ss << i+1;
253  TString id = ss.str();
254  hPSTAGM_tdiffVsTAGMColumn_L[i] = new TH2I("PSTAGM_tdiffVsTAGMColumn_L"+id,"PS-TAGM TDC time difference vs. TAGM column, fixed left arm PSC module "+id+";TAGM column;time(PSC module "+id+", left arm) - time(TAGM) [ns]",NC_TAGM,0.5,0.5+NC_TAGM,NTb_TAG,Tbl_TAG,Tbh_TAG);
255  }
256  gDirectory->cd("../");
257  gDirectory->mkdir("PSTAGMTimeOffsets_R")->cd();
258  for (int i=0; i<NC_PSC; i++) {
259  stringstream ss; ss << i+1;
260  TString id = ss.str();
261  hPSTAGM_tdiffVsTAGMColumn_R[i] = new TH2I("PSTAGM_tdiffVsTAGMColumn_R"+id,"PS-TAGM TDC time difference vs. TAGM column, fixed right arm PSC module "+id+";TAGM column;time(PSC module "+id+", right arm) - time(TAGM) [ns]",NC_TAGM,0.5,0.5+NC_TAGM,NTb_TAG,Tbl_TAG,Tbh_TAG);
262  }
263  psPairDir->cd();
264  //
265  gDirectory->mkdir("PSC_PS_TPOL")->cd();
266  hPSTPOL_NHits = new TH1I("PSTPOL_NHits","TPOL hit multiplicity;hits;events",5,0.5,5.5);
267  hPSTPOL_sector = new TH1I("PSTPOL_sector","TPOL sector;sector;hits / sector",NS_TPOL,0.5,0.5+NS_TPOL);
268  hPSTPOL_phi = new TH1F("PSTPOL_phi","TPOL azimuthal angle;triplet azimuthal angle [degrees];hits / sector",NS_TPOL,0.0,360.0);
269  hPSTPOL_peak = new TH1I("PSTPOL_peak","TPOL fADC pulse peak;pulse peak;hits",410,0.0,4100.0);
270  hPSTPOL_peakVsSector = new TH2I("PSTPOL_peakVsSector","TPOL fADC pulse peak vs. sector;sector;pulse peak",NS_TPOL,0.5,0.5+NS_TPOL,410,0.0,4100.0);
271  hPSTPOL_time = new TH1I("PSTPOL_time","TPOL time;time [ns];hits / 2 ns",400,-400.0,400.0);
272  hPSTPOL_timeVsSector = new TH2I("PSTPOL_timeVsSector","TPOL time vs. sector;sector;time [ns]",NS_TPOL,0.5,0.5+NS_TPOL,400,-400.0,400.0);
273  hPSTPOL_timeVsPhi = new TH2F("PSTPOL_timeVsPhi","TPOL time vs. phi;#phi [degrees];time [ns]",NS_TPOL,0.0,360.0,400,-400.0,400.0);
274  hPSTPOL_timeVsPeak = new TH2I("PSTPOL_timeVsPeak","TPOL time vs. peak;pulse peak;time [ns]",410,0.0,4100.0,400,-400.0,400.0);
275  // back to main dir
276  mainDir->cd();
277 
278  return NOERROR;
279 }
280 
281 //------------------
282 // brun
283 //------------------
284 jerror_t JEventProcessor_PSPair_online::brun(JEventLoop *eventLoop, int32_t runnumber)
285 {
286  // This is called whenever the run number changes
287  // extract the PS geometry
288  vector<const DPSGeometry*> psGeomVect;
289  eventLoop->Get(psGeomVect);
290  if (psGeomVect.size() == 0) return OBJECT_NOT_AVAILABLE;
291  const DPSGeometry& psGeom = *(psGeomVect[0]);
292  // get photon energy bin lows for variable-width energy binning
293  double Elows_PSarm[Narms][NC_PS+1];
294  double wl_min=0.05,wr_min = 0.05;
295  for (int i=0;i<NC_PS;i++) {
296  Elows_PSarm[0][i] = psGeom.getElow(0,i+1);
297  Elows_PSarm[1][i] = psGeom.getElow(1,i+1);
298  // find smallest bin widths to use for PS pair energy binning
299  double wl = fabs(psGeom.getEhigh(0,i+1) - psGeom.getElow(0,i+1));
300  double wr = fabs(psGeom.getEhigh(1,i+1) - psGeom.getElow(1,i+1));
301  if (wl<wl_min) wl_min = wl;
302  if (wr<wr_min) wr_min = wr;
303  }
304  // add the upper limits
305  Elows_PSarm[0][NC_PS] = psGeom.getEhigh(0,NC_PS);
306  Elows_PSarm[1][NC_PS] = psGeom.getEhigh(1,NC_PS);
307  // PS pair energy binning
308  double Ebw_PS = wl_min + wr_min;
309  const double Ebl_PS = psGeom.getElow(0,1) + psGeom.getElow(1,1);
310  const double Ebh_PS = psGeom.getEhigh(0,NC_PS) + psGeom.getEhigh(1,NC_PS);
311  double range = fabs(Ebh_PS-Ebl_PS);
312  int NEb_PS = range/Ebw_PS-int(range/Ebw_PS) < 0.5 ? int(range/Ebw_PS) : int(range/Ebw_PS) + 1;
313  double Elows_PS[NEb_PS+1];
314  for (int i=0;i<NEb_PS+1;i++) {
315  Elows_PS[i] = Ebl_PS + i*Ebw_PS;
316  }
317  // extract the TAGH geometry
318  vector<const DTAGHGeometry*> taghGeomVect;
319  eventLoop->Get(taghGeomVect);
320  if (taghGeomVect.size() == 0) return OBJECT_NOT_AVAILABLE;
321  const DTAGHGeometry& taghGeom = *(taghGeomVect[0]);
322  // get photon energy bin low of each counter for energy histogram binning
323  double Elows_TAGH[NC_TAGH+1];
324  for (int i=0;i<NC_TAGH;i++) {
325  Elows_TAGH[i] = taghGeom.getElow(NC_TAGH-i);
326  }
327  // add the upper limit
328  Elows_TAGH[NC_TAGH] = taghGeom.getEhigh(1);
329  // extract the TAGM geometry
330  vector<const DTAGMGeometry*> tagmGeomVect;
331  eventLoop->Get(tagmGeomVect);
332  if (tagmGeomVect.size() < 1)
333  return OBJECT_NOT_AVAILABLE;
334  const DTAGMGeometry& tagmGeom = *(tagmGeomVect[0]);
335  // get photon energy bin low of each counter for energy histogram binning
336  double Elows_TAGM[NC_TAGM+1];
337  for (int i=0;i<NC_TAGM;i++) {
338  Elows_TAGM[i] = tagmGeom.getElow(NC_TAGM-i);
339  }
340  // add the upper limit
341  Elows_TAGM[NC_TAGM] = tagmGeom.getEhigh(1);
342  //
343  const int NEdiff = 200;
344  double EdiffLows[NEdiff+1];
345  for (int i=0;i<NEdiff+1;i++) {
346  EdiffLows[i] = -1.0 + i*0.01;
347  }
348  double modules[NC_PSC+1];
349  for (int i=0;i<=NC_PSC;i++) {
350  modules[i] = 0.5+i;
351  }
352  const int NTb = 2000;
353  double Tlows[NTb+1];
354  for (int i=0;i<=NTb;i++) {
355  Tlows[i] = -400.0+i*0.4;
356  }
357  const int NTb_PS = 200;
358  double Tlows_PS[NTb_PS+1];
359  for (int i=0;i<=NTb_PS;i++) {
360  Tlows_PS[i] = -10.0+i*0.1;
361  }
362 
363  // Since we are filling histograms local to this plugin, it will not interfere with other ROOT operations: can use plugin-wide ROOT fill lock
364  japp->RootFillLock(this); //ACQUIRE ROOT FILL LOCK
365 
366  // set variable-width energy bins if histogram is empty
367  // PS
368  if (hPS_ElVsEr->GetEntries()==0) hPS_ElVsEr->SetBins(NC_PS,Elows_PSarm[1],NC_PS,Elows_PSarm[0]);
369  if (hPS_ElVsPSCIDLeft->GetEntries()==0) hPS_ElVsPSCIDLeft->SetBins(NC_PSC,modules,NC_PS,Elows_PSarm[0]);
370  if (hPS_ErVsPSCIDRight->GetEntries()==0) hPS_ErVsPSCIDRight->SetBins(NC_PSC,modules,NC_PS,Elows_PSarm[1]);
371  if (hPSTAGH_ElVsEr->GetEntries()==0) hPSTAGH_ElVsEr->SetBins(NC_PS,Elows_PSarm[1],NC_PS,Elows_PSarm[0]);
372  if (hPSTAGM_ElVsEr->GetEntries()==0) hPSTAGM_ElVsEr->SetBins(NC_PS,Elows_PSarm[1],NC_PS,Elows_PSarm[0]);
373  if (hPS_E->GetEntries()==0) hPS_E->SetBins(NEb_PS,Elows_PS);
374  if (hPSTAGH_E->GetEntries()==0) hPSTAGH_E->SetBins(NEb_PS,Elows_PS);
375  if (hPSTAGM_E->GetEntries()==0) hPSTAGM_E->SetBins(NEb_PS,Elows_PS);
376  if (hPS_tdiffVsE->GetEntries()==0) hPS_tdiffVsE->SetBins(NEb_PS,Elows_PS,NTb_PS,Tlows_PS);
377  if (hPS_PStdiffVsE->GetEntries()==0) hPS_PStdiffVsE->SetBins(NEb_PS,Elows_PS,NTb_PS,Tlows_PS);
378  if (hPS_PSCPStdiffVsE->GetEntries()==0) hPS_PSCPStdiffVsE->SetBins(NEb_PS,Elows_PS,NTb_PS,Tlows_PS);
379  if (hPSTAGH_timeVsE->GetEntries()==0) hPSTAGH_timeVsE->SetBins(NEb_PS,Elows_PS,NTb,Tlows);
380  if (hPSTAGM_timeVsE->GetEntries()==0) hPSTAGM_timeVsE->SetBins(NEb_PS,Elows_PS,NTb,Tlows);
381  // TAGH
382  if (hPS_Etagh->GetEntries()==0) hPS_Etagh->SetBins(NC_TAGH,Elows_TAGH);
383  if (hPS_timeVsEtagh->GetEntries()==0) hPS_timeVsEtagh->SetBins(NC_TAGH,Elows_TAGH,NTb,Tlows);
384  if (hPSTAGH_Etagh->GetEntries()==0) hPSTAGH_Etagh->SetBins(NC_TAGH,Elows_TAGH);
385  if (hPSTAGH_EVsEtagh->GetEntries()==0) hPSTAGH_EVsEtagh->SetBins(NC_TAGH,Elows_TAGH,NEb_PS,Elows_PS);
386  if (hPSTAGH_timeVsEtagh->GetEntries()==0) hPSTAGH_timeVsEtagh->SetBins(NC_TAGH,Elows_TAGH,NTb,Tlows);
387  if (hPSTAGH_EdiffVsEtagh->GetEntries()==0) hPSTAGH_EdiffVsEtagh->SetBins(NC_TAGH,Elows_TAGH,NEdiff,EdiffLows);
388  // TAGM
389  if (hPS_Etagm->GetEntries()==0) hPS_Etagm->SetBins(NC_TAGM,Elows_TAGM);
390  if (hPS_timeVsEtagm->GetEntries()==0) hPS_timeVsEtagm->SetBins(NC_TAGM,Elows_TAGM,NTb,Tlows);
391  if (hPSTAGM_Etagm->GetEntries()==0) hPSTAGM_Etagm->SetBins(NC_TAGM,Elows_TAGM);
392  if (hPSTAGM_EVsEtagm->GetEntries()==0) hPSTAGM_EVsEtagm->SetBins(NC_TAGM,Elows_TAGM,NEb_PS,Elows_PS);
393  if (hPSTAGM_timeVsEtagm->GetEntries()==0) hPSTAGM_timeVsEtagm->SetBins(NC_TAGM,Elows_TAGM,NTb,Tlows);
394  if (hPSTAGM_EdiffVsEtagm->GetEntries()==0) hPSTAGM_EdiffVsEtagm->SetBins(NC_TAGM,Elows_TAGM,NEdiff,EdiffLows);
395 
396  japp->RootFillUnLock(this); //RELEASE ROOT FILL LOCK
397 
398  //
399  return NOERROR;
400 }
401 
402 //------------------
403 // evnt
404 //------------------
405 jerror_t JEventProcessor_PSPair_online::evnt(JEventLoop *loop, uint64_t eventnumber)
406 {
407  // This is called for every event. Use of common resources like writing
408  // to a file or filling a histogram should be mutex protected. Using
409  // loop->Get(...) to get reconstructed objects (and thereby activating the
410  // reconstruction algorithm) should be done outside of any mutex lock
411  // since multiple threads may call this method at the same time.
412  // coarse PS pairs
413  vector<const DPSCPair*> cpairs;
414  loop->Get(cpairs);
415  // fine PS pairs
416  vector<const DPSPair*> fpairs;
417  loop->Get(fpairs);
418  // tagger hits
419  vector<const DTAGHHit*> taghhits;
420  loop->Get(taghhits);
421  vector<const DTAGMHit*> tagmhits;
422  loop->Get(tagmhits);
423  // TPOL hits
424  vector<const DTPOLHit*> tpolhits;
425  loop->Get(tpolhits);
426 
427  // FILL HISTOGRAMS
428  // Since we are filling histograms local to this plugin, it will not interfere with other ROOT operations: can use plugin-wide ROOT fill lock
429  japp->RootFillLock(this); //ACQUIRE ROOT FILL LOCK
430 
431  hPSC_NHitPairs->Fill(cpairs.size());
432  hPS_NHitPairs->Fill(fpairs.size());
433  // PSC coincidences
434  if (cpairs.size()>=1) {
435  // take pair with smallest time difference from sorted vector
436  const DPSCHit* clhit = cpairs[0]->ee.first; // left hit in coarse PS
437  const DPSCHit* crhit = cpairs[0]->ee.second;// right hit in coarse PS
438  hPSC_PSCIDLeftVsIDRight->Fill(crhit->module,clhit->module);
439  double PSC_tdiff = clhit->t-crhit->t;
440  hPSC_tdiffVsPSCIDRight[clhit->module-1]->Fill(crhit->module,PSC_tdiff);
441  hPSC_tdiffVsPSCIDLeft[crhit->module-1]->Fill(clhit->module,PSC_tdiff);
442  // PSC,PS coincidences
443  if (fpairs.size()>=1) {
444  pspair_num_events->Fill(1);
445  // take pair with smallest time difference from sorted vector
446  const DPSPair::PSClust* flhit = fpairs[0]->ee.first; // left hit in fine PS
447  const DPSPair::PSClust* frhit = fpairs[0]->ee.second; // right hit in fine PS
448  double E_pair = flhit->E+frhit->E;
449  hPS_PSCIDLeftVsIDRight->Fill(crhit->module,clhit->module);
450  hPS_PSIDLeftVsIDRight->Fill(frhit->column,flhit->column);
451  double PS_Ediff = flhit->E-frhit->E;
452  double PS_tdiff = flhit->t-frhit->t;
453  hPS_Ediff->Fill(PS_Ediff);
454  hPS_ElVsEr->Fill(frhit->E,flhit->E);
455  hPS_E->Fill(E_pair);
456  hPS_tdiffVsE->Fill(E_pair,PSC_tdiff);
457  hPS_PStdiffVsE->Fill(E_pair,PS_tdiff);
458  hPS_PSCPStdiffVsE->Fill(E_pair,PSC_tdiff-PS_tdiff);
459  // correlation between PSC and PS ids for each arm
460  hPS_PSIDLeftVsPSCIDLeft->Fill(clhit->module,flhit->column);
461  hPS_PSIDRightVsPSCIDRight->Fill(crhit->module,frhit->column);
462  hPS_ElVsPSCIDLeft->Fill(clhit->module,flhit->E);
463  hPS_ErVsPSCIDRight->Fill(crhit->module,frhit->E);
464  // PSC,PS,TAGH coincidences
465  double EdiffMax = 0.3; // max difference of tagger hit and pair energies
466  for (unsigned int i=0; i < taghhits.size(); i++) {
467  const DTAGHHit* tag = taghhits[i];
468  if (!tag->has_TDC||!tag->has_fADC) continue;
469  hPS_TAGHCounterID->Fill(tag->counter_id);
470  hPS_Etagh->Fill(tag->E);
471  hPS_timeVsEtagh->Fill(tag->E,tag->t);
472  double Ediff = E_pair-tag->E;
473  hPSTAGH_tdiffVsEdiff->Fill(Ediff,clhit->t-tag->t);
474  if (fabs(Ediff) > EdiffMax) continue; // loose cut on energy difference
475  hPSTAGH_TAGHCounterID->Fill(tag->counter_id);
476  hPSTAGH_Etagh->Fill(tag->E);
477  hPSTAGH_timeVsEtagh->Fill(tag->E,tag->t);
478  hPSTAGH_EVsEtagh->Fill(tag->E,E_pair);
479  hPSTAGH_EdiffVsEtagh->Fill(tag->E,Ediff);
480  hPSTAGH_EdiffVsTAGHCounterID->Fill(tag->counter_id,Ediff);
481  hPSTAGH_tdiffVsTAGHCounterID_L[clhit->module-1]->Fill(tag->counter_id,clhit->t-tag->t);
482  hPSTAGH_tdiffVsTAGHCounterID_R[crhit->module-1]->Fill(tag->counter_id,crhit->t-tag->t);
483  hPSTAGH_PSCIDLeftVsIDRight->Fill(crhit->module,clhit->module);
484  hPSTAGH_PSIDLeftVsIDRight->Fill(frhit->column,flhit->column);
485  hPSTAGH_ElVsEr->Fill(frhit->E,flhit->E);
486  hPSTAGH_E->Fill(E_pair);
487  hPSTAGH_timeVsE->Fill(E_pair,clhit->t-tag->t);
488  }
489  // PSC,PS,TAGM coincidences
490  for (unsigned int i=0; i < tagmhits.size(); i++) {
491  const DTAGMHit* tag = tagmhits[i];
492  if (!tag->has_TDC||!tag->has_fADC) continue;
493  if (tag->row!=0) continue;
494  hPS_TAGMColumn->Fill(tag->column);
495  hPS_Etagm->Fill(tag->E);
496  hPS_timeVsEtagm->Fill(tag->E,tag->t);
497  double Ediff = E_pair-tag->E;
498  hPSTAGM_tdiffVsEdiff->Fill(Ediff,clhit->t-tag->t);
499  if (fabs(Ediff) > EdiffMax) continue; // loose cut on energy difference
500  hPSTAGM_TAGMColumn->Fill(tag->column);
501  hPSTAGM_Etagm->Fill(tag->E);
502  hPSTAGM_timeVsEtagm->Fill(tag->E,tag->t);
503  hPSTAGM_EVsEtagm->Fill(tag->E,E_pair);
504  hPSTAGM_EdiffVsEtagm->Fill(tag->E,Ediff);
505  hPSTAGM_EdiffVsTAGMColumn->Fill(tag->column,Ediff);
506  hPSTAGM_tdiffVsTAGMColumn_L[clhit->module-1]->Fill(tag->column,clhit->t-tag->t);
507  hPSTAGM_tdiffVsTAGMColumn_R[crhit->module-1]->Fill(tag->column,crhit->t-tag->t);
508  hPSTAGM_PSCIDLeftVsIDRight->Fill(crhit->module,clhit->module);
509  hPSTAGM_PSIDLeftVsIDRight->Fill(frhit->column,flhit->column);
510  hPSTAGM_ElVsEr->Fill(frhit->E,flhit->E);
511  hPSTAGM_E->Fill(E_pair);
512  hPSTAGM_timeVsE->Fill(E_pair,clhit->t-tag->t);
513  }
514  // PSC,PS,TPOL coincidences
515  if (fabs(PS_Ediff) > 1.75) {japp->RootFillUnLock(this); return NOERROR;}
516  if (fabs(PSC_tdiff) > 1.3) {japp->RootFillUnLock(this); return NOERROR;}
517  if (E_pair < 8.4 || E_pair > 9.0) {japp->RootFillUnLock(this); return NOERROR;}
518  double ph_cut = 100.0;
519  int N_TPOL = 0;
520  for(unsigned int i=0; i<tpolhits.size(); i++) {
521  if (tpolhits[i]->pulse_peak>=ph_cut) N_TPOL++;
522  }
523  hPSTPOL_NHits->Fill(N_TPOL);
524  if (N_TPOL>1) {japp->RootFillUnLock(this); return NOERROR;}
525  for(unsigned int i=0; i<tpolhits.size(); i++) {
526  const DTPOLHit* hit = tpolhits[i];
527  hPSTPOL_peak->Fill(hit->pulse_peak);
528  hPSTPOL_peakVsSector->Fill(hit->sector,hit->pulse_peak);
529  hPSTPOL_timeVsPeak->Fill(hit->pulse_peak,hit->t);
530  if (hit->pulse_peak<ph_cut) continue;
531  hPSTPOL_sector->Fill(hit->sector);
532  hPSTPOL_phi->Fill(hit->phi);
533  hPSTPOL_time->Fill(hit->t);
534  hPSTPOL_timeVsSector->Fill(hit->sector,hit->t);
535  hPSTPOL_timeVsPhi->Fill(hit->phi,hit->t);
536  }
537  }
538  }
539  //
540  japp->RootFillUnLock(this); //RELEASE ROOT FILL LOCK
541 
542  return NOERROR;
543 }
544 
545 //------------------
546 // erun
547 //------------------
548 jerror_t JEventProcessor_PSPair_online::erun(void)
549 {
550  // This is called whenever the run number changes, before it is
551  // changed to give you a chance to clean up before processing
552  // events from the next run number.
553  return NOERROR;
554 }
555 
556 //------------------
557 // fini
558 //------------------
559 jerror_t JEventProcessor_PSPair_online::fini(void)
560 {
561  // Called before program exit after event processing is finished.
562  return NOERROR;
563 }
564 
DTPOLHit::sector
int sector
Definition: DTPOLHit.h:11
DTAGHHit::t
double t
Definition: DTAGHHit.h:19
hPSTAGH_timeVsEtagh
static TH2F * hPSTAGH_timeVsEtagh
Definition: JEventProcessor_PSPair_online.cc:75
DTAGMGeometry.h
DTAGHHit::E
double E
Definition: DTAGHHit.h:18
JEventProcessor_PSPair_online::init
jerror_t init(void)
Called once at program start.
Definition: JEventProcessor_PSPair_online.cc:135
DTAGMHit::E
double E
Definition: DTAGMHit.h:18
DTAGHGeometry::getElow
double getElow(unsigned int counter) const
Definition: DTAGHGeometry.cc:71
NC_PSC
const int NC_PSC
Definition: JEventProcessor_TPOL_tree.cc:29
hPSTAGH_tdiffVsTAGHCounterID_L
static TH2I * hPSTAGH_tdiffVsTAGHCounterID_L[NC_PSC]
Definition: JEventProcessor_PSPair_online.cc:78
DPSCHit::module
int module
Definition: DPSCHit.h:20
hPSTAGM_tdiffVsEdiff
static TH2F * hPSTAGM_tdiffVsEdiff
Definition: JEventProcessor_PSPair_online.cc:81
hPSC_tdiffVsPSCIDRight
static TH2I * hPSC_tdiffVsPSCIDRight[NC_PSC]
Definition: JEventProcessor_PSPair_online.cc:43
hPS_PStdiffVsE
static TH2F * hPS_PStdiffVsE
Definition: JEventProcessor_PSPair_online.cc:52
DTAGMHit.h
hPSTAGH_EVsEtagh
static TH2I * hPSTAGH_EVsEtagh
Definition: JEventProcessor_PSPair_online.cc:67
DPSGeometry::NUM_ARMS
static const int NUM_ARMS
Definition: DPSGeometry.h:22
JEventProcessor_PSPair_online::~JEventProcessor_PSPair_online
~JEventProcessor_PSPair_online()
Definition: JEventProcessor_PSPair_online.cc:127
hPSTPOL_peak
static TH1I * hPSTPOL_peak
Definition: JEventProcessor_PSPair_online.cc:99
Ebw_PS
const float Ebw_PS
Definition: JEventProcessor_PS_E_calib.cc:29
hPSTPOL_NHits
static TH1I * hPSTPOL_NHits
Definition: JEventProcessor_PSPair_online.cc:96
hPSTAGH_tdiffVsEdiff
static TH2F * hPSTAGH_tdiffVsEdiff
Definition: JEventProcessor_PSPair_online.cc:66
hPSC_PSCIDLeftVsIDRight
static TH2F * hPSC_PSCIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:41
hPSTPOL_sector
static TH1I * hPSTPOL_sector
Definition: JEventProcessor_PSPair_online.cc:97
hPS_Etagh
static TH1F * hPS_Etagh
Definition: JEventProcessor_PSPair_online.cc:60
hPS_timeVsEtagm
static TH2F * hPS_timeVsEtagm
Definition: JEventProcessor_PSPair_online.cc:64
hPS_timeVsEtagh
static TH2F * hPS_timeVsEtagh
Definition: JEventProcessor_PSPair_online.cc:61
hPSTPOL_timeVsPhi
static TH2F * hPSTPOL_timeVsPhi
Definition: JEventProcessor_PSPair_online.cc:103
DTAGMHit::row
int row
Definition: DTAGMHit.h:20
DTAGHHit::has_TDC
bool has_TDC
Definition: DTAGHHit.h:26
hPSTPOL_time
static TH1I * hPSTPOL_time
Definition: JEventProcessor_PSPair_online.cc:101
hPS_ElVsEr
static TH2F * hPS_ElVsEr
Definition: JEventProcessor_PSPair_online.cc:48
DPSGeometry.h
hPSC_NHitPairs
static TH1I * hPSC_NHitPairs
Definition: JEventProcessor_PSPair_online.cc:38
hPSTAGH_PSCIDLeftVsIDRight
static TH2F * hPSTAGH_PSCIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:68
hPSTAGM_timeVsE
static TH2F * hPSTAGM_timeVsE
Definition: JEventProcessor_PSPair_online.cc:87
hPS_Ediff
static TH1F * hPS_Ediff
Definition: JEventProcessor_PSPair_online.cc:50
hPSTAGH_PSIDLeftVsIDRight
static TH2F * hPSTAGH_PSIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:69
hPS_tdiffVsE
static TH2F * hPS_tdiffVsE
Definition: JEventProcessor_PSPair_online.cc:51
hPSTAGH_timeVsE
static TH2F * hPSTAGH_timeVsE
Definition: JEventProcessor_PSPair_online.cc:72
hPSTAGM_Etagm
static TH1F * hPSTAGM_Etagm
Definition: JEventProcessor_PSPair_online.cc:89
DPSGeometry::getEhigh
double getEhigh(int arm, int column) const
Definition: DPSGeometry.cc:48
hPSC_tdiffVsPSCIDLeft
static TH2I * hPSC_tdiffVsPSCIDLeft[NC_PSC]
Definition: JEventProcessor_PSPair_online.cc:42
NC_TAGM
const int NC_TAGM
Definition: JEventProcessor_TPOL_tree.cc:32
hPSTAGM_PSCIDLeftVsIDRight
static TH2F * hPSTAGM_PSCIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:83
DTAGMHit::t
double t
Definition: DTAGMHit.h:19
mainDir
TDirectory * mainDir
Definition: p2k_hists.C:2
DPSCHit::t
double t
Definition: DPSCHit.h:21
DTPOLHit::pulse_peak
double pulse_peak
Definition: DTPOLHit.h:15
japp
JApplication * japp
hPSTAGH_ElVsEr
static TH2F * hPSTAGH_ElVsEr
Definition: JEventProcessor_PSPair_online.cc:70
DTAGMGeometry::getEhigh
double getEhigh(unsigned int column) const
Definition: DTAGMGeometry.cc:84
DTPOLHit_factory.h
hPSTAGM_tdiffVsTAGMColumn_R
static TH2I * hPSTAGM_tdiffVsTAGMColumn_R[NC_PSC]
Definition: JEventProcessor_PSPair_online.cc:94
DTAGMHit::has_fADC
bool has_fADC
Definition: DTAGMHit.h:27
DTAGHHit::counter_id
int counter_id
Definition: DTAGHHit.h:20
NS_TPOL
const int NS_TPOL
Definition: JEventProcessor_PSPair_online.cc:36
hPS_TAGMColumn
static TH1F * hPS_TAGMColumn
Definition: JEventProcessor_PSPair_online.cc:62
hPSTAGH_EdiffVsEtagh
static TH2I * hPSTAGH_EdiffVsEtagh
Definition: JEventProcessor_PSPair_online.cc:77
DPSPair.h
hPSTAGH_TAGHCounterID
static TH1F * hPSTAGH_TAGHCounterID
Definition: JEventProcessor_PSPair_online.cc:73
hPSTAGM_TAGMColumn
static TH1F * hPSTAGM_TAGMColumn
Definition: JEventProcessor_PSPair_online.cc:88
InitPlugin
InitPlugin_t InitPlugin
pspair_num_events
static TH1I * pspair_num_events
Definition: JEventProcessor_PSPair_online.cc:45
Ebl_PS
const float Ebl_PS
Definition: JEventProcessor_PS_E_calib.cc:30
hPS_NHitPairs
static TH1I * hPS_NHitPairs
Definition: JEventProcessor_PSPair_online.cc:39
hPS_PSIDLeftVsIDRight
static TH2F * hPS_PSIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:47
DTAGHHit.h
hPSTAGH_E
static TH1F * hPSTAGH_E
Definition: JEventProcessor_PSPair_online.cc:71
hPSTAGM_EdiffVsTAGMColumn
static TH2I * hPSTAGM_EdiffVsTAGMColumn
Definition: JEventProcessor_PSPair_online.cc:91
JEventProcessor_PSPair_online::fini
jerror_t fini(void)
Called after last event of last event source has been processed.
Definition: JEventProcessor_PSPair_online.cc:559
DTAGHGeometry.h
DTAGMHit::has_TDC
bool has_TDC
Definition: DTAGMHit.h:27
DTPOLHit::phi
double phi
Definition: DTPOLHit.h:12
DPSCPair.h
Ebh_PS
const float Ebh_PS
Definition: JEventProcessor_PS_E_calib.cc:31
JEventProcessor_PSPair_online
Definition: JEventProcessor_PSPair_online.h:13
JEventProcessor_PSPair_online::brun
jerror_t brun(jana::JEventLoop *eventLoop, int32_t runnumber)
Called everytime a new run number is detected.
Definition: JEventProcessor_PSPair_online.cc:284
DPSGeometry::NUM_COARSE_COLUMNS
static const int NUM_COARSE_COLUMNS
Definition: DPSGeometry.h:25
DTAGMGeometry::getElow
double getElow(unsigned int column) const
Definition: DTAGMGeometry.cc:75
DTPOLHit.h
hPSTAGH_Etagh
static TH1F * hPSTAGH_Etagh
Definition: JEventProcessor_PSPair_online.cc:74
Narms
const int Narms
Definition: JEventProcessor_PS_online.cc:28
hPSTAGH_EdiffVsTAGHCounterID
static TH2I * hPSTAGH_EdiffVsTAGHCounterID
Definition: JEventProcessor_PSPair_online.cc:76
hPSTPOL_timeVsSector
static TH2I * hPSTPOL_timeVsSector
Definition: JEventProcessor_PSPair_online.cc:102
hPS_PSIDLeftVsPSCIDLeft
static TH2I * hPS_PSIDLeftVsPSCIDLeft
Definition: JEventProcessor_PSPair_online.cc:54
hPS_Etagm
static TH1F * hPS_Etagm
Definition: JEventProcessor_PSPair_online.cc:63
hPSTAGM_ElVsEr
static TH2F * hPSTAGM_ElVsEr
Definition: JEventProcessor_PSPair_online.cc:85
DTAGHGeometry::getEhigh
double getEhigh(unsigned int counter) const
Definition: DTAGHGeometry.cc:79
JEventProcessor_PSPair_online::JEventProcessor_PSPair_online
JEventProcessor_PSPair_online()
Definition: JEventProcessor_PSPair_online.cc:119
hPS_PSCIDLeftVsIDRight
static TH2F * hPS_PSCIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:46
hPSTAGM_PSIDLeftVsIDRight
static TH2F * hPSTAGM_PSIDLeftVsIDRight
Definition: JEventProcessor_PSPair_online.cc:84
hPS_PSCPStdiffVsE
static TH2F * hPS_PSCPStdiffVsE
Definition: JEventProcessor_PSPair_online.cc:53
DTAGHHit::has_fADC
bool has_fADC
Definition: DTAGHHit.h:26
hPS_PSIDRightVsPSCIDRight
static TH2I * hPS_PSIDRightVsPSCIDRight
Definition: JEventProcessor_PSPair_online.cc:55
hPSTAGM_timeVsEtagm
static TH2F * hPSTAGM_timeVsEtagm
Definition: JEventProcessor_PSPair_online.cc:90
NEb_PS
const float NEb_PS
Definition: JEventProcessor_PS_E_calib.cc:32
hPS_TAGHCounterID
static TH1F * hPS_TAGHCounterID
Definition: JEventProcessor_PSPair_online.cc:59
hPSTAGM_EVsEtagm
static TH2I * hPSTAGM_EVsEtagm
Definition: JEventProcessor_PSPair_online.cc:82
JEventProcessor_PSPair_online.h
JEventProcessor_PSPair_online::erun
jerror_t erun(void)
Called everytime run number changes, provided brun has been called.
Definition: JEventProcessor_PSPair_online.cc:548
NC_TAGH
const int NC_TAGH
Definition: JEventProcessor_TPOL_tree.cc:31
hPSTAGH_tdiffVsTAGHCounterID_R
static TH2I * hPSTAGH_tdiffVsTAGHCounterID_R[NC_PSC]
Definition: JEventProcessor_PSPair_online.cc:79
DTAGMGeometry::kColumnCount
static const unsigned int kColumnCount
Definition: DTAGMGeometry.h:31
JEventProcessor_PSPair_online::evnt
jerror_t evnt(jana::JEventLoop *eventLoop, uint64_t eventnumber)
Called every event.
Definition: JEventProcessor_PSPair_online.cc:405
hPS_ElVsPSCIDLeft
static TH2I * hPS_ElVsPSCIDLeft
Definition: JEventProcessor_PSPair_online.cc:56
DTAGMHit::column
int column
Definition: DTAGMHit.h:21
hPSTPOL_phi
static TH1F * hPSTPOL_phi
Definition: JEventProcessor_PSPair_online.cc:98
DTPOLHit::t
double t
Definition: DTPOLHit.h:18
hPSTAGM_tdiffVsTAGMColumn_L
static TH2I * hPSTAGM_tdiffVsTAGMColumn_L[NC_PSC]
Definition: JEventProcessor_PSPair_online.cc:93
DPSGeometry::NUM_FINE_COLUMNS
static const int NUM_FINE_COLUMNS
Definition: DPSGeometry.h:26
DTAGHGeometry::kCounterCount
static const unsigned int kCounterCount
Definition: DTAGHGeometry.h:28
hPSTAGM_E
static TH1F * hPSTAGM_E
Definition: JEventProcessor_PSPair_online.cc:86
hPS_ErVsPSCIDRight
static TH2I * hPS_ErVsPSCIDRight
Definition: JEventProcessor_PSPair_online.cc:57
hPS_E
static TH1F * hPS_E
Definition: JEventProcessor_PSPair_online.cc:49
hPSTPOL_timeVsPeak
static TH2I * hPSTPOL_timeVsPeak
Definition: JEventProcessor_PSPair_online.cc:104
hPSTAGM_EdiffVsEtagm
static TH2I * hPSTAGM_EdiffVsEtagm
Definition: JEventProcessor_PSPair_online.cc:92
DPSGeometry::getElow
double getElow(int arm, int column) const
Definition: DPSGeometry.cc:40
NC_PS
const int NC_PS
Definition: JEventProcessor_TPOL_tree.cc:30
hPSTPOL_peakVsSector
static TH2I * hPSTPOL_peakVsSector
Definition: JEventProcessor_PSPair_online.cc:100
DTPOLHit_factory::NSECTORS
static const int NSECTORS
Definition: DTPOLHit_factory.h:15