Changes to use VTriggerStore (Laurent)
[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 "AliLoader.h"
25 #include "AliLog.h"
26 #include "AliMUON.h" 
27 #include "AliMUONCalibrationData.h"
28 #include "AliMUONVDigit.h"
29 #include "AliMUONVDigitStore.h"
30 #include "AliMUONGlobalTrigger.h"
31 #include "AliMUONGlobalTriggerBoard.h"
32 #include "AliMUONLocalTrigger.h"
33 #include "AliMUONLocalTriggerBoard.h"
34 #include "AliMUONRegionalTrigger.h"
35 #include "AliMUONRegionalTriggerBoard.h"
36 #include "AliMUONTriggerCrate.h"
37 #include "AliMUONTriggerCrateStore.h"
38 #include "AliMUONTriggerElectronics.h"
39 #include "AliMUONVTriggerStore.h"
40 #include "AliMUONVCalibParam.h"
41 #include "AliMpCathodType.h"
42 #include "AliMpDEManager.h"
43 #include "AliMpSegmentation.h"
44 #include "AliMpVSegmentation.h"
45 #include "AliMpCathodType.h"
46
47 #include "AliMUONTriggerGUIboard.h"
48
49 #include "AliLog.h"
50 #include "AliLoader.h"
51 #include "AliRun.h"
52 #include <TBits.h>
53 #include <TSystem.h>
54
55
56 /// \cond CLASSIMP
57 ClassImp(AliMUONTriggerElectronics)
58 /// \endcond
59
60 //___________________________________________
61 AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONCalibrationData* calibData) 
62 : TObject(),
63   fSourceFileName(),
64   fCrates(new AliMUONTriggerCrateStore),
65   fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard)
66 {
67  /// CONSTRUCTOR
68 ///
69   SetDataSource();
70   Factory(calibData);
71   LoadMasks(calibData);
72 }
73
74 //___________________________________________
75 AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
76 {
77 /// DESTRUCTOR
78 ///
79   delete fGlobalTriggerBoard;
80   delete fCrates;
81 }
82
83 //___________________________________________
84 void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
85 {  
86  /// BUILD ALL ELECTRONICS
87  ///
88
89 // get coinc44 from AliMUON (added 12/09/06)
90   AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
91   Int_t coinc44 = pMUON->GetTriggerCoinc44();
92   if (coinc44 != 0 && coinc44 != 1) {
93       AliFatal("Coinc 44 should be equal to 0 or 1");
94       return;
95   }
96
97   fCrates->ReadFromFile(gSystem->ExpandPathName(fSourceFileName.Data()));
98   
99   if ( !calibData ) return;
100   
101   AliMUONTriggerLut* lut = calibData->TriggerLut();
102   
103   if (!lut) return;
104   
105   AliMUONLocalTriggerBoard* localBoard;
106   
107   fCrates->FirstLocalBoard();
108   
109   while ( (localBoard=fCrates->NextLocalBoard()) )
110   {
111     localBoard->SetLUT(lut);
112     localBoard->SetCoinc44(coinc44);
113   }
114 }
115
116 //___________________________________________
117 void AliMUONTriggerElectronics::Feed(const AliMUONVDigitStore& digitStore)
118 {
119   /// FILL INPUTS
120   ///
121   
122   TIter next(digitStore.CreateTriggerIterator());
123   AliMUONVDigit* mdig;
124   
125   while ( ( mdig = static_cast<AliMUONVDigit*>(next()) ) )
126   {      
127     //       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
128     //                  for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
129     Int_t ichamber = AliMpDEManager::GetChamberId(mdig->DetElemId());
130     Int_t schg = (Int_t)(mdig->Charge() + 0.5);
131     
132     //       APPLY CONDITION ON SOFT BACKGROUND 
133     Int_t tchg = schg - (Int_t(schg/10))*10;    
134     
135     if (schg<=10 || tchg>0) 
136     {
137       Int_t detElemId  = mdig->DetElemId();
138       Int_t cathode    = mdig->Cathode();
139       
140       const AliMpVSegmentation *seg = 
141         AliMpSegmentation::Instance()
142         ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
143       
144       Int_t ix = mdig->PadX(), iy = mdig->PadY();
145       
146       AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
147       
148       AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
149       
150       for (Int_t i=0; i<pad.GetNofLocations(); i++) 
151       {
152         AliMpIntPair location = pad.GetLocation(i);
153         
154         Int_t nboard = location.GetFirst();
155         
156         Int_t ibitxy = location.GetSecond();
157         
158         AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
159         
160         if (b) 
161         {
162           if (cathode && b->GetSwitch(6)) ibitxy += 8;
163           
164           b->SetbitM(ibitxy,cathode,ichamber-10);
165         }
166         else
167         {
168           AliError(Form("Could not get local board number %d",b->GetNumber()));
169         }
170       }
171     }           
172   }
173   
174   // Particular case of the columns with 22 local boards (2R(L) 3R(L))   
175   AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
176   
177   char *scratess[4] = {  "2R",   "2L",   "3L",   "3R"}; 
178   char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"}; 
179   Int_t    slotf[4] = {     2,      2,     10,     10}; 
180   Int_t    slotd[4] = {     1,      1,      9,      9}; 
181   
182   for (Int_t i = 0; i < 4; i++)
183   {
184     crate = fCrates->Crate(scratess[i]); 
185     bs = crate->Boards();
186     AliMUONLocalTriggerBoard *desybb = (AliMUONLocalTriggerBoard*)bs->At(14);
187     AliMUONLocalTriggerBoard *fromcb = (AliMUONLocalTriggerBoard*)bs->At(15);
188     AliMUONLocalTriggerBoard *desxbb = (AliMUONLocalTriggerBoard*)bs->At(16);
189     
190     crate = fCrates->Crate(scratesd[i]); 
191     bs = crate->Boards();
192     AliMUONLocalTriggerBoard *frombb = (AliMUONLocalTriggerBoard*)bs->At(slotf[i]);
193     AliMUONLocalTriggerBoard *desycb = (AliMUONLocalTriggerBoard*)bs->At(slotd[i]);
194     
195     UShort_t cX[2];
196     
197     //    COPY X3-4 FROM BOARD  2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
198     //    COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
199     frombb->GetX34(cX); desxbb->SetX34(cX);
200     
201     //    COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
202     //    COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
203     fromcb->GetX34(cX); desycb->SetX34(cX);
204     
205     UShort_t cY[4];
206     
207     desybb->GetY(cY); frombb->SetY(cY);
208     
209     frombb->GetY(cY); desxbb->SetY(cY);
210     fromcb->GetY(cY); desycb->SetY(cY);
211   }
212   
213   // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
214   AliMUONTriggerCrate* cr;
215   
216   fCrates->FirstCrate();
217   
218   while ( ( cr = fCrates->NextCrate() ) )
219   {            
220     TObjArray *boards = cr->Boards();
221     
222     for (Int_t j = 1; j < boards->GetEntries()-1; j++)
223     {
224       TObject *o = boards->At(j);
225                         
226       if (!o) break;
227                         
228       AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
229                         
230       AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
231                         
232       UShort_t cXY[2][4];
233                         
234       if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
235                         
236       //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
237       if (j < boards->GetEntries()-2)  
238       {
239               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
240                                 
241               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
242               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
243                                 
244               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
245       }
246     }
247   }
248 }
249
250
251 //___________________________________________
252 void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
253 {
254   /// FILL INPUTS
255   ///
256   AliMUONTriggerCrate* cr;
257    
258    fCrates->FirstCrate();
259    
260    while ( ( cr = fCrates->NextCrate() ) )
261    {                 
262      TObjArray *boards = cr->Boards();
263      
264      for (Int_t j = 1; j < boards->GetEntries(); j++)
265      {
266        TObject *o = boards->At(j);
267        
268        if (!o) break;
269        
270        AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
271        
272        board->SetXY(pattern);
273      }
274    }
275 }
276
277 //___________________________________________
278 void AliMUONTriggerElectronics::DumpOS()
279 {
280 /// DUMP IN THE OLD WAY
281 ///
282    for (Int_t i= 0; i < 234;i++)
283    {
284       AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
285
286       if (board) board->Scan("ALL");
287    }
288 }
289
290 //___________________________________________
291 void AliMUONTriggerElectronics::Scan(Option_t *option)
292 {
293   /// SCAN
294   ///
295
296   AliMUONTriggerCrate* cr;
297   
298   fCrates->FirstCrate();
299   
300   while ( ( cr = fCrates->NextCrate() ) )
301   {                
302     TObjArray *boards = cr->Boards();
303     
304     for (Int_t j = 0; j < boards->GetEntries(); j++)
305     {
306       TObject *o = boards->At(j);
307       
308       TString op = option;
309       
310       Bool_t cdtion = kFALSE;
311       
312       if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
313       if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
314       if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
315       
316       if (!o || !cdtion) continue;
317       
318       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
319       
320       board->Scan();
321     }
322   }
323 }
324
325 //___________________________________________
326 void AliMUONTriggerElectronics::Reset()
327 {
328   /// RESET
329   ///
330   
331    AliMUONTriggerCrate* cr;
332    
333    fCrates->FirstCrate();
334    
335    while ( ( cr = fCrates->NextCrate() ) )
336    {            
337       TObjArray *boards = cr->Boards();
338             
339       for (Int_t j=0; j<boards->GetEntries(); j++)
340       {     
341          AliMUONTriggerBoard *b = (AliMUONTriggerBoard*)boards->At(j);
342
343          if (b) b->Reset();
344       }
345    }
346 }
347
348 //_______________________________________________________________________
349 void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
350 {
351   /// LOAD MASKS FROM CDB
352   
353
354   // SET MASKS
355   
356   AliMUONTriggerCrate* cr;
357   
358   fCrates->FirstCrate();
359   
360   Int_t irb(0);
361   
362   while ( ( cr = fCrates->NextCrate() ) )
363   {            
364     TObjArray *boards = cr->Boards();
365     
366     AliMUONRegionalTriggerBoard *regb =
367       (AliMUONRegionalTriggerBoard*)boards->At(0);
368
369     AliMUONVCalibParam* regionalBoardMasks = calibData->RegionalTriggerBoardMasks(irb);
370     
371     for ( Int_t i = 0; i < regionalBoardMasks->Size(); ++i )
372     {
373       UShort_t rmask = static_cast<UShort_t>(regionalBoardMasks->ValueAsInt(i) & 0x3F);
374       regb->Mask(i,rmask);
375     }
376     
377     for (Int_t j = 1; j < boards->GetEntries(); j++)
378     {
379       AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(j);
380       
381       Int_t cardNumber = b->GetNumber();
382       
383       if (cardNumber) // interface board are not interested
384       {
385         AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
386         for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
387         {
388           UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
389           b->Mask(i,lmask);
390         }
391       }
392     }
393     ++irb;
394   }
395   
396   AliMUONVCalibParam* globalBoardMasks = calibData->GlobalTriggerBoardMasks();
397   for ( Int_t i = 0; i < globalBoardMasks->Size(); ++i )
398   {
399     UShort_t gmask = static_cast<UShort_t>(globalBoardMasks->ValueAsInt(i) & 0xFFF);
400     fGlobalTriggerBoard->Mask(i,gmask);
401   }
402 }
403
404
405 //___________________________________________
406 void AliMUONTriggerElectronics::LocalResponse()
407 {
408 /// \todo add comment
409         
410   AliMUONTriggerCrate* cr;
411   
412   fCrates->FirstCrate();
413   
414   while ( ( cr = fCrates->NextCrate() ) )
415   {            
416     
417     TObjArray *boards = cr->Boards();
418     
419     AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
420     
421     UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
422   
423     for (Int_t j = 1; j < boards->GetEntries(); j++)
424     {     
425         TObject *o = boards->At(j);
426       
427         if (!o) break;
428       
429         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
430       
431         if (board) // check if empty slot
432         {
433           board->Response();
434                                 
435           UShort_t response = board->GetResponse();            
436         
437           // CRATE CONTAINING INTERFACE BOARD
438           if (board->GetNumber() == 0) // copy boards
439           {
440             if ( response != 0 ) 
441               AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
442                                           board->GetName(),j,cr->GetName()));
443             AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
444
445           }
446         
447           thisl[j-1] = response;
448         }
449       }
450     
451     regb->SetLocalResponse(thisl);
452   }
453 }
454
455 //___________________________________________
456 void AliMUONTriggerElectronics::RegionalResponse()
457 {
458   /// Compute the response for all regional cards.
459   AliMUONTriggerCrate* cr;
460   
461   fCrates->FirstCrate();
462   
463   while ( ( cr = fCrates->NextCrate() ) )
464   {            
465       TObjArray *boards = cr->Boards();
466
467       AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
468       
469       if (regb) 
470       {
471          regb->Response();
472       }  
473    }
474 }
475
476 //___________________________________________
477 void AliMUONTriggerElectronics::GlobalResponse()
478 {
479   /// Compute the global response
480
481   UShort_t regional[16];
482   
483   AliMUONTriggerCrate* cr;
484   
485   fCrates->FirstCrate();
486   Int_t irb(0);
487   
488   if ( !fCrates->NumberOfCrates() >= 16 ) 
489   {
490     AliFatal(Form("Something is wrong : too many crates %d",
491                   fCrates->NumberOfCrates()));
492   }
493   
494   while ( ( cr = fCrates->NextCrate() ) )
495   {            
496     AliMUONTriggerBoard* rb = 
497       static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
498     regional[irb] = rb->GetResponse();
499     ++irb;
500   }
501   
502   fGlobalTriggerBoard->SetRegionalResponse(regional);
503   fGlobalTriggerBoard->Response();
504 }
505
506 //_______________________________________________________________________
507 void AliMUONTriggerElectronics::Digits2Trigger(const AliMUONVDigitStore& digitStore,
508                                                AliMUONVTriggerStore& triggerStore)
509 {
510   /// Main method to go from digits to trigger decision
511   AliMUONRegionalTrigger pRegTrig;
512   
513   triggerStore.Clear();
514   
515   // RUN THE FULL BEE CHAIN
516   Feed(digitStore);
517   LocalResponse();
518   RegionalResponse();      
519   GlobalResponse();
520   //    DumpOS();
521         
522   AliMUONTriggerCrate* cr;
523   AliMUONLocalTrigger localTrigger;
524   
525   // stored in right order
526   // do not used iterator order
527   
528   for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
529   {            
530     for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
531     {
532       cr = fCrates->Crate(iSide, iReg);     
533       TObjArray *boards = cr->Boards();
534       
535       UInt_t regInpLpt = 0;
536       UInt_t regInpHpt = 0;
537       
538       AliMUONRegionalTriggerBoard *regBoard = (AliMUONRegionalTriggerBoard*)boards->At(0);
539       
540       for (Int_t j = 1; j < boards->GetEntries(); j++)
541       {     
542         TObject *o = boards->At(j);
543         
544         if (!o) break;
545         
546         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
547         
548         if (board) 
549         {
550           //          L0 TRIGGER
551           // pcrochet 181206: MOOD needs ALL boards
552           //      if (board->Triggered())
553           //      {
554           
555           Int_t icirc = board->GetNumber();
556           if (icirc != 0) { // pcrochet 181206: MOOD needs ALL boards
557             
558             localTrigger.SetLoCircuit(icirc);
559             localTrigger.SetLoStripX(board->GetStripX11());
560             localTrigger.SetLoDev(board->GetDev());
561             localTrigger.SetLoSdev(board->GetSdev());
562             localTrigger.SetLoTrigY(board->GetTrigY());
563             localTrigger.SetLoStripY(board->GetStripY11());
564             
565             //             SAVE LUT OUTPUT 
566             UShort_t response = board->GetResponse();
567             localTrigger.SetLoHpt((response & 12) >> 2);
568             localTrigger.SetLoLpt(response &  3);
569             
570             // calculates regional inputs from local for the moment
571             UInt_t hPt = (response >> 2) & 0x3;
572             UInt_t lPt =  response       & 0x3;
573             
574             regInpHpt |= hPt << (30 - (j-1)*2);
575             regInpLpt |= lPt << (30 - (j-1)*2);
576             
577             TBits rrr;
578             rrr.Set(6,&response);         
579             
580             //             SAVE BIT PATTERN
581             localTrigger.SetX1Pattern(board->GetXY(0,0));
582             localTrigger.SetX2Pattern(board->GetXY(0,1));
583             localTrigger.SetX3Pattern(board->GetXY(0,2));
584             localTrigger.SetX4Pattern(board->GetXY(0,3));
585             
586             localTrigger.SetY1Pattern(board->GetXY(1,0));
587             localTrigger.SetY2Pattern(board->GetXY(1,1));
588             localTrigger.SetY3Pattern(board->GetXY(1,2));
589             localTrigger.SetY4Pattern(board->GetXY(1,3));
590             
591             //             ADD A NEW LOCAL TRIGGER          
592             triggerStore.Add(localTrigger);  
593             
594           }
595           }
596         }
597       pRegTrig.SetId(iReg + 8*iSide);
598       pRegTrig.SetLocalOutput(regInpLpt, 0);
599       pRegTrig.SetLocalOutput(regInpHpt, 1);
600       pRegTrig.SetOutput(regBoard->GetResponse());
601       
602       triggerStore.Add(pRegTrig);  
603       }
604     }
605   
606   // GLOBAL TRIGGER INFORMATION
607   UShort_t global = fGlobalTriggerBoard->GetResponse();
608   
609   AliMUONGlobalTrigger globalTrigger;
610   
611   globalTrigger.SetFromGlobalResponse(global);
612   // ADD A LOCAL TRIGGER IN THE LIST 
613   triggerStore.SetGlobal(globalTrigger);
614   
615   // NOW RESET ELECTRONICS
616   Reset();
617 }
618
619 //_______________________________________________________________________
620 void AliMUONTriggerElectronics::FeedBoardsGUI(TObjArray *guibs)
621 {
622   /// feed digits from board objects from the TriggerGUI, with values
623   /// read from a file or set interactively in the GUI
624   /// 
625
626   // adaptated from FeedM()
627
628   AliMUONTriggerGUIboard* board;
629   Int_t cathode, nstripX, nstripY, ix, iy, detElemId0, detElemId, charge;
630   Int_t iX1, iY1, schg, tchg;
631   Bool_t triggerBgn;
632
633   for (Int_t ib = 0; ib < 234; ib++) {
634
635     board = (AliMUONTriggerGUIboard*)guibs->At(ib);
636     if (board == 0) continue;
637
638     detElemId0 = board->GetDetElemId();
639
640     nstripX = board->GetNStripX();
641     nstripY = board->GetNStripY();
642
643     for (Int_t ichamber = 11; ichamber <= 14; ichamber++) {
644   
645       detElemId = ichamber * 100 + detElemId0;
646
647       // x strips
648       cathode = 0;
649       for (Int_t isx = 0; isx < nstripX; isx++) {
650
651         charge = (Int_t)board->GetXDig(ichamber-11,isx);
652         if (charge) {
653
654           triggerBgn = kFALSE;
655           schg = (Int_t)(charge + 0.5);
656           // APPLY CONDITION ON SOFT BACKGROUND 
657           tchg = schg - (Int_t(schg/10))*10;    
658           if (schg<=10 || tchg>0) {
659             triggerBgn = kFALSE;
660           } else {
661             triggerBgn = kTRUE;
662           }
663           if (triggerBgn) continue;
664
665           //printf("MT %2d SX %2d \n",ichamber,isx);
666
667           ix  = board->GetXSix();
668           iY1 = board->GetXSiy1();
669           iy  = isx + iY1;
670
671           //printf("X: CH %1d B %3d ID %4d ix %2d iy %2d \n",ichamber,ib,detElemId,ix,iy);
672           
673           const AliMpVSegmentation* seg = 
674             AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
675
676           AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
677
678           if (!pad.IsValid()) printf("Invalid pad! \n");
679
680           for (Int_t i=0; i<pad.GetNofLocations(); i++) {
681
682             AliMpIntPair location = pad.GetLocation(i);
683             Int_t nboard = location.GetFirst();
684             if (nboard != board->GetIdCircuit()) continue;
685             Int_t ibitxy = location.GetSecond();
686             
687             //printf("FeedGUI x (%2d): ix %d iy %d detElemId %d \n",ichamber,ix,iy,detElemId);
688
689             AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
690             
691             if (b) {
692               if (cathode && b->GetSwitch(6)) ibitxy += 8;
693               
694               //printf("Feed x-digits in board: %d cha %d s %d \n",nboard,ichamber,isx);
695               b->SetbitM(ibitxy,cathode,ichamber-11);
696               
697             } else {
698               AliError(Form("Could not get local board number %d",b->GetNumber()));
699             }         
700             
701           }
702
703         }
704
705       }
706
707       // y strips
708       cathode = 1;
709       for (Int_t isy = 0; isy < nstripY; isy++) {
710
711         charge = board->GetYDig(ichamber-11,isy);
712         if (charge) {
713
714           triggerBgn = kFALSE;
715           schg = (Int_t)(charge + 0.5);
716           // APPLY CONDITION ON SOFT BACKGROUND 
717           tchg = schg - (Int_t(schg/10))*10;    
718           if (schg<=10 || tchg>0) {
719             triggerBgn = kFALSE;
720           } else {
721             triggerBgn = kTRUE;
722           }
723           if (triggerBgn) continue;
724
725           //printf("MT %2d SY %2d \n",ichamber,isy);
726
727           iX1 = board->GetYSix1();
728           ix  = isy + iX1;
729           iy  = board->GetYSiy();
730
731           //printf("Y: CH %1d B %3d ID %4d ix %2d iy %2d \n",ichamber,ib,detElemId,ix,iy);
732           
733           const AliMpVSegmentation* seg = 
734             AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
735
736           AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
737
738           if (!pad.IsValid()) printf("Invalid pad! \n");;
739
740           for (Int_t i=0; i<pad.GetNofLocations(); i++) {
741
742             AliMpIntPair location = pad.GetLocation(i);
743             Int_t nboard = location.GetFirst();
744             if (nboard != board->GetIdCircuit()) continue;
745             Int_t ibitxy = location.GetSecond();
746             
747             //printf("FeedGUI y (%2d): ix %d iy %d detElemId %d \n",ichamber,ix,iy,detElemId);
748
749             AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
750             
751             if (b) {
752               if (cathode && b->GetSwitch(6)) ibitxy += 8;
753               
754               //printf("Feed y-digits in board: %d cha %d s %d \n",nboard,ichamber,isy);
755               b->SetbitM(ibitxy,cathode,ichamber-11);
756               
757             } else {
758               AliError(Form("Could not get local board number %d",b->GetNumber()));
759             }
760
761           }
762
763         }
764
765       }
766
767     }
768     
769   }
770
771   // ... the rest from FeedM()
772
773   // Particular case of the columns with 22 local boards (2R(L) 3R(L))   
774   AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
775
776   char *scratess[4] = {  "2R",   "2L",   "3L",   "3R"}; 
777   char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"}; 
778   Int_t    slotf[4] = {     2,      2,     10,     10}; 
779   Int_t    slotd[4] = {     1,      1,      9,      9}; 
780
781   for (Int_t i = 0; i < 4; i++)
782   {
783       crate = fCrates->Crate(scratess[i]); 
784       bs = crate->Boards();
785       AliMUONLocalTriggerBoard *desybb = (AliMUONLocalTriggerBoard*)bs->At(14);
786       AliMUONLocalTriggerBoard *fromcb = (AliMUONLocalTriggerBoard*)bs->At(15);
787       AliMUONLocalTriggerBoard *desxbb = (AliMUONLocalTriggerBoard*)bs->At(16);
788
789       crate = fCrates->Crate(scratesd[i]); 
790       bs = crate->Boards();
791       AliMUONLocalTriggerBoard *frombb = (AliMUONLocalTriggerBoard*)bs->At(slotf[i]);
792       AliMUONLocalTriggerBoard *desycb = (AliMUONLocalTriggerBoard*)bs->At(slotd[i]);
793
794       UShort_t cX[2];
795
796       //    COPY X3-4 FROM BOARD  2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
797       //    COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
798       frombb->GetX34(cX); desxbb->SetX34(cX);
799
800       //    COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
801       //    COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
802       fromcb->GetX34(cX); desycb->SetX34(cX);
803
804       UShort_t cY[4];
805
806       desybb->GetY(cY); frombb->SetY(cY);
807
808       frombb->GetY(cY); desxbb->SetY(cY);
809       fromcb->GetY(cY); desycb->SetY(cY);
810   }
811
812   // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
813   AliMUONTriggerCrate* cr;
814  
815   fCrates->FirstCrate();
816  
817   while ( ( cr = fCrates->NextCrate() ) )
818   {            
819       TObjArray *boards = cr->Boards();
820                 
821       for (Int_t j = 1; j < boards->GetEntries()-1; j++)
822       {
823           TObject *o = boards->At(j);
824                         
825           if (!o) break;
826                         
827           AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
828                         
829           AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
830                         
831           UShort_t cXY[2][4];
832                         
833           if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
834                         
835           //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
836           if (j < boards->GetEntries()-2)  
837           {
838               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
839                                 
840               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
841               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
842                                 
843               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
844           }
845       }
846   }
847 }
848
849 //_______________________________________________________________________
850 Int_t AliMUONTriggerElectronics::TriggerGUI(Int_t *trigInfo, Bool_t patt)
851 {
852   /// trigger with digits from TriggerGUI and return local trigger information
853   /// and optionally the strips pattern
854   /// 
855
856   Int_t nlo = 0;
857
858   LocalResponse();
859   RegionalResponse();      
860   GlobalResponse();
861
862   AliMUONTriggerCrate* cr;
863  
864   // stored in right order
865   // do not used iterator order
866
867   for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
868   {            
869     for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
870     {
871       cr = fCrates->Crate(iSide, iReg);     
872       TObjArray *boards = cr->Boards();
873
874       for (Int_t j = 1; j < boards->GetEntries(); j++)
875       {     
876         TObject *o = boards->At(j);
877       
878         if (!o) break;
879       
880         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
881       
882         if (board) 
883         {
884           //          L0 TRIGGER
885           if (board->Triggered())
886           {
887           
888             if (patt) {
889               cout << "                                   " << endl;
890               cout << "Local trigger board P A T T E R N :" << endl;
891               cout << "-----------------------------------" << endl;
892               cout << "                                   " << endl;
893               board->Pattern();
894               board->Scan("RESPF");
895             }
896
897             Int_t icirc    = board->GetNumber();
898             Int_t loStripX = board->GetStripX11();
899             Int_t loStripY = board->GetStripY11();
900             Int_t loDev    = board->GetDev();
901
902             UShort_t response = board->GetResponse();
903             Int_t loHpt = (response & 12) >> 2;
904             Int_t loLpt = response &  3;
905             /*
906             cout << "TriggerGUI done!" << endl;
907
908             cout << "Circuit = "  << icirc    << endl;
909             cout << "LoStripX = " << loStripX << endl;
910             cout << "LoStripY = " << loStripY << endl;
911             cout << "LoDev = "    << loDev    << endl;
912             cout                              << endl;
913             */
914             trigInfo[6*nlo+0] = icirc;
915             trigInfo[6*nlo+1] = loStripX;
916             trigInfo[6*nlo+2] = loStripY;
917             trigInfo[6*nlo+3] = loDev;
918
919             trigInfo[6*nlo+4] = loLpt;
920             trigInfo[6*nlo+5] = loHpt;
921
922             nlo++;
923
924           }
925         }
926       }
927     }
928   }
929
930   Reset();
931
932   return nlo;
933           
934 }
935