[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 "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)
  {  
    AliFatal("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);
	  //       assert(schg==mdig->Signal());
	  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 digitindex = digit;
	      Int_t detElemId  = mdig->DetElemId();
	      Int_t cathode    = mdig->Cathode();

	      const AliMpVSegmentation *seg = 
		AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,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);
						
		      DigitFiredCircuit(b->GetI(), cathode, ichamber, digitindex);
		  }
		  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();
  ClearDigitNumbers();
  fMUONData->ResetTrigger(); 
  // RUN THE FULL BEE CHAIN
  Trigger();
//    DumpOS();
	
  AliMUONTriggerCrate* cr;
  fCrates->FirstCrate();

  while ( ( cr = fCrates->NextCrate() ) )
  {            
    TObjArray *boards = cr->Boards();

    UInt_t regInpLpt = 0;
    UInt_t regInpHpt = 0;
    UShort_t localMask = 0x0;

    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
        if (board->Triggered())
        {
          
          Int_t icirc = board->GetNumber();

          fLocalTrigger->SetLoCircuit(icirc);
          fLocalTrigger->SetLoStripX(board->GetStripX11());
          fLocalTrigger->SetLoDev(board->GetDev());
          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 >> 4) & 0x3;
	  UInt_t lPt = (response >> 2) & 0x3;
	    
	  regInpHpt |= hPt << (30 - (j-1)*2);
	  regInpLpt |= lPt << (30 - (j-1)*2);
	  localMask |= (0x1 << (j-1)); // local mask

          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));
          
	  fLocalTrigger->SetDigits(fDigitNumbers[icirc]);

          //             ADD A NEW LOCAL TRIGGER          
          fMUONData->AddLocalTrigger(*fLocalTrigger);  
	  
        }
      }
    }
    pRegTrig->SetLocalOutput(regInpLpt, 0);
    pRegTrig->SetLocalOutput(regInpHpt, 1);
    pRegTrig->SetLocalMask(localMask);
    pRegTrig->SetOutput((regBoard->GetResponse() >> 4) & 0xF); // to be uniformized (oct06 ?)

    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();
}

//_______________________________________________________________________
void AliMUONTriggerElectronics::ClearDigitNumbers()
{
// RESET fDigitNumbers
	for (Int_t i=0; i<AliMUONConstants::NTriggerCircuit(); i++) fDigitNumbers[i].Set(0);
}

//_______________________________________________________________________
void AliMUONTriggerElectronics::DigitFiredCircuit(Int_t circuit, Int_t cathode,
                                                  Int_t chamber, Int_t digit)
{
// REGISTERS THAT THE SPECIFIED DIGIT FIRED THE SPECIFIED CIRCUIT
// THIS DIGIT GETS ADDED TO AN ARRAY WHICH WILL BE COPIED TO
// AliMUONLocalTrigger WHEN SUCH AN OBJECT IS CREATED FOR EACH CIRCUIT
	Int_t digitnumber = AliMUONLocalTrigger::EncodeDigitNumber(chamber, cathode, digit);
	Int_t last = fDigitNumbers[circuit].GetSize();
	fDigitNumbers[circuit].Set(last + 1);
	fDigitNumbers[circuit][last] = digitnumber;
}
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"
	43
	44	#include "AliLog.h"
	45	#include "AliLoader.h"
	46	#include "AliRun.h"
	47
	48	//#include "Riostream.h"
	49	#include "TBits.h"
516d3280	50	#include "TSystem.h"
516d3280	51
6014107b	52	/// \cond CLASSIMP
63ed9c6b	53	ClassImp(AliMUONTriggerElectronics)
6014107b	54	/// \endcond
63ed9c6b	55
516d3280	56	//___________________________________________
4c0f0f5d	57	AliMUONTriggerElectronics::AliMUONTriggerElectronics(AliMUONData Data, AliMUONCalibrationData calibData)
516d3280	58	: TTask("AliMUONTriggerElectronics",
516d3280	59	"From trigger digits to Local and Global Trigger objects"),
43368512	60	fSourceFileName(),
f1e8d46c	61	fCrates(new AliMUONTriggerCrateStore),
516d3280	62	fGlobalTriggerBoard(new AliMUONGlobalTriggerBoard),
1908473e	63	fMUONData(Data),
	64	fLocalTrigger(new AliMUONLocalTrigger()),
	65	fGlobalTrigger(new AliMUONGlobalTrigger())
	66
516d3280	67	{
6014107b	68	/// CONSTRUCTOR
6014107b	69	///
516d3280	70	if (!fMUONData)
	71	{
	72	AliFatal("NO MUON TRIGGER DATA");
	73	}
	74
f1e8d46c	75	SetDataSource();
	76	Factory(calibData);
	77	LoadMasks(calibData);
516d3280	78	}
	79
	80	//___________________________________________
	81	AliMUONTriggerElectronics::~AliMUONTriggerElectronics()
	82	{
6014107b	83	/// DESTRUCTOR
6014107b	84	///
516d3280	85	delete fGlobalTriggerBoard;
516d3280	86	delete fCrates;
1908473e	87	delete fLocalTrigger;
	88	delete fGlobalTrigger;
	89
516d3280	90	}
	91
	92	//___________________________________________
4c0f0f5d	93	void AliMUONTriggerElectronics::Factory(AliMUONCalibrationData* calibData)
516d3280	94	{
6014107b	95	/// BUILD ALL ELECTRONICS
6014107b	96	///
e93b11d0	97
	98	// get coinc44 from AliMUON (added 12/09/06)
	99	AliMUON pMUON = (AliMUON)gAlice->GetModule("MUON");
	100	Int_t coinc44 = pMUON->GetTriggerCoinc44();
	101	if (coinc44 != 0 && coinc44 != 1) {
	102	AliFatal("Coinc 44 should be equal to 0 or 1");
	103	return;
	104	}
	105
f1e8d46c	106	fCrates->ReadFromFile(gSystem->ExpandPathName(fSourceFileName.Data()));
	107
	108	if ( !calibData ) return;
	109
	110	AliMUONTriggerLut* lut = calibData->TriggerLut();
	111
	112	if (!lut) return;
	113
	114	AliMUONLocalTriggerBoard* localBoard;
	115
	116	fCrates->FirstLocalBoard();
	117
	118	while ( (localBoard=fCrates->NextLocalBoard()) )
	119	{
	120	localBoard->SetLUT(lut);
e93b11d0	121	localBoard->SetCoinc44(coinc44);
f1e8d46c	122	}
8af755f4	123	}
516d3280	124
8af755f4	125	//___________________________________________
	126	void AliMUONTriggerElectronics::FeedM()
	127	{
6014107b	128	/// FILL INPUTS
6014107b	129	///
43368512	130	for (Int_t ichamber=10; ichamber<14; ichamber++)
43368512	131	{
f4678817	132	TClonesArray *muonDigits = fMUONData->Digits(ichamber);
f4678817	133	Int_t ndigits = muonDigits->GetEntriesFast();
8af755f4	134
8af755f4	135	for (Int_t digit=0; digit<ndigits; digit++)
43368512	136	{
43368512	137	AliMUONDigit mdig = static_cast<AliMUONDigit>(muonDigits->UncheckedAt(digit));
8af755f4	138
43368512	139	// CHECKME ! The TrackCharge is not ok with new digitizerV3 !
	140	// for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
	141	// assert(schg==mdig->Signal());
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 digitindex = digit;
	152	Int_t detElemId = mdig->DetElemId();
	153	Int_t cathode = mdig->Cathode();
8af755f4	154
43368512	155	const AliMpVSegmentation *seg =
666ada1e	156	AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,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	DigitFiredCircuit(b->GetI(), cathode, ichamber, digitindex);
	181	}
	182	else
	183	{
	184	AliError(Form("Could not get local board number %d",b->GetNumber()));
	185	}
	186	}
	187	}
	188	}
	189	}
8af755f4	190
43368512	191	// Particular case of the columns with 22 local boards (2R(L) 3R(L))
43368512	192	AliMUONTriggerCrate crate = 0x0; TObjArray bs = 0x0;
8af755f4	193
43368512	194	char *scratess[4] = { "2R", "2L", "3L", "3R"};
	195	char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"};
	196	Int_t slotf[4] = { 2, 2, 10, 10};
	197	Int_t slotd[4] = { 1, 1, 9, 9};
8af755f4	198
43368512	199	for (Int_t i = 0; i < 4; i++)
43368512	200	{
f1e8d46c	201	crate = fCrates->Crate(scratess[i]);
8af755f4	202	bs = crate->Boards();
	203	AliMUONLocalTriggerBoard desybb = (AliMUONLocalTriggerBoard)bs->At(14);
	204	AliMUONLocalTriggerBoard fromcb = (AliMUONLocalTriggerBoard)bs->At(15);
	205	AliMUONLocalTriggerBoard desxbb = (AliMUONLocalTriggerBoard)bs->At(16);
	206
f1e8d46c	207	crate = fCrates->Crate(scratesd[i]);
8af755f4	208	bs = crate->Boards();
	209	AliMUONLocalTriggerBoard frombb = (AliMUONLocalTriggerBoard)bs->At(slotf[i]);
	210	AliMUONLocalTriggerBoard desycb = (AliMUONLocalTriggerBoard)bs->At(slotd[i]);
	211
	212	UShort_t cX[2];
	213
43368512	214	// COPY X3-4 FROM BOARD 2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
43368512	215	// COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
8af755f4	216	frombb->GetX34(cX); desxbb->SetX34(cX);
8af755f4	217
43368512	218	// COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
43368512	219	// COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
8af755f4	220	fromcb->GetX34(cX); desycb->SetX34(cX);
	221
	222	UShort_t cY[4];
	223
	224	desybb->GetY(cY); frombb->SetY(cY);
	225
	226	frombb->GetY(cY); desxbb->SetY(cY);
	227	fromcb->GetY(cY); desycb->SetY(cY);
43368512	228	}
8af755f4	229
43368512	230	// FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
43368512	231	AliMUONTriggerCrate* cr;
f1e8d46c	232
43368512	233	fCrates->FirstCrate();
f1e8d46c	234
43368512	235	while ( ( cr = fCrates->NextCrate() ) )
	236	{
	237	TObjArray *boards = cr->Boards();
8af755f4	238
43368512	239	for (Int_t j = 1; j < boards->GetEntries()-1; j++)
	240	{
	241	TObject *o = boards->At(j);
8af755f4	242
43368512	243	if (!o) break;
8af755f4	244
43368512	245	AliMUONLocalTriggerBoard currboard = (AliMUONLocalTriggerBoard)o;
8af755f4	246
43368512	247	AliMUONLocalTriggerBoard neighbour = (AliMUONLocalTriggerBoard)boards->At(j+1);
8af755f4	248
43368512	249	UShort_t cXY[2][4];
8af755f4	250
43368512	251	if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
8af755f4	252
43368512	253	// LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
	254	if (j < boards->GetEntries()-2)
	255	{
	256	AliMUONLocalTriggerBoard nextboard = (AliMUONLocalTriggerBoard)boards->At(j+2);
8af755f4	257
43368512	258	currboard->GetXY(cXY); neighbour->SetXYD(cXY);
43368512	259	nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
8af755f4	260
43368512	261	if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
	262	}
	263	}
	264	}
516d3280	265	}
516d3280	266
	267	//___________________________________________
	268	void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
	269	{
6014107b	270	/// FILL INPUTS
6014107b	271	///
f1e8d46c	272	AliMUONTriggerCrate* cr;
	273
	274	fCrates->FirstCrate();
	275
	276	while ( ( cr = fCrates->NextCrate() ) )
	277	{
	278	TObjArray *boards = cr->Boards();
	279
43368512	280	for (Int_t j = 1; j < boards->GetEntries(); j++)
f1e8d46c	281	{
	282	TObject *o = boards->At(j);
	283
	284	if (!o) break;
	285
	286	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
	287
	288	board->SetXY(pattern);
	289	}
516d3280	290	}
	291	}
	292
	293	//___________________________________________
	294	void AliMUONTriggerElectronics::DumpOS()
	295	{
6014107b	296	/// DUMP IN THE OLD WAY
6014107b	297	///
43368512	298	for (Int_t i= 0; i < 234;i++)
516d3280	299	{
f1e8d46c	300	AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
516d3280	301
43368512	302	if (board) board->Scan("ALL");
516d3280	303	}
	304	}
	305
	306	//___________________________________________
	307	void AliMUONTriggerElectronics::Scan(Option_t *option)
	308	{
6014107b	309	/// SCAN
6014107b	310	///
516d3280	311
f1e8d46c	312	AliMUONTriggerCrate* cr;
	313
	314	fCrates->FirstCrate();
	315
	316	while ( ( cr = fCrates->NextCrate() ) )
43368512	317	{
f1e8d46c	318	TObjArray *boards = cr->Boards();
f1e8d46c	319
43368512	320	for (Int_t j = 0; j < boards->GetEntries(); j++)
f1e8d46c	321	{
	322	TObject *o = boards->At(j);
	323
	324	TString op = option;
	325
	326	Bool_t cdtion = kFALSE;
	327
	328	if (op.Contains("LOCAL")) cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
	329	if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
	330	if (op.Contains("GLOBAL")) cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
	331
	332	if (!o \|\| !cdtion) continue;
	333
	334	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
	335
	336	board->Scan();
	337	}
	338	}
516d3280	339	}
	340
	341	//___________________________________________
	342	void AliMUONTriggerElectronics::Reset()
	343	{
6014107b	344	/// RESET
6014107b	345	///
f1e8d46c	346
	347	AliMUONTriggerCrate* cr;
	348
	349	fCrates->FirstCrate();
	350
	351	while ( ( cr = fCrates->NextCrate() ) )
516d3280	352	{
516d3280	353	TObjArray *boards = cr->Boards();
	354
	355	for (Int_t j=0; j<boards->GetEntries(); j++)
	356	{
	357	AliMUONTriggerBoard b = (AliMUONTriggerBoard)boards->At(j);
	358
	359	if (b) b->Reset();
	360	}
	361	}
	362	}
	363
4c0f0f5d	364	//_______________________________________________________________________
	365	void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
	366	{
	367	// LOAD MASKS FROM CDB
	368
	369
	370	// SET MASKS
f1e8d46c	371
	372	AliMUONTriggerCrate* cr;
	373
	374	fCrates->FirstCrate();
	375
	376	Int_t irb(0);
	377
	378	while ( ( cr = fCrates->NextCrate() ) )
43368512	379	{
4c0f0f5d	380	TObjArray *boards = cr->Boards();
	381
	382	AliMUONRegionalTriggerBoard *regb =
	383	(AliMUONRegionalTriggerBoard*)boards->At(0);
	384
f1e8d46c	385	AliMUONVCalibParam* regionalBoardMasks = calibData->RegionalTriggerBoardMasks(irb);
4c0f0f5d	386
	387	for ( Int_t i = 0; i < regionalBoardMasks->Size(); ++i )
	388	{
	389	UShort_t rmask = static_cast<UShort_t>(regionalBoardMasks->ValueAsInt(i) & 0x3F);
	390	regb->Mask(i,rmask);
	391	}
	392
43368512	393	for (Int_t j = 1; j < boards->GetEntries(); j++)
4c0f0f5d	394	{
	395	AliMUONLocalTriggerBoard b = (AliMUONLocalTriggerBoard)boards->At(j);
	396
	397	Int_t cardNumber = b->GetNumber();
	398
	399	if (cardNumber) // interface board are not interested
	400	{
	401	AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
	402	for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
	403	{
	404	UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
	405	b->Mask(i,lmask);
	406	}
	407	}
	408	}
f1e8d46c	409	++irb;
4c0f0f5d	410	}
	411
	412	AliMUONVCalibParam* globalBoardMasks = calibData->GlobalTriggerBoardMasks();
	413	for ( Int_t i = 0; i < globalBoardMasks->Size(); ++i )
	414	{
	415	UShort_t gmask = static_cast<UShort_t>(globalBoardMasks->ValueAsInt(i) & 0xFFF);
	416	fGlobalTriggerBoard->Mask(i,gmask);
	417	}
	418	}
	419
	420
516d3280	421	//___________________________________________
	422	void AliMUONTriggerElectronics::LocalResponse()
	423	{
6014107b	424	/// \todo add comment
516d3280	425
f1e8d46c	426	AliMUONTriggerCrate* cr;
	427
	428	fCrates->FirstCrate();
	429
	430	while ( ( cr = fCrates->NextCrate() ) )
43368512	431	{
f1e8d46c	432
	433	TObjArray *boards = cr->Boards();
	434
	435	AliMUONRegionalTriggerBoard regb = (AliMUONRegionalTriggerBoard)boards->At(0);
	436
	437	UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
29e3f51e	438
29e3f51e	439	for (Int_t j = 1; j < boards->GetEntries(); j++)
f1e8d46c	440	{
43368512	441	TObject *o = boards->At(j);
f1e8d46c	442
43368512	443	if (!o) break;
f1e8d46c	444
43368512	445	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
f1e8d46c	446
29e3f51e	447	if (board) // check if empty slot
43368512	448	{
43368512	449	board->Response();
516d3280	450
29e3f51e	451	UShort_t response = board->GetResponse();
f1e8d46c	452
29e3f51e	453	// CRATE CONTAINING INTERFACE BOARD
	454	if (board->GetNumber() == 0) // copy boards
	455	{
	456	if ( response != 0 )
	457	AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
43368512	458	board->GetName(),j,cr->GetName()));
29e3f51e	459	AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
	460
	461	}
f1e8d46c	462
29e3f51e	463	thisl[j-1] = response;
43368512	464	}
516d3280	465	}
f1e8d46c	466
	467	regb->SetLocalResponse(thisl);
	468	}
516d3280	469	}
	470
	471	//___________________________________________
	472	void AliMUONTriggerElectronics::RegionalResponse()
	473	{
f1e8d46c	474	/// Compute the response for all regional cards.
	475	AliMUONTriggerCrate* cr;
	476
	477	fCrates->FirstCrate();
	478
	479	while ( ( cr = fCrates->NextCrate() ) )
43368512	480	{
516d3280	481	TObjArray *boards = cr->Boards();
	482
	483	AliMUONRegionalTriggerBoard regb = (AliMUONRegionalTriggerBoard)boards->At(0);
	484
	485	if (regb)
	486	{
	487	regb->Response();
516d3280	488	}
	489	}
	490	}
	491
	492	//___________________________________________
	493	void AliMUONTriggerElectronics::GlobalResponse()
	494	{
f1e8d46c	495	/// Compute the global response
516d3280	496
f1e8d46c	497	UShort_t regional[16];
	498
	499	AliMUONTriggerCrate* cr;
	500
	501	fCrates->FirstCrate();
	502	Int_t irb(0);
	503
	504	if ( !fCrates->NumberOfCrates() >= 16 )
	505	{
	506	AliFatal(Form("Something is wrong : too many crates %d",
	507	fCrates->NumberOfCrates()));
	508	}
	509
	510	while ( ( cr = fCrates->NextCrate() ) )
43368512	511	{
f1e8d46c	512	AliMUONTriggerBoard* rb =
	513	static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
	514	regional[irb] = rb->GetResponse();
	515	++irb;
	516	}
	517
	518	fGlobalTriggerBoard->SetRegionalResponse(regional);
	519	fGlobalTriggerBoard->Response();
516d3280	520	}
516d3280	521
516d3280	522	//_______________________________________________________________________
	523	void
	524	AliMUONTriggerElectronics::Exec(Option_t*)
	525	{
6014107b	526	/// \todo add comment
6014107b	527	///
516d3280	528	Digits2Trigger();
	529	}
	530
	531	//_______________________________________________________________________
	532	void AliMUONTriggerElectronics::Trigger()
	533	{
6014107b	534	/// \todo add comment
6014107b	535	///
8af755f4	536	FeedM();
516d3280	537	LocalResponse();
	538	RegionalResponse();
	539	GlobalResponse();
	540	}
516d3280	541
516d3280	542	//_______________________________________________________________________
	543	void AliMUONTriggerElectronics::Digits2Trigger()
	544	{
f1e8d46c	545	/// Main method to go from digits to trigger decision
47dc4ee7	546	AliMUONRegionalTrigger *pRegTrig = new AliMUONRegionalTrigger();
f1e8d46c	547	ClearDigitNumbers();
f1e8d46c	548	fMUONData->ResetTrigger();
f1e8d46c	549	// RUN THE FULL BEE CHAIN
f1e8d46c	550	Trigger();
68ee8c5e	551	// DumpOS();
8af755f4	552
f1e8d46c	553	AliMUONTriggerCrate* cr;
f1e8d46c	554	fCrates->FirstCrate();
68ee8c5e	555
f1e8d46c	556	while ( ( cr = fCrates->NextCrate() ) )
	557	{
	558	TObjArray *boards = cr->Boards();
47dc4ee7	559
	560	UInt_t regInpLpt = 0;
	561	UInt_t regInpHpt = 0;
	562	UShort_t localMask = 0x0;
	563
	564	AliMUONRegionalTriggerBoard regBoard = (AliMUONRegionalTriggerBoard)boards->At(0);
	565
	566	for (Int_t j = 1; j < boards->GetEntries(); j++)
f1e8d46c	567	{
	568	TObject *o = boards->At(j);
	569
	570	if (!o) break;
	571
	572	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
	573
	574	if (board)
	575	{
	576	// L0 TRIGGER
	577	if (board->Triggered())
	578	{
f1e8d46c	579
f1e8d46c	580	Int_t icirc = board->GetNumber();
68ee8c5e	581
1908473e	582	fLocalTrigger->SetLoCircuit(icirc);
	583	fLocalTrigger->SetLoStripX(board->GetStripX11());
	584	fLocalTrigger->SetLoDev(board->GetDev());
	585	fLocalTrigger->SetLoStripY(board->GetStripY11());
f1e8d46c	586
	587	// SAVE LUT OUTPUT
	588	UShort_t response = board->GetResponse();
ad705f30	589	fLocalTrigger->SetLoHpt((response & 12) >> 2);
ad705f30	590	fLocalTrigger->SetLoLpt(response & 3);
47dc4ee7	591
	592	// calculates regional inputs from local for the moment
	593	UInt_t hPt = (response >> 4) & 0x3;
	594	UInt_t lPt = (response >> 2) & 0x3;
	595
	596	regInpHpt \|= hPt << (30 - (j-1)*2);
	597	regInpLpt \|= lPt << (30 - (j-1)*2);
	598	localMask \|= (0x1 << (j-1)); // local mask
	599
f1e8d46c	600	TBits rrr;
68ee8c5e	601	rrr.Set(6,&response);
f1e8d46c	602
f1e8d46c	603	// SAVE BIT PATTERN
1908473e	604	fLocalTrigger->SetX1Pattern(board->GetXY(0,0));
	605	fLocalTrigger->SetX2Pattern(board->GetXY(0,1));
	606	fLocalTrigger->SetX3Pattern(board->GetXY(0,2));
	607	fLocalTrigger->SetX4Pattern(board->GetXY(0,3));
f1e8d46c	608
1908473e	609	fLocalTrigger->SetY1Pattern(board->GetXY(1,0));
	610	fLocalTrigger->SetY2Pattern(board->GetXY(1,1));
	611	fLocalTrigger->SetY3Pattern(board->GetXY(1,2));
	612	fLocalTrigger->SetY4Pattern(board->GetXY(1,3));
f1e8d46c	613
1908473e	614	fLocalTrigger->SetDigits(fDigitNumbers[icirc]);
	615
	616	// ADD A NEW LOCAL TRIGGER
	617	fMUONData->AddLocalTrigger(*fLocalTrigger);
68ee8c5e	618
f1e8d46c	619	}
516d3280	620	}
f1e8d46c	621	}
47dc4ee7	622	pRegTrig->SetLocalOutput(regInpLpt, 0);
	623	pRegTrig->SetLocalOutput(regInpHpt, 1);
	624	pRegTrig->SetLocalMask(localMask);
	625	pRegTrig->SetOutput((regBoard->GetResponse() >> 4) & 0xF); // to be uniformized (oct06 ?)
	626
	627	fMUONData->AddRegionalTrigger(*pRegTrig);
68ee8c5e	628
f1e8d46c	629	}
47dc4ee7	630	delete pRegTrig;
f1e8d46c	631
1908473e	632	// GLOBAL TRIGGER INFORMATION
f1e8d46c	633	UShort_t global = fGlobalTriggerBoard->GetResponse();
8d4fefab	634	fGlobalTrigger->SetFromGlobalResponse(global);
8d4fefab	635
f1e8d46c	636
f1e8d46c	637	// ADD A LOCAL TRIGGER IN THE LIST
1908473e	638	fMUONData->AddGlobalTrigger(*fGlobalTrigger);
47dc4ee7	639
f1e8d46c	640	// NOW RESET ELECTRONICS
f1e8d46c	641	Reset();
516d3280	642	}
	643
	644	//_______________________________________________________________________
	645	void AliMUONTriggerElectronics::ClearDigitNumbers()
	646	{
	647	// RESET fDigitNumbers
	648	for (Int_t i=0; i<AliMUONConstants::NTriggerCircuit(); i++) fDigitNumbers[i].Set(0);
	649	}
	650
	651	//_______________________________________________________________________
	652	void AliMUONTriggerElectronics::DigitFiredCircuit(Int_t circuit, Int_t cathode,
	653	Int_t chamber, Int_t digit)
	654	{
	655	// REGISTERS THAT THE SPECIFIED DIGIT FIRED THE SPECIFIED CIRCUIT
	656	// THIS DIGIT GETS ADDED TO AN ARRAY WHICH WILL BE COPIED TO
	657	// AliMUONLocalTrigger WHEN SUCH AN OBJECT IS CREATED FOR EACH CIRCUIT
	658	Int_t digitnumber = AliMUONLocalTrigger::EncodeDigitNumber(chamber, cathode, digit);
	659	Int_t last = fDigitNumbers[circuit].GetSize();
	660	fDigitNumbers[circuit].Set(last + 1);
	661	fDigitNumbers[circuit][last] = digitnumber;
	662	}
	663