32eb1070c92f1736a8c15fe1deffd84a23ff0f55
[u/mrichter/AliRoot.git] / PWG1 / TRD / info / AliTRDtrackInfo.cxx
1 /**************************************************************************
2 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3 *                                                                        *
4 * Author: The ALICE Off-line Project.                                    *
5 * Contributors are mentioned in the code where appropriate.              *
6 *                                                                        *
7 * Permission to use, copy, modify and distribute this software and its   *
8 * documentation strictly for non-commercial purposes is hereby granted   *
9 * without fee, provided that the above copyright notice appears in all   *
10 * copies and that both the copyright notice and this permission notice   *
11 * appear in the supporting documentation. The authors make no claims     *
12 * about the suitability of this software for any purpose. It is          *
13 * provided "as is" without express or implied warranty.                  *
14 **************************************************************************/
15
16 /* $Id: AliTRDtrackInfo.cxx 27496 2008-07-22 08:35:45Z cblume $ */
17
18 ////////////////////////////////////////////////////////////////////////////
19 //                                                                        //
20 //  Reconstruction QA                                                     //
21 //                                                                        //
22 //  Authors:                                                              //
23 //    Alex Bercuci <A.Bercuci@gsi.de>                                     //
24 //    Markus Fasel <M.Fasel@gsi.de>                                       //
25 //                                                                        //
26 ////////////////////////////////////////////////////////////////////////////
27
28 #include "TDatabasePDG.h"
29 #include "TPDGCode.h"
30 #include "TVectorT.h"
31
32 #include "AliTrackReference.h"
33 #include "AliExternalTrackParam.h"
34
35 #include "AliTRDseedV1.h"
36 #include "AliTRDtrackV1.h"
37 #include "AliTRDgeometry.h"
38 #include "AliTRDtrackerV1.h"
39
40 #include "AliTRDtrackInfo.h"
41
42 ClassImp(AliTRDtrackInfo)
43 ClassImp(AliTRDtrackInfo::AliMCinfo)
44 ClassImp(AliTRDtrackInfo::AliESDinfo)
45 Double_t AliTRDtrackInfo::AliMCinfo::fgKalmanStep = 2.;
46 Bool_t AliTRDtrackInfo::AliMCinfo::fgKalmanUpdate = kTRUE;
47
48 //___________________________________________________
49 AliTRDtrackInfo::AliTRDtrackInfo():
50   TObject()
51   ,fNClusters(0)
52   ,fTRDtrack(NULL)
53   ,fMC(NULL)
54   ,fESD()
55 {
56   //
57   // Default constructor
58   //
59 }
60
61
62 //___________________________________________________
63 AliTRDtrackInfo::AliTRDtrackInfo(const AliTRDtrackInfo &trdInfo):
64   TObject((const TObject&)trdInfo)  
65   ,fNClusters(trdInfo.fNClusters)
66   ,fTRDtrack(NULL)
67   ,fMC(NULL)
68   ,fESD(trdInfo.fESD)
69 {
70   //
71   // copy Entries
72   //
73
74   if(trdInfo.fMC) fMC = new AliMCinfo(*trdInfo.fMC);
75
76   if(trdInfo.fTRDtrack){ 
77     fTRDtrack = new AliTRDtrackV1(*trdInfo.fTRDtrack);
78     if(trdInfo.fTRDtrack->IsOwner()) fTRDtrack->SetOwner();
79   }
80 }
81
82 //___________________________________________________
83 AliTRDtrackInfo::AliMCinfo::AliMCinfo()
84   :fLabel(0)
85   ,fPDG(0)
86   ,fNTrackRefs(0)
87 {
88   // Set 0-Pointers
89   memset(fTrackRefs, 0, sizeof(AliTrackReference *) * 12);
90 }
91
92 //___________________________________________________
93 AliTRDtrackInfo::AliMCinfo::AliMCinfo(const AliMCinfo &mc)
94   :fLabel(mc.fLabel)
95   ,fPDG(mc.fPDG)
96   ,fNTrackRefs(mc.fNTrackRefs)
97 {
98   //
99   // Constructor
100   //
101
102   memset(fTrackRefs, 0, sizeof(AliTrackReference *) * 12);
103   for(Int_t ien = 0; ien < 12; ien++){
104     if(mc.fTrackRefs[ien])
105       fTrackRefs[ien] = new AliTrackReference(*(mc.fTrackRefs[ien]));
106   }
107 }
108
109 //________________________________________________________
110 Int_t AliTRDtrackInfo::AliMCinfo::GetPID() const
111 {
112 // Translate pdg code to PID index
113
114   switch(fPDG){
115   case kElectron: 
116   case kPositron: return AliPID::kElectron;  
117   case kMuonPlus:
118   case kMuonMinus: return AliPID::kMuon;  
119   case kPiPlus: 
120   case kPiMinus: return AliPID::kPion;  
121   case kKPlus: 
122   case kKMinus: return AliPID::kKaon;
123   case kProton: 
124   case kProtonBar: return AliPID::kProton;
125   } 
126   return -1;
127 }
128
129 //___________________________________________________
130 AliTRDtrackInfo::AliESDinfo::AliESDinfo()
131   :fHasV0(0)
132   ,fId(-1)
133   ,fStatus(0)
134   ,fKinkIndex(0)
135   ,fTPCncls(0)
136   ,fTOFbc(0)
137   ,fTRDpidQuality(0)
138   ,fTRDnSlices(0)
139   ,fTRDslices(NULL)
140   ,fOP(NULL)
141   ,fTPCout(NULL)
142 {
143   //
144   // Constructor
145   //
146
147   memset(fTRDr, 0, AliPID::kSPECIES*sizeof(Double32_t));
148   memset(fTRDv0pid, 0, AliPID::kSPECIES*sizeof(Int_t));
149 }
150
151 //___________________________________________________
152 AliTRDtrackInfo::AliESDinfo::AliESDinfo(const AliESDinfo &esd)
153   :fHasV0(esd.fHasV0)
154   ,fId(esd.fId)
155   ,fStatus(esd.fStatus)
156   ,fKinkIndex(esd.fKinkIndex)
157   ,fTPCncls(esd.fTPCncls)
158   ,fTOFbc(esd.fTOFbc)
159   ,fTRDpidQuality(esd.fTRDpidQuality)
160   ,fTRDnSlices(esd.fTRDnSlices)
161   ,fTRDslices(NULL)
162   ,fOP(NULL)
163   ,fTPCout(NULL)
164 {
165   //
166   // Constructor
167   //
168
169   memcpy(fTRDr, esd.fTRDr, AliPID::kSPECIES*sizeof(Double32_t));
170   memcpy(fTRDv0pid, esd.fTRDv0pid, AliPID::kSPECIES*sizeof(Int_t));
171
172   if(fTRDnSlices){
173     fTRDslices = new Double32_t[fTRDnSlices];
174     memcpy(fTRDslices, esd.fTRDslices, fTRDnSlices*sizeof(Double32_t));
175   }
176   if(esd.fOP) fOP = new AliExternalTrackParam(*esd.fOP);
177   if(esd.fTPCout) fTPCout = new AliExternalTrackParam(*esd.fTPCout);
178 }
179
180
181 //___________________________________________________
182 AliTRDtrackInfo::~AliTRDtrackInfo()
183 {
184   //
185   // Destructor
186   //
187
188   if(fMC) delete fMC;
189   if(fTRDtrack) delete fTRDtrack;
190 }
191
192 //___________________________________________________
193 AliTRDtrackInfo::AliMCinfo::~AliMCinfo()
194 {
195   //
196   // Destructor
197   //
198
199   fNTrackRefs = 0;
200   for(Int_t ien = 0; ien < 12; ien++){
201     if(fTrackRefs[ien]) delete fTrackRefs[ien];
202     fTrackRefs[ien] = NULL;
203   }
204 }
205
206 //___________________________________________________
207 AliTRDtrackInfo::AliESDinfo::~AliESDinfo()
208 {
209   //
210   // Destructor
211   //
212
213   if(fTRDnSlices){
214     delete [] fTRDslices;
215     fTRDslices = NULL;
216     fTRDnSlices = 0;
217   }
218   if(fOP) delete fOP; fOP = NULL;
219   if(fTPCout) delete fTPCout; fTPCout = NULL;
220 }
221
222 //___________________________________________________
223 void AliTRDtrackInfo::AliESDinfo::Delete(const Option_t *){
224   //
225   // Delete Pointer members 
226   // 
227   if(fTRDnSlices){
228     delete [] fTRDslices;
229     fTRDslices = NULL;
230     fTRDnSlices = 0;
231   }
232   if(fOP) delete fOP; fOP = NULL;
233   if(fTPCout) delete fTPCout; fTPCout = NULL;
234 }
235
236
237 //___________________________________________________
238 AliTRDtrackInfo& AliTRDtrackInfo::operator=(const AliTRDtrackInfo &trdInfo)
239 {
240   //
241   // = Operator
242   //
243   if(this == &trdInfo) return *this;
244
245   fNClusters  = trdInfo.fNClusters;
246   fESD        = trdInfo.fESD;
247
248   if(trdInfo.fMC){
249     if(!fMC) fMC = new AliMCinfo(*trdInfo.fMC);
250     else{
251       fMC->~AliMCinfo();
252       new(fMC) AliMCinfo(*trdInfo.fMC);
253     }
254   } else {if(fMC) delete fMC; fMC = NULL;}
255
256   if(trdInfo.fTRDtrack){
257     if(!fTRDtrack) fTRDtrack = new AliTRDtrackV1(*trdInfo.fTRDtrack);
258     else{
259       fTRDtrack->~AliTRDtrackV1();
260       new(fTRDtrack) AliTRDtrackV1(*trdInfo.fTRDtrack);
261     }
262     if(trdInfo.fTRDtrack->IsOwner()) fTRDtrack->SetOwner();
263   } else {if(fTRDtrack) delete fTRDtrack; fTRDtrack = NULL;}
264
265   return *this;
266 }
267
268 //___________________________________________________
269 AliTRDtrackInfo::AliMCinfo& AliTRDtrackInfo::AliMCinfo::operator=(const AliMCinfo &mc)
270 {
271   //
272   // Assignment operator
273   //
274
275   if(this == &mc) return *this;
276   fLabel      = mc.fLabel;
277   fPDG        = mc.fPDG;
278   fNTrackRefs = mc.fNTrackRefs;
279
280   AliTrackReference **itr = &fTrackRefs[0];
281   AliTrackReference* const *jtr = &mc.fTrackRefs[0];
282   for(Int_t ien = 0; ien < 12; ien++, itr++, jtr++){
283     if((*jtr)){
284       if(!(*itr)) (*itr) = new AliTrackReference(*(*jtr));
285       else{
286         (*itr)->~AliTrackReference();
287         new(&(*itr)) AliTrackReference(*(*jtr));
288       }
289     } else {if((*itr)) delete (*itr); (*itr) = NULL;}
290   }
291   return *this;
292 }
293
294 //___________________________________________________
295 AliTRDtrackInfo::AliESDinfo& AliTRDtrackInfo::AliESDinfo::operator=(const AliESDinfo &esd)
296 {
297   //
298   // Assignment operator
299   //
300
301   if(this == &esd) return *this;
302   fHasV0       = esd.fHasV0;
303   fId          = esd.fId;
304   fStatus      = esd.fStatus;
305   fKinkIndex   = esd.fKinkIndex;
306   fTPCncls     = esd.fTPCncls;
307   fTOFbc       = esd.fTOFbc;
308   fTRDpidQuality= esd.fTRDpidQuality;
309   fTRDnSlices  = esd.fTRDnSlices;
310   fTRDslices   = NULL;
311
312   memcpy(fTRDr, esd.fTRDr, AliPID::kSPECIES*sizeof(Double32_t));
313   memcpy(fTRDv0pid, esd.fTRDv0pid, AliPID::kSPECIES*sizeof(Int_t));
314
315   if(fTRDnSlices){
316     fTRDslices = new Double32_t[fTRDnSlices];
317     memcpy(fTRDslices, esd.fTRDslices, fTRDnSlices*sizeof(Double32_t));
318   }
319   if(esd.fOP){
320     if(fOP){
321       fOP->~AliExternalTrackParam();
322       // RS: Constructor from VTrack was used instead of Constructor from AliExternalTrackParam
323       new(fOP) AliExternalTrackParam(*esd.fOP);
324     } else fOP = new AliExternalTrackParam(*esd.fOP);
325   } else {if(fOP) delete fOP; fOP = NULL;}
326   if(esd.fTPCout){
327     if(fTPCout){
328       fTPCout->~AliExternalTrackParam();
329       // RS: Constructor from VTrack was used instead of Constructor from AliExternalTrackParam
330       new(fTPCout) AliExternalTrackParam(*esd.fTPCout);
331     } else fTPCout = new AliExternalTrackParam(*esd.fTPCout);
332   } else { if(fTPCout) delete fTPCout; fTPCout = NULL;}
333
334   return *this;
335 }
336
337 //___________________________________________________
338 void AliTRDtrackInfo::Delete(const Option_t *)
339 {
340   //
341   // Delete
342   //
343
344   AliDebug(2, Form("track[%p] mc[%p]", (void*)fTRDtrack, (void*)fMC));
345   fNClusters  = 0;
346   if(fMC) delete fMC; fMC = NULL;
347   fESD.Delete(NULL);
348   if(fTRDtrack) delete fTRDtrack; fTRDtrack = NULL;
349 }
350
351 //___________________________________________________
352 void AliTRDtrackInfo::SetTrack(const AliTRDtrackV1 *track)
353 {
354   //
355   // Set the TRD track
356   //
357
358   if(!fTRDtrack) fTRDtrack = new AliTRDtrackV1(*track);
359   else{
360     fTRDtrack->~AliTRDtrackV1();
361     new(fTRDtrack) AliTRDtrackV1(*track);
362   }
363   fTRDtrack->SetOwner();
364   // Make a copy for the object in order to avoid ownership problems
365 }
366
367 //___________________________________________________
368 void AliTRDtrackInfo::AddTrackRef(const AliTrackReference *tref)
369 {
370   //
371   // Add track reference
372   //
373
374   if(fMC->fNTrackRefs >= 12){ 
375     SetCurved();
376     return;
377   }
378   // Make a copy for the object in order to avoid ownership problems
379   fMC->fTrackRefs[fMC->fNTrackRefs++] = new AliTrackReference(*tref);
380 }
381
382 //___________________________________________________
383 AliTrackReference* AliTRDtrackInfo::GetTrackRef(Int_t idx) const
384 {
385 //
386 // Returns a track reference
387 //
388   if(!fMC) return NULL;
389   return (idx>=0 && idx < 12) ? fMC->fTrackRefs[idx] : NULL;
390 }
391
392 //___________________________________________________
393 AliTrackReference* AliTRDtrackInfo::GetTrackRef(const AliTRDseedV1* const tracklet) const
394 {
395 //
396 // Returns a track reference
397 //
398   if(!fMC) return NULL;
399   Double_t cw = AliTRDgeometry::CamHght() + AliTRDgeometry::CdrHght();
400   AliTrackReference * const* jtr = &(fMC->fTrackRefs[0]);
401   for(Int_t itr = 0; itr < fMC->fNTrackRefs; itr++, ++jtr){
402     if(!(*jtr)) break;   
403     if(TMath::Abs(tracklet->GetX0() - (*jtr)->LocalX()) < cw) return (*jtr);
404   }
405   return NULL;
406 }
407
408 //___________________________________________________
409 Int_t AliTRDtrackInfo::GetNumberOfClusters() const
410 {
411   //
412   // Returns the number of clusters
413   //
414
415   Int_t n = 0;
416   if(!fTRDtrack) return 0;
417   if(fTRDtrack->GetNumberOfTracklets() == 0) return n;
418   AliTRDseedV1 *tracklet = NULL;
419   for(Int_t ip=0; ip<6; ip++){
420     if(!(tracklet = const_cast<AliTRDseedV1 *>(fTRDtrack->GetTracklet(ip)))) continue;
421     n+=tracklet->GetN();
422   }
423   return n;
424 }
425
426
427 //___________________________________________________
428 void  AliTRDtrackInfo::SetOuterParam(const AliExternalTrackParam *op)
429 {
430   //
431   // Set outer track parameters
432   //
433
434   if(!op) return;
435   if(fESD.fOP){
436     fESD.fOP->~AliExternalTrackParam();
437     new(fESD.fOP) AliExternalTrackParam(*op);
438   } else fESD.fOP = new AliExternalTrackParam(*op);
439 }
440
441 //___________________________________________________
442 void  AliTRDtrackInfo::SetTPCoutParam(const AliExternalTrackParam *op)
443 {
444   //
445   // Set TPCout track parameters
446   //
447
448   if(!op) return;
449   if(fESD.fTPCout){
450     fESD.fTPCout->~AliExternalTrackParam();
451     new(fESD.fTPCout) AliExternalTrackParam(*op);
452   } else fESD.fTPCout = new AliExternalTrackParam(*op);
453 }
454
455 //___________________________________________________
456 Int_t AliTRDtrackInfo::GetNTracklets() const
457 {
458   //
459   // Return the number of tracklets
460   //
461
462   if(!fTRDtrack) return 0;
463   return fTRDtrack->GetNumberOfTracklets();
464 }
465
466 //___________________________________________________
467 void AliTRDtrackInfo::SetSlices(Int_t n, Double32_t *s)
468 {
469   //
470   // Set the slices
471   //
472   if(fESD.fTRDnSlices != n){
473     fESD.fTRDnSlices = 0;
474     delete [] fESD.fTRDslices;
475     fESD.fTRDslices = NULL;
476   }
477
478   if(!fESD.fTRDnSlices){
479     fESD.fTRDnSlices = n;
480     fESD.fTRDslices = new Double32_t[fESD.fTRDnSlices];
481   }
482
483   memcpy(fESD.fTRDslices, s, n*sizeof(Double32_t));
484 }
485  
486 //___________________________________________________
487 Bool_t AliTRDtrackInfo::AliMCinfo::GetDirections(Float_t &x0, Float_t &y0, Float_t &z0, Float_t &dydx, Float_t &dzdx, Float_t &pt, Float_t &eta, Float_t &phi, UChar_t &status) const
488 {
489 // Check for 2 track ref for the tracklet defined bythe radial position x0
490 // The "status" is a bit map and gives a more informative output in case of failure:
491 //   - 0 : everything is OK
492 //   - BIT(0) : 0 track refs found
493 //   - BIT(1) : 1 track reference found
494 //   - BIT(2) : dx <= 0 between track references
495 //   - BIT(3) : dx > 0 && dx < 3.7 - tangent tracks 
496
497   status = 0;
498   Double_t cw = AliTRDgeometry::CamHght() + AliTRDgeometry::CdrHght();
499   Int_t nFound = 0;
500   AliTrackReference *tr[2] = {NULL, NULL};
501   AliTrackReference * const* jtr = &fTrackRefs[0];
502   for(Int_t itr = 0; itr < fNTrackRefs; itr++, ++jtr){
503     if(!(*jtr)) break;
504 /*
505     if(fDebugLevel>=5) printf("\t\tref[%2d] x[%6.3f]\n", itr, (*jtr)->LocalX());*/
506     if(TMath::Abs(x0 - (*jtr)->LocalX()) > cw) continue;
507     tr[nFound++] = (*jtr);
508     if(nFound == 2) break;
509   } 
510   if(nFound < 2){ 
511     AliDebugGeneral("AliTRDtrackInfo::AliMCinfo::GetDirections()", 1, Form("Missing track ref x0[%6.3f] nref[%d]", x0, nFound));
512     if(!nFound) SETBIT(status, 0);
513     else SETBIT(status, 1);
514     return kFALSE;
515   }
516   pt=tr[1]->Pt();
517   if(pt < 1.e-3) return kFALSE;
518
519   Double_t dx = tr[1]->LocalX() - tr[0]->LocalX();
520   if(dx <= 0.){
521     AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::GetDirections()", Form("Track ref with wrong radial distances refX0[%6.3f] refX1[%6.3f]", tr[0]->LocalX(), tr[1]->LocalX()));
522     SETBIT(status, 2);
523     return kFALSE;
524   }
525   if(TMath::Abs(dx-AliTRDgeometry::CamHght()-AliTRDgeometry::CdrHght())>1.E-3) SETBIT(status, 3); 
526
527   dydx = (tr[1]->LocalY() - tr[0]->LocalY()) / dx;
528   dzdx = (tr[1]->Z() - tr[0]->Z()) / dx;
529   //Float_t dx0 = tr[1]->LocalX() - x0;
530   y0   =  tr[1]->LocalY()/* - dydx*dx0*/;
531   z0   =  tr[1]->Z()/* - dzdx*dx0*/;
532   x0   =  tr[1]->LocalX();
533   eta  =  -TMath::Log(TMath::Tan(0.5 * tr[1]->Theta()));
534   phi  =  TMath::ATan2(tr[1]->Y(), tr[1]->X());
535   return kTRUE;
536 }
537
538 //___________________________________________________
539 Bool_t AliTRDtrackInfo::AliMCinfo::PropagateKalman(
540       TVectorD *x, TVectorD *y, TVectorD *z,
541       TVectorD *dx, TVectorD *dy, TVectorD *dz,
542       TVectorD *pt, TVectorD *dpt, TVectorD *budget, TVectorD *c, Double_t mass) const
543 {
544 // Propagate Kalman from the first TRD track reference to 
545 // last one and save residuals in the y, z and pt.
546 // 
547 // This is to calibrate the dEdx and MS corrections
548
549   if(!fNTrackRefs) return kFALSE;
550   for(Int_t itr=kNTrackRefs; itr--;){
551     (*x)[itr] = 0.;(*y)[itr] = 0.;(*z)[itr] = 0.;
552     (*dx)[itr] = -1.; (*dy)[itr] = 100.; (*dz)[itr] = 100.; (*dpt)[itr] = 100.;
553   }
554
555   // Initialize TRD track to the first track reference
556   AliTrackReference *tr(NULL);
557   Int_t itr(0); while(!(tr = fTrackRefs[itr])) itr++;
558   if(tr->Pt()<1.e-3) return kFALSE;
559
560   AliTRDtrackV1 tt;
561   Double_t xyz[3]={tr->X(),tr->Y(),tr->Z()};
562   Double_t pxyz[3]={tr->Px(),tr->Py(),tr->Pz()};
563   Double_t var[6] = {1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4, 1.e-4};
564   Double_t cov[21]={
565     var[0],  0.,  0.,  0.,  0.,  0.,
566          var[1],  0.,  0.,  0.,  0.,
567               var[2],  0.,  0.,  0.,
568                    var[3],  0.,  0.,
569                         var[4],  0.,
570                              var[5]
571   };
572   TDatabasePDG db;
573   const TParticlePDG *pdg=db.GetParticle(fPDG);
574   if(!pdg){
575     AliWarningGeneral("AliTRDtrackInfo::AliMCinfo::PropagateKalman()", Form("PDG entry missing for code %d. References for track %d", fPDG, fNTrackRefs));
576     return kFALSE;
577   }
578   tt.Set(xyz, pxyz, cov, Short_t(pdg->Charge()));
579   if(mass<0){ // mass 0 use PDG
580     tt.SetMass(pdg->Mass());
581   } else { // use rec value
582     tt.SetMass(mass);
583   }
584
585 //  Double_t bg(tr->P()/pdg->Mass());
586 //  printf("\n\nNEW track PDG[%d] bg[%f] x[%f]\n", fPDG, bg, TMath::Log(bg));
587   Double_t x0(tr->LocalX());
588   const Double_t *cc(NULL);
589   for(Int_t ip=0; itr<fNTrackRefs; itr++){
590     if(!(tr = fTrackRefs[itr])) continue;
591 //    printf("ip[%d] det[%d]\n", ip, tr->DetectorId());
592     if(!AliTRDtrackerV1::PropagateToX(tt, tr->LocalX(), fgKalmanStep)) continue;
593
594     //if(update) ...
595     tt.GetXYZ(xyz);
596     (*x)[ip]   = xyz[0];
597     (*y)[ip]   = xyz[1];
598     (*z)[ip]   = xyz[2];
599     (*dx)[ip]  = tt.GetX() - x0;
600     (*dy)[ip]  = tt.GetY() - tr->LocalY();
601     (*dz)[ip]  = tt.GetZ() - tr->Z();
602     (*pt)[ip]  = tr->Pt();
603     (*dpt)[ip] = tt.Pt()- tr->Pt();
604 //    printf("pt : kalman[%e] MC[%e]\n", tt.Pt(), tr->Pt());
605     (*budget)[ip] = tt.GetBudget(0);
606     cc = tt.GetCovariance();
607 //    printf("dx[%5.2f] sy[%f]\n", (*dx)[ip], TMath::Sqrt(cc[0]));
608     for(Int_t ic(0), jp(ip*15); ic<15; ic++, jp++) (*c)[jp]=cc[ic];
609     ip++;
610   }
611   return kTRUE;
612 }