MUON/AliMUONTriggerDecisionV1.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 // This is AliMUONTriggerDecision adaped for the mapping with a patch
  19 // for triggerCircuit.
  20 // Will be replaced soon by new trigger architecture.
  21
  22 #include "AliMUONTriggerDecisionV1.h"
  23
  24 #include <TError.h>
  25 #include "AliMUONTriggerCircuit.h"
  26 #include "AliMUONTriggerConstants.h"
  27 #include "AliMUONTriggerLut.h"
  28 #include "AliMUON.h"
  29 #include "AliMUONDigit.h"
  30 #include "AliMUONConstants.h"
  31 #include "AliMUONGlobalTrigger.h"
  32 #include "AliMUONLocalTrigger.h"
  33 #include "AliRun.h"
  34 #include "AliRunLoader.h"
  35 #include "AliLoader.h"
  36 #include "AliLog.h"
  37
  38 //#include "AliMUONGeometrySegmentation.h"
  39 #include "AliMpTriggerSegmentation.h"
  40 #include "AliMUONSegmentation.h"
  41 #include "AliMpVSegmentation.h"
  42
  43
  44 // A note on debug level. Using AliLog facility, you can set the verbosity
  45 // of this class.
  46 //
  47 // DebugLevel =
  48 // 0 : don't print anything
  49 // 1 : print Global Trigger Output
  50 // 2 : print Local and Global Trigger Outputs
  51 // 3 : iprint = 2 + detailed info on X strips
  52 // 4 : iprint = 2 + detailed info on Y strip
  53 // 5 : iprint = 2 + detailed info on X and Y strips
  54 // Note : with DebugLevel>2, the strips detailed info is given for all circuits
  55
  56 //----------------------------------------------------------------------
  57 ClassImp(AliMUONTriggerDecisionV1)
  58
  59 //----------------------------------------------------------------------
  60 AliMUONTriggerDecisionV1::AliMUONTriggerDecisionV1(AliMUONData* data)
  61   : TTask("AliMUONTriggerDecisionV1",
  62           "From trigger digits to Local and Global Trigger objects (old style)"),
  63     fMUONData(data),
  64     fMUON(0x0),
  65     fTriggerCircuit(new TObjArray(AliMUONConstants::NTriggerCircuit()))
  66 {
  67   // Constructor
  68
  69   // initialize container
  70   if (fMUONData == 0)
  71   {
  72     AliFatal("No MUONdata for trigger");
  73   }
  74
  75   // Global Trigger information
  76   Int_t i;
  77   Int_t icirc;
  78   Int_t istrip;
  79
  80   for (i=0; i<3; i++)
  81   {   // [0] : Low pt, [1] : High pt, [2] : All pt
  82     fGlobalSinglePlus[i]=0;     // tot num of single plus
  83     fGlobalSingleMinus[i]=0;    // tot num of single minus
  84     fGlobalSingleUndef[i]=0;    // tot num of single undefined
  85     fGlobalPairUnlike[i]=0;     // tot num of unlike-sign pairs
  86     fGlobalPairLike[i]=0;       // tot num of like-sign pairs
  87   }
  88
  89   // Local Trigger information
  90   for (icirc=0; icirc<234; icirc++)
  91   {
  92     fTrigger[icirc]=0;                   // trigger or not
  93     fStripX11[icirc]=0;                   // X strip in MC11 which triggers
  94     fDev[icirc]=0;                        // deviation which triggers
  95     fStripY11[icirc]=0;                   // Y strip in MC11 which triggers
  96     for (i=0; i<2; i++)
  97     {           // pt information via LuT
  98       fLutLpt[icirc][i]=fLutHpt[icirc][i]=fLutApt[icirc][i]=0;
  99     }
 100   }
 101
 102   // bit pattern
 103   for (icirc=0; icirc<234; icirc++)
 104   {
 105     for (istrip=0; istrip<16; istrip++)
 106     {
 107       fXbit11[icirc][istrip]=fXbit12[icirc][istrip]=0;
 108       fYbit11[icirc][istrip]=fYbit12[icirc][istrip]=0;
 109       fYbit21[icirc][istrip]=fYbit22[icirc][istrip]=0;
 110       fYbit21U[icirc][istrip]=fYbit22U[icirc][istrip]=0;
 111       fYbit21D[icirc][istrip]=fYbit22D[icirc][istrip]=0;
 112     }
 113     for (istrip=0; istrip<32; istrip++)
 114     {
 115       fXbit21[icirc][istrip]=fXbit22[icirc][istrip]=0;
 116     }
 117   }
 118
 119
 120   // getting MUON
 121   fMUON = (AliMUON*) gAlice->GetDetector("MUON");
 122
 123   // setting circuit
 124   for (icirc = 0; icirc < AliMUONConstants::NTriggerCircuit(); icirc++)
 125   {
 126     AliMUONTriggerCircuit* pCir = 0;
 127     pCir = &(fMUON->TriggerCircuit(icirc));
 128     fTriggerCircuit->AddAt(pCir, icirc);
 129   }
 130 }
 131
 132 //----------------------------------------------------------------------
 133 AliMUONTriggerDecisionV1::AliMUONTriggerDecisionV1()
 134 : TTask("AliMUONTriggerDecisionV1",
 135         "From trigger digits to Local and Global Trigger objects (old style)"),
 136
 137     fTriggerCircuit(0),
 138     fMUONData(0),
 139     fMUON(0)
 140 {
 141 // Default constructor
 142 }
 143
 144 //----------------------------------------------------------------------
 145 AliMUONTriggerDecisionV1::AliMUONTriggerDecisionV1(const AliMUONTriggerDecisionV1& rhs)
 146     : TTask(rhs),
 147       fTriggerCircuit(rhs.fTriggerCircuit),
 148       fMUONData(rhs.fMUONData),
 149       fMUON(rhs.fMUON)
 150 {
 151 // Protected copy constructor
 152
 153   AliFatal("Not implemented.");
 154 }
 155
 156 //----------------------------------------------------------------------
 157 AliMUONTriggerDecisionV1::~AliMUONTriggerDecisionV1()
 158 {
 159 // Destructor
 160   if (fTriggerCircuit)
 161   {
 162     fTriggerCircuit->Clear();// Sets pointers to 0 since it is not the owner
 163     delete fTriggerCircuit;
 164   }
 165 }
 166
 167 //----------------------------------------------------------------------
 168 AliMUONTriggerDecisionV1&
 169 AliMUONTriggerDecisionV1::operator=(const AliMUONTriggerDecisionV1& rhs)
 170 {
 171 // Protected assignement operator
 172
 173   if (this == &rhs) return *this;
 174
 175   AliFatal("Not implemented.");
 176
 177   return *this;
 178 }
 179
 180
 181 //----------------------------------------------------------------------
 182 void AliMUONTriggerDecisionV1::Trigger()
 183 {
 184 // main method of the class which calls the overall Trigger procedure
 185
 186   ResetBit();
 187   SetBit();
 188   SetBitUpDownX();
 189   SetBitUpDownY();
 190
 191   Int_t coinc44=0, resetMid=0; // initialize coincidence
 192
 193   AliMUONTriggerCircuit* triggerCircuit;
 194
 195   for (Int_t icirc=0; icirc<234; icirc++)
 196   {
 197     // loop on circuits
 198     triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
 199
 200     Int_t minDevStrip[5], minDev[5], coordY[5];
 201     for (Int_t i=0; i<5; i++)
 202     {
 203       minDevStrip[i]=minDev[i]=coordY[i]=0;
 204     }
 205     Int_t x2m=triggerCircuit->GetX2m();
 206     Int_t x2ud=triggerCircuit->GetX2ud();
 207     Int_t orMud[2]={0,0};
 208     triggerCircuit->GetOrMud(orMud);
 209
 210     // call triggerX
 211     TrigX(fXbit11[icirc],fXbit12[icirc],fXbit21[icirc],fXbit22[icirc],
 212           coinc44, minDevStrip, minDev);
 213
 214     // call triggerY
 215     TrigY(fYbit11[icirc],fYbit12[icirc],fYbit21[icirc],fYbit22[icirc],
 216           fYbit21U[icirc],fYbit21D[icirc],fYbit22U[icirc],fYbit22D[icirc],
 217           x2m,x2ud,orMud,resetMid,coinc44,coordY);
 218
 219     // call LocalTrigger
 220     Int_t iTrigger=0;
 221     LocalTrigger(icirc, minDevStrip, minDev, coordY, iTrigger);
 222
 223     if (iTrigger==1)
 224     {
 225       StdoutToAliDebug(1,
 226                        PrintBitPatXInput(icirc);
 227                        PrintBitPatYInput(icirc);
 228                        PrintLocalOutput(minDevStrip, minDev, coordY););
 229     }
 230   }  //  end loop on circuits
 231
 232   // call Global Trigger
 233   GlobalTrigger();
 234 }
 235
 236 //----------------------------------------------------------------------
 237 void AliMUONTriggerDecisionV1::ResetBit()
 238 {
 239   // reset bit pattern, global and local trigger output tables to 0
 240
 241   Int_t i;
 242   Int_t icirc;
 243   Int_t istrip;
 244
 245   for (icirc=0; icirc<234; icirc++)
 246   {
 247     for (istrip=0; istrip<16; istrip++)
 248     {
 249       fXbit11[icirc][istrip]=fXbit12[icirc][istrip]=0;
 250       fYbit11[icirc][istrip]=fYbit12[icirc][istrip]=0;
 251       fYbit21[icirc][istrip]=fYbit22[icirc][istrip]=0;
 252       fYbit21U[icirc][istrip]=fYbit22U[icirc][istrip]=0;
 253       fYbit21D[icirc][istrip]=fYbit22D[icirc][istrip]=0;
 254     }
 255     for (istrip=0; istrip<32; istrip++)
 256     {
 257       fXbit21[icirc][istrip]=fXbit22[icirc][istrip]=0;
 258     }
 259   }
 260
 261   for (i=0; i<3; i++)
 262   {
 263     fGlobalSinglePlus[i]=0;
 264     fGlobalSingleMinus[i]=0;
 265     fGlobalSingleUndef[i]=0;
 266     fGlobalPairLike[i]=0;
 267     fGlobalPairLike[i]=0;
 268   }
 269
 270   for (icirc=0; icirc<234; icirc++)
 271   {
 272     fTrigger[icirc]=0;
 273     fStripX11[icirc]=0;
 274     fDev[icirc]=0;
 275     fStripY11[icirc]=0;
 276     for (i=0; i<2; i++)
 277     {
 278       fLutLpt[icirc][i]=fLutHpt[icirc][i]=fLutApt[icirc][i]=0;
 279     }
 280   }
 281 }
 282
 283 //----------------------------------------------------------------------
 284 void AliMUONTriggerDecisionV1::SetBit()
 285 {
 286     // 1) loop over chambers and cathodes
 287     // 2) load digits
 288     // 3) remove soft background
 289     // 4) set the bit patterns
 290
 291     Int_t cathode;
 292     AliMUONTriggerCircuit* triggerCircuit;
 293
 294     for (Int_t chamber = 11; chamber < 15; ++chamber)
 295     {
 296
 297         TClonesArray* muonDigits = fMUONData->Digits(chamber-1);
 298         Int_t ndigits = muonDigits->GetEntriesFast();
 299         AliDebug(3,Form("Found %d digits in %p %d", ndigits, muonDigits,chamber-1));
 300
 301         for (Int_t digit = 0; digit < ndigits; ++digit)
 302         {
 303             AliMUONDigit* mdig  = static_cast<AliMUONDigit*>
 304                 (muonDigits->UncheckedAt(digit));
 305
 306             // get the center of the pad Id
 307             Int_t ix=mdig->PadX();
 308             Int_t iy=mdig->PadY();
 309             Int_t detElemId=mdig->DetElemId();
 310 //      cathode = mdig->Cathode() + 1;
 311             cathode = mdig->Cathode();
 312
 313             const AliMpVSegmentation* seg =
 314                 fMUON->GetSegmentation()->GetMpSegmentation(detElemId,cathode);
 315             AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
 316
 317             AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
 318
 319 //      pad.Print();
 320
 321             // get the sum of the coded charge
 322             // see coding convention in AliMUONChamberTrigger::DisIntegration
 323             Int_t sumCharge = mdig->Signal();
 324
 325             // apply condition on soft background
 326             Int_t testCharge=sumCharge-(Int_t(sumCharge/10))*10;
 327
 328             if(sumCharge<=10||testCharge>0)
 329             {
 330                 Int_t icirc;
 331
 332                 // FIXME: if it works like this, rename digitindex to digit simply...
 333                 Int_t digitindex = digit;
 334
 335                 if (cathode==0) {
 336                     for (Int_t i=0; i<pad.GetNofLocations(); i++) {
 337                         AliMpIntPair location = pad.GetLocation(i);
 338                         icirc=Board2Circuit(location.GetFirst()-1);
 339                         triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
 340                         DigitFiredCircuit(icirc, cathode, chamber-1, digitindex);
 341                         switch (chamber) {
 342                         case 11:
 343                             fXbit11[icirc][location.GetSecond()]=1;
 344                             break;
 345                         case 12:
 346                             fXbit12[icirc][location.GetSecond()]=1;
 347                             break;
 348                         case 13:
 349                             fXbit21[icirc][location.GetSecond()+8]=1;
 350                             break;
 351                         case 14:
 352                             fXbit22[icirc][location.GetSecond()+8]=1;
 353                             break;
 354                         }
 355                     } // end of loop on locations
 356
 357                 } else {                // Y plane
 358                     for (Int_t i=0; i<pad.GetNofLocations(); i++) {
 359                         AliMpIntPair location = pad.GetLocation(i);
 360                         icirc=Board2Circuit(location.GetFirst()-1);
 361                         triggerCircuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
 362
 363                         switch (chamber) {
 364                         case 11:
 365                             fYbit11[icirc][location.GetSecond()]=1;
 366                             break;
 367                         case 12:
 368                             fYbit12[icirc][location.GetSecond()]=1;
 369                             break;
 370                         case 13:
 371                             fYbit21[icirc][location.GetSecond()]=1;
 372                             break;
 373                         case 14:
 374                             fYbit22[icirc][location.GetSecond()]=1;
 375                             break;
 376                         }
 377                     } // end of loop on locations
 378                 } // end of condition on cathode
 379             }  // remove soft background
 380         }   // end loop on digit
 381     }     // end loop on chamber
 382 }
 383
 384 //----------------------------------------------------------------------
 385 void AliMUONTriggerDecisionV1::SetBitUpDownX()
 386 {
 387 // Set X bit for up and down part of circuits
 388   Int_t idModule, nStripX, nStripY, iPosCircuit;
 389   Int_t idCirc,iCircD,idCircD,iCircU,idCircU;
 390
 391
 392   for (Int_t iCirc=0; iCirc<234; iCirc++)
 393   {
 394
 395     AliMUONTriggerCircuit* circuit;   // current circuit
 396     AliMUONTriggerCircuit* circuitD;  // circuit Down
 397     AliMUONTriggerCircuit* circuitU;  // circuit Up
 398
 399     circuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(iCirc);
 400     idModule=circuit->GetIdModule();      // corresponding module Id.
 401     nStripX=circuit->GetNstripX();        // number of X strips
 402     nStripY=circuit->GetNstripY();        // number of Y strips
 403     iPosCircuit=circuit->GetPosCircuit(); // position of circuit in module
 404     idCirc=circuit->GetIdCircuit();
 405
 406     // fill lower part
 407     if (iPosCircuit==1)
 408     {               // need to scan lower module
 409         if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91)
 410         {
 411 // cp temporary trick
 412             iCircD=circuit->GetICircuitD(); // first circuit in module down
 413             Int_t sign=TMath::Abs(idModule)/idModule;
 414             Int_t idModuleD=sign*(TMath::Abs(idModule)+10);  // lower module Id
 415             Int_t nstripx=AliMUONTriggerConstants::NstripX(ModuleNumber(idModuleD)); // and its number of strips
 416             Int_t ioffset=0;
 417             if (nstripx==32) {
 418                 ioffset = 1;
 419             } else if (nstripx==48) {
 420                 ioffset = 2;
 421             } else if (nstripx==64) {
 422                 ioffset = 3;
 423             }
 424             iCircD = iCircD + ioffset;
 425
 426             circuitD = (AliMUONTriggerCircuit*)fTriggerCircuit->At(iCircD);
 427             idCircD=circuitD->GetIdCircuit();
 428 // cp temporary trick
 429             for (Int_t istrip=0; istrip<8; istrip++)
 430             {
 431                 if (fXbit21[iCircD][istrip+16]==1) fXbit21[iCirc][istrip]=1;
 432                 if (fXbit22[iCircD][istrip+16]==1) fXbit22[iCirc][istrip]=1;
 433             }
 434         }
 435
 436     } else
 437     {                         // lower strips within same module
 438         if (idCirc>0) {
 439             idCircD=idCirc-1;
 440         } else {
 441             idCircD=idCirc+1;
 442         }
 443         iCircD=CircuitNumber(idCircD);
 444
 445         for (Int_t istrip=0; istrip<8; istrip++)
 446         {
 447             if (fXbit21[iCircD][istrip+16]==1) fXbit21[iCirc][istrip]=1;
 448             if (fXbit22[iCircD][istrip+16]==1) fXbit22[iCirc][istrip]=1;
 449         }
 450     }
 451
 452     // fill upper part
 453     if ( (iPosCircuit==1&&nStripX==16)||(iPosCircuit==2&&nStripX==32)||
 454          (iPosCircuit==3&&nStripX==48)||(iPosCircuit==4&&nStripX==64))
 455     {
 456         if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61)
 457         {                    // need to scan upper module
 458             Int_t iCircU=circuit->GetICircuitU();
 459             circuitU = (AliMUONTriggerCircuit*)fTriggerCircuit->At(iCircU);
 460
 461             for (Int_t istrip=24; istrip<32; istrip++)
 462             {
 463                 if (fXbit21[iCircU][istrip-16]==1) fXbit21[iCirc][istrip]=1;
 464                 if (fXbit22[iCircU][istrip-16]==1) fXbit22[iCirc][istrip]=1;
 465             }
 466         }
 467
 468     } else
 469     {                       // upper strips within same module
 470 //      idCirc=circuit->GetIdCircuit();
 471         if (idCirc>0) {
 472             idCircU=idCirc+1;
 473         } else {
 474             idCircU=idCirc-1;
 475         }
 476         iCircU=CircuitNumber(idCircU);
 477         for (Int_t istrip=24; istrip<32; istrip++)
 478         {
 479             if (fXbit21[iCircU][istrip-16]==1) fXbit21[iCirc][istrip]=1;
 480             if (fXbit22[iCircU][istrip-16]==1) fXbit22[iCirc][istrip]=1;
 481         }
 482     }
 483   } // loop on circuit
 484
 485 }
 486
 487 //----------------------------------------------------------------------
 488 void AliMUONTriggerDecisionV1::SetBitUpDownY(){
 489 // Set Y bit for up and down parts of circuits
 490   Int_t idModule, nStripX, nStripY, iPosCircuit;
 491
 492
 493   for (Int_t icirc=0; icirc<234; icirc++) {
 494
 495     AliMUONTriggerCircuit* circuit;   // current circuit
 496     AliMUONTriggerCircuit* circuitD;  // circuit Down
 497     AliMUONTriggerCircuit* circuitU;  // circuit Up
 498
 499     circuit = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icirc);
 500     idModule=circuit->GetIdModule();      // corresponding module Id.
 501     nStripX=circuit->GetNstripX();        // number of X strips
 502     nStripY=circuit->GetNstripY();        // number of Y strips
 503     iPosCircuit=circuit->GetPosCircuit(); // position of circuit in module
 504
 505 // fill lower part
 506     if (iPosCircuit==1) {               // need to scan lower module
 507       if(idModule<91&&TMath::Abs(idModule)!=41&&idModule>-91) {
 508         Int_t icircD=circuit->GetICircuitD();
 509         circuitD = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icircD);
 510         Int_t nStripD=circuitD->GetNstripY();
 511
 512         if (TMath::Abs(idModule)==42) { // shift of +8 bits
 513           for (Int_t istrip=0; istrip<nStripD; istrip++) {
 514             fYbit21D[icirc][istrip+8]=fYbit21[icircD][istrip];
 515             fYbit22D[icirc][istrip+8]=fYbit22[icircD][istrip];
 516           }
 517         } else if (TMath::Abs(idModule)==52) { // shift of -8 bits
 518           for (Int_t istrip=0; istrip<nStripD; istrip++) {
 519             fYbit21D[icirc][istrip]=fYbit21[icircD][istrip+8];
 520             fYbit22D[icirc][istrip]=fYbit22[icircD][istrip+8];
 521           }
 522         } else {
 523           for (Int_t istrip=0; istrip<nStripD; istrip++) {
 524             fYbit21D[icirc][istrip]=fYbit21[icircD][istrip];
 525             fYbit22D[icirc][istrip]=fYbit22[icircD][istrip];
 526           }
 527         }
 528       }
 529     } else {                         // lower strips within same module
 530       for (Int_t istrip=0; istrip<nStripY; istrip++) {
 531         fYbit21D[icirc][istrip]=fYbit21[icirc][istrip];
 532         fYbit22D[icirc][istrip]=fYbit22[icirc][istrip];
 533       }
 534     }
 535
 536 // fill upper part
 537     if ((iPosCircuit==1&&nStripX==16)||(iPosCircuit==2&&nStripX==32)||
 538         (iPosCircuit==3&&nStripX==48)||(iPosCircuit==4&&nStripX==64)) {
 539       if ((idModule>17||idModule<-17)&&TMath::Abs(idModule)!=61) {
 540         Int_t icircU=circuit->GetICircuitU();
 541         circuitU = (AliMUONTriggerCircuit*)fTriggerCircuit->At(icircU);
 542         Int_t nStripU=circuitU->GetNstripY();
 543
 544         if (TMath::Abs(idModule)==62) { // shift of +8 bits
 545           for (Int_t istrip=0; istrip<nStripU; istrip++) {
 546             fYbit21U[icirc][istrip+8]=fYbit21[icircU][istrip];
 547             fYbit22U[icirc][istrip+8]=fYbit22[icircU][istrip];
 548           }
 549         } else if (TMath::Abs(idModule)==52) { // shift of -8 bits
 550           for (Int_t istrip=0; istrip<nStripU; istrip++) {
 551             fYbit21U[icirc][istrip]=fYbit21[icircU][istrip+8];
 552             fYbit22U[icirc][istrip]=fYbit22[icircU][istrip+8];
 553           }
 554         } else {
 555           for (Int_t istrip=0; istrip<nStripU; istrip++) {
 556             fYbit21U[icirc][istrip]=fYbit21[icircU][istrip];
 557             fYbit22U[icirc][istrip]=fYbit22[icircU][istrip];
 558           }
 559         }
 560       }
 561     } else {                       // upper strips within same module
 562       for (Int_t istrip=0; istrip<nStripY; istrip++) {
 563         fYbit21U[icirc][istrip]=fYbit21[icirc][istrip];
 564         fYbit22U[icirc][istrip]=fYbit22[icirc][istrip];
 565       }
 566     }
 567   } // loop on circuit
 568 }
 569
 570
 571 //----------------------------------------------------------------------
 572 // x part of trigger Algo
 573 //----------------------------------------------------------------------
 574 //----------------------------------------------------------------------
 575 void AliMUONTriggerDecisionV1::TrigX(Int_t ch1q[16], Int_t ch2q[16],
 576                                    Int_t ch3q[32], Int_t ch4q[32],
 577                                    Int_t coinc44, Int_t minDevStrip[5],
 578                                    Int_t minDev[5]){
 579 // note : coinc44 = flag 0 or 1 (0 coincidence -> 3/4, 1 coincidence -> 4/4)
 580 //---------------------------------------------------------
 581 // step # 1 : declustering, reduction DS, calculate sgle & dble
 582 //---------------------------------------------------------
 583   Int_t ch1e[19], ch2e[20], ch3e[35], ch4e[36];
 584   Int_t sgleHit1[31], sgleHit2[63];
 585   Int_t dbleHit1[31], dbleHit2[63];
 586
 587   Int_t i;
 588   Int_t j;
 589
 590   for (i=0; i<31; i++)
 591   {
 592     sgleHit1[i]=0;
 593     dbleHit1[i]=0;
 594   }
 595   for (i=0; i<63; i++)
 596   {
 597     sgleHit2[i]=0;
 598     dbleHit2[i]=0;
 599   }
 600
 601 //--- inititialize che using chq
 602   for (i=0; i<19; i++)
 603   {
 604     if (i<1||i>16)  ch1e[i]=0;
 605     else            ch1e[i]=ch1q[i-1];
 606   }
 607   for (i=0; i<20; i++)
 608   {
 609     if (i<2||i>17) ch2e[i]=0;
 610     else           ch2e[i]=ch2q[i-2];
 611   }
 612   for (i=0; i<35; i++)
 613   {
 614     if (i<1||i>32) ch3e[i]=0;
 615     else           ch3e[i]=ch3q[i-1];
 616   }
 617   for (i=0; i<36; i++)
 618   {
 619     if (i<2||i>33) ch4e[i]=0;
 620     else           ch4e[i]=ch4q[i-2];
 621   }
 622
 623
 624 //--- calculate dble & sgle first station
 625   for (i=0; i<=15; i++)
 626   {
 627     sgleHit1[2*i] = (!ch1e[i+1]|(ch1e[i]^ch1e[i+2])) &
 628       (!ch2e[i+2] | (ch2e[i+1]^ch2e[i+3]));
 629
 630     dbleHit1[2*i] = ch1e[i+1]&!(ch1e[i+2]^ch1e[i]) &
 631       (ch2e[i+2] | (!ch2e[i]&ch2e[i+1]) | (ch2e[i+3]&!ch2e[i+4]));
 632   }
 633
 634   for (i=0; i<=14; i++)
 635   {
 636     sgleHit1[2*i+1] = (!ch1e[i+1]|!ch1e[i+2]|(ch1e[i]^ch1e[i+3])) &
 637       (!ch2e[i+2] | !ch2e[i+3] | (ch2e[i+1]^ch2e[i+4]));
 638     dbleHit1[2*i+1] = ch1e[i+1]&ch1e[i+2]&!(ch1e[i]^ch1e[i+3]) &
 639       (ch2e[i+2]&(!ch2e[i+1]|!ch2e[i]) |
 640               ch2e[i+3]&(ch2e[i+2]|!ch2e[i+4]|!ch2e[i+5]));
 641   }
 642
 643 //--- calculate dble & sgle second station
 644   for (i=0; i<=31; i++)
 645   {
 646     sgleHit2[2*i] = (!ch3e[i+1]|(ch3e[i]^ch3e[i+2])) &
 647       (!ch4e[i+2] | (ch4e[i+1]^ch4e[i+3]));
 648     dbleHit2[2*i] = ch3e[i+1]&!(ch3e[i+2]^ch3e[i]) &
 649       (ch4e[i+2] | (!ch4e[i]&ch4e[i+1]) | (ch4e[i+3]&!ch4e[i+4]));
 650   }
 651
 652   for (i=0; i<=30; i++)
 653   {
 654     sgleHit2[2*i+1] = (!ch3e[i+1]|!ch3e[i+2]|(ch3e[i]^ch3e[i+3])) &
 655       (!ch4e[i+2] | !ch4e[i+3] | (ch4e[i+1]^ch4e[i+4]));
 656     dbleHit2[2*i+1] = ch3e[i+1]&ch3e[i+2]&!(ch3e[i]^ch3e[i+3]) &
 657       (ch4e[i+2]&(!ch4e[i+1]|!ch4e[i]) |
 658        ch4e[i+3]&(ch4e[i+2]|!ch4e[i+4]|!ch4e[i+5]));
 659   }
 660
 661 //---
 662   /* FIXME : use AliLog here...
 663
 664   if(fDebug==3||fDebug==5)
 665   {
 666     printf("===============================================================\n");
 667     printf(" X plane after sgle and dble \n");
 668     printf("                       0987654321098765432109876543210");
 669     printf("\n SGLE1                 ");
 670     for (istrip=30; istrip>=0; istrip--) printf("%i",(!sgleHit1[istrip]));
 671     printf("\n DBLE1                 ");
 672     for (istrip=30; istrip>=0; istrip--) printf("%i",dbleHit1[istrip]);
 673     printf("\n SGLE2 ");
 674     for (istrip=62; istrip>=0; istrip--) printf("%i",(!sgleHit2[istrip]));
 675     printf("\n DBLE2 ");
 676     for (istrip=62; istrip>=0; istrip--) printf("%i",dbleHit2[istrip]);
 677     printf("\n       210987654321098765432109876543210987654321098765432109876543210\n");
 678   }
 679   */
 680
 681 //---------------------------------------------------------
 682 // step # 2 : coincidence 3/4
 683 //---------------------------------------------------------
 684   Int_t rearImage[31][31];
 685   for (i=0; i<31; i++)
 686   {
 687     for (j=0; j<31; j++)
 688     {
 689       rearImage[i][j]=0;
 690     }
 691   }
 692
 693  Int_t notOr1=!dbleHit1[30] & !dbleHit1[29] & !dbleHit1[28] & !dbleHit1[27] &
 694  !dbleHit1[26] & !dbleHit1[25] & !dbleHit1[24] & !dbleHit1[23] &
 695  !dbleHit1[22] & !dbleHit1[21] & !dbleHit1[20] & !dbleHit1[19] &
 696  !dbleHit1[18] & !dbleHit1[17] & !dbleHit1[16] & !dbleHit1[15] &
 697  !dbleHit1[14] & !dbleHit1[13] & !dbleHit1[12] & !dbleHit1[11] &
 698  !dbleHit1[10] & !dbleHit1[9]  & !dbleHit1[8]  & !dbleHit1[7]  &
 699  !dbleHit1[6]  & !dbleHit1[5]  & !dbleHit1[4]  & !dbleHit1[3]  &
 700  !dbleHit1[2]  & !dbleHit1[1]  & !dbleHit1[0]  & !coinc44;
 701
 702  Int_t notOr2= !dbleHit2[62] & !dbleHit2[61] & !dbleHit2[60] & !dbleHit2[59] &
 703  !dbleHit2[58] & !dbleHit2[57] & !dbleHit2[56] & !dbleHit2[55] &
 704  !dbleHit2[54] & !dbleHit2[53] & !dbleHit2[52] & !dbleHit2[51] &
 705  !dbleHit2[50] & !dbleHit2[49] & !dbleHit2[48] & !dbleHit2[47] &
 706  !dbleHit2[46] & !dbleHit2[45] & !dbleHit2[44] & !dbleHit2[43] &
 707  !dbleHit2[42] & !dbleHit2[41] & !dbleHit2[40] & !dbleHit2[39] &
 708  !dbleHit2[38] & !dbleHit2[37] & !dbleHit2[36] & !dbleHit2[35] &
 709  !dbleHit2[34] & !dbleHit2[33] & !dbleHit2[32] & !dbleHit2[31] &
 710  !dbleHit2[30] & !dbleHit2[29] & !dbleHit2[28] & !dbleHit2[27] &
 711  !dbleHit2[26] & !dbleHit2[25] & !dbleHit2[24] & !dbleHit2[23] &
 712  !dbleHit2[22] & !dbleHit2[21] & !dbleHit2[20] & !dbleHit2[19] &
 713  !dbleHit2[18] & !dbleHit2[17] & !dbleHit2[16] & !dbleHit2[15] &
 714  !dbleHit2[14] & !dbleHit2[13] & !dbleHit2[12] & !dbleHit2[11] &
 715  !dbleHit2[10] & !dbleHit2[9]  & !dbleHit2[8]  & !dbleHit2[7]  &
 716  !dbleHit2[6]  & !dbleHit2[5]  & !dbleHit2[4]  & !dbleHit2[3]  &
 717  !dbleHit2[2]  & !dbleHit2[1]  & !dbleHit2[0]  & !coinc44;
 718
 719 // DS reduction
 720  for (i=0; i<31; i++)
 721  {
 722    sgleHit1[i] = !sgleHit1[i]&notOr1;
 723  }
 724  for (i=0; i<63; i++)
 725  {
 726    sgleHit2[i] = !sgleHit2[i]&notOr2;
 727  }
 728
 729 // extract rearImage
 730  for (i=0; i<31; i++)
 731  {
 732    Int_t tmpSgleHit2[31];
 733    Int_t tmpDbleHit2[31];
 734    for (j=0; j<31; j++)
 735    {
 736      tmpSgleHit2[j] = sgleHit2[i+j+1];
 737      tmpDbleHit2[j] = dbleHit2[i+j+1];
 738    }
 739
 740    for (Int_t k=0; k<31; k++)
 741    {
 742      rearImage[i][k]=(sgleHit1[i]&tmpDbleHit2[k])|
 743        (dbleHit1[i]&(tmpSgleHit2[k]|tmpDbleHit2[k]));
 744    }
 745  }
 746
 747   //-----------
 748  /* FIXME: use AliLog here
 749  if(fDebug==3||fDebug==5) {
 750    printf("===============================================================\n");
 751    for (i=30; i>=0; i--)
 752    {
 753    printf("%i \t",i);
 754    for (istrip=31; istrip>=0; istrip--) printf("%i",rearImage[i][istrip]);
 755    printf("\n");
 756    }
 757  }
 758 */
 759
 760 //---------------------------------------------------------
 761 // step # 3 : calculate deviation
 762 //---------------------------------------------------------
 763  Int_t dev[31][6];
 764  for (i=0; i<31; i++)
 765  {
 766    for (j=0; j<6; j++)
 767    {
 768      dev[i][j]=0;
 769    }
 770  }
 771
 772  for (i=0; i<31; i++)
 773  {
 774    Int_t leftDev[5], rightDev[5];
 775    Int_t orL1, andL1, andL2, orR1, orR2, andR1, andR2, andR3;
 776
 777 // calculate Left deviation
 778  orL1=rearImage[i][16]|rearImage[i][18]|rearImage[i][20]|rearImage[i][22];
 779  andL1=!rearImage[i][17]&!rearImage[i][19]&!rearImage[i][21] & !orL1;
 780  andL2=!rearImage[i][23]&!rearImage[i][24]&!rearImage[i][25]&!rearImage[i][26];
 781
 782  leftDev[0] = (rearImage[i][16]|!rearImage[i][17]) &
 783  (rearImage[i][16]|rearImage[i][18]|!rearImage[i][19]&
 784  (rearImage[i][20]|!rearImage[i][21])) &
 785  (orL1|!rearImage[i][23]&(rearImage[i][24]|!rearImage[i][25])) &
 786  (orL1|rearImage[i][24]|rearImage[i][26]|!rearImage[i][27]&
 787  (rearImage[i][28]|!rearImage[i][29]));
 788
 789  leftDev[1] = !rearImage[i][16] &
 790  !(!rearImage[i][17]&!rearImage[i][18]&!rearImage[i][21]&!rearImage[i][22] &
 791  (!rearImage[i][25]&!rearImage[i][26]&(rearImage[i][27]|rearImage[i][28]))) &
 792  (rearImage[i][17]|rearImage[i][18] | !rearImage[i][19]&!rearImage[i][20]) &
 793  (rearImage[i][17]|rearImage[i][18]|rearImage[i][21]|rearImage[i][22] |
 794  !rearImage[i][23]&!rearImage[i][24]);
 795
 796  leftDev[2] = (!rearImage[i][16]&!rearImage[i][17]&!rearImage[i][18]) &
 797  (rearImage[i][19]|rearImage[i][20]|rearImage[i][21]|rearImage[i][22] | andL2);
 798
 799  leftDev[3] = andL1;
 800
 801  leftDev[4] =
 802  !rearImage[i][27]&!rearImage[i][28]&!rearImage[i][29]&!rearImage[i][30] &
 803  andL1 & andL2;
 804
 805  // calculate Right deviation
 806  orR1=rearImage[i][8]|rearImage[i][10]|rearImage[i][12]|rearImage[i][14];
 807  orR2=rearImage[i][8]|rearImage[i][9]|rearImage[i][10]|rearImage[i][11];
 808  andR1=!rearImage[i][12]&!rearImage[i][13]&!rearImage[i][14]&!rearImage[i][15];
 809  andR2=
 810  !rearImage[i][8]&!rearImage[i][9]&!rearImage[i][10]&!rearImage[i][11] & andR1;
 811  andR3=!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][6]&!rearImage[i][7];
 812
 813  rightDev[0] = !rearImage[i][15]&(rearImage[i][14]|!rearImage[i][13]) &
 814  ((rearImage[i][12]|rearImage[i][14]|!rearImage[i][11]&
 815  (rearImage[i][10]|!rearImage[i][9])) &
 816  ((orR1|!rearImage[i][7]&(rearImage[i][6]|!rearImage[i][5])) &
 817  (orR1|rearImage[i][4]|rearImage[i][6]|!rearImage[i][3]&(rearImage[i][2]|
 818  !rearImage[i][1]))));
 819
 820  rightDev[1] = !rearImage[i][15]&!rearImage[i][14] &
 821  !(!rearImage[i][4]&!rearImage[i][5]&!rearImage[i][8]&!rearImage[i][9] &
 822  (!rearImage[i][12]&!rearImage[i][13]&(rearImage[i][2]|rearImage[i][3]))) &
 823  (rearImage[i][12]|rearImage[i][13] | !rearImage[i][10]&!rearImage[i][11]) &
 824  (rearImage[i][8]|rearImage[i][9]|rearImage[i][12]|rearImage[i][13] |
 825  !rearImage[i][6]&!rearImage[i][7]);
 826
 827  rightDev[2] = andR1 & (orR2 | andR3);
 828  rightDev[3] = andR2;
 829  rightDev[4] =
 830  !rearImage[i][0]&!rearImage[i][1]&!rearImage[i][2]&!rearImage[i][3] &
 831  andR2 & andR3 ;
 832
 833  // compare Left & Right deviations
 834  Int_t tmpLeftDev=0, tmpRightDev=0;
 835  for (j=0; j<5; j++)
 836  {
 837    tmpLeftDev  = tmpLeftDev + Int_t(leftDev[j]<<j);
 838    tmpRightDev = tmpRightDev + Int_t(rightDev[j]<<j);
 839  }
 840
 841  // assign mimimum deviation do dev[][]
 842  if (tmpLeftDev < tmpRightDev )
 843  {
 844    for (j=0; j<5; j++){ dev[i][j]=leftDev[j];}
 845    dev[i][5]=1;
 846  } else
 847  {
 848    for (j=0; j<5; j++){ dev[i][j]=rightDev[j];}
 849    dev[i][5]=0;
 850  }
 851   }
 852
 853 //---
 854  /* FIXME: use AliLog here...
 855  if(fDebug==3||fDebug==5) {
 856    printf("===============================================================\n");
 857    for (i=30; i>=0; i--) {
 858      printf("%i \t",i);
 859      for (istrip=5; istrip>=0; istrip--) printf("%i",dev[i][istrip]);
 860      printf(" \n");
 861    }
 862  }
 863  */
 864
 865 //---------------------------------------------------------
 866 // step # 4 : sort deviation
 867 //---------------------------------------------------------
 868  Int_t bga1[16], bga2[8], bga3[4], bga4[2], bga5;
 869  Int_t tmpbga1[16][6], tmpbga2[8][6], tmpbga3[4][6], tmpbga4[2][6], tmpbga5[6];
 870  Int_t tmpMax[6]={1,1,1,1,1,0};
 871
 872   for (i=0; i<15; i++)
 873   {
 874     Sort2x5(dev[2*i],dev[2*i+1],tmpbga1[i],bga1[i]);
 875   }
 876   Sort2x5(dev[30],tmpMax,tmpbga1[15],bga1[15]);
 877
 878 //--
 879   /* FIXME: use AliLog here...
 880
 881   if(fDebug==3||fDebug==5) {
 882     printf("===============================================================\n");
 883     printf(" sorting : 1st level \n");
 884     for (i=15; i>=0; i--) {
 885       printf("\t %i \t",bga1[i]);
 886       for (j=5; j>=0; j--) printf("%i",tmpbga1[i][j]);
 887      printf(" \n");
 888     }
 889   }
 890 */
 891
 892   for (i=0; i<8; i++)
 893   {
 894     Sort2x5(tmpbga1[2*i],tmpbga1[2*i+1],tmpbga2[i],bga2[i]);
 895   }
 896
 897 //--
 898   /* FIXME: use AliLog here...
 899   if(fDebug==3||fDebug==5) {
 900     printf("===============================================================\n");
 901     printf(" sorting : 2nd level \n");
 902     for (i=7; i>=0; i--) {
 903       printf("\t %i \t",bga2[i]);
 904       for (j=5; j>=0; j--) printf("%i",tmpbga1[i][j]);
 905       printf(" \n");
 906     }
 907   }
 908   */
 909
 910   for (i=0; i<4; i++)
 911   {
 912     Sort2x5(tmpbga2[2*i],tmpbga2[2*i+1],tmpbga3[i],bga3[i]);
 913   }
 914
 915 //--
 916   /* FIXME: use AliLog here...
 917   if(fDebug==3||fDebug==5) {
 918     printf("===============================================================\n");
 919     printf(" sorting : 3rd level \n");
 920     for (i=3; i>=0; i--) {
 921       printf("\t %i \t",bga3[i]);
 922       for (j=5; j>=0; j--) printf("%i",tmpbga3[i][j]);
 923       printf(" \n");
 924     }
 925   }
 926 */
 927
 928   for (i=0; i<2; i++)
 929   {
 930     Sort2x5(tmpbga3[2*i],tmpbga3[2*i+1],tmpbga4[i],bga4[i]);
 931   }
 932
 933 //--
 934   /* FIXME: use AliLog Here...
 935   if(fDebug==3||fDebug==5) {
 936     printf("===============================================================\n");
 937     printf(" sorting : 4th level \n");
 938     for (i=1; i>=0; i--) {
 939       printf("\t %i \t",bga4[i]);
 940       for (j=5; j>=0; j--) printf("%i",tmpbga4[i][j]);
 941       printf(" \n");
 942     }
 943   }
 944   */
 945
 946   Sort2x5(tmpbga4[0],tmpbga4[1],tmpbga5,bga5);
 947
 948  // coding from 6 to 5 bits
 949   minDev[4] = tmpbga5[5] | tmpbga5[4];
 950   for (i=0; i<4; i++)
 951   {
 952     minDev[i]=tmpbga5[i] & !tmpbga5[4];
 953   }
 954
 955  // find address of strip with minimum deviation
 956     minDevStrip[4]=bga5;
 957     if (bga5<=1) minDevStrip[3]=bga4[bga5];
 958
 959     Int_t tmpAd=minDevStrip[3]+minDevStrip[4]*2;
 960     if (tmpAd<=3) minDevStrip[2]=bga3[tmpAd];
 961
 962     tmpAd=minDevStrip[2]+minDevStrip[3]*2+minDevStrip[4]*4;
 963     if (tmpAd<=7) minDevStrip[1]=bga2[tmpAd];
 964
 965     tmpAd=minDevStrip[1]+minDevStrip[2]*2+minDevStrip[3]*4+minDevStrip[4]*8;
 966     if (tmpAd<=15) minDevStrip[0]=bga1[tmpAd];
 967
 968     /* FIXME : use AliLog here...
 969     if(fDebug==3||fDebug==5) {
 970     printf("===============================================================\n");
 971     printf("minDevStrip = ");
 972     for  (i=4; i>=0; i--) printf("%i",minDevStrip[i]);
 973     printf(" minDev = ");
 974     for  (i=4; i>=0; i--) printf("%i",minDev[i]);
 975     printf(" \n");
 976     printf("===============================================================\n");
 977   }
 978 */
 979 }
 980
 981 //---------------------------------------------
 982 void AliMUONTriggerDecisionV1::Sort2x5(Int_t dev1[6], Int_t dev2[6],
 983                                        Int_t minDev[6], Int_t &dev1GTdev2)
 984 {
 985   // returns minimun between dev1 and dev2
 986   Int_t tmpDev1=0, tmpDev2=0;
 987   for (Int_t j=0; j<5; j++)
 988   {
 989     tmpDev1 = tmpDev1 + Int_t(dev1[j]<<j);
 990     tmpDev2 = tmpDev2 + Int_t(dev2[j]<<j);
 991   }
 992   if (tmpDev1 <= tmpDev2 )
 993   {
 994     for (Int_t j=0; j<=5; j++) { minDev[j]=dev1[j];}
 995     dev1GTdev2=0;
 996   } else
 997   {
 998     for (Int_t j=0; j<=5; j++) { minDev[j]=dev2[j];}
 999     dev1GTdev2=1;
1000   }
1001 }
1002
1003 //----------------------------------------------------------------------
1004 // y part of trigger Algo
1005 //----------------------------------------------------------------------
1006
1007 //----------------------------------------------------------------------
1008 void AliMUONTriggerDecisionV1::TrigY(Int_t y1[16], Int_t y2[16],
1009                                      Int_t y3[16], Int_t y4[16],
1010                                      Int_t y3u[16], Int_t y3d[16],
1011                                      Int_t y4u[16], Int_t y4d[16],
1012                                      Int_t x2m, Int_t x2ud, Int_t orMud[2],
1013                                      Int_t resetMid, Int_t coinc44,
1014                                      Int_t coordY[5]){
1015   // note : resMid = 1 -> cancel
1016   //---------------------------------------------------------
1017   // step # 1 : prehandling Y
1018   //---------------------------------------------------------
1019   Int_t i;
1020
1021   for (i=0; i<16; i++)
1022   {
1023     y3[i]=y3[i]&!resetMid;
1024     y4[i]=y4[i]&!resetMid;
1025   }
1026
1027   Int_t ch1[16], ch2[16], ch3[16], ch4[16];
1028
1029   Int_t tmpy3to16[16], tmpy4to16[16];
1030   Int_t tmpy3uto16[16], tmpy3dto16[16], tmpy4uto16[16], tmpy4dto16[16];
1031   for (i=0; i<8; i++)
1032   {
1033     ch1[2*i]   = y1[i]&x2m | y1[2*i]&!x2m;
1034     ch1[2*i+1] = y1[i]&x2m | y1[2*i+1]&!x2m;
1035
1036     ch2[2*i]   = y2[i]&x2m | y2[2*i]&!x2m;
1037     ch2[2*i+1] = y2[i]&x2m | y2[2*i+1]&!x2m;
1038
1039     tmpy3to16[2*i]   = y3[i]&x2m | y3[2*i]&!x2m;
1040     tmpy3to16[2*i+1] = y3[i]&x2m | y3[2*i+1]&!x2m;
1041
1042     tmpy4to16[2*i]   = y4[i]&x2m | y4[2*i]&!x2m;
1043     tmpy4to16[2*i+1] = y4[i]&x2m | y4[2*i+1]&!x2m;
1044
1045     tmpy3uto16[2*i]   = y3u[i]&x2ud | y3u[2*i]&!x2ud;
1046     tmpy3uto16[2*i+1] = y3u[i]&x2ud | y3u[2*i+1]&!x2ud;
1047
1048     tmpy4uto16[2*i]   = y4u[i]&x2ud | y4u[2*i]&!x2ud;
1049     tmpy4uto16[2*i+1] = y4u[i]&x2ud | y4u[2*i+1]&!x2ud;
1050
1051     tmpy3dto16[2*i]   = y3d[i]&x2ud | y3d[2*i]&!x2ud;
1052     tmpy3dto16[2*i+1] = y3d[i]&x2ud | y3d[2*i+1]&!x2ud;
1053
1054     tmpy4dto16[2*i]   = y4d[i]&x2ud | y4d[2*i]&!x2ud;
1055     tmpy4dto16[2*i+1] = y4d[i]&x2ud | y4d[2*i+1]&!x2ud;
1056   }
1057
1058   if (orMud[0]==0&&orMud[1]==0)
1059   {
1060     for (i=0; i<16; i++)
1061     {
1062       ch3[i] = tmpy3to16[i];
1063       ch4[i] = tmpy4to16[i];
1064     }
1065   }
1066   if (orMud[0]==0&&orMud[1]==1)
1067   {
1068     for (i=0; i<16; i++)
1069     {
1070       ch3[i] = tmpy3uto16[i]|tmpy3to16[i];
1071       ch4[i] = tmpy4uto16[i]|tmpy4to16[i];
1072     }
1073   }
1074   if (orMud[0]==1&&orMud[1]==0)
1075   {
1076     for (i=0; i<16; i++)
1077     {
1078       ch3[i] = tmpy3dto16[i]|tmpy3to16[i];
1079       ch4[i] = tmpy4dto16[i]|tmpy4to16[i];
1080     }
1081   }
1082   if (orMud[0]==1&&orMud[1]==1)
1083   {
1084     for (i=0; i<16; i++)
1085     {
1086       ch3[i] = tmpy3dto16[i]|tmpy3to16[i]|tmpy3uto16[i];
1087       ch4[i] = tmpy4dto16[i]|tmpy4to16[i]|tmpy4uto16[i];
1088     }
1089   }
1090
1091   // debug
1092   /* FIXME: use AliLog here...
1093     if(fDebug==4||fDebug==5) {
1094       printf("===============================================================\n");
1095       printf(" Y plane after PreHandling x2m x2ud orMud %i %i %i %i \n",
1096              x2m,x2ud,orMud[0],orMud[1]);
1097       printf("                            ");
1098       for (istrip=15; istrip>=0; istrip--) {
1099         if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1100         if (istrip<10) printf("%i",istrip);
1101       }
1102       printf("\n YMC11                      ");
1103       for (istrip=15; istrip>=0; istrip--) printf("%i",ch1[istrip]);
1104       printf("\n YMC12                      ");
1105       for (istrip=15; istrip>=0; istrip--) printf("%i",ch2[istrip]);
1106       printf("\n YMC21                      ");
1107       for (istrip=15; istrip>=0; istrip--) printf("%i",ch3[istrip]);
1108       printf("\n YMC22                      ");
1109       for (istrip=15; istrip>=0; istrip--) printf("%i",ch4[istrip]);
1110       printf(" \n");
1111     }
1112   */
1113   //debug
1114
1115   //---------------------------------------------------------
1116   // step # 2 : calculate sgle and dble, apply DS reduction
1117   //---------------------------------------------------------
1118   Int_t sgle1[16], dble1[16];
1119   Int_t sgle2[16], dble2[16];
1120
1121   // Calculate simple and double hits
1122   for (i=0; i<16; i++)
1123   {
1124     dble1[i] = ch1[i] & ch2[i];
1125     dble2[i] = ch3[i] & ch4[i];
1126
1127     sgle1[i] = (ch1[i]|ch2[i]);
1128     sgle2[i] = (ch3[i]|ch4[i]);
1129   }
1130
1131   //debug
1132   /* FIXME: use AliLog here...
1133     if(fDebug==4||fDebug==5) {
1134       printf("===============================================================\n");
1135       printf(" Y plane after sgle dble \n");
1136       printf("                            ");
1137       for (istrip=15; istrip>=0; istrip--) {
1138         if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1139         if (istrip<10) printf("%i",istrip);
1140       }
1141       printf("\n SGLE1                      ");
1142       for (istrip=15; istrip>=0; istrip--) printf("%i",sgle1[istrip]);
1143       printf("\n DBLE1                      ");
1144       for (istrip=15; istrip>=0; istrip--) printf("%i",dble1[istrip]);
1145       printf("\n SGLE2                      ");
1146       for (istrip=15; istrip>=0; istrip--) printf("%i",sgle2[istrip]);
1147       printf("\n DBLE2                      ");
1148       for (istrip=15; istrip>=0; istrip--) printf("%i",dble2[istrip]);
1149       printf(" \n");
1150     }
1151   //debug
1152   */
1153
1154   // DS Reduction
1155   Int_t notOr1, notOr2;
1156
1157   notOr1=!dble1[15] & !dble1[14] & !dble1[13] & !dble1[12] &
1158     !dble1[11] & !dble1[10] & !dble1[9]  & !dble1[8]  &
1159     !dble1[7]  & !dble1[6]  & !dble1[5]  & !dble1[4]  &
1160     !dble1[3]  & !dble1[2]  & !dble1[1]  & !dble1[0];
1161
1162   notOr2=!dble2[15] & !dble2[14] & !dble2[13] & !dble2[12] &
1163     !dble2[11] & !dble2[10] & !dble2[9]  & !dble2[8]  &
1164     !dble2[7]  & !dble2[6]  & !dble2[5]  & !dble2[4]  &
1165     !dble2[3]  & !dble2[2]  & !dble2[1]  & !dble2[0];
1166
1167   for (i=0; i<16; i++)
1168   {
1169     sgle1[i] = sgle1[i] & notOr1 & !coinc44;
1170     sgle2[i] = sgle2[i] & notOr2 & !coinc44;
1171   }
1172
1173   //---------------------------------------------------------
1174   // step # 3 : 3/4 coincidence
1175   //---------------------------------------------------------
1176   Int_t frontImage[16];
1177
1178   for (i=1; i<15; i++)
1179   {
1180     frontImage[i] = (dble1[i] | sgle1[i]) &
1181     (dble2[i+1] | dble2[i] | dble2[i-1]) |
1182     dble1[i] & (sgle2[i+1] | sgle2[i] | sgle2[i-1]);
1183   }
1184   frontImage[0] = (dble1[0] | sgle1[0]) &
1185     (dble2[1] | dble2[0]) | dble1[0] & (sgle2[1] | sgle2[0]);
1186
1187   frontImage[15] = (dble1[15] | sgle1[15]) &
1188     (dble2[15] | dble2[14]) | dble1[15] & (sgle2[15] | sgle2[14]);
1189
1190
1191   //debug
1192   /* FIXME: use AliLog here...
1193     if(fDebug==4||fDebug==5) {
1194       printf("===============================================================\n");
1195       printf(" Y plane frontImage\n");
1196       printf("                            ");
1197       for (istrip=15; istrip>=0; istrip--) {
1198         if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1199         if (istrip<10) printf("%i",istrip);
1200       }
1201       printf("\n                            ");
1202       for (istrip=15; istrip>=0; istrip--) printf("%i",frontImage[istrip]);
1203       printf("\n");
1204     }
1205   //debug
1206   */
1207
1208   //---------------------------------------------------------
1209   // step # 4 : Y position
1210   //---------------------------------------------------------
1211   Int_t or1, or2, and1, and2, and3;
1212
1213   or1  = frontImage[7]|frontImage[5]|frontImage[3]|frontImage[1];
1214   or2  = frontImage[7]|frontImage[6]|frontImage[5]|frontImage[4];
1215   and1 = !frontImage[3]&!frontImage[2]&!frontImage[1]&!frontImage[0];
1216   and2 = !frontImage[7]&!frontImage[6]&!frontImage[5]&!frontImage[4] & and1;
1217   and3 = !frontImage[11]&!frontImage[10]&!frontImage[9]&!frontImage[8];
1218
1219   coordY[0] = !frontImage[0]&(frontImage[1]|!frontImage[2]) &
1220     (frontImage[3]|frontImage[1]|!frontImage[4]&(frontImage[5]|!frontImage[6])) &
1221     (or1|!frontImage[8]&(frontImage[9]|!frontImage[10])) &
1222     (or1|frontImage[11]|frontImage[9]|!frontImage[12]&(frontImage[13]|!frontImage[14]));
1223
1224   coordY[1] = !frontImage[0]&!frontImage[1] &
1225     !(!frontImage[11]&!frontImage[10]&!frontImage[7]&!frontImage[6] &
1226       !frontImage[3]&!frontImage[2]&(frontImage[13]|frontImage[12])) &
1227     (frontImage[3]|frontImage[2] | !frontImage[5]&!frontImage[4]) &
1228     (frontImage[7]|frontImage[6]|frontImage[3]|frontImage[2] |
1229      !frontImage[9]&!frontImage[8]);
1230
1231   coordY[2] = and1 & (or2 | and3);
1232
1233   coordY[3] = and2;
1234
1235   coordY[4] = !frontImage[15]&!frontImage[14]&!frontImage[13]&!frontImage[12] &
1236     and2 & and3 ;
1237
1238 }
1239 //----------------------------------------------------------------------
1240 // end of trigger Algo
1241 //----------------------------------------------------------------------
1242
1243 //______________________________________________________________________________
1244 void AliMUONTriggerDecisionV1::LocalTrigger(Int_t icirc,
1245                                             Int_t minDevStrip[5],
1246                                             Int_t minDev[5], Int_t coordY[5],
1247                                             Int_t &iTrigger){
1248   // returns local trigger answer for circuit icirc
1249   Int_t i;
1250
1251   AliMUONTriggerCircuit* triggerCircuit;
1252   triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);
1253 //  Int_t idCircuit=triggerCircuit->GetIdCircuit();
1254
1255   Int_t signDev=minDev[4];
1256   Int_t deviation=0;
1257   for (i=0; i<4; i++)
1258   {          // extract deviation
1259     deviation = deviation+Int_t(minDev[i]<<i);
1260   }
1261
1262   Int_t istripX1Circ=0;
1263   for (i=0; i<5; i++)
1264   {          // extract X1 strip fired
1265     istripX1Circ = istripX1Circ+Int_t(minDevStrip[i]<<i);
1266   }
1267
1268   Int_t iStripY=0;
1269   for (i=0; i<4; i++)
1270   {          // extract Y strip fired
1271     iStripY = iStripY+Int_t(coordY[i]<<i);
1272   }
1273
1274   // trigger or not
1275   if (signDev==1&&deviation==0)
1276   {      // something in X ?
1277     iTrigger=0;
1278   } else
1279   {
1280     if (coordY[4]==1&&iStripY==15)
1281     {   // something in Y ?
1282       iTrigger=0;
1283     } else
1284     {
1285       iTrigger=1;
1286     }
1287   }
1288
1289   if (iTrigger==1)
1290   {
1291     // fill fTrigger fStripX11 fStripY11
1292     fTrigger[icirc] = 1;
1293     fStripX11[icirc] = istripX1Circ;
1294     fStripY11[icirc] = iStripY;
1295
1296     // calculate deviation in [0+30]
1297     Int_t sign=0;
1298     if (signDev==0&&deviation!=0) sign=-1;
1299     if (signDev==0&&deviation==0) sign=0;
1300     if (signDev==1)               sign=1;
1301     fDev[icirc] = sign * deviation + 15; // fill fDev
1302
1303     // get Lut output for circuit/istripX/idev/istripY
1304     AliMUONTriggerLut lut;
1305     //    lut->StartEvent();
1306     lut.GetLutOutput(icirc,fStripX11[icirc],fDev[icirc],fStripY11[icirc],
1307                      fLutLpt[icirc],fLutHpt[icirc],fLutApt[icirc]);
1308     //    lut->FinishEvent();
1309
1310     /* FIXME : use AliLog here...
1311     if (fDebug>1) {
1312         Float_t pt= // get ptCal corresponding to istripX1Circ/idev/iStripY
1313         triggerCircuit->PtCal(fStripX11[icirc],fDev[icirc],fStripY11[icirc]);
1314         printf("-------------------------------------------\n");
1315         printf(" Local Trigger info for circuit Id %i (number %i ) \n",
1316                idCircuit,icirc);
1317         printf(" istripX1 signDev deviation istripY = %i %i %i %i \n",
1318                istripX1Circ,signDev,deviation,iStripY);
1319         printf(" fStripX11 %d fDev %d fStripY11 %d \n",fStripX11[icirc],fDev[icirc],fStripY11[icirc]);
1320         printf(" pt = %f  (GeV/c) \n",pt);
1321         printf("-------------------------------------------\n");
1322         printf(" Local Trigger Lut Output = Lpt : ");
1323         for (i=1; i>=0; i--) printf("%i",fLutLpt[icirc][i]);
1324         printf(" Hpt : ");
1325         for (i=1; i>=0; i--) printf("%i",fLutHpt[icirc][i]);
1326         printf(" Apt : ");
1327         for (i=1; i>=0; i--) printf("%i",fLutApt[icirc][i]);
1328         printf("\n");
1329         printf("-------------------------------------------\n");
1330       } // fDebug > 1
1331
1332     */
1333   }  // local trigger = 1
1334 }
1335
1336 //----------------------------------------------------------------------
1337 void AliMUONTriggerDecisionV1::GlobalTrigger()
1338 {
1339   // loop on Lut[icirc] and give Global Trigger output
1340     Int_t i;
1341
1342   for (Int_t icirc=0; icirc<234; icirc++)
1343   {
1344     if (fLutLpt[icirc][0]==1&&fLutLpt[icirc][1]==1)
1345       fGlobalSingleUndef[0] = fGlobalSingleUndef[0] + 1;
1346     if (fLutHpt[icirc][0]==1&&fLutHpt[icirc][1]==1)
1347       fGlobalSingleUndef[1] = fGlobalSingleUndef[1] + 1;
1348     if (fLutApt[icirc][0]==1&&fLutApt[icirc][1]==1)
1349       fGlobalSingleUndef[2] = fGlobalSingleUndef[2] + 1;
1350
1351     if (fLutLpt[icirc][0]==0&&fLutLpt[icirc][1]==1)
1352       fGlobalSinglePlus[0] = fGlobalSinglePlus[0] + 1;
1353     if (fLutHpt[icirc][0]==0&&fLutHpt[icirc][1]==1)
1354       fGlobalSinglePlus[1] = fGlobalSinglePlus[1] + 1;
1355     if (fLutApt[icirc][0]==0&&fLutApt[icirc][1]==1)
1356       fGlobalSinglePlus[2] = fGlobalSinglePlus[2] + 1;
1357
1358     if (fLutLpt[icirc][0]==1&&fLutLpt[icirc][1]==0)
1359       fGlobalSingleMinus[0] = fGlobalSingleMinus[0] + 1;
1360     if (fLutHpt[icirc][0]==1&&fLutHpt[icirc][1]==0)
1361       fGlobalSingleMinus[1] = fGlobalSingleMinus[1] + 1;
1362     if (fLutApt[icirc][0]==1&&fLutApt[icirc][1]==0)
1363       fGlobalSingleMinus[2] = fGlobalSingleMinus[2] + 1;
1364   }
1365
1366   // like sign low, high and all pt
1367   for (i=0; i<3; i++)
1368   {
1369     fGlobalPairLike[i]=fGlobalSingleMinus[i]*(fGlobalSingleMinus[i]-1)/2 +
1370       fGlobalSinglePlus[i]*(fGlobalSinglePlus[i]-1)/2 +
1371       fGlobalSingleUndef[i]*(fGlobalSingleUndef[i]-1)/2 +
1372       fGlobalSingleUndef[i]*fGlobalSinglePlus[i] +
1373       fGlobalSingleUndef[i]*fGlobalSingleMinus[i];
1374   }
1375
1376   // unlike sign low, high and all pt
1377   for (i=0; i<3; i++)
1378   {
1379     fGlobalPairUnlike[i]=fGlobalSingleMinus[i]*fGlobalSinglePlus[i] +
1380       fGlobalSingleUndef[i]*(fGlobalSingleUndef[i]-1)/2 +
1381       fGlobalSingleUndef[i]*fGlobalSinglePlus[i] +
1382       fGlobalSingleUndef[i]*fGlobalSingleMinus[i];
1383   }
1384
1385   StdoutToAliDebug(1,
1386     printf("===================================================\n");
1387     printf(" Global Trigger output       Low pt  High pt   All\n");
1388     printf(" number of Single Plus      :\t");
1389     for (i=0; i<3; i++) printf("%i\t",fGlobalSinglePlus[i]);
1390     printf("\n");
1391     printf(" number of Single Minus     :\t");
1392     for (i=0; i<3; i++) printf("%i\t",fGlobalSingleMinus[i]);
1393     printf("\n");
1394     printf(" number of Single Undefined :\t");
1395     for (i=0; i<3; i++) printf("%i\t",fGlobalSingleUndef[i]);
1396     printf("\n");
1397     printf(" number of UnlikeSign pair  :\t");
1398     for (i=0; i<3; i++) printf("%i\t",fGlobalPairUnlike[i]);
1399     printf("\n");
1400     printf(" number of LikeSign pair    :\t");
1401     for (i=0; i<3; i++) printf("%i\t",fGlobalPairLike[i]);
1402     printf("\n");
1403     printf("===================================================\n");
1404     printf("\n");
1405                    );
1406 }
1407
1408 //----------------------------------------------------------------------
1409 void AliMUONTriggerDecisionV1::PrintBitPatXInput(Int_t icirc)
1410 {
1411 // print bit pattern for X strips
1412
1413     Int_t istrip;
1414
1415   printf("-------- TRIGGER INPUT ---------\n");
1416   printf("===============================================================\n");
1417   printf("                            5432109876543210");
1418   printf("\n XMC11                      ");
1419   for (istrip=15; istrip>=0; istrip--) printf("%i",fXbit11[icirc][istrip]);
1420   printf("\n XMC12                      ");
1421   for (istrip=15; istrip>=0; istrip--) printf("%i",fXbit12[icirc][istrip]);
1422   printf("\n XMC21              ");
1423   for (istrip=31; istrip>=0; istrip--) printf("%i",fXbit21[icirc][istrip]);
1424   printf("\n XMC22              ");
1425   for (istrip=31; istrip>=0; istrip--) printf("%i",fXbit22[icirc][istrip]);
1426   printf("\n                    ");
1427   printf("10987654321098765432109876543210\n");
1428 }
1429
1430 //----------------------------------------------------------------------
1431 void AliMUONTriggerDecisionV1::PrintBitPatYInput(Int_t icirc)
1432 {
1433 // print bit pattern for Y strips
1434
1435     Int_t istrip;
1436
1437   AliMUONTriggerCircuit* triggerCircuit;
1438   triggerCircuit = (AliMUONTriggerCircuit*) fTriggerCircuit->At(icirc);
1439   Int_t idCircuit=triggerCircuit->GetIdCircuit();
1440   Int_t nStrip=triggerCircuit->GetNstripY();
1441
1442   printf("---------------------------------------------------------------\n");
1443   printf("                            ");
1444   for (istrip=nStrip-1; istrip>=0; istrip--) {
1445     if (istrip>9)  printf("%i",istrip-10*Int_t(istrip/10));
1446     if (istrip<10) printf("%i",istrip);
1447   }
1448   printf("\n YMC11                      ");
1449   for (istrip=nStrip-1; istrip>=0; istrip--)
1450     printf("%i",fYbit11[icirc][istrip]);
1451   printf("\n YMC12                      ");
1452   for (istrip=nStrip-1; istrip>=0; istrip--)
1453     printf("%i",fYbit12[icirc][istrip]);
1454   printf("\n YMC21                      ");
1455   for (istrip=nStrip-1; istrip>=0; istrip--)
1456     printf("%i",fYbit21[icirc][istrip]);
1457   printf("\n YMC22                      ");
1458   for (istrip=nStrip-1; istrip>=0; istrip--)
1459     printf("%i",fYbit22[icirc][istrip]);
1460   printf("\n");
1461 // tmp
1462   printf("---------------------------------------------------------------");
1463   printf("\n upper part of circuit %i",idCircuit);
1464   printf("\n UMC21                      ");
1465   for (istrip=15; istrip>=0; istrip--) printf("%i",fYbit21U[icirc][istrip]);
1466   printf("\n UMC22                      ");
1467   for (istrip=15; istrip>=0; istrip--) printf("%i", fYbit22U[icirc][istrip]);
1468
1469   printf("\n lower part of circuit %i",idCircuit);
1470   printf("\n LMC21                      ");
1471   for (istrip=15; istrip>=0; istrip--) printf("%i",fYbit21D[icirc][istrip]);
1472   printf("\n LMC22                      ");
1473   for (istrip=15; istrip>=0; istrip--) printf("%i",fYbit22D[icirc][istrip]);
1474   printf("\n");
1475   printf("===============================================================\n");
1476 }
1477
1478 //----------------------------------------------------------------------
1479 void AliMUONTriggerDecisionV1::PrintLocalOutput(Int_t minDevStrip[5],
1480                                               Int_t minDev[5],
1481                                               Int_t coordY[5]){
1482 // print Local trigger output before the LuT step
1483
1484     Int_t i;
1485
1486   printf("===============================================================\n");
1487   printf("-------- TRIGGER OUTPUT --------\n");
1488   printf("minDevStrip = ");
1489   for  (i=4; i>=0; i--) printf("%i",minDevStrip[i]);
1490   printf(" minDev = ");
1491   for  (i=4; i>=0; i--) printf("%i",minDev[i]);
1492   printf(" coordY = ");
1493   for  (i=4; i>=0; i--) printf("%i",coordY[i]);
1494   printf(" \n");
1495 }
1496
1497 //----------------------------------------------------------------------
1498 //--- methods which return member data related info
1499 //----------------------------------------------------------------------
1500 Int_t AliMUONTriggerDecisionV1::GetITrigger(Int_t icirc) const
1501 {
1502 // returns Local Trigger Status
1503   return fTrigger[icirc];
1504 }
1505 //----------------------------------------------------------------------
1506 Int_t AliMUONTriggerDecisionV1::GetStripX11(Int_t icirc) const
1507 {
1508 // returns fStripX11
1509   return fStripX11[icirc];
1510 }
1511 //----------------------------------------------------------------------
1512 Int_t AliMUONTriggerDecisionV1::GetDev(Int_t icirc) const
1513 {
1514 // returns idev
1515   return fDev[icirc];
1516 }
1517 //----------------------------------------------------------------------
1518 Int_t AliMUONTriggerDecisionV1::GetStripY11(Int_t icirc) const
1519 {
1520 // returns fStripY11;
1521    return fStripY11[icirc];
1522 }
1523 //----------------------------------------------------------------------
1524 void AliMUONTriggerDecisionV1::GetLutOutput(Int_t icirc, Int_t lpt[2],
1525                                           Int_t hpt[2], Int_t apt[2]) const
1526 {
1527 // returns Look up Table output
1528   for (Int_t i=0; i<2; i++) {
1529     lpt[i]=fLutLpt[icirc][i];
1530     hpt[i]=fLutHpt[icirc][i];
1531     apt[i]=fLutApt[icirc][i];
1532   }
1533 }
1534 //----------------------------------------------------------------------
1535 void AliMUONTriggerDecisionV1::GetGlobalTrigger(Int_t singlePlus[3],
1536                                               Int_t singleMinus[3],
1537                                               Int_t singleUndef[3],
1538                                               Int_t pairUnlike[3],
1539                                               Int_t pairLike[3]) const
1540 {
1541 // returns Global Trigger information (0,1,2 : Lpt,Hpt,Apt)
1542 // should not be used anymore.
1543   for (Int_t i=0; i<3; i++)
1544   {
1545     singlePlus[i]  = fGlobalSinglePlus[i];
1546     singleMinus[i] = fGlobalSingleMinus[i];
1547     singleUndef[i] = fGlobalSingleUndef[i];
1548     pairUnlike[i]  = fGlobalPairUnlike[i];
1549     pairLike[i]    = fGlobalPairLike[i];
1550   }
1551 }
1552
1553 //_______________________________________________________________________
1554 void AliMUONTriggerDecisionV1::Exec(Option_t*)
1555 {
1556   // call the Trigger Algorithm and fill TreeD
1557
1558   ClearDigitNumbers();
1559
1560   fMUONData->ResetTrigger();
1561
1562   Trigger();
1563
1564   AliMUONGlobalTrigger* pGloTrig =
1565     new AliMUONGlobalTrigger(fGlobalSinglePlus, fGlobalSingleMinus,
1566                              fGlobalSingleUndef, fGlobalPairUnlike,
1567                              fGlobalPairLike);
1568
1569   // add a local trigger in the list
1570   fMUONData->AddGlobalTrigger(*pGloTrig);
1571   delete pGloTrig;
1572
1573   for (Int_t icirc=0; icirc<AliMUONConstants::NTriggerCircuit(); icirc++)
1574   {
1575     if(GetITrigger(icirc)==1)
1576     {
1577       Int_t localtr[15]={0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
1578       Int_t loLpt[2]={0,0}; Int_t loHpt[2]={0,0}; Int_t loApt[2]={0,0};
1579       GetLutOutput(icirc, loLpt, loHpt, loApt);
1580       localtr[0] = icirc;
1581       localtr[1] = GetStripX11(icirc);
1582       localtr[2] = GetDev(icirc);
1583       localtr[3] = GetStripY11(icirc);
1584       for (Int_t i = 0; i < 2; i++)
1585       {    // convert the Lut output in 1 digit
1586         localtr[4] += Int_t(loLpt[i]<<i);
1587         localtr[5] += Int_t(loHpt[i]<<i);
1588         localtr[6] += Int_t(loApt[i]<<i);
1589       }
1590
1591       for (Int_t i = 0; i < 16; i++)
1592       {    // convert X/Y bit in bit pattern
1593         localtr[7]  |= (fXbit11[icirc][i] << i);
1594         localtr[8]  |= (fXbit12[icirc][i] << i);
1595
1596         // 8 first and last elts correspond to neighbouring cards
1597         localtr[9]  |= (fXbit21[icirc][i+8] << i);
1598         localtr[10] |= (fXbit22[icirc][i+8] << i);
1599
1600         localtr[11] |= (fYbit11[icirc][i] << i);
1601         localtr[12] |= (fYbit12[icirc][i] << i);
1602         localtr[13] |= (fYbit21[icirc][i] << i);
1603         localtr[14] |= (fYbit22[icirc][i] << i);
1604       }
1605
1606       AliMUONLocalTrigger* pLocTrig = new AliMUONLocalTrigger(localtr, fDigitNumbers[icirc]);
1607       fMUONData->AddLocalTrigger(*pLocTrig);  // add a local trigger in the list
1608       delete pLocTrig;
1609     }
1610   }
1611 }
1612
1613 //_______________________________________________________________________
1614 void AliMUONTriggerDecisionV1::ClearDigitNumbers()
1615 {
1616 // Clears the fDigitNumbers arrays so that they are all empty.
1617
1618         for (Int_t i = 0; i < AliMUONConstants::NTriggerCircuit(); i++)
1619   {
1620                 fDigitNumbers[i].Set(0);
1621   }
1622 }
1623
1624 //_______________________________________________________________________
1625 void AliMUONTriggerDecisionV1::DigitFiredCircuit(Int_t circuit, Int_t cathode,
1626                                                  Int_t chamber, Int_t digit)
1627 {
1628   // Registers that the specified digit fired the specified circuit.
1629   // This digit gets added to an array which will be copied to
1630   // AliMUONLocalTrigger when such an object is created for each circuit.
1631
1632         Int_t digitnumber = AliMUONLocalTrigger::EncodeDigitNumber(chamber, cathode, digit);
1633         Int_t last = fDigitNumbers[circuit].GetSize();
1634         fDigitNumbers[circuit].Set(last + 1);
1635         fDigitNumbers[circuit][last] = digitnumber;
1636 }
1637
1638 //_______________________________________________________________________
1639 const Int_t AliMUONTriggerDecisionV1::fgkCircuitSortedAsBoard[234]={
1640     911, 811, 812, 711, 712, 611, 612, 613, 411, 412, 413, 311, 312, 211, 212, 111,
1641     921, 821, 822, 721, 722, 621, 622, 623, 624, 521, 522, 523, 524, 421, 422, 423, 424, 321, 322, 221, 222, 121,
1642     931, 831, 832, 731, 732, 631, 632, 633, 634, 531, 532, 533, 534, 431, 432, 433, 434, 331, 332, 231, 232, 131,
1643     941, 841, 842, 741, 742, 641, 642, 541, 542, 441, 442, 341, 342, 241, 242, 141,
1644     951, 851, 852, 751, 752, 651, 652, 551, 552, 451, 452, 351, 352, 251, 252, 151,
1645     961, 861, 862, 761, 762, 661, 662, 561, 562, 461, 462, 361, 362, 261, 262, 161,
1646     971, 871, 771, 671, 571, 471, 371, 271, 171,
1647     -911, -811, -812, -711, -712, -611, -612, -613, -411, -412, -413, -311, -312, -211, -212, -111,
1648     -921, -821, -822, -721, -722, -621, -622, -623, -624, -521, -522, -523, -524, -421, -422, -423, -424, -321, -322, -221, -222, -121,
1649     -931, -831, -832, -731, -732, -631, -632, -633, -634, -531, -532, -533, -534, -431, -432, -433, -434, -331, -332, -231, -232, -131,
1650     -941, -841, -842, -741, -742, -641, -642, -541, -542, -441, -442, -341, -342, -241, -242, -141,
1651     -951, -851, -852, -751, -752, -651, -652, -551, -552, -451, -452, -351, -352, -251, -252, -151,
1652     -961, -861, -862, -761, -762, -661, -662, -561, -562, -461, -462, -361, -362, -261, -262, -161,
1653     -971, -871, -771, -671, -571, -471, -371, -271, -171};
1654
1655 //----------------------------------------------------------------------
1656 Int_t AliMUONTriggerDecisionV1::ModuleNumber(Int_t idModule) const {
1657 // returns module number imod (from 0 to 63) corresponding to module idmodule
1658   Int_t absidModule=TMath::Abs(idModule);
1659   Int_t iModule=0;
1660   for (Int_t i=0; i<63; i++) {
1661     if (AliMUONTriggerConstants::ModuleId(i)==absidModule) {
1662       iModule=i;
1663       break;
1664     }
1665   }
1666   return iModule;
1667 }
1668 //----------------------------------------------------------------------
1669 Int_t AliMUONTriggerDecisionV1::CircuitNumber(Int_t idCircuit) const {
1670 // returns circuit number iCircuit (0-234) corresponding to circuit idCircuit
1671   Int_t iCircuit=0;
1672   for (Int_t i=0; i<234; i++) {
1673     if (AliMUONTriggerConstants::CircuitId(i)==idCircuit) {
1674       iCircuit=i;
1675       break;
1676     }
1677   }
1678   return iCircuit;
1679 }
1680 //_______________________________________________________________________
1681 Int_t AliMUONTriggerDecisionV1::Board2Circuit(Int_t iboard) const {
1682 // returns Circuit number corresponding to iboard
1683     Int_t idCircuit = fgkCircuitSortedAsBoard[iboard];
1684     return CircuitNumber(idCircuit);
1685 }
1686