DQM configure file
[u/mrichter/AliRoot.git] / MUON / AliMUONGlobalTriggerBoard.cxx
index 26c144f..ba23767 100644 (file)
 
 /* $Id$ */
 
-//*-- Author: Rachid Guernane (LPCCFd)
-//    GLOBAL TRIGGER IMPLEMENTATION
-//    INPUTS ARE REGIONAL RESPONSES
-//    OUTPUT IS A 12-BIT WORD
-//    4 BITS PER TRIGGER LEVEL
+//-----------------------------------------------------------------------------
+/// \class AliMUONGlobalTriggerBoard
+/// Global trigger implementation:
+/// - inputs are regional responses
+/// - output is a 12-bit word
+/// - 4 bits per trigger level
+///
+/// \author Rachid Guernane (LPCCFd), 
+/// Corrected by Christian Finck (Subatech)
+//-----------------------------------------------------------------------------
 
 #include "AliMUONGlobalTriggerBoard.h"
 #include "AliLog.h"
 
 #include <Riostream.h>
 
+/// \cond CLASSIMP
 ClassImp(AliMUONGlobalTriggerBoard)
+/// \endcond
 
 //___________________________________________
-AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard()
+AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard(): AliMUONTriggerBoard()
 {
+/// Default constructor
+
    for (Int_t i=0;i<16;i++) fRegionalResponse[i] = 0;
+   for (Int_t i=0;i< 4;i++) fGlobalInput[i] = 0;
+   for (Int_t i=0;i< 4;i++) fMask[i] = 0xffffffff;
 }
 
 //___________________________________________
 AliMUONGlobalTriggerBoard::AliMUONGlobalTriggerBoard(const char *name, Int_t a) : AliMUONTriggerBoard(name, a)
 {
+/// Standard constructor
+
    for (Int_t i=0;i<16;i++) fRegionalResponse[i] = 0;
+   for (Int_t i=0;i< 4;i++) fGlobalInput[i] = 0;
+   for (Int_t i=0;i< 4;i++) fMask[i] = 0xffffffff;
+}
+
+//___________________________________________
+AliMUONGlobalTriggerBoard::~AliMUONGlobalTriggerBoard()
+{
+/// Destructor
 }
 
 //___________________________________________
-void AliMUONGlobalTriggerBoard::Mask(Int_t index, UShort_t mask)
+void AliMUONGlobalTriggerBoard::Mask(Int_t index, UInt_t mask)
 {
-  // MASK GLOBAL TRIGGER BOARD INPUT index WITH VALUE mask
-  if ( index>=0 && index < 16 ) 
+  /// mask global trigger board input index with value mask
+  if ( index >= 0 && index < 4 ) 
   {
     fMask[index]=mask;
   }
   else
   {
-    AliError(Form("Index %d out of bounds (max %d)",index,16));
+    AliError(Form("Index %d out of bounds (max %d)",index,3));
   }  
 }
 
 //___________________________________________
 void AliMUONGlobalTriggerBoard::Response()
 {
-   // COMPUTE THE GLOBAL TRIGGER BOARD
-   // RESPONSE ACCORDING TO THE Algo() METHOD
+   /// compute the global trigger board
+   /// response according to the algo() method
+// output from global trigger algorithm
+// [+, -, US, LS] * [Hpt, Lpt]
+// transformed to [usHpt, usLpt, lsHpt, lsLpt, sHpt, sLpt] according
+// to Global Trigger Unit user manual
+
    Int_t t[16];
 
-   for (Int_t i=0;i<16;i++) t[i] = fRegionalResponse[i] & fMask[i];
+   BuildGlobalInput();
+   MaskGlobalInput();
 
+   for (Int_t i = 0; i < 16; ++i) 
+   {
+     t[i] = fRegionalResponse[i];
+   }
+   
+   
    Int_t rank = 8;
 
    for (Int_t i=0;i<4;i++)
@@ -72,63 +105,71 @@ void AliMUONGlobalTriggerBoard::Response()
       
       for (Int_t j=0;j<rank;j++)
       {
-         UShort_t athres = Algo(t[2*j],t[2*j+1],"APT");
-
-         UShort_t lthres = Algo(t[2*j],t[2*j+1],"LPT"); lthres <<= 4;
+         UShort_t lthres = Algo(t[2*j],t[2*j+1],"LPT");
 
-         UShort_t hthres = Algo(t[2*j],t[2*j+1],"HPT"); hthres <<= 8;
+         UShort_t hthres = Algo(t[2*j],t[2*j+1],"HPT"); hthres <<= 4;
 
-         t[ip] = athres | lthres | hthres;
+         t[ip] = lthres | hthres;
 
          ip++;
       }
       
       rank /= 2; 
    }
+   UChar_t sLpt, sHpt, lsLpt, lsHpt, usLpt, usHpt;
+   sLpt  = ((t[0] & 0xC)  != 0);
+   sHpt  = ((t[0] & 0xC0) != 0);
+   lsLpt = ((t[0] & 0x1)  != 0);
+   lsHpt = ((t[0] & 0x10) != 0);
+   usLpt = ((t[0] & 0x2 ) != 0);
+   usHpt = ((t[0] & 0x20) != 0);
+
+   // LSB is zero (trigger choice to send to CTP: sLpt or sHpt)
+
+   sLpt  <<= 1;
+   sHpt  <<= 2;
+   lsLpt <<= 3;
+   lsHpt <<= 4;
+   usLpt <<= 5;
+   usHpt <<= 6;
+
+   fResponse = sLpt | sHpt | lsLpt | lsHpt | usLpt |usHpt;
+   
 
-   fResponse = t[0]; // 12-bit [H4:L4:A4]
 }
 
 //___________________________________________
-UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
+UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, const char *thres)
 {
-   // GLOBAL TRIGGER ALGORITHM
-   TBits a(12), b(12); a.Set(12,&i); b.Set(12,&j);
+/// global trigger algorithm
+///   a ,b = reg  response  =  Hpt (+|-|us|ls) |  Lpt (+|-|us|ls)  
+                           
+   TBits a(8), b(8); a.Set(8,&i); b.Set(8,&j);
 
    TBits trg1(2), trg2(2), trg(2);
 
-   if (!strcmp(thres,"APT"))
+   if (!strcmp(thres,"LPT"))
    {
       trg1[0] = a[2]; trg1[1] = a[3]; 
       trg2[0] = b[2]; trg2[1] = b[3];
    }
-   else if (!strcmp(thres,"LPT"))
-   {
-      trg1[0] = a[6]; trg1[1] = a[7]; 
-      trg2[0] = b[6]; trg2[1] = b[7];
-   }
    else
    {
-      trg1[0] = a[10]; trg1[1] = a[11]; 
-      trg2[0] = b[10]; trg2[1] = b[11];         
+      trg1[0] = a[6]; trg1[1] = a[7]; 
+      trg2[0] = b[6]; trg2[1] = b[7];         
    }
        
    TBits trgLS1(1), trgUS1(1), trgLS2(1), trgUS2(1), trgLS(1), trgUS(1);
 
-   if (!strcmp(thres,"APT"))
-   {
-      trgLS1[0] = a[1]; trgUS1[0] = a[0]; 
-      trgLS2[0] = b[1]; trgUS2[0] = b[0];
-   }
-   else if (!strcmp(thres,"LPT"))
+   if (!strcmp(thres,"LPT"))
    {
-      trgLS1[0] = a[5]; trgUS1[0] = a[4]; 
-      trgLS2[0] = b[5]; trgUS2[0] = b[4];
+      trgLS1[0] = a[0]; trgUS1[0] = a[1]; 
+      trgLS2[0] = b[0]; trgUS2[0] = b[1];
    }
    else
    {
-      trgLS1[0] = a[9]; trgUS1[0] = a[8]; 
-      trgLS2[0] = b[9]; trgUS2[0] = b[8];         
+      trgLS1[0] = a[4]; trgUS1[0] = a[5]; 
+      trgLS2[0] = b[4]; trgUS2[0] = b[5];         
    }
 
    trgLS[0] = ( trg1[0] & trg2[0] ) | ( trg1[1] & trg2[1] ) | trgLS1[0] | trgLS2[0];
@@ -139,8 +180,8 @@ UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
    
    TBits v(4);
    
-   v[0] = trgUS[0];
-   v[1] = trgLS[0];
+   v[0] = trgLS[0];
+   v[1] = trgUS[0];
    v[2] = trg[0];
    v[3] = trg[1];
 
@@ -151,10 +192,80 @@ UShort_t AliMUONGlobalTriggerBoard::Algo(UShort_t i, UShort_t j, char *thres)
 }
 
 //___________________________________________
+void AliMUONGlobalTriggerBoard::BuildGlobalInput()
+{
+  /// build the 4 words (32bits) global input from the regional responses
+  /// the order of regional responses is:
+  /// 1R, 2R, 2-3R, 3R, 4R, 5R, 6R, 7R, 1L, 2L, 2-3L, 3L, 4L, 5L, 6L, 7L
+
+  for (Int_t i=0;i< 4;i++) fGlobalInput[i] = 0;
+
+  UShort_t regRespInv;
+  for (Int_t iReg = 0; iReg < 16; iReg++) {
+
+    regRespInv = InvertPairBits(iReg);
+
+    if (iReg < 8) {    // right
+      // Lpt word
+      fGlobalInput[0] |=  (regRespInv & 0x0F)       << (4*iReg);
+      // Hpt word
+      fGlobalInput[2] |= ((regRespInv & 0xF0) >> 4) << (4*iReg);
+    } else {           // left
+      // Lpt word
+      fGlobalInput[1] |=  (regRespInv & 0x0F)       << (4*(iReg-8));
+      // Hpt word
+      fGlobalInput[3] |= ((regRespInv & 0xF0) >> 4) << (4*(iReg-8));
+    }
+
+  }
+
+}
+
+//___________________________________________
+void AliMUONGlobalTriggerBoard::MaskGlobalInput()
+{
+  /// Apply masks to global input and recalculate regional inputs before
+  /// applying the global response
+
+  UInt_t gitmp[4];
+  for (Int_t i = 0; i < 4; i++) {
+    fGlobalInput[i] &= fMask[i];
+    gitmp[i] = fGlobalInput[i];
+  }
+
+  RecomputeRegional(gitmp);
+}
+
+
+//___________________________________________
+void AliMUONGlobalTriggerBoard::RecomputeRegional(UInt_t gitmp[4])
+{
+  //
+  /// Recomput regional response from global input
+  //
+  for (Int_t iReg = 0; iReg < 16; iReg++) {
+    fRegionalResponse[iReg] = 0;
+    if (iReg < 8) {    // right
+      // Lpt
+      fRegionalResponse[iReg] |=  (gitmp[0] >> (4*iReg))     & 0xF;
+      // Hpt
+      fRegionalResponse[iReg] |= ((gitmp[2] >> (4*iReg))     & 0xF) << 4;
+    } else {           // left
+      // Lpt
+      fRegionalResponse[iReg] |=  (gitmp[1] >> (4*(iReg-8))) & 0xF;
+      // Hpt
+      fRegionalResponse[iReg] |= ((gitmp[3] >> (4*(iReg-8))) & 0xF) << 4;
+    }
+
+    fRegionalResponse[iReg] = InvertPairBits(iReg);
+  }
+}
+
+//___________________________________________
 void AliMUONGlobalTriggerBoard::Scan(Option_t*) const
 {
-  // PRINT GLOBAL TRIGGER OUTPUT 
-  TBits w(12); w.Set(12,&fResponse);
+  /// print global trigger output 
+  TBits w(7); w.Set(7,&fResponse);
 
 // TRG[1:0]
 // 00 noth
@@ -162,59 +273,49 @@ void AliMUONGlobalTriggerBoard::Scan(Option_t*) const
 // 10 positive track
 // 11 undef
 
-   Int_t iSP[3] = {0,0,0}, iSM[3] = {0,0,0}, iSU[3] = {0,0,0};
-
-   TBits a(2), n(2), p(2), u(2);
-   
-   UShort_t val;
-
-   val = 1; n.Set(2,&val);
-   val = 2; p.Set(2,&val);
-   val = 3; u.Set(2,&val);
-   
-   a[0] = w[2];
-   a[1] = w[3];
-   
-   if      (a==p) iSP[0] = 1;
-   else if (a==n) iSM[0] = 1;
-   else if (a==u) iSU[0] = 1;   
-
-   a[0] = w[6];
-   a[1] = w[7];
+   Int_t iS[2] = {0,0};
 
-   if      (a==p) iSP[1] = 1;
-   else if (a==n) iSM[1] = 1;
-   else if (a==u) iSU[1] = 1;
-   
-   a[0] = w[10];
-   a[1] = w[11];
-
-   if      (a==p) iSP[2] = 1;
-   else if (a==n) iSM[2] = 1;
-   else if (a==u) iSU[2] = 1;
+   iS[0] = (Int_t)w.TestBitNumber(1);
+   iS[1] = (Int_t)w.TestBitNumber(2);
 
-   Int_t iPU[3] = {w[0],w[4],w[8]};
-   Int_t iPL[3] = {w[1],w[5],w[9]};
+   Int_t iPU[2] = {w[5],w[6]};
+   Int_t iPL[2] = {w[3],w[4]};
 
-   printf("===================================================\n");
-   printf(" Global Trigger output       Low pt  High pt   All\n");
-   printf(" number of Single Plus      :\t");
-   for (Int_t i=0; i<3; i++) printf("%i\t",iSP[i]);
-   printf("\n");
-   printf(" number of Single Minus     :\t");
-   for (Int_t i=0; i<3; i++) printf("%i\t",iSM[i]);
-   printf("\n");
-   printf(" number of Single Undefined :\t"); 
-   for (Int_t i=0; i<3; i++) printf("%i\t",iSU[i]);
+   printf("============================================\n");
+   printf(" Global Trigger output       Low pt  High pt\n");
+   printf(" number of Single           :\t");
+   for (Int_t i=0; i<2; i++) printf("%i\t",iS[i]);
    printf("\n");
    printf(" number of UnlikeSign pair  :\t"); 
-   for (Int_t i=0; i<3; i++) printf("%i\t",iPU[i]);
+   for (Int_t i=0; i<2; i++) printf("%i\t",iPU[i]);
    printf("\n");
    printf(" number of LikeSign pair    :\t");  
-   for (Int_t i=0; i<3; i++) printf("%i\t",iPL[i]);
+   for (Int_t i=0; i<2; i++) printf("%i\t",iPL[i]);
    printf("\n");
    printf("===================================================\n");
    printf("\n");
 }
 
-ClassImp(AliMUONGlobalTriggerBoard)
+
+//___________________________________________
+UShort_t AliMUONGlobalTriggerBoard::InvertPairBits(Int_t iReg)
+{
+  //
+  /// invert "pair" bits in regional response
+  /// [+, -, US, LS] becomes [+, -, LS, US]
+  //
+  TBits rs(8), rsi(8);
+  rs.Set(8,&fRegionalResponse[iReg]);
+    for (Int_t i = 0; i < 4; i++) {
+      if (i%2 == 0) {
+       rsi[2*i]   = rs[2*i+1];
+       rsi[2*i+1] = rs[2*i];
+      } else {
+       rsi[2*i]   = rs[2*i];
+       rsi[2*i+1] = rs[2*i+1];
+      }
+    }
+    UShort_t regRespInv = 0;
+    rsi.Get(&regRespInv);
+    return regRespInv;
+}