rtang/ANASEN_analysis
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

modified: Analyzer.C added sections for crossover calculation

Browse Source 
modified:   Armory/ClassPW.h
	modified:   ProcessRun.sh
This commit is contained in:
vs19g 2025-01-16 11:27:33 -05:00
parent 9bf83f8028
commit f18b51e334
3 changed files with 275 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

430
Analyzer.C
View File

@ -14,70 +14,71 @@
#include "TVector3.h" #include "TVector3.h"
TH2F * hsx3IndexVE; TH2F *hsx3IndexVE;
TH2F * hqqqIndexVE; TH2F *hqqqIndexVE;
TH2F * hpcIndexVE; TH2F *hpcIndexVE;
TH2F * hsx3Coin; TH2F *hsx3Coin;
TH2F * hqqqCoin; TH2F *hqqqCoin;
TH2F * hpcCoin; TH2F *hpcCoin;
TH2F * hqqqPolar; TH2F *hqqqPolar;
TH2F * hsx3VpcIndex; TH2F *hsx3VpcIndex;
TH2F * hqqqVpcIndex; TH2F *hqqqVpcIndex;
TH2F * hqqqVpcE; TH2F *hqqqVpcE;
TH2F * hsx3VpcE; TH2F *hsx3VpcE;
TH2F * hanVScatsum; TH2F *hanVScatsum;
int padID = 0; int padID = 0;
SX3 sx3_contr; SX3 sx3_contr;
PW pw_contr; PW pw_contr;
PW pwinstance;
TVector3 hitPos; TVector3 hitPos;
bool HitNonZero; bool HitNonZero;
TH1F * hZProj; TH1F *hZProj;
void Analyzer::Begin(TTree * /*tree*/){ void Analyzer::Begin(TTree * /*tree*/)
{
TString option = GetOption(); 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"); hsx3IndexVE = new TH2F("hsx3IndexVE", "SX3 index vs Energy; sx3 index ; Energy", 24 * 12, 0, 24 * 12, 400, 0, 5000);
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"); hsx3IndexVE->SetNdivisions(-612, "x");
hpcIndexVE = new TH2F("hpcIndexVE", "PC index vs Energy; PC index ; Energy", 2*24, 0, 2*24, 400, 0, 4000); hpcIndexVE->SetNdivisions( -1204, "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, 400, 0, 4000);
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);
hsx3Coin = new TH2F("hsx3Coin", "SX3 Coincident", 24*12, 0, 24*12, 24*12, 0, 24*12); hqqqPolar = new TH2F("hqqqPolar", "QQQ Polar ID", 16 * 4, -TMath::Pi(), TMath::Pi(), 16, 10, 50);
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 = new TH2F("hsx3Vpcindex", "sx3 vs pc; sx3 index; pc index", 24*12, 0, 24*12, 48, 0, 48); hsx3VpcIndex->SetNdivisions(-12, "y");
hsx3VpcIndex->SetNdivisions( -612, "x"); hqqqVpcIndex = new TH2F("hqqqVpcindex", "qqq vs pc; qqq index; pc index", 4 * 2 * 16, 0, 4 * 2 * 16, 48, 0, 48);
hsx3VpcIndex->SetNdivisions( -12, "y"); hqqqVpcIndex->SetNdivisions(-612, "x");
hqqqVpcIndex = new TH2F("hqqqVpcindex", "qqq vs pc; qqq index; pc index", 4*2*16, 0, 4*2*16, 48, 0, 48); hqqqVpcIndex->SetNdivisions(-12, "y");
hqqqVpcIndex->SetNdivisions( -612, "x");
hqqqVpcIndex->SetNdivisions( -12, "y");
hqqqVpcE = new TH2F("hqqqVpcEnergy", "qqq vs pc; qqq energy; pc energy", 400, 0, 5000, 800, 0, 16000); hqqqVpcE = new TH2F("hqqqVpcEnergy", "qqq vs pc; qqq energy; pc energy", 400, 0, 5000, 800, 0, 16000);
hqqqVpcE->SetNdivisions( -612, "x"); hqqqVpcE->SetNdivisions(-612, "x");
hqqqVpcE->SetNdivisions( -12, "y"); hqqqVpcE->SetNdivisions(-12, "y");
hsx3VpcE = new TH2F("hsx3VpcEnergy", "sx3 vs pc; sx3 energy; pc energy", 400, 0, 5000, 800, 0, 16000); hsx3VpcE = new TH2F("hsx3VpcEnergy", "sx3 vs pc; sx3 energy; pc energy", 400, 0, 5000, 800, 0, 16000);
hsx3VpcE->SetNdivisions( -612, "x"); hsx3VpcE->SetNdivisions(-612, "x");
hsx3VpcE->SetNdivisions( -12, "y"); hsx3VpcE->SetNdivisions(-12, "y");
hZProj = new TH1F("hZProj", "Z Projection", 200, -600, 600); hZProj = new TH1F("hZProj", "Z Projection", 200, -600, 600);
hanVScatsum = new TH2F("hanVScatsum", "Anode vs Cathode Sum; Anode E; Cathode E", 400,0 , 10000, 400, 0 , 16000); hanVScatsum = new TH2F("hanVScatsum", "Anode vs Cathode Sum; Anode E; Cathode E", 400, 0, 10000, 400, 0, 16000);
sx3_contr.ConstructGeo(); sx3_contr.ConstructGeo();
pw_contr.ConstructGeo(); pw_contr.ConstructGeo();
} }
Bool_t Analyzer::Process(Long64_t entry)
{
Bool_t Analyzer::Process(Long64_t entry){
// if ( entry > 100 ) return kTRUE; // if ( entry > 100 ) return kTRUE;
@ -109,46 +110,54 @@ Bool_t Analyzer::Process(Long64_t entry){
// sx3.Print(); // sx3.Print();
//########################################################### Raw data // ########################################################### Raw data
// //======================= SX3 // //======================= SX3
std::vector<std::pair<int, int>> ID; // first = id, 2nd = index std::vector<std::pair<int, int>> ID; // first = id, 2nd = index
for( int i = 0; i < sx3.multi; i ++){ for (int i = 0; i < sx3.multi; i++)
{
ID.push_back(std::pair<int, int>(sx3.id[i], i)); ID.push_back(std::pair<int, int>(sx3.id[i], i));
hsx3IndexVE->Fill( sx3.index[i], sx3.e[i] ); hsx3IndexVE->Fill(sx3.index[i], sx3.e[i]);
for( int j = i+1; j < sx3.multi; j++){ for (int j = i + 1; j < sx3.multi; j++)
hsx3Coin->Fill( sx3.index[i], sx3.index[j]); {
hsx3Coin->Fill(sx3.index[i], sx3.index[j]);
} }
for( int j = 0; j < pc.multi; j++){ for (int j = 0; j < pc.multi; j++)
hsx3VpcIndex->Fill( sx3.index[i], pc.index[j] ); {
hsx3VpcIndex->Fill(sx3.index[i], pc.index[j]);
// if( sx3.ch[index] > 8 ){ // if( sx3.ch[index] > 8 ){
// hsx3VpcE->Fill( sx3.e[i], pc.e[j] ); // hsx3VpcE->Fill( sx3.e[i], pc.e[j] );
// } // }
} }
} }
if (ID.size() > 0)
if( ID.size() > 0 ){ {
std::sort(ID.begin(), ID.end(), [](const std::pair<int, int> & a, const std::pair<int, int> & b) { std::sort(ID.begin(), ID.end(), [](const std::pair<int, int> &a, const std::pair<int, int> &b)
return a.first < b.first; { return a.first < b.first; });
} );
// printf("##############################\n"); // printf("##############################\n");
// for( size_t i = 0; i < ID.size(); i++) printf("%zu | %d %d \n", i, ID[i].first, ID[i].second ); // 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; std::vector<std::pair<int, int>> sx3ID;
sx3ID.push_back(ID[0]); sx3ID.push_back(ID[0]);
bool found = false; bool found = false;
for( size_t i = 1; i < ID.size(); i++){ for (size_t i = 1; i < ID.size(); i++)
if( ID[i].first == sx3ID.back().first) { {
if (ID[i].first == sx3ID.back().first)
{
sx3ID.push_back(ID[i]); sx3ID.push_back(ID[i]);
if( sx3ID.size() >= 3) { if (sx3ID.size() >= 3)
{
found = true; found = true;
} }
}else{ }
if( !found ){ else
{
if (!found)
{
sx3ID.clear(); sx3ID.clear();
sx3ID.push_back(ID[i]); sx3ID.push_back(ID[i]);
} }
@ -157,33 +166,42 @@ Bool_t Analyzer::Process(Long64_t entry){
// printf("---------- sx3ID Multi : %zu \n", sx3ID.size()); // printf("---------- sx3ID Multi : %zu \n", sx3ID.size());
if( found ){ if (found)
{
int sx3ChUp, sx3ChDn, sx3ChBk; int sx3ChUp, sx3ChDn, sx3ChBk;
float sx3EUp, sx3EDn; float sx3EUp, sx3EDn;
// printf("------ sx3 ID : %d, multi: %zu\n", sx3ID[0].first, sx3ID.size()); // printf("------ sx3 ID : %d, multi: %zu\n", sx3ID[0].first, sx3ID.size());
for( size_t i = 0; i < sx3ID.size(); i++ ){ for (size_t i = 0; i < sx3ID.size(); i++)
{
int index = sx3ID[i].second; int index = sx3ID[i].second;
// printf(" %zu | index %d | ch : %d, energy : %d \n", i, index, sx3.ch[index], sx3.e[index]); // 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] < 8 ){ {
if( sx3.ch[index] % 2 == 0) { if (sx3.ch[index] % 2 == 0)
{
sx3ChDn = sx3.ch[index]; sx3ChDn = sx3.ch[index];
sx3EDn = sx3.e[index]; sx3EDn = sx3.e[index];
}else{ }
else
{
sx3ChUp = sx3.ch[index]; sx3ChUp = sx3.ch[index];
sx3EUp = sx3.e[index]; sx3EUp = sx3.e[index];
} }
}else{ }
else
{
sx3ChBk = sx3.ch[index]; sx3ChBk = sx3.ch[index];
} }
for( int j = 0; j < pc.multi; j++){ for (int j = 0; j < pc.multi; j++)
// hsx3VpcIndex->Fill( sx3.index[i], pc.index[j] ); {
if( sx3.ch[index] > 8 ){ // hsx3VpcIndex->Fill( sx3.index[i], pc.index[j] );
hsx3VpcE->Fill( sx3.e[i], pc.e[j] ); if (sx3.ch[index] > 8)
// hpcIndexVE->Fill( pc.index[i], pc.e[i] ); {
} 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); sx3_contr.CalSX3Pos(sx3ID[0].first, sx3ChUp, sx3ChDn, sx3ChBk, sx3EUp, sx3EDn);
@ -191,91 +209,140 @@ Bool_t Analyzer::Process(Long64_t entry){
HitNonZero = true; HitNonZero = true;
// hitPos.Print(); // hitPos.Print();
} }
} }
// //======================= QQQ // //======================= QQQ
for( int i = 0; i < qqq.multi; i ++){ for (int i = 0; i < qqq.multi; i++)
{
// for( int j = 0; j < pc.multi; j++){ // for( int j = 0; j < pc.multi; j++){
// if(pc.index[j]==4){ // if(pc.index[j]==4){
hqqqIndexVE->Fill( qqq.index[i], qqq.e[i] ); hqqqIndexVE->Fill(qqq.index[i], qqq.e[i]);
// }
// } // }
for( int j = 0; j < qqq.multi; j++){ // }
if ( j == i ) continue; for (int j = 0; j < qqq.multi; j++)
hqqqCoin->Fill( qqq.index[i], qqq.index[j]); {
if (j == i)
continue;
hqqqCoin->Fill(qqq.index[i], qqq.index[j]);
} }
for (int j = i + 1; j < qqq.multi; j++)
for( int j = i + 1; j < qqq.multi; j++){ {
for( int k = 0; k < pc.multi; k++){ for (int k = 0; k < pc.multi; k++)
if(pc.index[k]<24 && pc.e[k]>50 ){ {
hqqqVpcE->Fill( qqq.e[i], pc.e[k] ); if (pc.index[k] < 24 && pc.e[k] > 50)
{
hqqqVpcE->Fill(qqq.e[i], pc.e[k]);
// hpcIndexVE->Fill( pc.index[i], pc.e[i] ); // hpcIndexVE->Fill( pc.index[i], pc.e[i] );
hqqqVpcIndex->Fill( qqq.index[i], pc.index[j] ); hqqqVpcIndex->Fill(qqq.index[i], pc.index[j]);
} }
// } // }
} }
// if( qqq.used[i] == true ) continue; // if( qqq.used[i] == true ) continue;
//if( qqq.id[i] == qqq.id[j] && (16 - qqq.ch[i]) * (16 - qqq.ch[j]) < 0 ){ // must be same detector and wedge and ring // if( qqq.id[i] == qqq.id[j] && (16 - qqq.ch[i]) * (16 - qqq.ch[j]) < 0 ){ // must be same detector and wedge and ring
if( qqq.id[i] == qqq.id[j] ){ // must be same detector if (qqq.id[i] == qqq.id[j])
{ // must be same detector
int chWedge = -1; int chWedge = -1;
int chRing = -1; int chRing = -1;
if( qqq.ch[i] < qqq.ch[j]){ if (qqq.ch[i] < qqq.ch[j])
{
chRing = qqq.ch[j] - 16; chRing = qqq.ch[j] - 16;
chWedge = qqq.ch[i]; chWedge = qqq.ch[i];
}else{ }
else
{
chRing = qqq.ch[i]; chRing = qqq.ch[i];
chWedge = qqq.ch[j] - 16; chWedge = qqq.ch[j] - 16;
} }
// printf(" ID : %d , chWedge : %d, chRing : %d \n", qqq.id[i], chWedge, chRing); // printf(" ID : %d , chWedge : %d, chRing : %d \n", qqq.id[i], chWedge, chRing);
double theta = -TMath::Pi()/2 + 2*TMath::Pi()/16/4.*(qqq.id[i]*16 + chWedge +0.5); double theta = -TMath::Pi() / 2 + 2 * TMath::Pi() / 16 / 4. * (qqq.id[i] * 16 + chWedge + 0.5);
double rho = 10.+40./16.*(chRing+0.5); double rho = 10. + 40. / 16. * (chRing + 0.5);
// if(qqq.e[i]>50){ // if(qqq.e[i]>50){
hqqqPolar->Fill( theta, rho); hqqqPolar->Fill(theta, rho);
// } // }
// qqq.used[i] = true; // qqq.used[i] = true;
// qqq.used[j] = true; // qqq.used[j] = true;
if( !HitNonZero ){ if (!HitNonZero)
double x = rho * TMath::Cos(theta); {
double y = rho * TMath::Sin(theta); double x = rho * TMath::Cos(theta);
hitPos.SetXYZ(x, y, 23 + 75 + 30); double y = rho * TMath::Sin(theta);
HitNonZero = true; hitPos.SetXYZ(x, y, 23 + 75 + 30);
HitNonZero = true;
} }
} }
} }
} }
// //======================= PC // //======================= PC
ID.clear(); ID.clear();
int counter=0; int counter = 0;
std::vector<std::pair<int, double>> E; std::vector<std::pair<int, double>> E;
E.clear(); E.clear();
for( int i = 0; i < pc.multi; i ++){ for (int i = 0; i < pc.multi; i++)
{
if( pc.e[i] > 100 ) ID.push_back(std::pair<int, int>(pc.id[i], i)); if (pc.e[i] > 100)
if( pc.e[i] > 100 ) E.push_back(std::pair<int, double>(pc.index[i], pc.e[i])); ID.push_back(std::pair<int, int>(pc.id[i], i));
if (pc.e[i] > 100)
E.push_back(std::pair<int, double>(pc.index[i], pc.e[i]));
hpcIndexVE->Fill( pc.index[i], pc.e[i] ); hpcIndexVE->Fill(pc.index[i], pc.e[i]);
for( int j = i+1; j < pc.multi; j++){ for (int j = i + 1; j < pc.multi; j++)
hpcCoin->Fill( pc.index[i], pc.index[j]); {
hpcCoin->Fill(pc.index[i], pc.index[j]);
} }
} }
// for( size_t i = 0; i < E.size(); i++) printf("%zu | %d %d \n", i, E[i].first, E[i].second ); // for( size_t i = 0; i < E.size(); i++) printf("%zu | %d %d \n", i, E[i].first, E[i].second );
if( E.size()>=3 ){ pwinstance.ConstructGeo();
Coord Crossover[24][24];
std::vector<std::tuple<int, TVector3, TVector3>> AnGeo;
std::vector<std::tuple<int, TVector3, TVector3>> CatGeo;
TVector3 a, c, diff;
double a2, ac, c2, adiff, cdiff, denom, alpha, beta;
int index = 0;
for (int i = 0; i < pwinstance.An.size(); i++)
{
AnGeo.push_back(std::make_tuple(i, pwinstance.An[i].first, pwinstance.An[i].second));
a = pwinstance.An[i].first - pwinstance.An[i].second;
for (int j = 0; j < pwinstance.Ca.size(); j++)
{
CatGeo.push_back(std::make_tuple(j, pwinstance.Ca[j].first, pwinstance.Ca[j].second));
c = pwinstance.Ca[j].first - pwinstance.Ca[j].second;
diff = pwinstance.An[i].first - pwinstance.Ca[j].first;
a2 = a.Dot(a);
ac = a.Dot(c);
c2 = c.Dot(c);
adiff = a.Dot(diff);
cdiff = c.Dot(diff);
denom = a2 * c2 - ac * ac;
alpha = (ac * cdiff - c2 * adiff) / denom;
beta = (a2 * cdiff - ac * adiff) / denom;
Crossover[i][j].x = pwinstance.An[i].first.X() + alpha * a.X();
Crossover[i][j].y = pwinstance.An[i].first.Y() + alpha * a.Y();
Crossover[i][j].z = pwinstance.An[i].first.Z() + alpha * a.Z();
if (i == 23)
{
if (abs(i - j) < 7 || abs(i - j) > 17)
{
if (alpha < 0 && alpha > -1)
{
printf("Anode and cathode indices and coord : %d %d %f %f %f %f\n", i, j, pwinstance.Ca[j].first.X(), pwinstance.Ca[j].first.Y(), pwinstance.Ca[j].first.Z(), alpha);
printf("Crossover wires, points and alpha are : %f %f %f %f \n", Crossover[i][j].x, Crossover[i][j].y, Crossover[i][j].z, alpha);
}
}
}
}
}
if (E.size() >= 3)
{
int aID = 0; int aID = 0;
int cID = 0; int cID = 0;
@ -291,117 +358,140 @@ Bool_t Analyzer::Process(Long64_t entry){
// } // }
// printf("anode= %d, cathode = %d\n", aID, cID); // printf("anode= %d, cathode = %d\n", aID, cID);
for( int k = 0; k < qqq.multi; k++){ for (int k = 0; k < qqq.multi; k++)
if(qqq.index[k]==75 && pc.index[k]==2 && pc.e[k]>100){ {
if (qqq.index[k] == 75 && pc.index[k] == 2 && pc.e[k] > 100)
int multi_an =0; {
for(int l=0;l<E.size();l++){
if(E[l].first<24){
multi_an++;
}
}
if(multi_an>=1){ int multi_an = 0;
for(int l=0;l<E.size();l++){ for (int l = 0; l < E.size(); l++)
if(E[l].first<24 && E[l].first!=19 && E[l].first!=12){ {
aE = E[l].second; if (E[l].first < 24)
}else if(E[l].first>24){ {
cE = E[l].second; multi_an++;
}
}
if (multi_an >= 1)
{
for (int l = 0; l < E.size(); l++)
{
if (E[l].first < 24 && E[l].first != 19 && E[l].first != 12)
{
aE = E[l].second;
}
else if (E[l].first > 24)
{
cE = E[l].second;
}
} }
} }
} }
}
} hanVScatsum->Fill(aE, cE);
}
hanVScatsum->Fill(aE,cE); if (ID[0].first < 1)
{
if( ID[0].first < 1 ) {
aID = pc.ch[ID[0].second]; aID = pc.ch[ID[0].second];
cID = pc.ch[ID[1].second]; cID = pc.ch[ID[1].second];
}else{ }
else
{
cID = pc.ch[ID[0].second]; cID = pc.ch[ID[0].second];
aID = pc.ch[ID[1].second]; aID = pc.ch[ID[1].second];
} }
if( HitNonZero){ if (HitNonZero)
pw_contr.CalTrack( hitPos, aID, cID); {
pw_contr.CalTrack(hitPos, aID, cID);
hZProj->Fill(pw_contr.GetZ0()); hZProj->Fill(pw_contr.GetZ0());
} }
} }
// ########################################################### Track constrcution
//########################################################### Track constrcution // ############################## DO THE KINEMATICS
//############################## DO THE KINEMATICS
return kTRUE; return kTRUE;
} }
void Analyzer::Terminate(){ void Analyzer::Terminate()
{
gStyle->SetOptStat("neiou"); gStyle->SetOptStat("neiou");
TCanvas * canvas = new TCanvas("cANASEN", "ANASEN", 2000, 2000); TCanvas *canvas = new TCanvas("cANASEN", "ANASEN", 2000, 2000);
canvas->Divide(3,3); canvas->Divide(3, 3);
//hsx3VpcIndex->Draw("colz"); // hsx3VpcIndex->Draw("colz");
//=============================================== pad-1 //=============================================== pad-1
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
hsx3IndexVE->Draw("colz"); hsx3IndexVE->Draw("colz");
//=============================================== pad-2 //=============================================== pad-2
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
hqqqIndexVE->Draw("colz"); hqqqIndexVE->Draw("colz");
//=============================================== pad-3 //=============================================== pad-3
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
hpcIndexVE->Draw("colz"); hpcIndexVE->Draw("colz");
//=============================================== pad-4 //=============================================== pad-4
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
hsx3Coin->Draw("colz"); hsx3Coin->Draw("colz");
//=============================================== pad-5 //=============================================== pad-5
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
canvas->cd(padID)->SetLogz(true); canvas->cd(padID)->SetLogz(true);
hqqqCoin->Draw("colz"); hqqqCoin->Draw("colz");
//=============================================== pad-6 //=============================================== pad-6
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
hpcCoin->Draw("colz"); hpcCoin->Draw("colz");
//=============================================== pad-7 //=============================================== pad-7
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
// hsx3VpcIndex ->Draw("colz"); // hsx3VpcIndex ->Draw("colz");
hsx3VpcE->Draw("colz") ; hsx3VpcE->Draw("colz");
//=============================================== pad-8 //=============================================== pad-8
padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1); padID++;
canvas->cd(padID);
canvas->cd(padID)->SetGrid(1);
// hqqqVpcIndex ->Draw("colz"); // hqqqVpcIndex ->Draw("colz");
hqqqVpcE ->Draw("colz"); hqqqVpcE->Draw("colz");
//=============================================== pad-9 //=============================================== pad-9
padID ++; padID++;
// canvas->cd(padID)->DrawFrame(-50, -50, 50, 50); // canvas->cd(padID)->DrawFrame(-50, -50, 50, 50);
// hqqqPolar->Draw("same colz pol"); // hqqqPolar->Draw("same colz pol");
canvas->cd(padID); canvas->cd(padID)->SetGrid(1); canvas->cd(padID);
// hZProj->Draw(); canvas->cd(padID)->SetGrid(1);
// hZProj->Draw();
hanVScatsum->Draw("colz"); hanVScatsum->Draw("colz");
} }

8
Armory/ClassPW.h
View File

@ -30,6 +30,7 @@ struct PWHitInfo
struct Coord struct Coord
{ {
float x, y, z; float x, y, z;
Coord() : x(0), y(0), z(0) {}
Coord(const TVector3 &vec) Coord(const TVector3 &vec)
{ {
x = vec.X(); // TVector3's X() returns the x-coordinate x = vec.X(); // TVector3's X() returns the x-coordinate
@ -51,6 +52,9 @@ public:
std::pair<short, short> Get2ndNearestID() const { return hitInfo.nextNearestWire; } std::pair<short, short> Get2ndNearestID() const { return hitInfo.nextNearestWire; }
std::pair<double, double> Get2ndNearestDistance() const { return hitInfo.nextNearestDist; } std::pair<double, double> Get2ndNearestDistance() const { return hitInfo.nextNearestDist; }
std::vector<std::pair<TVector3, TVector3>> An; // the anode wire position vector in space
std::vector<std::pair<TVector3, TVector3>> Ca; // the cathode wire position vector in space
TVector3 GetTrackPos() const { return trackPos; } TVector3 GetTrackPos() const { return trackPos; }
TVector3 GetTrackVec() const { return trackVec; } TVector3 GetTrackVec() const { return trackVec; }
double GetTrackTheta() const { return trackVec.Theta(); } double GetTrackTheta() const { return trackVec.Theta(); }
@ -109,8 +113,8 @@ private:
double anodeLength; double anodeLength;
double cathodeLength; double cathodeLength;
std::vector<std::pair<TVector3, TVector3>> An; // the anode wire position vector in space // std::vector<std::pair<TVector3, TVector3>> An; // the anode wire position vector in space
std::vector<std::pair<TVector3, TVector3>> Ca; // the cathode wire position vector in space // std::vector<std::pair<TVector3, TVector3>> Ca; // the cathode wire position vector in space
double Distance(TVector3 a1, TVector3 a2, TVector3 b1, TVector3 b2) double Distance(TVector3 a1, TVector3 a2, TVector3 b1, TVector3 b2)
{ {

16
ProcessRun.sh
View File

@ -10,18 +10,20 @@ runID=$1
timeWindow=$2 timeWindow=$2
rawFolder=/home/tandem/Desktop/analysis/data rawFolder=/home/tandem/Desktop/analysis/data
rootFolder=/home/tandem/Desktop/analysis/data/root_data rootFolder=../root_data
rsync -a splitpole@128.186.111.223:/media/nvmeData/ANASEN27Alap/*.fsu /home/tandem/Desktop/analysis/data if [ $option -eq 0 ]; then
fileList=`\ls -1 ${rawFolder}/Run_${runID}_*.fsu` rsync -auh --info=progress2 splitpole@128.186.111.223:/media/nvmeData/2024_09_17Fap/*.fsu /home/tandem/data1/2024_09_17Fap/data
./EventBuilder ${timeWindow} 0 0 10000000 ${fileList} fileList=`\ls -1 ${rawFolder}/*Run_${runID}_*.fsu`
outFile=${rawFolder}/*${runID}*${timeWindow}.root ./EventBuilder ${timeWindow} 0 0 100000000 ${fileList}
mv -vf ${outFile} ${rootFolder}/. outFile=${rawFolder}/*${runID}*${timeWindow}.root
./Mapper ${rootFolder}/*${runID}*${timeWindow}.root mv -vf ${outFile} ${rootFolder}/.
./Mapper ${rootFolder}/*${runID}*${timeWindow}.root
fi
root "processRun.C(\"${rootFolder}/Run_${runID}_mapped.root\")" root "processRun.C(\"${rootFolder}/Run_${runID}_mapped.root\")"