[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)
  {  
    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,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
	  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 >> 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"
	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)
516d3280	71	{
64860867	72	AliWarning("NO MUON TRIGGER DATA");
516d3280	73	}
516d3280	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 !
43368512	140	// for (Int_t ichg=0; ichg<10; ichg++) schg += mdig->TrackCharge(ichg);
8d4fefab	141	Int_t schg = (Int_t)(mdig->Signal() + 0.5);
516d3280	142
43368512	143	// APPLY CONDITION ON SOFT BACKGROUND
43368512	144	Int_t tchg = schg - (Int_t(schg/10))*10;
516d3280	145
43368512	146	if (schg<=10 \|\| tchg>0)
	147	{
	148	// mdig->Print();
516d3280	149
43368512	150	Int_t detElemId = mdig->DetElemId();
43368512	151	Int_t cathode = mdig->Cathode();
8af755f4	152
43368512	153	const AliMpVSegmentation *seg =
666ada1e	154	AliMpSegmentation::Instance()->GetMpSegmentation(detElemId,cathode);
8af755f4	155
43368512	156	Int_t ix = mdig->PadX(), iy = mdig->PadY();
8af755f4	157
43368512	158	AliDebug(3,Form("cathode %d ix %d iy %d ",cathode,ix,iy));
8af755f4	159
43368512	160	AliMpPad pad = seg->PadByIndices(AliMpIntPair(ix,iy),kTRUE);
8af755f4	161
43368512	162	for (Int_t i=0; i<pad.GetNofLocations(); i++)
	163	{
	164	AliMpIntPair location = pad.GetLocation(i);
8af755f4	165
43368512	166	Int_t nboard = location.GetFirst();
8af755f4	167
43368512	168	Int_t ibitxy = location.GetSecond();
8af755f4	169
43368512	170	AliMUONLocalTriggerBoard *b = fCrates->LocalBoard(nboard);
8af755f4	171
43368512	172	if (b)
	173	{
	174	if (cathode && b->GetSwitch(6)) ibitxy += 8;
8af755f4	175
43368512	176	b->SetbitM(ibitxy,cathode,ichamber-10);
8af755f4	177
43368512	178	}
	179	else
	180	{
	181	AliError(Form("Could not get local board number %d",b->GetNumber()));
	182	}
	183	}
	184	}
	185	}
	186	}
8af755f4	187
43368512	188	// Particular case of the columns with 22 local boards (2R(L) 3R(L))
43368512	189	AliMUONTriggerCrate crate = 0x0; TObjArray bs = 0x0;
8af755f4	190
43368512	191	char *scratess[4] = { "2R", "2L", "3L", "3R"};
	192	char *scratesd[4] = {"2-3R", "2-3L", "2-3L", "2-3R"};
	193	Int_t slotf[4] = { 2, 2, 10, 10};
	194	Int_t slotd[4] = { 1, 1, 9, 9};
8af755f4	195
43368512	196	for (Int_t i = 0; i < 4; i++)
43368512	197	{
f1e8d46c	198	crate = fCrates->Crate(scratess[i]);
8af755f4	199	bs = crate->Boards();
	200	AliMUONLocalTriggerBoard desybb = (AliMUONLocalTriggerBoard)bs->At(14);
	201	AliMUONLocalTriggerBoard fromcb = (AliMUONLocalTriggerBoard)bs->At(15);
	202	AliMUONLocalTriggerBoard desxbb = (AliMUONLocalTriggerBoard)bs->At(16);
	203
f1e8d46c	204	crate = fCrates->Crate(scratesd[i]);
8af755f4	205	bs = crate->Boards();
	206	AliMUONLocalTriggerBoard frombb = (AliMUONLocalTriggerBoard)bs->At(slotf[i]);
	207	AliMUONLocalTriggerBoard desycb = (AliMUONLocalTriggerBoard)bs->At(slotd[i]);
	208
	209	UShort_t cX[2];
	210
43368512	211	// COPY X3-4 FROM BOARD 2 OF CRATE 2-3 TO BOARD 16 OF CRATE 2
43368512	212	// COPY X3-4 FROM BOARD 10 OF CRATE 2-3 TO BOARD 16 OF CRATE 3
8af755f4	213	frombb->GetX34(cX); desxbb->SetX34(cX);
8af755f4	214
43368512	215	// COPY X3-4 FROM BOARD 15 OF CRATE 2 TO BOARD 1 OF CRATE 2-3
43368512	216	// COPY X3-4 FROM BOARD 15 OF CRATE 3 TO BOARD 9 OF CRATE 2-3
8af755f4	217	fromcb->GetX34(cX); desycb->SetX34(cX);
	218
	219	UShort_t cY[4];
	220
	221	desybb->GetY(cY); frombb->SetY(cY);
	222
	223	frombb->GetY(cY); desxbb->SetY(cY);
	224	fromcb->GetY(cY); desycb->SetY(cY);
43368512	225	}
8af755f4	226
43368512	227	// FILL UP/DOWN OF CURRENT BOARD (DONE VIA J3 BUS IN REAL LIFE)
43368512	228	AliMUONTriggerCrate* cr;
f1e8d46c	229
43368512	230	fCrates->FirstCrate();
f1e8d46c	231
43368512	232	while ( ( cr = fCrates->NextCrate() ) )
	233	{
	234	TObjArray *boards = cr->Boards();
8af755f4	235
43368512	236	for (Int_t j = 1; j < boards->GetEntries()-1; j++)
	237	{
	238	TObject *o = boards->At(j);
8af755f4	239
43368512	240	if (!o) break;
8af755f4	241
43368512	242	AliMUONLocalTriggerBoard currboard = (AliMUONLocalTriggerBoard)o;
8af755f4	243
43368512	244	AliMUONLocalTriggerBoard neighbour = (AliMUONLocalTriggerBoard)boards->At(j+1);
8af755f4	245
43368512	246	UShort_t cXY[2][4];
8af755f4	247
43368512	248	if (j==1) {neighbour->GetXY(cXY); currboard->SetXYU(cXY);}
8af755f4	249
43368512	250	// LAST BOARD IN THE CRATE HAS NO UP EXCEPT FOR CRATES 2 & 3
	251	if (j < boards->GetEntries()-2)
	252	{
	253	AliMUONLocalTriggerBoard nextboard = (AliMUONLocalTriggerBoard)boards->At(j+2);
8af755f4	254
43368512	255	currboard->GetXY(cXY); neighbour->SetXYD(cXY);
43368512	256	nextboard->GetXY(cXY); neighbour->SetXYU(cXY);
8af755f4	257
43368512	258	if (j==boards->GetEntries()-3) {neighbour->GetXY(cXY); nextboard->SetXYD(cXY);}
	259	}
	260	}
	261	}
516d3280	262	}
516d3280	263
	264	//___________________________________________
	265	void AliMUONTriggerElectronics::Feed(UShort_t pattern[2][4])
	266	{
6014107b	267	/// FILL INPUTS
6014107b	268	///
f1e8d46c	269	AliMUONTriggerCrate* cr;
	270
	271	fCrates->FirstCrate();
	272
	273	while ( ( cr = fCrates->NextCrate() ) )
	274	{
	275	TObjArray *boards = cr->Boards();
	276
43368512	277	for (Int_t j = 1; j < boards->GetEntries(); j++)
f1e8d46c	278	{
	279	TObject *o = boards->At(j);
	280
	281	if (!o) break;
	282
	283	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
	284
	285	board->SetXY(pattern);
	286	}
516d3280	287	}
	288	}
	289
	290	//___________________________________________
	291	void AliMUONTriggerElectronics::DumpOS()
	292	{
6014107b	293	/// DUMP IN THE OLD WAY
6014107b	294	///
43368512	295	for (Int_t i= 0; i < 234;i++)
516d3280	296	{
f1e8d46c	297	AliMUONLocalTriggerBoard *board = fCrates->LocalBoard(i);
516d3280	298
43368512	299	if (board) board->Scan("ALL");
516d3280	300	}
	301	}
	302
	303	//___________________________________________
	304	void AliMUONTriggerElectronics::Scan(Option_t *option)
	305	{
6014107b	306	/// SCAN
6014107b	307	///
516d3280	308
f1e8d46c	309	AliMUONTriggerCrate* cr;
	310
	311	fCrates->FirstCrate();
	312
	313	while ( ( cr = fCrates->NextCrate() ) )
43368512	314	{
f1e8d46c	315	TObjArray *boards = cr->Boards();
f1e8d46c	316
43368512	317	for (Int_t j = 0; j < boards->GetEntries(); j++)
f1e8d46c	318	{
	319	TObject *o = boards->At(j);
	320
	321	TString op = option;
	322
	323	Bool_t cdtion = kFALSE;
	324
	325	if (op.Contains("LOCAL")) cdtion = o->IsA() == AliMUONLocalTriggerBoard::Class();
	326	if (op.Contains("REGIONAL")) cdtion = o->IsA() == AliMUONRegionalTriggerBoard::Class();
	327	if (op.Contains("GLOBAL")) cdtion = o->IsA() == AliMUONGlobalTriggerBoard::Class();
	328
	329	if (!o \|\| !cdtion) continue;
	330
	331	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
	332
	333	board->Scan();
	334	}
	335	}
516d3280	336	}
	337
	338	//___________________________________________
	339	void AliMUONTriggerElectronics::Reset()
	340	{
6014107b	341	/// RESET
6014107b	342	///
f1e8d46c	343
	344	AliMUONTriggerCrate* cr;
	345
	346	fCrates->FirstCrate();
	347
	348	while ( ( cr = fCrates->NextCrate() ) )
516d3280	349	{
516d3280	350	TObjArray *boards = cr->Boards();
	351
	352	for (Int_t j=0; j<boards->GetEntries(); j++)
	353	{
	354	AliMUONTriggerBoard b = (AliMUONTriggerBoard)boards->At(j);
	355
	356	if (b) b->Reset();
	357	}
	358	}
	359	}
	360
4c0f0f5d	361	//_______________________________________________________________________
	362	void AliMUONTriggerElectronics::LoadMasks(AliMUONCalibrationData* calibData)
	363	{
	364	// LOAD MASKS FROM CDB
	365
	366
	367	// SET MASKS
f1e8d46c	368
	369	AliMUONTriggerCrate* cr;
	370
	371	fCrates->FirstCrate();
	372
	373	Int_t irb(0);
	374
	375	while ( ( cr = fCrates->NextCrate() ) )
43368512	376	{
4c0f0f5d	377	TObjArray *boards = cr->Boards();
	378
	379	AliMUONRegionalTriggerBoard *regb =
	380	(AliMUONRegionalTriggerBoard*)boards->At(0);
	381
f1e8d46c	382	AliMUONVCalibParam* regionalBoardMasks = calibData->RegionalTriggerBoardMasks(irb);
4c0f0f5d	383
	384	for ( Int_t i = 0; i < regionalBoardMasks->Size(); ++i )
	385	{
	386	UShort_t rmask = static_cast<UShort_t>(regionalBoardMasks->ValueAsInt(i) & 0x3F);
	387	regb->Mask(i,rmask);
	388	}
	389
43368512	390	for (Int_t j = 1; j < boards->GetEntries(); j++)
4c0f0f5d	391	{
	392	AliMUONLocalTriggerBoard b = (AliMUONLocalTriggerBoard)boards->At(j);
	393
	394	Int_t cardNumber = b->GetNumber();
	395
	396	if (cardNumber) // interface board are not interested
	397	{
	398	AliMUONVCalibParam* localBoardMasks = calibData->LocalTriggerBoardMasks(cardNumber);
	399	for ( Int_t i = 0; i < localBoardMasks->Size(); ++i )
	400	{
	401	UShort_t lmask = static_cast<UShort_t>(localBoardMasks->ValueAsInt(i) & 0xFFFF);
	402	b->Mask(i,lmask);
	403	}
	404	}
	405	}
f1e8d46c	406	++irb;
4c0f0f5d	407	}
	408
	409	AliMUONVCalibParam* globalBoardMasks = calibData->GlobalTriggerBoardMasks();
	410	for ( Int_t i = 0; i < globalBoardMasks->Size(); ++i )
	411	{
	412	UShort_t gmask = static_cast<UShort_t>(globalBoardMasks->ValueAsInt(i) & 0xFFF);
	413	fGlobalTriggerBoard->Mask(i,gmask);
	414	}
	415	}
	416
	417
516d3280	418	//___________________________________________
	419	void AliMUONTriggerElectronics::LocalResponse()
	420	{
6014107b	421	/// \todo add comment
516d3280	422
f1e8d46c	423	AliMUONTriggerCrate* cr;
	424
	425	fCrates->FirstCrate();
	426
	427	while ( ( cr = fCrates->NextCrate() ) )
43368512	428	{
f1e8d46c	429
	430	TObjArray *boards = cr->Boards();
	431
	432	AliMUONRegionalTriggerBoard regb = (AliMUONRegionalTriggerBoard)boards->At(0);
	433
	434	UShort_t thisl[16]; for (Int_t j=0; j<16; j++) thisl[j] = 0;
29e3f51e	435
29e3f51e	436	for (Int_t j = 1; j < boards->GetEntries(); j++)
f1e8d46c	437	{
43368512	438	TObject *o = boards->At(j);
f1e8d46c	439
43368512	440	if (!o) break;
f1e8d46c	441
43368512	442	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
f1e8d46c	443
29e3f51e	444	if (board) // check if empty slot
43368512	445	{
43368512	446	board->Response();
516d3280	447
29e3f51e	448	UShort_t response = board->GetResponse();
f1e8d46c	449
29e3f51e	450	// CRATE CONTAINING INTERFACE BOARD
	451	if (board->GetNumber() == 0) // copy boards
	452	{
	453	if ( response != 0 )
	454	AliWarning(Form("Interface board %s in slot %d of crate %s has a non zero response",
43368512	455	board->GetName(),j,cr->GetName()));
29e3f51e	456	AliDebug(1, Form("local slot %d, number %d in crate %s\n", j, board->GetNumber(), cr->GetName()));
	457
	458	}
f1e8d46c	459
29e3f51e	460	thisl[j-1] = response;
43368512	461	}
516d3280	462	}
f1e8d46c	463
	464	regb->SetLocalResponse(thisl);
	465	}
516d3280	466	}
	467
	468	//___________________________________________
	469	void AliMUONTriggerElectronics::RegionalResponse()
	470	{
f1e8d46c	471	/// Compute the response for all regional cards.
	472	AliMUONTriggerCrate* cr;
	473
	474	fCrates->FirstCrate();
	475
	476	while ( ( cr = fCrates->NextCrate() ) )
43368512	477	{
516d3280	478	TObjArray *boards = cr->Boards();
	479
	480	AliMUONRegionalTriggerBoard regb = (AliMUONRegionalTriggerBoard)boards->At(0);
	481
	482	if (regb)
	483	{
	484	regb->Response();
516d3280	485	}
	486	}
	487	}
	488
	489	//___________________________________________
	490	void AliMUONTriggerElectronics::GlobalResponse()
	491	{
f1e8d46c	492	/// Compute the global response
516d3280	493
f1e8d46c	494	UShort_t regional[16];
	495
	496	AliMUONTriggerCrate* cr;
	497
	498	fCrates->FirstCrate();
	499	Int_t irb(0);
	500
	501	if ( !fCrates->NumberOfCrates() >= 16 )
	502	{
	503	AliFatal(Form("Something is wrong : too many crates %d",
	504	fCrates->NumberOfCrates()));
	505	}
	506
	507	while ( ( cr = fCrates->NextCrate() ) )
43368512	508	{
f1e8d46c	509	AliMUONTriggerBoard* rb =
	510	static_cast<AliMUONTriggerBoard*>(cr->Boards()->At(0));
	511	regional[irb] = rb->GetResponse();
	512	++irb;
	513	}
	514
	515	fGlobalTriggerBoard->SetRegionalResponse(regional);
	516	fGlobalTriggerBoard->Response();
516d3280	517	}
516d3280	518
516d3280	519	//_______________________________________________________________________
	520	void
	521	AliMUONTriggerElectronics::Exec(Option_t*)
	522	{
6014107b	523	/// \todo add comment
6014107b	524	///
516d3280	525	Digits2Trigger();
	526	}
	527
	528	//_______________________________________________________________________
	529	void AliMUONTriggerElectronics::Trigger()
	530	{
6014107b	531	/// \todo add comment
6014107b	532	///
8af755f4	533	FeedM();
516d3280	534	LocalResponse();
	535	RegionalResponse();
	536	GlobalResponse();
	537	}
516d3280	538
516d3280	539	//_______________________________________________________________________
	540	void AliMUONTriggerElectronics::Digits2Trigger()
	541	{
f1e8d46c	542	/// Main method to go from digits to trigger decision
47dc4ee7	543	AliMUONRegionalTrigger *pRegTrig = new AliMUONRegionalTrigger();
f1e8d46c	544	fMUONData->ResetTrigger();
f1e8d46c	545	// RUN THE FULL BEE CHAIN
f1e8d46c	546	Trigger();
68ee8c5e	547	// DumpOS();
8af755f4	548
f1e8d46c	549	AliMUONTriggerCrate* cr;
6a6a56b4	550
	551	// stored in right order
	552	// do not used iterator order
68ee8c5e	553
6a6a56b4	554	for (Int_t iSide = 0; iSide < 2; iSide++) // right & left side
f1e8d46c	555	{
6a6a56b4	556	for (Int_t iReg = 0; iReg < 8; iReg++) // 8 crates/regional boards for each side.
	557	{
	558	cr = fCrates->Crate(iSide, iReg);
	559	TObjArray *boards = cr->Boards();
47dc4ee7	560
6a6a56b4	561	UInt_t regInpLpt = 0;
6a6a56b4	562	UInt_t regInpHpt = 0;
47dc4ee7	563
6a6a56b4	564	AliMUONRegionalTriggerBoard regBoard = (AliMUONRegionalTriggerBoard)boards->At(0);
47dc4ee7	565
6a6a56b4	566	for (Int_t j = 1; j < boards->GetEntries(); j++)
	567	{
	568	TObject *o = boards->At(j);
f1e8d46c	569
6a6a56b4	570	if (!o) break;
f1e8d46c	571
6a6a56b4	572	AliMUONLocalTriggerBoard board = (AliMUONLocalTriggerBoard)o;
f1e8d46c	573
6a6a56b4	574	if (board)
	575	{
	576	// L0 TRIGGER
	577	if (board->Triggered())
	578	{
f1e8d46c	579
6a6a56b4	580	Int_t icirc = board->GetNumber();
68ee8c5e	581
6a6a56b4	582	fLocalTrigger->SetLoCircuit(icirc);
	583	fLocalTrigger->SetLoStripX(board->GetStripX11());
	584	fLocalTrigger->SetLoDev(board->GetDev());
	585	fLocalTrigger->SetLoStripY(board->GetStripY11());
f1e8d46c	586
6a6a56b4	587	// SAVE LUT OUTPUT
	588	UShort_t response = board->GetResponse();
	589	fLocalTrigger->SetLoHpt((response & 12) >> 2);
	590	fLocalTrigger->SetLoLpt(response & 3);
	591
	592	// calculates regional inputs from local for the moment
4798d385	593	UInt_t hPt = (response >> 2) & 0x3;
4798d385	594	UInt_t lPt = response & 0x3;
47dc4ee7	595
6a6a56b4	596	regInpHpt \|= hPt << (30 - (j-1)*2);
6a6a56b4	597	regInpLpt \|= lPt << (30 - (j-1)*2);
47dc4ee7	598
6a6a56b4	599	TBits rrr;
6a6a56b4	600	rrr.Set(6,&response);
f1e8d46c	601
6a6a56b4	602	// SAVE BIT PATTERN
	603	fLocalTrigger->SetX1Pattern(board->GetXY(0,0));
	604	fLocalTrigger->SetX2Pattern(board->GetXY(0,1));
	605	fLocalTrigger->SetX3Pattern(board->GetXY(0,2));
	606	fLocalTrigger->SetX4Pattern(board->GetXY(0,3));
f1e8d46c	607
6a6a56b4	608	fLocalTrigger->SetY1Pattern(board->GetXY(1,0));
	609	fLocalTrigger->SetY2Pattern(board->GetXY(1,1));
	610	fLocalTrigger->SetY3Pattern(board->GetXY(1,2));
	611	fLocalTrigger->SetY4Pattern(board->GetXY(1,3));
f1e8d46c	612
6a6a56b4	613	// ADD A NEW LOCAL TRIGGER
6a6a56b4	614	fMUONData->AddLocalTrigger(*fLocalTrigger);
68ee8c5e	615
6a6a56b4	616	}
6a6a56b4	617	}
516d3280	618	}
4798d385	619	pRegTrig->SetId(iReg + 8*iSide);
6a6a56b4	620	pRegTrig->SetLocalOutput(regInpLpt, 0);
6a6a56b4	621	pRegTrig->SetLocalOutput(regInpHpt, 1);
4798d385	622	pRegTrig->SetOutput(regBoard->GetResponse());
47dc4ee7	623
6a6a56b4	624	fMUONData->AddRegionalTrigger(*pRegTrig);
6a6a56b4	625	}
f1e8d46c	626	}
47dc4ee7	627	delete pRegTrig;
f1e8d46c	628
1908473e	629	// GLOBAL TRIGGER INFORMATION
f1e8d46c	630	UShort_t global = fGlobalTriggerBoard->GetResponse();
8d4fefab	631	fGlobalTrigger->SetFromGlobalResponse(global);
8d4fefab	632
f1e8d46c	633
f1e8d46c	634	// ADD A LOCAL TRIGGER IN THE LIST
1908473e	635	fMUONData->AddGlobalTrigger(*fGlobalTrigger);
47dc4ee7	636
f1e8d46c	637	// NOW RESET ELECTRONICS
f1e8d46c	638	Reset();
516d3280	639	}
516d3280	640