From d4582d80ff0261fba1dea2c2c171e1beab0cbae9 Mon Sep 17 00:00:00 2001 From: vsitaraman Date: Mon, 12 May 2025 17:21:25 -0400 Subject: [PATCH] modified: GainMatch.C new file: GainMatchSX3.C new file: GainMatchSX3.h --- .vscode/settings.json | 5 +- GainMatch.C | 7 -- GainMatchSX3.C | 235 ++++++++++++++++++++++++++++++++++++++++++ GainMatchSX3.h | 114 ++++++++++++++++++++ 4 files changed, 353 insertions(+), 8 deletions(-) create mode 100644 GainMatchSX3.C create mode 100644 GainMatchSX3.h diff --git a/.vscode/settings.json b/.vscode/settings.json index 04ae739..556dce7 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -106,7 +106,10 @@ "FitHistogramsWithTSpectrum_Sequential_Improved.C": "cpp", "PlotAndFitCentroids.C": "cpp", "MatchAndPlotCentroids.C": "cpp", - "GainMatch.C": "cpp" + "GainMatch.C": "cpp", + "GainMatchSX3.C": "cpp", + "RelBack_Fix_new.C": "cpp", + "SiRelativeGains_Step1_new.C": "cpp" }, "github-enterprise.uri": "https://fsunuc.physics.fsu.edu" } \ No newline at end of file diff --git a/GainMatch.C b/GainMatch.C index f783550..a5df348 100644 --- a/GainMatch.C +++ b/GainMatch.C @@ -12,7 +12,6 @@ #include #include "Armory/ClassSX3.h" -#include "Armory/ClassPW.h" #include "TVector3.h" @@ -22,9 +21,6 @@ TH2F *hQQQFVB; int padID = 0; SX3 sx3_contr; -PW pw_contr; -TVector3 hitPos; -bool HitNonZero; TCutG *cut; std::map, std::vector>> dataPoints; @@ -36,7 +32,6 @@ void GainMatch::Begin(TTree * /*tree*/) hQQQFVB = new TH2F("hQQQFVB", "number of good QQQ vs QQQ id", 400, 0, 16000, 400, 0, 16000); sx3_contr.ConstructGeo(); - pw_contr.ConstructGeo(); // Load the TCutG object TFile *cutFile = TFile::Open("qqqcorr.root"); @@ -56,8 +51,6 @@ void GainMatch::Begin(TTree * /*tree*/) Bool_t GainMatch::Process(Long64_t entry) { - hitPos.Clear(); - HitNonZero = false; b_sx3Multi->GetEntry(entry); b_sx3ID->GetEntry(entry); diff --git a/GainMatchSX3.C b/GainMatchSX3.C new file mode 100644 index 0000000..9df8505 --- /dev/null +++ b/GainMatchSX3.C @@ -0,0 +1,235 @@ +#define GainMatchSX3_cxx + +#include "GainMatchSX3.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "Armory/ClassSX3.h" + +#include "TVector3.h" + +TH2F *hSX3FvsB; +TH2F *hQQQFVB; + +int padID = 0; + +SX3 sx3_contr; +TCutG *cut; +std::map, std::vector>> dataPoints; + +void GainMatchSX3::Begin(TTree * /*tree*/) +{ + TString option = GetOption(); + + hSX3FvsB = new TH2F("hSX3FvsB", "SX3 Front vs Back; Front E; Back E", 400, 0, 16000, 400, 0, 16000); + + sx3_contr.ConstructGeo(); + + // Load the TCutG object + TFile *cutFile = TFile::Open("sx3cut.root"); + if (!cutFile || cutFile->IsZombie()) + { + std::cerr << "Error: Could not open sx3cut.root" << std::endl; + return; + } + cut = dynamic_cast(cutFile->Get("sx3cut")); + if (!cut) + { + std::cerr << "Error: Could not find TCutG named 'sx3cut' in sx3cut.root" << std::endl; + return; + } + cut->SetName("sx3cut"); // Ensure the cut has the correct name +} + +Bool_t GainMatchSX3::Process(Long64_t entry) +{ + + b_sx3Multi->GetEntry(entry); + b_sx3ID->GetEntry(entry); + b_sx3Ch->GetEntry(entry); + b_sx3E->GetEntry(entry); + b_sx3T->GetEntry(entry); + b_qqqMulti->GetEntry(entry); + b_qqqID->GetEntry(entry); + b_qqqCh->GetEntry(entry); + b_qqqE->GetEntry(entry); + b_qqqT->GetEntry(entry); + b_pcMulti->GetEntry(entry); + b_pcID->GetEntry(entry); + b_pcCh->GetEntry(entry); + b_pcE->GetEntry(entry); + b_pcT->GetEntry(entry); + + sx3.CalIndex(); + qqq.CalIndex(); + pc.CalIndex(); + + std::vector> ID; + for (int i = 0; i < sx3.multi; i++) + { + ID.push_back(std::pair(sx3.id[i], i)); + } + + if (ID.size() > 0) + { + std::sort(ID.begin(), ID.end(), [](const std::pair &a, const std::pair &b) + { return a.first < b.first; }); + + std::vector> sx3ID; + sx3ID.push_back(ID[0]); + bool found = false; + + for (size_t i = 1; i < ID.size(); i++) + { + if (ID[i].first == sx3ID.back().first) + { + sx3ID.push_back(ID[i]); + if (sx3ID.size() >= 3) + { + found = true; + } + } + else + { + if (!found) + { + sx3ID.clear(); + sx3ID.push_back(ID[i]); + } + } + } + + if (found) + { + int sx3ChUp = -1, sx3ChDn = -1, sx3ChBk = -1; + float sx3EUp = 0.0, sx3EDn = 0.0, sx3EBk = 0.0; + + for (size_t i = 0; i < sx3ID.size(); i++) + { + int index = sx3ID[i].second; + if (sx3.ch[index] < 8) + { + if (sx3.ch[index] % 2 == 0) + { + sx3ChDn = sx3.ch[index]/2; + sx3EDn = sx3.e[index]; + } + else + { + sx3ChUp = sx3.ch[index]/2; + sx3EUp = sx3.e[index]; + } + } + else + { + sx3ChBk = sx3.ch[index]; + sx3EBk = sx3.e[index]; + } + } + hSX3FvsB->Fill(sx3EUp + sx3EDn, sx3EBk); + + for (int i = 0; i < sx3.multi; i++) + { + TString histName = Form("hSX3FVB_id%d_F%d_L+R%d", sx3.id[i], sx3ChUp, sx3ChBk); + TH2F *hist2d = (TH2F *)gDirectory->Get(histName); + if (!hist2d) + { + hist2d = new TH2F(histName, Form("hSX3FVB_id%d_F%d_L+R%d", sx3.id[i], sx3ChUp, sx3ChBk), 400, 0, 16000, 400, 0, 16000); + } + + hist2d->Fill(sx3EUp + sx3EDn, sx3EBk); + if (cut && cut->IsInside(sx3EUp + sx3EDn, sx3EBk)) + { + // Accumulate data for gain matching + dataPoints[{sx3.id[i], sx3ChUp, sx3ChBk}].emplace_back(sx3EBk, sx3EUp + sx3EDn); + } + } + } + } + + return kTRUE; +} + +void GainMatchSX3::Terminate() +{ + const int MAX_DET = 24; + const int MAX_UP = 4; + const int MAX_DOWN = 4; + const int MAX_BK = 4; + + double gainArray[MAX_DET][MAX_UP][MAX_BK] = {{{0}}}; + bool gainValid[MAX_DET][MAX_UP][MAX_BK] = {{{false}}}; + + std::ofstream outFile("sx3_GainMatch.txt"); + if (!outFile.is_open()) + { + std::cerr << "Error opening output file!" << std::endl; + return; + } + + for (const auto &kv : dataPoints) + { + auto [id, ud,bk] = kv.first; + const auto &pts = kv.second; + if (pts.size() < 5) + continue; + + std::vector bkE, udE; + for (const auto &pr : pts) + { + bkE.push_back(pr.first); + udE.push_back(pr.second); + } + + TGraph g(bkE.size(), bkE.data(), udE.data()); + TF1 f("f", "[0]*x", 0, 16000); + g.Fit(&f, "QNR"); + gainArray[id][ud][bk] = f.GetParameter(0); + gainValid[id][ud][bk] = true; + } + + for (int id = 0; id < MAX_DET; ++id) + { + for (int bk = 0; bk < MAX_BK; ++bk) + { + for (int ud = 0; ud < MAX_UP; ++ud) + { + if (gainValid[id][ud][bk]) + { + outFile << id << " " << bk << " " << ud << " " << gainArray[id][ud][bk] << std::endl; + printf("Gain match Det%d Up+Dn%d Back%d → %.4f \n", id, ud, bk, gainArray[id][ud][bk]); + } + } + } + } + + outFile.close(); + std::cout << "Gain matching complete." << std::endl; + + // === Plot all gain-matched QQQ points together with a 2D histogram === + TH2F *hAll = new TH2F("hAll", "All SX3 Gain-Matched;Corrected Back E;Up+dn E", + 400, 0, 16000, 400, 0, 16000); + + // Fill the combined TH2F with corrected data + for (auto &kv : dataPoints) + { + int id, ud, bk; + std::tie(id, ud, bk) = kv.first; + if (!gainValid[id][ud][bk]) + continue; + auto &pts = kv.second; + for (auto &pr : pts) + { + double corrBack = pr.first * gainArray[id][ud][bk]; + double udE = pr.second; + hAll->Fill(corrBack, udE); + } + } +} diff --git a/GainMatchSX3.h b/GainMatchSX3.h new file mode 100644 index 0000000..5088a32 --- /dev/null +++ b/GainMatchSX3.h @@ -0,0 +1,114 @@ +#ifndef GainMatchSX3_h +#define GainMatchSX3_h + +#include +#include +#include +#include + +#include "Armory/ClassDet.h" + +class GainMatchSX3 : public TSelector { +public : + TTree *fChain; //!pointer to the analyzed TTree or TChain + +// Fixed size dimensions of array or collections stored in the TTree if any. + + // Declaration of leaf types + Det sx3; + Det qqq; + Det pc ; + + ULong64_t evID; + UInt_t run; + + // List of branches + TBranch *b_eventID; //! + TBranch *b_run; //! + TBranch *b_sx3Multi; //! + TBranch *b_sx3ID; //! + TBranch *b_sx3Ch; //! + TBranch *b_sx3E; //! + TBranch *b_sx3T; //! + TBranch *b_qqqMulti; //! + TBranch *b_qqqID; //! + TBranch *b_qqqCh; //! + TBranch *b_qqqE; //! + TBranch *b_qqqT; //! + TBranch *b_pcMulti; //! + TBranch *b_pcID; //! + TBranch *b_pcCh; //! + TBranch *b_pcE; //! + TBranch *b_pcT; //! + + GainMatchSX3(TTree * /*tree*/ =0) : fChain(0) { } + virtual ~GainMatchSX3() { } + virtual Int_t Version() const { return 2; } + virtual void Begin(TTree *tree); + virtual void SlaveBegin(TTree *tree); + virtual void Init(TTree *tree); + virtual Bool_t Notify(); + virtual Bool_t Process(Long64_t entry); + virtual Int_t GetEntry(Long64_t entry, Int_t getall = 0) { return fChain ? fChain->GetTree()->GetEntry(entry, getall) : 0; } + virtual void SetOption(const char *option) { fOption = option; } + virtual void SetObject(TObject *obj) { fObject = obj; } + virtual void SetInputList(TList *input) { fInput = input; } + virtual TList *GetOutputList() const { return fOutput; } + virtual void SlaveTerminate(); + virtual void Terminate(); + + ClassDef(GainMatchSX3,0); +}; + +#endif + +#ifdef GainMatchSX3_cxx +void GainMatchSX3::Init(TTree *tree){ + + // Set branch addresses and branch pointers + if (!tree) return; + fChain = tree; + fChain->SetMakeClass(1); + + fChain->SetBranchAddress("evID", &evID, &b_eventID); + fChain->SetBranchAddress("run", &run, &b_run); + + sx3.SetDetDimension(24,12); + qqq.SetDetDimension(4,32); + pc.SetDetDimension(2,24); + + fChain->SetBranchAddress("sx3Multi", &sx3.multi, &b_sx3Multi); + fChain->SetBranchAddress("sx3ID", &sx3.id, &b_sx3ID); + fChain->SetBranchAddress("sx3Ch", &sx3.ch, &b_sx3Ch); + fChain->SetBranchAddress("sx3E", &sx3.e, &b_sx3E); + fChain->SetBranchAddress("sx3T", &sx3.t, &b_sx3T); + fChain->SetBranchAddress("qqqMulti", &qqq.multi, &b_qqqMulti); + fChain->SetBranchAddress("qqqID", &qqq.id, &b_qqqID); + fChain->SetBranchAddress("qqqCh", &qqq.ch, &b_qqqCh); + fChain->SetBranchAddress("qqqE", &qqq.e, &b_qqqE); + fChain->SetBranchAddress("qqqT", &qqq.t, &b_qqqT); + fChain->SetBranchAddress("pcMulti", &pc.multi, &b_pcMulti); + fChain->SetBranchAddress("pcID", &pc.id, &b_pcID); + fChain->SetBranchAddress("pcCh", &pc.ch, &b_pcCh); + fChain->SetBranchAddress("pcE", &pc.e, &b_pcE); + fChain->SetBranchAddress("pcT", &pc.t, &b_pcT); + +} + +Bool_t GainMatchSX3::Notify(){ + + return kTRUE; +} + +void GainMatchSX3::SlaveBegin(TTree * /*tree*/){ + + TString option = GetOption(); + +} + +void GainMatchSX3::SlaveTerminate(){ + +} + + +#endif // #ifdef GainMatchSX3_cxx \ No newline at end of file