Sudarsan Balakrishnan
b2242ccacd
A lot of the files are identical to old ones, but the main changes are: 1) EXFit2.C in sx3cal - Finds front/right gains for each strip using the known middle two pad edges, but gainmatches all backs 2) Define new 'fix' loci, arising from the step-ladder correction to A1C2 events. This is tested in scratch/sx3z_vs_pcz/testmodel.h, will be given a better name in the future. 3) Explore A1C2 and A1C3 loci in detail 4) environment variables to 'flip' and 'offset' wires during sort. All env vars are set in shell scripts that call them 5) environment variables that allow for timestamp bounds to be set and unset. Default limiting values are 0 and dbl_max so no harm done unless these specific env vars are set. 6) Some bookkeeping indicating 27Al instead of 26Al in all places.
455 lines
14 KiB
C
455 lines
14 KiB
C
#define PCGainMatch_cxx
|
|
|
|
#include "PCGainMatch.h"
|
|
#include <TH2.h>
|
|
#include <TStyle.h>
|
|
#include <TCanvas.h>
|
|
#include <TMath.h>
|
|
#include <TCutG.h>
|
|
#include <utility>
|
|
#include <algorithm>
|
|
#include "Armory/ClassSX3.h"
|
|
#include "Armory/ClassPW.h"
|
|
|
|
#include "TVector3.h"
|
|
|
|
TH2F * hsx3IndexVE;
|
|
TH2F * hqqqIndexVE;
|
|
TH2F * hpcIndexVE;
|
|
|
|
TH2F * hsx3Coin;
|
|
TH2F * hqqqCoin;
|
|
TH2F * hpcCoin;
|
|
|
|
TH2F * hqqqPolar;
|
|
TH2F * hsx3VpcIndex;
|
|
TH2F * hqqqVpcIndex;
|
|
TH2F * hqqqVpcE;
|
|
TH2F * hsx3VpcE;
|
|
TH2F * hanVScatsum;
|
|
TH2F * hanVScatsum_a[24];
|
|
TH2F * hanVScatsum_hcut;
|
|
TH2F * hanVScatsum_lcut;
|
|
TH2F * hAnodeHits;
|
|
TH1F * hAnodeMultiplicity;
|
|
|
|
|
|
int padID = 0;
|
|
|
|
SX3 sx3_contr;
|
|
PW pw_contr;
|
|
TVector3 hitPos;
|
|
bool HitNonZero;
|
|
|
|
TH1F * hZProj;
|
|
TCutG *AnCatSum_high;
|
|
TCutG *AnCatSum_low;
|
|
TCutG *PCCoinc_cut1;
|
|
TCutG *PCCoinc_cut2;
|
|
bool inCuth;
|
|
bool inCutl;
|
|
bool inPCCut;
|
|
|
|
void PCGainMatch::Begin(TTree * /*tree*/){
|
|
TString option = GetOption();
|
|
|
|
hsx3IndexVE = new TH2F("hsx3IndexVE", "SX3 index vs Energy; sx3 index ; Energy", 24*12, 0, 24*12, 400, 0, 5000); hsx3IndexVE->SetNdivisions( -612, "x");
|
|
hqqqIndexVE = new TH2F("hqqqIndexVE", "QQQ index vs Energy; QQQ index ; Energy", 4*2*16, 0, 4*2*16, 400, 0, 5000); hqqqIndexVE->SetNdivisions( -1204, "x");
|
|
hpcIndexVE = new TH2F("hpcIndexVE", "PC index vs Energy; PC index ; Energy", 2*24, 0, 2*24, 800, 0, 16000); hpcIndexVE->SetNdivisions( -1204, "x");
|
|
|
|
|
|
hsx3Coin = new TH2F("hsx3Coin", "SX3 Coincident", 24*12, 0, 24*12, 24*12, 0, 24*12);
|
|
hqqqCoin = new TH2F("hqqqCoin", "QQQ Coincident", 4*2*16, 0, 4*2*16, 4*2*16, 0, 4*2*16);
|
|
hpcCoin = new TH2F("hpcCoin", "PC Coincident", 2*24, 0, 2*24, 2*24, 0, 2*24);
|
|
|
|
hqqqPolar = new TH2F("hqqqPolar", "QQQ Polar ID", 16*4, -TMath::Pi(), TMath::Pi(),16, 10, 50);
|
|
|
|
hsx3VpcIndex = new TH2F("hsx3Vpcindex", "sx3 vs pc; sx3 index; pc index", 24*12, 0, 24*12, 48, 0, 48);
|
|
hsx3VpcIndex->SetNdivisions( -612, "x");
|
|
hsx3VpcIndex->SetNdivisions( -12, "y");
|
|
hqqqVpcIndex = new TH2F("hqqqVpcindex", "qqq vs pc; qqq index; pc index", 4*2*16, 0, 4*2*16, 48, 0, 48);
|
|
hqqqVpcIndex->SetNdivisions( -612, "x");
|
|
hqqqVpcIndex->SetNdivisions( -12, "y");
|
|
|
|
hqqqVpcE = new TH2F("hqqqVpcEnergy", "qqq vs pc; qqq energy; pc energy", 400, 0, 5000, 400, 0, 5000);
|
|
hqqqVpcE->SetNdivisions( -612, "x");
|
|
hqqqVpcE->SetNdivisions( -12, "y");
|
|
|
|
hsx3VpcE = new TH2F("hsx3VpcEnergy", "sx3 vs pc; sx3 energy; pc energy", 400, 0, 5000, 400, 0, 5000);
|
|
hsx3VpcE->SetNdivisions( -612, "x");
|
|
hsx3VpcE->SetNdivisions( -12, "y");
|
|
|
|
hZProj = new TH1F("hZProj", "Nos of anodes", 20, 0, 19);
|
|
hAnodeHits = new TH2F("hAnodeHits", "Anode vs Anode Energy, Anode ID; Anode E", 24,0 , 23, 400, 0 , 20000);
|
|
hAnodeMultiplicity = new TH1F("hAnodeMultiplicity", "Number of Anodes/Event", 40, 0, 40);
|
|
hanVScatsum = new TH2F("hanVScatsum", "Anode vs Cathode Sum; Anode E; Cathode E", 400,0 , 10000, 800, 0 , 16000);
|
|
for (int i = 0; i < 24; i++) {
|
|
TString histName = Form("hAnodeVsCathode_%d", i);
|
|
TString histTitle = Form("Anode %d vs Cathode Sum; Anode E; Cathode Sum E", i);
|
|
hanVScatsum_a[i] = new TH2F(histName, histTitle, 400, 0, 10000, 400, 0, 16000);
|
|
}
|
|
hanVScatsum_lcut = new TH2F("hanVScatsum_LCUT", "Anode vs Cathode Sum; Anode E; Cathode E", 400,0 , 16000, 400, 0 , 16000);
|
|
hanVScatsum_hcut = new TH2F("hanVScatsum_HCUT", "Anode vs Cathode Sum; Anode E; Cathode E", 400,0 , 16000, 400, 0 , 16000);
|
|
|
|
sx3_contr.ConstructGeo();
|
|
pw_contr.ConstructGeo();
|
|
// TFile *f1 = new TFile("AnCatSum_high.root");
|
|
// TFile *f2 = new TFile("AnCatSum_low.root");
|
|
// TFile *f3 = new TFile("PCCoinc_cut1.root");
|
|
// TFile *f4 = new TFile("PCCoinc_cut2.root");
|
|
// AnCatSum_high= (TCutG*)f1->Get("AnCatSum_high");
|
|
// AnCatSum_low= (TCutG*)f2->Get("AnCatSum_low");
|
|
// PCCoinc_cut1= (TCutG*)f3->Get("PCCoinc_cut1");
|
|
// PCCoinc_cut2= (TCutG*)f4->Get("PCCoinc_cut2");
|
|
}
|
|
|
|
|
|
|
|
|
|
Bool_t PCGainMatch::Process(Long64_t entry){
|
|
// if (entry % 1000000 == 0) {
|
|
// std::cout << "Processing entry: " << entry << std::endl;
|
|
// }
|
|
// if ( entry > 100 ) return kTRUE;
|
|
|
|
hitPos.Clear();
|
|
HitNonZero = false;
|
|
|
|
// if( entry > 1) return kTRUE;
|
|
// printf("################### ev : %llu \n", 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();
|
|
|
|
// sx3.Print();
|
|
|
|
//########################################################### Raw data
|
|
|
|
// //======================= PC
|
|
|
|
std::vector<std::pair<int, double>> anodeHits={};
|
|
std::vector<std::pair<int, double>> cathodeHits={};
|
|
int aID = 0;
|
|
int cID = 0;
|
|
float aE = 0;
|
|
float cE = 0;
|
|
|
|
// Define the excluded SX3 and QQQ channels
|
|
// std::unordered_set<int> excludeSX3 = {34, 35, 36, 37, 61, 62, 67, 73, 74, 75, 76, 77, 78, 79, 80, 93, 97, 100, 103, 108, 109, 110, 111, 112};
|
|
// std::unordered_set<int> excludeQQQ = {0, 17, 109, 110, 111, 112, 113, 119, 127, 128};
|
|
// inCuth=false;
|
|
// inCutl=false;
|
|
// inPCCut=false;
|
|
for( int i = 0; i < pc.multi; i ++){
|
|
|
|
if(pc.e[i]>50 && pc.multi<7){
|
|
|
|
float aESum = 0;
|
|
float cESum = 0;
|
|
if (pc.index[i] < 24 ) {
|
|
anodeHits.push_back(std::pair<int, double>(pc.index[i], pc.e[i]));
|
|
} else if (pc.index[i] >= 24) {
|
|
cathodeHits.push_back(std::pair<int, double>(pc.index[i], pc.e[i]));
|
|
}
|
|
|
|
for(int j=i+1;j<pc.multi;j++){
|
|
// if(PCCoinc_cut1->IsInside(pc.index[i], pc.index[j]) || PCCoinc_cut2->IsInside(pc.index[i], pc.index[j])){
|
|
// // hpcCoin->Fill(pc.index[i], pc.index[j]);
|
|
// inPCCut = true;
|
|
// }
|
|
hpcCoin->Fill(pc.index[i], pc.index[j]);
|
|
}
|
|
if (anodeHits.size()==1 && cathodeHits.size() >= 1) {
|
|
|
|
for (const auto& anode : anodeHits) {
|
|
// for(int l=0; l<sx3.multi; l++){
|
|
// if (sx3.index[l]==80){
|
|
|
|
aID = anode.first;
|
|
aE = anode.second;
|
|
aESum += aE;
|
|
// printf("aID : %d, aE : %f\n", aID, aE);
|
|
}
|
|
|
|
// printf("aID : %d, aE : %f, cE : %f\n", aID, aE, cE);
|
|
for (const auto& cathode : cathodeHits) {
|
|
cID = cathode.first;
|
|
cE = cathode.second;
|
|
// if(cE>cEMax){
|
|
// cEMax = cE;
|
|
// cIDMax = cID;
|
|
// }
|
|
// if(cE>cEnextMax && cE<cEMax){
|
|
// cEnextMax = cE;
|
|
// cIDnextMax = cID;
|
|
// }
|
|
|
|
cESum += cE;
|
|
}
|
|
// }
|
|
|
|
// inCuth = false;
|
|
// inCutl = false;
|
|
// inPCCut = false;
|
|
// for(int j=i+1;j<pc.multi;j++){
|
|
// if(PCCoinc_cut1->IsInside(pc.index[i], pc.index[j]) || PCCoinc_cut2->IsInside(pc.index[i], pc.index[j])){
|
|
// // hpcCoin->Fill(pc.index[i], pc.index[j]);
|
|
// inPCCut = true;
|
|
// }
|
|
// hpcCoin->Fill(pc.index[i], pc.index[j]);
|
|
// }
|
|
|
|
// Check if the accumulated energies are within the defined ranges
|
|
// if (AnCatSum_high && AnCatSum_high->IsInside(aESum, cESum)) {
|
|
// inCuth = true;
|
|
// }
|
|
// if (AnCatSum_low && AnCatSum_low->IsInside(aESum, cESum)) {
|
|
// inCutl = true;
|
|
// }
|
|
|
|
// Fill histograms based on the cut conditions
|
|
// if (inCuth && inPCCut) {
|
|
// hanVScatsum_hcut->Fill(aESum, cESum);
|
|
// }
|
|
// if (inCutl && inPCCut) {
|
|
// hanVScatsum_lcut->Fill(aESum, cESum);
|
|
// }
|
|
// for(auto anode : anodeHits){
|
|
|
|
// float aE = anode.second;
|
|
// aESum += aE;
|
|
// if(inPCCut){
|
|
hanVScatsum->Fill(aESum, cESum);
|
|
// }
|
|
if (aID < 24 && aE > 50) {
|
|
hanVScatsum_a[aID]->Fill(aE, cESum);
|
|
}
|
|
|
|
|
|
// }
|
|
// Fill histograms for the `pc` data
|
|
hpcIndexVE->Fill(pc.index[i], pc.e[i]);
|
|
// if(inPCCut){
|
|
hAnodeMultiplicity->Fill(anodeHits.size());
|
|
// }
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// //======================= SX3
|
|
|
|
std::vector<std::pair<int, int>> ID; // first = id, 2nd = index
|
|
for( int i = 0; i < sx3.multi; i ++){
|
|
if(sx3.e[i]>50){
|
|
ID.push_back(std::pair<int, int>(sx3.id[i], i));
|
|
hsx3IndexVE->Fill( sx3.index[i], sx3.e[i] );
|
|
|
|
for( int j = i+1; j < sx3.multi; j++){
|
|
hsx3Coin->Fill( sx3.index[i], sx3.index[j]);
|
|
}
|
|
|
|
for( int j = 0; j < pc.multi; j++){
|
|
hsx3VpcIndex->Fill( sx3.index[i], pc.index[j] );
|
|
// if( sx3.ch[index] > 8 ){
|
|
// hsx3VpcE->Fill( sx3.e[i], pc.e[j] );
|
|
// }
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if( ID.size() > 0 ){
|
|
std::sort(ID.begin(), ID.end(), [](const std::pair<int, int> & a, const std::pair<int, int> & b) {
|
|
return a.first < b.first;
|
|
} );
|
|
// printf("##############################\n");
|
|
// for( size_t i = 0; i < ID.size(); i++) printf("%zu | %d %d \n", i, ID[i].first, ID[i].second );
|
|
|
|
std::vector<std::pair<int, int>> 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]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// printf("---------- sx3ID Multi : %zu \n", sx3ID.size());
|
|
|
|
if( found ){
|
|
int sx3ChUp, sx3ChDn, sx3ChBk;
|
|
float sx3EUp, sx3EDn;
|
|
// printf("------ sx3 ID : %d, multi: %zu\n", sx3ID[0].first, sx3ID.size());
|
|
for( size_t i = 0; i < sx3ID.size(); i++ ){
|
|
int index = sx3ID[i].second;
|
|
// printf(" %zu | index %d | ch : %d, energy : %d \n", i, index, sx3.ch[index], sx3.e[index]);
|
|
|
|
|
|
if( sx3.ch[index] < 8 ){
|
|
if( sx3.ch[index] % 2 == 0) {
|
|
sx3ChDn = sx3.ch[index];
|
|
sx3EDn = sx3.e[index];
|
|
}else{
|
|
sx3ChUp = sx3.ch[index];
|
|
sx3EUp = sx3.e[index];
|
|
}
|
|
}else{
|
|
sx3ChBk = sx3.ch[index];
|
|
}
|
|
for( int j = 0; j < pc.multi; j++){
|
|
|
|
// hsx3VpcIndex->Fill( sx3.index[i], pc.index[j] );
|
|
if( sx3.ch[index] > 8 && pc.index[j]<24 && pc.e[j]>50 ){
|
|
hsx3VpcE->Fill( sx3.e[i], pc.e[j] );
|
|
// hpcIndexVE->Fill( pc.index[i], pc.e[i] );
|
|
}
|
|
}
|
|
}
|
|
|
|
sx3_contr.CalSX3Pos(sx3ID[0].first, sx3ChUp, sx3ChDn, sx3ChBk, sx3EUp, sx3EDn);
|
|
hitPos = sx3_contr.GetHitPos();
|
|
HitNonZero = true;
|
|
// hitPos.Print();
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// //======================= QQQ
|
|
for( int i = 0; i < qqq.multi; i ++){
|
|
|
|
// for( int j = 0; j < pc.multi; j++){
|
|
if(qqq.e[i]>50 ){
|
|
hqqqIndexVE->Fill( qqq.index[i], qqq.e[i] );
|
|
for( int j = 0; j < qqq.multi; j++){
|
|
if ( j == i ) continue;
|
|
hqqqCoin->Fill( qqq.index[i], qqq.index[j]);
|
|
}
|
|
|
|
|
|
for( int j = i + 1; j < qqq.multi; j++){
|
|
for( int k = 0; k < pc.multi; k++){
|
|
// if(qqq.e[i>50]){
|
|
hqqqVpcE->Fill( qqq.e[i], pc.e[k] );
|
|
hqqqVpcIndex->Fill( qqq.index[i], pc.index[j] );
|
|
}
|
|
// }
|
|
}
|
|
}
|
|
// }
|
|
}
|
|
|
|
// hanVScatsum->Fill(aE,cE);
|
|
|
|
|
|
if( HitNonZero){
|
|
pw_contr.CalTrack( hitPos, aID, cID);
|
|
hZProj->Fill(pw_contr.GetZ0());
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//########################################################### Track constrcution
|
|
|
|
|
|
//############################## DO THE KINEMATICS
|
|
|
|
|
|
return kTRUE;
|
|
}
|
|
|
|
void PCGainMatch::Terminate(){
|
|
|
|
gStyle->SetOptStat("neiou");
|
|
TCanvas * canvas = new TCanvas("cANASEN", "ANASEN", 2000, 2000);
|
|
canvas->Divide(3,3);
|
|
|
|
//hsx3VpcIndex->Draw("colz");
|
|
|
|
//=============================================== pad-1
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
hsx3IndexVE->Draw("colz");
|
|
|
|
//=============================================== pad-2
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
hqqqIndexVE->Draw("colz");
|
|
|
|
//=============================================== pad-3
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
hpcIndexVE->Draw("colz");
|
|
|
|
//=============================================== pad-4
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
hsx3Coin->Draw("colz");
|
|
|
|
//=============================================== pad-5
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
canvas->cd(padID)->SetLogz(true);
|
|
|
|
hqqqCoin->Draw("colz");
|
|
|
|
//=============================================== pad-6
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
hpcCoin->Draw("colz");
|
|
|
|
//=============================================== pad-7
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
// hsx3VpcIndex ->Draw("colz");
|
|
hsx3VpcE->Draw("colz") ;
|
|
|
|
//=============================================== pad-8
|
|
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
|
|
// hqqqVpcIndex ->Draw("colz");
|
|
|
|
hqqqVpcE ->Draw("colz");
|
|
//=============================================== pad-9
|
|
padID ++;
|
|
|
|
// canvas->cd(padID)->DrawFrame(-50, -50, 50, 50);
|
|
// hqqqPolar->Draw("same colz pol");
|
|
|
|
canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
|
|
hanVScatsum->Draw("colz");
|
|
// hAnodeHits->Draw("colz");
|
|
// hAnodeMultiplicity->Draw();
|
|
}
|