1 ////////////////////////////////////////////////
2 // Manager and hits classes for set:MUON //
3 ////////////////////////////////////////////////
10 #include <TObjArray.h>
16 #include "AliCallf77.h"
18 // Static variables for the pad-hit iterator routines
19 static Int_t sMaxIterPad=0;
20 static Int_t sCurIterPad=0;
24 //___________________________________________
36 //___________________________________________
37 AliMUON::AliMUON(const char *name, const char *title)
38 : AliDetector(name,title)
42 <img src="picts/alimuon.gif">
46 fHits = new TClonesArray("AliMUONhit",1000 );
47 fClusters = new TClonesArray("AliMUONcluster",10000);
51 fNdch = new Int_t[11];
53 fDchambers = new TObjArray(11);
57 for (i=0; i<11 ;i++) {
58 (*fDchambers)[i] = new TClonesArray("AliMUONdigit",10000);
62 fRecClusters=new TObjArray(20);
64 (*fRecClusters)[i] = new TObjArray(1000);
67 // Transport angular cut
75 //___________________________________________
81 // for (Int_t i=0;i<10;i++) {
82 // delete (*fDchambers)[i];
86 for (Int_t i=0;i<20;i++)
87 delete (*fRecClusters)[i];
92 //___________________________________________
93 void AliMUON::AddHit(Int_t track, Int_t *vol, Float_t *hits)
95 TClonesArray &lhits = *fHits;
96 new(lhits[fNhits++]) AliMUONhit(fIshunt,track,vol,hits);
98 //___________________________________________
99 void AliMUON::AddCluster(Int_t *clhits)
101 TClonesArray &lclusters = *fClusters;
102 new(lclusters[fNclusters++]) AliMUONcluster(clhits);
104 //_____________________________________________________________________________
105 void AliMUON::AddDigits(Int_t id, Int_t *tracks, Int_t *charges, Int_t *digits)
108 // Add a MUON digit to the list
111 TClonesArray &ldigits = *((TClonesArray*)(*fDchambers)[id]);
112 new(ldigits[fNdch[id]++]) AliMUONdigit(tracks,charges,digits);
116 //_____________________________________________________________________________
117 void AliMUON::AddRecCluster(Int_t iCh, Int_t iCat, AliMUONRecCluster* Cluster)
120 // Add a MUON reconstructed cluster to the list
122 TObjArray* ClusterList = RecClusters(iCh,iCat);
123 ClusterList->Add(Cluster);
126 //___________________________________________
127 void AliMUON::BuildGeometry()
130 const int kColorMUON = kBlue;
132 Top=gAlice->GetGeometry()->GetNode("alice");
135 const float cz[10] = { 511, 519, 686, 694, 971, 979, 1245, 1253, 1445, 1453};
136 const float acc_min = TMath::Tan( 2*.0174532925199432958);
137 const float acc_max = TMath::Tan(9*.0174532925199432958);
141 rmin = (cz[0]+0.25)*acc_min;
142 rmax = cz[0]*acc_max;
143 new TTUBE("S_MUON1","MUON chamber 1","void",rmin,rmax,0.25);
145 Node = new TNode("MUON1","MUON chamber 1","S_MUON1",0,0,cz[0],"");
146 Node->SetLineColor(kColorMUON);
150 rmin = (cz[1]+0.25)*acc_min;
151 rmax = cz[1]*acc_max;
152 new TTUBE("S_MUON2","MUON chamber 2","void",rmin,rmax,0.25);
154 Node = new TNode("MUON2","MUON chamber 2","S_MUON2",0,0,cz[1],"");
156 Node->SetLineColor(kColorMUON);
159 rmin = (cz[2]+0.25)*acc_min;
160 rmax = cz[2]*acc_max;
161 new TTUBE("S_MUON3","MUON chamber 3","void",rmin,rmax,0.25);
163 Node = new TNode("MUON3","MUON chamber 3","S_MUON3",0,0,cz[2],"");
164 Node->SetLineColor(kColorMUON);
168 rmin = (cz[3]+0.25)*acc_min;
169 rmax = cz[3]*acc_max;
170 new TTUBE("S_MUON4","MUON chamber 4","void",rmin,rmax,0.25);
172 Node = new TNode("MUON4","MUON chamber 4","S_MUON4",0,0,cz[3],"");
173 Node->SetLineColor(kColorMUON);
178 rmax = cz[4]*acc_max;
179 new TTUBE("S_MUON5","MUON chamber 5","void",rmin,rmax,0.25);
181 Node = new TNode("MUON5","MUON chamber 5","S_MUON5",0,0,cz[4],"");
182 Node->SetLineColor(kColorMUON);
187 rmax = cz[5]*acc_max;
188 new TTUBE("S_MUON6","MUON chamber 6","void",rmin,rmax,0.25);
190 Node = new TNode("MUON6","MUON chamber 6","S_MUON6",0,0,cz[5],"");
192 Node->SetLineColor(kColorMUON);
196 rmax = cz[6]*acc_max;
197 new TTUBE("S_MUON7","MUON chamber 7","void",rmin,rmax,0.25);
199 Node = new TNode("MUON7","MUON chamber 7","S_MUON7",0,0,cz[6],"");
200 Node->SetLineColor(kColorMUON);
205 rmax = cz[7]*acc_max;
206 new TTUBE("S_MUON8","MUON chamber 8","void",rmin,rmax,0.25);
208 Node = new TNode("MUON8","MUON chamber 8","S_MUON8",0,0,cz[7],"");
209 Node->SetLineColor(kColorMUON);
214 rmax = cz[8]*acc_max;
215 new TTUBE("S_MUON9","MUON chamber 9","void",rmin,rmax,0.25);
217 Node = new TNode("MUON9","MUON chamber 9","S_MUON9",0,0,cz[8],"");
218 Node->SetLineColor(kColorMUON);
223 rmax = cz[9]*acc_max;
224 new TTUBE("S_MUON10","MUON chamber 10","void",rmin,rmax,0.25);
226 Node = new TNode("MUON10","MUON chamber 10","S_MUON10",0,0,cz[9],"");
227 Node->SetLineColor(kColorMUON);
232 //___________________________________________
233 Int_t AliMUON::DistancetoPrimitive(Int_t , Int_t )
238 //___________________________________________
239 void AliMUON::MakeBranch(Option_t* option)
241 // Create Tree branches for the MUON.
243 const Int_t buffersize = 4000;
245 sprintf(branchname,"%sCluster",GetName());
247 AliDetector::MakeBranch(option);
249 if (fClusters && gAlice->TreeH()) {
250 gAlice->TreeH()->Branch(branchname,&fClusters, buffersize);
251 printf("Making Branch %s for clusters\n",branchname);
254 // one branch for digits per chamber
257 for (i=0; i<10 ;i++) {
258 sprintf(branchname,"%sDigits%d",GetName(),i+1);
260 if (fDchambers && gAlice->TreeD()) {
261 gAlice->TreeD()->Branch(branchname,&((*fDchambers)[i]), buffersize);
262 printf("Making Branch %s for digits in chamber %d\n",branchname,i+1);
265 // one branch for rec clusters
266 for (i=0; i<20; i++) {
267 sprintf(branchname,"%sRecClus%d",GetName(),i+1);
268 if (fRecClusters && gAlice->TreeD()) {
270 ->Branch(branchname,"TObjArray",
271 &((*fRecClusters)[i]), buffersize,0);
272 printf("Making Branch %s for clusters in chamber %d\n",
278 //___________________________________________
279 void AliMUON::SetTreeAddress()
281 // Set branch address for the Hits and Digits Tree.
283 AliDetector::SetTreeAddress();
286 TTree *treeH = gAlice->TreeH();
287 TTree *treeD = gAlice->TreeD();
291 branch = treeH->GetBranch("MUONCluster");
292 if (branch) branch->SetAddress(&fClusters);
297 for (int i=0; i<10; i++) {
298 sprintf(branchname,"%sDigits%d",GetName(),i+1);
300 branch = treeD->GetBranch(branchname);
301 if (branch) branch->SetAddress(&((*fDchambers)[i]));
306 //___________________________________________
307 void AliMUON::ResetHits()
309 // Reset number of clusters and the cluster array for this detector
310 AliDetector::ResetHits();
312 if (fClusters) fClusters->Clear();
315 //____________________________________________
316 void AliMUON::ResetDigits()
319 // Reset number of digits and the digits array for this detector
321 for ( int i=0;i<10;i++ ) {
322 if ((*fDchambers)[i]) (*fDchambers)[i]->Clear();
323 if (fNdch) fNdch[i]=0;
326 //____________________________________________
327 void AliMUON::ResetRecClusters()
330 // Reset the rec clusters
332 for ( int i=0;i<20;i++ ) {
333 if ((*fRecClusters)[i]) (*fRecClusters)[i]->Clear();
336 //___________________________________________
338 void AliMUON::SetPADSIZ(Int_t id, Int_t isec, Float_t p1, Float_t p2)
341 ((AliMUONchamber*) (*fChambers)[i]) ->SetPADSIZ(isec,p1,p2);
342 ((AliMUONchamber*) (*fChambers)[i+1])->SetPADSIZ(isec,p1,p2);
345 //___________________________________________
346 void AliMUON::SetMUCHSP(Int_t id, Float_t p1)
349 ((AliMUONchamber*) (*fChambers)[i])->SetMUCHSP(p1);
350 ((AliMUONchamber*) (*fChambers)[i+1])->SetMUCHSP(p1);
353 //___________________________________________
354 void AliMUON::SetMUSIGM(Int_t id, Float_t p1, Float_t p2)
357 ((AliMUONchamber*) (*fChambers)[i])->SetMUSIGM(p1,p2);
358 ((AliMUONchamber*) (*fChambers)[i+1])->SetMUSIGM(p1,p2);
361 //___________________________________________
362 void AliMUON::SetRSIGM(Int_t id, Float_t p1)
365 ((AliMUONchamber*) (*fChambers)[i])->SetRSIGM(p1);
366 ((AliMUONchamber*) (*fChambers)[i+1])->SetRSIGM(p1);
369 //___________________________________________
370 void AliMUON::SetMAXADC(Int_t id, Float_t p1)
373 ((AliMUONchamber*) (*fChambers)[i])->SetMAXADC(p1);
374 ((AliMUONchamber*) (*fChambers)[i+1])->SetMAXADC(p1);
377 //___________________________________________
378 void AliMUON::SetSMAXAR(Float_t p1)
383 //___________________________________________
384 void AliMUON::SetSMAXAL(Float_t p1)
389 //___________________________________________
390 void AliMUON::SetDMAXAR(Float_t p1)
395 //___________________________________________
396 void AliMUON::SetDMAXAL(Float_t p1)
400 //___________________________________________
401 void AliMUON::SetMUONACC(Bool_t acc, Float_t angmin, Float_t angmax)
407 //___________________________________________
408 void AliMUON::SetSegmentationModel(Int_t id, Int_t isec, AliMUONsegmentation *segmentation)
410 ((AliMUONchamber*) (*fChambers)[id])->SegmentationModel(isec, segmentation);
413 //___________________________________________
414 void AliMUON::SetResponseModel(Int_t id, AliMUONresponse *response)
416 ((AliMUONchamber*) (*fChambers)[id])->ResponseModel(response);
419 void AliMUON::SetNsec(Int_t id, Int_t nsec)
421 ((AliMUONchamber*) (*fChambers)[id])->SetNsec(nsec);
425 //___________________________________________
427 void AliMUON::StepManager()
429 printf("Dummy version of muon step -- it should never happen!!\n");
430 const Float_t kRaddeg = 180/TMath::Pi();
431 AliMC* pMC = AliMC::GetMC();
434 Float_t pt, th0, th1;
437 if((nsec=pMC->NSecondaries())>0) {
438 pMC->ProdProcess(proc);
439 if((pMC->TrackPid()==113 || pMC->TrackPid()==114) && !strcmp(proc,"DCAY")) {
441 // Check angular acceptance
442 //* --- and have muons from resonance decays in the wanted window ---
444 printf(" AliMUON::StepManager: Strange resonance Decay into %d particles\n",nsec);
447 pMC->GetSecondary(0,ipart,x,p);
448 pt = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
449 th0 = TMath::ATan2(pt,p[2])*kRaddeg;
450 pMC->GetSecondary(1,ipart,x,p);
451 pt = TMath::Sqrt(p[0]*p[0]+p[1]*p[1]);
452 th1 = TMath::ATan2(pt,p[2])*kRaddeg;
453 if(!(fAccMin < th0 && th0 < fAccMax) ||
454 !(fAccMin < th1 && th1 < fAccMax))
461 void AliMUON::ReconstructClusters()
464 // Initialize the necessary correspondance table
466 static const Int_t kMaxNpadx = 600;
467 static const Int_t kMaxNpady = 600;
468 Int_t elem[kMaxNpadx*2][kMaxNpady*2];
470 // Loop on chambers and on cathode planes
472 for (Int_t ich=0;ich<10;ich++)
473 for (Int_t icat=0;icat<2;icat++) {
475 // Get ready the current chamber stuff
477 AliMUONchamber* iChamber= &(this->Chamber(ich));
478 AliMUONsegmentation* segmentation =
479 iChamber->GetSegmentationModel(icat+1);
482 TClonesArray *MUONdigits = this->DigitsAddress(ich);
485 cout << "Npx " << segmentation->Npx()
486 << " Npy " << segmentation->Npy() << endl;
490 gAlice->ResetDigits();
491 gAlice->TreeD()->GetEvent(icat+1); // spurious +1 ...
492 Int_t ndigits = MUONdigits->GetEntriesFast();
495 printf("Found %d digits for cathode %d in chamber %d \n",
498 AliMUONRecCluster *Cluster;
500 // Build the correspondance table
502 memset(elem,0,sizeof(Int_t)*kMaxNpadx*kMaxNpady*4);
504 for (digit=0; digit<ndigits; digit++)
506 mdig = (AliMUONdigit*)MUONdigits->UncheckedAt(digit);
507 elem[kMaxNpadx+mdig->fPadX][kMaxNpady+mdig->fPadY] = digit+1;
508 // because default is 0
511 // Declare some useful variables
520 for (digit=0;digit<ndigits;digit++) {
521 mdig = (AliMUONdigit*)MUONdigits->UncheckedAt(digit);
523 // if digit still available, start clustering
525 if (elem[kMaxNpadx+mdig->fPadX][kMaxNpady+mdig->fPadY]) {
526 Cluster = new AliMUONRecCluster(digit, ich, icat);
527 elem[kMaxNpadx+mdig->fPadX][kMaxNpady+mdig->fPadY]=0;
529 // loop over the current list of digits
530 // and look for neighbours
532 for(Int_t clusDigit=Cluster->FirstDigitIndex();
533 clusDigit!=Cluster->InvalidDigitIndex();
534 clusDigit=Cluster->NextDigitIndex()) {
535 AliMUONdigit* pDigit=(AliMUONdigit*)MUONdigits
536 ->UncheckedAt(clusDigit);
537 segmentation->Neighbours(pDigit->fPadX,pDigit->fPadY,
538 &Nlist, Xlist, Ylist);
539 for (Int_t Ilist=0;Ilist<Nlist;Ilist++) {
540 if (elem[kMaxNpadx+Xlist[Ilist]][kMaxNpady
543 // Add the digit at the end and reset the table
545 Cluster->AddDigit(elem[kMaxNpadx+Xlist[Ilist]][kMaxNpady+Ylist[Ilist]]-1);
546 elem[kMaxNpadx+Xlist[Ilist]][kMaxNpady
552 // Store the cluster (good time to do Cluster polishing)
554 segmentation->FitXY(Cluster,MUONdigits);
556 AddRecCluster(ich,icat,Cluster);
559 printf("===> %d Clusters\n",nclust);
564 //______________________________________________________________________________
565 void AliMUON::Streamer(TBuffer &R__b)
567 // Stream an object of class AliMUON.
568 AliMUONchamber *iChamber;
569 AliMUONsegmentation *segmentation;
570 AliMUONresponse *response;
571 TClonesArray *digitsaddress;
573 if (R__b.IsReading()) {
574 Version_t R__v = R__b.ReadVersion(); if (R__v) { }
575 AliDetector::Streamer(R__b);
577 R__b >> fClusters; // diff
579 R__b.ReadArray(fNdch);
586 // Stream chamber related information
587 for (Int_t i =0; i<10; i++) {
588 iChamber=(AliMUONchamber*) (*fChambers)[i];
589 iChamber->Streamer(R__b);
590 if (iChamber->Nsec()==1) {
591 segmentation=iChamber->GetSegmentationModel(1);
592 segmentation->Streamer(R__b);
594 segmentation=iChamber->GetSegmentationModel(1);
595 segmentation->Streamer(R__b);
596 segmentation=iChamber->GetSegmentationModel(2);
597 segmentation->Streamer(R__b);
599 response=iChamber->GetResponseModel();
600 response->Streamer(R__b);
601 digitsaddress=(TClonesArray*) (*fDchambers)[i];
602 digitsaddress->Streamer(R__b);
606 R__b.WriteVersion(AliMUON::IsA());
607 AliDetector::Streamer(R__b);
609 R__b << fClusters; // diff
611 R__b.WriteArray(fNdch, 10);
618 // Stream chamber related information
619 for (Int_t i =0; i<10; i++) {
620 iChamber=(AliMUONchamber*) (*fChambers)[i];
621 iChamber->Streamer(R__b);
622 if (iChamber->Nsec()==1) {
623 segmentation=iChamber->GetSegmentationModel(1);
624 segmentation->Streamer(R__b);
626 segmentation=iChamber->GetSegmentationModel(1);
627 segmentation->Streamer(R__b);
628 segmentation=iChamber->GetSegmentationModel(2);
629 segmentation->Streamer(R__b);
631 response=iChamber->GetResponseModel();
632 response->Streamer(R__b);
634 digitsaddress=(TClonesArray*) (*fDchambers)[i];
635 digitsaddress->Streamer(R__b);
639 AliMUONcluster* AliMUON::FirstPad(AliMUONhit* hit)
642 // Initialise the pad iterator
643 // Return the address of the first padhit for hit
644 TClonesArray *theClusters = Clusters();
645 Int_t nclust = theClusters->GetEntriesFast();
646 if (nclust && hit->fPHlast > 0) {
647 sMaxIterPad=hit->fPHlast;
648 sCurIterPad=hit->fPHfirst;
649 return (AliMUONcluster*) fClusters->UncheckedAt(sCurIterPad-1);
655 AliMUONcluster* AliMUON::NextPad()
658 if (sCurIterPad <= sMaxIterPad) {
659 return (AliMUONcluster*) fClusters->UncheckedAt(sCurIterPad-1);
665 ClassImp(AliMUONcluster)
667 //___________________________________________
668 AliMUONcluster::AliMUONcluster(Int_t *clhits)
670 fHitNumber=clhits[0];
678 ClassImp(AliMUONdigit)
679 //_____________________________________________________________________________
680 AliMUONdigit::AliMUONdigit(Int_t *digits)
683 // Creates a MUON digit object to be updated
690 //_____________________________________________________________________________
691 AliMUONdigit::AliMUONdigit(Int_t *tracks, Int_t *charges, Int_t *digits)
694 // Creates a MUON digit object
699 for(Int_t i=0; i<10; i++) {
700 fTcharges[i] = charges[i];
701 fTracks[i] = tracks[i];
705 ClassImp(AliMUONlist)
707 //____________________________________________________________________________
708 AliMUONlist::AliMUONlist(Int_t rpad, Int_t *digits):
712 // Creates a MUON digit list object
716 fTrackList = new TObjArray;
719 //_____________________________________________________________________________
724 //___________________________________________
725 AliMUONhit::AliMUONhit(Int_t shunt, Int_t track, Int_t *vol, Float_t *hits):
729 fParticle=(Int_t) hits[0];
737 fPHfirst=(Int_t) hits[8];
738 fPHlast=(Int_t) hits[9];
740 ClassImp(AliMUONreccluster)
742 ClassImp(AliMUONRecCluster)
744 //_____________________________________________________________________
745 AliMUONRecCluster::AliMUONRecCluster()
752 AliMUONRecCluster(Int_t FirstDigit,Int_t Ichamber, Int_t Icathod)
756 fDigits = new TArrayI(10);
758 AddDigit(FirstDigit);
763 void AliMUONRecCluster::AddDigit(Int_t Digit)
765 if (fNdigit==fDigits->GetSize()) {
766 //enlarge the list by hand!
767 Int_t *array= new Int_t[fNdigit*2];
768 for(Int_t i=0;i<fNdigit;i++)
769 array[i] = fDigits->At(i);
770 fDigits->Adopt(fNdigit*2,array);
772 fDigits->AddAt(Digit,fNdigit);
777 AliMUONRecCluster::~AliMUONRecCluster()
783 Int_t AliMUONRecCluster::FirstDigitIndex()
786 return fDigits->At(fCurrentDigit);
789 Int_t AliMUONRecCluster::NextDigitIndex()
792 if (fCurrentDigit<fNdigit)
793 return fDigits->At(fCurrentDigit);
795 return InvalidDigitIndex();
798 Int_t AliMUONRecCluster::NDigits()
803 void AliMUONRecCluster::Finish()
805 // In order to reconstruct coordinates, one has to
806 // get back to the digits which is not trivial here,
807 // because we don't know where digits are stored!
808 // Center Of Gravity, or other method should be
809 // a property of AliMUON class!