Separating run-dependent mapping data from data, which are not
[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 //-----------------------------------------------------------------------------
19 // Class AliMUONTriggerElectronics
20 //--------------------------------
21 // Manager class for muon trigger electronics
22 // Client of trigger board classes
23 // Debugged by Ph. Crochet & Ch. Finck
24 // Interfaced with new mapping Ch. Finck
25 //
26 // Author: Rachid Guernane (LPCCFd)
27 //-----------------------------------------------------------------------------
28
29 #include "AliLoader.h"
30 #include "AliLog.h"
31 #include "AliMUON.h" 
32 #include "AliMUONCalibrationData.h"
33 #include "AliMUONVDigit.h"
34 #include "AliMUONVDigitStore.h"
35 #include "AliMUONGlobalTrigger.h"
36 #include "AliMUONGlobalTriggerBoard.h"
37 #include "AliMUONLocalTrigger.h"
38 #include "AliMUONLocalTriggerBoard.h"
39 #include "AliMUONRegionalTrigger.h"
40 #include "AliMUONRegionalTriggerBoard.h"
41 #include "AliMUONTriggerCrate.h"
42 #include "AliMUONTriggerCrateStore.h"
43 #include "AliMUONTriggerElectronics.h"
44 #include "AliMUONTriggerCrateConfig.h"
45 #include "AliMUONRegionalTriggerConfig.h"
46 #include "AliMUONGlobalCrateConfig.h"
47 #include "AliMUONVTriggerStore.h"
48 #include "AliMUONVCalibParam.h"
49 #include "AliMpCathodType.h"
50 #include "AliMpDEManager.h"
51 #include "AliMpSegmentation.h"
52 #include "AliMpVSegmentation.h"
53 #include "AliMpCathodType.h"
54 #include "AliMpTriggerCrate.h"
55 #include "AliMpLocalBoard.h"
56 #include "AliMpDDLStore.h"
57 #include "AliMpExMap.h"
58 #include "AliMpIntPair.h"
59
60 #include "AliLog.h"
61 #include "AliLoader.h"
62 #include "AliRun.h"
63 #include <TBits.h>
64 #include <TSystem.h>
65
66
67 /// \cond CLASSIMP
68 ClassImp(AliMUONTriggerElectronics)
69 /// \endcond
70
71 //___________________________________________
72 AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONCalibrationData* calibData) 
73 : TObject(),
74   fCrates(new AliMUONTriggerCrateStore),
75   fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard)
76 {
77  /// CONSTRUCTOR
78 ///
79
80   for (Int_t i = 0; i < 2; ++i) {
81     fCopyXInput[i] = new TList();
82     fCopyXInput[i]->SetOwner();
83     fCopyYInput[i] = new TList();
84     fCopyYInput[i]->SetOwner();
85   }
86
87   SetCopyInput();
88   
89   Factory(calibData);
90   LoadMasks(calibData); 
91 }
92
93 //___________________________________________
94 AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
95 {
96 /// DESTRUCTOR
97 ///
98   delete fGlobalTriggerBoard;
99   delete fCrates;
100   for (Int_t i = 0; i < 2; ++i) {
101     delete fCopyXInput[i];
102     delete fCopyYInput[i];
103   }
104
105 }
106
107 //___________________________________________
108 void AliMUONTriggerElectronics::SetCopyInput()
109 {  
110   /// set list of copy input
111   
112     for (Int_t iDDL = 0; iDDL < 2; ++iDDL) { 
113     
114       for(Int_t iReg = 0; iReg < 8; ++iReg){   //reg loop
115       
116         AliMpTriggerCrate* crateMapping = AliMpDDLStore::Instance()->GetTriggerCrate(iDDL, iReg);
117       
118         for(Int_t iLocal = 0; iLocal < crateMapping->GetNofLocalBoards(); ++iLocal) { 
119         
120           Int_t localBoardFromId = crateMapping->GetLocalBoardId(iLocal);
121           if (!localBoardFromId) continue; //empty slot, should not happen
122         
123           AliMpLocalBoard* localBoardFrom = AliMpDDLStore::Instance()->GetLocalBoard(localBoardFromId);
124           Int_t localBoardToId;
125           if ((localBoardToId = localBoardFrom->GetInputXto())) {
126               AliMpLocalBoard* localBoardTo = AliMpDDLStore::Instance()->GetLocalBoard(localBoardToId);
127               TString crateFrom = localBoardFrom->GetCrate();
128               Int_t   slotFrom  = localBoardFrom->GetSlot();
129               TString crateTo   = localBoardTo->GetCrate();
130               Int_t   slotTo    = localBoardTo->GetSlot();
131           
132               fCopyXInput[0]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateFrom), slotFrom));
133               fCopyXInput[1]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateTo), slotTo));
134               AliDebug(3, Form("copy xInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
135                                crateTo.Data(), slotTo));
136           }
137         
138           if ((localBoardToId = localBoardFrom->GetInputYto())) {
139               AliMpLocalBoard* localBoardTo = AliMpDDLStore::Instance()->GetLocalBoard(localBoardToId);
140               TString crateFrom = localBoardFrom->GetCrate();
141               Int_t   slotFrom  = localBoardFrom->GetSlot();
142               TString crateTo   = localBoardTo->GetCrate();
143               Int_t   slotTo    = localBoardTo->GetSlot();
144           
145               fCopyYInput[0]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateFrom), slotFrom));
146               fCopyYInput[1]->Add(new AliMpIntPair(AliMpExMap::GetIndex(crateTo), slotTo));
147               AliDebug(3, Form("copy yInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
148                                crateTo.Data(), slotTo));
149           
150           }
151  
152         }
153       }
154     }
155 }
156
157 //___________________________________________
158 void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
159 {  
160  /// BUILD ALL ELECTRONICS
161  ///
162
163     fCrates->ReadFromFile(calibData);
164 }
165
166 //___________________________________________
167 void AliMUONTriggerElectronics::Feed(const AliMUONVDigitStore& digitStore)
168 {
169   /// FILL INPUTS
170   ///
171   
172   TIter next(digitStore.CreateTriggerIterator());
173   AliMUONVDigit* mdig;
174   
175   while ( ( mdig = static_cast<AliMUONVDigit*>(next()) ) )
176   {      
177     //       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
178     //                  for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
179     Int_t ichamber = AliMpDEManager::GetChamberId(mdig->DetElemId());
180     Int_t schg = (Int_t)(mdig->Charge() + 0.5);
181     
182     //       APPLY CONDITION ON SOFT BACKGROUND 
183     Int_t tchg = schg - (Int_t(schg/10))*10;    
184     
185     if (schg<=10 || tchg>0) 
186     {
187       Int_t detElemId  = mdig->DetElemId();
188       Int_t cathode    = mdig->Cathode();
189     
190       const AliMpVSegmentation* seg = 
191           AliMpSegmentation::Instance()
192           ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));
193   
194       Int_t ix = mdig->PadX(), iy = mdig->PadY();
195       
196       AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
197
198       AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
199       
200       for (Int_t i=0; i<pad.GetNofLocations(); i++) 
201       {
202         AliMpIntPair location = pad.GetLocation(i);
203         
204         Int_t nboard = location.GetFirst();
205         
206         Int_t ibitxy = location.GetSecond();
207         
208         AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
209         
210         if (b) 
211         {
212           if (cathode && b->GetSwitch(6)) ibitxy += 8;
213           
214           b->SetbitM(ibitxy,cathode,ichamber-10);
215         }
216         else
217         {
218           AliError(Form("Could not get local board number %d",b->GetNumber()));
219         }
220       }
221     }           
222   }
223
224   // Particular case of the columns with 22 local boards (2R(L) 3R(L))   
225   // fill copy input from mapping instead of hardcoded valued (Ch.F)
226   AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;
227
228   for (Int_t i = 0; i < fCopyXInput[0]->GetEntries(); ++i) 
229   {
230     AliMpIntPair* pair = (AliMpIntPair*)fCopyXInput[0]->At(i);
231     TString crateFrom  =  AliMpExMap::GetString(pair->GetFirst());
232     Int_t   slotFrom   =  pair->GetSecond();
233
234     pair = (AliMpIntPair*)fCopyXInput[1]->At(i);
235     TString crateTo  =  AliMpExMap::GetString(pair->GetFirst());
236     Int_t   slotTo   =  pair->GetSecond();
237
238     AliDebug(3, Form("copy xInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
239                      crateTo.Data(), slotTo));
240
241     UShort_t cX[2];
242     crate = fCrates->Crate(crateFrom); 
243     bs = crate->Boards();
244     AliMUONLocalTriggerBoard *fromxb = (AliMUONLocalTriggerBoard*)bs->At(slotFrom);
245     crate = fCrates->Crate(crateTo); 
246     bs = crate->Boards();
247     AliMUONLocalTriggerBoard *desxb = (AliMUONLocalTriggerBoard*)bs->At(slotTo);
248     fromxb->GetX34(cX); desxb->SetX34(cX);
249
250
251   }
252
253   for (Int_t i = 0; i < fCopyYInput[0]->GetEntries(); ++i) 
254   {
255     AliMpIntPair* pair = (AliMpIntPair*)fCopyYInput[0]->At(i);
256     TString crateFrom  =  AliMpExMap::GetString(pair->GetFirst());
257     Int_t   slotFrom   =  pair->GetSecond();
258
259     pair = (AliMpIntPair*)fCopyYInput[1]->At(i);
260     TString crateTo  =  AliMpExMap::GetString(pair->GetFirst());
261     Int_t   slotTo   =  pair->GetSecond();
262
263     AliDebug(3, Form("copy yInputs from local  %s_%d to %s_%d\n", crateFrom.Data(), slotFrom, 
264                      crateTo.Data(), slotTo));
265
266     UShort_t cY[4];
267     crate = fCrates->Crate(crateFrom); 
268     bs = crate->Boards();
269     AliMUONLocalTriggerBoard *fromyb = (AliMUONLocalTriggerBoard*)bs->At(slotFrom);
270     crate = fCrates->Crate(crateTo); 
271     bs = crate->Boards();
272     AliMUONLocalTriggerBoard *desyb = (AliMUONLocalTriggerBoard*)bs->At(slotTo);
273     fromyb->GetY(cY); desyb->SetY(cY);
274   }
275   
276   // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
277   AliMUONTriggerCrate* cr;
278   TIter next2(fCrates->CreateCrateIterator());
279   
280   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next2()) ) )
281   {            
282     TObjArray *boards = cr->Boards();
283     
284     for (Int_t j = 1; j < boards->GetEntries()-1; j++)
285     {
286       TObject *o = boards->At(j);
287                         
288       if (!o) break;
289                         
290       AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
291                         
292       AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
293                         
294       UShort_t cXY[2][4];
295                         
296       if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
297                         
298       //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
299       if (j < boards->GetEntries()-2)  
300       {
301               AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
302                                 
303               currboard->GetXY(cXY); neighbour->SetXYD(cXY);
304               nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
305                                 
306               if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
307       }
308     }
309   }
310  
311 }
312
313
314 //___________________________________________
315 void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
316 {
317   /// FILL INPUTS
318   ///
319   AliMUONTriggerCrate* cr;
320   TIter next(fCrates->CreateCrateIterator());
321    
322    while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
323    {                 
324      TObjArray *boards = cr->Boards();
325      
326      for (Int_t j = 1; j < boards->GetEntries(); j++)
327      {
328        TObject *o = boards->At(j);
329        
330        if (!o) break;
331        
332        AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
333        
334        board->SetXY(pattern);
335      }
336    }
337 }
338
339 //___________________________________________
340 void AliMUONTriggerElectronics::DumpOS()
341 {
342 /// DUMP IN THE OLD WAY
343 ///
344    for (Int_t i= 0; i < 234;i++)
345    {
346       AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
347
348       if (board) board->Scan("ALL");
349    }
350 }
351
352 //___________________________________________
353 void AliMUONTriggerElectronics::Scan(Option_t *option)
354 {
355   /// SCAN
356   ///
357
358   AliMUONTriggerCrate* cr;
359   TIter next(fCrates->CreateCrateIterator());  
360   
361   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
362   {                
363     TObjArray *boards = cr->Boards();
364     
365     for (Int_t j = 0; j < boards->GetEntries(); j++)
366     {
367       TObject *o = boards->At(j);
368       
369       TString op = option;
370       
371       Bool_t cdtion = kFALSE;
372       
373       if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
374       if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
375       if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
376       
377       if (!o || !cdtion) continue;
378       
379       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
380       
381       board->Scan();
382     }
383   }
384 }
385
386 //___________________________________________
387 void AliMUONTriggerElectronics::Reset()
388 {
389   /// RESET
390   ///
391   
392    AliMUONTriggerCrate* cr;
393   TIter next(fCrates->CreateCrateIterator());
394    while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
395    {            
396       TObjArray *boards = cr->Boards();
397             
398       for (Int_t j=0; j<boards->GetEntries(); j++)
399       {     
400          AliMUONTriggerBoard *b = (AliMUONTriggerBoard*)boards->At(j);
401
402          if (b) b->Reset();
403       }
404    }
405 }
406
407
408 //_______________________________________________________________________
409 void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
410 {
411   /// Load mask from config in CDB 
412   
413   // Set mask
414   
415   AliMUONRegionalTriggerConfig* regionalConfig = calibData->RegionalTriggerConfig();
416   if (!regionalConfig)
417      AliWarning("No valid regional trigger configuration in CDB");
418
419   
420   AliMUONTriggerCrate* cr;
421   TIter next(fCrates->CreateCrateIterator());
422   
423   Int_t irb(0);
424   
425   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
426   {            
427     TObjArray *boards = cr->Boards();
428     
429     AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
430
431     AliMUONTriggerCrateConfig* crateConfig = regionalConfig->FindTriggerCrate(cr->GetName());
432     
433     if (!crateConfig)
434     {
435       AliError(Form("Crate %s not present in configuration !!!", cr->GetName()));
436       return;
437     }
438     
439     UShort_t rmask= crateConfig->GetMask();
440
441     regb->Mask(rmask);
442     
443     for (Int_t j = 1; j < boards->GetEntries(); j++)
444     {
445       AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(j);
446       
447       Int_t cardNumber = b->GetNumber();
448       
449       if (cardNumber) // interface board are not interested
450       {
451         AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
452         for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
453         {
454           UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
455           b->Mask(i,lmask);
456         }
457       }
458     }
459     ++irb;
460   }
461   
462    AliMUONGlobalCrateConfig * globalConfig = calibData->GlobalTriggerCrateConfig();
463   if (!globalConfig)
464      AliWarning("No valid trigger crate configuration in CDB");
465
466     UShort_t gmask = 0;
467     gmask = globalConfig->GetFirstDarcDisable();
468     fGlobalTriggerBoard->Mask(0,gmask);
469
470     gmask = globalConfig->GetSecondDarcDisable();
471     fGlobalTriggerBoard->Mask(1,gmask);
472 }
473
474 //___________________________________________
475 void AliMUONTriggerElectronics::LocalResponse()
476 {
477 /// Compute the response for local cards
478         
479   AliMUONTriggerCrate* cr;
480   TIter next(fCrates->CreateCrateIterator());
481   
482   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
483   {            
484     
485     TObjArray *boards = cr->Boards();
486     
487     AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
488     
489     UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
490   
491     for (Int_t j = 1; j < boards->GetEntries(); j++)
492     {     
493         TObject *o = boards->At(j);
494       
495         if (!o) break;
496       
497         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
498       
499         if (board) // check if empty slot
500         {
501           board->Response();
502                                 
503           UShort_t response = board->GetResponse();            
504         
505           // CRATE CONTAINING INTERFACE BOARD
506           if (board->GetNumber() == 0) // copy boards
507           {
508             if ( response != 0 ) 
509               AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
510                                           board->GetName(),j,cr->GetName()));
511             AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
512
513           }
514         
515           thisl[j-1] = response;
516         }
517       }
518     
519     regb->SetLocalResponse(thisl);
520   }
521 }
522
523 //___________________________________________
524 void AliMUONTriggerElectronics::RegionalResponse()
525 {
526   /// Compute the response for all regional cards.
527   AliMUONTriggerCrate* cr;
528   TIter next(fCrates->CreateCrateIterator());
529   
530   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next()) ) )
531   {            
532       TObjArray *boards = cr->Boards();
533
534       AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
535       
536       if (regb) 
537       {
538          regb->Response();
539       }  
540    }
541 }
542
543 //___________________________________________
544 void AliMUONTriggerElectronics::GlobalResponse()
545 {
546   /// Compute the global response
547
548   UShort_t regional[16];
549   
550   AliMUONTriggerCrate* cr;
551   Int_t irb(0);
552   
553   if ( !fCrates->NumberOfCrates() >= 16 ) 
554   {
555     AliFatal(Form("Something is wrong : too many crates %d",
556                   fCrates->NumberOfCrates()));
557   }
558
559   TIter next(fCrates->CreateCrateIterator());
560
561   while ( ( cr = static_cast<AliMUONTriggerCrate*>(next())))
562   {            
563     AliMUONTriggerBoard* rb = 
564       static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
565     regional[irb] = rb->GetResponse();
566     ++irb;
567   }
568   
569   fGlobalTriggerBoard->SetRegionalResponse(regional);
570   fGlobalTriggerBoard->Response();
571 }
572
573 //_______________________________________________________________________
574 void AliMUONTriggerElectronics::Digits2Trigger(const AliMUONVDigitStore& digitStore,
575                                                AliMUONVTriggerStore& triggerStore)
576 {
577   /// Main method to go from digits to trigger decision
578   AliMUONRegionalTrigger pRegTrig;
579   
580   triggerStore.Clear();
581   
582   // RUN THE FULL BEE CHAIN
583   Feed(digitStore);
584   LocalResponse();
585   RegionalResponse();      
586   GlobalResponse();
587   //    DumpOS();
588         
589   AliMUONTriggerCrate* cr;
590   AliMUONLocalTrigger localTrigger;
591   
592   // stored in right order
593   // do not used iterator order
594   
595   for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
596   {            
597     for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
598     {
599       cr = fCrates->Crate(iSide, iReg);     
600       TObjArray *boards = cr->Boards();
601       
602       UInt_t regInpLpt = 0;
603       UInt_t regInpHpt = 0;
604       
605       AliMUONRegionalTriggerBoard *regBoard = (AliMUONRegionalTriggerBoard*)boards->At(0);
606       
607       for (Int_t j = 1; j < boards->GetEntries(); j++)
608       {     
609         TObject *o = boards->At(j);
610         
611         if (!o) break;
612         
613         AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
614         
615         if (board) 
616         {
617           //          L0 TRIGGER
618           // pcrochet 181206: MOOD needs ALL boards
619           //      if (board->Triggered())
620           //      {
621           
622           Int_t icirc = board->GetNumber();
623           if (icirc != 0) { // pcrochet 181206: MOOD needs ALL boards
624             
625             localTrigger.SetLoCircuit(icirc);
626             localTrigger.SetLoStripX(board->GetStripX11());
627             localTrigger.SetLoDev(board->GetDev());
628             localTrigger.SetLoSdev(board->GetSdev());
629             localTrigger.SetLoTrigY(board->GetTrigY());
630             localTrigger.SetLoStripY(board->GetStripY11());
631             
632             //             SAVE LUT OUTPUT 
633             UShort_t response = board->GetResponse();
634             localTrigger.SetLoHpt((response & 12) >> 2);
635             localTrigger.SetLoLpt(response &  3);
636             
637             // calculates regional inputs from local for the moment
638             UInt_t hPt = (response >> 2) & 0x3;
639             UInt_t lPt =  response       & 0x3;
640             
641             regInpHpt |= hPt << (30 - (j-1)*2);
642             regInpLpt |= lPt << (30 - (j-1)*2);
643             
644             TBits rrr;
645             rrr.Set(6,&response);         
646             
647             //             SAVE BIT PATTERN
648             localTrigger.SetX1Pattern(board->GetXY(0,0));
649             localTrigger.SetX2Pattern(board->GetXY(0,1));
650             localTrigger.SetX3Pattern(board->GetXY(0,2));
651             localTrigger.SetX4Pattern(board->GetXY(0,3));
652             
653             localTrigger.SetY1Pattern(board->GetXY(1,0));
654             localTrigger.SetY2Pattern(board->GetXY(1,1));
655             localTrigger.SetY3Pattern(board->GetXY(1,2));
656             localTrigger.SetY4Pattern(board->GetXY(1,3));
657             
658             //             ADD A NEW LOCAL TRIGGER          
659             triggerStore.Add(localTrigger);  
660             
661           }
662           }
663         }
664       pRegTrig.SetId(iReg + 8*iSide);
665       pRegTrig.SetLocalOutput(regInpLpt, 0);
666       pRegTrig.SetLocalOutput(regInpHpt, 1);
667       pRegTrig.SetOutput(regBoard->GetResponse());
668       
669       triggerStore.Add(pRegTrig);  
670       }
671     }
672   
673   // GLOBAL TRIGGER INFORMATION
674   UShort_t global = fGlobalTriggerBoard->GetResponse();
675   
676   AliMUONGlobalTrigger globalTrigger;
677   
678   globalTrigger.SetFromGlobalResponse(global);
679   // ADD A LOCAL TRIGGER IN THE LIST 
680   triggerStore.SetGlobal(globalTrigger);
681   
682   // NOW RESET ELECTRONICS
683   Reset();
684 }