yangyong/combineICEE/testSelection_cluster.h

    
TChain *fChain; 

int dataflag; 

int totalEntries; 


int totalEntriesL1; 


int entry; 


int doBarrel; 
int doEndcap; 

int trigger; 

  
  float ptminCut; 
float ptpairCut; 
float s4s9Cut; 
float s9s25Cut; 
float isoCut; 


 // L1 objects
      static const int MAXL1OBJ = 20;
      //     static const int MAXL1BITS = 128;
      // L1 EM isolated objects
      int nL1EMIso;
      float L1EMIso_e[MAXL1OBJ];
      float L1EMIso_et[MAXL1OBJ];
      float L1EMIso_eta[MAXL1OBJ];
      float L1EMIso_phi[MAXL1OBJ];
      // L1 EM non-isolated objects
      int nL1EMnonIso;
      float L1EMnonIso_e[MAXL1OBJ];
      float L1EMnonIso_et[MAXL1OBJ];
      float L1EMnonIso_eta[MAXL1OBJ];
      float L1EMnonIso_phi[MAXL1OBJ];

      int bunchX; 
      int orbitNumber; 
      int evtTime; 
      
      int runNumber; 
      int evtNumber; 
      int lumiBlock; 
    static const int MAXL1bits = 500;
      static const int MAXHLTbits = 500;
      int nL1bits;
      int L1bits[MAXL1bits];

int nL1Alca; 
int L1Alca[MAXL1bits];

      
      int nL1bitsTech;
      int L1bitsTech[MAXL1bits];

int psL1; 
int L1Cut; 

int dpsL1DecisionWord8E29v3; 
int dpsL1DecisionWord8E29v3_1; 
int dpsL1DecisionWord8E29v3_2; 
int dpsL1DecisionWord8E29v3_3; 
int dpsL1DecisionWord8E29v3_4; 
int dpsL1DecisionWord8E29v3_5; 
int dpsL1DecisionWord8E29v4; 

int dpsL1bits8E29v3[MAXL1bits];

int dpsL1bits8E29v3_1[MAXL1bits];
int dpsL1bits8E29v3_2[MAXL1bits];
int dpsL1bits8E29v3_3[MAXL1bits];
int dpsL1bits8E29v3_4[MAXL1bits];
int dpsL1bits8E29v3_5[MAXL1bits];


int dpsL1bits8E29v4[MAXL1bits];

int iCountL1NoPrescale8E29v3[500]; ///2009.06.27

int iCountL1NoPrescale8E29v3_1[500]; ///2009.06.27 EG PS = 10 
int iCountL1NoPrescale8E29v3_2[500]; ///2009.06.27 EG PS = 20 
int iCountL1NoPrescale8E29v3_3[500]; ///2009.06.27 EG PS = 50 
int iCountL1NoPrescale8E29v3_4[500]; ///2009.06.27 EG PS = 2 
int iCountL1NoPrescale8E29v3_5[500]; ///2009.06.27 EG PS = 4 


int iCountL1NoPrescale8E29v4[500]; ///2009.06.27, prescale 100 for EG5, Jet6,10,20


      float xOffPVwithBS;
      float yOffPVwithBS;
      float zOffPVwithBS;


      static const int MAXGenPIZ = 1000; 

      int nGenpi0; 
      int nGeneta; 
      float etaGenpi0[MAXGenPIZ];
      float phiGenpi0[MAXGenPIZ];
      float etGenpi0[MAXGenPIZ];
      float eGenpi0[MAXGenPIZ];
      float mGenpi0[MAXGenPIZ];
      float dr2phGenpi0[MAXGenPIZ];
      float dr2phGeneta[MAXGenPIZ];
      float etaGeneta[MAXGenPIZ];
      float phiGeneta[MAXGenPIZ];
      float etGeneta[MAXGenPIZ];
      float eGeneta[MAXGenPIZ];
      float ePhtGenpi0[MAXGenPIZ][2];
      float etaPhtGenpi0[MAXGenPIZ][2];
      float phiPhtGenpi0[MAXGenPIZ][2];
      float ePhtGeneta[MAXGenPIZ][2];
      float etaPhtGeneta[MAXGenPIZ][2];
      float phiPhtGeneta[MAXGenPIZ][2];
      float vtxGenpi0[MAXGenPIZ][3];
      float vtxPhtGenpi0[MAXGenPIZ][3];
      float vtxGeneta[MAXGenPIZ][3];
      float vtxPhtGeneta[MAXGenPIZ][3];


      int pidMomGenpi0[MAXGenPIZ];
      int barcodeMomGenpi0[MAXGenPIZ];
      
      int pidMomGeneta[MAXGenPIZ];
      int barcodeMomGeneta[MAXGenPIZ];

      int isConvPhtGeneta[MAXGenPIZ][2];
      float convPht1Geneta[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
      float convPht2Geneta[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi

      int isConvPhtGenpi0[MAXGenPIZ][2];
      float convPht1Genpi0[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
      float convPht2Genpi0[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
      float convVtxPhtGenpi0[MAXGenPIZ][6];
      float convVtxPhtGeneta[MAXGenPIZ][6];
      
   static const int MAX3x3ClusEB = 2000;
      int n3x3ClusEB;
      float e3x3ClusEB[MAX3x3ClusEB];
      float eta3x3ClusEB[MAX3x3ClusEB];
      float phi3x3ClusEB[MAX3x3ClusEB];

      ///tmp by simplelog
      float leta3x3ClusEB[MAX3x3ClusEB];
      float lphi3x3ClusEB[MAX3x3ClusEB];
      

      float x3x3ClusEB[MAX3x3ClusEB];
      float y3x3ClusEB[MAX3x3ClusEB];
      float z3x3ClusEB[MAX3x3ClusEB];

      int nXt3x3ClusEB[MAX3x3ClusEB];
      float eXt3x3ClusEB[MAX3x3ClusEB][9];
      int ietaXt3x3ClusEB[MAX3x3ClusEB][9]; ///index from -85,0,84; ,
      int iphiXt3x3ClusEB[MAX3x3ClusEB][9]; ///phi, 0,359
      float etaXt3x3ClusEB[MAX3x3ClusEB][9];
      float phiXt3x3ClusEB[MAX3x3ClusEB][9];
      
      
      float xXt3x3ClusEB[MAX3x3ClusEB][9];
      float yXt3x3ClusEB[MAX3x3ClusEB][9];
      float zXt3x3ClusEB[MAX3x3ClusEB][9];
      float S43x3ClusEB[MAX3x3ClusEB];
      float S63x3ClusEB[MAX3x3ClusEB];
      float S253x3ClusEB[MAX3x3ClusEB];
      
      float s4s93x3ClusEB[MAX3x3ClusEB];
      float s6s93x3ClusEB[MAX3x3ClusEB];
      float s9s253x3ClusEB[MAX3x3ClusEB];
      
      
      static const int MAX3x3ClusEE = 2000;
      int n3x3ClusEE;
      float e3x3ClusEE[MAX3x3ClusEE];
      float eta3x3ClusEE[MAX3x3ClusEE];
      float phi3x3ClusEE[MAX3x3ClusEE];

      ///tmp by simplelog
      float leta3x3ClusEE[MAX3x3ClusEE];
      float lphi3x3ClusEE[MAX3x3ClusEE];
      float tXt3x3ClusEB[MAX3x3ClusEB][9];  

      float x3x3ClusEE[MAX3x3ClusEE];
      float y3x3ClusEE[MAX3x3ClusEE];
      float z3x3ClusEE[MAX3x3ClusEE];

      int nXt3x3ClusEE[MAX3x3ClusEE];
      float eXt3x3ClusEE[MAX3x3ClusEE][9];
      int ixXt3x3ClusEE[MAX3x3ClusEE][9]; ///index from -85,0,84; ,
      int iyXt3x3ClusEE[MAX3x3ClusEE][9]; ///phi, 0,359
      int izXt3x3ClusEE[MAX3x3ClusEE][9]; ///phi, 0,359
      
      float etaXt3x3ClusEE[MAX3x3ClusEE][9];
      float phiXt3x3ClusEE[MAX3x3ClusEE][9];
     float tXt3x3ClusEE[MAX3x3ClusEE][9];   
      
      float xXt3x3ClusEE[MAX3x3ClusEE][9];
      float yXt3x3ClusEE[MAX3x3ClusEE][9];
      float zXt3x3ClusEE[MAX3x3ClusEE][9];
      float S43x3ClusEE[MAX3x3ClusEE];
      float S63x3ClusEE[MAX3x3ClusEE];
      float S253x3ClusEE[MAX3x3ClusEE];
      
      float s4s93x3ClusEE[MAX3x3ClusEE];
      float s6s93x3ClusEE[MAX3x3ClusEE];
      float s9s253x3ClusEE[MAX3x3ClusEE];
      

float xEBAll[170][360];  ///eta -85, -1, 1, 86, [0,169].  phi, 1,360, [0,359];
float yEBAll[170][360]; 
float zEBAll[170][360]; 
float etaEBAll[170][360]; 
float phiEBAll[170][360]; 

float dxEBAll[170][360];  ///eta -85, -1, 1, 86, [0,169].  phi, 1,360, [0,359];
float dyEBAll[170][360]; 
float dzEBAll[170][360]; 

float xEEAll[2][101][101];
float yEEAll[2][101][101];
float zEEAll[2][101][101];
float etaEEAll[2][101][101];
float phiEEAll[2][101][101];


float dxEEAll[2][101][101];
float dyEEAll[2][101][101];
float dzEEAll[2][101][101];
int nCrystalCut;
int doPizEta; 
bool useGenVtxforRecoGenMatch;
int dataOrMC;

vector<int> L1bitsUsed; 
vector<int> L1bitsTechUsed; 

vector<int> L1bitsNotUsed; 
vector<int> L1bitsTechNotUsed; 

ofstream txtout; 
int useRecVtxforReco ;
int vetoRunList;
int evtNotUse;
int applyBPTX;
int procID;
int vetoBeamSrape;

  int nPxlHits ; 
      float clusVtxQual; 
      
      int    nHfTowersP     ;
      int    nHfTowersN     ; 

      float sumHfEsubEpPlus; 
      float sumHfEsubEpMinus; 
      
      float sumHfEaddEpPlus; 
      float sumHfEaddEpMinus; 
      
      
      int phyDeclared; 
      
      float highPurityTrackFrac; 
 static const int MAXTRK = 5000;
      int nTracks;
      float pxTracks[MAXTRK];
      float pyTracks[MAXTRK];
      float pzTracks[MAXTRK];
      float pTracks[MAXTRK];
      float ptTracks[MAXTRK];
      float etaTracks[MAXTRK];
      float phiTracks[MAXTRK];
      int pidTracks[MAXTRK];
      int chargeTracks[MAXTRK]; 
      float vxTracks[MAXTRK];
      float vyTracks[MAXTRK];
      float vzTracks[MAXTRK];
      int nhitsTracks[MAXTRK];
      float nChi2Tracks[MAXTRK];
      int algoTracks[MAXTRK];
      int ndofTracks[MAXTRK];
      int nValidhitsTracks[MAXTRK];
      int nValidpixelhitsTracks[MAXTRK];
      int nValidstriphitsTracks[MAXTRK];
      int qualityFlagTracks[MAXTRK];
      
      float vBeamSpot[3];
int hfCoindence;
int vetoHighHitPxl;
int recalcs4s9;
int applyEnCorr;
int corrSeedEnScale;
float eSeed;
int vetoSpike;
int applyPhyDeclare;
int validVtx;
int NtrkOffPVwithBS;
float ptminCut_ee;
float s4s9Cut_ee;
float s9s25Cut_ee;
int passEG3;
int passEG2;
int passEG4;
int passEG5;


///make above in one
///first one mean ncut
///at most 10 cuts, 100 steps each.
float variable[10];
const int ncuts = 5; 
///min max cut 
float init_cutValue[10][2];
int nstepCut[10];
float cutValues[10][100];

const int nstepsMAX = 31; 
//at most 20 steps.
int nSigPassed[nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX];
int nBkgPassed[nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX];


int IsSignal; 
int IsBkgrd; 
int indexBestCuts1[10];
int indexBestCuts2[10];

float isolation; 


///for differetn fom
int indexBestCuts[10][10];

//SB>0.5,0.6...
int indexBestCuts_SB[10][10][10];


///for different fom and cuts
TH1F *hh_fom[10][10]; 


  Float_t         mpair;
   Float_t         ptpair;
   Int_t           pizMatched;
   Int_t           etaMatched;
   Int_t           pizMatchedv1;
   Int_t           etaMatchedv1;
   Float_t         ptmin;
   Float_t         s4s9min;
   Float_t         s9s25min;
   Float_t         iso;
   Float_t         isoeta;
   Float_t         isov1;
   Float_t         isoetav1;
   Float_t         isov2;
   Float_t         isoetav2;
   Int_t           passL1;
   Int_t           nxt9[2];
   Int_t           seediEta[2];
   Int_t           seediPhi[2];

int doEcut; 

int testAbsoluteIso; 
float ptminOpt;
int izXt3x3ClusEB[MAX3x3ClusEB][9];
Int_t seediZ[2];
Float_t etapair;
int isoflag;
int ptCutSetee;
int testpizwind;
float eSeed_ee;
int fullunpack;


TTree *pizTree; 


TTree *etaTree; 

      float mpair_3x3; 
int nxtClus1; 
      float eXtalClus1[25];
      int ietaXtalClus1[25];
      int iphiXtalClus1[25];
      float tXtalClus1[25];
      int fXtalClus1[25];
      int nxtClus2; 
      float eXtalClus2[25];
      int ietaXtalClus2[25];
      int iphiXtalClus2[25];
      float tXtalClus2[25];
      int fXtalClus2[25];
int savePizTree;


int passBSC40or41;
int passBSC34;
int passHF;
int passBeamScrape;
int passVtx;
int passBeamHalo;
int passBSC0;
int passHighHitPxl;
int rmOverlap;
float mpairv1;
float phipair; 
float geninfo[6];
int start_entry;
int end_entry;
int calibMethod;
int applyCorrEta;
int applyCorrPhi;
int applyCorrDead; 


double corrfactorEta[170];
double corrfactorEtatb[170];
double corrfactorEtaco[170];
double corrfactorPhi[360];
double corrfactoriEtaiPhi[170][360];

///pre-calib ( all 1)  or phi-sym or BS 
double preCalibiEtaiPhi[170][360];


int iterStep;

int cutset;
int evtRange;
int flagiEtaiPhi[170][360];
int usePreCalib;
int useVtx;
float randGausiEtaiPhi[170][360];

const int kEndcEtaRings = 39;
float eta_ring_ee[kEndcEtaRings];
float etaBoundary_ee[kEndcEtaRings+1];
int nxtal_ring_ee[kEndcEtaRings];
float eta_ring_eezside[2][kEndcEtaRings];
float etaBoundary_eezside[2][kEndcEtaRings+1];


///calibration constant fro endcap
double corrfactorEtaRings[2][kEndcEtaRings]; 
double corrfactoriZiXiY[2][101][101];

int izXtalClus1[25];
int izXtalClus2[25];

double corrfactorSM[36];
int applyCorrSM;
TChain *fChainAlca;

double corrfactorSM_final[36];


float Cpi0Corrv1[170][360];
float Cpi0v1[170][360];

float Ccombv1[170][360];
float CcombCorrv1[170][360];

float Cphi[170][360];
float CBS[170][360];

float CphiCorr[170][360];
float CBSCorr[170][360];
int flag_ietaiphi[170][360];
int ndead_ietaiphi[170][360];
int ndeadcorner_ietaiphi[170][360];
int ndeadside_ietaiphi[170][360];
int ndeadflag_ietaiphi[170][360];
double corrfactorDead[20] ;
int evtNotUsed;

///some correction to crystals
double preCorrectionIetaIphi[170][360];
double corrfactorIetaSM[38][85];
double corrfactorPhiSide[2][360];
int validRecHitEndCap[2][101][101];
int flag_endcap[2][101][101];
int ndeadcorner_endcap[2][101][101];
int ndeadside_endcap[2][101][101];
int ndeadflag_endcap[2][101][101];
Revision:	1.1
Committed:	Tue Apr 10 20:03:11 2012 UTC (13 years, 1 month ago) by yangyong
Content type:	text/plain
Branch:	MAIN
CVS Tags:	V2012comb, pi0etaee_laser20111122_eefloatalpha, HEAD
Log Message:	LaserTag: EcalLaserAPDPNRatios_data_20111122_158851_180363 and alpha Tag ( for Endcap Only) EcalLaserAlphas_lto420-620_progr_data_20111122
#	User	Rev	Content
1	yangyong	1.1
2			TChain *fChain;
3
4			int dataflag;
5
6			int totalEntries;
7
8
9			int totalEntriesL1;
10
11
12			int entry;
13
14
15			int doBarrel;
16			int doEndcap;
17
18			int trigger;
19
20
21			float ptminCut;
22			float ptpairCut;
23			float s4s9Cut;
24			float s9s25Cut;
25			float isoCut;
26
27
28			// L1 objects
29			static const int MAXL1OBJ = 20;
30			// static const int MAXL1BITS = 128;
31			// L1 EM isolated objects
32			int nL1EMIso;
33			float L1EMIso_e[MAXL1OBJ];
34			float L1EMIso_et[MAXL1OBJ];
35			float L1EMIso_eta[MAXL1OBJ];
36			float L1EMIso_phi[MAXL1OBJ];
37			// L1 EM non-isolated objects
38			int nL1EMnonIso;
39			float L1EMnonIso_e[MAXL1OBJ];
40			float L1EMnonIso_et[MAXL1OBJ];
41			float L1EMnonIso_eta[MAXL1OBJ];
42			float L1EMnonIso_phi[MAXL1OBJ];
43
44			int bunchX;
45			int orbitNumber;
46			int evtTime;
47
48			int runNumber;
49			int evtNumber;
50			int lumiBlock;
51			static const int MAXL1bits = 500;
52			static const int MAXHLTbits = 500;
53			int nL1bits;
54			int L1bits[MAXL1bits];
55
56			int nL1Alca;
57			int L1Alca[MAXL1bits];
58
59
60			int nL1bitsTech;
61			int L1bitsTech[MAXL1bits];
62
63			int psL1;
64			int L1Cut;
65
66			int dpsL1DecisionWord8E29v3;
67			int dpsL1DecisionWord8E29v3_1;
68			int dpsL1DecisionWord8E29v3_2;
69			int dpsL1DecisionWord8E29v3_3;
70			int dpsL1DecisionWord8E29v3_4;
71			int dpsL1DecisionWord8E29v3_5;
72			int dpsL1DecisionWord8E29v4;
73
74			int dpsL1bits8E29v3[MAXL1bits];
75
76			int dpsL1bits8E29v3_1[MAXL1bits];
77			int dpsL1bits8E29v3_2[MAXL1bits];
78			int dpsL1bits8E29v3_3[MAXL1bits];
79			int dpsL1bits8E29v3_4[MAXL1bits];
80			int dpsL1bits8E29v3_5[MAXL1bits];
81
82
83			int dpsL1bits8E29v4[MAXL1bits];
84
85			int iCountL1NoPrescale8E29v3[500]; ///2009.06.27
86
87			int iCountL1NoPrescale8E29v3_1[500]; ///2009.06.27 EG PS = 10
88			int iCountL1NoPrescale8E29v3_2[500]; ///2009.06.27 EG PS = 20
89			int iCountL1NoPrescale8E29v3_3[500]; ///2009.06.27 EG PS = 50
90			int iCountL1NoPrescale8E29v3_4[500]; ///2009.06.27 EG PS = 2
91			int iCountL1NoPrescale8E29v3_5[500]; ///2009.06.27 EG PS = 4
92
93
94			int iCountL1NoPrescale8E29v4[500]; ///2009.06.27, prescale 100 for EG5, Jet6,10,20
95
96
97			float xOffPVwithBS;
98			float yOffPVwithBS;
99			float zOffPVwithBS;
100
101
102			static const int MAXGenPIZ = 1000;
103
104			int nGenpi0;
105			int nGeneta;
106			float etaGenpi0[MAXGenPIZ];
107			float phiGenpi0[MAXGenPIZ];
108			float etGenpi0[MAXGenPIZ];
109			float eGenpi0[MAXGenPIZ];
110			float mGenpi0[MAXGenPIZ];
111			float dr2phGenpi0[MAXGenPIZ];
112			float dr2phGeneta[MAXGenPIZ];
113			float etaGeneta[MAXGenPIZ];
114			float phiGeneta[MAXGenPIZ];
115			float etGeneta[MAXGenPIZ];
116			float eGeneta[MAXGenPIZ];
117			float ePhtGenpi0[MAXGenPIZ][2];
118			float etaPhtGenpi0[MAXGenPIZ][2];
119			float phiPhtGenpi0[MAXGenPIZ][2];
120			float ePhtGeneta[MAXGenPIZ][2];
121			float etaPhtGeneta[MAXGenPIZ][2];
122			float phiPhtGeneta[MAXGenPIZ][2];
123			float vtxGenpi0[MAXGenPIZ][3];
124			float vtxPhtGenpi0[MAXGenPIZ][3];
125			float vtxGeneta[MAXGenPIZ][3];
126			float vtxPhtGeneta[MAXGenPIZ][3];
127
128
129			int pidMomGenpi0[MAXGenPIZ];
130			int barcodeMomGenpi0[MAXGenPIZ];
131
132			int pidMomGeneta[MAXGenPIZ];
133			int barcodeMomGeneta[MAXGenPIZ];
134
135			int isConvPhtGeneta[MAXGenPIZ][2];
136			float convPht1Geneta[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
137			float convPht2Geneta[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
138
139			int isConvPhtGenpi0[MAXGenPIZ][2];
140			float convPht1Genpi0[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
141			float convPht2Genpi0[MAXGenPIZ][6]; ///e, eta, phi, e, eta, phi
142			float convVtxPhtGenpi0[MAXGenPIZ][6];
143			float convVtxPhtGeneta[MAXGenPIZ][6];
144
145			static const int MAX3x3ClusEB = 2000;
146			int n3x3ClusEB;
147			float e3x3ClusEB[MAX3x3ClusEB];
148			float eta3x3ClusEB[MAX3x3ClusEB];
149			float phi3x3ClusEB[MAX3x3ClusEB];
150
151			///tmp by simplelog
152			float leta3x3ClusEB[MAX3x3ClusEB];
153			float lphi3x3ClusEB[MAX3x3ClusEB];
154
155
156			float x3x3ClusEB[MAX3x3ClusEB];
157			float y3x3ClusEB[MAX3x3ClusEB];
158			float z3x3ClusEB[MAX3x3ClusEB];
159
160			int nXt3x3ClusEB[MAX3x3ClusEB];
161			float eXt3x3ClusEB[MAX3x3ClusEB][9];
162			int ietaXt3x3ClusEB[MAX3x3ClusEB][9]; ///index from -85,0,84; ,
163			int iphiXt3x3ClusEB[MAX3x3ClusEB][9]; ///phi, 0,359
164			float etaXt3x3ClusEB[MAX3x3ClusEB][9];
165			float phiXt3x3ClusEB[MAX3x3ClusEB][9];
166
167
168			float xXt3x3ClusEB[MAX3x3ClusEB][9];
169			float yXt3x3ClusEB[MAX3x3ClusEB][9];
170			float zXt3x3ClusEB[MAX3x3ClusEB][9];
171			float S43x3ClusEB[MAX3x3ClusEB];
172			float S63x3ClusEB[MAX3x3ClusEB];
173			float S253x3ClusEB[MAX3x3ClusEB];
174
175			float s4s93x3ClusEB[MAX3x3ClusEB];
176			float s6s93x3ClusEB[MAX3x3ClusEB];
177			float s9s253x3ClusEB[MAX3x3ClusEB];
178
179
180
181			static const int MAX3x3ClusEE = 2000;
182			int n3x3ClusEE;
183			float e3x3ClusEE[MAX3x3ClusEE];
184			float eta3x3ClusEE[MAX3x3ClusEE];
185			float phi3x3ClusEE[MAX3x3ClusEE];
186
187			///tmp by simplelog
188			float leta3x3ClusEE[MAX3x3ClusEE];
189			float lphi3x3ClusEE[MAX3x3ClusEE];
190			float tXt3x3ClusEB[MAX3x3ClusEB][9];
191
192			float x3x3ClusEE[MAX3x3ClusEE];
193			float y3x3ClusEE[MAX3x3ClusEE];
194			float z3x3ClusEE[MAX3x3ClusEE];
195
196			int nXt3x3ClusEE[MAX3x3ClusEE];
197			float eXt3x3ClusEE[MAX3x3ClusEE][9];
198			int ixXt3x3ClusEE[MAX3x3ClusEE][9]; ///index from -85,0,84; ,
199			int iyXt3x3ClusEE[MAX3x3ClusEE][9]; ///phi, 0,359
200			int izXt3x3ClusEE[MAX3x3ClusEE][9]; ///phi, 0,359
201
202			float etaXt3x3ClusEE[MAX3x3ClusEE][9];
203			float phiXt3x3ClusEE[MAX3x3ClusEE][9];
204			float tXt3x3ClusEE[MAX3x3ClusEE][9];
205
206			float xXt3x3ClusEE[MAX3x3ClusEE][9];
207			float yXt3x3ClusEE[MAX3x3ClusEE][9];
208			float zXt3x3ClusEE[MAX3x3ClusEE][9];
209			float S43x3ClusEE[MAX3x3ClusEE];
210			float S63x3ClusEE[MAX3x3ClusEE];
211			float S253x3ClusEE[MAX3x3ClusEE];
212
213			float s4s93x3ClusEE[MAX3x3ClusEE];
214			float s6s93x3ClusEE[MAX3x3ClusEE];
215			float s9s253x3ClusEE[MAX3x3ClusEE];
216
217
218			float xEBAll[170][360]; ///eta -85, -1, 1, 86, [0,169]. phi, 1,360, [0,359];
219			float yEBAll[170][360];
220			float zEBAll[170][360];
221			float etaEBAll[170][360];
222			float phiEBAll[170][360];
223
224			float dxEBAll[170][360]; ///eta -85, -1, 1, 86, [0,169]. phi, 1,360, [0,359];
225			float dyEBAll[170][360];
226			float dzEBAll[170][360];
227
228			float xEEAll[2][101][101];
229			float yEEAll[2][101][101];
230			float zEEAll[2][101][101];
231			float etaEEAll[2][101][101];
232			float phiEEAll[2][101][101];
233
234
235			float dxEEAll[2][101][101];
236			float dyEEAll[2][101][101];
237			float dzEEAll[2][101][101];
238			int nCrystalCut;
239			int doPizEta;
240			bool useGenVtxforRecoGenMatch;
241			int dataOrMC;
242
243			vector<int> L1bitsUsed;
244			vector<int> L1bitsTechUsed;
245
246			vector<int> L1bitsNotUsed;
247			vector<int> L1bitsTechNotUsed;
248
249			ofstream txtout;
250			int useRecVtxforReco ;
251			int vetoRunList;
252			int evtNotUse;
253			int applyBPTX;
254			int procID;
255			int vetoBeamSrape;
256
257			int nPxlHits ;
258			float clusVtxQual;
259
260			int nHfTowersP ;
261			int nHfTowersN ;
262
263			float sumHfEsubEpPlus;
264			float sumHfEsubEpMinus;
265
266			float sumHfEaddEpPlus;
267			float sumHfEaddEpMinus;
268
269
270			int phyDeclared;
271
272			float highPurityTrackFrac;
273			static const int MAXTRK = 5000;
274			int nTracks;
275			float pxTracks[MAXTRK];
276			float pyTracks[MAXTRK];
277			float pzTracks[MAXTRK];
278			float pTracks[MAXTRK];
279			float ptTracks[MAXTRK];
280			float etaTracks[MAXTRK];
281			float phiTracks[MAXTRK];
282			int pidTracks[MAXTRK];
283			int chargeTracks[MAXTRK];
284			float vxTracks[MAXTRK];
285			float vyTracks[MAXTRK];
286			float vzTracks[MAXTRK];
287			int nhitsTracks[MAXTRK];
288			float nChi2Tracks[MAXTRK];
289			int algoTracks[MAXTRK];
290			int ndofTracks[MAXTRK];
291			int nValidhitsTracks[MAXTRK];
292			int nValidpixelhitsTracks[MAXTRK];
293			int nValidstriphitsTracks[MAXTRK];
294			int qualityFlagTracks[MAXTRK];
295
296			float vBeamSpot[3];
297			int hfCoindence;
298			int vetoHighHitPxl;
299			int recalcs4s9;
300			int applyEnCorr;
301			int corrSeedEnScale;
302			float eSeed;
303			int vetoSpike;
304			int applyPhyDeclare;
305			int validVtx;
306			int NtrkOffPVwithBS;
307			float ptminCut_ee;
308			float s4s9Cut_ee;
309			float s9s25Cut_ee;
310			int passEG3;
311			int passEG2;
312			int passEG4;
313			int passEG5;
314
315
316
317
318			///make above in one
319			///first one mean ncut
320			///at most 10 cuts, 100 steps each.
321			float variable[10];
322			const int ncuts = 5;
323			///min max cut
324			float init_cutValue[10][2];
325			int nstepCut[10];
326			float cutValues[10][100];
327
328			const int nstepsMAX = 31;
329			//at most 20 steps.
330			int nSigPassed[nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX];
331			int nBkgPassed[nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX][nstepsMAX];
332
333
334			int IsSignal;
335			int IsBkgrd;
336			int indexBestCuts1[10];
337			int indexBestCuts2[10];
338
339			float isolation;
340
341
342			///for differetn fom
343			int indexBestCuts[10][10];
344
345			//SB>0.5,0.6...
346			int indexBestCuts_SB[10][10][10];
347
348
349			///for different fom and cuts
350			TH1F *hh_fom[10][10];
351
352
353			Float_t mpair;
354			Float_t ptpair;
355			Int_t pizMatched;
356			Int_t etaMatched;
357			Int_t pizMatchedv1;
358			Int_t etaMatchedv1;
359			Float_t ptmin;
360			Float_t s4s9min;
361			Float_t s9s25min;
362			Float_t iso;
363			Float_t isoeta;
364			Float_t isov1;
365			Float_t isoetav1;
366			Float_t isov2;
367			Float_t isoetav2;
368			Int_t passL1;
369			Int_t nxt9[2];
370			Int_t seediEta[2];
371			Int_t seediPhi[2];
372
373			int doEcut;
374
375			int testAbsoluteIso;
376			float ptminOpt;
377			int izXt3x3ClusEB[MAX3x3ClusEB][9];
378			Int_t seediZ[2];
379			Float_t etapair;
380			int isoflag;
381			int ptCutSetee;
382			int testpizwind;
383			float eSeed_ee;
384			int fullunpack;
385
386
387			TTree *pizTree;
388
389
390			TTree *etaTree;
391
392			float mpair_3x3;
393			int nxtClus1;
394			float eXtalClus1[25];
395			int ietaXtalClus1[25];
396			int iphiXtalClus1[25];
397			float tXtalClus1[25];
398			int fXtalClus1[25];
399			int nxtClus2;
400			float eXtalClus2[25];
401			int ietaXtalClus2[25];
402			int iphiXtalClus2[25];
403			float tXtalClus2[25];
404			int fXtalClus2[25];
405			int savePizTree;
406
407
408			int passBSC40or41;
409			int passBSC34;
410			int passHF;
411			int passBeamScrape;
412			int passVtx;
413			int passBeamHalo;
414			int passBSC0;
415			int passHighHitPxl;
416			int rmOverlap;
417			float mpairv1;
418			float phipair;
419			float geninfo[6];
420			int start_entry;
421			int end_entry;
422			int calibMethod;
423			int applyCorrEta;
424			int applyCorrPhi;
425			int applyCorrDead;
426
427
428			double corrfactorEta[170];
429			double corrfactorEtatb[170];
430			double corrfactorEtaco[170];
431			double corrfactorPhi[360];
432			double corrfactoriEtaiPhi[170][360];
433
434			///pre-calib ( all 1) or phi-sym or BS
435			double preCalibiEtaiPhi[170][360];
436
437
438			int iterStep;
439
440			int cutset;
441			int evtRange;
442			int flagiEtaiPhi[170][360];
443			int usePreCalib;
444			int useVtx;
445			float randGausiEtaiPhi[170][360];
446
447			const int kEndcEtaRings = 39;
448			float eta_ring_ee[kEndcEtaRings];
449			float etaBoundary_ee[kEndcEtaRings+1];
450			int nxtal_ring_ee[kEndcEtaRings];
451			float eta_ring_eezside[2][kEndcEtaRings];
452			float etaBoundary_eezside[2][kEndcEtaRings+1];
453
454
455			///calibration constant fro endcap
456			double corrfactorEtaRings[2][kEndcEtaRings];
457			double corrfactoriZiXiY[2][101][101];
458
459			int izXtalClus1[25];
460			int izXtalClus2[25];
461
462			double corrfactorSM[36];
463			int applyCorrSM;
464			TChain *fChainAlca;
465
466			double corrfactorSM_final[36];
467
468
469
470			float Cpi0Corrv1[170][360];
471			float Cpi0v1[170][360];
472
473			float Ccombv1[170][360];
474			float CcombCorrv1[170][360];
475
476			float Cphi[170][360];
477			float CBS[170][360];
478
479			float CphiCorr[170][360];
480			float CBSCorr[170][360];
481			int flag_ietaiphi[170][360];
482			int ndead_ietaiphi[170][360];
483			int ndeadcorner_ietaiphi[170][360];
484			int ndeadside_ietaiphi[170][360];
485			int ndeadflag_ietaiphi[170][360];
486			double corrfactorDead[20] ;
487			int evtNotUsed;
488
489			///some correction to crystals
490			double preCorrectionIetaIphi[170][360];
491			double corrfactorIetaSM[38][85];
492			double corrfactorPhiSide[2][360];
493			int validRecHitEndCap[2][101][101];
494			int flag_endcap[2][101][101];
495			int ndeadcorner_endcap[2][101][101];
496			int ndeadside_endcap[2][101][101];
497			int ndeadflag_endcap[2][101][101];