#define gainmatch_cxx

#include "gainmatch.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 * hqqqIndexVE_cut;
TH2F * hpcIndexVE;

TH2F * hsx3Coin;
TH2F * hqqqCoin;
TH2F * hpcCoin;
TH2F * hpcCoin_cut;

TH2F * hGoodQQQ;
TH2F * hGoodQQQRingVWedge;

TH2F * hqqqPolar;
TH2F * hsx3VpcIndex;
TH2F * hqqqVpcIndex;
TH2F * hqqqVpcIndex_cut;
TH2F * hqqqVpcE;
TH2F * hqqqVpcE_cut;
TH2F * hqqqVpcE_cut1;
TH2F * hqqqVpcE_cut2;
TH2F * hqqqVpcE_cutCoinc;
TH2F * hsx3VpcE;
TH2F * hanVScatsum;
TH2F * hanVScatsum_cut;
TH2F * hanVScatsum_cut1;
TH2F * hanVScatsum_cut2;
TH2F * hsx3Vsx3;
TH2F * hsx3uVsx3d_01;
TH2F * hsx3uVsx3d_23;
TH2F * hsx3uVsx3d_45;
TH2F * hsx3uVsx3d_67;
TH2F * hVCID;
TH1F *hsx3bk_9_shifted ;
TH1F *hsx3bk_10_shifted ;
TH1F *hsx3bk_11_shifted ;

int padID = 0;

TCutG *Coinc_cut_set1;
//TCutG *crap_cut;
TCutG *AnCathCoinc_cut;
TCutG *AnCathCoinc_cut1;
TCutG *AnCathCoinc_cut2;

SX3 sx3_contr;
PW pw_contr;
TVector3 hitPos;
bool HitNonZero;
bool inCut;
bool inCut1;
bool inCut2;
bool inCutCoinc;
TH1F *hZd_01_1;
TH1F *hZd_01_2;
TH1F *hZd_01_3;
TH1F *hZd_01_4;
TH1F * hZProj;
TH1F * hsx3bk_11;
TH1F * hsx3bk_10;
TH1F * hsx3bk_9;
TH1F * hsx3bk_8;
void gainmatch::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");
    hqqqIndexVE_cut = new TH2F("hqqqIndexVE_cut", "QQQ index vs Energy gated; 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");

  hGoodQQQ = new TH2F("hGoodQQQ", "number of good QQQ vs QQQ id", 10, 0, 10, 4, 0, 4);
  hGoodQQQRingVWedge = new TH2F("hGoodQQQRingVWedge", "Ring index, Wedge index", 16*4, 0, 16*4, 16*4, 0, 16*4);
  hZd_01_1 =new TH1F("hZd_01_1", "Z position", 100, -1, 1); 
  hZd_01_2 =new TH1F("hZd_01_2", "Z position", 100, -1, 1); 
  hZd_01_3 =new TH1F("hZd_01_3", "Z position", 100, -1, 1); 
  hZd_01_4 =new TH1F("hZd_01_4", "Z position", 100, -1, 1); 
  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);
  hpcCoin_cut  = new TH2F("hpcCoin_cut",  "PC Coincident gated",    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);
  hsx3Vsx3 = new TH2F("hsx3Vsx3", "sx3 vs sx3; sx3 E; sx3 E",  8000, 0, 16000, 8000, 0, 16000);
  hsx3uVsx3d_01 = new TH2F("hsx3uVsx3d_01", "sx3u vs sx3d; sx3u E; sx3d E",  100, 0, 1, 100, 0, 1);
  hsx3uVsx3d_23 = new TH2F("hsx3uVsx3d_23", "sx3u vs sx3d; sx3u E; sx3d E",  100, 0, 1, 100, 0, 1);
  hsx3uVsx3d_45 = new TH2F("hsx3uVsx3d_45", "sx3u vs sx3d; sx3u E; sx3d E",  1000, 0, 5000, 1000, 0, 5000);
  hsx3uVsx3d_67 = new TH2F("hsx3uVsx3d_67", "sx3u vs sx3d; sx3u E; sx3d E",  1000, 0, 5000, 1000, 0, 5000);
  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");

  hqqqVpcIndex_cut = new TH2F("hqqqVpcindex_cut", "qqq vs pc gated; qqq index; pc index",  4*2*16, 0, 4*2*16, 48, 0, 48);
  hqqqVpcIndex_cut->SetNdivisions( -612, "x");
  hqqqVpcIndex_cut->SetNdivisions( -12, "y");

  hqqqVpcE = new TH2F("hqqqVpcEnergy", "qqq vs pc; qqq energy; pc energy", 8000, 0, 16000, 8000, 0, 16000);
  hqqqVpcE->SetNdivisions( -612, "x");
  hqqqVpcE->SetNdivisions( -12, "y");
    
  hqqqVpcE_cut = new TH2F("hqqqVpcEnergy_cut", "qqq vs pc gated; qqq energy; pc energy", 8000, 0, 16000, 8000, 0, 16000);
  hqqqVpcE_cut->SetNdivisions( -612, "x");
  hqqqVpcE_cut->SetNdivisions( -12, "y");
    
    hqqqVpcE_cut1 = new TH2F("hqqqVpcEnergy_cut1", "qqq vs pc gated; qqq energy; pc energy", 8000, 0, 16000, 8000, 0, 16000);
    hqqqVpcE_cut1->SetNdivisions( -612, "x");
    hqqqVpcE_cut1->SetNdivisions( -12, "y");
      
    hqqqVpcE_cut2 = new TH2F("hqqqVpcEnergy_cut2", "qqq vs pc gated; qqq energy; pc energy", 8000, 0, 16000, 8000, 0, 16000);
    hqqqVpcE_cut2->SetNdivisions( -612, "x");
    hqqqVpcE_cut2->SetNdivisions( -12, "y");
    
    hqqqVpcE_cutCoinc = new TH2F("hqqqVpcEnergy_cutCoinc", "qqq vs pc gated; qqq energy; pc energy", 8000, 0, 16000, 8000, 0, 16000);
    hqqqVpcE_cutCoinc->SetNdivisions( -612, "x");
    hqqqVpcE_cutCoinc->SetNdivisions( -12, "y");
  hsx3bk_8=new TH1F("hsx3bk_8", "hsx3bk_8",1000, 0,5000);
  hsx3bk_9=new TH1F("hsx3bk_9", "hsx3bk_9",1000, 0,5000);
  hsx3bk_10=new TH1F("hsx3bk_10", "hsx3bk_10",1000, 0,5000); 
  hsx3bk_11=new TH1F("hsx3bk_11", "hsx3bk_11",1000, 0,5000);
  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");
  hsx3bk_9_shifted  = new TH1F("hsx3bk_9_shifted", "hsx3bk_9",1000, 0,5000);
  hsx3bk_10_shifted  = new TH1F("hsx3bk_10_shifted", "hsx3bk_9",1000, 0,5000);
  hsx3bk_11_shifted  = new TH1F("hsx3bk_11_shifted", "hsx3bk_9",1000, 0,5000);
  hZProj = new TH1F("hZProj", "Z Projection", 200, -600, 600);

  hanVScatsum = new TH2F("hanVScatsum", "Anode vs Cathode Sum; Anode E; Cathode E", 8000,0 , 16000, 8000, 0 , 16000);
  hanVScatsum_cut = new TH2F("hanVScatsum_cut", "Anode vs Cathode Sum gated; Anode E; Cathode E", 1600,0 , 16000, 1600, 0 , 16000);
    hanVScatsum_cut1 = new TH2F("hanVScatsum_cut1", "Anode vs Cathode Sum gated; Anode E; Cathode E", 1600,0 , 16000, 1600, 0 , 16000);
    hanVScatsum_cut2 = new TH2F("hanVScatsum_cut2", "Anode vs Cathode Sum gated; Anode E; Cathode E", 1600,0 , 16000, 1600, 0 , 16000);

  hVCID = new TH2F("hVCID", "Virtual Cathod ID vs total Cath. Energy", 200, 0, 24, 200, 0, 10000);

  sx3_contr.ConstructGeo();
  pw_contr.ConstructGeo();

  TFile *f3 = new TFile("Coinc_cut_set1.root");
    //TFile *f4 = new TFile("crap_cut.root");
  TFile *f = new TFile("AnCathCoinc_cut.root");
    TFile *f1 = new TFile("AnCathCoinc_cut1.root");
    TFile *f2 = new TFile("AnCathCoinc_cut2.root");

    
  Coinc_cut_set1 = (TCutG*)f3->Get("Coinc_cut_set1");
    //crap_cut = (TCutG*)f4->Get("crap_cut");
  AnCathCoinc_cut = (TCutG*)f->Get("AnCathCoinc_cut");
    AnCathCoinc_cut1 = (TCutG*)f1->Get("AnCathCoinc_cut1");
    AnCathCoinc_cut2 = (TCutG*)f2->Get("AnCathCoinc_cut2");

    
}




Bool_t gainmatch::Process(Long64_t entry){

  // if ( entry > 100 ) return kTRUE;

  hitPos.Clear();
  HitNonZero = false;
    inCut = 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
  // //======================= SX3

std::vector<std::pair<int, int>> ID; // first = id, 2nd = index
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]);

    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 (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;
    });

    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]);
            }
        }
    }

    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];
                    sx3EDn = sx3.e[index];
                } else {
                    sx3ChUp = sx3.ch[index];
                    sx3EUp = sx3.e[index];
                }
            } else {
                sx3ChBk = sx3.ch[index];
                sx3EBk = sx3.e[index];
            }

            int ch = sx3.ch[index];
            float energy = sx3.e[index];
            if (sx3ID[0].first == 9) {
               float peak8 = 0.0;
    		float peak9 = 0.0;
    		int peak10 = 0.0;
   		float peak11 = 0.0;
   		float shift9 =0.0;
   		float shift10 =0.0;
   		float shift11 =0.0;
   		int minBin_8 = hsx3bk_8->FindBin(1);
                int maxBin_8 = hsx3bk_8->FindBin(5000);
                int maxRangeBinContent_8 = -1;
                double maxBinCenter_8 = 0.0;
                int minBin_9 = hsx3bk_9->FindBin(1);
                int maxBin_9 = hsx3bk_9->FindBin(5000);
                int maxRangeBinContent_9 = -1;
                double maxBinCenter_9 = 0.0;
                int minBin_10 = hsx3bk_10->FindBin(1);
                int maxBin_10 = hsx3bk_10->FindBin(5000);
                int maxRangeBinContent_10 = -1;
                double maxBinCenter_10 = 0.0;
                int minBin_11 = hsx3bk_11->FindBin(1);
                int maxBin_11 = hsx3bk_11->FindBin(5000);
                int maxRangeBinContent_11 = -1;
                double maxBinCenter_11 = 0.0;
                if (sx3ChBk == 8) {
                   
                   hsx3bk_8->Fill(sx3EBk);
                    

                    for (int bin = minBin_8; bin <= maxBin_8; ++bin) {
                       if (hsx3bk_8->GetBinContent(bin) > maxRangeBinContent_8) {
                         maxRangeBinContent_8 = hsx3bk_8->GetBinContent(bin);
                         maxBinCenter_8 = hsx3bk_8->GetBinCenter(bin);
                       }
                    }

                   //peak8 = hsx3bk_8->GetMaximumBin();
                   //peak8 = hsx3bk_8->GetMaximumBin();
                   //printf("peak8: %f\n",  maxBinCenter_8);
                }
               //printf("peak8_mm: %f\n",  maxBinCenter);
               else if (sx3ChBk == 9) {
                  
                   hsx3bk_9->Fill(sx3EBk);
                   for (int bin = minBin_9; bin <= maxBin_9; ++bin) {
                       if (hsx3bk_9->GetBinContent(bin) > maxRangeBinContent_9) {
                         maxRangeBinContent_9 = hsx3bk_9->GetBinContent(bin);
                         maxBinCenter_9 = hsx3bk_9->GetBinCenter(bin);
                       }
                    }

                   //peak8 = hsx3bk_8->GetMaximumBin();
                   //peak8 = hsx3bk_8->GetMaximumBin();
                    //printf("peak9: %f\n",  maxBinCenter_9);
                   //hsx3bk_9_shifted->Fill(sx3EBk*0.76);
                    peak9 = 2097.5/maxBinCenter_9;
                    //printf("peak9_shift: %f\n",  peak9);
                    hsx3bk_9_shifted->Fill(sx3EBk*(2097.5/maxBinCenter_9));
                   //printf("peak9 %d\n", peak9);
                }
               else if(sx3ChBk == 10) {
                    
                   hsx3bk_10->Fill(sx3EBk);
                   for (int bin = minBin_10; bin <= maxBin_10; ++bin) {
                       if (hsx3bk_10->GetBinContent(bin) > maxRangeBinContent_10) {
                         maxRangeBinContent_10 = hsx3bk_10->GetBinContent(bin);
                         maxBinCenter_10 = hsx3bk_10->GetBinCenter(bin);
                       }
                    }

                   //peak8 = hsx3bk_8->GetMaximumBin();
                   //peak8 = hsx3bk_8->GetMaximumBin();
                    //printf("peak10: %f\n",  maxBinCenter_10);
                   //hsx3bk_9_shifted->Fill(sx3EBk*0.76);
                    peak10= 2097.5/maxBinCenter_10;
                    //printf("peak10_shift: %f\n", 1787.5/maxBinCenter_10);
                    hsx3bk_10_shifted->Fill(sx3EBk*(2097.5/maxBinCenter_10));
                   //printf("peak9 %d\n", peak9);
                }
                   //peak10 = hsx3bk_10->GetMaximumBin();
                   // printf("peak10 %d\n" ,peak10);
               
              else if(sx3ChBk == 11) {
                   
                   hsx3bk_11->Fill(sx3EBk);
                   for (int bin = minBin_11; bin <= maxBin_11; ++bin) {
                       if (hsx3bk_11->GetBinContent(bin) > maxRangeBinContent_11) {
                         maxRangeBinContent_11 = hsx3bk_11->GetBinContent(bin);
                         maxBinCenter_11 = hsx3bk_11->GetBinCenter(bin);
                       }
                    }

                   //peak8 = hsx3bk_8->GetMaximumBin();
                   //peak8 = hsx3bk_8->GetMaximumBin();
                    //printf("peak9: %f\n",  maxBinCenter_11);
                   //hsx3bk_9_shifted->Fill(sx3EBk*0.76);
                    peak11 = 2097.5/maxBinCenter_11;
                    //printf("peak11_shift: %f\n",  peak11);
                    hsx3bk_11_shifted->Fill(sx3EBk*(2097.5/maxBinCenter_11));
                   //printf("peak9 %d\n", peak9);
                
                }
                 
    	          
                  float sx3EBk_shifted = 0.0;
                  float sx3E_u_matched_01 = 0.0;
                  float sx3E_d_matched_01 = 0.0;
                  float sx3E_fb_matched_01 = 0.0;
                  float sx3E_fbu_matched_01 = 0.0;
                  float sx3E_fbd_matched_01 = 0.0;  
                  float diff =0.0;
                  float ratio = 0.0;
                  float coeff = 0.0;
                     if (sx3ChBk == 9) {
                        sx3EBk_shifted = (sx3EBk *(2097.5/maxBinCenter_9));
                     } else if (sx3ChBk == 10) {
                        sx3EBk_shifted = (sx3EBk * (2097.5/maxBinCenter_10));
                     } else if (sx3ChBk == 11) {
                       sx3EBk_shifted = (sx3EBk * (2097.5/maxBinCenter_11)) ;
                     } else {
                     sx3EBk_shifted = sx3EBk; // Use unshifted value for sx3ChBk == 8
                     }
                     if ((sx3ChUp == 1 && sx3ChDn == 0)) {
                        sx3E_u_matched_01= (sx3EUp-0.898729)/0.836243;
                        //sx3E_u_matched_01= (0.836243*sx3EDn)+0.898729;
                        sx3E_d_matched_01= (sx3EDn-0.898729)/0.836243;
                        sx3E_fb_matched_01=(sx3EBk_shifted+9.2423)/0.924773 ;
                        sx3E_fbu_matched_01=(sx3E_u_matched_01+9.2423)/0.924773 ;
                        sx3E_fbd_matched_01=(sx3E_d_matched_01+9.2423)/0.924773 ;
                        diff = sx3E_fb_matched_01 - (sx3EUp+sx3E_fbd_matched_01);
                        ratio = sx3EUp/sx3E_fbd_matched_01;
                        coeff = ((sx3EUp+diff) - (sx3E_fbd_matched_01*ratio))/(diff*(1+ratio));
                     }
                     
                 //TH2F *hsx3uVsx3d_01 = nullptr;
               if (sx3ChBk >=8) { 
                    
                  //if (sx3ChBk == 9) {
                     

                       
                          if ((sx3ChUp == 1 && sx3ChDn == 0)) {
                             if (sx3ChUp != -1 && sx3ChDn != -1 && sx3ChBk !=-1) {
                                if (sx3EBk_shifted > 50 && sx3EUp > 50 && sx3EDn > 50) {
                                 printf("sx3EUp: %f, sx3EDn: %f, sx3E_u_matched_01: %f,sx3E_d_matched_01: %f\n", sx3EUp, sx3EDn, sx3E_u_matched_01,sx3E_d_matched_01);
                              //printf("Filling hsx3uVsx3d_01_shifted: %f\n", sx3EBk_ud_matched_01 / sx3EBk_shifted);   
                             // hsx3uVsx3d_01->Fill(sx3E_u_matched_01 / sx3EBk_shifted, sx3E_d_matched_01 / sx3EBk_shifted);
                                  hsx3uVsx3d_01->Fill(sx3EUp / sx3EBk_shifted, sx3E_d_matched_01 / sx3EBk_shifted);                              
                                  hsx3uVsx3d_23->Fill(sx3EUp / sx3EBk_shifted, sx3EDn/ sx3EBk_shifted);
                            }
                       } 
                 //}
                }     
                  else if ((sx3ChUp == 3 && sx3ChDn == 2)) {
                       if (sx3ChUp != -1 && sx3ChDn != -1 && sx3ChBk !=-1) {
                         if (sx3EBk_shifted != 0 && sx3EBk_shifted > 50 && sx3EUp > 50 && sx3EDn > 50) {
                              printf("sx3EUp: %f, sx3EDn: %f, sx3EBk_shifted: %f\n", sx3EUp, sx3EDn, sx3EBk_shifted);
                              printf("Filling hsx3uVsx3d_23_shifted: %f\n", sx3EUp / sx3EBk_shifted);
                             // hsx3uVsx3d_23->Fill(sx3EUp / sx3EBk_shifted, (-0.924754*sx3EUp+0.916671) / sx3EBk_shifted);
                          
                         }
                      }    
                  }   
                   /* if ((sx3ChUp == 1 && sx3ChDn == 0)) {
                        if (sx3ChUp != -1 && sx3ChDn != -1 && sx3ChBk !=-1) {
                          if (sx3EBk != 0 && sx3EBk > 50 && sx3EUp > 50 && sx3EDn > 50) {
                            printf("sx3EUp: %f, sx3EDn: %f, sx3EBk: %f\n", sx3EUp, sx3EDn, sx3EBk);
                            printf("Filling hsx3uVsx3d_01: %f\n", sx3EUp / sx3EBk);
                            hsx3uVsx3d_45->Fill(sx3EUp / sx3EBk, sx3EDn / sx3EBk);
                          
                         }
                      }    
                  } 
                  else if ((sx3ChUp == 3 && sx3ChDn == 2)) {
                       if (sx3ChUp != -1 && sx3ChDn != -1 && sx3ChBk !=-1) {
                         if (sx3EBk != 0 && sx3EBk > 50 && sx3EUp > 50 && sx3EDn > 50) {
                            printf("sx3EUp: %f, sx3EDn: %f, sx3EBk: %f\n", sx3EUp, sx3EDn, sx3EBk);
                            printf("Filling hsx3uVsx3d_23: %f\n", sx3EUp / sx3EBk);
                            hsx3uVsx3d_67->Fill(sx3EUp / sx3EBk, sx3EDn / sx3EBk);
                           
                         }
                      }    
                }*/
                 if (sx3ChUp == 1 && sx3ChDn == 0){
                //if (sx3ChUp == 1 || sx3ChDn == 0 || sx3ChUp == 3 || sx3ChDn == 2 || sx3ChUp == 5 || sx3ChDn == 4 || sx3ChUp == 7 || sx3ChDn == 6) {
                        if (sx3ChUp != -1  && sx3ChBk !=-1 && sx3ChDn !=-1) {
                           if (sx3EBk_shifted > 50 && sx3EUp > 50 && sx3EDn>50  &&sx3E_u_matched_01>50 && sx3E_u_matched_01>50) {
                              //printf("sx3EUp: %f, sx3EDn: %f, sx3E_u_matched_01: %f,sx3E_d_matched_01: %f\n", sx3EUp, sx3EDn, sx3E_u_matched_01,sx3E_d_matched_01);
                              printf("Filling hsx3uVsx3d_nn: %f, gggggg: %f \n", (sx3EUp+sx3EDn),(sx3E_u_matched_01+sx3E_d_matched_01) );   
                              hsx3uVsx3d_45->Fill((sx3EUp+sx3E_d_matched_01),sx3EBk_shifted);
                              hsx3uVsx3d_67->Fill((sx3EUp+sx3E_d_matched_01),sx3E_fb_matched_01);
                            } 
                       } 
                 }
                  /*if (sx3ChBk > 8) {
                     if ((sx3ChUp == 7 && sx3ChDn == 6) || 
                         (sx3ChUp == 5 && sx3ChDn == 4) || 
                         (sx3ChUp == 3 && sx3ChDn == 2) || 
                         (sx3ChUp == 1 && sx3ChDn == 0)) {
                    if (sx3ChUp != -1 && sx3ChDn != -1 && sx3ChBk !=-1) {
                        if (sx3EBk != 0 && sx3EBk > 50 && sx3EUp > 50 && sx3EDn > 50) {
                            hsx3uVsx3d->Fill(sx3EUp / sx3EBk, sx3EDn / sx3EBk);
                            hsx3Vsx3->Fill(sx3EUp ,sx3EDn);
                            printf("sx3EUp: %f | sx3EDn: %f | sx3EBk: %f | sx3ChUp: %d | sx3ChDn: %d | sx3ChBk: %d\n", sx3EUp, sx3EDn, sx3EBk, sx3ChUp, sx3ChDn, sx3ChBk);
                        }
                    }
                  }
                 }*/
                 //else {
                    //printf("sx3EUp\n");
                //}
            if (sx3ChUp == 1 && sx3ChDn == 0){
               
                if (sx3ChUp != -1  && sx3ChBk !=-1 && sx3ChDn !=-1) {
                    if (sx3E_d_matched_01> sx3EUp ) {
                       //printf("hZd_01_1_dn: %f\n", sx3E_d_matched_01);
                        //printf("hZd_01_1_b: %f\n", sx3E_fb_matched_01);
                        hZd_01_1->Fill((2*(sx3E_d_matched_01+(coeff*diff))/sx3E_fb_matched_01)-1);
                        }
                    else if(sx3EUp> sx3E_d_matched_01) {
                        //printf("hZd_01_2_sx3EUp: %f\n",sx3EUp );
                        //printf("hZd_01_2_sx3EDn: %f\n",sx3E_fb_matched_01);
                        
                        hZd_01_2->Fill(1-(2*(sx3EUp+(1-coeff)*diff))/sx3E_fb_matched_01);
                        }  
                    else if(sx3EUp>0.0  && sx3E_d_matched_01>0.0 && sx3E_d_matched_01>=sx3EUp ) {
                        hZd_01_3->Fill((2*(sx3E_d_matched_01+ coeff*diff)/sx3E_fb_matched_01)-1);
                        } 
                    else if(sx3EUp>0.0  && sx3E_d_matched_01>0.0 && sx3E_d_matched_01<sx3EUp ) {
                        hZd_01_4->Fill(1-(2*(sx3EUp+ (1-coeff)*diff)/sx3E_fb_matched_01));
                       } 
                 }
            }
          }
            for (int j = 0; j < pc.multi; j++) {
                if (sx3.ch[index] > 8) {
                    hsx3VpcE->Fill(sx3.e[i], pc.e[j]);
                }
            }
        }

        sx3_contr.CalSX3Pos(sx3ID[0].first, sx3ChUp, sx3ChDn, sx3ChBk, sx3EUp, sx3EDn);
        hitPos = sx3_contr.GetHitPos();
        HitNonZero = true;
        // hitPos.Print();
    }
}





  // //======================= PC


  //########################################################### Track constrcution


  //############################## DO THE KINEMATICS

}
  return kTRUE;
}

void gainmatch::Terminate(){

 
}