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() {
  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

/**
 * Clear the CaloLevel2 object
 **/
void CaloLevel2::Clear() {    
  //
//  CaloTrk->Clear(); //ELENA
  if(CaloTrk)CaloTrk->Delete(); //ELENA
  //
  nstrip = 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() {     //ELENA
  if(CaloTrk){ //ELENA
      CaloTrk->Delete(); //ELENA
      delete CaloTrk; //ELENA
  }     //ELENA
} //ELENA

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