From f18b51e3340356896d7144b553b38e504fc53b88 Mon Sep 17 00:00:00 2001
From: vs19g <vignesh.sitaraman@gmail.com>
Date: Thu, 16 Jan 2025 11:27:33 -0500
Subject: [PATCH] 	modified:   Analyzer.C added sections for crossover
 calculation 	modified:   Armory/ClassPW.h 	modified:   ProcessRun.sh

---
 Analyzer.C       | 430 ++++++++++++++++++++++++++++-------------------
 Armory/ClassPW.h |   8 +-
 ProcessRun.sh    |  16 +-
 3 files changed, 275 insertions(+), 179 deletions(-)

diff --git a/Analyzer.C b/Analyzer.C
index df60a97..ef15b2b 100644
--- a/Analyzer.C
+++ b/Analyzer.C
@@ -14,70 +14,71 @@
 
 #include "TVector3.h"
 
-TH2F * hsx3IndexVE;
-TH2F * hqqqIndexVE;
-TH2F * hpcIndexVE;
+TH2F *hsx3IndexVE;
+TH2F *hqqqIndexVE;
+TH2F *hpcIndexVE;
 
-TH2F * hsx3Coin;
-TH2F * hqqqCoin;
-TH2F * hpcCoin;
+TH2F *hsx3Coin;
+TH2F *hqqqCoin;
+TH2F *hpcCoin;
 
-TH2F * hqqqPolar;
-TH2F * hsx3VpcIndex;
-TH2F * hqqqVpcIndex;
-TH2F * hqqqVpcE;
-TH2F * hsx3VpcE;
-TH2F * hanVScatsum;
+TH2F *hqqqPolar;
+TH2F *hsx3VpcIndex;
+TH2F *hqqqVpcIndex;
+TH2F *hqqqVpcE;
+TH2F *hsx3VpcE;
+TH2F *hanVScatsum;
 int padID = 0;
 
 SX3 sx3_contr;
 PW pw_contr;
+PW pwinstance;
 TVector3 hitPos;
 bool HitNonZero;
 
-TH1F * hZProj;
+TH1F *hZProj;
 
-void Analyzer::Begin(TTree * /*tree*/){
+void Analyzer::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, 400, 0, 4000); hpcIndexVE->SetNdivisions( -1204, "x");
+  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, 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);
-  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);
 
-  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");
+  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, 800, 0, 16000);
-  hqqqVpcE->SetNdivisions( -612, "x");
-  hqqqVpcE->SetNdivisions( -12, "y");
-  
+  hqqqVpcE->SetNdivisions(-612, "x");
+  hqqqVpcE->SetNdivisions(-12, "y");
+
   hsx3VpcE = new TH2F("hsx3VpcEnergy", "sx3 vs pc; sx3 energy; pc energy", 400, 0, 5000, 800, 0, 16000);
-  hsx3VpcE->SetNdivisions( -612, "x");
-  hsx3VpcE->SetNdivisions( -12, "y");
+  hsx3VpcE->SetNdivisions(-612, "x");
+  hsx3VpcE->SetNdivisions(-12, "y");
 
   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();
   pw_contr.ConstructGeo();
-
 }
 
-
-
-
-Bool_t Analyzer::Process(Long64_t entry){
+Bool_t Analyzer::Process(Long64_t entry)
+{
 
   // if ( entry > 100 ) return kTRUE;
 
@@ -109,46 +110,54 @@ Bool_t Analyzer::Process(Long64_t entry){
 
   // sx3.Print();
 
-  //########################################################### Raw data
-  // //======================= SX3
+  // ########################################################### Raw data
+  //  //======================= SX3
 
   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));
 
-    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++){
-      hsx3Coin->Fill( sx3.index[i], sx3.index[j]);
+    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] );
+    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;
-    } );
+  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; 
+    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) {
+    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) {
+        if (sx3ID.size() >= 3)
+        {
           found = true;
-        } 
-      }else{
-        if( !found ){
+        }
+      }
+      else
+      {
+        if (!found)
+        {
           sx3ID.clear();
           sx3ID.push_back(ID[i]);
         }
@@ -157,33 +166,42 @@ Bool_t Analyzer::Process(Long64_t entry){
 
     // printf("---------- sx3ID Multi : %zu \n", sx3ID.size());
 
-    if( found ){
+    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++ ){
+      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) {
+        if (sx3.ch[index] < 8)
+        {
+          if (sx3.ch[index] % 2 == 0)
+          {
             sx3ChDn = sx3.ch[index];
             sx3EDn = sx3.e[index];
-          }else{
+          }
+          else
+          {
             sx3ChUp = sx3.ch[index];
             sx3EUp = sx3.e[index];
           }
-        }else{
+        }
+        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 ){
-              hsx3VpcE->Fill( sx3.e[i], pc.e[j] );
-          //  hpcIndexVE->Fill( pc.index[i], pc.e[i] );
-            }
+        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]);
+            //  hpcIndexVE->Fill( pc.index[i], pc.e[i] );
           }
+        }
       }
 
       sx3_contr.CalSX3Pos(sx3ID[0].first, sx3ChUp, sx3ChDn, sx3ChBk, sx3EUp, sx3EDn);
@@ -191,91 +209,140 @@ Bool_t Analyzer::Process(Long64_t entry){
       HitNonZero = true;
       // hitPos.Print();
     }
-
   }
-  
 
   // //======================= 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++){
-        // if(pc.index[j]==4){
-          hqqqIndexVE->Fill( qqq.index[i], qqq.e[i] );
-        // }
+    // if(pc.index[j]==4){
+    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 = 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(pc.index[k]<24 && pc.e[k]>50 ){
-          hqqqVpcE->Fill( qqq.e[i], pc.e[k] );
+    for (int j = i + 1; j < qqq.multi; j++)
+    {
+      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]);
           //  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.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] && (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
+
         int chWedge = -1;
-        int chRing  =  -1;
-        if( qqq.ch[i] < qqq.ch[j]){
+        int chRing = -1;
+        if (qqq.ch[i] < qqq.ch[j])
+        {
           chRing = qqq.ch[j] - 16;
           chWedge = qqq.ch[i];
-        }else{
+        }
+        else
+        {
           chRing = qqq.ch[i];
           chWedge = qqq.ch[j] - 16;
         }
 
         // 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 rho   = 10.+40./16.*(chRing+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);
         // if(qqq.e[i]>50){
-        hqqqPolar->Fill( theta, rho);
+        hqqqPolar->Fill(theta, rho);
         // }
         // qqq.used[i] = true;
         // qqq.used[j] = true;
 
-        if( !HitNonZero ){
-        double x = rho * TMath::Cos(theta);
-        double y = rho * TMath::Sin(theta);
-        hitPos.SetXYZ(x, y, 23 + 75 + 30);
-        HitNonZero = true;
+        if (!HitNonZero)
+        {
+          double x = rho * TMath::Cos(theta);
+          double y = rho * TMath::Sin(theta);
+          hitPos.SetXYZ(x, y, 23 + 75 + 30);
+          HitNonZero = true;
         }
       }
     }
-  
-   
   }
   // //======================= PC
 
   ID.clear();
-  int counter=0;
-  std::vector<std::pair<int, double>> E; 
+  int counter = 0;
+  std::vector<std::pair<int, double>> E;
   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 ) E.push_back(std::pair<int, double>(pc.index[i], pc.e[i]));
+    if (pc.e[i] > 100)
+      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++){
-      hpcCoin->Fill( pc.index[i], pc.index[j]);
-    
+    for (int j = i + 1; j < pc.multi; 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 cID = 0;
@@ -291,117 +358,140 @@ Bool_t Analyzer::Process(Long64_t entry){
     // }
     // printf("anode= %d, cathode = %d\n", aID, cID);
 
-   for( int k = 0; k < qqq.multi; k++){
-    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++;
-        }
-      }
+    for (int k = 0; k < qqq.multi; k++)
+    {
+      if (qqq.index[k] == 75 && pc.index[k] == 2 && pc.e[k] > 100)
+      {
 
-      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;
+        int multi_an = 0;
+        for (int l = 0; l < E.size(); l++)
+        {
+          if (E[l].first < 24)
+          {
+            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);
-      
-    if( ID[0].first < 1 ) {
+    }
+    hanVScatsum->Fill(aE, cE);
+
+    if (ID[0].first < 1)
+    {
       aID = pc.ch[ID[0].second];
       cID = pc.ch[ID[1].second];
-    }else{
+    }
+    else
+    {
       cID = pc.ch[ID[0].second];
       aID = pc.ch[ID[1].second];
     }
 
-    if( HitNonZero){
-      pw_contr.CalTrack( hitPos, aID, cID);
+    if (HitNonZero)
+    {
+      pw_contr.CalTrack(hitPos, aID, cID);
       hZProj->Fill(pw_contr.GetZ0());
     }
-
-  
   }
-  
 
+  // ########################################################### Track constrcution
 
-  //########################################################### Track constrcution
-
-
-  //############################## DO THE KINEMATICS
-
+  // ############################## DO THE KINEMATICS
 
   return kTRUE;
 }
 
-void Analyzer::Terminate(){
+void Analyzer::Terminate()
+{
 
   gStyle->SetOptStat("neiou");
-  TCanvas * canvas = new TCanvas("cANASEN", "ANASEN", 2000, 2000); 
-  canvas->Divide(3,3);
+  TCanvas *canvas = new TCanvas("cANASEN", "ANASEN", 2000, 2000);
+  canvas->Divide(3, 3);
 
-  //hsx3VpcIndex->Draw("colz");
+  // hsx3VpcIndex->Draw("colz");
 
   //=============================================== pad-1
-  padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
+  padID++;
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
 
   hsx3IndexVE->Draw("colz");
 
   //=============================================== pad-2
-  padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
+  padID++;
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
 
   hqqqIndexVE->Draw("colz");
 
   //=============================================== pad-3
-  padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
+  padID++;
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
 
   hpcIndexVE->Draw("colz");
 
   //=============================================== pad-4
-  padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
+  padID++;
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
 
   hsx3Coin->Draw("colz");
 
   //=============================================== 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);
 
   hqqqCoin->Draw("colz");
 
   //=============================================== pad-6
-  padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
+  padID++;
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
 
   hpcCoin->Draw("colz");
 
   //=============================================== pad-7
-  padID ++; canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
+  padID++;
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
 
-  // hsx3VpcIndex ->Draw("colz"); 
-  hsx3VpcE->Draw("colz") ;
+  // hsx3VpcIndex ->Draw("colz");
+  hsx3VpcE->Draw("colz");
 
   //=============================================== 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
-  padID ++; 
+  padID++;
 
   // canvas->cd(padID)->DrawFrame(-50, -50, 50, 50);
   // hqqqPolar->Draw("same colz pol");
 
- canvas->cd(padID); canvas->cd(padID)->SetGrid(1);
-//  hZProj->Draw();
+  canvas->cd(padID);
+  canvas->cd(padID)->SetGrid(1);
+  //  hZProj->Draw();
   hanVScatsum->Draw("colz");
-
 }
diff --git a/Armory/ClassPW.h b/Armory/ClassPW.h
index ee94254..d65e559 100644
--- a/Armory/ClassPW.h
+++ b/Armory/ClassPW.h
@@ -30,6 +30,7 @@ struct PWHitInfo
 struct Coord
 {
   float x, y, z;
+  Coord() : x(0), y(0), z(0) {}
   Coord(const TVector3 &vec)
   {
     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<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 GetTrackVec() const { return trackVec; }
   double GetTrackTheta() const { return trackVec.Theta(); }
@@ -109,8 +113,8 @@ private:
   double anodeLength;
   double cathodeLength;
 
-  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>> An; // the anode 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)
   {
diff --git a/ProcessRun.sh b/ProcessRun.sh
index 6539a32..dc15ea3 100755
--- a/ProcessRun.sh
+++ b/ProcessRun.sh
@@ -10,18 +10,20 @@ runID=$1
 timeWindow=$2
 
 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\")"