CalorimeterLevel2/src/CaloLevel2.cpp

/**
 * \file src/CaloLevel2.cpp
 * \author Emiliano Mocchiutti
 *
**/
#include <TObject.h>
#include <CaloLevel2.h>

//
ClassImp(CaloTrkVar);
ClassImp(CaloLevel2);

/**
 * CaloTrkVar constructor
**/
CaloTrkVar::CaloTrkVar() {
  this->Clear();
}

/**
 * Clear variables
**/
void CaloTrkVar::Clear(Option_t *t) {
  //void CaloTrkVar::Clear() {
  trkseqno = 0;
  noint = 0;
  ncore = 0;
  qcore = 0.;
  ncyl = 0;
  qcyl = 0.;
  qtrack = 0.;
  qtrackx = 0.;
  qtracky = 0.;
  dxtrack = 0.;
  dytrack = 0.;
  qlast = 0.;
  nlast = 0;
  qpre = 0.;
  npre = 0;
  qpresh = 0.;
  npresh = 0;
  qtr = 0.;
  ntr = 0;
  planetot = 0;
  qmean = 0.;
  qlow = 0.;
  nlow = 0;
  dX0l = 0.;
  memset(tbar, 0, 2*22*sizeof(Float_t));
  memset(tibar, 0, 2*22*sizeof(Int_t));
}

/**
 * Copies from t to this
**/
CaloTrkVar::CaloTrkVar(const CaloTrkVar &t){
  trkseqno = t.trkseqno;
  noint = t.noint;
  ncore = t.ncore;
  qcore = t.qcore;
  ncyl = t.ncyl;
  qcyl = t.qcyl;
  qtrack = t.qtrack;
  qtrackx = t.qtrackx;
  qtracky = t.qtracky;
  dxtrack = t.dxtrack;
  dytrack = t.dytrack;
  qlast = t.qlast;
  nlast = t.nlast;
  qpre = t.qpre;
  npre = t.npre;
  qpresh = t.qpresh;
  npresh = t.npresh;
  qtr = t.qtr;
  ntr = t.ntr;  
  planetot = t.planetot;
  qmean = t.qmean;
  dX0l = t.dX0l;
  qlow = t.qlow;
  nlow = t.nlow;
  memcpy(tibar,t.tibar,sizeof(tibar));
  memcpy(tbar,t.tbar,sizeof(tbar));
}

/**
 * CaloLevel2 constructor
**/
CaloLevel2::CaloLevel2() {    
  //
//  CaloTrk = new TClonesArray("CaloTrkVar",1); //ELENA
  CaloTrk = 0; //ELENA
  //
  this->Clear();
  //
}
/**
 * Create the TClonesArray
**/
void CaloLevel2::Set(){//ELENA
    if(!CaloTrk)CaloTrk = new TClonesArray("CaloTrkVar",1); //ELENA
}//ELENA
//--------------------------------------
//
//
//--------------------------------------
void CaloLevel2::SetTrackArray(TClonesArray *track){//ELENA
//    if(track && strcmp(track->GetClass()->GetName(),"CaloTrkVar")==0){
    if(track ){
        if(CaloTrk)CaloTrk->Clear("C");
        CaloTrk = track;
    }
}

/**
 * Clear the CaloLevel2 object
 **/
void CaloLevel2::Clear(Option_t *t ) {    
  //
  //  CaloTrk->Clear(); //ELENA
  if(CaloTrk)CaloTrk->Delete(); //ELENA
  //
  nstrip = 0;
  nsatstrip = 0;
  qtot = 0.;
  //  impx = 0.;
  //  impy = 0.;
  qmax = 0.;
  nx22 = 0;
  qx22 = 0.;
  elen = 0.;
  selen = 0.;
  memset(perr, 0, 4*sizeof(Int_t));
  memset(swerr, 0, 4*sizeof(Int_t));
  memset(crc, 0, 4*sizeof(Int_t));
  memset(qq, 0, 4*sizeof(Int_t));
  memset(varcfit, 0, 4*sizeof(Float_t));
  memset(npcfit, 0, 4*sizeof(Int_t));
  memset(tanx, 0, 2*sizeof(Int_t));
  memset(tany, 0, 2*sizeof(Int_t));
  memset(fitmode, 0, 2*sizeof(Int_t));
  memset(planemax, 0, 2*sizeof(Int_t));
  memset(selfdelay, 0, 4*7*sizeof(Int_t));
  memset(cibar, 0, 2*22*sizeof(Int_t));
  memset(cbar, 0, 2*22*sizeof(Float_t));
  good = 0;
  selftrigger = 0;
  //
}

/**
 * Delete the CaloLevel2 object
 **/
void CaloLevel2::Delete(Option_t *t) {     //ELENA
  if(CaloTrk){ //ELENA
      CaloTrk->Delete(); //ELENA
      delete CaloTrk; //ELENA
  }     //ELENA
} //ELENA

/**
 * CaloLevel2 
**/
Bool_t CaloLevel2::IsGood(Bool_t strict) {  
  //
  if ( strict ){
    if ( !good ) return(false);
    if ( perr[0] ) return(false);
    if ( perr[1] ) return(false);
    if ( perr[2] ) return(false);
    if ( perr[3] ) return(false);
    if ( swerr[0] ) return(false);
    if ( swerr[1] ) return(false);
    if ( swerr[2] ) return(false);
    if ( swerr[3] ) return(false);
    if ( crc[0] ) return(false);
    if ( crc[1] ) return(false);
    if ( crc[2] ) return(false);
    if ( crc[3] ) return(false);
  } else {
    if ( perr[0] == 129 ||  perr[0] == 136 || perr[0] == 142 || perr[0] == 143 ) return(false);
    if ( perr[1] == 129 ||  perr[1] == 136 || perr[1] == 142 || perr[1] == 143 ) return(false);
    if ( perr[2] == 129 ||  perr[2] == 136 || perr[2] == 142 || perr[2] == 143 ) return(false);
    if ( perr[3] == 129 ||  perr[3] == 136 || perr[3] == 142 || perr[3] == 143 ) return(false);
  };
  //
  return(true);
}

/**
 * Fills a struct cCaloLevel2 with values from a CaloLevel2 object (to put data into a F77 common).
 */
void CaloLevel2::GetLevel2Struct(cCaloLevel2 *l2) const {
 
  l2->good = good;      
  l2->selftrigger = selftrigger;
  l2->nstrip = nstrip;     
  l2->nx22 = nx22;  
  l2->qtot = qtot;     
  l2->qx22 = qx22;     
  l2->qmax = qmax;     
  //  l2->impx = impx;     
  //  l2->impy = impy;     
  //  l2->tanx = tanx;     
  //  l2->tany = tany;  
  l2->elen = elen;      
  l2->selen = selen; 
        
  for(Int_t i=0;i<2;i++){
    l2->planemax[i] = planemax[i];       
    l2->varcfit[i] = varcfit[i];
    l2->npcfit[i] = npcfit[i];
  }
  for(Int_t i=0;i<4;i++){
    l2->perr[i] = perr[i];   
    l2->swerr[i] = swerr[i];  
    l2->calcrc[i] = crc[i];     
    l2->qq[i] = qq[i];  
  }

  if(CaloTrk){ //ELENA
      l2->calntrk = CaloTrk->GetEntries();  
      for(Int_t i=0;i<l2->calntrk;i++){
          l2->caltrkseqno[i] = ((CaloTrkVar *)CaloTrk->At(i))->trkseqno;  
          l2->ncore[i] = ((CaloTrkVar *)CaloTrk->At(i))->ncore;     
          l2->noint[i] = ((CaloTrkVar *)CaloTrk->At(i))->noint;     
          l2->ncyl[i] = ((CaloTrkVar *)CaloTrk->At(i))->ncyl;      
          l2->nlast[i] = ((CaloTrkVar *)CaloTrk->At(i))->nlast;     
          l2->npre[i] = ((CaloTrkVar *)CaloTrk->At(i))->npre;      
          l2->npresh[i] = ((CaloTrkVar *)CaloTrk->At(i))->npresh;    
          l2->ntr[i] = ((CaloTrkVar *)CaloTrk->At(i))->ntr;       
          l2->planetot[i] = ((CaloTrkVar *)CaloTrk->At(i))->planetot;  
          l2->nlow[i] = ((CaloTrkVar *)CaloTrk->At(i))->nlow;      
          l2->qcore[i] =((CaloTrkVar *)CaloTrk->At(i))->qcore ;   
          l2->qcyl[i] = ((CaloTrkVar *)CaloTrk->At(i))->qcyl;    
          l2->qlast[i] = ((CaloTrkVar *)CaloTrk->At(i))->qlast;   
          l2->qpre[i] = ((CaloTrkVar *)CaloTrk->At(i))->qpre;    
          l2->qpresh[i] = ((CaloTrkVar *)CaloTrk->At(i))->qpresh;  
          l2->qtr[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtr;     
          l2->qtrack[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtrack;  
          l2->qtrackx[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtrackx; 
          l2->qtracky[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtracky; 
          l2->dxtrack[i] = ((CaloTrkVar *)CaloTrk->At(i))->dxtrack; 
          l2->dytrack[i] = ((CaloTrkVar *)CaloTrk->At(i))->dytrack; 
          l2->qmean[i] = ((CaloTrkVar *)CaloTrk->At(i))->qmean;   
          l2->qlow[i] = ((CaloTrkVar *)CaloTrk->At(i))->qlow;    
          l2->dX0l[i] = ((CaloTrkVar *)CaloTrk->At(i))->dX0l;  
          for (Int_t j=0; j<2; j++){
              for (Int_t k=0; k<22; k++){
                  l2->tbar[i][k][j] = ((CaloTrkVar *)CaloTrk->At(i))->tbar[k][j];
              };
          };
      }  
  } //ELENA
}

/**
 * Returns the impact position on the top of the calorimeter as determined by the calorimeter itself.
 * @param tr : if tr = 0 use the calorimeter "normal" fit, if 1 use the calorimeter "selftrigger" fit (if any!)
**/
Float_t CaloLevel2::impx(Int_t tr){
  if ( tr == 0 ) return(cbar[0][0]);
  if ( tr == 1 ) {
    if ( !CaloTrk ) return(-110.);
    TClonesArray &t = *(CaloTrk);
    for (Int_t itrk=0; itrk<ntrk(); itrk++){
      CaloTrkVar *calotrack = (CaloTrkVar*)t[itrk];
      if ( calotrack->trkseqno == -1 ) return(calotrack->tbar[0][0]);
    };
  };
  if ( tr !=0 && tr !=1 ){
    printf(" Cannot get impx for other than calo or selftrigger tracks!\n");
  } else {
    printf(" Cannot find selftrigger block\n");
  };
  return(-100.);
}

/**
 * Returns the impact position on the top of the calorimeter as determined by the calorimeter itself.
 * @param tr : if tr = 0 use the calorimeter "normal" fit, if 1 use the calorimeter "selftrigger" fit (if any!)
**/
Float_t CaloLevel2::impy(Int_t tr){
  if ( tr == 0 ) return(cbar[0][1]);
  if ( tr == 1 ) {
    if ( !CaloTrk ) return(-110.);
    TClonesArray &t = *(CaloTrk);
    for (Int_t itrk=0; itrk<ntrk(); itrk++){
      CaloTrkVar *calotrack = (CaloTrkVar*)t[itrk];
      if ( calotrack->trkseqno == -1 ) return(calotrack->tbar[0][1]);
    };
  };
  if ( tr !=0 && tr !=1 ){
    printf(" Cannot get impy for other than calo or selftrigger tracks!\n");
  } else {
    printf(" Cannot find selftrigger block\n");
  };
  return(-100.);
}
/**
 * Should return the energy in GeV if the particle would be an electron
 * using a parametrization taken from Monte Carlo simulation
**/
void CaloLevel2::GetElectronEnergy(Float_t &energy, Float_t &sigma){
  if ( nstrip == 0 ) return;
  energy = qtot / 260.;
  //  energy = qtot * 40.82 * 0.000106;
  sigma = 0.;
  if ( energy > 0. ) sigma = energy * (0.01183 + 0.121/sqrt(energy));
  return;
}

/**
 * Returns pointer to the set of track-related variables "itrk"
**/
CaloTrkVar *CaloLevel2::GetCaloTrkVar(Int_t itrk){
  //    
  if(itrk >= ntrk()){
    printf(" CaloLevel2 ERROR: track related variables set %i does not exists! \n",itrk);
    printf("                   stored track related variables = %i \n",ntrk());
    return(NULL);
  }
  if(!CaloTrk)return 0; //ELENA
  TClonesArray &t = *(CaloTrk);
  CaloTrkVar *calotrack = (CaloTrkVar*)t[itrk];
  return calotrack;
}

/**
 * Retrieves the calorimeter track matching the seqno-th tracker stored track. 
 * (If seqno = -1 retrieves the self-trigger calorimeter track)
 */
CaloTrkVar *CaloLevel2::GetCaloStoredTrack(int seqno){

  if( ntrk()==0 ){
    printf("CaloLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo %i but no Calorimeter tracks are stored\n",seqno);
    return NULL;
  };
  
  CaloTrkVar *c = 0;
  Int_t it_calo=0;
     
  do { 
    c = GetCaloTrkVar(it_calo);
    it_calo++; 
  } while( c && seqno != c->trkseqno && it_calo < ntrk());      
  
  if(!c || seqno != c->trkseqno){
    c = 0;
    if(seqno!=-1 && seqno !=-2 && seqno!=-3 ) printf("CaloLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo %i does not match Calorimeter stored tracks\n",seqno);
  };
  return c;
     
}
1	mocchiut	1.1	/**
2			* \file src/CaloLevel2.cpp
3			* \author Emiliano Mocchiutti
4			*
5			**/
6			#include <TObject.h>
7			#include <CaloLevel2.h>
8	mocchiut	1.9
9			//
10	mocchiut	1.1	ClassImp(CaloTrkVar);
11			ClassImp(CaloLevel2);
12
13			/**
14			* CaloTrkVar constructor
15			**/
16			CaloTrkVar::CaloTrkVar() {
17	mocchiut	1.7	this->Clear();
18	mocchiut	1.15	}
19	mocchiut	1.7
20			/**
21			* Clear variables
22			**/
23	mocchiut	1.15	void CaloTrkVar::Clear(Option_t *t) {
24			//void CaloTrkVar::Clear() {
25	mocchiut	1.1	trkseqno = 0;
26			noint = 0;
27			ncore = 0;
28			qcore = 0.;
29			ncyl = 0;
30			qcyl = 0.;
31			qtrack = 0.;
32			qtrackx = 0.;
33			qtracky = 0.;
34			dxtrack = 0.;
35			dytrack = 0.;
36			qlast = 0.;
37			nlast = 0;
38			qpre = 0.;
39			npre = 0;
40			qpresh = 0.;
41			npresh = 0;
42			qtr = 0.;
43			ntr = 0;
44			planetot = 0;
45			qmean = 0.;
46			qlow = 0.;
47			nlow = 0;
48			dX0l = 0.;
49	mocchiut	1.5	memset(tbar, 0, 222sizeof(Float_t));
50			memset(tibar, 0, 222sizeof(Int_t));
51	mocchiut	1.1	}
52
53			/**
54			* Copies from t to this
55			**/
56			CaloTrkVar::CaloTrkVar(const CaloTrkVar &t){
57			trkseqno = t.trkseqno;
58			noint = t.noint;
59			ncore = t.ncore;
60			qcore = t.qcore;
61			ncyl = t.ncyl;
62			qcyl = t.qcyl;
63			qtrack = t.qtrack;
64			qtrackx = t.qtrackx;
65			qtracky = t.qtracky;
66			dxtrack = t.dxtrack;
67			dytrack = t.dytrack;
68			qlast = t.qlast;
69			nlast = t.nlast;
70			qpre = t.qpre;
71			npre = t.npre;
72			qpresh = t.qpresh;
73			npresh = t.npresh;
74			qtr = t.qtr;
75			ntr = t.ntr;
76			planetot = t.planetot;
77			qmean = t.qmean;
78			dX0l = t.dX0l;
79			qlow = t.qlow;
80			nlow = t.nlow;
81			memcpy(tibar,t.tibar,sizeof(tibar));
82			memcpy(tbar,t.tbar,sizeof(tbar));
83			}
84
85			/**
86			* CaloLevel2 constructor
87			**/
88			CaloLevel2::CaloLevel2() {
89			//
90	pam-fi	1.10	// CaloTrk = new TClonesArray("CaloTrkVar",1); //ELENA
91			CaloTrk = 0; //ELENA
92	mocchiut	1.7	//
93			this->Clear();
94	mocchiut	1.1	//
95	mocchiut	1.15	}
96	pam-fi	1.11	/**
97			* Create the TClonesArray
98			**/
99			void CaloLevel2::Set(){//ELENA
100			if(!CaloTrk)CaloTrk = new TClonesArray("CaloTrkVar",1); //ELENA
101			}//ELENA
102	pam-fi	1.20	//--------------------------------------
103			//
104			//
105			//--------------------------------------
106			void CaloLevel2::SetTrackArray(TClonesArray *track){//ELENA
107			// if(track && strcmp(track->GetClass()->GetName(),"CaloTrkVar")==0){
108			if(track ){
109			if(CaloTrk)CaloTrk->Clear("C");
110			CaloTrk = track;
111			}
112			}
113	mocchiut	1.1
114	mocchiut	1.8	/**
115			* Clear the CaloLevel2 object
116			**/
117	mocchiut	1.15	void CaloLevel2::Clear(Option_t *t ) {
118	mocchiut	1.2	//
119	mocchiut	1.15	// CaloTrk->Clear(); //ELENA
120	pam-fi	1.10	if(CaloTrk)CaloTrk->Delete(); //ELENA
121	mocchiut	1.2	//
122			nstrip = 0;
123	mocchiut	1.16	nsatstrip = 0;
124	mocchiut	1.2	qtot = 0.;
125	mocchiut	1.12	// impx = 0.;
126			// impy = 0.;
127	mocchiut	1.2	qmax = 0.;
128			nx22 = 0;
129			qx22 = 0.;
130			elen = 0.;
131			selen = 0.;
132	mocchiut	1.5	memset(perr, 0, 4*sizeof(Int_t));
133			memset(swerr, 0, 4*sizeof(Int_t));
134			memset(crc, 0, 4*sizeof(Int_t));
135			memset(qq, 0, 4*sizeof(Int_t));
136	mocchiut	1.12	memset(varcfit, 0, 4*sizeof(Float_t));
137			memset(npcfit, 0, 4*sizeof(Int_t));
138			memset(tanx, 0, 2*sizeof(Int_t));
139			memset(tany, 0, 2*sizeof(Int_t));
140			memset(fitmode, 0, 2*sizeof(Int_t));
141	mocchiut	1.5	memset(planemax, 0, 2*sizeof(Int_t));
142	mocchiut	1.14	memset(selfdelay, 0, 47sizeof(Int_t));
143	mocchiut	1.5	memset(cibar, 0, 222sizeof(Int_t));
144			memset(cbar, 0, 222sizeof(Float_t));
145	mocchiut	1.2	good = 0;
146			selftrigger = 0;
147	mocchiut	1.9	//
148	mocchiut	1.15	}
149	mocchiut	1.2
150	pam-fi	1.10	/**
151			* Delete the CaloLevel2 object
152			**/
153	mocchiut	1.15	void CaloLevel2::Delete(Option_t *t) { //ELENA
154	pam-fi	1.10	if(CaloTrk){ //ELENA
155			CaloTrk->Delete(); //ELENA
156			delete CaloTrk; //ELENA
157			} //ELENA
158			} //ELENA
159	pam-fi	1.4
160			/**
161	mocchiut	1.18	* CaloLevel2
162			**/
163			Bool_t CaloLevel2::IsGood(Bool_t strict) {
164			//
165			if ( strict ){
166			if ( !good ) return(false);
167	mocchiut	1.19	if ( perr[0] ) return(false);
168			if ( perr[1] ) return(false);
169			if ( perr[2] ) return(false);
170			if ( perr[3] ) return(false);
171			if ( swerr[0] ) return(false);
172			if ( swerr[1] ) return(false);
173			if ( swerr[2] ) return(false);
174			if ( swerr[3] ) return(false);
175			if ( crc[0] ) return(false);
176			if ( crc[1] ) return(false);
177			if ( crc[2] ) return(false);
178			if ( crc[3] ) return(false);
179	mocchiut	1.18	} else {
180			if ( perr[0] == 129 \|\| perr[0] == 136 \|\| perr[0] == 142 \|\| perr[0] == 143 ) return(false);
181			if ( perr[1] == 129 \|\| perr[1] == 136 \|\| perr[1] == 142 \|\| perr[1] == 143 ) return(false);
182			if ( perr[2] == 129 \|\| perr[2] == 136 \|\| perr[2] == 142 \|\| perr[2] == 143 ) return(false);
183			if ( perr[3] == 129 \|\| perr[3] == 136 \|\| perr[3] == 142 \|\| perr[3] == 143 ) return(false);
184			};
185			//
186			return(true);
187			}
188
189			/**
190	pam-fi	1.4	* Fills a struct cCaloLevel2 with values from a CaloLevel2 object (to put data into a F77 common).
191			*/
192			void CaloLevel2::GetLevel2Struct(cCaloLevel2 *l2) const {
193
194			l2->good = good;
195			l2->selftrigger = selftrigger;
196			l2->nstrip = nstrip;
197			l2->nx22 = nx22;
198			l2->qtot = qtot;
199			l2->qx22 = qx22;
200			l2->qmax = qmax;
201	mocchiut	1.12	// l2->impx = impx;
202			// l2->impy = impy;
203			// l2->tanx = tanx;
204			// l2->tany = tany;
205	pam-fi	1.4	l2->elen = elen;
206			l2->selen = selen;
207
208			for(Int_t i=0;i<2;i++){
209			l2->planemax[i] = planemax[i];
210			l2->varcfit[i] = varcfit[i];
211			l2->npcfit[i] = npcfit[i];
212			}
213			for(Int_t i=0;i<4;i++){
214			l2->perr[i] = perr[i];
215			l2->swerr[i] = swerr[i];
216			l2->calcrc[i] = crc[i];
217			l2->qq[i] = qq[i];
218			}
219
220	pam-fi	1.10	if(CaloTrk){ //ELENA
221			l2->calntrk = CaloTrk->GetEntries();
222			for(Int_t i=0;i<l2->calntrk;i++){
223			l2->caltrkseqno[i] = ((CaloTrkVar *)CaloTrk->At(i))->trkseqno;
224			l2->ncore[i] = ((CaloTrkVar *)CaloTrk->At(i))->ncore;
225			l2->noint[i] = ((CaloTrkVar *)CaloTrk->At(i))->noint;
226			l2->ncyl[i] = ((CaloTrkVar *)CaloTrk->At(i))->ncyl;
227			l2->nlast[i] = ((CaloTrkVar *)CaloTrk->At(i))->nlast;
228			l2->npre[i] = ((CaloTrkVar *)CaloTrk->At(i))->npre;
229			l2->npresh[i] = ((CaloTrkVar *)CaloTrk->At(i))->npresh;
230			l2->ntr[i] = ((CaloTrkVar *)CaloTrk->At(i))->ntr;
231			l2->planetot[i] = ((CaloTrkVar *)CaloTrk->At(i))->planetot;
232			l2->nlow[i] = ((CaloTrkVar *)CaloTrk->At(i))->nlow;
233			l2->qcore[i] =((CaloTrkVar *)CaloTrk->At(i))->qcore ;
234			l2->qcyl[i] = ((CaloTrkVar *)CaloTrk->At(i))->qcyl;
235			l2->qlast[i] = ((CaloTrkVar *)CaloTrk->At(i))->qlast;
236			l2->qpre[i] = ((CaloTrkVar *)CaloTrk->At(i))->qpre;
237			l2->qpresh[i] = ((CaloTrkVar *)CaloTrk->At(i))->qpresh;
238			l2->qtr[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtr;
239			l2->qtrack[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtrack;
240			l2->qtrackx[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtrackx;
241			l2->qtracky[i] = ((CaloTrkVar *)CaloTrk->At(i))->qtracky;
242			l2->dxtrack[i] = ((CaloTrkVar *)CaloTrk->At(i))->dxtrack;
243			l2->dytrack[i] = ((CaloTrkVar *)CaloTrk->At(i))->dytrack;
244			l2->qmean[i] = ((CaloTrkVar *)CaloTrk->At(i))->qmean;
245			l2->qlow[i] = ((CaloTrkVar *)CaloTrk->At(i))->qlow;
246			l2->dX0l[i] = ((CaloTrkVar *)CaloTrk->At(i))->dX0l;
247			for (Int_t j=0; j<2; j++){
248			for (Int_t k=0; k<22; k++){
249			l2->tbar[i][k][j] = ((CaloTrkVar *)CaloTrk->At(i))->tbar[k][j];
250			};
251			};
252			}
253			} //ELENA
254	pam-fi	1.4	}
255
256	mocchiut	1.1	/**
257	mocchiut	1.12	* Returns the impact position on the top of the calorimeter as determined by the calorimeter itself.
258			* @param tr : if tr = 0 use the calorimeter "normal" fit, if 1 use the calorimeter "selftrigger" fit (if any!)
259			**/
260			Float_t CaloLevel2::impx(Int_t tr){
261			if ( tr == 0 ) return(cbar[0][0]);
262			if ( tr == 1 ) {
263			if ( !CaloTrk ) return(-110.);
264			TClonesArray &t = *(CaloTrk);
265			for (Int_t itrk=0; itrk<ntrk(); itrk++){
266			CaloTrkVar calotrack = (CaloTrkVar)t[itrk];
267			if ( calotrack->trkseqno == -1 ) return(calotrack->tbar[0][0]);
268			};
269			};
270			if ( tr !=0 && tr !=1 ){
271			printf(" Cannot get impx for other than calo or selftrigger tracks!\n");
272			} else {
273			printf(" Cannot find selftrigger block\n");
274			};
275			return(-100.);
276	mocchiut	1.15	}
277	mocchiut	1.12
278			/**
279			* Returns the impact position on the top of the calorimeter as determined by the calorimeter itself.
280			* @param tr : if tr = 0 use the calorimeter "normal" fit, if 1 use the calorimeter "selftrigger" fit (if any!)
281			**/
282			Float_t CaloLevel2::impy(Int_t tr){
283			if ( tr == 0 ) return(cbar[0][1]);
284			if ( tr == 1 ) {
285			if ( !CaloTrk ) return(-110.);
286			TClonesArray &t = *(CaloTrk);
287			for (Int_t itrk=0; itrk<ntrk(); itrk++){
288			CaloTrkVar calotrack = (CaloTrkVar)t[itrk];
289			if ( calotrack->trkseqno == -1 ) return(calotrack->tbar[0][1]);
290			};
291			};
292			if ( tr !=0 && tr !=1 ){
293			printf(" Cannot get impy for other than calo or selftrigger tracks!\n");
294			} else {
295			printf(" Cannot find selftrigger block\n");
296			};
297			return(-100.);
298	mocchiut	1.15	}
299	mocchiut	1.12	/**
300	mocchiut	1.8	* Should return the energy in GeV if the particle would be an electron
301			* using a parametrization taken from Monte Carlo simulation
302			**/
303	mocchiut	1.1	void CaloLevel2::GetElectronEnergy(Float_t &energy, Float_t &sigma){
304			if ( nstrip == 0 ) return;
305	mocchiut	1.17	energy = qtot / 260.;
306	mocchiut	1.16	// energy = qtot * 40.82 * 0.000106;
307	mocchiut	1.1	sigma = 0.;
308			if ( energy > 0. ) sigma = energy * (0.01183 + 0.121/sqrt(energy));
309			return;
310	mocchiut	1.15	}
311	mocchiut	1.1
312			/**
313			* Returns pointer to the set of track-related variables "itrk"
314			**/
315			CaloTrkVar *CaloLevel2::GetCaloTrkVar(Int_t itrk){
316			//
317			if(itrk >= ntrk()){
318			printf(" CaloLevel2 ERROR: track related variables set %i does not exists! \n",itrk);
319			printf(" stored track related variables = %i \n",ntrk());
320			return(NULL);
321			}
322	pam-fi	1.10	if(!CaloTrk)return 0; //ELENA
323	mocchiut	1.1	TClonesArray &t = *(CaloTrk);
324			CaloTrkVar calotrack = (CaloTrkVar)t[itrk];
325			return calotrack;
326			}
327	mocchiut	1.13
328			/**
329			* Retrieves the calorimeter track matching the seqno-th tracker stored track.
330			* (If seqno = -1 retrieves the self-trigger calorimeter track)
331			*/
332			CaloTrkVar *CaloLevel2::GetCaloStoredTrack(int seqno){
333
334			if( ntrk()==0 ){
335			printf("CaloLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo %i but no Calorimeter tracks are stored\n",seqno);
336			return NULL;
337			};
338
339			CaloTrkVar *c = 0;
340			Int_t it_calo=0;
341
342			do {
343			c = GetCaloTrkVar(it_calo);
344			it_calo++;
345			} while( c && seqno != c->trkseqno && it_calo < ntrk());
346
347			if(!c \|\| seqno != c->trkseqno){
348			c = 0;
349			if(seqno!=-1 && seqno !=-2 && seqno!=-3 ) printf("CaloLevel2::GetCaloStoredTrack(int) : requested tracker SeqNo %i does not match Calorimeter stored tracks\n",seqno);
350			};
351			return c;
352
353	mocchiut	1.15	}