[u/mrichter/AliRoot.git] / MUON / AliMUONTriggerElectronics.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

//*-- Author: Rachid Guernane (LPCCFd)
//*   Manager class for muon trigger electronics
//*   Client of trigger board classes
//*
//*

#include "AliMUONTriggerElectronics.h"
#include "AliMUONTriggerCrate.h"
#include "AliMUONTriggerCrateStore.h"
#include "AliMUONConstants.h"
#include "AliMUONLocalTriggerBoard.h"
#include "AliMUONRegionalTriggerBoard.h"
#include "AliMUONGlobalTriggerBoard.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONRegionalTrigger.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUON.h" 
#include "AliMUONData.h" 
#include "AliMUONDigit.h"
#include "AliMUONSegmentation.h"
#include "AliMUONCalibrationData.h"
#include "AliMUONVCalibParam.h"

#include "AliMpSegmentation.h"
#include "AliMpVSegmentation.h"
#include "AliMpCathodType.h"

#include "AliLog.h"
#include "AliLoader.h"
#include "AliRun.h"

//#include "Riostream.h"
#include "TBits.h"
#include "TSystem.h"

/// \cond CLASSIMP
ClassImp(AliMUONTriggerElectronics)
/// \endcond

//___________________________________________
AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONData *Data, AliMUONCalibrationData* calibData) 
: TTask("AliMUONTriggerElectronics",
        "From trigger digits to Local and Global Trigger objects"),
  fSourceFileName(),
  fCrates(new AliMUONTriggerCrateStore),
  fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard),
  fMUONData(Data),
  fLocalTrigger(new AliMUONLocalTrigger()),
  fGlobalTrigger(new AliMUONGlobalTrigger())

{
/// CONSTRUCTOR
///
  if (!fMUONData)
  {  
    AliWarning("NO MUON TRIGGER DATA");
  }
    
  SetDataSource();
  Factory(calibData);
  LoadMasks(calibData);
}

//___________________________________________
AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
{
/// DESTRUCTOR
///
  delete fGlobalTriggerBoard;
  delete fCrates;
  delete fLocalTrigger;
  delete fGlobalTrigger;

}

//___________________________________________
void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
{  
 /// BUILD ALL ELECTRONICS
 ///

// get coinc44 from AliMUON (added 12/09/06)
  AliMUON *pMUON  = (AliMUON*)gAlice->GetModule("MUON");
  Int_t coinc44 = pMUON->GetTriggerCoinc44();
  if (coinc44 != 0 && coinc44 != 1) {
      AliFatal("Coinc 44 should be equal to 0 or 1");
      return;
  }

  fCrates->ReadFromFile(gSystem->ExpandPathName(fSourceFileName.Data()));
  
  if ( !calibData ) return;
  
  AliMUONTriggerLut* lut = calibData->TriggerLut();
  
  if (!lut) return;
  
  AliMUONLocalTriggerBoard* localBoard;
  
  fCrates->FirstLocalBoard();
  
  while ( (localBoard=fCrates->NextLocalBoard()) )
  {
    localBoard->SetLUT(lut);
    localBoard->SetCoinc44(coinc44);
  }
}

//___________________________________________
void AliMUONTriggerElectronics::FeedM()
{
/// FILL INPUTS
///
    for (Int_t ichamber=10; ichamber<14; ichamber++) 
    {
      TClonesArray *muonDigits = fMUONData->Digits(ichamber);
      Int_t ndigits = muonDigits->GetEntriesFast();

      for (Int_t digit=0; digit<ndigits; digit++)
      {
	  AliMUONDigit *mdig = static_cast<AliMUONDigit*>(muonDigits->UncheckedAt(digit));

	  //       CHECKME ! The TrackCharge is not ok with new digitizerV3 !
	  //			for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
	  Int_t schg = (Int_t)(mdig->Signal() + 0.5);
         
	  //       APPLY CONDITION ON SOFT BACKGROUND	
	  Int_t tchg = schg - (Int_t(schg/10))*10;	

	  if (schg<=10 || tchg>0) 
	  {
	      //   				mdig->Print();

	      Int_t detElemId  = mdig->DetElemId();
	      Int_t cathode    = mdig->Cathode();

	      const AliMpVSegmentation *seg = 
		AliMpSegmentation::Instance()
                  ->GetMpSegmentation(detElemId,AliMp::GetCathodType(cathode));

	      Int_t ix = mdig->PadX(), iy = mdig->PadY();
				
	      AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));

	      AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
				
	      for (Int_t i=0; i<pad.GetNofLocations(); i++) 
	      {
		  AliMpIntPair location = pad.GetLocation(i);
					
		  Int_t nboard = location.GetFirst();

		  Int_t ibitxy = location.GetSecond();

		  AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);

		  if (b) 
		  {
		      if (cathode && b->GetSwitch(6)) ibitxy += 8;
						
		      b->SetbitM(ibitxy,cathode,ichamber-10);
						
		  }
		  else
		  {
		      AliError(Form("Could not get local board number %d",b->GetNumber()));
		 }
	      }
	  }		
      }
    }

  // Particular case of the columns with 22 local boards (2R(L) 3R(L))   
  AliMUONTriggerCrate *crate = 0x0; TObjArray *bs = 0x0;

  char *scratess[4] = {  "2R",   "2L",   "3L",   "3R"}; 
  char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"}; 
  Int_t    slotf[4] = {     2,      2,     10,     10}; 
  Int_t    slotd[4] = {     1,      1,      9,      9}; 

  for (Int_t i = 0; i < 4; i++)
  {
      crate = fCrates->Crate(scratess[i]); 
      bs = crate->Boards();
      AliMUONLocalTriggerBoard *desybb = (AliMUONLocalTriggerBoard*)bs->At(14);
      AliMUONLocalTriggerBoard *fromcb = (AliMUONLocalTriggerBoard*)bs->At(15);
      AliMUONLocalTriggerBoard *desxbb = (AliMUONLocalTriggerBoard*)bs->At(16);

      crate = fCrates->Crate(scratesd[i]); 
      bs = crate->Boards();
      AliMUONLocalTriggerBoard *frombb = (AliMUONLocalTriggerBoard*)bs->At(slotf[i]);
      AliMUONLocalTriggerBoard *desycb = (AliMUONLocalTriggerBoard*)bs->At(slotd[i]);

      UShort_t cX[2];

      //    COPY X3-4 FROM BOARD  2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
      //    COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
      frombb->GetX34(cX); desxbb->SetX34(cX);

      //    COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
      //    COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
      fromcb->GetX34(cX); desycb->SetX34(cX);

      UShort_t cY[4];

      desybb->GetY(cY); frombb->SetY(cY);

      frombb->GetY(cY); desxbb->SetY(cY);
      fromcb->GetY(cY); desycb->SetY(cY);
  }

  // FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
  AliMUONTriggerCrate* cr;
 
  fCrates->FirstCrate();
 
  while ( ( cr = fCrates->NextCrate() ) )
  {            
      TObjArray *boards = cr->Boards();
		
      for (Int_t j = 1; j < boards->GetEntries()-1; j++)
      {
	  TObject *o = boards->At(j);
			
	  if (!o) break;
			
	  AliMUONLocalTriggerBoard *currboard = (AliMUONLocalTriggerBoard*)o;
			
	  AliMUONLocalTriggerBoard *neighbour = (AliMUONLocalTriggerBoard*)boards->At(j+1);
			
	  UShort_t cXY[2][4];
			
	  if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
			
	  //       LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
	  if (j < boards->GetEntries()-2)  
	  {
	      AliMUONLocalTriggerBoard *nextboard = (AliMUONLocalTriggerBoard*)boards->At(j+2);
				
	      currboard->GetXY(cXY); neighbour->SetXYD(cXY);
	      nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
				
	      if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
	  }
      }
  }
}

//___________________________________________
void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
{
  /// FILL INPUTS
  ///
  AliMUONTriggerCrate* cr;
   
   fCrates->FirstCrate();
   
   while ( ( cr = fCrates->NextCrate() ) )
   {                 
     TObjArray *boards = cr->Boards();
     
     for (Int_t j = 1; j < boards->GetEntries(); j++)
     {
       TObject *o = boards->At(j);
       
       if (!o) break;
       
       AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
       
       board->SetXY(pattern);
     }
   }
}

//___________________________________________
void AliMUONTriggerElectronics::DumpOS()
{
/// DUMP IN THE OLD WAY
///
   for (Int_t i= 0; i < 234;i++)
   {
      AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);

      if (board) board->Scan("ALL");
   }
}

//___________________________________________
void AliMUONTriggerElectronics::Scan(Option_t *option)
{
  /// SCAN
  ///

  AliMUONTriggerCrate* cr;
  
  fCrates->FirstCrate();
  
  while ( ( cr = fCrates->NextCrate() ) )
  {                
    TObjArray *boards = cr->Boards();
    
    for (Int_t j = 0; j < boards->GetEntries(); j++)
    {
      TObject *o = boards->At(j);
      
      TString op = option;
      
      Bool_t cdtion = kFALSE;
      
      if (op.Contains("LOCAL"))    cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
      if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
      if (op.Contains("GLOBAL"))   cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
      
      if (!o || !cdtion) continue;
      
      AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
      
      board->Scan();
    }
  }
}

//___________________________________________
void AliMUONTriggerElectronics::Reset()
{
  /// RESET
  ///
  
   AliMUONTriggerCrate* cr;
   
   fCrates->FirstCrate();
   
   while ( ( cr = fCrates->NextCrate() ) )
   {            
      TObjArray *boards = cr->Boards();
            
      for (Int_t j=0; j<boards->GetEntries(); j++)
      {     
         AliMUONTriggerBoard *b = (AliMUONTriggerBoard*)boards->At(j);

         if (b) b->Reset();
      }
   }
}

//_______________________________________________________________________
void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
{
  /// LOAD MASKS FROM CDB
  

  // SET MASKS
  
  AliMUONTriggerCrate* cr;
  
  fCrates->FirstCrate();
  
  Int_t irb(0);
  
  while ( ( cr = fCrates->NextCrate() ) )
  {            
    TObjArray *boards = cr->Boards();
    
    AliMUONRegionalTriggerBoard *regb =
      (AliMUONRegionalTriggerBoard*)boards->At(0);

    AliMUONVCalibParam* regionalBoardMasks = calibData->RegionalTriggerBoardMasks(irb);
    
    for ( Int_t i = 0; i < regionalBoardMasks->Size(); ++i )
    {
      UShort_t rmask = static_cast<UShort_t>(regionalBoardMasks->ValueAsInt(i) & 0x3F);
      regb->Mask(i,rmask);
    }
    
    for (Int_t j = 1; j < boards->GetEntries(); j++)
    {
      AliMUONLocalTriggerBoard *b = (AliMUONLocalTriggerBoard*)boards->At(j);
      
      Int_t cardNumber = b->GetNumber();
      
      if (cardNumber) // interface board are not interested
      {
        AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
        for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
        {
          UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
          b->Mask(i,lmask);
        }
      }
    }
    ++irb;
  }
  
  AliMUONVCalibParam* globalBoardMasks = calibData->GlobalTriggerBoardMasks();
  for ( Int_t i = 0; i < globalBoardMasks->Size(); ++i )
  {
    UShort_t gmask = static_cast<UShort_t>(globalBoardMasks->ValueAsInt(i) & 0xFFF);
    fGlobalTriggerBoard->Mask(i,gmask);
  }
}


//___________________________________________
void AliMUONTriggerElectronics::LocalResponse()
{
/// \todo add comment
	
  AliMUONTriggerCrate* cr;
  
  fCrates->FirstCrate();
  
  while ( ( cr = fCrates->NextCrate() ) )
  {            
    
    TObjArray *boards = cr->Boards();
    
    AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
    
    UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
  
    for (Int_t j = 1; j < boards->GetEntries(); j++)
    {     
	TObject *o = boards->At(j);
      
	if (!o) break;
      
	AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
      
	if (board) // check if empty slot
	{
	  board->Response();
				
	  UShort_t response = board->GetResponse();            
        
	  // CRATE CONTAINING INTERFACE BOARD
	  if (board->GetNumber() == 0) // copy boards
	  {
	    if ( response != 0 ) 
	      AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
					  board->GetName(),j,cr->GetName()));
	    AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));

	  }
        
	  thisl[j-1] = response;
	}
      }
    
    regb->SetLocalResponse(thisl);
  }
}

//___________________________________________
void AliMUONTriggerElectronics::RegionalResponse()
{
  /// Compute the response for all regional cards.
  AliMUONTriggerCrate* cr;
  
  fCrates->FirstCrate();
  
  while ( ( cr = fCrates->NextCrate() ) )
  {            
      TObjArray *boards = cr->Boards();

      AliMUONRegionalTriggerBoard *regb = (AliMUONRegionalTriggerBoard*)boards->At(0);
      
      if (regb) 
      {
         regb->Response();
      }  
   }
}

//___________________________________________
void AliMUONTriggerElectronics::GlobalResponse()
{
  /// Compute the global response

  UShort_t regional[16];
  
  AliMUONTriggerCrate* cr;
  
  fCrates->FirstCrate();
  Int_t irb(0);
  
  if ( !fCrates->NumberOfCrates() >= 16 ) 
  {
    AliFatal(Form("Something is wrong : too many crates %d",
                  fCrates->NumberOfCrates()));
  }
  
  while ( ( cr = fCrates->NextCrate() ) )
  {            
    AliMUONTriggerBoard* rb = 
      static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
    regional[irb] = rb->GetResponse();
    ++irb;
  }
  
  fGlobalTriggerBoard->SetRegionalResponse(regional);
  fGlobalTriggerBoard->Response();
}

//_______________________________________________________________________
void 
AliMUONTriggerElectronics::Exec(Option_t*)
{
/// \todo add comment
///
  Digits2Trigger();
}

//_______________________________________________________________________
void AliMUONTriggerElectronics::Trigger()
{
/// \todo add comment
///
   FeedM();
   LocalResponse();
   RegionalResponse();      
   GlobalResponse();
}

//_______________________________________________________________________
void AliMUONTriggerElectronics::Digits2Trigger()
{
  /// Main method to go from digits to trigger decision
  AliMUONRegionalTrigger *pRegTrig = new AliMUONRegionalTrigger();
  fMUONData->ResetTrigger(); 
  // RUN THE FULL BEE CHAIN
  Trigger();
//    DumpOS();
	
  AliMUONTriggerCrate* cr;
 
  // stored in right order
  // do not used iterator order

  for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
  {            
    for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
    {
      cr = fCrates->Crate(iSide, iReg);     
      TObjArray *boards = cr->Boards();

      UInt_t regInpLpt = 0;
      UInt_t regInpHpt = 0;

      AliMUONRegionalTriggerBoard *regBoard = (AliMUONRegionalTriggerBoard*)boards->At(0);

      for (Int_t j = 1; j < boards->GetEntries(); j++)
      {     
	TObject *o = boards->At(j);
      
	if (!o) break;
      
	AliMUONLocalTriggerBoard *board = (AliMUONLocalTriggerBoard*)o;
      
	if (board) 
	{
	  //          L0 TRIGGER
// pcrochet 181206: MOOD needs ALL boards
//	  if (board->Triggered())
//	  {
          
	    Int_t icirc = board->GetNumber();
	    if (icirc != 0) { // pcrochet 181206: MOOD needs ALL boards

	    fLocalTrigger->SetLoCircuit(icirc);
	    fLocalTrigger->SetLoStripX(board->GetStripX11());
	    fLocalTrigger->SetLoDev(board->GetDev());
	    fLocalTrigger->SetLoSdev(board->GetSdev());
	    fLocalTrigger->SetLoTrigY(board->GetTrigY());
	    fLocalTrigger->SetLoStripY(board->GetStripY11());
          
	    //             SAVE LUT OUTPUT 
	    UShort_t response = board->GetResponse();
	    fLocalTrigger->SetLoHpt((response & 12) >> 2);
	    fLocalTrigger->SetLoLpt(response &  3);

	    // calculates regional inputs from local for the moment
	    UInt_t hPt = (response >> 2) & 0x3;
	    UInt_t lPt =  response       & 0x3;
	    
	    regInpHpt |= hPt << (30 - (j-1)*2);
	    regInpLpt |= lPt << (30 - (j-1)*2);

	    TBits rrr;
	    rrr.Set(6,&response);	  
          
	    //             SAVE BIT PATTERN
	    fLocalTrigger->SetX1Pattern(board->GetXY(0,0));
	    fLocalTrigger->SetX2Pattern(board->GetXY(0,1));
	    fLocalTrigger->SetX3Pattern(board->GetXY(0,2));
	    fLocalTrigger->SetX4Pattern(board->GetXY(0,3));
          
	    fLocalTrigger->SetY1Pattern(board->GetXY(1,0));
	    fLocalTrigger->SetY2Pattern(board->GetXY(1,1));
	    fLocalTrigger->SetY3Pattern(board->GetXY(1,2));
	    fLocalTrigger->SetY4Pattern(board->GetXY(1,3));
          
	    //             ADD A NEW LOCAL TRIGGER          
	    fMUONData->AddLocalTrigger(*fLocalTrigger);  
	  
	  }
	}
      }
      pRegTrig->SetId(iReg + 8*iSide);
      pRegTrig->SetLocalOutput(regInpLpt, 0);
      pRegTrig->SetLocalOutput(regInpHpt, 1);
      pRegTrig->SetOutput(regBoard->GetResponse());

      fMUONData->AddRegionalTrigger(*pRegTrig);  
    }
  }
  delete pRegTrig;
  
  // GLOBAL TRIGGER INFORMATION
  UShort_t global = fGlobalTriggerBoard->GetResponse();
  fGlobalTrigger->SetFromGlobalResponse(global);

  
  // ADD A LOCAL TRIGGER IN THE LIST 
  fMUONData->AddGlobalTrigger(*fGlobalTrigger);

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