727e7839abe0531c6d26d74f8b484bc22388b7cf
[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerElectronics.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$ */
17
18 //*-- Author: Rachid Guernane (LPCCFd)
19 //*   Manager class for muon trigger electronics
20 //*   Client of trigger board classes
21 //*
22 //*
23
24 #include "AliMUONTriggerElectronics.h"
25 #include "AliMUONTriggerCrate.h"
26 #include "AliMUONTriggerCrateStore.h"
27 #include "AliMUONConstants.h"
28 #include "AliMUONLocalTriggerBoard.h"
29 #include "AliMUONRegionalTriggerBoard.h"
30 #include "AliMUONGlobalTriggerBoard.h"
31 #include "AliMUONLocalTrigger.h"
32 #include "AliMUONRegionalTrigger.h"
33 #include "AliMUONGlobalTrigger.h"
34 #include "AliMUON.h" 
35 #include "AliMUONData.h" 
36 #include "AliMUONDigit.h"
37 #include "AliMUONSegmentation.h"
38 #include "AliMUONCalibrationData.h"
39 #include "AliMUONVCalibParam.h"
40
41 #include "AliMpSegmentation.h"
42 #include "AliMpVSegmentation.h"
43
44 #include "AliLog.h"
45 #include "AliLoader.h"
46 #include "AliRun.h"
47
48 //#include "Riostream.h"
49 #include "TBits.h"
50 #include "TSystem.h"
51
52 /// \cond CLASSIMP
53 ClassImp(AliMUONTriggerElectronics)
54 /// \endcond
55
56 //___________________________________________
57 AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONData *Data, AliMUONCalibrationData* calibData) 
58 : TTask("AliMUONTriggerElectronics",
59         "From trigger digits to Local and Global Trigger objects"),
60   fSourceFileName(),
61   fCrates(new AliMUONTriggerCrateStore),
62   fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard),
63   fMUONData(Data),
64   fLocalTrigger(new AliMUONLocalTrigger()),
65   fGlobalTrigger(new AliMUONGlobalTrigger())
66
67 {
68 /// CONSTRUCTOR
69 ///
70   if (!fMUONData)
71   {  
72     AliFatal("NO MUON TRIGGER DATA");
73   }
74     
75   SetDataSource();
76   Factory(calibData);
77   LoadMasks(calibData);
78 }
79
80 //___________________________________________
81 AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
82 {
83 /// DESTRUCTOR
84 ///
85   delete fGlobalTriggerBoard;
86   delete fCrates;
87   delete fLocalTrigger;
88   delete fGlobalTrigger;
89
90 }
91
92 //___________________________________________
93 void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
94 {  
95  /// BUILD ALL ELECTRONICS
96  ///
97
98 // get coinc44 from AliMUON (added 12/09/06)
99   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
100   Int_t coinc44 = pMUON->GetTriggerCoinc44();
101   if (coinc44 != 0 && coinc44 != 1) {
102       AliFatal("Coinc 44 should be equal to 0 or 1");
103       return;
104   }
105
106   fCrates->ReadFromFile(gSystem->ExpandPathName(fSourceFileName.Data()));
107   
108   if ( !calibData ) return;
109   
110   AliMUONTriggerLut* lut = calibData->TriggerLut();
111   
112   if (!lut) return;
113   
114   AliMUONLocalTriggerBoard* localBoard;
115   
116   fCrates->FirstLocalBoard();
117   
118   while ( (localBoard=fCrates->NextLocalBoard()) )
119   {
120     localBoard->SetLUT(lut);
121     localBoard->SetCoinc44(coinc44);
122   }
123 }
124
125 //___________________________________________
126 void AliMUONTriggerElectronics::FeedM()
127 {
128 /// FILL INPUTS
129 ///
130     for (Int_t ichamber=10; ichamber<14; ichamber++) 
131     {
132       TClonesArray *muonDigits = fMUONData->Digits(ichamber);
133       Int_t ndigits = muonDigits->GetEntriesFast();
134
135       for (Int_t digit=0; digit<ndigits; digit++)
136       {
137           AliMUONDigit *mdig = static_cast<AliMUONDigit*>(muonDigits->UncheckedAt(digit));
138
139           //       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
140           //                    for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
141           //       assert(schg==mdig->Signal());
142           Int_t schg = (Int_t)(mdig->Signal() + 0.5);
143          
144           //       APPLY CONDITION ON SOFT BACKGROUND   
145           Int_t tchg = schg - (Int_t(schg/10))*10;      
146
147           if (schg<=10 || tchg>0) 
148           {
149               //                                mdig->Print();
150
151               Int_t digitindex = digit;
152               Int_t detElemId  = mdig->DetElemId();
153               Int_t cathode    = mdig->Cathode();
154
155               const AliMpVSegmentation *seg = 
156                 AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,cathode);
157
158               Int_t ix = mdig->PadX(), iy = mdig->PadY();
159                                 
160               AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
161
162               AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
163                                 
164               for (Int_t i=0; i<pad.GetNofLocations(); i++) 
165               {
166                   AliMpIntPair location = pad.GetLocation(i);
167                                         
168                   Int_t nboard = location.GetFirst();
169
170                   Int_t ibitxy = location.GetSecond();
171
172                   AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
173
174                   if (b) 
175                   {
176                       if (cathode && b->GetSwitch(6)) ibitxy += 8;
177                                                 
178                       b->SetbitM(ibitxy,cathode,ichamber-10);
179                                                 
180                       DigitFiredCircuit(b->GetI(), cathode, ichamber, digitindex);
181                   }
182                   else
183                   {
184                       AliError(Form("Could not get local board number %d",b->GetNumber()));
185                  }
186               }
187           }             
188       }
189     }
190
191   // Particular case of the columns with 22 local boards (2R(L) 3R(L))   
192   AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
193
194   char *scratess[4] = {  "2R",   "2L",   "3L",   "3R"}; 
195   char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"}; 
196   Int_t    slotf[4] = {     2,      2,     10,     10}; 
197   Int_t    slotd[4] = {     1,      1,      9,      9}; 
198
199   for (Int_t i = 0; i < 4; i++)
200   {
201       crate = fCrates->Crate(scratess[i]); 
202       bs = crate->Boards();
203       AliMUONLocalTriggerBoard *desybb = (AliMUONLocalTriggerBoard*)bs->At(14);
204       AliMUONLocalTriggerBoard *fromcb = (AliMUONLocalTriggerBoard*)bs->At(15);
205       AliMUONLocalTriggerBoard *desxbb = (AliMUONLocalTriggerBoard*)bs->At(16);
206
207       crate = fCrates->Crate(scratesd[i]); 
208       bs = crate->Boards();
209       AliMUONLocalTriggerBoard *frombb = (AliMUONLocalTriggerBoard*)bs->At(slotf[i]);
210       AliMUONLocalTriggerBoard *desycb = (AliMUONLocalTriggerBoard*)bs->At(slotd[i]);
211
212       UShort_t cX[2];
213
214       //    COPY X3-4 FROM BOARD  2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
215       //    COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
216       frombb->GetX34(cX); desxbb->SetX34(cX);
217
218       //    COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
219       //    COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
220       fromcb->GetX34(cX); desycb->SetX34(cX);
221
222       UShort_t cY[4];
223
224       desybb->GetY(cY); frombb->SetY(cY);
225
226       frombb->GetY(cY); desxbb->SetY(cY);
227       fromcb->GetY(cY); desycb->SetY(cY);
228   }
229
230   // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
231   AliMUONTriggerCrate* cr;
232  
233   fCrates->FirstCrate();
234  
235   while ( ( cr = fCrates->NextCrate() ) )
236   {            
237       TObjArray *boards = cr->Boards();
238                 
239       for (Int_t j = 1; j < boards->GetEntries()-1; j++)
240       {
241           TObject *o = boards->At(j);
242                         
243           if (!o) break;
244                         
245           AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
246                         
247           AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
248                         
249           UShort_t cXY[2][4];
250                         
251           if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
252                         
253           //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
254           if (j < boards->GetEntries()-2)  
255           {
256               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
257                                 
258               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
259               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
260                                 
261               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
262           }
263       }
264   }
265 }
266
267 //___________________________________________
268 void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
269 {
270   /// FILL INPUTS
271   ///
272   AliMUONTriggerCrate* cr;
273    
274    fCrates->FirstCrate();
275    
276    while ( ( cr = fCrates->NextCrate() ) )
277    {                 
278      TObjArray *boards = cr->Boards();
279      
280      for (Int_t j = 1; j < boards->GetEntries(); j++)
281      {
282        TObject *o = boards->At(j);
283        
284        if (!o) break;
285        
286        AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
287        
288        board->SetXY(pattern);
289      }
290    }
291 }
292
293 //___________________________________________
294 void AliMUONTriggerElectronics::DumpOS()
295 {
296 /// DUMP IN THE OLD WAY
297 ///
298    for (Int_t i= 0; i < 234;i++)
299    {
300       AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
301
302       if (board) board->Scan("ALL");
303    }
304 }
305
306 //___________________________________________
307 void AliMUONTriggerElectronics::Scan(Option_t *option)
308 {
309   /// SCAN
310   ///
311
312   AliMUONTriggerCrate* cr;
313   
314   fCrates->FirstCrate();
315   
316   while ( ( cr = fCrates->NextCrate() ) )
317   {                
318     TObjArray *boards = cr->Boards();
319     
320     for (Int_t j = 0; j < boards->GetEntries(); j++)
321     {
322       TObject *o = boards->At(j);
323       
324       TString op = option;
325       
326       Bool_t cdtion = kFALSE;
327       
328       if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
329       if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
330       if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
331       
332       if (!o || !cdtion) continue;
333       
334       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
335       
336       board->Scan();
337     }
338   }
339 }
340
341 //___________________________________________
342 void AliMUONTriggerElectronics::Reset()
343 {
344   /// RESET
345   ///
346   
347    AliMUONTriggerCrate* cr;
348    
349    fCrates->FirstCrate();
350    
351    while ( ( cr = fCrates->NextCrate() ) )
352    {            
353       TObjArray *boards = cr->Boards();
354             
355       for (Int_t j=0; j<boards->GetEntries(); j++)
356       {     
357          AliMUONTriggerBoard *b = (AliMUONTriggerBoard*)boards->At(j);
358
359          if (b) b->Reset();
360       }
361    }
362 }
363
364 //_______________________________________________________________________
365 void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
366 {
367   // LOAD MASKS FROM CDB
368   
369
370   // SET MASKS
371   
372   AliMUONTriggerCrate* cr;
373   
374   fCrates->FirstCrate();
375   
376   Int_t irb(0);
377   
378   while ( ( cr = fCrates->NextCrate() ) )
379   {            
380     TObjArray *boards = cr->Boards();
381     
382     AliMUONRegionalTriggerBoard *regb =
383       (AliMUONRegionalTriggerBoard*)boards->At(0);
384
385     AliMUONVCalibParam* regionalBoardMasks = calibData->RegionalTriggerBoardMasks(irb);
386     
387     for ( Int_t i = 0; i < regionalBoardMasks->Size(); ++i )
388     {
389       UShort_t rmask = static_cast<UShort_t>(regionalBoardMasks->ValueAsInt(i) & 0x3F);
390       regb->Mask(i,rmask);
391     }
392     
393     for (Int_t j = 1; j < boards->GetEntries(); j++)
394     {
395       AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(j);
396       
397       Int_t cardNumber = b->GetNumber();
398       
399       if (cardNumber) // interface board are not interested
400       {
401         AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
402         for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
403         {
404           UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
405           b->Mask(i,lmask);
406         }
407       }
408     }
409     ++irb;
410   }
411   
412   AliMUONVCalibParam* globalBoardMasks = calibData->GlobalTriggerBoardMasks();
413   for ( Int_t i = 0; i < globalBoardMasks->Size(); ++i )
414   {
415     UShort_t gmask = static_cast<UShort_t>(globalBoardMasks->ValueAsInt(i) & 0xFFF);
416     fGlobalTriggerBoard->Mask(i,gmask);
417   }
418 }
419
420
421 //___________________________________________
422 void AliMUONTriggerElectronics::LocalResponse()
423 {
424 /// \todo add comment
425         
426   AliMUONTriggerCrate* cr;
427   
428   fCrates->FirstCrate();
429   
430   while ( ( cr = fCrates->NextCrate() ) )
431   {            
432     
433     TObjArray *boards = cr->Boards();
434     
435     AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
436     
437     UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
438   
439     for (Int_t j = 1; j < boards->GetEntries(); j++)
440     {     
441         TObject *o = boards->At(j);
442       
443         if (!o) break;
444       
445         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
446       
447         if (board) // check if empty slot
448         {
449           board->Response();
450                                 
451           UShort_t response = board->GetResponse();            
452         
453           // CRATE CONTAINING INTERFACE BOARD
454           if (board->GetNumber() == 0) // copy boards
455           {
456             if ( response != 0 ) 
457               AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
458                                           board->GetName(),j,cr->GetName()));
459             AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
460
461           }
462         
463           thisl[j-1] = response;
464         }
465       }
466     
467     regb->SetLocalResponse(thisl);
468   }
469 }
470
471 //___________________________________________
472 void AliMUONTriggerElectronics::RegionalResponse()
473 {
474   /// Compute the response for all regional cards.
475   AliMUONTriggerCrate* cr;
476   
477   fCrates->FirstCrate();
478   
479   while ( ( cr = fCrates->NextCrate() ) )
480   {            
481       TObjArray *boards = cr->Boards();
482
483       AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
484       
485       if (regb) 
486       {
487          regb->Response();
488       }  
489    }
490 }
491
492 //___________________________________________
493 void AliMUONTriggerElectronics::GlobalResponse()
494 {
495   /// Compute the global response
496
497   UShort_t regional[16];
498   
499   AliMUONTriggerCrate* cr;
500   
501   fCrates->FirstCrate();
502   Int_t irb(0);
503   
504   if ( !fCrates->NumberOfCrates() >= 16 ) 
505   {
506     AliFatal(Form("Something is wrong : too many crates %d",
507                   fCrates->NumberOfCrates()));
508   }
509   
510   while ( ( cr = fCrates->NextCrate() ) )
511   {            
512     AliMUONTriggerBoard* rb = 
513       static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
514     regional[irb] = rb->GetResponse();
515     ++irb;
516   }
517   
518   fGlobalTriggerBoard->SetRegionalResponse(regional);
519   fGlobalTriggerBoard->Response();
520 }
521
522 //_______________________________________________________________________
523 void 
524 AliMUONTriggerElectronics::Exec(Option_t*)
525 {
526 /// \todo add comment
527 ///
528   Digits2Trigger();
529 }
530
531 //_______________________________________________________________________
532 void AliMUONTriggerElectronics::Trigger()
533 {
534 /// \todo add comment
535 ///
536    FeedM();
537    LocalResponse();
538    RegionalResponse();      
539    GlobalResponse();
540 }
541
542 //_______________________________________________________________________
543 void AliMUONTriggerElectronics::Digits2Trigger()
544 {
545   /// Main method to go from digits to trigger decision
546   AliMUONRegionalTrigger *pRegTrig = new AliMUONRegionalTrigger();
547   ClearDigitNumbers();
548   fMUONData->ResetTrigger(); 
549   // RUN THE FULL BEE CHAIN
550   Trigger();
551 //    DumpOS();
552         
553   AliMUONTriggerCrate* cr;
554   fCrates->FirstCrate();
555
556   while ( ( cr = fCrates->NextCrate() ) )
557   {            
558     TObjArray *boards = cr->Boards();
559
560     UInt_t regInpLpt = 0;
561     UInt_t regInpHpt = 0;
562     UShort_t localMask = 0x0;
563
564     AliMUONRegionalTriggerBoard *regBoard = (AliMUONRegionalTriggerBoard*)boards->At(0);
565
566     for (Int_t j = 1; j < boards->GetEntries(); j++)
567     {     
568       TObject *o = boards->At(j);
569       
570       if (!o) break;
571       
572       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
573       
574       if (board) 
575       {
576         //          L0 TRIGGER
577         if (board->Triggered())
578         {
579           
580           Int_t icirc = board->GetNumber();
581
582           fLocalTrigger->SetLoCircuit(icirc);
583           fLocalTrigger->SetLoStripX(board->GetStripX11());
584           fLocalTrigger->SetLoDev(board->GetDev());
585           fLocalTrigger->SetLoStripY(board->GetStripY11());
586           
587           //             SAVE LUT OUTPUT 
588           UShort_t response = board->GetResponse();
589           fLocalTrigger->SetLoHpt((response & 12) >> 2);
590           fLocalTrigger->SetLoLpt(response &  3);
591
592           // calculates regional inputs from local for the moment
593           UInt_t hPt = (response >> 4) & 0x3;
594           UInt_t lPt = (response >> 2) & 0x3;
595             
596           regInpHpt |= hPt << (30 - (j-1)*2);
597           regInpLpt |= lPt << (30 - (j-1)*2);
598           localMask |= (0x1 << (j-1)); // local mask
599
600           TBits rrr;
601           rrr.Set(6,&response);   
602           
603           //             SAVE BIT PATTERN
604           fLocalTrigger->SetX1Pattern(board->GetXY(0,0));
605           fLocalTrigger->SetX2Pattern(board->GetXY(0,1));
606           fLocalTrigger->SetX3Pattern(board->GetXY(0,2));
607           fLocalTrigger->SetX4Pattern(board->GetXY(0,3));
608           
609           fLocalTrigger->SetY1Pattern(board->GetXY(1,0));
610           fLocalTrigger->SetY2Pattern(board->GetXY(1,1));
611           fLocalTrigger->SetY3Pattern(board->GetXY(1,2));
612           fLocalTrigger->SetY4Pattern(board->GetXY(1,3));
613           
614           fLocalTrigger->SetDigits(fDigitNumbers[icirc]);
615
616           //             ADD A NEW LOCAL TRIGGER          
617           fMUONData->AddLocalTrigger(*fLocalTrigger);  
618           
619         }
620       }
621     }
622     pRegTrig->SetLocalOutput(regInpLpt, 0);
623     pRegTrig->SetLocalOutput(regInpHpt, 1);
624     pRegTrig->SetLocalMask(localMask);
625     pRegTrig->SetOutput((regBoard->GetResponse() >> 4) & 0xF); // to be uniformized (oct06 ?)
626
627     fMUONData->AddRegionalTrigger(*pRegTrig);  
628     
629   }
630   delete pRegTrig;
631   
632   // GLOBAL TRIGGER INFORMATION
633   UShort_t global = fGlobalTriggerBoard->GetResponse();
634   fGlobalTrigger->SetFromGlobalResponse(global);
635
636   
637   // ADD A LOCAL TRIGGER IN THE LIST 
638   fMUONData->AddGlobalTrigger(*fGlobalTrigger);
639
640   // NOW RESET ELECTRONICS
641   Reset();
642 }
643
644 //_______________________________________________________________________
645 void AliMUONTriggerElectronics::ClearDigitNumbers()
646 {
647 // RESET fDigitNumbers
648         for (Int_t i=0; i<AliMUONConstants::NTriggerCircuit(); i++) fDigitNumbers[i].Set(0);
649 }
650
651 //_______________________________________________________________________
652 void AliMUONTriggerElectronics::DigitFiredCircuit(Int_t circuit, Int_t cathode,
653                                                   Int_t chamber, Int_t digit)
654 {
655 // REGISTERS THAT THE SPECIFIED DIGIT FIRED THE SPECIFIED CIRCUIT
656 // THIS DIGIT GETS ADDED TO AN ARRAY WHICH WILL BE COPIED TO
657 // AliMUONLocalTrigger WHEN SUCH AN OBJECT IS CREATED FOR EACH CIRCUIT
658         Int_t digitnumber = AliMUONLocalTrigger::EncodeDigitNumber(chamber, cathode, digit);
659         Int_t last = fDigitNumbers[circuit].GetSize();
660         fDigitNumbers[circuit].Set(last + 1);
661         fDigitNumbers[circuit][last] = digitnumber;
662 }
663