diff --git a/analysis/include/RawSvtHitHistos.h b/analysis/include/RawSvtHitHistos.h index c6a83082a..05025aef7 100644 --- a/analysis/include/RawSvtHitHistos.h +++ b/analysis/include/RawSvtHitHistos.h @@ -26,7 +26,7 @@ class RawSvtHitHistos : public HistoManager{ ~RawSvtHitHistos(); void DefineHistos(); - void FillHistograms(RawSvtHit* rawSvtHit,float weight = 1.,int Ireg=0,unsigned int nhit = 0,Float_t TimeDiff = -42069.0,Float_t AmpDiff = -42069.0); + void FillHistograms(RawSvtHit* rawSvtHit,float weight = 1.,int Ireg=0,unsigned int nhit = 0,Float_t TimeDiff = -42069.0,Float_t AmpDiff = -42069.0,int str=-10000, int hitc = 0, int hitl = 0,float otherTime = 69420.0); void saveHistosSVT(TFile* outF,std::string folder); private: diff --git a/analysis/plotconfigs/svt/rawSvtAnaHits.json b/analysis/plotconfigs/svt/rawSvtAnaHits.json index 63c146494..7ddb4054b 100644 --- a/analysis/plotconfigs/svt/rawSvtAnaHits.json +++ b/analysis/plotconfigs/svt/rawSvtAnaHits.json @@ -46,6 +46,26 @@ "maxX" : 1, "ytitle" : "Chi_Sqr of Fits" + }, + "SvtHybrids_HitsPerCluster_h" : { + "prefix" : "hit_clu", + "type" : "h", + "xtitle" : "hit_no", + "bins" : 8, + "minX" : 0, + "maxX" : 8, + "ytitle" : "Hits On A Cluster" + + }, + "SvtHybrids_HitsOnALayer_h" : { + "prefix" : "hit_lay", + "type" : "h", + "xtitle" : "hit_no", + "bins" : 8, + "minX" : 0, + "maxX" : 8, + "ytitle" : "Hits On A Layer" + }, "SvtHybrids_ADCcount_hh" : { "prefix" : "adcC", @@ -70,8 +90,55 @@ "binsY" : 100, "minY" : -3000, "maxY" : 9000 - + }, + "SvtHybrids_T0Strip_hh" : { + "prefix" : "adcC", + "type" : "hh", + "xtitle" : "T0", + "binsX" : 100, + "minX" : -120, + "maxX" : 100, + "ytitle" : "Strip Distance", + "binsY" : 1024, + "minY" : -512, + "maxY" : 512 + }, + "SvtHybrids_2HitCluDiff_hh" : { + "prefix" : "adcC", + "type" : "hh", + "xtitle" : "T0", + "binsX" : 100, + "minX" : -120, + "maxX" : 100, + "ytitle" : "Strip Distance", + "binsY" : 100, + "minY" : -120, + "maxY" : 100 }, + "SvtHybrids_AmChi_Sqr_hh" : { + "prefix" : "T0", + "type" : "hh", + "xtitle" : "Chi Sqr vs Amplitude", + "binsX" : 100, + "minX" : 0, + "maxX" : 1, + "ytitle" : "Amplitude", + "binsY" : 100, + "minY" : 0, + "maxY" : 7000 + }, + "SvtHybrids_T0Chi_Sqr_hh" : { + "prefix" : "T0", + "type" : "hh", + "xtitle" : "Chi Sqr vs Amplitude", + "binsX" : 100, + "minX" : 0, + "maxX" : 1, + "ytitle" : "T0", + "binsY" : 100, + "minY" : -120, + "maxY" : 100 + }, "SvtHybrids_T0Err_hh" : { "prefix" : "toerr", "type" : "hh", @@ -83,7 +150,6 @@ "binsY" : 100, "minY" : 0, "maxY" : 200 - }, "SvtHybrids_AmErr_hh" : { "prefix" : "Amperr", diff --git a/analysis/selections/svtHit/R1.json b/analysis/selections/svtHit/R1.json new file mode 100644 index 000000000..edf221854 --- /dev/null +++ b/analysis/selections/svtHit/R1.json @@ -0,0 +1,23 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : 100.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -10.0, + "id" : 3, + "info" : "Lower Bound on Region" + } + +} diff --git a/analysis/selections/svtHit/R2.json b/analysis/selections/svtHit/R2.json new file mode 100644 index 000000000..bcdf4f205 --- /dev/null +++ b/analysis/selections/svtHit/R2.json @@ -0,0 +1,23 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -10.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -120.0, + "id" : 3, + "info" : "Lower Bound on Region" + } + +} diff --git a/analysis/selections/svtHit/R3.json b/analysis/selections/svtHit/R3.json new file mode 100644 index 000000000..d23500a50 --- /dev/null +++ b/analysis/selections/svtHit/R3.json @@ -0,0 +1,23 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -120.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -220.0, + "id" : 3, + "info" : "Lower Bound on Region" + } + +} diff --git a/analysis/selections/svtHit/R4.json b/analysis/selections/svtHit/R4.json new file mode 100644 index 000000000..755d53b56 --- /dev/null +++ b/analysis/selections/svtHit/R4.json @@ -0,0 +1,23 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + } + +} diff --git a/analysis/selections/svtHit/Region1Phase0.json b/analysis/selections/svtHit/Region1Phase0.json new file mode 100644 index 000000000..b9e6fcd6f --- /dev/null +++ b/analysis/selections/svtHit/Region1Phase0.json @@ -0,0 +1,27 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 0.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region1Phase1.json b/analysis/selections/svtHit/Region1Phase1.json new file mode 100644 index 000000000..b5bbbbd72 --- /dev/null +++ b/analysis/selections/svtHit/Region1Phase1.json @@ -0,0 +1,27 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 1.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region1Phase2.json b/analysis/selections/svtHit/Region1Phase2.json new file mode 100644 index 000000000..ee3a0632c --- /dev/null +++ b/analysis/selections/svtHit/Region1Phase2.json @@ -0,0 +1,27 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 2.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region1Phase3.json b/analysis/selections/svtHit/Region1Phase3.json new file mode 100644 index 000000000..e81876f9d --- /dev/null +++ b/analysis/selections/svtHit/Region1Phase3.json @@ -0,0 +1,27 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 3.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region1Phase4.json b/analysis/selections/svtHit/Region1Phase4.json new file mode 100644 index 000000000..19a1a8c46 --- /dev/null +++ b/analysis/selections/svtHit/Region1Phase4.json @@ -0,0 +1,27 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 4.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region1Phase5.json b/analysis/selections/svtHit/Region1Phase5.json new file mode 100644 index 000000000..ad43eb4c1 --- /dev/null +++ b/analysis/selections/svtHit/Region1Phase5.json @@ -0,0 +1,27 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -220.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -320.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 5.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region2Phase0.json b/analysis/selections/svtHit/Region2Phase0.json new file mode 100644 index 000000000..19c468b21 --- /dev/null +++ b/analysis/selections/svtHit/Region2Phase0.json @@ -0,0 +1,28 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -160.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -190.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 0.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } + +} diff --git a/analysis/selections/svtHit/Region2Phase1.json b/analysis/selections/svtHit/Region2Phase1.json new file mode 100644 index 000000000..5b5d5dd68 --- /dev/null +++ b/analysis/selections/svtHit/Region2Phase1.json @@ -0,0 +1,28 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -160.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -190.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 1.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } + +} diff --git a/analysis/selections/svtHit/Region2Phase2.json b/analysis/selections/svtHit/Region2Phase2.json new file mode 100644 index 000000000..eaef18f51 --- /dev/null +++ b/analysis/selections/svtHit/Region2Phase2.json @@ -0,0 +1,28 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -160.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -190.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 2.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } + +} diff --git a/analysis/selections/svtHit/Region2Phase3.json b/analysis/selections/svtHit/Region2Phase3.json new file mode 100644 index 000000000..0d6554792 --- /dev/null +++ b/analysis/selections/svtHit/Region2Phase3.json @@ -0,0 +1,28 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -160.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -190.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 3.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } + +} diff --git a/analysis/selections/svtHit/Region2Phase4.json b/analysis/selections/svtHit/Region2Phase4.json new file mode 100644 index 000000000..d9b4e4dd7 --- /dev/null +++ b/analysis/selections/svtHit/Region2Phase4.json @@ -0,0 +1,28 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -160.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -190.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 4.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } + +} diff --git a/analysis/selections/svtHit/Region2Phase5.json b/analysis/selections/svtHit/Region2Phase5.json new file mode 100644 index 000000000..ee4825756 --- /dev/null +++ b/analysis/selections/svtHit/Region2Phase5.json @@ -0,0 +1,28 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -160.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -190.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "time_phase" : { + "cut" : 5.0, + "id" : 4, + "info" : "Equal Bound on Phase" + } + +} diff --git a/analysis/selections/svtHit/Region3Phase0.json b/analysis/selections/svtHit/Region3Phase0.json new file mode 100644 index 000000000..b23f2bd0a --- /dev/null +++ b/analysis/selections/svtHit/Region3Phase0.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -1.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -7.0, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 0.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region3Phase1.json b/analysis/selections/svtHit/Region3Phase1.json new file mode 100644 index 000000000..e84aa2c75 --- /dev/null +++ b/analysis/selections/svtHit/Region3Phase1.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -1.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -7.0, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 1.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region3Phase2.json b/analysis/selections/svtHit/Region3Phase2.json new file mode 100644 index 000000000..96e517b34 --- /dev/null +++ b/analysis/selections/svtHit/Region3Phase2.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -1.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -7.0, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 2.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region3Phase3.json b/analysis/selections/svtHit/Region3Phase3.json new file mode 100644 index 000000000..5c87c3660 --- /dev/null +++ b/analysis/selections/svtHit/Region3Phase3.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -1.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -7.0, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 3.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region3Phase4.json b/analysis/selections/svtHit/Region3Phase4.json new file mode 100644 index 000000000..087cbf80b --- /dev/null +++ b/analysis/selections/svtHit/Region3Phase4.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -1.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -7.0, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 4.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region3Phase5.json b/analysis/selections/svtHit/Region3Phase5.json new file mode 100644 index 000000000..ffc43ca2a --- /dev/null +++ b/analysis/selections/svtHit/Region3Phase5.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -1.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -7.0, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 5.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region4Phase0.json b/analysis/selections/svtHit/Region4Phase0.json new file mode 100644 index 000000000..69a12d4e7 --- /dev/null +++ b/analysis/selections/svtHit/Region4Phase0.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -18.5, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -23.5, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 0.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region4Phase1.json b/analysis/selections/svtHit/Region4Phase1.json new file mode 100644 index 000000000..295f076b8 --- /dev/null +++ b/analysis/selections/svtHit/Region4Phase1.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -18.5, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -23.5, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 1.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region4Phase2.json b/analysis/selections/svtHit/Region4Phase2.json new file mode 100644 index 000000000..6a22a3158 --- /dev/null +++ b/analysis/selections/svtHit/Region4Phase2.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -18.5, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -23.5, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 2.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region4Phase3.json b/analysis/selections/svtHit/Region4Phase3.json new file mode 100644 index 000000000..a3885eb3d --- /dev/null +++ b/analysis/selections/svtHit/Region4Phase3.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -18.5, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -23.5, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 3.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region4Phase4.json b/analysis/selections/svtHit/Region4Phase4.json new file mode 100644 index 000000000..04ba5cd7f --- /dev/null +++ b/analysis/selections/svtHit/Region4Phase4.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -18.5, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -23.5, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 4.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region4Phase5.json b/analysis/selections/svtHit/Region4Phase5.json new file mode 100644 index 000000000..48b983e63 --- /dev/null +++ b/analysis/selections/svtHit/Region4Phase5.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -57.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -61.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -18.5, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -23.5, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 5.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region5Phase0.json b/analysis/selections/svtHit/Region5Phase0.json new file mode 100644 index 000000000..3e40384da --- /dev/null +++ b/analysis/selections/svtHit/Region5Phase0.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -51.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -57.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -24.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -30, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 0.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region5Phase1.json b/analysis/selections/svtHit/Region5Phase1.json new file mode 100644 index 000000000..ce3a8de1e --- /dev/null +++ b/analysis/selections/svtHit/Region5Phase1.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -51.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -57.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -24.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -30, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 1.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region5Phase2.json b/analysis/selections/svtHit/Region5Phase2.json new file mode 100644 index 000000000..46f341e65 --- /dev/null +++ b/analysis/selections/svtHit/Region5Phase2.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -51.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -57.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -24.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -30, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 2.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region5Phase3.json b/analysis/selections/svtHit/Region5Phase3.json new file mode 100644 index 000000000..6365ef29c --- /dev/null +++ b/analysis/selections/svtHit/Region5Phase3.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -51.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -57.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -24.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -30, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 3.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region5Phase4.json b/analysis/selections/svtHit/Region5Phase4.json new file mode 100644 index 000000000..7a1fe0271 --- /dev/null +++ b/analysis/selections/svtHit/Region5Phase4.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -51.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -57.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -24.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -30, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 4.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region5Phase5.json b/analysis/selections/svtHit/Region5Phase5.json new file mode 100644 index 000000000..b5ca04abc --- /dev/null +++ b/analysis/selections/svtHit/Region5Phase5.json @@ -0,0 +1,37 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -51.0, + "id" : 2, + "info" : "Upper Bound on FT Region" + }, + "Otime_gt" : { + "cut" : -57.0, + "id" : 3, + "info" : "Lower Bound on FT Region" + }, + "Stime_lt" : { + "cut" : -24.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : -30, + "id" : 5, + "info" : "Lower Bound on CT Region" + }, + "time_phase" : { + "cut" : 5.0, + "id" : 6, + "info" : "Equal Bound on Phase" + } +} diff --git a/analysis/selections/svtHit/Region6.json b/analysis/selections/svtHit/Region6.json new file mode 100644 index 000000000..2744104f5 --- /dev/null +++ b/analysis/selections/svtHit/Region6.json @@ -0,0 +1,33 @@ +{ + "getN_et" : { + "cut" : 2.0, + "id" : 0, + "info" : "How Many Pulses" + }, + "doing_ct" : { + "cut" : 0.0, + "id" : 1, + "info" : "Do We Fit Close Time" + }, + "Otime_lt" : { + "cut" : -10.0, + "id" : 2, + "info" : "Upper Bound on Region" + }, + "Otime_gt" : { + "cut" : -130.0, + "id" : 3, + "info" : "Lower Bound on Region" + }, + "Stime_lt" : { + "cut" : -40.0, + "id" : 4, + "info" : "Upper Bound on CT Region" + }, + "Stime_gt" : { + "cut" : 40, + "id" : 5, + "info" : "Lower Bound on CT Region" + } + +} diff --git a/analysis/src/RawSvtHitHistos.cxx b/analysis/src/RawSvtHitHistos.cxx index ef3d6f0bb..a8ea98af7 100644 --- a/analysis/src/RawSvtHitHistos.cxx +++ b/analysis/src/RawSvtHitHistos.cxx @@ -22,7 +22,7 @@ void RawSvtHitHistos::DefineHistos(){ //std::cout<<"hello2"< hybridStrings={}; std::string histokey; //std::cout<getAmp(i),weight); histokey = swTag + "_SvtHybrids_Chi_Sqr_h"; Fill1DHisto(histokey, rawSvtHit->getChiSq(i),weight); + + histokey = swTag + "_SvtHybrids_HitsPerCluster_h"; + Fill1DHisto(histokey,HITC,weight); + //Fill2DHisto(histokey,,,weight); + + histokey = swTag + "_SvtHybrids_HitsOnALayer_h"; + Fill1DHisto(histokey,HITL,weight); + //std::cout<getStrip()<getADCs(); @@ -82,8 +90,6 @@ void RawSvtHitHistos::FillHistograms(RawSvtHit* rawSvtHit,float weight,int i,uns // - - histokey = swTag + "_SvtHybrids_ADCcountdeshift_hh"; for(unsigned int K=1; K<6; K++){ if(feb<=1){ @@ -103,7 +109,19 @@ void RawSvtHitHistos::FillHistograms(RawSvtHit* rawSvtHit,float weight,int i,uns } //adcs_=rawSvtHit->getADCs(i); //Fill1DHisto(histokey, -(rawSvthit->getT0(i)),weight); + + histokey = swTag + "_SvtHybrids_T0Strip_hh"; + Fill2DHisto(histokey,rawSvtHit->getT0(i),rawSvtHit->getStrip()-STR,weight); + + histokey = swTag + "_SvtHybrids_2HitCluDiff_hh"; + Fill2DHisto(histokey,rawSvtHit->getT0(i),otherTime,weight); + + histokey = swTag + "_SvtHybrids_AmChi_Sqr_hh"; + Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getAmp(i),weight); + histokey = swTag + "_SvtHybrids_T0Chi_Sqr_hh"; + Fill2DHisto(histokey, rawSvtHit->getChiSq(i), rawSvtHit->getT0(i),weight); + //std::cout<<"hello7"<getT0(i), rawSvtHit->getT0err(i),weight); diff --git a/event/include/TrackerHit.h b/event/include/TrackerHit.h index af5ab82d4..90997d329 100644 --- a/event/include/TrackerHit.h +++ b/event/include/TrackerHit.h @@ -111,6 +111,8 @@ class TrackerHit : public TObject { /** Is a hit shared between multiple tracks. */ bool isShared() const ; + int getNHits() { return n_rawhits_;} ; + /** Add raw hit to the raw hit reference array */ void addRawHit(TObject* rawhit) { ++n_rawhits_; diff --git a/plotUtils/makeHTML.py b/plotUtils/makeHTML.py new file mode 100755 index 000000000..4cdbfb7e4 --- /dev/null +++ b/plotUtils/makeHTML.py @@ -0,0 +1,244 @@ +import ROOT as r +from ROOT import TCanvas,TH1F,TH2F,TH2D,TLegend,THStack +import os,sys,glob +import numpy as np +import argparse + +print("HOLLO") + +def makeHTML(outDir,filename,title,plots,branchnames,mode):#,selection): + print("DID I COME HERE") + os.chdir(outDir) + outfilebase = os.path.split(outDir)[1] + f = open(filename+'.html',"w+") + f.write("\n") + f.write("\n") + f.write(""+ title +" \n") + f.write("\n") + f.write("\n") + for i in range(0,len(plots)): + pname = "" + offset = 1 + if i==0 or i%2==0: + f.write("\n") + if mode==0: + f.write("\n") + if mode==1: + if plots[i][len(plots[i])-1]=="l": + f.write("\n") + else: + f.write("\n") + if i==offset: + f.write("\n") + elif (i>offset and (i-offset)%2==0) or i==len(plots): + f.write("\n") + f.write("
\"""+branchnames[i]+"\""
\n") + f.write("\n") + f.write("") + f.close() + path_parent=os.path.dirname(os.getcwd()) + os.chdir(path_parent) + +def buildLegend(canvas,x1=0.50, y1=0.60,x2=0.70,y2=0.8,textsize=0.025,separation=0.1,fill=0,border=0): + #canvas.cd() + legend = canvas.BuildLegend(x1,y1,x2,y2) + legend.Draw() + legend.SetTextSize(textsize) + #legend.SetEntrySeparation(separation) + #legend.SetFillStyle(fill) + legend.SetFillColorAlpha(r.kGray,0.7) + legend.SetBorderSize(border) + +def format1DPlot(plot, name, title = "",linecolor = 1, linewidth = 2, linestyle = 1): + plot.SetLineWidth(linewidth) + plot.SetLineColor(linecolor) + plot.SetLineStyle(linestyle) + plot.SetName(name) + if title != "": + plot.SetTitle(title) + +def getStatsYPositions(nplots): + start = 1.0 + end = 0.1 + height = (start-end)/nplots + if height > 0.1: + height = 0.1 + #ypositions = list(range(start,end,height)) + ypositions = np.arange(end,start,height) + ypositions= np.flipud(ypositions) + print(ypositions) + return ypositions,height + + +def setStatsBox(plot,xpos=0.9,ypos=0.9,height=0.2,width=0.1,linecolor=r.kBlack,color=r.kWhite,alpha=0.8): + r.gPad.Update() + stats = plot.GetListOfFunctions().FindObject("stats") + stats.SetFillColorAlpha(color,alpha) + stats.SetLineColor(linecolor) + r.gStyle.SetStatY(ypos) + r.gStyle.SetStatH(height) + r.gStyle.SetStatW(width) + r.gStyle.SetStatX(xpos) + r.gPad.Update() + +def savePlotAsPNG(plot, plot_dir, drawOptions=""): + c = r.TCanvas(plot.GetName(),plot.GetName(),1800,900) + c.cd() + plot.Draw("%s"%(drawOptions)) + setStatsBox(plot,xpos=0.8,ypos=0.8) + c.Update() + c.SaveAs("%s/%s.png"%(plot_dir,plot.GetName())) + #r.gPad.Update() + c.Close() + +def overlay1DPlots(plots,outf,c,canvas_name,legend_names = []): + #statsbox formatting + statspositions,height = getStatsYPositions(len(plots)) + + ymax = -99999 + for i,plot in enumerate(plots): + ymaxi = plot.GetMaximum() + if ymaxi > ymax: + ymax = ymaxi + + + #c = r.TCanvas("%s"%(canvas_name),"%s"%(canvas_name),1800,1000) + c.cd() + + #set yaxis + for i,plot in enumerate(plots): + plot.GetYaxis().SetRangeUser(0.00001,ymax*1.1) + if i < 1: + plot.Draw("hist") + setStatsBox(plot,ypos=statspositions[i],height=height,linecolor=colors[i]) + else: + plot.Draw("histsames") + setStatsBox(plot,ypos=statspositions[i],height=height,linecolor=colors[i]) + + if len(legend_names) > 0: + for i, plot in enumerate(plots): + plot.SetTitle(legend_names[i]) + + buildLegend(c) + plots[0].SetTitle(canvas_name) + c.SaveAs(outf+"/"+canvas_name+".png","png") + #r.gPad.Update() + c.Close() + +parser = argparse.ArgumentParser(description="The baseConfig options for plotHistDir") + +parser.add_argument("-i","--inFileBase",type=str,dest="inf",action='store',help="input file base, use when files are in the same directory", default=None) +parser.add_argument("-o","--outFileBase",type=str,dest="outf",action='store',help="Generates Pictures and HTML Webpage Here", default=None) +parser.add_argument("-r","--ratioEnable",type=int,dest="ratio",action='store',help="Enables Ratio Curves", default=0) +parser.add_argument("-mc","--mcFileBase",type=str,dest="mc",action='store',help="Enables MC and Takes in Curves", default="Nope") +parser.add_argument("-l","--list",nargs=4,type=float,dest="leglist",action='store',help="Relocates the Legend",default=[.73,.32,.97,.53]) + +options = parser.parse_args() +inf=options.inf +outf=options.outf +R=(options.ratio==1)#or(not(options.mc=='Nope')) +MC=options.mc +leglist=options.leglist +print(leglist) +#treeNum=options.treeNum +#branchNum=options.branchNum + +colors = [r.kBlack,r.kRed,r.kBlue,r.kGreen+2,r.kOrange-2] +#legends=["",""] + +#print(os.listdir(inf)) + +inFileList=os.listdir(inf) +if (not(options.mc=='Nope')): + mcFileList=os.listdir(MC) +if R: + inFileList=inFileList[:2] +r.gROOT.SetBatch(1) + +DFS=r.TFile(inf+"/"+inFileList[0])#DirectoryForSize +SubDirs=[] +SubDirNames=[] +for i in range(0,len(DFS.GetListOfKeys())): + print(type(DFS.Get(DFS.GetListOfKeys().At(i).GetName()))) + if(len(str(type(DFS.Get(DFS.GetListOfKeys().At(i).GetName()))))==45): + SubDirs.append(DFS.Get(DFS.GetListOfKeys().At(i).GetName())) + SubDirNames.append(DFS.GetListOfKeys().At(i).GetName()) + +BranchNames=[[SubDirs[i].GetListOfKeys().At(j).GetName() for j in range(len(SubDirs[i].GetListOfKeys()))] for i in range(len(SubDirs))] +#OneD=[] +print(SubDirNames) + +for i in range(len(SubDirs)): + OneD=[] + for j in range(len(SubDirs[i].GetListOfKeys())): + #print(BranchNames[i][j]) + c=r.TCanvas() + leg = TLegend(leglist[0],leglist[1],leglist[2],leglist[3])#TLegend(.73,.32,.97,.53) + DFSnow=r.TFile(inf+"/"+inFileList[0]) + Entry=DFSnow.Get(SubDirNames[i]+"/"+BranchNames[i][j]) + is2d=(type(Entry)==TH2D) + #print(is2d) + try: + if (not(is2d))and(not(options.mc=='Nope')): + ths1=THStack(BranchNames[i][j],BranchNames[i][j]) + for I in range(len(mcFileList)): + DFSnow=r.TFile(MC+"/"+mcFileList[I]) + Entry=DFSnow.Get(SubDirNames[i]+"/"+BranchNames[i][j]) + Entry.SetDirectory(0) + ths1.Add(Entry) + ths1.Draw("stack") + print("hello") + except: + print("Failed at "+BranchNames[i][j]) + if R and not(is2d): + c.Divide(1,2) + c.cd(1) + plots=[] + for I in range(len(inFileList)): + DFSnow=r.TFile(inf+"/"+inFileList[I]) + Entry=DFSnow.Get(SubDirNames[i]+"/"+BranchNames[i][j]) + if is2d: + Entry.SetTitle(inFileList[I]) + Entry.Draw("colz") + c.Print(outf+"/pic"+str(i)+"_"+str(j)+"_"+str(I)+".png","png") + c.Clear() + continue + Entry.SetDirectory(0) + Entry.SetLineColor(colors[I%5]) + if options.mc=='Nope': + leg.AddEntry(Entry,inFileList[I],"L") + plots.append(Entry) + #Entry.Draw("colz same") + #overlay1DPlots() + + try: + if R and not(is2d): + c.cd(2) + f1=r.TFile(inf+"/"+inFileList[0]) + Entry1=f1.Get(SubDirNames[i]+"/"+BranchNames[i][j]) + Entry1.SetDirectory(0) + f2=r.TFile(inf+"/"+inFileList[1]) + Entry2=f2.Get(SubDirNames[i]+"/"+BranchNames[i][j]) + Entry2.Divide(Entry1) + #print("hello") + Entry2.Draw("colz") + except: + print("Failed on 1D Histogram for "+BranchNames[i][j]) + if is2d: + makeHTML(outf,BranchNames[i][j],BranchNames[i][j],["pic"+str(i)+"_"+str(j)+"_"+str(I)+".png" for I in range(len(inFileList))],[],0) + print("hello") + OneD.append(0) + else: + overlay1DPlots(plots,outf,c,BranchNames[i][j],inFileList) + #leg.Draw() + #c.Print(outf+"/"+BranchNames[i][j]+".png","png") + c.Clear() + OneD.append(1) + filetype=[".html",".png"] + #ThreeD=OneD + #print(OneD) + #print(len(BranchNames[0])) + print([BranchNames[i][j]+"_"+str(OneD[j])+"_"+filetype[OneD[j]] for j in range(len(BranchNames[i]))]) + makeHTML(outf,SubDirNames[i],SubDirNames[i],[BranchNames[i][j]+filetype[OneD[j]] for j in range(len(BranchNames[i]))],BranchNames[i],1) +makeHTML(outf,"master","Master",[SubDirNames[i]+".html" for i in range(len(SubDirNames))],SubDirNames,1) diff --git a/plotUtils/makeHTML2.py b/plotUtils/makeHTML2.py new file mode 100755 index 000000000..f3455ea76 --- /dev/null +++ b/plotUtils/makeHTML2.py @@ -0,0 +1,257 @@ +import ROOT as r +from ROOT import TCanvas,TH1F,TH2F,TH2D,TLegend,THStack +import os,sys,glob +import numpy as np +import argparse + +print("HOLLO") + +def makeHTML(outDir,filename,title,plots,branchnames,mode):#,selection): + print("DID I COME HERE") + os.chdir(outDir) + outfilebase = os.path.split(outDir)[1] + f = open(filename+'.html',"w+") + f.write("\n") + f.write("\n") + f.write(""+ title +" \n") + f.write("\n") + f.write("\n") + for i in range(0,len(plots)): + pname = "" + offset = 1 + if i==0 or i%2==0: + f.write("\n") + if mode==0: + f.write("\n") + if mode==1: + if plots[i][len(plots[i])-1]=="l": + f.write("\n") + else: + f.write("\n") + if i==offset: + f.write("\n") + elif (i>offset and (i-offset)%2==0) or i==len(plots): + f.write("\n") + f.write("
\"""+branchnames[i]+"\""
\n") + f.write("\n") + f.write("") + f.close() + path_parent=os.path.dirname(os.getcwd()) + os.chdir(path_parent) + +def buildLegend(canvas,x1=0.50, y1=0.60,x2=0.70,y2=0.8,textsize=0.025,separation=0.1,fill=0,border=0): + #canvas.cd() + legend = canvas.BuildLegend(x1,y1,x2,y2) + legend.Draw() + legend.SetTextSize(textsize) + #legend.SetEntrySeparation(separation) + #legend.SetFillStyle(fill) + legend.SetFillColorAlpha(r.kGray,0.7) + legend.SetBorderSize(border) + +def format1DPlot(plot, name, title = "",linecolor = 1, linewidth = 2, linestyle = 1): + plot.SetLineWidth(linewidth) + plot.SetLineColor(linecolor) + plot.SetLineStyle(linestyle) + plot.SetName(name) + if title != "": + plot.SetTitle(title) + +def getStatsYPositions(nplots): + start = 1.0 + end = 0.1 + height = (start-end)/nplots + if height > 0.1: + height = 0.1 + #ypositions = list(range(start,end,height)) + ypositions = np.arange(end,start,height) + ypositions= np.flipud(ypositions) + print(ypositions) + return ypositions,height + + +def setStatsBox(plot,xpos=0.9,ypos=0.9,height=0.2,width=0.1,linecolor=r.kBlack,color=r.kWhite,alpha=0.8): + r.gPad.Update() + stats = plot.GetListOfFunctions().FindObject("stats") + stats.SetFillColorAlpha(color,alpha) + stats.SetLineColor(linecolor) + r.gStyle.SetStatY(ypos) + r.gStyle.SetStatH(height) + r.gStyle.SetStatW(width) + r.gStyle.SetStatX(xpos) + r.gPad.Update() + +def savePlotAsPNG(plot, plot_dir, drawOptions=""): + c = r.TCanvas(plot.GetName(),plot.GetName(),1800,900) + c.cd() + plot.Draw("%s"%(drawOptions)) + setStatsBox(plot,xpos=0.8,ypos=0.8) + c.Update() + c.SaveAs("%s/%s.png"%(plot_dir,plot.GetName())) + #r.gPad.Update() + c.Close() + +def overlay1DPlots(plots,outf,c,canvas_name,legend_names = []): + #statsbox formatting + statspositions,height = getStatsYPositions(len(plots)) + + ymax = -99999 + for i,plot in enumerate(plots): + ymaxi = plot.GetMaximum() + if ymaxi > ymax: + ymax = ymaxi + + + #c = r.TCanvas("%s"%(canvas_name),"%s"%(canvas_name),1800,1000) + c.cd() + + #set yaxis + for i,plot in enumerate(plots): + plot.GetYaxis().SetRangeUser(0.00001,ymax*1.1) + if i < 1: + plot.Draw("hist") + setStatsBox(plot,ypos=statspositions[i],height=height,linecolor=colors[i]) + else: + plot.Draw("histsames") + setStatsBox(plot,ypos=statspositions[i],height=height,linecolor=colors[i]) + + if len(legend_names) > 0: + for i, plot in enumerate(plots): + plot.SetTitle(legend_names[i]) + + buildLegend(c) + plots[0].SetTitle(canvas_name) + c.SaveAs(outf+"/"+canvas_name+".png","png") + #r.gPad.Update() + c.Close() + +parser = argparse.ArgumentParser(description="The baseConfig options for plotHistDir") + +parser.add_argument("-i","--inFileBase",type=str,dest="inf",action='store',help="input file base, use when files are in the same directory", default=None) +parser.add_argument("-o","--outFileBase",type=str,dest="outf",action='store',help="Generates Pictures and HTML Webpage Here", default=None) +parser.add_argument("-r","--ratioEnable",type=int,dest="ratio",action='store',help="Enables Ratio Curves", default=0) +parser.add_argument("-mc","--mcFileBase",type=str,dest="mc",action='store',help="Enables MC and Takes in Curves", default="Nope") +parser.add_argument("-l","--list",nargs=4,type=float,dest="leglist",action='store',help="Relocates the Legend",default=[.73,.32,.97,.53]) + +options = parser.parse_args() +inf=options.inf +outf=options.outf +R=(options.ratio==1)#or(not(options.mc=='Nope')) +MC=options.mc +leglist=options.leglist +print(leglist) +#treeNum=options.treeNum +#branchNum=options.branchNum + +colors = [r.kBlack,r.kRed,r.kBlue,r.kGreen+2,r.kOrange-2] +#legends=["",""] + +#print(os.listdir(inf)) + +inFileList=os.listdir(inf) +if (not(options.mc=='Nope')): + mcFileList=os.listdir(MC) +if R: + inFileList=inFileList[:2] +r.gROOT.SetBatch(1) + +DFS=r.TFile(inf+"/"+inFileList[0])#DirectoryForSize +SubDirs=[] +SubDirNames=[] +for i in range(0,len(DFS.GetListOfKeys())): + print(type(DFS.Get(DFS.GetListOfKeys().At(i).GetName()))) + if(len(str(type(DFS.Get(DFS.GetListOfKeys().At(i).GetName()))))==45): + SubDirs.append(DFS.Get(DFS.GetListOfKeys().At(i).GetName())) + SubDirNames.append(DFS.GetListOfKeys().At(i).GetName()) + +BranchNames=[[SubDirs[i].GetListOfKeys().At(j).GetName() for j in range(len(SubDirs[i].GetListOfKeys()))] for i in range(len(SubDirs))] +#OneD=[] +print(SubDirNames) + + + +#FIRST THE MODULE HTMLS +#THEN THE REGIONS SubDirs/SubDirNames +#THEN THE TYPE OF HIST +#THEN PHASES + +Layers=[] +for j in range(len(SubDirs[i].GetListOfKeys())): + word=SubDirs[0].GetListOfKeys().At(j).GetName() + word=word[word.find('L'):] + Layers.append(word) +print(Layers) + +#for i in range(len(SubDirs)): +# OneD=[] +# for j in range(len(SubDirs[i].GetListOfKeys())): +# #print(BranchNames[i][j]) +# c=r.TCanvas() +# leg = TLegend(leglist[0],leglist[1],leglist[2],leglist[3])#TLegend(.73,.32,.97,.53) +# DFSnow=r.TFile(inf+"/"+inFileList[0]) +# Entry=DFSnow.Get(SubDirNames[i]+"/"+BranchNames[i][j]) +# is2d=(type(Entry)==TH2D) +# #print(is2d) +# try: +# if (not(is2d))and(not(options.mc=='Nope')): +# for I in range(len(mcFileList)): +# DFSnow=r.TFile(MC+"/"+mcFileList[I]) +# Entry=DFSnow.Get(SubDirNames[i]+"/"+BranchNames[i][j]) +# Entry.SetDirectory(0) +# ths1.Add(Entry) +# ths1.Draw("stack") +# print("hello") +# except: +# print("Failed at "+BranchNames[i][j]) +# if R and not(is2d): +# c.Divide(1,2) +# c.cd(1) +# plots=[] +# for I in range(len(inFileList)): +# DFSnow=r.TFile(inf+"/"+inFileList[I]) +# Entry=DFSnow.Get(SubDirNames[i]+"/"+BranchNames[i][j]) +# if is2d: +# Entry.SetTitle(inFileList[I]) +# Entry.Draw("colz") +# c.Print(outf+"/pic"+str(i)+"_"+str(j)+"_"+str(I)+".png","png") +# c.Clear() +# continue +# Entry.SetDirectory(0) +# Entry.SetLineColor(colors[I%5]) +# if options.mc=='Nope': +# leg.AddEntry(Entry,inFileList[I],"L") +# plots.append(Entry) +# #Entry.Draw("colz same") +# #overlay1DPlots() +# +# try: +# if R and not(is2d): +# c.cd(2) +# f1=r.TFile(inf+"/"+inFileList[0]) +# Entry1=f1.Get(SubDirNames[i]+"/"+BranchNames[i][j]) +# Entry1.SetDirectory(0) +# f2=r.TFile(inf+"/"+inFileList[1]) +# Entry2=f2.Get(SubDirNames[i]+"/"+BranchNames[i][j]) +# Entry2.Divide(Entry1) +# #print("hello") +# Entry2.Draw("colz") +# except: +# print("Failed on 1D Histogram for "+BranchNames[i][j]) +# if is2d: +# makeHTML(outf,BranchNames[i][j],BranchNames[i][j],["pic"+str(i)+"_"+str(j)+"_"+str(I)+".png" for I in range(len(inFileList))],[],0) +# print("hello") +# OneD.append(0) +# else: +# overlay1DPlots(plots,outf,c,BranchNames[i][j],inFileList) +# #leg.Draw() +# #c.Print(outf+"/"+BranchNames[i][j]+".png","png") +# c.Clear() +# OneD.append(1) +# filetype=[".html",".png"] +# #ThreeD=OneD +# #print(OneD) +# #print(len(BranchNames[0])) +# print([BranchNames[i][j]+"_"+str(OneD[j])+"_"+filetype[OneD[j]] for j in range(len(BranchNames[i]))]) +# makeHTML(outf,SubDirNames[i],SubDirNames[i],[BranchNames[i][j]+filetype[OneD[j]] for j in range(len(BranchNames[i]))],BranchNames[i],1) +#makeHTML(outf,"master","Master",[SubDirNames[i]+".html" for i in range(len(SubDirNames))],SubDirNames,1) diff --git a/processing/src/ConfigurePython.cxx b/processing/src/ConfigurePython.cxx index 67dd17a04..6ad55df14 100644 --- a/processing/src/ConfigurePython.cxx +++ b/processing/src/ConfigurePython.cxx @@ -300,10 +300,11 @@ ConfigurePython::~ConfigurePython() { Process* ConfigurePython::makeProcess() { Process* p = new Process(); + std::cout<<"WAS IT HERE THAT I BROKE 1"<Get("HPS_Event"); + std::cout<<"DID I BREAK HERE IN HPSEVENT1"<setupEvent(&event); } + std::cout<<"AM I RUNNING THIS PART 2"<initialize(event.getTree()); module->setFile(file->getOutputFile()); diff --git a/processing/src/hpstr.cxx b/processing/src/hpstr.cxx index 139bf60a1..a934f19f3 100644 --- a/processing/src/hpstr.cxx +++ b/processing/src/hpstr.cxx @@ -52,7 +52,8 @@ int main(int argc, char **argv) { std::cout << "---- [ hpstr ]: Configuration load complete --------" << std::endl; Process* p = cfg.makeProcess(); - int run_mode = p->getRunMode(); + std::cout << "I MANAGED TO MAKE THE PROCESS" << std::endl; + int run_mode = p->getRunMode(); std::cout << "---- [ hpstr ]: Process mode " << run_mode << " initialized. --------" << std::endl; diff --git a/processors/config/clustersOnTracks.py b/processors/config/clustersOnTracks.py index 8a81d820f..fbde7dcb8 100644 --- a/processors/config/clustersOnTracks.py +++ b/processors/config/clustersOnTracks.py @@ -1,17 +1,20 @@ import HpstrConf import sys,os -#import baseConfig as base +import baseConfig as base +#options = base.parser.parse_args() + #base.parser.add_argument('-b', '--baselines', type=str, dest="baselines",default="", # help="input offline baseline analysis root file") # Use the input file to set the output file name -infilename = sys.argv[1].strip() -outfilename = sys.argv[2].strip() +#infilename = sys.argv[1].strip() +#outfilename = sys.argv[2].strip() -#options = base.parser.parse_args() -#infilename = options.inFilename -#outfilename = options.outFilename + +options = base.parser.parse_args() +infilename = options.inFilename +outfilename = options.outFilename print('Input file: %s' % infilename) print('Output file: %s' % outfilename) @@ -34,10 +37,10 @@ clusters.parameters["debug"] = 1 clusters.parameters["anaName"] = 'anaClusOnTrk' clusters.parameters["trkColl"] = 'KalmanFullTracks' -#clusters.parameters["BaselineFits"] = "/home/alic/HPS/projects/baselines/jlab/clusters_on_track/" -clusters.parameters["BaselineFits"] = "/home/alic/HPS/projects/baselines/jlab/clusters_on_track/hps_14552_offline_analysis.root" +clusters.parameters["BaselineFits"] = ""#/home/alic/HPS/projects/baselines/jlab/clusters_on_track/" +#clusters.parameters["BaselineFits"] = "/home/alic/HPS/projects/baselines/jlab/clusters_on_track/hps_14552_offline_analysis.root" #clusters.parameters["BaselineFits"] = options.baselines -clusters.parameters["BaselineRun"] = "010705" +clusters.parameters["BaselineRun"] = "014552" p.sequence = [clusters] diff --git a/processors/config/fitBL_cfg.py b/processors/config/fitBL_cfg.py index d2bd8b2ea..973d6695a 100644 --- a/processors/config/fitBL_cfg.py +++ b/processors/config/fitBL_cfg.py @@ -58,7 +58,8 @@ def timeSample_callback(options, opt, value, parser): # Processor Configuration # ############################### fitBL.parameters["histCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/svt/SvtBlFits.json' -fitBL.parameters["rawhitsHistCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/svt/baselinefits/rawSvtHits.json' +p +fitBL.parameters["rawhitsHistCfg"] = '/sdf/group/hps/users/alspellm/src/hpstr/analysis/plotconfigs/svt/baselinefits/rawSvtHits_old.json' #fitBL.parameters["rawhitsHistCfg"] = os.environ['HPSTR_BASE']+'/analysis/plotconfigs/svt/baselinefits/rawSvtHits_old.json' fitBL.parameters["layer"] = options.layer fitBL.parameters["rebin"] = options.rebin diff --git a/processors/config/kalSimpTuple_cfg.py b/processors/config/kalSimpTuple_cfg.py old mode 100644 new mode 100755 index fb61a879a..0dc69bcad --- a/processors/config/kalSimpTuple_cfg.py +++ b/processors/config/kalSimpTuple_cfg.py @@ -85,7 +85,7 @@ track.parameters["trkCollRoot"] = 'KalmanFullTracks' track.parameters["kinkRelCollLcio"] = '' track.parameters["trkRelCollLcio"] = 'KFTrackDataRelations' -track.parameters["trkhitCollRoot"] = 'SiClustersOnTrack' +track.parameters["trkhitCollRoot"] = 'SiClustersOnTrack_KF' track.parameters["hitFitsCollLcio"] = 'SVTFittedRawTrackerHits' #Only for detail studies @@ -171,32 +171,33 @@ fsp.parameters["trkRelCollLcio"] = "KFTrackDataRelations" -if(options.tracking == "KF"): - sequence = []#header, vtx, ecal, track] - #Get KF svt truth hits - if(options.truthHits > 0): - sequence.append(svthits) -elif(options.tracking == "GBL"): - sequence = []#header, vtxgbl, ecal, trackgbl] - #Get GBL svt truth hits - if(options.truthHits > 0): - sequence.append(svthitsgbl) -elif(options.tracking == "BOTH"): - sequence = []#header, vtxgbl, trackgbl, vtx, ecal, track] - #Get KF and GBL svt truth hits - if(options.truthHits > 0): - sequence.append(svthits) - sequence.append(svthitsgbl) -else: - print("ERROR::Need to specify which tracks KF, GBL, or BOTH") - -#Keep svt raw hits -if(options.rawHits > 0): - sequence.append(rawsvt) -#If MC, get MCParticles -if(not options.isData): - sequence.append(mcpart) -sequence.append(fsp) + +sequence = [header, track, svthits, rawsvt] +#if(options.tracking == "KF"): +# #Get KF svt truth hits +# if(options.truthHits > 0): +# sequence.append(svthits) +#elif(options.tracking == "GBL"): +# #sequence = []#header, vtxgbl, ecal, trackgbl] +# #Get GBL svt truth hits +# if(options.truthHits > 0): +# sequence.append(svthitsgbl) +#elif(options.tracking == "BOTH"): +# #sequence = []#header, vtxgbl, trackgbl, vtx, ecal, track] +# #Get KF and GBL svt truth hits +# if(options.truthHits > 0): +# sequence.append(svthits) +# sequence.append(svthitsgbl) +#else: +# print("ERROR::Need to specify which tracks KF, GBL, or BOTH") +# +##Keep svt raw hits +#if(options.rawHits > 0): +# sequence.append(rawsvt) +##If MC, get MCParticles +#if(not options.isData): +# sequence.append(mcpart) +#sequence.append(fsp) p.sequence = sequence diff --git a/processors/config/rawSvtAnaHits_cfg.py b/processors/config/rawSvtAnaHits_cfg.py index a5eae7148..6a112d890 100644 --- a/processors/config/rawSvtAnaHits_cfg.py +++ b/processors/config/rawSvtAnaHits_cfg.py @@ -71,7 +71,7 @@ RegionPath+'TimeResolution.json' ] -rawAnaSvt.parameters["MatchList"] = ['OneFit','CTFit','SecondFitTimeCT'] +rawAnaSvt.parameters["MatchList"] = ['OneFit','CTFit','SecondFit'] rawAnaSvt.parameters["timeref"]=0.0 rawAnaSvt.parameters["ampref"]=0.0 diff --git a/processors/config/recoTuple_cfg.py b/processors/config/recoTuple_cfg.py index 10159640b..4f28e0f78 100644 --- a/processors/config/recoTuple_cfg.py +++ b/processors/config/recoTuple_cfg.py @@ -31,6 +31,9 @@ trackgbl = HpstrConf.Processor('trackgbl', 'TrackingProcessor') trackrefitgbl = HpstrConf.Processor('trackrefitgbl', 'TrackingProcessor') svthits = HpstrConf.Processor('svthits', 'Tracker3DHitProcessor') + +svthits2 = HpstrConf.Processor('svthitskf', 'Tracker2DHitProcessor') + rawsvt = HpstrConf.Processor('rawsvt', 'SvtRawDataProcessor') ecal = HpstrConf.Processor('ecal', 'ECalDataProcessor') vtx = HpstrConf.Processor('vtx', 'VertexProcessor') @@ -44,7 +47,7 @@ # Processor Configuration # ############################### #Event -header.parameters["debug"] = 0 +header.parameters["debug"] = 1 header.parameters["headCollRoot"] = "EventHeader" header.parameters["trigCollLcio"] = "TriggerBank" header.parameters["rfCollLcio"] = "RFHits" @@ -54,19 +57,25 @@ header.parameters["tsCollRoot"] = "TSBank" #SvtRawData -rawsvt.parameters["debug"] = 0 +rawsvt.parameters["debug"] = 1 rawsvt.parameters["hitCollLcio"] = 'SVTRawTrackerHits' rawsvt.parameters["hitfitCollLcio"] = 'SVTFittedRawTrackerHits' rawsvt.parameters["hitCollRoot"] = 'SVTRawTrackerHits' #Tracker3DHits -svthits.parameters["debug"] = 0 +svthits.parameters["debug"] = 1 svthits.parameters["hitCollLcio"] = 'RotatedHelicalTrackHits' svthits.parameters["hitCollRoot"] = 'RotatedHelicalTrackHits' +#Tracker2DHits + +svthits2.parameters["debug"] = 1 +svthits2.parameters["hitCollLcio"] = 'StripClusterer_SiTrackerHitStrip1D' +svthits2.parameters["hitCollRoot"] = 'SiClusters' +svthits2.parameters["mcPartRelLcio"] = 'SVTTrueHitRelations' #Tracking -track.parameters["debug"] = 0 +track.parameters["debug"] = 1 track.parameters["trkCollLcio"] = 'KalmanFullTracks' track.parameters["trkCollRoot"] = 'KalmanFullTracks' track.parameters["kinkRelCollLcio"] = '' @@ -77,7 +86,7 @@ track.parameters["bfield"] = bfield[str(options.year)] -trackgbl.parameters["debug"] = 0 +trackgbl.parameters["debug"] = 1 trackgbl.parameters["trkCollLcio"] = 'GBLTracks' trackgbl.parameters["trkCollRoot"] = 'GBLTracks' trackgbl.parameters["kinkRelCollLcio"] = 'GBLKinkDataRelations' @@ -92,21 +101,21 @@ # trackgbl.parameters["truthTrackCollRoot"] = 'Truth_GBLTracks' #ECalData -ecal.parameters["debug"] = 0 +ecal.parameters["debug"] = 1 ecal.parameters["hitCollLcio"] = 'EcalCalHits' ecal.parameters["hitCollRoot"] = 'RecoEcalHits' ecal.parameters["clusCollLcio"] = "EcalClustersCorr" ecal.parameters["clusCollRoot"] = "RecoEcalClusters" #Vertex -vtx.parameters["debug"] = 0 +vtx.parameters["debug"] = 1 vtx.parameters["vtxCollLcio"] = 'UnconstrainedV0Vertices_KF' vtx.parameters["vtxCollRoot"] = 'UnconstrainedV0Vertices_KF' vtx.parameters["partCollRoot"] = 'ParticlesOnVertices_KF' vtx.parameters["kinkRelCollLcio"] = '' vtx.parameters["trkRelCollLcio"] = 'KFTrackDataRelations' -cvtxgbl.parameters["debug"] = 0 +cvtxgbl.parameters["debug"] = 1 cvtxgbl.parameters["vtxCollLcio"] = 'TargetConstrainedV0Vertices_KF' cvtxgbl.parameters["vtxCollRoot"] = 'TargetConstrainedV0Vertices_KF' cvtxgbl.parameters["partCollRoot"] = 'ParticlesOnVertices_KF' @@ -114,14 +123,14 @@ cvtxgbl.parameters["trkRelCollLcio"] = 'KFTrackDataRelations' -vtxgbl.parameters["debug"] = 0 +vtxgbl.parameters["debug"] = 1 vtxgbl.parameters["vtxCollLcio"] = 'UnconstrainedV0Vertices' vtxgbl.parameters["vtxCollRoot"] = 'UnconstrainedV0Vertices' vtxgbl.parameters["partCollRoot"] = 'ParticlesOnVertices' vtxgbl.parameters["kinkRelCollLcio"] = 'GBLKinkDataRelations' vtxgbl.parameters["trkRelCollLcio"] = 'TrackDataRelations' -cvtxgbl.parameters["debug"] = 0 +cvtxgbl.parameters["debug"] = 1 cvtxgbl.parameters["vtxCollLcio"] = 'TargetConstrainedV0Vertices' cvtxgbl.parameters["vtxCollRoot"] = 'TargetConstrainedV0Vertices' cvtxgbl.parameters["partCollRoot"] = 'ParticlesOnVertices' @@ -129,12 +138,12 @@ cvtxgbl.parameters["trkRelCollLcio"] = 'TrackDataRelations' #MCParticle -mcpart.parameters["debug"] = 0 +mcpart.parameters["debug"] = 1 mcpart.parameters["mcPartCollLcio"] = 'MCParticle' mcpart.parameters["mcPartCollRoot"] = 'MCParticle' #FinalStateParticleProcessor -fsp.parameters["debug"] = 0 +fsp.parameters["debug"] = 1 fsp.parameters["fspCollLcio"] = "FinalStateParticles_KF" fsp.parameters["fspCollRoot"] = "FinalStateParticles_KF" fsp.parameters["kinkRelCollLcio"] = "" @@ -144,11 +153,12 @@ # Sequence which the processors will run. if options.isData == -1: print("Please specficy if this is Data or not via option -t") -if (not options.isData): - p.sequence = [header, vtx, cvtx, vtxgbl, cvtxgbl, ecal, track, trackgbl, mcpart] -else: - p.sequence = [header, vtx, cvtx, vtxgbl, cvtxgbl, ecal, track, trackgbl, fsp] +#if (not options.isData): +# p.sequence = [header, vtx, cvtx, vtxgbl, cvtxgbl, ecal, track, trackgbl, mcpart] +#else: + #p.sequence = [header, vtx, cvtx, vtxgbl, cvtxgbl, ecal, track, trackgbl, fsp] #p.sequence = [header, vtx, ecal, track] +p.sequence = [header,svthits2,fsp] p.input_files = lcio_file p.output_files = [root_file] diff --git a/processors/config/roryClusterAna.py b/processors/config/roryClusterAna.py new file mode 100755 index 000000000..812db21e7 --- /dev/null +++ b/processors/config/roryClusterAna.py @@ -0,0 +1,56 @@ +import HpstrConf +import sys +import baseConfig as base +from baseConfig import bfield + +base.parser.add_argument("-L", "--layer", type=int, dest="layer", + help="Layer Under Investigation", metavar="layer",default=-1) +base.parser.add_argument("-M", "--module", type=int, dest="module", + help="Module Under Investigation", metavar="module",default=-1) +base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", + help="IS IT MC", metavar="module",default=0) +base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", + help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) +base.parser.add_argument("-cut", "--cut", type=float, dest="cut", + help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) + + +options = base.parser.parse_args() + +# Use the input file to set the output file name +root_file = options.inFilename +ana_file = options.outFilename + +#print('LCIO file: %s' % root_file) +#print('Root file: %s' % ana_file) + +p = HpstrConf.Process() + +#p.max_events = 1000 +p.run_mode = 1 +p.skip_events = options.skip_events +p.max_events = options.nevents + +# Library containing processors +p.add_library("libprocessors") + +############################### +# Processors # +############################### +rclu = HpstrConf.Processor('rclu','RoryClusterAnaProcessor') +rclu.parameters["debug"] = 0 +rclu.parameters["layer"] = options.layer +rclu.parameters["module"] = options.module +rclu.parameters["isMC"] = options.isMC +rclu.parameters["doTrack"] = options.doTrack +rclu.parameters["cut"] = options.cut + +sequence = [rclu] + +p.sequence = sequence + +print("THE INPUT FILE IS "+str(root_file)) +p.input_files = root_file +p.output_files = [ana_file] + +p.printProcess() diff --git a/processors/config/roryClusterCompareAna.py b/processors/config/roryClusterCompareAna.py new file mode 100755 index 000000000..a3d05995d --- /dev/null +++ b/processors/config/roryClusterCompareAna.py @@ -0,0 +1,64 @@ +import HpstrConf +import sys +import baseConfig as base +from baseConfig import bfield + +base.parser.add_argument("-L", "--layer", type=int, dest="layer", + help="Layer Under Investigation", metavar="layer",default=-1) +base.parser.add_argument("-M", "--module", type=int, dest="module", + help="Module Under Investigation", metavar="module",default=-1) +base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", + help="IS IT MC", metavar="module",default=0) +base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", + help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) +base.parser.add_argument("-cut", "--cut", type=float, dest="cut", + help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) +base.parser.add_argument("-fn1", "--fn1", type=str, dest="fileName1", + help="Name for the First File", metavar="fileName1",default="") +base.parser.add_argument("-fn2", "--fn2", type=str, dest="fileName2", + help="Name for the Second File", metavar="fileName2",default="") + + + + +options = base.parser.parse_args() + +# Use the input file to set the output file name +root_files = [options.fileName1]#,options.fileName2] +ana_file = options.outFilename + +#print('LCIO file: %s' % root_file) +#print('Root file: %s' % ana_file) + +p = HpstrConf.Process() + +#p.max_events = 1000 +p.run_mode = 2 +p.skip_events = options.skip_events +p.max_events = options.nevents + +# Library containing processors +p.add_library("libprocessors") + +############################### +# Processors # +############################### +rcclu = HpstrConf.Processor('rclu','RoryClusterCompareAnaProcessor') +rcclu.parameters["debug"] = 0 +rcclu.parameters["layer"] = options.layer +rcclu.parameters["module"] = options.module +rcclu.parameters["isMC"] = options.isMC +rcclu.parameters["doTrack"] = options.doTrack +rcclu.parameters["cut"] = options.cut +rcclu.parameters["fileName1"] = options.fileName1 +rcclu.parameters["fileName2"] = options.fileName2 + +sequence = [rcclu] + +p.sequence = sequence + +print("THE INPUT FILES ARE "+str(options.fileName1)+" AND "+str(options.fileName2)) +p.input_files = root_files +p.output_files = [ana_file] + +p.printProcess() diff --git a/processors/config/roryClusterCompareSeedAna.py b/processors/config/roryClusterCompareSeedAna.py new file mode 100755 index 000000000..243e710ad --- /dev/null +++ b/processors/config/roryClusterCompareSeedAna.py @@ -0,0 +1,64 @@ +import HpstrConf +import sys +import baseConfig as base +from baseConfig import bfield + +base.parser.add_argument("-L", "--layer", type=int, dest="layer", + help="Layer Under Investigation", metavar="layer",default=-1) +base.parser.add_argument("-M", "--module", type=int, dest="module", + help="Module Under Investigation", metavar="module",default=-1) +base.parser.add_argument("-MC", "--MC", type=int, dest="isMC", + help="IS IT MC", metavar="module",default=0) +base.parser.add_argument("-doT", "--doT", type=int, dest="doTrack", + help="DO WE DO TRACK STUFF", metavar="doTrack",default=0) +base.parser.add_argument("-cut", "--cut", type=float, dest="cut", + help="Momentum Cut for NShared Profile", metavar="cut",default=-1.0) +base.parser.add_argument("-fn1", "--fn1", type=str, dest="fileName1", + help="Name for the First File", metavar="fileName1",default="") +base.parser.add_argument("-fn2", "--fn2", type=str, dest="fileName2", + help="Name for the Second File", metavar="fileName2",default="") + + + + +options = base.parser.parse_args() + +# Use the input file to set the output file name +root_files = [options.fileName1]#,options.fileName2] +ana_file = options.outFilename + +#print('LCIO file: %s' % root_file) +#print('Root file: %s' % ana_file) + +p = HpstrConf.Process() + +#p.max_events = 1000 +p.run_mode = 2 +p.skip_events = options.skip_events +p.max_events = options.nevents + +# Library containing processors +p.add_library("libprocessors") + +############################### +# Processors # +############################### +rcclu = HpstrConf.Processor('rclu','RoryClusterCompareSeedAnaProcessor') +rcclu.parameters["debug"] = 0 +rcclu.parameters["layer"] = options.layer +rcclu.parameters["module"] = options.module +rcclu.parameters["isMC"] = options.isMC +rcclu.parameters["doTrack"] = options.doTrack +rcclu.parameters["cut"] = options.cut +rcclu.parameters["fileName1"] = options.fileName1 +rcclu.parameters["fileName2"] = options.fileName2 + +sequence = [rcclu] + +p.sequence = sequence + +print("THE INPUT FILES ARE "+str(options.fileName1)+" AND "+str(options.fileName2)) +p.input_files = root_files +p.output_files = [ana_file] + +p.printProcess() diff --git a/processors/include/RoryClusterAnaProcessor.h b/processors/include/RoryClusterAnaProcessor.h new file mode 100644 index 000000000..e1aee9014 --- /dev/null +++ b/processors/include/RoryClusterAnaProcessor.h @@ -0,0 +1,168 @@ +#ifndef __RORYCLUSTER_ANAPROCESSOR_H__ +#define __RORYCLUSTER_ANAPROCESSOR_H__ + +//HPSTR +#include "HpsEvent.h" +#include "RawSvtHit.h" +#include "TrackerHit.h" +#include "RawSvtHitHistos.h" +#include "AnaHelpers.h" +#include "Event.h" +#include "BaseSelector.h" +#include "RawSvtHitHistos.h" +#include "EventHeader.h" +#include "VTPData.h" +#include "TSData.h" +#include "CalCluster.h" +#include "Track.h" +#include "TrackerHit.h" +#include "Collections.h" +//#include " +//ROOT + +#include "Processor.h" +#include "TClonesArray.h" +#include "TBranch.h" +#include "TTree.h" +#include "TFile.h" +#include "TF1.h" +#include "TGraphErrors.h" +#include "TAxis.h" +#include "TROOT.h" +#include "TPad.h" +#include "TCanvas.h" +#include "TLegend.h" +#include "TProfile.h" + +class TTree; + + +class RoryClusterAnaProcessor : public Processor { + + public: + + RoryClusterAnaProcessor(const std::string& name, Process& process); + + ~RoryClusterAnaProcessor(); + + virtual bool process(IEvent* ievent); + + virtual void initialize(TTree* tree); + + virtual void Plot1(); + + virtual void Plot2(); + + virtual void Plot3(); + + virtual void Plot4(); + + virtual void Plot5(); + + virtual void Plot6(); + + virtual void Plot7(); + + virtual void TrackPlot1(); + + virtual void SplittingPlots(); + + virtual void WriteRoot(); + + //virtual void ClusterFit(); + + virtual void fillDeads(); + + virtual int GetStrip(int feb, int hyb,int strip); + + //virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); + + //virtual int hitEff(IEvent* ievent, int L); + + //virtual TF1* fourPoleFitFunction(std::string word, int caser); + + //virtual float str_to_float(std::string word); + + //float reverseEngineerTime(float ti, long t); + + //virtual int maximum(int arr[]); + + virtual void finalize(); + + virtual void configure(const ParameterSet& parameters); + + private: + + //Containers to hold histogrammer info + //RawSvtHitHistos* histos{nullptr}; + ModuleMapper * mmapper_; + + TTree* tree_; + TBranch* bClusters_{nullptr}; + TBranch* bClustersKF_{nullptr}; + TBranch* bsvtraw_{nullptr}; + TBranch* btracks_{nullptr}; + + int layer_{-1}; + int module_{-1}; + + TH1F* layers_; + TH1F* layersOnTrk_; + TH1F* layersOffTrk_; + TH1F* charges_; + TH1F* chargesOnTrk_; + TH1F* chargesOffTrk_; + + TH1F* layersNTD_; + TH1F* layersOnTrkNTD_; + TH1F* layersOffTrkNTD_; + TH1F* chargesNTD_; + TH1F* chargesOnTrkNTD_; + TH1F* chargesOffTrkNTD_; + + TH1F* positions_; + TH1F* positionsOnTrk_; + TH1F* ClusDistances_; + TH1F* ClusDistancesNTD_; + + TH1F* times_; + TH1F* timesOnTrk_; + TH1F* timesOffTrk_; + TH1F* timesNTD_; + TH1F* timesOnTrkNTD_; + TH1F* timesOffTrkNTD_; + + //TRACKING RELATED VARIABLES + + TH2F* Z0VNShare2Hist_; + TH2F* Z0VNShare2HistCut_; + TH1F* SharedAmplitudes_; + TH1F* UnSharedAmplitudes_; + TH1F* SharedTimes_; + TH1F* UnSharedTimes_; + + TH1F* WandShared_; + TH2F* statusLR_; + TH2F* statusNTD_; + TH1F* StripOcc_; + TH1F* StripOccOnTrk_; + + float pcut_{-1.0}; + + bool doingTracks_{false}; + + float Deads_[24576]; + float Deads2_[24576]; + + std::vector * Clusters_{}; + std::vector * ClustersKF_{}; + std::vector * svtraw_{}; + std::vector * tracks_{}; + + + //std::string anaName_{"roryClusterAna"}; + int debug_{0}; + int isMC_{0}; +}; + +#endif diff --git a/processors/include/RoryClusterCompareAnaProcessor.h b/processors/include/RoryClusterCompareAnaProcessor.h new file mode 100644 index 000000000..9d0985071 --- /dev/null +++ b/processors/include/RoryClusterCompareAnaProcessor.h @@ -0,0 +1,245 @@ +#ifndef __RORYCLUSTERCOMPARE_ANAPROCESSOR_H__ +#define __RORYCLUSTERCOMPARE_ANAPROCESSOR_H__ + +//HPSTR +#include "HpsEvent.h" +#include "RawSvtHit.h" +#include "TrackerHit.h" +#include "RawSvtHitHistos.h" +#include "AnaHelpers.h" +#include "Event.h" +#include "BaseSelector.h" +#include "RawSvtHitHistos.h" +#include "EventHeader.h" +#include "VTPData.h" +#include "TSData.h" +#include "CalCluster.h" +#include "Track.h" +#include "TrackerHit.h" +#include "Collections.h" +#include "HpsEventFile.h" +#include "HpsEvent.h" + +//#include " +//ROOT + +#include "Processor.h" +#include "TClonesArray.h" +#include "TBranch.h" +#include "TTree.h" +#include "TFile.h" +#include "TF1.h" +#include "TGraphErrors.h" +#include "TAxis.h" +#include "TROOT.h" +#include "TPad.h" +#include "TCanvas.h" +#include "TLegend.h" +#include "TProfile.h" + +class TTree; + + +class RoryClusterCompareAnaProcessor : public Processor { + + public: + + RoryClusterCompareAnaProcessor(const std::string& name, Process& process); + + ~RoryClusterCompareAnaProcessor(); + + virtual bool process(); + + virtual bool process(IEvent* event) {return true;}; + + virtual void initialize(std::string inFilename, std::string outFilename); + + virtual void initialize(TTree* tree) {}; + + virtual void Plot1(); + + virtual void Plot2(); + + virtual void Plot3(); + + virtual void Plot4(); + + virtual void loop(IEvent* ievent1,IEvent* ievent2); + + virtual void WriteRoot(); + + //virtual void Plot5(); + + //virtual void Plot6(); + + //virtual void Plot7(); + + virtual void TrackPlot1(); + + virtual void TrackPlot2(); + + virtual void PlotShared1(); + + virtual void fillDeads(); + + virtual int GetStrip(int feb, int hyb,int strip); + + virtual void finalize(); + + virtual void configure(const ParameterSet& parameters); + + private: + + HpsEventFile* file1_{nullptr}; + HpsEventFile* file2_{nullptr}; + HpsEvent event1_; + HpsEvent event2_; + TTree* tree1_; + TTree* tree2_; + + //Containers to hold histogrammer info + //RawSvtHitHistos* histos{nullptr}; + ModuleMapper * mmapper_; + + TBranch* bClusters1_{nullptr}; + TBranch* bClustersKF1_{nullptr}; + TBranch* bsvtraw1_{nullptr}; + TBranch* btracks1_{nullptr}; + + TBranch* bClusters2_{nullptr}; + TBranch* bClustersKF2_{nullptr}; + TBranch* bsvtraw2_{nullptr}; + TBranch* btracks2_{nullptr}; + + + int layer_{-1}; + int module_{-1}; + + //FOR THE FIRST FILE + + TH1F* layers1_; + TH1F* layersOnTrk1_; + TH1F* layersOffTrk1_; + TH1F* charges1_; + TH1F* chargesOnTrk1_; + TH1F* chargesOffTrk1_; + TH2F* charges2D_; + + TH1F* layersNTD1_; + TH1F* layersOnTrkNTD1_; + TH1F* layersOffTrkNTD1_; + TH1F* chargesNTD1_; + TH1F* chargesOnTrkNTD1_; + TH1F* chargesOffTrkNTD1_; + + TH1F* positions1_; + TH1F* positionsOnTrk1_; + TH1F* ClusDistances1_; + TH1F* ClusDistancesNTD1_; + + TH1F* times1_; + TH1F* timesOnTrk1_; + TH1F* timesOffTrk1_; + TH1F* timesNTD1_; + TH1F* timesOnTrkNTD1_; + TH1F* timesOffTrkNTD1_; + + //FOR THE SECOND FILE + + TH1F* layers2_; + TH1F* layersOnTrk2_; + TH1F* layersOffTrk2_; + TH1F* charges2_; + TH1F* chargesOnTrk2_; + TH1F* chargesOffTrk2_; + + TH1F* layersNTD2_; + TH1F* layersOnTrkNTD2_; + TH1F* layersOffTrkNTD2_; + TH1F* chargesNTD2_; + TH1F* chargesOnTrkNTD2_; + TH1F* chargesOffTrkNTD2_; + + TH1F* positions2_; + TH1F* positionsOnTrk2_; + TH1F* ClusDistances2_; + TH1F* ClusDistancesNTD2_; + + TH1F* times2_; + TH1F* timesOnTrk2_; + TH1F* timesOffTrk2_; + TH1F* timesNTD2_; + TH1F* timesOnTrkNTD2_; + TH1F* timesOffTrkNTD2_; + + //SHARED DISTRIBUTIONS + + TH1F* DifferenceInPositions_; + TH1F* DifferenceInCharges_; + TH2F* DifferenceInPositionsVStripNo_; + TH2F* DifferenceInPositionVsCharge_; + TH2F* DifferenceInPositionVsChargeNTD_; + TH2F* MinComboPosition0_; + TH2F* MinComboPosition1_; + TH2F* MinComboPosition2_; + TH2F* MinComboChargeNTD_; + TH2F* DeltaTVsDeltaCharge_; + TH2F* DeltaTVsDeltaChargeV2_; + TH2F* ChargeShared2D_; + //TRACKING RELATED VARIABLES + + TH2F* Z0VNShare2Hist1_; + TH2F* Z0VNShare2HistCut1_; + TH1F* SharedAmplitudes1_; + TH1F* UnSharedAmplitudes1_; + TH1F* SharedTimes1_; + TH1F* UnSharedTimes1_; + TH1F* TrackMomentumInTime1_; + TH1F* TrackMomentumOutTime1_; + TH1F* TrackMomentumAllTime1_; + TH1F* TrackMomentumTInTime1_; + TH1F* TrackMomentumTOutTime1_; + TH1F* TrackMomentumTAllTime1_; + TH1F* HitsOnTrack1_; + + TH2F* Z0VNShare2Hist2_; + TH2F* Z0VNShare2HistCut2_; + TH1F* SharedAmplitudes2_; + TH1F* UnSharedAmplitudes2_; + TH1F* SharedTimes2_; + TH1F* UnSharedTimes2_; + TH1F* TrackMomentumInTime2_; + TH1F* TrackMomentumOutTime2_; + TH1F* TrackMomentumAllTime2_; + TH1F* TrackMomentumTInTime2_; + TH1F* TrackMomentumTOutTime2_; + TH1F* TrackMomentumTAllTime2_; + TH1F* HitsOnTrack2_; + + float pcut_{-1.0}; + + bool doingTracks_{false}; + + float Deads_[24576]; + + std::string fileOne_{""}; + + std::string fileTwo_{""}; + + std::vector * Clusters1_{}; + std::vector * ClustersKF1_{}; + std::vector * svtraw1_{}; + std::vector * tracks1_{}; + + std::vector * Clusters2_{}; + std::vector * ClustersKF2_{}; + std::vector * svtraw2_{}; + std::vector * tracks2_{}; + + //std::string anaName_{"roryClusterAna"}; + int debug_{0}; + int isMC_{0}; + float ident_{1.0}; +}; + +#endif diff --git a/processors/include/RoryClusterCompareSeedAnaProcessor.h b/processors/include/RoryClusterCompareSeedAnaProcessor.h new file mode 100644 index 000000000..deca84c15 --- /dev/null +++ b/processors/include/RoryClusterCompareSeedAnaProcessor.h @@ -0,0 +1,176 @@ +#ifndef __RORYCLUSTERCOMPARESEED_ANAPROCESSOR_H__ +#define __RORYCLUSTERCOMPARESEED_ANAPROCESSOR_H__ + +//HPSTR +#include "HpsEvent.h" +#include "RawSvtHit.h" +#include "TrackerHit.h" +#include "RawSvtHitHistos.h" +#include "AnaHelpers.h" +#include "Event.h" +#include "BaseSelector.h" +#include "RawSvtHitHistos.h" +#include "EventHeader.h" +#include "VTPData.h" +#include "TSData.h" +#include "CalCluster.h" +#include "Track.h" +#include "TrackerHit.h" +#include "Collections.h" +#include "HpsEventFile.h" +#include "HpsEvent.h" + +//#include " +//ROOT + +#include "Processor.h" +#include "TClonesArray.h" +#include "TBranch.h" +#include "TTree.h" +#include "TFile.h" +#include "TF1.h" +#include "TGraphErrors.h" +#include "TAxis.h" +#include "TROOT.h" +#include "TPad.h" +#include "TCanvas.h" +#include "TLegend.h" +#include "TProfile.h" + +class TTree; + + +class RoryClusterCompareSeedAnaProcessor : public Processor { + + public: + + RoryClusterCompareSeedAnaProcessor(const std::string& name, Process& process); + + ~RoryClusterCompareSeedAnaProcessor(); + + virtual bool process(); + + virtual bool process(IEvent* event) {return true;}; + + virtual void initialize(std::string inFilename, std::string outFilename); + + virtual void initialize(TTree* tree) {}; + + virtual void loop(IEvent* ievent1,IEvent* ievent2); + + virtual void WriteRoot(); + + + virtual void fillDeads(); + + virtual int GetStrip(int feb, int hyb,int strip); + + virtual void finalize(); + + virtual void configure(const ParameterSet& parameters); + + private: + + HpsEventFile* file1_{nullptr}; + HpsEventFile* file2_{nullptr}; + HpsEvent event1_; + HpsEvent event2_; + TTree* tree1_; + TTree* tree2_; + + //Containers to hold histogrammer info + //RawSvtHitHistos* histos{nullptr}; + ModuleMapper * mmapper_; + + TBranch* bClusters1_{nullptr}; + TBranch* bClustersKF1_{nullptr}; + TBranch* bsvtraw1_{nullptr}; + TBranch* btracks1_{nullptr}; + + TBranch* bClusters2_{nullptr}; + TBranch* bClustersKF2_{nullptr}; + TBranch* bsvtraw2_{nullptr}; + TBranch* btracks2_{nullptr}; + + + int layer_{-1}; + int module_{-1}; + bool helper_{false}; + float countWeird_{0.0}; + + //SHARED DISTRIBUTIONS + + TH1F* DifferenceInPositions_; + TH1F* DifferenceInCharges_; + TH2F* DifferenceInPositionsVStripNo_; + TH2F* DifferenceInPositionVsCharge_; + TH2F* DifferenceInPositionVsChargeNTD_; + TH2F* MinComboPosition0_; + TH2F* MinComboPosition1_; + TH2F* MinComboPosition2_; + TH2F* MinComboChargeNTD_; + TH2F* DeltaTVsDeltaCharge_; + TH2F* DeltaTVsDeltaChargeV2_; + TH2F* ChargeShared2D_; + //TRACKING RELATED VARIABLES + + TH2F* Z0VNShare2Hist1_; + TH2F* Z0VNShare2HistCut1_; + TH1F* SharedAmplitudes1_; + TH1F* UnSharedAmplitudes1_; + TH1F* SharedTimes1_; + TH1F* UnSharedTimes1_; + TH1F* TrackMomentumInTime1_; + TH1F* TrackMomentumOutTime1_; + TH1F* TrackMomentumAllTime1_; + TH1F* TrackMomentumTInTime1_; + TH1F* TrackMomentumTOutTime1_; + TH1F* TrackMomentumTAllTime1_; + + TH2F* Z0VNShare2Hist2_; + TH2F* Z0VNShare2HistCut2_; + TH1F* SharedAmplitudes2_; + TH1F* UnSharedAmplitudes2_; + TH1F* SharedTimes2_; + TH1F* UnSharedTimes2_; + TH1F* TrackMomentumInTime2_; + TH1F* TrackMomentumOutTime2_; + TH1F* TrackMomentumAllTime2_; + TH1F* TrackMomentumTInTime2_; + TH1F* TrackMomentumTOutTime2_; + TH1F* TrackMomentumTAllTime2_; + + TH2F* TwoTimes_; + TH1F* UnChangedTimes_; + TH2F* TwoCharges_; + TH1F* UnChangedCharges_; + TH1F* SharpPlot_; + TH2F* DidItAdd_; + + float pcut_{-1.0}; + + bool doingTracks_{false}; + + float Deads_[24576]; + + std::string fileOne_{""}; + + std::string fileTwo_{""}; + + std::vector * Clusters1_{}; + std::vector * ClustersKF1_{}; + std::vector * svtraw1_{}; + std::vector * tracks1_{}; + + std::vector * Clusters2_{}; + std::vector * ClustersKF2_{}; + std::vector * svtraw2_{}; + std::vector * tracks2_{}; + + //std::string anaName_{"roryClusterAna"}; + int debug_{0}; + int isMC_{0}; + float ident_{1.0}; +}; + +#endif diff --git a/processors/include/SvtRawDataAnaProcessor.h b/processors/include/SvtRawDataAnaProcessor.h index 00616e717..0b782e6d2 100644 --- a/processors/include/SvtRawDataAnaProcessor.h +++ b/processors/include/SvtRawDataAnaProcessor.h @@ -48,6 +48,8 @@ class SvtRawDataAnaProcessor : public Processor { virtual void initialize(TTree* tree); virtual void sample(RawSvtHit* thisHit, std::string word, IEvent* ievent, long t,int i); + + //virtual int hitEff(IEvent* ievent, int L); virtual TF1* fourPoleFitFunction(std::string word, int caser); @@ -86,15 +88,23 @@ class SvtRawDataAnaProcessor : public Processor { TBranch* brecoClu_{nullptr}; TBranch* bPart_{nullptr}; TBranch* bTrk_{nullptr}; + TBranch* bClusters_{nullptr}; TBranch* bevH_; - + /* + TTree *HitEff_; + //TBranch* bL1_{nullptr}; + int L1_; + bool doHitEff_{false}; + */ std::vector * svtHits_{}; VTPData * vtpBank_; TSData * tsBank_; std::vector* recoClu_{}; std::vector* Trk_{}; std::vector* Part_{}; + std::vector* Clusters_{}; + //std::vector Trk_{}; EventHeader * evH_; diff --git a/processors/include/Tracker2DHitProcessor.h b/processors/include/Tracker2DHitProcessor.h index 223ef6351..d501d9fb6 100644 --- a/processors/include/Tracker2DHitProcessor.h +++ b/processors/include/Tracker2DHitProcessor.h @@ -29,6 +29,7 @@ #include "Collections.h" #include "Processor.h" #include "Track.h" +#include "RawSvtHit.h" #include "TrackerHit.h" #include "Event.h" @@ -82,6 +83,10 @@ class Tracker2DHitProcessor : public Processor { std::string hitCollLcio_{"RotatedHelicalTrackHits"}; std::string hitCollRoot_{"RotatedHelicalTrackHits"}; + std::vector rawhits_{}; + std::string rawhitCollRoot_{"fspOnTrackRawHits"}; + std::string hitFitsCollLcio_{"SVTFittedRawTrackerHits"}; + std::string mcPartRelLcio_{"RotatedHelicalTrackMCRelations"}; //Debug Level diff --git a/processors/src/FinalStateParticleProcessor.cxx b/processors/src/FinalStateParticleProcessor.cxx index 271a71409..8053d33cc 100644 --- a/processors/src/FinalStateParticleProcessor.cxx +++ b/processors/src/FinalStateParticleProcessor.cxx @@ -129,6 +129,9 @@ bool FinalStateParticleProcessor::process(IEvent* ievent) { if (lc_fsp->getTracks().size()>0){ EVENT::Track* lc_track = static_cast(lc_fsp->getTracks()[0]); Track* track = utils::buildTrack(lc_track,gbl_kink_data,track_data); + if (track->isKalmanTrack()){ + hitType=1; //SiClusters + } EVENT::TrackerHitVec lc_tracker_hits = lc_track->getTrackerHits(); for (auto lc_tracker_hit : lc_tracker_hits) { TrackerHit* tracker_hit = utils::buildTrackerHit(static_cast(lc_tracker_hit),rotateHits,hitType); diff --git a/processors/src/RoryClusterAnaProcessor.cxx b/processors/src/RoryClusterAnaProcessor.cxx new file mode 100755 index 000000000..eb773030e --- /dev/null +++ b/processors/src/RoryClusterAnaProcessor.cxx @@ -0,0 +1,911 @@ +/** + * @file RoryClusterAnaProcessor.cxx + * @brief AnaProcessor used fill histograms to study svt hit fitting + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory + */ +#include "RoryClusterAnaProcessor.h" +//#include "Int_t.h" +#include + +RoryClusterAnaProcessor::RoryClusterAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ + mmapper_ = new ModuleMapper(2021); +} +//TODO CHECK THIS DESTRUCTOR +RoryClusterAnaProcessor::~RoryClusterAnaProcessor(){} + +void RoryClusterAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring RoryClusterAnaProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug"); + layer_ = parameters.getInteger("layer"); + module_ = parameters.getInteger("module"); + isMC_ = parameters.getInteger("isMC"); + doingTracks_ = (parameters.getInteger("doTrack")==1); + pcut_ = (float)parameters.getDouble("cut"); + //anaName_ = parameters.getString("anaName"); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + + +void RoryClusterAnaProcessor::initialize(TTree* tree) { + fillDeads(); + tree_= tree; + //tree_->Print(); + + if(isMC_==1){ + layers_=new TH1F("layers","MC Strip Width for All Clusters",12,0.0,12.0); + layersOnTrk_=new TH1F("layersOnTrk","MC Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrk_=new TH1F("layersOffTrk","MC Strip Width for Clusters off Track",12,0.0,12.0); + charges_=new TH1F("charges","MC Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrk_=new TH1F("chargesOnTrk","MC Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrk_=new TH1F("chargesOffTrk","MC Charge Distribution for Off Track",1000,0.0,0.000016); + + layersNTD_=new TH1F("layersNTD","MC Strip Width for All Clusters",12,0.0,12.0); + layersOnTrkNTD_=new TH1F("layersOnTrkNTD","MC Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrkNTD_=new TH1F("layersOffTrkNTD","MC Strip Width for Clusters off Track",12,0.0,12.0); + chargesNTD_=new TH1F("chargesNTD","MC Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrkNTD_=new TH1F("chargesOnTrkNTD","MC Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrkNTD_=new TH1F("chargesOffTrkNTD","MC Charge Distribution for Off Track",1000,0.0,0.000016); + + positions_=new TH1F("Positions","MC Location of Cluster Hit;Layer;Hits",14,0.0,14.0); + positionsOnTrk_=new TH1F("PositionsOnTrk","MC Location of Cluster Hit for On Track",14,0.0,14.0); + ClusDistances_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); + ClusDistancesNTD_=new TH1F("Minimum Cluster Difference","MC Minimum Distance Between Clusters",14,0.0,14.0); + + times_=new TH1F("Times","MC Time of Cluster Hit",1000,-60.0,60.0); + timesOnTrk_=new TH1F("TimesOnTrk","MC Time of On Track Cluster Hit",1000,-60.0,60.0); + timesOffTrk_=new TH1F("TimesOffTrk","MC Time of Off Cluster Hit",1000,-60.0,60.0); + timesNTD_=new TH1F("TimesNTD","MC Time of Cluster Hit NTD",1000,-60.0,60.0); + timesOnTrkNTD_=new TH1F("TimesOnTrkNTD","MC Time of On Track Cluster Hit NTD",1000,-60.0,60.0); + timesOffTrkNTD_=new TH1F("TimesOffTrkNTD","MC Time of Off Cluster Hit NTD",1000,-60.0,60.0); + + std::cout<<"I GET HERE 1"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + std::cout<<"I GET HERE 2"<SetBranchAddress("SiClusters",&Clusters_,&bClusters_); + tree_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF_,&bClustersKF_); + tree_->SetBranchAddress("SVTRawTrackerHits",&svtraw_,&bsvtraw_); + if(doingTracks_){ + tree_->SetBranchAddress("KalmanFullTracks",&tracks_,&btracks_); + } + std::cout<<"I GET HERE 2"<size()<<" hits"<size();i++){ + Track* track = tracks_->at(i); + //bool general = ((layer_==-1)||(module_==-1)); + //if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(track->getTrackTime()*track->getTrackTime()<100.0){ + Z0VNShare2Hist_->Fill(track->getZ0Err(),track->getNShared()); + if(track->getP()Fill(track->getZ0Err(),track->getNShared()); + } + } + //} + } + } + for(int i = 0; i < Clusters_->size(); i++){ + TrackerHit * clu = Clusters_->at(i); + Int_t LAYER = -1; + Int_t MODULE = -1; + + RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); + + LAYER=clu->getLayer(); + MODULE=seed->getModule(); + + if(doingTracks_){ + int WSHAREDCONDITION = 0; + bool isShared = false;int increment = 0; + for(int i = 0;isize();i++){ + Track* track = tracks_->at(i); + for(int j = 0; jgetSvtHits().GetEntries();j++){ + TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); + if(clu->getTime()==test->getTime()){ + increment+=1; + } + } + } + if(increment>1){ + isShared=true; + WSHAREDCONDITION+=2.0; + } + + float twoAway=-10000.0;float oneback=100000.0; + float puptwoAway=0.0;float puponeback=0.0;float pupcurr=0.0; + float strip2=-1;float strip1=0.0;float main=-1; + int minStrip=1000000l; + int maxStrip=-1; + for(int p = 0;pgetRawHits().GetEntries();p++){ + RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(p)); + if(holder->getStrip()getStrip(); + } + if(holder->getStrip()>maxStrip){ + maxStrip=holder->getStrip(); + } + } + //std::cout<<"\n"<getRawHits().GetEntries();pp++){ + RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(pp)); + if(holder->getStrip()==p){ + curr=holder->getAmp(0); + main=holder->getStrip(); + if(holder->getFitN()>1){ + pupcurr=holder->getAmp(1); + if(std::abs(holder->getT0(0))>std::abs(holder->getT0(1))){ + curr=holder->getAmp(1); + pupcurr=holder->getAmp(0); + } + } + } + if(holder->getStrip()==p+1){ + oneback=holder->getAmp(0); + strip1=holder->getStrip(); + if(holder->getFitN()>1){ + puponeback=holder->getAmp(1); + if(std::abs(holder->getT0(0))>std::abs(holder->getT0(1))){ + oneback=holder->getAmp(1); + puponeback=holder->getAmp(0); + } + } + } + if(holder->getStrip()==p+2){ + twoAway=holder->getAmp(0); + strip2=holder->getStrip(); + if(holder->getFitN()>1){ + puptwoAway=holder->getAmp(1); + if(std::abs(holder->getT0(0))>std::abs(holder->getT0(1))){ + twoAway=holder->getAmp(1); + puptwoAway=holder->getAmp(0); + } + } + } + } + bool condition = (twoAway>oneback)and(onebackgetNHits()>2){ + std::cout<0){ + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(isShared){ + SharedAmplitudes_->Fill(clu->getCharge()); + SharedTimes_->Fill(clu->getTime()); + }else{ + UnSharedAmplitudes_->Fill(clu->getCharge()); + UnSharedTimes_->Fill(clu->getTime()); + } + } + if(clu->getRawHits().GetEntries()>2){WandShared_->Fill(WSHAREDCONDITION);} + } + //DO THE WHOLE CLUSTER 1 and 2 STRIP THING. + if(clu->getNHits()<=2){ + bool general = ((layer_==-1)||(module_==-1)); + RawSvtHit * one = (RawSvtHit *)(clu->getRawHits().At(0)); + RawSvtHit * two = (RawSvtHit*)(clu->getRawHits().At(clu->getNHits()-1)); + float strip = ((float)(one->getStrip())+(float)(two->getStrip()))/2.0; + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + StripOcc_->Fill(strip); + if(increment>0){StripOccOnTrk_->Fill(strip);} + } + } + } + + + float seedStrip = (float)(seed->getStrip()); + float nLayers = (float)(clu->getRawHits().GetEntries()); + float ncharges = (float)(clu->getCharge()); + float ntimes = (float)(clu->getTime()); + //float ntimes = 0.0; + //for(int p = 0;pgetRawHits().GetEntries();p++){ + // RawSvtHit * holder = (RawSvtHit*)(clu->getRawHits().At(p)); + // ntimes+=holder->getT0(0); + //} + //ntimes=gtimes;//%ncharges; + bool onTrk = false; + bool NTD = false; + for(unsigned int j = 0; j < ClustersKF_->size(); j++){ + if(clu->getID()==(ClustersKF_->at(j)->getID())){ + onTrk = true; + } + } + //std::cout<getVolume()<getHwFromSw(input); + //std::cout<=0){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + + //BETTER NTD CONDITION + for(int P=0;PgetRawHits().GetEntries();P++){ + RawSvtHit* hitToCheck=(RawSvtHit*)(clu->getRawHits().At(P)); + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,hitToCheck->getStrip()-1)]==1); + } + if(Deads_[GetStrip(feb,hyb,channelL)]==1){ + //FOR LOOP TO GET LEFTLEFT CLUSTER + TrackerHit * clul; + RawSvtHit * left; + bool dinglebop=false; + statl=1.0; + for(int LEFTCLUS=0;LEFTCLUSsize();LEFTCLUS++){ + clul = Clusters_->at(LEFTCLUS); + RawSvtHit * zero = (RawSvtHit *)(clul->getRawHits().At(0)); + RawSvtHit * last = (RawSvtHit*)(clul->getRawHits().At(clul->getNHits()-1)); + if(zero->getStrip()==seedStrip-2){left = (RawSvtHit*)(clul->getRawHits().At(0));dinglebop=true;break;} + if(last->getStrip()==seedStrip-2){left = (RawSvtHit*)(clul->getRawHits().At(clul->getNHits()-1));dinglebop=true;break;} + } + if(dinglebop){ + if(clul->getCharge()>.000000){statl+=1.0;} + if(statl==2.0){statusLR_->Fill(Deads2_[GetStrip(feb,hyb,channelL)],-1*(clul->getCharge()));} + statusNTD_->Fill(Deads2_[GetStrip(feb,hyb,channelL)],statl); + } + } + } + //HERE IS SOMETHING IMPORTANT: THE LR STATUS ONLY PLOTS IF BOTH ACTIVATR + if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + for(int P=0;PgetRawHits().GetEntries();P++){ + RawSvtHit* hitToCheck=(RawSvtHit*)(clu->getRawHits().At(P)); + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,hitToCheck->getStrip()+1)]==1); + } + if(Deads_[GetStrip(feb,hyb,channelR)]==1){ + TrackerHit * clur; + RawSvtHit * right; + bool dinglebop=false; + statr=0.0; + for(int RIGHTCLUS=0;RIGHTCLUSsize();RIGHTCLUS++){ + clur = Clusters_->at(RIGHTCLUS); + RawSvtHit * zero = (RawSvtHit *)(clur->getRawHits().At(0)); + RawSvtHit * last = (RawSvtHit*)(clur->getRawHits().At(clur->getNHits()-1)); + if(zero->getStrip()==seedStrip+2){right = (RawSvtHit*)(clur->getRawHits().At(0));dinglebop=true;break;} + if(last->getStrip()==seedStrip+2){right = (RawSvtHit*)(clur->getRawHits().At(clur->getNHits()-1));dinglebop=true;break;} + } + if(dinglebop){ + if(clur->getCharge()>.000000){statr+=2.0;} + if(statr==2.0){statusLR_->Fill(Deads2_[GetStrip(feb,hyb,channelR)],1*(clur->getCharge()));} + statusNTD_->Fill(Deads2_[GetStrip(feb,hyb,channelR)],statr); + } + } + } + //std::cout<<"AFTER THE NTD STUFF"<size(); p++){ + if(p==i){continue;} + TrackerHit * clu2 = Clusters_->at(p); + RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); + float LAYER2=clu->getLayer(); + float MODULE2=seed->getModule(); + if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float dist = ((float)(seed2->getStrip()))-seedStrip; + if(dist<0){dist*=-1.0;} + if(distFill(Dist); + if(NTD){ClusDistancesNTD_->Fill(Dist);} + } + //std::cout<<"HELLO"<Fill(nLayers); + charges_->Fill(ncharges); + positions_->Fill(clu->getLayer()); + times_->Fill(ntimes); + if(onTrk){ + layersOnTrk_->Fill(nLayers); + chargesOnTrk_->Fill(ncharges); + timesOnTrk_->Fill(ntimes); + }else{ + layersOffTrk_->Fill(nLayers); + chargesOffTrk_->Fill(ncharges); + timesOffTrk_->Fill(ntimes); + } + if(NTD){ + layersNTD_->Fill(nLayers); + chargesNTD_->Fill(ncharges); + positionsOnTrk_->Fill(clu->getLayer()); + timesNTD_->Fill(ntimes); + if(onTrk){ + layersOnTrkNTD_->Fill(nLayers); + chargesOnTrkNTD_->Fill(ncharges); + timesOnTrkNTD_->Fill(ntimes); + }else{ + layersOffTrkNTD_->Fill(nLayers); + chargesOffTrkNTD_->Fill(ncharges); + timesOffTrkNTD_->Fill(ntimes); + } + } + } + } + return true; +} + +void RoryClusterAnaProcessor::fillDeads(){ + for(int i = 0;i<24576;i++){ + Deads_[i]=0.0; + Deads2_[i]=-1.0; + } + std::string FILENAME="/fs/ddn/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::ifstream file(FILENAME.c_str()); + std::string line; + std::getline(file,line); + float counter=0.0; + while (std::getline(file, line)) { + int value = std::atoi(line.c_str()); + Deads_[value]=1.0; + Deads2_[value]=counter; + counter+=1.0; + } + file.close(); + return; +} + +int RoryClusterAnaProcessor::GetStrip(int feb,int hyb,int strip){ + int BigCount = 0; + if(feb<=1){ + BigCount+=feb*2048+hyb*512+strip; + }else{ + BigCount+=4096; + BigCount+=(feb-2)*2560+hyb*640+strip; + } + return BigCount; +} + +void RoryClusterAnaProcessor::Plot1(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + layers_->GetXaxis()->SetTitle("Width (strip)"); + layers_->GetYaxis()->SetTitle("Hits"); + layersOnTrk_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrk_->GetYaxis()->SetTitle("Hits"); + layersOffTrk_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrk_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Layers for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for On Track Clusters"); + layersOnTrk_->Draw("e"); + c1->SaveAs("onClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for Off Track Clusters"); + layersOffTrk_->Draw("e"); + c1->SaveAs("offClusters.png"); + c1->Clear(); + + layers_->SetTitle("Cluster Strip Width for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + layers_->SetLineColor(kCyan); + layersOnTrk_->SetLineColor(kGreen); + legend->AddEntry(layers_,"Layers"); + legend->AddEntry(layersOnTrk_,"Layers On Track"); + legend->AddEntry(layersOffTrk_,"Layers Off Track"); + layers_->Draw("e"); + layersOnTrk_->Draw("same e"); + layersOffTrk_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogether.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot2(){ + TCanvas *c1 = new TCanvas("c"); + gPad->SetLogy(true); + c1->cd(); + + charges_->GetXaxis()->SetTitle("Charge"); + charges_->GetYaxis()->SetTitle("Hits"); + chargesOffTrk_->GetXaxis()->SetTitle("Charge"); + chargesOffTrk_->GetYaxis()->SetTitle("Hits"); + chargesOnTrk_->GetXaxis()->SetTitle("Charge"); + chargesOnTrk_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Charges for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for On Track Clusters"); + chargesOnTrk_->Draw("e"); + c1->SaveAs("onClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for Off Track Clusters"); + chargesOffTrk_->Draw("e"); + c1->SaveAs("offClustersCharge.png"); + c1->Clear(); + + layers_->SetTitle("Putting all Charges Together"); + auto legend = new TLegend(0.3,0.8,.68,.9); + charges_->SetLineColor(kCyan); + chargesOnTrk_->SetLineColor(kGreen); + legend->AddEntry(charges_,"Charges"); + legend->AddEntry(chargesOnTrk_,"Charges On Track"); + legend->AddEntry(chargesOffTrk_,"Charges Off Track"); + charges_->Draw("e"); + chargesOnTrk_->Draw("same e"); + chargesOffTrk_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherCharges.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot3(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + layersNTD_->GetXaxis()->SetTitle("Width (strip)"); + layersNTD_->GetYaxis()->SetTitle("Hits"); + layersOnTrkNTD_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrkNTD_->GetYaxis()->SetTitle("Hits"); + layersOffTrkNTD_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrkNTD_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("NTD Layers for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClustersNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Layers for On Track Clusters"); + layersOnTrkNTD_->Draw("e"); + c1->SaveAs("onClustersNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Layers for Off Track Clusters"); + layersOffTrkNTD_->Draw("e"); + c1->SaveAs("offClustersNTD.png"); + c1->Clear(); + + layersNTD_->SetTitle("NTD Cluster Strip Width for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + layersNTD_->SetLineColor(kCyan); + layersOnTrkNTD_->SetLineColor(kGreen); + legend->AddEntry(layersNTD_,"Layers"); + legend->AddEntry(layersOnTrkNTD_,"Layers On Track"); + legend->AddEntry(layersOffTrkNTD_,"Layers Off Track"); + layersNTD_->Draw("e"); + layersOnTrkNTD_->Draw("same e"); + layersOffTrkNTD_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherNTD.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot4(){ + TCanvas *c1 = new TCanvas("c"); + gPad->SetLogy(true); + c1->cd(); + + chargesNTD_->GetXaxis()->SetTitle("Charge"); + chargesNTD_->GetYaxis()->SetTitle("Hits"); + chargesOffTrkNTD_->GetXaxis()->SetTitle("Charge"); + chargesOffTrkNTD_->GetYaxis()->SetTitle("Hits"); + chargesOnTrkNTD_->GetXaxis()->SetTitle("Charge"); + chargesOnTrkNTD_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("NTD Charges for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("allClustersChargeNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Charges for On Track Clusters"); + chargesOnTrkNTD_->Draw("e"); + c1->SaveAs("onClustersChargeNTD.png"); + c1->Clear(); + + c1->SetTitle("NTD Charges for Off Track Clusters"); + chargesOffTrkNTD_->Draw("e"); + c1->SaveAs("offClustersChargeNTD.png"); + c1->Clear(); + + chargesNTD_->SetTitle("NTD Charge Distribution for all Charges"); + auto legend = new TLegend(0.3,0.8,.68,.9); + chargesNTD_->SetLineColor(kCyan); + chargesOnTrkNTD_->SetLineColor(kGreen); + legend->AddEntry(chargesNTD_,"Charges"); + legend->AddEntry(chargesOnTrkNTD_,"Charges On Track"); + legend->AddEntry(chargesOffTrkNTD_,"Charges Off Track"); + chargesNTD_->Draw("e"); + chargesOnTrkNTD_->Draw("same e"); + chargesOffTrkNTD_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherChargesNTD.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot5(){ + TCanvas *c1 = new TCanvas("c"); + gPad->SetLogy(true); + c1->cd(); + positions_->GetXaxis()->SetTitle("Layer"); + positions_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Cluster Position for all Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("positions.png"); + c1->Clear(); + + positionsOnTrk_->GetXaxis()->SetTitle("Layer"); + positionsOnTrk_->GetYaxis()->SetTitle("Hits"); + + //c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Cluster Position for NTD Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("positionsNTD.png"); + c1->Clear(); + + ClusDistances_->GetXaxis()->SetTitle("Separation"); + ClusDistances_->GetYaxis()->SetTitle("Pairs"); + + c1->SetTitle("Cluster Separation on Same Sensors"); + ClusDistances_->Draw("e"); + c1->SaveAs("clusDistances.png"); + c1->Clear(); + + ClusDistancesNTD_->GetXaxis()->SetTitle("Separation"); + ClusDistancesNTD_->GetYaxis()->SetTitle("Pairs"); + + c1->SetTitle("Cluster Separation on Same Sensors for NTD"); + ClusDistancesNTD_->Draw("e"); + c1->SaveAs("clusDistancesNTD.png"); + c1->Clear(); +} + +void RoryClusterAnaProcessor::Plot6(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + times_->GetXaxis()->SetTitle("Times (ns)"); + times_->GetYaxis()->SetTitle("Hits"); + timesOnTrk_->GetXaxis()->SetTitle("Time (ns)"); + timesOnTrk_->GetYaxis()->SetTitle("Hits"); + timesOffTrk_->GetXaxis()->SetTitle("Time (ns)"); + timesOffTrk_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Times for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw(); + c1->SaveAs("alltimes.png"); + c1->Clear(); + + c1->SetTitle("Times for On Track Clusters"); + timesOnTrk_->Draw("e"); + c1->SaveAs("ontimes.png"); + c1->Clear(); + + c1->SetTitle("Times for Off Track Clusters"); + timesOffTrk_->Draw("e"); + c1->SaveAs("offtimes.png"); + c1->Clear(); + + times_->SetTitle("Cluster Times for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + times_->SetLineColor(kCyan); + timesOnTrk_->SetLineColor(kGreen); + legend->AddEntry(times_,"Times"); + legend->AddEntry(timesOnTrk_,"Times On Track"); + legend->AddEntry(timesOffTrk_,"Times Off Track"); + times_->Draw("e"); + timesOnTrk_->Draw("same e"); + timesOffTrk_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherTimes.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::Plot7(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + timesNTD_->GetXaxis()->SetTitle("Times (ns)"); + timesNTD_->GetYaxis()->SetTitle("Hits"); + timesOnTrkNTD_->GetXaxis()->SetTitle("Time (ns)"); + timesOnTrkNTD_->GetYaxis()->SetTitle("Hits"); + timesOffTrkNTD_->GetXaxis()->SetTitle("Time (ns)"); + timesOffTrkNTD_->GetYaxis()->SetTitle("Hits"); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Times for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + c1->SaveAs("alltimesNTD.png"); + c1->Clear(); + + c1->SetTitle("Times for On Track Clusters"); + timesOnTrkNTD_->Draw("e"); + c1->SaveAs("ontimesNTD.png"); + c1->Clear(); + + c1->SetTitle("Times for Off Track Clusters"); + timesOffTrkNTD_->Draw("e"); + c1->SaveAs("offtimesNTD.png"); + c1->Clear(); + + timesNTD_->SetTitle("Cluster Times for all Cluster Cuts"); + auto legend = new TLegend(0.3,0.8,.68,.9); + timesNTD_->SetLineColor(kCyan); + timesOnTrkNTD_->SetLineColor(kGreen); + legend->AddEntry(timesNTD_,"Times"); + legend->AddEntry(timesOnTrkNTD_,"Times On Track"); + legend->AddEntry(timesOffTrkNTD_,"Times Off Track"); + timesNTD_->Draw("e"); + timesOnTrkNTD_->Draw("same e"); + timesOffTrkNTD_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("PutOnTogetherTimesNTD.png"); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::TrackPlot1(){ + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + //FIRST I DO THE PROFILES OF THE NSHARED HITS PLOTS + + TProfile* p1 = Z0VNShare2Hist_->ProfileX("p1"); + TProfile* p2 = Z0VNShare2HistCut_->ProfileX("p2"); + auto legend = new TLegend(0.3,0.8,.68,.9); + p2->SetLineColor(kRed); + p2->SetLineWidth(2.0); + p1->SetLineWidth(2.0); + legend->AddEntry(p1,"Shared Profile Not Cut"); + legend->AddEntry(p2,"Shared Profile Cut"); + p1->Draw("e"); + p2->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("Z0VSharedProfile.png"); + c1->Clear(); + + //NOW I DO THE CHARGE DISTRIBUTION FOR SHARED AND UNSHARED HITS OVERLAYED + SharedAmplitudes_->SetTitle("The Charge of Clusters Shared Between Tracks"); + legend = new TLegend(0.3,0.8,.68,.9); + SharedAmplitudes_->SetLineColor(kRed); + SharedAmplitudes_->SetLineWidth(2.0); + UnSharedAmplitudes_->SetLineWidth(2.0); + legend->AddEntry(SharedAmplitudes_,"Charge Distribution for Shared Clusters"); + legend->AddEntry(UnSharedAmplitudes_,"Charge Distribution for UnShared Clusters"); + UnSharedAmplitudes_->Draw("e"); + SharedAmplitudes_->Draw("same e"); + legend->Draw("same e"); + gPad->SetLogy(true); + c1->SaveAs("SharedVUnSharedChargeDist.png"); + c1->Clear(); + + //NOW I DO THE TIME DISTRIBUTION FOR SHARED AND UNSHARED HITS OVERLAYED + SharedTimes_->SetTitle("The Time of Clusters Shared Between Tracks"); + legend = new TLegend(0.3,0.8,.68,.9); + SharedTimes_->SetLineColor(kRed); + SharedTimes_->SetLineWidth(2.0); + UnSharedTimes_->SetLineWidth(2.0); + legend->AddEntry(SharedTimes_,"Time Distribution for Shared Clusters"); + legend->AddEntry(UnSharedTimes_,"Time Distribution for UnShared Clusters"); + UnSharedTimes_->Draw("e"); + SharedTimes_->Draw("same e"); + legend->Draw("same e"); + c1->SaveAs("SharedVUnSharedTimeDist.png"); + gPad->SetLogy(false); + c1->Clear(); + return; +} + +void RoryClusterAnaProcessor::SplittingPlots(){ + //std::cout<<"DURING SPLITTING PLOTS"<cd(); + + WandShared_->SetTitle("W Condition for Clusters"); + auto legend = new TLegend(0.3,0.8,.68,.9); + WandShared_->SetLineColor(kRed); + WandShared_->SetLineWidth(2.0); + legend->AddEntry(WandShared_,"W Condition for Clusters"); + WandShared_->Draw("e"); + legend->Draw("same e"); + gPad->SetLogy(true); + c1->SaveAs("WCondition.png"); + c1->Clear(); + + statusLR_->SetTitle("Left Right Amplitudes vs Dead Channel"); + gPad->SetLogz(false); + statusLR_->Draw("colz"); + c1->SaveAs("statusLR.png"); + c1->Clear(); + + statusNTD_->SetTitle("Channel LR Status vs Dead Channel"); + statusNTD_->Draw("colz"); + c1->SaveAs("statusNTD.png"); + gPad->SetLogz(false); + c1->Clear(); + + //std::cout<<"These ran too"<Write(); + layersOnTrk_->Write(); + layersOffTrk_->Write(); + charges_->Write(); + chargesOnTrk_->Write(); + chargesOffTrk_->Write(); + + layersNTD_->Write(); + layersOnTrkNTD_->Write(); + layersOffTrkNTD_->Write(); + chargesNTD_->Write(); + chargesOnTrkNTD_->Write(); + chargesOffTrkNTD_->Write(); + + positions_->Write(); + positionsOnTrk_->Write(); + ClusDistances_->Write(); + ClusDistancesNTD_->Write(); + + times_->Write(); + timesOnTrk_->Write(); + timesOffTrk_->Write(); + timesNTD_->Write(); + timesOnTrkNTD_->Write(); + timesOffTrkNTD_->Write(); + //SHARED DISTRIBUTIONS + + //DifferenceInPositions_->Write(); + //DifferenceInCharges_->Write(); + + //TRACKING RELATED VARIABLES + + Z0VNShare2Hist_->Write(); + Z0VNShare2HistCut_->Write(); + SharedAmplitudes_->Write(); + UnSharedAmplitudes_->Write(); + SharedTimes_->Write(); + UnSharedTimes_->Write(); + /*TrackMomentumInTime_->Write(); + TrackMomentumOutTime_->Write(); + TrackMomentumAllTime_->Write(); + TrackMomentumTInTime_->Write(); + TrackMomentumTOutTime_->Write(); + TrackMomentumTAllTime_->Write();*/ + WandShared_->Write(); + statusLR_->Write(); + statusNTD_->Write(); + StripOcc_->Write(); + StripOccOnTrk_->Write(); + outputFile->Close(); + return; +} +void RoryClusterAnaProcessor::finalize() { + Plot1(); + Plot2(); + Plot3(); + Plot4(); + Plot5(); + Plot6(); + Plot7(); + if(doingTracks_){ + TrackPlot1(); + SplittingPlots(); + } + WriteRoot(); + //ClusterFit(); + return; +} +DECLARE_PROCESSOR(RoryClusterAnaProcessor); diff --git a/processors/src/RoryClusterCompareAnaProcessor.cxx b/processors/src/RoryClusterCompareAnaProcessor.cxx new file mode 100755 index 000000000..a67ec9609 --- /dev/null +++ b/processors/src/RoryClusterCompareAnaProcessor.cxx @@ -0,0 +1,981 @@ +/** + * @file RoryClusterCompareAnaProcessor.cxx + * @brief AnaProcessor used to compare two means of reconstruction directly. + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory + */ +#include "RoryClusterCompareAnaProcessor.h" +//#include "Int_t.h" +#include + +RoryClusterCompareAnaProcessor::RoryClusterCompareAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ + mmapper_ = new ModuleMapper(2021); +} +//TODO CHECK THIS DESTRUCTOR +RoryClusterCompareAnaProcessor::~RoryClusterCompareAnaProcessor(){} + +void RoryClusterCompareAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring RoryClusterCompareAnaProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug"); + layer_ = parameters.getInteger("layer"); + module_ = parameters.getInteger("module"); + isMC_ = parameters.getInteger("isMC"); + doingTracks_ = (parameters.getInteger("doTrack")==1); + pcut_ = (float)parameters.getDouble("cut"); + //anaName_ = parameters.getString("anaName"); + fileOne_ = parameters.getString("fileName1"); + fileTwo_ = parameters.getString("fileName2"); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + + +void RoryClusterCompareAnaProcessor::initialize(std::string inFilename, std::string outFilename){ + fillDeads(); + std::cout<<"DO I MAKE IT HERE1"<setupEvent(&event1_); + file2_->setupEvent(&event2_); + std::cout<<"DO I MAKE IT HERE3"<Print(); + + //Instantiating the first layer + + layers1_=new TH1F("layers","Strip Width for All Clusters",12,0.0,12.0); + layersOnTrk1_=new TH1F("layersOnTrk","Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrk1_=new TH1F("layersOffTrk","Strip Width for Clusters off Track",12,0.0,12.0); + charges1_=new TH1F("charges","Charge Distribution for All Clusters",1000,0.0,0.000016); + charges2D_=new TH2F("Charge Distribution for Both Reco Techniques","Charge Distribution for Both Reco Techniques",500,0.0,0.000016,500,0.0,0.000016); + chargesOnTrk1_=new TH1F("chargesOnTrk","Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrk1_=new TH1F("chargesOffTrk","Charge Distribution for Off Track",1000,0.0,0.000016); + + layersNTD1_=new TH1F("layersNTD","Strip Width for All Clusters",12,0.0,12.0); + layersOnTrkNTD1_=new TH1F("layersOnTrkNTD","Strip Width for Clusters on Track",12,0.0,12.0); + layersOffTrkNTD1_=new TH1F("layersOffTrkNTD","Strip Width for Clusters off Track",12,0.0,12.0); + chargesNTD1_=new TH1F("chargesNTD","Charge Distribution for All Clusters",1000,0.0,0.000016); + chargesOnTrkNTD1_=new TH1F("chargesOnTrkNTD","Charge Distribution for On Track",1000,0.0,.000016); + chargesOffTrkNTD1_=new TH1F("chargesOffTrkNTD","Charge Distribution for Off Track",1000,0.0,0.000016); + + positions1_=new TH1F("Positions","Location of Cluster Hit;Layer;Hits",14,0.0,14.0); + positionsOnTrk1_=new TH1F("PositionsOnTrk","Location of Cluster Hit for On Track",14,0.0,14.0); + ClusDistances1_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); + ClusDistancesNTD1_=new TH1F("Minimum Cluster Difference","Minimum Distance Between Clusters",14,0.0,14.0); + + times1_=new TH1F("Times","Time of Cluster Hit",1000,-60.0,60.0); + timesOnTrk1_=new TH1F("TimesOnTrk","Time of On Track Cluster Hit",1000,-60.0,60.0); + timesOffTrk1_=new TH1F("TimesOffTrk","Time of Off Cluster Hit",1000,-60.0,60.0); + timesNTD1_=new TH1F("TimesNTD","Time of Cluster Hit NTD",1000,-60.0,60.0); + timesOnTrkNTD1_=new TH1F("TimesOnTrkNTD","Time of On Track Cluster Hit NTD",1000,-60.0,60.0); + timesOffTrkNTD1_=new TH1F("TimesOffTrkNTD","Time of Off Cluster Hit NTD",1000,-60.0,60.0); + + if(doingTracks_){ + Z0VNShare2Hist1_= new TH2F("Z0VNShare2Hist","Z0 versus Number of Shared Hits No Cut",100,0,3,8,0,8); + Z0VNShare2HistCut1_= new TH2F("Z0VNShare2HistCut","Z0 versus Number of Shared Hits Momentum Cut",100,0,3,8,0,8); + SharedAmplitudes1_= new TH1F("SharedAmplitudes","The Amplitudes of Clusters Shared Between Tracks",1000,0.0,0.000016); + UnSharedAmplitudes1_= new TH1F("UnSharedAmplitudes","The Amplitudes of Clusters Not Shared Between Tracks",1000,0.0,0.000016); + SharedTimes1_= new TH1F("SharedTimes","The Times of Clusters Shared Between Tracks",1000,-60.0,60.0); + UnSharedTimes1_= new TH1F("UnSharedTimes","The Times of Clusters Not Shared Between Tracks",1000,-60.0,60.0); + TrackMomentumInTime1_ = new TH1F("TrackMomentumInTime","The Momentum of In Time Tracks",1000,0.0,7.0); + TrackMomentumOutTime1_ = new TH1F("TrackMomentumOutTime","The Momentum of Out of Time Tracks",1000,0.0,7.0); + TrackMomentumAllTime1_ = new TH1F("TrackMomentumAll","The Momentum of All Tracks",1000,0.0,7.0); + + TrackMomentumTInTime1_ = new TH1F("TrackMomentumTInTime","The Transverse Momentum of In Time Tracks",1000,0.0,7.0); + TrackMomentumTOutTime1_ = new TH1F("TrackMomentumTOutTime","The Transverse Momentum of Out of Time Tracks",1000,0.0,7.0); + TrackMomentumTAllTime1_ = new TH1F("TrackMomentumTAll","The Transverse Momentum of All Tracks",1000,0.0,7.0); + HitsOnTrack1_ = new TH1F("HitsOnTrack","Hits On Tracks",15,-.5,14.5); + } + + + //Instantiating the first layer + + layers2_=new TH1F("layers2","Strip Width for All Clusters2",12,0.0,12.0); + layersOnTrk2_=new TH1F("layersOnTrk2","Strip Width for Clusters on Track2",12,0.0,12.0); + layersOffTrk2_=new TH1F("layersOffTrk2","Strip Width for Clusters off Track2",12,0.0,12.0); + charges2_=new TH1F("charges2","Charge Distribution for All Clusters2",1000,0.0,0.000016); + chargesOnTrk2_=new TH1F("chargesOnTrk2","Charge Distribution for On Track2",1000,0.0,.000016); + chargesOffTrk2_=new TH1F("chargesOffTrk2","Charge Distribution for Off Track2",1000,0.0,0.000016); + + layersNTD2_=new TH1F("layersNTD2","Strip Width for All Clusters2",12,0.0,12.0); + layersOnTrkNTD2_=new TH1F("layersOnTrkNTD2","Strip Width for Clusters on Track2",12,0.0,12.0); + layersOffTrkNTD2_=new TH1F("layersOffTrkNTD2","Strip Width for Clusters off Track2",12,0.0,12.0); + chargesNTD2_=new TH1F("chargesNTD2","Charge Distribution for All Clusters2",1000,0.0,0.000016); + chargesOnTrkNTD2_=new TH1F("chargesOnTrkNTD2","Charge Distribution for On Track2",1000,0.0,.000016); + chargesOffTrkNTD2_=new TH1F("chargesOffTrkNTD2","Charge Distribution for Off Track2",1000,0.0,0.000016); + + times2_=new TH1F("Times2","Time of Cluster Hit2",1000,-60.0,60.0); + timesOnTrk2_=new TH1F("TimesOnTrk2","Time of On Track Cluster Hit2",1000,-60.0,60.0); + timesOffTrk2_=new TH1F("TimesOffTrk2","Time of Off Cluster Hit2",1000,-60.0,60.0); + timesNTD2_=new TH1F("TimesNTD2","Time of Cluster Hit NTD2",1000,-60.0,60.0); + timesOnTrkNTD2_=new TH1F("TimesOnTrkNTD2","Time of On Track Cluster Hit NTD2",1000,-60.0,60.0); + timesOffTrkNTD2_=new TH1F("TimesOffTrkNTD2","Time of Off Cluster Hit NTD2",1000,-60.0,60.0); + + positions2_=new TH1F("Positions2","Location of Cluster Hit;Layer;Hits2",14,0.0,14.0); + positionsOnTrk2_=new TH1F("PositionsOnTrk2","Location of Cluster Hit for On Track2",14,0.0,14.0); + ClusDistances2_=new TH1F("Minimum Cluster Difference2","Minimum Distance Between Clusters2",14,0.0,14.0); + ClusDistancesNTD2_=new TH1F("Minimum Cluster Difference2","Minimum Distance Between Clusters2",14,0.0,14.0); + + + //Event by event comparisions of variables + DifferenceInPositions_=new TH1F("Difference in Cluster Positions","Difference in Cluster Positions",100,-0.05,.5); + //DifferenceInPositions_=new TH1F("Difference in Cluster Positions","Difference in Cluster Positions",100,-0.0000000005,.000000005); + DifferenceInCharges_=new TH1F("Difference in Charge Positions","Difference in Charge Positions",100,-.000005,.00005); + DifferenceInPositionsVStripNo_= new TH2F("Difference in Cluster Positions vs. Strip No","Difference in Cluster Positions vs. Strip No",100,-0.05,.5,6,0,6); + DifferenceInPositionVsCharge_ = new TH2F("Difference in Cluster Positions vs. Charge Difference","Difference in Cluster Positions vs. Charge Difference",100,-0.05,.5,100,-.000005,.00005); + DifferenceInPositionVsChargeNTD_ = new TH2F("Difference in Cluster Positions vs. Charge Difference NTD","Difference in Cluster Positions vs. Charge Difference NTD",100,-0.05,.5,100,-.000005,.00005); + MinComboPosition0_ = new TH2F("Position X of First Cluster v.s Position of Closest Cluster","Position X of First Cluster v.s Position of Closest Cluster",200,-.5,.5,200,-.5,.5); + MinComboPosition1_ = new TH2F("Position Y of First Cluster v.s Position of Closest Cluster","Position Y of First Cluster v.s Position of Closest Cluster",200,-.5,.5,200,-.5,.5); + MinComboPosition2_ = new TH2F("Position Z of First Cluster v.s Position of Closest Cluster","Position Z of First Cluster v.s Position of Closest Cluster",200,-.5,.5,200,-.5,.5); + MinComboChargeNTD_ = new TH2F("Cluster of Smaller One vs. Combined Cluster","Cluster of Smaller One vs. Combined Cluster",100,-0.000005,.00005,100,-.000005,.00005); + DeltaTVsDeltaCharge_ = new TH2F("Time Between NTD vs. Did the Bind","Time Between NTD vs. Did the Bind",200,-100.0,100.0,2000,-.00005,.00005); + DeltaTVsDeltaChargeV2_ = new TH2F("Time Between NTD vs. Did the Bind 2","Time Between NTD vs. Did the Bind 2",2000,-220.0,220.0,2000,-.00005,.00005); + ChargeShared2D_ = new TH2F("Cluster of Smaller One vs. Larger One","Cluster of Smaller One vs. Larger One",100,-0.000005,.00005,100,-.000005,.00005); + + + if(doingTracks_){ + Z0VNShare2Hist2_= new TH2F("Z0VNShare2Hist2","Z0 versus Number of Shared Hits No Cut2",100,0,3,8,0,8); + Z0VNShare2HistCut2_= new TH2F("Z0VNShare2HistCut2","Z0 versus Number of Shared Hits Momentum Cut2",100,0,3,8,0,8); + SharedAmplitudes2_= new TH1F("SharedAmplitudes2","The Amplitudes of Clusters Shared Between Tracks2",1000,0.0,0.000016); + UnSharedAmplitudes2_= new TH1F("UnSharedAmplitudes2","The Amplitudes of Clusters Not Shared Between Tracks2",1000,0.0,0.000016); + SharedTimes2_= new TH1F("SharedTimes2","The Times of Clusters Shared Between Tracks2",1000,-60.0,60.0); + UnSharedTimes2_= new TH1F("UnSharedTimes2","The Times of Clusters Not Shared Between Tracks2",1000,-60.0,60.0); + + TrackMomentumInTime2_ = new TH1F("TrackMomentumInTime2","The Momentum of In Time Tracks2",1000,0.0,7.0); + TrackMomentumOutTime2_ = new TH1F("TrackMomentumOutTime2","The Momentum of Out of Time Tracks2",1000,0.0,7.0); + TrackMomentumAllTime2_ = new TH1F("TrackMomentumAll2","The Momentum of All Tracks2",1000,0.0,7.0); + + TrackMomentumTInTime2_ = new TH1F("TrackMomentumTInTime2","The Transverse Momentum of In Time Tracks2",1000,0.0,7.0); + TrackMomentumTOutTime2_ = new TH1F("TrackMomentumTOutTime2","The Transverse Momentum of Out of Time Tracks2",1000,0.0,7.0); + TrackMomentumTAllTime2_ = new TH1F("TrackMomentumTAll2","The Transverse Momentum of All Tracks2",1000,0.0,7.0); + HitsOnTrack2_ = new TH1F("HitsOnTrack2","Hits On Tracks",15,-.5,14.5); + } + std::cout<<"I GET HERE 1"<SetBranchAddress("SiClusters",&Clusters1_,&bClusters1_); + tree1_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF1_,&bClustersKF1_); + tree1_->SetBranchAddress("SVTRawTrackerHits",&svtraw1_,&bsvtraw1_); + + tree2_->SetBranchAddress("SiClusters",&Clusters2_,&bClusters2_); + tree2_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF2_,&bClustersKF2_); + tree2_->SetBranchAddress("SVTRawTrackerHits",&svtraw2_,&bsvtraw2_); + + if(doingTracks_){ + tree1_->SetBranchAddress("KalmanFullTracks", &tracks1_, &btracks1_); + tree2_->SetBranchAddress("KalmanFullTracks", &tracks2_, &btracks2_); + } + std::cout<<"I GET HERE 2"<nextEvent())and(n_events_processed<40000000)) { + file2_->nextEvent(); + if (n_events_processed%1000 == 0){std::cout<<"Event:"<size()<<" hits"<1.0){std::cout<size();}else{size=tracks2_->size();} + for(int i = 0;iat(i);}else{track=tracks2_->at(i);} + if(track->getTrackTime()*track->getTrackTime()<100.0){ + if(ident_<1.5){Z0VNShare2Hist1_->Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2Hist2_->Fill(track->getZ0Err(),track->getNShared());} + if(track->getP()Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2HistCut2_->Fill(track->getZ0Err(),track->getNShared());} + } + } + //Track Momentum for In and Out of time hits (All not just transverse) + if(ident_<1.5){TrackMomentumAllTime1_->Fill(track->getP());}else{TrackMomentumAllTime2_->Fill(track->getP());} + + if(track->getTrackTime()*track->getTrackTime()<16.0){ + if(ident_<1.5){TrackMomentumInTime1_->Fill(track->getP());}else{TrackMomentumInTime2_->Fill(track->getP());} + }else{ + if(ident_<1.5){TrackMomentumOutTime1_->Fill(track->getP());}else{TrackMomentumOutTime2_->Fill(track->getP());} + } + + //Transverse Track Momentum for same cuts + if(ident_<1.5){TrackMomentumTAllTime1_->Fill(track->getPt());}else{TrackMomentumTAllTime2_->Fill(track->getPt());} + if(track->getTrackTime()*track->getTrackTime()<16.0){ + if(ident_<1.5){TrackMomentumTInTime1_->Fill(track->getPt());}else{TrackMomentumTInTime2_->Fill(track->getPt());} + }else{ + if(ident_<1.5){TrackMomentumTOutTime1_->Fill(track->getPt());}else{TrackMomentumTOutTime2_->Fill(track->getPt());} + } + } + } + int size2=-1; + if(ident_<1.5){size2=Clusters1_->size();}else{size2=Clusters2_->size();} + for(int i = 0; i < size2; i++){ + TrackerHit * clu; + if(ident_<1.5){clu = Clusters1_->at(i);}else{clu=Clusters2_->at(i);} + Int_t LAYER = -1; + Int_t MODULE = -1; + + RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); + + LAYER=clu->getLayer(); + MODULE=seed->getModule(); + + + float seedStrip = (float)(seed->getStrip()); + float nLayers = (float)(clu->getRawHits().GetEntries()); + float ncharges = (float)(clu->getCharge()); + float ntimes = (float)(clu->getTime()); + + bool onTrk = false; + bool NTD = false; + int size3 = -1; + if(ident_<1.5){size3=ClustersKF1_->size();}else{size3=ClustersKF2_->size();} + for(unsigned int j = 0; j < size3; j++){ + int ID=-1; + if(ident_<1.5){ID=ClustersKF1_->at(j)->getID();}else{ID=ClustersKF2_->at(j)->getID();} + if(clu->getID()==ID){ + onTrk = true; + } + } + + std::string input = "ly"+std::to_string(LAYER+1)+"_m"+std::to_string(MODULE); + std::string helper = mmapper_->getHwFromSw(input); + + int feb=std::stoi(helper.substr(1,1)); + int hyb=std::stoi(helper.substr(3,1)); + //std::cout<<"I GOT HERE HELLO COMPARE"<=0){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + } + if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + } + //if(NTD){std::cout<<"THE NTD IS "< pos1 = clu->getPosition(); + for(int j = 0; jsize(); j++){ + std::vector pos2 = Clusters2_->at(j)->getPosition(); + float curDist=0.0; + float curCharge=std::abs(clu->getCharge()-Clusters2_->at(j)->getCharge()); + for(int d=0;d<3;d++){ + curDist+=(pos2[d]-pos1[d])*(pos2[d]-pos1[d]); + } + curDist=std::sqrt(curDist); + if(curDistFill(minDist); + DifferenceInCharges_->Fill(minCharge); + charges2D_->Fill(clu->getCharge(),Clusters2_->at(minCoor)->getCharge()); + DifferenceInPositionsVStripNo_->Fill(minDist,clu->getRawHits().GetEntries()); + DifferenceInPositionVsCharge_->Fill(minDist,minCharge); + std::vector pos2 = Clusters2_->at(minCoor)->getPosition(); + MinComboPosition0_->Fill(pos1[0],pos2[0]); + MinComboPosition1_->Fill(pos1[1],pos2[1]); + MinComboPosition2_->Fill(pos1[2],pos2[2]); + bool condition1 = (Deads_[GetStrip(feb,hyb,channelL)]==1)or(Deads_[GetStrip(feb,hyb,channelR)]==1); + //std::cout<<"I GOT HERE HELLO COMPARE 2"<=0)and(condition1)){ + //std::cout<<"I GOT HERE HELLO COMPARE 3"<at(minCoor)->getRawHits().GetEntries() + for(int PP=0;PPat(minCoor)->getNHits();PP++){ + //std::cout<<"I GOT HERE HELLO COMPARE 4"<at(minCoor)->getRawHits().At(PP)); + for(int PPP=0;PPPgetFitN();PPP++){ + MTIME+=hithold->getT0(PPP)/hithold->getT0err(PPP); + MTIMEERRINV+=(1.0/hithold->getT0err(PPP)); + } + } + MTIME=MTIME/MTIMEERRINV; + //std::cout<<"I GOT HERE HELLO COMPARE 3"<at(secCoor)->getRawHits().GetEntries() + for(int PP=0;PPat(secCoor)->getNHits();PP++){ + RawSvtHit * hithold = (RawSvtHit *)(Clusters2_->at(secCoor)->getRawHits().At(PP)); + for(int PPP=0;PPPgetFitN();PPP++){ + STIME+=hithold->getT0(PPP)/hithold->getT0err(PPP); + STIMEERRINV+=(1.0/hithold->getT0err(PPP)); + } + } + STIME=STIME/STIMEERRINV; + if(Clusters2_->at(minCoor)->getCharge()at(secCoor)->getCharge()){ + if(NTD){MinComboChargeNTD_->Fill(Clusters2_->at(minCoor)->getCharge(),clu->getCharge()); + if(clu->getCharge()-(Clusters2_->at(minCoor)->getCharge()+Clusters2_->at(minCoor)->getCharge())<.0000001){ChargeShared2D_->Fill(Clusters2_->at(secCoor)->getCharge(),Clusters2_->at(minCoor)->getCharge());} + DeltaTVsDeltaCharge_->Fill(Clusters2_->at(secCoor)->getTime()-Clusters2_->at(minCoor)->getTime(),clu->getCharge()-Clusters2_->at(minCoor)->getCharge());} + //HERE IS THE TIME CUT SHENANIGANS MIN COOR SMALLER + if(minCoorat(secCoor)->getRawHits().At(0)); + //if(clu->getCharge()-(Clusters2_->at(minCoor)->getCharge()+Clusters2_->at(minCoor)->getCharge())<.0000001){ + DeltaTVsDeltaChargeV2_->Fill((MTIME-seedLeft->getT0(0))/seedLeft->getT0err(0),clu->getCharge()-Clusters2_->at(minCoor)->getCharge()); + //} + }else{ + RawSvtHit* seedLeft = (RawSvtHit*)(Clusters2_->at(minCoor)->getRawHits().At(0)); + //if(clu->getCharge()-(Clusters2_->at(minCoor)->getCharge()+Clusters2_->at(minCoor)->getCharge())<.0000001){ + DeltaTVsDeltaChargeV2_->Fill((STIME-seedLeft->getT0(0))/seedLeft->getT0err(0),clu->getCharge()-Clusters2_->at(minCoor)->getCharge()); + //} + } + }else{ + if(NTD){MinComboChargeNTD_->Fill(Clusters2_->at(minCoor)->getCharge(),clu->getCharge()); + if(clu->getCharge()-(Clusters2_->at(minCoor)->getCharge()+Clusters2_->at(minCoor)->getCharge())<.0000001){ + ChargeShared2D_->Fill(Clusters2_->at(minCoor)->getCharge(),Clusters2_->at(secCoor)->getCharge()); + } + DeltaTVsDeltaCharge_->Fill(Clusters2_->at(secCoor)->getTime()-Clusters2_->at(minCoor)->getTime(),clu->getCharge()-Clusters2_->at(secCoor)->getCharge());} + //HERE IS THE TIME CUT SHENANIGANS SEC CORR SMALLER + if(minCoorat(secCoor)->getRawHits().At(0)); + //if(clu->getCharge()-(Clusters2_->at(minCoor)->getCharge()+Clusters2_->at(minCoor)->getCharge())<.0000001){ + DeltaTVsDeltaChargeV2_->Fill((MTIME-seedLeft->getT0(0))/seedLeft->getT0err(0),clu->getCharge()-Clusters2_->at(secCoor)->getCharge()); + //} + }else{ + RawSvtHit* seedLeft = (RawSvtHit*)(Clusters2_->at(minCoor)->getRawHits().At(0)); + //if(clu->getCharge()-(Clusters2_->at(minCoor)->getCharge()+Clusters2_->at(minCoor)->getCharge())<.0000001){ + DeltaTVsDeltaChargeV2_->Fill((STIME-seedLeft->getT0(0))/seedLeft->getT0err(0),clu->getCharge()-Clusters2_->at(secCoor)->getCharge()); + //} + } + + } + } + //std::cout<<"DINDADIDDLYDO"<Fill(minDist,minCharge);} + } + } + + + if(doingTracks_){ + bool isShared = false;int increment = 0; + for(int i = 0;iat(i); + HitsOnTrack1_->Fill(track->getSvtHits().GetEntries()); + }else{ + track=tracks2_->at(i); + HitsOnTrack2_->Fill(track->getSvtHits().GetEntries()); + } + for(int j = 0; jgetSvtHits().GetEntries();j++){ + TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); + if(clu->getTime()==test->getTime()){ + increment+=1; + } + } + } + if(increment>1){ + isShared=true; + } + if(increment>0){ + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(isShared){ + if(ident_<1.5){SharedAmplitudes1_->Fill(clu->getCharge());}else{SharedAmplitudes2_->Fill(clu->getCharge());} + if(ident_<1.5){SharedTimes1_->Fill(clu->getTime());}else{SharedTimes2_->Fill(clu->getTime());} + }else{ + if(ident_<1.5){UnSharedAmplitudes1_->Fill(clu->getCharge());}else{UnSharedAmplitudes2_->Fill(clu->getCharge());} + if(ident_<1.5){UnSharedTimes1_->Fill(clu->getTime());}else{UnSharedTimes2_->Fill(clu->getTime());} + } + } + } + } + + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + //NOW IS THE PART WHERE I FILL THE CLUSTER DISTANCE HISTOGRAM + float Dist=69420; + for(int p = 0; p < size2; p++){ + if(p==i){continue;} + TrackerHit * clu2; + if(ident_<1.5){clu2 = Clusters1_->at(p);}else{clu2=Clusters2_->at(p);} + RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); + float LAYER2=clu->getLayer(); + float MODULE2=seed->getModule(); + if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float dist = ((float)(seed2->getStrip()))-seedStrip; + if(dist<0){dist*=-1.0;} + if(distFill(Dist);}else{/*std::cout<<"1 "<Fill(Dist);} + if(NTD){if(ident_<1.5){ClusDistancesNTD1_->Fill(Dist);}else{ClusDistancesNTD2_->Fill(Dist);}} + } + //std::cout<<"HELLO"<Fill(nLayers);}else{layers2_->Fill(nLayers);} + if(ident_<1.5){charges1_->Fill(ncharges);}else{charges2_->Fill(ncharges);} + if(ident_<1.5){positions1_->Fill(clu->getLayer());}else{/*std::cout<<"2"<Fill(clu->getLayer());} + if(ident_<1.5){times1_->Fill(ntimes);}else{times2_->Fill(ntimes);} + if(onTrk){ + if(ident_<1.5){layersOnTrk1_->Fill(nLayers);}else{layersOnTrk2_->Fill(nLayers);} + if(ident_<1.5){chargesOnTrk1_->Fill(ncharges);}else{chargesOnTrk2_->Fill(ncharges);} + if(ident_<1.5){timesOnTrk1_->Fill(ntimes);}else{timesOnTrk2_->Fill(ntimes);} + if(ident_<1.5){positionsOnTrk1_->Fill(clu->getLayer());}else{positionsOnTrk2_->Fill(clu->getLayer());}//std::cout<<"3"<Fill(nLayers);}else{layersOffTrk2_->Fill(nLayers);} + if(ident_<1.5){chargesOffTrk1_->Fill(ncharges);}else{chargesOffTrk2_->Fill(ncharges);} + if(ident_<1.5){timesOffTrk1_->Fill(ntimes);}else{timesOffTrk2_->Fill(ntimes);} + } + if(NTD){ + if(ident_<1.5){layersNTD1_->Fill(nLayers);}else{layersNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesNTD1_->Fill(ncharges);}else{chargesNTD2_->Fill(ncharges);} + if(ident_<1.5){timesNTD1_->Fill(ntimes);}else{timesNTD2_->Fill(ntimes);} + if(onTrk){ + if(ident_<1.5){layersOnTrkNTD1_->Fill(nLayers);}else{layersOnTrkNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesOnTrkNTD1_->Fill(ncharges);}else{chargesOnTrkNTD2_->Fill(ncharges);} + if(ident_<1.5){timesOnTrkNTD1_->Fill(ntimes);}else{timesOnTrkNTD2_->Fill(ntimes);} + }else{ + if(ident_<1.5){layersOffTrkNTD1_->Fill(nLayers);}else{layersOffTrkNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesOffTrkNTD1_->Fill(ncharges);}else{chargesOffTrkNTD2_->Fill(ncharges);} + if(ident_<1.5){timesOffTrkNTD1_->Fill(ntimes);}else{timesOffTrkNTD2_->Fill(ntimes);} + } + } + } + } + } + return; +} + + +void RoryClusterCompareAnaProcessor::fillDeads(){ + for(int i = 0;i<24576;i++){ + Deads_[i]=0.0; + } + std::string FILENAME="/fs/ddn/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::ifstream file(FILENAME.c_str()); + std::string line; + std::getline(file,line); + while (std::getline(file, line)) { + int value = std::atoi(line.c_str()); + Deads_[value]=1.0; + } + file.close(); + return; +} + +int RoryClusterCompareAnaProcessor::GetStrip(int feb,int hyb,int strip){ + int BigCount = 0; + if(feb<=1){ + BigCount+=feb*2048+hyb*512+strip; + }else{ + BigCount+=4096; + BigCount+=(feb-2)*2560+hyb*640+strip; + } + return BigCount; +} + +void RoryClusterCompareAnaProcessor::Plot1(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + layers1_->GetXaxis()->SetTitle("Width (strip)"); + layers1_->GetYaxis()->SetTitle("Hits"); + layersOnTrk1_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrk1_->GetYaxis()->SetTitle("Hits"); + layersOffTrk1_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrk1_->GetYaxis()->SetTitle("Hits"); + layers1_->SetLineColor(kRed); + layersOnTrk1_->SetLineColor(kRed); + layersOffTrk1_->SetLineColor(kRed); + + + layers2_->GetXaxis()->SetTitle("Width (strip)"); + layers2_->GetYaxis()->SetTitle("Hits"); + layersOnTrk2_->GetXaxis()->SetTitle("Width (strip)"); + layersOnTrk2_->GetYaxis()->SetTitle("Hits"); + layersOffTrk2_->GetXaxis()->SetTitle("Width (strip)"); + layersOffTrk2_->GetYaxis()->SetTitle("Hits"); + layers2_->SetLineColor(kBlue); + layersOnTrk2_->SetLineColor(kBlue); + layersOffTrk2_->SetLineColor(kBlue); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Layers for All Clusters"); + //std::cout<<"I AM IN THE FINAL STEP 2"<GetEntries()<Draw("e"); + layers2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(layers1_,"Layers Rec 1"); + legend1->AddEntry(layers2_,"Layers Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for On Track Clusters"); + layersOnTrk1_->Draw("e"); + layersOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(layersOnTrk1_,"Layers On Track Rec 1"); + legend2->AddEntry(layersOnTrk2_,"Layers On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("onClusters.png"); + c1->Clear(); + + c1->SetTitle("Layers for Off Track Clusters"); + layersOffTrk1_->Draw("e"); + layersOffTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(layersOffTrk1_,"Layers Off Track Rec 1"); + legend3->AddEntry(layersOffTrk2_,"Layers Off Track Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("offClusters.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::Plot2(){ + TCanvas *c1 = new TCanvas("c"); + //gPad->SetLogy(true); + c1->cd(); + + charges1_->GetXaxis()->SetTitle("Charge"); + charges1_->GetYaxis()->SetTitle("Hits"); + chargesOffTrk1_->GetXaxis()->SetTitle("Charge"); + chargesOffTrk1_->GetYaxis()->SetTitle("Hits"); + chargesOnTrk1_->GetXaxis()->SetTitle("Charge"); + chargesOnTrk1_->GetYaxis()->SetTitle("Hits"); + charges1_->SetLineColor(kRed); + chargesOnTrk1_->SetLineColor(kRed); + chargesOffTrk1_->SetLineColor(kRed); + + charges2_->GetXaxis()->SetTitle("Charge"); + charges2_->GetYaxis()->SetTitle("Hits"); + chargesOffTrk2_->GetXaxis()->SetTitle("Charge"); + chargesOffTrk2_->GetYaxis()->SetTitle("Hits"); + chargesOnTrk2_->GetXaxis()->SetTitle("Charge"); + chargesOnTrk2_->GetYaxis()->SetTitle("Hits"); + charges2_->SetLineColor(kBlue); + chargesOnTrk2_->SetLineColor(kBlue); + chargesOffTrk2_->SetLineColor(kBlue); + + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Charges for All Clusters"); + charges1_->Draw("e"); + charges2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(charges1_,"Charges Rec 1"); + legend1->AddEntry(charges2_,"Charges Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for On Track Clusters"); + chargesOnTrk1_->Draw("e"); + chargesOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(chargesOnTrk1_,"Charges On Track Rec 1"); + legend2->AddEntry(chargesOnTrk2_,"Charges On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("onClustersCharge.png"); + c1->Clear(); + + c1->SetTitle("Charges for Off Track Clusters"); + chargesOffTrk1_->Draw("e"); + chargesOffTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(chargesOffTrk1_,"Charges Off Track Rec 1"); + legend3->AddEntry(chargesOffTrk2_,"Charges Off Track Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("offClustersCharge.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::Plot3(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + + times1_->GetXaxis()->SetTitle("Charge"); + times1_->GetYaxis()->SetTitle("Hits"); + timesOffTrk1_->GetXaxis()->SetTitle("Charge"); + timesOffTrk1_->GetYaxis()->SetTitle("Hits"); + timesOnTrk1_->GetXaxis()->SetTitle("Charge"); + timesOnTrk1_->GetYaxis()->SetTitle("Hits"); + times1_->SetLineColor(kRed); + timesOnTrk1_->SetLineColor(kRed); + timesOffTrk1_->SetLineColor(kRed); + + + times2_->GetXaxis()->SetTitle("Charge"); + times2_->GetYaxis()->SetTitle("Hits"); + timesOffTrk2_->GetXaxis()->SetTitle("Charge"); + timesOffTrk2_->GetYaxis()->SetTitle("Hits"); + timesOnTrk2_->GetXaxis()->SetTitle("Charge"); + timesOnTrk2_->GetYaxis()->SetTitle("Hits"); + times2_->SetLineColor(kBlue); + timesOnTrk2_->SetLineColor(kBlue); + timesOffTrk2_->SetLineColor(kBlue); + + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Times for All Clusters"); + times1_->Draw("e"); + times2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(times1_,"Times Rec 1"); + legend1->AddEntry(times2_,"Times Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("alltimes.png"); + c1->Clear(); + + c1->SetTitle("Times for On Track Clusters"); + timesOnTrk1_->Draw("e"); + timesOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(timesOnTrk1_,"Times On Track Rec 1"); + legend2->AddEntry(timesOnTrk2_,"Times On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("ontimes.png"); + c1->Clear(); + + c1->SetTitle("Times for Off Track Clusters"); + timesOffTrk1_->Draw("e"); + timesOffTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(timesOffTrk1_,"Times Off Track Rec 1"); + legend3->AddEntry(timesOffTrk2_,"Times Off Track Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("offtimes.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::Plot4(){ + std::cout<<"I AM IN THE FINAL STEP"<SetLogy(true); + c1->cd(); + + positions1_->GetXaxis()->SetTitle("Position"); + positions1_->GetYaxis()->SetTitle("Hits"); + positionsOnTrk1_->GetXaxis()->SetTitle("Position"); + positionsOnTrk1_->GetYaxis()->SetTitle("Hits"); + + positions2_->GetXaxis()->SetTitle("Position"); + positions2_->GetYaxis()->SetTitle("Hits"); + positionsOnTrk2_->GetXaxis()->SetTitle("Position"); + positionsOnTrk2_->GetYaxis()->SetTitle("Hits"); + + positions1_->SetLineColor(kRed); + positionsOnTrk1_->SetLineColor(kRed); + positions2_->SetLineColor(kBlue); + positionsOnTrk2_->SetLineColor(kBlue); + + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Position for All Clusters"); + positions1_->Draw("e"); + positions2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(positions1_,"Position Rec 1"); + legend1->AddEntry(positions2_,"Position Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("positions.png"); + c1->Clear(); + + c1->SetTitle("Position for On Track Clusters"); + positionsOnTrk1_->Draw("e"); + positionsOnTrk2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(positionsOnTrk1_,"Position On Track Rec 1"); + legend2->AddEntry(positionsOnTrk2_,"Position On Track Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("onpositions.png"); + c1->Clear(); + + c1->SetTitle("Cluster Distances"); + positionsOnTrk1_->Draw("e"); + positionsOnTrk2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(positionsOnTrk1_,"Cluster Distances Rec 1"); + legend3->AddEntry(positionsOnTrk2_,"Cluster Distances Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("clusDistances.png"); + c1->Clear(); + + return; +} + +void RoryClusterCompareAnaProcessor::TrackPlot1(){ + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + gPad->SetLogy(false); + TrackMomentumAllTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumAllTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumInTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumInTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumOutTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumOutTime1_->GetYaxis()->SetTitle("Momentum"); + + TrackMomentumAllTime1_->SetLineColor(kRed); + TrackMomentumInTime1_->SetLineColor(kRed); + TrackMomentumOutTime1_->SetLineColor(kRed); + TrackMomentumAllTime2_->SetLineColor(kBlue); + TrackMomentumInTime2_->SetLineColor(kBlue); + TrackMomentumOutTime2_->SetLineColor(kBlue); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Momentum for All Tracks"); + TrackMomentumAllTime1_->Draw("e"); + TrackMomentumAllTime2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(TrackMomentumAllTime1_,"Momenta Rec 1"); + legend1->AddEntry(TrackMomentumAllTime2_,"Momenta Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allTracksMomenta.png"); + c1->Clear(); + + c1->SetTitle("Momentum for In Time Tracks"); + TrackMomentumInTime1_->Draw("e"); + TrackMomentumInTime2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(TrackMomentumInTime1_,"Momenta Rec 1"); + legend2->AddEntry(TrackMomentumInTime2_,"Momenta Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("inTimeTracksMomenta.png"); + c1->Clear(); + + gPad->SetLogy(true); + c1->SetTitle("Momentum for Out Time Tracks"); + TrackMomentumOutTime1_->Draw("e"); + TrackMomentumOutTime2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(TrackMomentumOutTime1_,"Momenta Rec 1"); + legend3->AddEntry(TrackMomentumOutTime2_,"Momenta Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("outTimeTracksMomenta.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::TrackPlot2(){ + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + gPad->SetLogy(false); + TrackMomentumTAllTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumTAllTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumTInTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumTInTime1_->GetYaxis()->SetTitle("Momentum"); + TrackMomentumTOutTime1_->GetXaxis()->SetTitle("Track Number"); + TrackMomentumTOutTime1_->GetYaxis()->SetTitle("Momentum"); + + TrackMomentumTAllTime1_->SetLineColor(kRed); + TrackMomentumTInTime1_->SetLineColor(kRed); + TrackMomentumTOutTime1_->SetLineColor(kRed); + TrackMomentumTAllTime2_->SetLineColor(kBlue); + TrackMomentumTInTime2_->SetLineColor(kBlue); + TrackMomentumTOutTime2_->SetLineColor(kBlue); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Transverse Momentum for All Tracks"); + TrackMomentumTAllTime1_->Draw("e"); + TrackMomentumTAllTime2_->Draw("e same"); + auto legend1 = new TLegend(0.3,0.8,.68,.9); + legend1->AddEntry(TrackMomentumTAllTime1_,"Momenta Rec 1"); + legend1->AddEntry(TrackMomentumTAllTime2_,"Momenta Rec 2"); + legend1->Draw("same e"); + c1->SaveAs("allTracksMomentaT.png"); + c1->Clear(); + + c1->SetTitle("Transverse Momentum for In Time Tracks"); + TrackMomentumTInTime1_->Draw("e"); + TrackMomentumTInTime2_->Draw("e same"); + auto legend2 = new TLegend(0.3,0.8,.68,.9); + legend2->AddEntry(TrackMomentumTInTime1_,"Momenta Rec 1"); + legend2->AddEntry(TrackMomentumTInTime2_,"Momenta Rec 2"); + legend2->Draw("same e"); + c1->SaveAs("inTimeTracksMomentaT.png"); + c1->Clear(); + gPad->SetLogy(true); + c1->SetTitle("Transverse Momentum for Out Time Tracks"); + TrackMomentumTOutTime1_->Draw("e"); + TrackMomentumTOutTime2_->Draw("e same"); + auto legend3 = new TLegend(0.3,0.8,.68,.9); + legend3->AddEntry(TrackMomentumTOutTime1_,"Momenta Rec 1"); + legend3->AddEntry(TrackMomentumTOutTime2_,"Momenta Rec 2"); + legend3->Draw("same e"); + c1->SaveAs("outTimeTracksMomentaT.png"); + c1->Clear(); + return; +} + +void RoryClusterCompareAnaProcessor::PlotShared1() { + TCanvas *c1 = new TCanvas("c"); + c1->cd(); + gPad->SetLogy(true); + + DifferenceInPositions_->GetXaxis()->SetTitle("Closest Cluster Position"); + DifferenceInCharges_->GetXaxis()->SetTitle("Closest Cluster Charge"); + DifferenceInPositions_->GetYaxis()->SetTitle("No Hits"); + DifferenceInCharges_->GetYaxis()->SetTitle("No Hits"); + + DifferenceInPositions_->SetLineColor(kRed); + DifferenceInCharges_->SetLineColor(kRed); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Closest Associated Hit Position"); + DifferenceInPositions_->Draw("e"); + c1->SaveAs("PositionDifference.png"); + c1->Clear(); + + c1->DrawFrame(0.0,3000.0,150.0,7000.0); + c1->SetTitle("Closest Associated Hit Charge"); + DifferenceInCharges_->Draw("e"); + c1->SaveAs("ChargeDifference.png"); + c1->Clear(); + + return; +} +void RoryClusterCompareAnaProcessor::WriteRoot(){ + TFile *outputFile; + outputFile = new TFile("picHistos.root","RECREATE"); + + layers1_->Write(); + layersOnTrk1_->Write(); + layersOffTrk1_->Write(); + charges1_->Write(); + chargesOnTrk1_->Write(); + chargesOffTrk1_->Write(); + charges2D_->Write(); + + layersNTD1_->Write(); + layersOnTrkNTD1_->Write(); + layersOffTrkNTD1_->Write(); + chargesNTD1_->Write(); + chargesOnTrkNTD1_->Write(); + chargesOffTrkNTD1_->Write(); + + positions1_->Write(); + positionsOnTrk1_->Write(); + ClusDistances1_->Write(); + ClusDistancesNTD1_->Write(); + + times1_->Write(); + timesOnTrk1_->Write(); + timesOffTrk1_->Write(); + timesNTD1_->Write(); + timesOnTrkNTD1_->Write(); + timesOffTrkNTD1_->Write(); + + //FOR THE SECOND FILE + + layers2_->Write(); + layersOnTrk2_->Write(); + layersOffTrk2_->Write(); + charges2_->Write(); + chargesOnTrk2_->Write(); + chargesOffTrk2_->Write(); + + layersNTD2_->Write(); + layersOnTrkNTD2_->Write(); + layersOffTrkNTD2_->Write(); + chargesNTD2_->Write(); + chargesOnTrkNTD2_->Write(); + chargesOffTrkNTD2_->Write(); + + positions2_->Write(); + positionsOnTrk2_->Write(); + ClusDistances2_->Write(); + ClusDistancesNTD2_->Write(); + + times2_->Write(); + timesOnTrk2_->Write(); + timesOffTrk2_->Write(); + timesNTD2_->Write(); + timesOnTrkNTD2_->Write(); + timesOffTrkNTD2_->Write(); + + //SHARED DISTRIBUTIONS + + DifferenceInPositions_->Write(); + DifferenceInCharges_->Write(); + DifferenceInPositionsVStripNo_->Write(); + DifferenceInPositionVsCharge_->Write(); + DifferenceInPositionVsChargeNTD_->Write(); + MinComboPosition0_->Write(); + MinComboPosition1_->Write(); + MinComboPosition2_->Write(); + MinComboChargeNTD_->Write(); + DeltaTVsDeltaCharge_->Write(); + DeltaTVsDeltaChargeV2_->Write(); + ChargeShared2D_->Write(); + + //TRACKING RELATED VARIABLES + + Z0VNShare2Hist1_->Write(); + Z0VNShare2HistCut1_->Write(); + SharedAmplitudes1_->Write(); + UnSharedAmplitudes1_->Write(); + SharedTimes1_->Write(); + UnSharedTimes1_->Write(); + TrackMomentumInTime1_->Write(); + TrackMomentumOutTime1_->Write(); + TrackMomentumAllTime1_->Write(); + TrackMomentumTInTime1_->Write(); + TrackMomentumTOutTime1_->Write(); + TrackMomentumTAllTime1_->Write(); + HitsOnTrack1_->SetLineColor(kRed); + HitsOnTrack1_->Write(); + + Z0VNShare2Hist2_->Write(); + Z0VNShare2HistCut2_->Write(); + SharedAmplitudes2_->Write(); + UnSharedAmplitudes2_->Write(); + SharedTimes2_->Write(); + UnSharedTimes2_->Write(); + TrackMomentumInTime2_->Write(); + TrackMomentumOutTime2_->Write(); + TrackMomentumAllTime2_->Write(); + TrackMomentumTInTime2_->Write(); + TrackMomentumTOutTime2_->Write(); + TrackMomentumTAllTime2_->Write(); + HitsOnTrack2_->SetLineColor(kBlue); + HitsOnTrack2_->Write(); + + outputFile->Close(); + return; +} +void RoryClusterCompareAnaProcessor::finalize() { + Plot1(); + Plot2(); + Plot3(); + Plot4(); + if(doingTracks_){ + TrackPlot1(); + TrackPlot2(); + } + PlotShared1(); + WriteRoot(); + //ClusterFit(); + return; +} +DECLARE_PROCESSOR(RoryClusterCompareAnaProcessor); diff --git a/processors/src/RoryClusterCompareSeedAnaProcessor.cxx b/processors/src/RoryClusterCompareSeedAnaProcessor.cxx new file mode 100755 index 000000000..6701f0f9e --- /dev/null +++ b/processors/src/RoryClusterCompareSeedAnaProcessor.cxx @@ -0,0 +1,628 @@ +/** + * @file RoryClusterCompareAnaProcessor.cxx + * @brief AnaProcessor used to compare two means of reconstruction directly. + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory + */ +#include "RoryClusterCompareSeedAnaProcessor.h" +//#include "Int_t.h" +#include + +RoryClusterCompareSeedAnaProcessor::RoryClusterCompareSeedAnaProcessor(const std::string& name, Process& process) : Processor(name,process){ + mmapper_ = new ModuleMapper(2021); +} +//TODO CHECK THIS DESTRUCTOR +RoryClusterCompareSeedAnaProcessor::~RoryClusterCompareSeedAnaProcessor(){} + +void RoryClusterCompareSeedAnaProcessor::configure(const ParameterSet& parameters) { + std::cout << "Configuring RoryClusterCompareSeedAnaProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug"); + layer_ = parameters.getInteger("layer"); + module_ = parameters.getInteger("module"); + isMC_ = parameters.getInteger("isMC"); + doingTracks_ = (parameters.getInteger("doTrack")==1); + pcut_ = (float)parameters.getDouble("cut"); + //anaName_ = parameters.getString("anaName"); + fileOne_ = parameters.getString("fileName1"); + fileTwo_ = parameters.getString("fileName2"); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } + +} + + +void RoryClusterCompareSeedAnaProcessor::initialize(std::string inFilename, std::string outFilename){ + fillDeads(); + std::cout<<"DO I MAKE IT HERE1"<setupEvent(&event1_); + file2_->setupEvent(&event2_); + std::cout<<"DO I MAKE IT HERE3"<SetBranchAddress("SiClusters",&Clusters1_,&bClusters1_); + tree1_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF1_,&bClustersKF1_); + tree1_->SetBranchAddress("SVTRawTrackerHits",&svtraw1_,&bsvtraw1_); + + tree2_->SetBranchAddress("SiClusters",&Clusters2_,&bClusters2_); + tree2_->SetBranchAddress("SiClustersOnTrack_KF",&ClustersKF2_,&bClustersKF2_); + tree2_->SetBranchAddress("SVTRawTrackerHits",&svtraw2_,&bsvtraw2_); + + if(doingTracks_){ + tree1_->SetBranchAddress("KalmanFullTracks", &tracks1_, &btracks1_); + tree2_->SetBranchAddress("KalmanFullTracks", &tracks2_, &btracks2_); + } + std::cout<<"I GET HERE 2 DING"<nextEvent())and(n_events_processed<4000000)) { + file2_->nextEvent(); + if (n_events_processed%1000 == 0){std::cout<<"Event:"<8000)and(n_events_processed<9000)){helper_=true;std::cout<size()<<" hits"<1.0){std::cout<size();}else{size=tracks2_->size();} + for(int i = 0;iat(i);}else{track=tracks2_->at(i);} + if(track->getTrackTime()*track->getTrackTime()<100.0){ + if(ident_<1.5){Z0VNShare2Hist1_->Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2Hist2_->Fill(track->getZ0Err(),track->getNShared());} + if(track->getP()Fill(track->getZ0Err(),track->getNShared());}else{Z0VNShare2HistCut2_->Fill(track->getZ0Err(),track->getNShared());} + } + } + //Track Momentum for In and Out of time hits (All not just transverse) + if(ident_<1.5){TrackMomentumAllTime1_->Fill(track->getP());}else{TrackMomentumAllTime2_->Fill(track->getP());} + + if(track->getTrackTime()*track->getTrackTime()<16.0){ + if(ident_<1.5){TrackMomentumInTime1_->Fill(track->getP());}else{TrackMomentumInTime2_->Fill(track->getP());} + }else{ + if(ident_<1.5){TrackMomentumOutTime1_->Fill(track->getP());}else{TrackMomentumOutTime2_->Fill(track->getP());} + } + + //Transverse Track Momentum for same cuts + if(ident_<1.5){TrackMomentumTAllTime1_->Fill(track->getPt());}else{TrackMomentumTAllTime2_->Fill(track->getPt());} + if(track->getTrackTime()*track->getTrackTime()<16.0){ + if(ident_<1.5){TrackMomentumTInTime1_->Fill(track->getPt());}else{TrackMomentumTInTime2_->Fill(track->getPt());} + }else{ + if(ident_<1.5){TrackMomentumTOutTime1_->Fill(track->getPt());}else{TrackMomentumTOutTime2_->Fill(track->getPt());} + } + } + } + int size2=-1; + if(ident_<1.5){size2=Clusters1_->size();}else{size2=Clusters2_->size();} + float COUNT=0.0; + float DENOM=0.0; + for(int i = 0; i < size2; i++){ + TrackerHit * clu; + if(ident_<1.5){clu = Clusters1_->at(i);}else{clu=Clusters2_->at(i);} + Int_t LAYER = -1; + Int_t MODULE = -1; + + RawSvtHit * seed = (RawSvtHit*)(clu->getRawHits().At(0)); + + LAYER=clu->getLayer(); + MODULE=seed->getModule(); + + + float seedStrip = (float)(seed->getStrip()); + float nLayers = (float)(clu->getRawHits().GetEntries()); + float ncharges = (float)(clu->getCharge()); + float ntimes = (float)(clu->getTime()); + + bool onTrk = false; + bool NTD = false; + int size3 = -1; + if(ident_<1.5){size3=ClustersKF1_->size();}else{size3=ClustersKF2_->size();} + for(unsigned int j = 0; j < size3; j++){ + int ID=-1; + if(ident_<1.5){ID=ClustersKF1_->at(j)->getID();}else{ID=ClustersKF2_->at(j)->getID();} + if(clu->getID()==ID){ + onTrk = true; + } + } + + std::string input = "ly"+std::to_string(LAYER+1)+"_m"+std::to_string(MODULE); + std::string helper = mmapper_->getHwFromSw(input); + + int feb=std::stoi(helper.substr(1,1)); + int hyb=std::stoi(helper.substr(3,1)); + + int channelL=seedStrip-1; + int channelR=seedStrip+1; + if(channelL>=0){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelL)]==1); + } + if(((feb<=1)&&(channelR<=511))||((feb>1)&&(channelR<=639))){ + NTD=(NTD)||(Deads_[GetStrip(feb,hyb,channelR)]==1); + } + if(ident_<1.5){ + //WE ARE GOING TO DO ALL OUR EVENT BY EVENT ANALYSIS HERE + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + float minDist=10000000; + int minCoor=-1; + //std::vector pos1 = clu->getPosition(); + //ABSOLUTELY FORCES EQUALITY + for(int j = 0; jsize(); j++){ + RawSvtHit * justHoldin = (RawSvtHit *)(Clusters2_->at(j)->getRawHits().At(0)); + if((not(LAYER==Clusters2_->at(j)->getLayer()))or(not(MODULE==justHoldin->getModule()))){continue;} + if(justHoldin->getStrip()==seedStrip){ + minCoor=j; + minDist=0; + } + } + if(not(minCoor==-1)){ + RawSvtHit * justHoldin = (RawSvtHit *)(Clusters2_->at(minCoor)->getRawHits().At(0)); + if(not(abs(clu->getTime()-Clusters2_->at(minCoor)->getTime())==0.0)){ + TwoTimes_->Fill(clu->getTime(),Clusters2_->at(minCoor)->getTime()); + }else{ + UnChangedTimes_->Fill(clu->getTime()); + } + if(not(abs(clu->getCharge()-Clusters2_->at(minCoor)->getCharge())==0.0)){ + if(Clusters2_->at(minCoor)->getCharge()getCharge()){ + countWeird_+=1.0;std::cout<getNHits(); + if(Clusters2_->at(minCoor)->getNHits()>End){ + End=Clusters2_->at(minCoor)->getNHits(); + } + for(int II=0;IIgetNHits()){ + RawSvtHit * rawhit1 = (RawSvtHit *)(clu->getRawHits().At(II)); + T1=rawhit1->getT0(0); + T1err=rawhit1->getT0err(0); + strip1=(float)(rawhit1->getStrip()); + } + if(IIat(minCoor)->getNHits()){ + RawSvtHit * rawhit2 = (RawSvtHit *)(Clusters2_->at(minCoor)->getRawHits().At(II)); + T2=rawhit2->getT0(0); + T2err=rawhit2->getT0err(0); + strip2=(float)(rawhit2->getStrip()); + } + //if(Deads_[GetStrip(feb,hyb,channelR)]==1){ + std::cout<Fill(clu->getCharge(),Clusters2_->at(minCoor)->getCharge()); + }else{ + UnChangedCharges_->Fill(clu->getCharge()); + } + + } + //if(helper_){ + //DENOM+=1.0; + if(minCoor>-1){ + //COUNT+=1.0; + float chargeSub = 0.0; + if(NTD){ + //std::cout<<"GOT HERE 1"<at(minCoor)->getNHits()>1){ + //std::cout<<"GOT HERE 2"<at(minCoor)->getRawHits().At(1)); + cltime=(seed->getT0(0)/seed->getT0err(0)+cl2->getT0(0)/cl2->getT0err(0))/(1.0/seed->getT0err(0)+1.0/cl2->getT0err(0)); + }else{ + //std::cout<<"GOT HERE 3"<getT0(0); + } + //std::cout<<"GOT HERE 4"<at(minCoor)->getCharge()-clu->getCharge()); + //std::cout<<"GOT HERE 5"<at(minCoor)->getNHits();indexer++){ + if(clu->getNHits()at(minCoor)->getNHits()){ + //std::cout<<"HELLO I GOT TO NHITS"<at(minCoor)->getRawHits().At(clu->getNHits())); + DidItAdd_->Fill((cltime-deadCandidate->getT0(0))/deadCandidate->getT0err(0),chargeSub); + } + //if(cond1){std::cout<<"PASSED 1"<getStrip()==seedStrip-2)and(Deads_[GetStrip(feb,hyb,channelL)]==1)); + //if(cond1){std::cout<<"PASSED 2"<Fill((cltime-deadCandidate->getT0(0))/deadCandidate->getT0err(0),chargeSub);} + //cond1 = (cond1)and((LAYER==Clusters1_->at(indexer)->getLayer())and(MODULE=deadCandidate->getModule())); + + //} + //std::cout<size();indexer++){ + //std::cout<<"GOT HERE 5"<at(indexer)->getRawHits().At(0)); + bool cond1 = (deadCandidate->getStrip()==seedStrip+2)and(Deads_[GetStrip(feb,hyb,channelR)]==1); + if(cond1){std::cout<<"PASSED 1"<getStrip()==seedStrip-2)and(Deads_[GetStrip(feb,hyb,channelL)]==1)); + if(cond1){std::cout<<"PASSED 2"<at(indexer)->getLayer())and(MODULE=deadCandidate->getModule())); + if(cond1){ + std::cout<<"GOT HERE 6"<at(minCoor)->getNHits();G++){ + //std::cout<<"\n"<at(minCoor)->getRawHits().At(G)); + if((not(LAYER==Clusters2_->at(minCoor)->getLayer()))or(not(MODULE==justHoldin->getModule()))){continue;} + //THIS LINE BELOW FINDS OUT IF YOUR CLUSTER2 MATCH CONTAINS THE ACROSS DEAD CHANNEL + //if(justHoldin->getStrip()==seedStrip-2){ + //if(Clusters2_->at(minCoor)->getNHits()>1){std::cout<getStrip()<<" "<at(minCoor)->getRawHits().At(GG)); + if((not(LAYER==Clusters2_->at(minCoor)->getLayer()))or(not(MODULE==justHoldin2->getModule()))){continue;} + timeHold+=justHoldin2->getT0(0)/justHoldin2->getT0err(0); + timeErr+=1.0/justHoldin2->getT0err(0); + }catch(...){ + std::cout<<"There was an encased exception"<at(minCoor)->getNHits()<Fill((timeHold-justHoldin->getT0(0))/(justHoldin->getT0err(0))); + //} + }catch(...){ + std::cout<<"There was an exception"<at(minCoor)->getNHits()<at(i);}else{track=tracks2_->at(i);} + for(int j = 0; jgetSvtHits().GetEntries();j++){ + TrackerHit * test = (TrackerHit *)(track->getSvtHits().At(j)); + if(clu->getTime()==test->getTime()){ + increment+=1; + } + } + } + if(increment>1){ + isShared=true; + } + if(increment>0){ + bool general = ((layer_==-1)||(module_==-1)); + if(((LAYER==layer_)&&(MODULE==module_))||(general)){ + if(isShared){ + if(ident_<1.5){SharedAmplitudes1_->Fill(clu->getCharge());}else{SharedAmplitudes2_->Fill(clu->getCharge());} + if(ident_<1.5){SharedTimes1_->Fill(clu->getTime());}else{SharedTimes2_->Fill(clu->getTime());} + }else{ + if(ident_<1.5){UnSharedAmplitudes1_->Fill(clu->getCharge());}else{UnSharedAmplitudes2_->Fill(clu->getCharge());} + if(ident_<1.5){UnSharedTimes1_->Fill(clu->getTime());}else{UnSharedTimes2_->Fill(clu->getTime());} + } + } + } + } + } + //if(ident_<1.5){std::cout<<"THE AMOUNT OF MATCHING CLUSTERS IS "<getNHits();GG++){ + try{ + RawSvtHit * justHoldin2 = (RawSvtHit *)(clu->getRawHits().At(GG)); + timeHold+=justHoldin2->getT0(0); + timeErr+=justHoldin2->getT0err(0); + }catch(...){ + std::cout<<"There was an encased exception"<getNHits()<at(minCoor)->getNHits()>4){ + float cluTime = 0.0; + float cluErr = 0.0; + for(int G=0;Gat(minCoor)->getNHits();G++){ + RawSvtHit * printer = (RawSvtHit *)(Clusters2_->at(minCoor)->getRawHits().At(G)); + cluTime+=printer->getT0(0)/printer->getT0err(0); + cluErr+=1/(printer->getT0err(0)); + std::cout<getStrip()<<", Hit Time: "<getT0(0)<<", Hit Error: "<getT0err(0)<<", Cluster Time: "<at(p);}else{clu2=Clusters2_->at(p);} + RawSvtHit * seed2 = (RawSvtHit*)(clu2->getRawHits().At(0)); + float LAYER2=clu->getLayer(); + float MODULE2=seed->getModule(); + if((not(LAYER2==LAYER))or(not(MODULE2==MODULE))){continue;} + float dist = ((float)(seed2->getStrip()))-seedStrip; + if(dist<0){dist*=-1.0;} + if(distFill(Dist);}else{std::cout<<"1 "<Fill(Dist);} + if(NTD){if(ident_<1.5){ClusDistancesNTD1_->Fill(Dist);}else{ClusDistancesNTD2_->Fill(Dist);}} + } + //std::cout<<"HELLO"<Fill(nLayers);}else{layers2_->Fill(nLayers);} + if(ident_<1.5){charges1_->Fill(ncharges);}else{charges2_->Fill(ncharges);} + if(ident_<1.5){positions1_->Fill(clu->getLayer());}else{std::cout<<"2"<Fill(clu->getLayer());} + if(ident_<1.5){times1_->Fill(ntimes);}else{times2_->Fill(ntimes);} + if(onTrk){ + if(ident_<1.5){layersOnTrk1_->Fill(nLayers);}else{layersOnTrk2_->Fill(nLayers);} + if(ident_<1.5){chargesOnTrk1_->Fill(ncharges);}else{chargesOnTrk2_->Fill(ncharges);} + if(ident_<1.5){timesOnTrk1_->Fill(ntimes);}else{timesOnTrk2_->Fill(ntimes);} + if(ident_<1.5){positionsOnTrk1_->Fill(clu->getLayer());}else{positionsOnTrk2_->Fill(clu->getLayer());}//std::cout<<"3"<Fill(nLayers);}else{layersOffTrk2_->Fill(nLayers);} + if(ident_<1.5){chargesOffTrk1_->Fill(ncharges);}else{chargesOffTrk2_->Fill(ncharges);} + if(ident_<1.5){timesOffTrk1_->Fill(ntimes);}else{timesOffTrk2_->Fill(ntimes);} + } + if(NTD){ + if(ident_<1.5){layersNTD1_->Fill(nLayers);}else{layersNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesNTD1_->Fill(ncharges);}else{chargesNTD2_->Fill(ncharges);} + if(ident_<1.5){timesNTD1_->Fill(ntimes);}else{timesNTD2_->Fill(ntimes);} + if(onTrk){ + if(ident_<1.5){layersOnTrkNTD1_->Fill(nLayers);}else{layersOnTrkNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesOnTrkNTD1_->Fill(ncharges);}else{chargesOnTrkNTD2_->Fill(ncharges);} + if(ident_<1.5){timesOnTrkNTD1_->Fill(ntimes);}else{timesOnTrkNTD2_->Fill(ntimes);} + }else{ + if(ident_<1.5){layersOffTrkNTD1_->Fill(nLayers);}else{layersOffTrkNTD2_->Fill(nLayers);} + if(ident_<1.5){chargesOffTrkNTD1_->Fill(ncharges);}else{chargesOffTrkNTD2_->Fill(ncharges);} + if(ident_<1.5){timesOffTrkNTD1_->Fill(ntimes);}else{timesOffTrkNTD2_->Fill(ntimes);} + } + } + } +*/ + +void RoryClusterCompareSeedAnaProcessor::fillDeads(){ + for(int i = 0;i<24576;i++){ + Deads_[i]=0.0; + } + std::string FILENAME="/fs/ddn/sdf/group/hps/users/rodwyer1/run/cluster_study/badchannels2021.dat"; + std::ifstream file(FILENAME.c_str()); + std::string line; + std::getline(file,line); + while (std::getline(file, line)) { + int value = std::atoi(line.c_str()); + Deads_[value]=1.0; + } + file.close(); + return; +} + +int RoryClusterCompareSeedAnaProcessor::GetStrip(int feb,int hyb,int strip){ + int BigCount = 0; + if(feb<=1){ + BigCount+=feb*2048+hyb*512+strip; + }else{ + BigCount+=4096; + BigCount+=(feb-2)*2560+hyb*640+strip; + } + return BigCount; +} + +void RoryClusterCompareSeedAnaProcessor::WriteRoot(){ + TFile *outputFile; + outputFile = new TFile("picHistos.root","RECREATE"); + + /*layers1_->Write(); + layersOnTrk1_->Write(); + layersOffTrk1_->Write(); + charges1_->Write(); + chargesOnTrk1_->Write(); + chargesOffTrk1_->Write(); + charges2D_->Write(); + + layersNTD1_->Write(); + layersOnTrkNTD1_->Write(); + layersOffTrkNTD1_->Write(); + chargesNTD1_->Write(); + chargesOnTrkNTD1_->Write(); + chargesOffTrkNTD1_->Write(); + + positions1_->Write(); + positionsOnTrk1_->Write(); + ClusDistances1_->Write(); + ClusDistancesNTD1_->Write(); + + times1_->Write(); + timesOnTrk1_->Write(); + timesOffTrk1_->Write(); + timesNTD1_->Write(); + timesOnTrkNTD1_->Write(); + timesOffTrkNTD1_->Write(); + + //FOR THE SECOND FILE + + layers2_->Write(); + layersOnTrk2_->Write(); + layersOffTrk2_->Write(); + charges2_->Write(); + chargesOnTrk2_->Write(); + chargesOffTrk2_->Write(); + + layersNTD2_->Write(); + layersOnTrkNTD2_->Write(); + layersOffTrkNTD2_->Write(); + chargesNTD2_->Write(); + chargesOnTrkNTD2_->Write(); + chargesOffTrkNTD2_->Write(); + + positions2_->Write(); + positionsOnTrk2_->Write(); + ClusDistances2_->Write(); + ClusDistancesNTD2_->Write(); + + times2_->Write(); + timesOnTrk2_->Write(); + timesOffTrk2_->Write(); + timesNTD2_->Write(); + timesOnTrkNTD2_->Write(); + timesOffTrkNTD2_->Write(); + */ + + TwoTimes_->Write(); + UnChangedTimes_->Write(); + TwoCharges_->Write(); + UnChangedCharges_->Write(); + SharpPlot_->Write(); + DidItAdd_->Write(); + + //SHARED DISTRIBUTIONS + + DifferenceInPositions_->Write(); + DifferenceInCharges_->Write(); + DifferenceInPositionsVStripNo_->Write(); + DifferenceInPositionVsCharge_->Write(); + DifferenceInPositionVsChargeNTD_->Write(); + MinComboPosition0_->Write(); + MinComboPosition1_->Write(); + MinComboPosition2_->Write(); + MinComboChargeNTD_->Write(); + DeltaTVsDeltaCharge_->Write(); + DeltaTVsDeltaChargeV2_->Write(); + ChargeShared2D_->Write(); + + + //TRACKING RELATED VARIABLES + + Z0VNShare2Hist1_->Write(); + Z0VNShare2HistCut1_->Write(); + SharedAmplitudes1_->Write(); + UnSharedAmplitudes1_->Write(); + SharedTimes1_->Write(); + UnSharedTimes1_->Write(); + TrackMomentumInTime1_->Write(); + TrackMomentumOutTime1_->Write(); + TrackMomentumAllTime1_->Write(); + TrackMomentumTInTime1_->Write(); + TrackMomentumTOutTime1_->Write(); + TrackMomentumTAllTime1_->Write(); + + Z0VNShare2Hist2_->Write(); + Z0VNShare2HistCut2_->Write(); + SharedAmplitudes2_->Write(); + UnSharedAmplitudes2_->Write(); + SharedTimes2_->Write(); + UnSharedTimes2_->Write(); + TrackMomentumInTime2_->Write(); + TrackMomentumOutTime2_->Write(); + TrackMomentumAllTime2_->Write(); + TrackMomentumTInTime2_->Write(); + TrackMomentumTOutTime2_->Write(); + TrackMomentumTAllTime2_->Write(); + + outputFile->Close(); + return; +} +void RoryClusterCompareSeedAnaProcessor::finalize() { + WriteRoot(); + //ClusterFit(); + return; +} +DECLARE_PROCESSOR(RoryClusterCompareSeedAnaProcessor); diff --git a/processors/src/SvtRawDataAnaProcessor.cxx b/processors/src/SvtRawDataAnaProcessor.cxx index bf6cc591b..f81ff1590 100644 --- a/processors/src/SvtRawDataAnaProcessor.cxx +++ b/processors/src/SvtRawDataAnaProcessor.cxx @@ -1,7 +1,7 @@ /** * @file SvtRawDataAnaProcessor.cxx * @brief AnaProcessor used fill histograms to study svt hit fitting - * @author Cameron Bravo, SLAC National Accelerator Laboratory + * @author Rory O'Dwyer and Cameron Bravo, SLAC National Accelerator Laboratory */ #include "SvtRawDataAnaProcessor.h" @@ -210,6 +210,7 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { tree_= tree; + //tree->Show(); // init histos //histos = new RawSvtHitHistos(anaName_.c_str(), mmapper_); //histos->loadHistoConfig(histCfgFilename_); @@ -223,8 +224,16 @@ void SvtRawDataAnaProcessor::initialize(TTree* tree) { //tree_->SetBranchAddress("RecoEcalClusters",&recoClu_,&brecoClu_ ); //tree_->SetBranchAddress("KalmanFullTracks",&Trk_,&bTrk_); tree_->SetBranchAddress("FinalStateParticles_KF",&Part_,&bPart_); + tree_->SetBranchAddress("SiClusters",&Clusters_,&bClusters_); tree_->SetBranchAddress("EventHeader",&evH_,&bevH_); - + + /* + //Making the Hit Efficiency Tree + TTree *HitEff_ = new TTree("hitEff","hitEff"); + HitEff_->Branch("L1",&L1_,"L1/I"); + //HitEff_->SetBranchAddress("L1",&L1_,&bL1_); + */ + for (unsigned int i_reg = 0; i_reg < regionSelections_.size(); i_reg++) { std::string regname = AnaHelpers::getFileName(regionSelections_[i_reg],false); @@ -263,7 +272,11 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { //std::cout<<"Here is the TSBank Trigger Time"<T<prescaled.Single_3_Top==1)or(tsBank_->prescaled.Single_3_Bot==1)))){return true;} @@ -273,37 +286,131 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { //std::cout<<"Trigger Time: "<singletrigs.at(0).T<size(); i++){ - RawSvtHit * thisHit = svtHits_->at(i); + //std::cout<<"I got here 9C"<Fill(); + } + return true; + }*/ + for(unsigned int i = 0; isize();i++){ + Clusters_->at(i)->getLayer(); + } + + for(unsigned int I = 0; I < svtHits_->size(); I++){ + RawSvtHit * thisHit = svtHits_->at(I); int getNum = thisHit->getFitN();//std::cout<<"I got here 10"<size();i++){ - std::cout<<"Do I break here 3"<at(i)->getPDG()==22){continue;} - std::cout<<"Do I break here 4"<at(i)->getCluster().getEnergy()<0){continue;} - std::cout<<"Do I break here 5"<at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} //std::cout<<"For each Tracker Hit I now print out Raw Hit Info: "<at(i)->getTrack().getSvtHits().GetEntries();j++){ - std::cout<<"Do I break here 6"<at(i)->getTrack().getSvtHits().At(j)); + double TrackTime = Part_->at(i)->getTrack().getTrackTime(); //std::cout<getTime()<getRawHits().GetEntries();k++){ RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); - if(rHit->getT0(0)==thisHit->getT0(0)){Continue=false;} + //if(rHit->getT0(0)==thisHit->getT0(0)){ + //STR=rHit->getStrip(); + int mode=0; + if((rHit->getT0(0)==thisHit->getT0(0))and(mode==0)){//or(mode==2))){ + //This is the HIT ON TRACK Modes + bool InCluster = false; + int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER + //std::cout<<"DID I GET HERE B4 CLUSTERS"<size(); Cl++){ + //std::cout<<"DO I GET HERE"<at(Cl)->getRawHits().GetEntries(); Clh++){ + //std::cout<<"DO I GET HERE 2"<at(Cl)->getRawHits().At(Clh)); + if((cluHit->getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ + LAY++; + } + if((cluHit->getT0(0)==thisHit->getT0(0))){//and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ + InCluster = true; + HITC=Clusters_->at(Cl)->getRawHits().GetEntries(); + HITL=LAY; + if(Clusters_->at(Cl)->getRawHits().GetEntries()==2){ + RawSvtHit * otherHit = (RawSvtHit*)(Clusters_->at(Cl)->getRawHits().At((Clh+1)%2)); + otherTime = otherHit->getT0(0); + } + } + //if((mode==2)and((cluHit->getStrip()-thisHit->getStrip())*(cluHit->getStrip()-thisHit->getStrip())<=100)and(rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())and((cluHit->getT0(0)-TrackTime)*(cluHit->getT0(0)-TrackTime)<=(thisHit->getT0(0)-TrackTime)*(thisHit->getT0(0)-TrackTime))){ + // MissHit==true; + //} + } + } + if(InCluster){ + Continue = false; + } + }//std::cout<getLayer()<getT0(0)<=-30)and(not(rHit->getT0(0)==thisHit->getT0(0)))and(mode==1)){ + //This is the HIT OFF TRACK Mode + //You are looking at the really early time on track hits, and specifically at other hits in the same layer and module + //to see if you have evidence of a misplaced hit. + + if((rHit->getLayer()==thisHit->getLayer())and(rHit->getModule()==thisHit->getModule())){ + STR=rHit->getStrip(); + //THIS CONDITIONS ON IT BEING IN CLUSTERS + + + bool InCluster = false; + int LAY = 0;//THE PURPOSE OF LAY IS TO COUNT THE NUMBER OF HITS PER LAYER + //std::cout<<"DID I GET HERE B4 CLUSTERS"<size(); Cl++){ + //std::cout<<"DO I GET HERE"<at(Cl)->getRawHits().GetEntries(); Clh++){ + //std::cout<<"DO I GET HERE 2"<at(Cl)->getRawHits().At(Clh)); + //std::cout<getLayer()<getLayer()==thisHit->getLayer())and(cluHit->getModule()==thisHit->getModule())){ + LAY++; + } + if((cluHit->getT0(0)==thisHit->getT0(0))and(not(Clusters_->at(Cl)->getID()==tHit->getID()))){ + InCluster = true; + HITC=Clusters_->at(Cl)->getRawHits().GetEntries(); + HITL=LAY; + } + } + } + if(InCluster){ + Continue = false; + } + } + } + + + //if(rHit->getT0(0)==thisHit->getT0(0)){ + //Continue=false; + //bool helper=true;//(Part_->at(i)->getTrack().getTrackerHitCount()>=12); + //helper = (helper)and(thisHit->getChiSq(0)<.9); + //helper=(helper)and(Part_->at(i)->getTrack().getChi2()<=8); + //if(helper){ + // Continue=false; + //} + //} //std::cout<<"Raw Hit T0: "<getT0(0)<at(i)->getTrack().getSvtHits().At(j)->getRawHits().At(0).getT0()<FillHistograms(thisHit,weight,J,i,TimeDiff,AmpDiff); - } + reg_histos_[regions_[i_reg]]->FillHistograms(thisHit,weight,J,I,TimeDiff,AmpDiff,STR,HITC,HITL,otherTime); + } } } //std::cout<size();i++){ + //std::cout<<"Do I break here 3"<at(i)->getPDG()==22){continue;} + //std::cout<<"Do I break here 4"<at(i)->getCluster().getEnergy()<0){continue;} + //std::cout<<"Do I break here 5"<at(i)->getCluster().getTime()<=40)and(Part_->at(i)->getCluster().getTime()>=36))){continue;} + //std::cout<<"For each Tracker Hit I now print out Raw Hit Info: "<at(i)->getTrack().getTrackerHitCount()>12){ + deno = 0; + for(int j = 0; jat(i)->getTrack().getSvtHits().GetEntries();j++){ + TrackerHit * tHit = (TrackerHit*)(Part_->at(i)->getTrack().getSvtHits().At(j)); + for(int k = 0;kgetRawHits().GetEntries();k++){ + RawSvtHit * rHit = (RawSvtHit*)(tHit->getRawHits().At(k)); + if((rHit->getLayer()==L)){ + deno = 1; + //I DID THE PROBE + } + } + } + } + } + return deno; +} +*/ + void SvtRawDataAnaProcessor::sample(RawSvtHit* thisHit,std::string word, IEvent* ievent,long T,int N){ auto mod = std::to_string(thisHit->getModule()); @@ -617,6 +744,10 @@ bool SvtRawDataAnaProcessor::process(IEvent* ievent) { void SvtRawDataAnaProcessor::finalize() { outF_->cd(); + /*TDirectory* hitdir{nullptr}; + hitdir = outF_->mkdir("HitEfficiency"); + hitdir->cd(); + HitEff_->Write(); */ for(reg_it it = reg_histos_.begin(); it!=reg_histos_.end(); ++it){ std::string dirName = it->first; (it->second)->saveHistos(outF_,dirName); diff --git a/processors/src/Tracker2DHitProcessor.cxx b/processors/src/Tracker2DHitProcessor.cxx index 4908b5580..0acefae6d 100644 --- a/processors/src/Tracker2DHitProcessor.cxx +++ b/processors/src/Tracker2DHitProcessor.cxx @@ -1,135 +1,161 @@ -#include "Tracker2DHitProcessor.h" -#include "utilities.h" - -Tracker2DHitProcessor::Tracker2DHitProcessor(const std::string& name, Process& process) - : Processor(name, process) { -} - -Tracker2DHitProcessor::~Tracker2DHitProcessor() { -} - -void Tracker2DHitProcessor::configure(const ParameterSet& parameters) { - - std::cout << "Configuring Tracker2DHitProcessor" << std::endl; - try - { - debug_ = parameters.getInteger("debug", debug_); - hitCollLcio_ = parameters.getString("hitCollLcio", hitCollLcio_); - hitCollRoot_ = parameters.getString("hitCollRoot", hitCollRoot_); - mcPartRelLcio_ = parameters.getString("mcPartRelLcio", mcPartRelLcio_); - } - catch (std::runtime_error& error) - { - std::cout << error.what() << std::endl; - } -} - -void Tracker2DHitProcessor::initialize(TTree* tree) { - // Add branches to tree - tree->Branch(hitCollRoot_.c_str(), &hits_); -} - -bool Tracker2DHitProcessor::process(IEvent* ievent) { - - for(int i = 0; i < hits_.size(); i++) delete hits_.at(i); - hits_.clear(); - - Event* event = static_cast (ievent); - UTIL::LCRelationNavigator* mcPartRel_nav; - - // Get the collection of 2D hits from the LCIO event. If no such collection - // exist, a DataNotAvailableException is thrown - EVENT::LCCollection* tracker_hits{nullptr}; - try - { - tracker_hits = event->getLCCollection(hitCollLcio_.c_str()); - } - catch (EVENT::DataNotAvailableException e) - { - std::cout << e.what() << std::endl; - } - - //Check to see if MC Particles are in the file - auto evColls = event->getLCEvent()->getCollectionNames(); - auto it = std::find (evColls->begin(), evColls->end(), mcPartRelLcio_.c_str()); - bool hasMCParts = true; - EVENT::LCCollection* mcPartRel; - if(it == evColls->end()) hasMCParts = false; - if(hasMCParts) - { - mcPartRel = event->getLCCollection(mcPartRelLcio_.c_str()); - // Heap an LCRelation navigator which will allow faster access - mcPartRel_nav = new UTIL::LCRelationNavigator(mcPartRel); - - } - - // Create a map from an LCIO TrackerHit to a SvtHit. This will be used when - // assigning references to a track - // TODO: Use an unordered map for faster access - std::map hit_map; - - // Loop over all of the 2D hits in the LCIO event and add them to the - // HPS event - for (int ihit = 0; ihit < tracker_hits->getNumberOfElements(); ++ihit) { - - // Get a 2D hit from the list of hits - IMPL::TrackerHitImpl* lc_tracker_hit = static_cast(tracker_hits->getElementAt(ihit)); - - if(debug_ > 0) - std::cout << "tracker hit lcio id: " << lc_tracker_hit->id() << std::endl; - - // Build a TrackerHit - TrackerHit* tracker_hit = utils::buildTrackerHit(lc_tracker_hit); - - if(hasMCParts) - { - //Get the SvtRawTrackerHits that make up the 2D hit - EVENT::LCObjectVec rawHits = lc_tracker_hit->getRawHits(); - for(int irawhit = 0; irawhit < rawHits.size(); ++irawhit){ - IMPL::TrackerHitImpl* rawhit = static_cast(rawHits.at(irawhit)); - if(debug_ > 0) - std::cout << "rawhit on track has lcio id: " << rawhit->id() << std::endl; - - // Get the list of fit params associated with the raw tracker hit - EVENT::LCObjectVec lc_simtrackerhits = mcPartRel_nav->getRelatedToObjects(rawhit); - - //Loop over SimTrackerHits to get MCParticles - for(int isimhit = 0; isimhit < lc_simtrackerhits.size(); isimhit++){ - IMPL::SimTrackerHitImpl* lc_simhit = static_cast(lc_simtrackerhits.at(isimhit)); - IMPL::MCParticleImpl* lc_mcp = static_cast(lc_simhit->getMCParticle()); - tracker_hit->addMCPartID(lc_mcp->id()); - if(debug_ > 0) { - std::cout << "simtrackerhit lcio id: " << lc_simhit->id() << std::endl; - std::cout << "mcp lcio id: " << lc_mcp->id() << std::endl; - } - } - - /* - // Get all the MC Particle IDs associated to the hit - for(int ipart = 0; ipart < mcPart_list.size(); ipart++) - { - IMPL::MCParticleImpl* lc_particle - = static_cast(mcPart_list.at(ipart)); - tracker_hit->addMCPartID(lc_particle->id()); - if(debug_ > 0) std::cout << "Has Related MC Particle with ID " << lc_particle->id() << std::endl; - } - */ - } - } - - // Map the TrackerHit object to the corresponding SvtHit object. This - // will be used later when setting references for hits on tracks. - //hit_map[lc_tracker_hit] = tracker_hit; - hits_.push_back(tracker_hit); - - } - - if(hasMCParts) delete mcPartRel_nav; - - return true; -} - -void Tracker2DHitProcessor::finalize() { -} - -DECLARE_PROCESSOR(Tracker2DHitProcessor); +#include "Tracker2DHitProcessor.h" +#include "utilities.h" + +Tracker2DHitProcessor::Tracker2DHitProcessor(const std::string& name, Process& process) + : Processor(name, process) { +} + +Tracker2DHitProcessor::~Tracker2DHitProcessor() { +} + +void Tracker2DHitProcessor::configure(const ParameterSet& parameters) { + + std::cout << "Configuring Tracker2DHitProcessor" << std::endl; + try + { + debug_ = parameters.getInteger("debug", debug_); + hitCollLcio_ = parameters.getString("hitCollLcio", hitCollLcio_); + hitCollRoot_ = parameters.getString("hitCollRoot", hitCollRoot_); + hitFitsCollLcio_ = parameters.getString("hitFitsCollLcio", hitFitsCollLcio_); + rawhitCollRoot_ = parameters.getString("rawhitCollRoot", hitCollRoot_); + mcPartRelLcio_ = parameters.getString("mcPartRelLcio", mcPartRelLcio_); + } + catch (std::runtime_error& error) + { + std::cout << error.what() << std::endl; + } +} + +void Tracker2DHitProcessor::initialize(TTree* tree) { + // Add branches to tree + tree->Branch(hitCollRoot_.c_str(), &hits_); + if (!rawhitCollRoot_.empty()) + tree->Branch(rawhitCollRoot_.c_str(), &rawhits_); +} + +bool Tracker2DHitProcessor::process(IEvent* ievent) { + + for(int i = 0; i < hits_.size(); i++) delete hits_.at(i); + hits_.clear(); + + if (rawhits_.size() > 0) { + for (std::vector::iterator it = rawhits_.begin(); it != rawhits_.end(); ++it) { + delete *it; + } + rawhits_.clear(); + } + + Event* event = static_cast (ievent); + UTIL::LCRelationNavigator* mcPartRel_nav; + + // Get the collection of 2D hits from the LCIO event. If no such collection + // exist, a DataNotAvailableException is thrown + EVENT::LCCollection* tracker_hits{nullptr}; + try + { + tracker_hits = event->getLCCollection(hitCollLcio_.c_str()); + } + catch (EVENT::DataNotAvailableException e) + { + std::cout << e.what() << std::endl; + } + + //Check to see if MC Particles are in the file + auto evColls = event->getLCEvent()->getCollectionNames(); + auto mcit = std::find (evColls->begin(), evColls->end(), mcPartRelLcio_.c_str()); + bool hasMCParts = true; + EVENT::LCCollection* mcPartRel; + if(mcit == evColls->end()) hasMCParts = false; + if(hasMCParts) + { + mcPartRel = event->getLCCollection(mcPartRelLcio_.c_str()); + // Heap an LCRelation navigator which will allow faster access + mcPartRel_nav = new UTIL::LCRelationNavigator(mcPartRel); + + } + + // Create a map from an LCIO TrackerHit to a SvtHit. This will be used when + // assigning references to a track + // TODO: Use an unordered map for faster access + std::map hit_map; + + EVENT::LCCollection* raw_svt_hit_fits = nullptr; + auto fitit = std::find (evColls->begin(), evColls->end(), hitFitsCollLcio_.c_str()); + bool hasFits = true; + if(fitit == evColls->end()) hasFits = false; + if(hasFits) + { + raw_svt_hit_fits = event->getLCCollection(hitFitsCollLcio_.c_str()); + } + + // Loop over all of the 2D hits in the LCIO event and add them to the + // HPS event + for (int ihit = 0; ihit < tracker_hits->getNumberOfElements(); ++ihit) { + + // Get a 2D hit from the list of hits + IMPL::TrackerHitImpl* lc_tracker_hit = static_cast(tracker_hits->getElementAt(ihit)); + + if(debug_ > 0) + std::cout << "tracker hit lcio id: " << lc_tracker_hit->id() << std::endl; + + // Build a TrackerHit + TrackerHit* tracker_hit = utils::buildTrackerHit(lc_tracker_hit,true,1); + std::vector rawSvthits; + utils::addRawInfoTo3dHit(tracker_hit, lc_tracker_hit, raw_svt_hit_fits,&rawSvthits,1); + for (auto rhit : rawSvthits) + rawhits_.push_back(rhit); + + + if(hasMCParts) + { + //Get the SvtRawTrackerHits that make up the 2D hit + EVENT::LCObjectVec rawHits = lc_tracker_hit->getRawHits(); + for(int irawhit = 0; irawhit < rawHits.size(); ++irawhit) + { + IMPL::TrackerHitImpl* rawhit = static_cast(rawHits.at(irawhit)); + if(debug_ > 0) + std::cout << "rawhit on track has lcio id: " << rawhit->id() << std::endl; + + // Get the list of fit params associated with the raw tracker hit + EVENT::LCObjectVec lc_simtrackerhits = mcPartRel_nav->getRelatedToObjects(rawhit); + + //Loop over SimTrackerHits to get MCParticles + for(int isimhit = 0; isimhit < lc_simtrackerhits.size(); isimhit++){ + IMPL::SimTrackerHitImpl* lc_simhit = static_cast(lc_simtrackerhits.at(isimhit)); + IMPL::MCParticleImpl* lc_mcp = static_cast(lc_simhit->getMCParticle()); + tracker_hit->addMCPartID(lc_mcp->id()); + if(debug_ > 0) { + std::cout << "simtrackerhit lcio id: " << lc_simhit->id() << std::endl; + std::cout << "mcp lcio id: " << lc_mcp->id() << std::endl; + } + } + + /* + // Get all the MC Particle IDs associated to the hit + for(int ipart = 0; ipart < mcPart_list.size(); ipart++) + { + IMPL::MCParticleImpl* lc_particle + = static_cast(mcPart_list.at(ipart)); + tracker_hit->addMCPartID(lc_particle->id()); + if(debug_ > 0) std::cout << "Has Related MC Particle with ID " << lc_particle->id() << std::endl; + } + */ + } + } + + // Map the TrackerHit object to the corresponding SvtHit object. This + // will be used later when setting references for hits on tracks. + //hit_map[lc_tracker_hit] = tracker_hit; + hits_.push_back(tracker_hit); + + } + + if(hasMCParts) delete mcPartRel_nav; + + return true; +} + +void Tracker2DHitProcessor::finalize() { +} + +DECLARE_PROCESSOR(Tracker2DHitProcessor);