[u/mrichter/AliRoot.git] / MUON / AliMUONDigitMaker.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.                  *
 **************************************************************************/

/// \class AliMUONDigitMaker
/// MUON Digit maker from rawdata.
///
/// Raw2Digits:
/// Using real mapping  for tracker
/// Indranil Das (Adapted for runloader: Ch. Finck) july 05
///
/// Implemented non-constant buspatch numbers for tracking
/// with correct DDL id.
/// (Ch. Finck, dec 05)
///
/// Add reader for scaler trigger events
/// Use memcpy instead of assignment elt by elt
/// (Ch. Finck, Jan 06)
///
/// Using new interface with AliMUONRawStreamTracker(Trigger)
/// (New interface of AliMUONRawReader class)
/// (further details could be found in Alice-note)
/// (Ch. Finck, March 06)
///
/// Add (S)Digit maker tracker (for free)
/// and for trigger. Create trigger inverse mapping.
/// (Ch. Finck, oct 06) 

#include "AliMUONDigitMaker.h"
#include "AliMUONDigit.h"

#include "AliMUONConstants.h"
#include "AliMUONData.h"

#include "AliMUONRawStreamTracker.h"
#include "AliMUONDDLTracker.h"
#include "AliMUONDspHeader.h"
#include "AliMUONBlockHeader.h"
#include "AliMUONBusStruct.h"

#include "AliMUONRawStreamTrigger.h"
#include "AliMUONDDLTrigger.h"
#include "AliMUONDarcHeader.h"
#include "AliMUONRegHeader.h"
#include "AliMUONLocalStruct.h"

#include "AliMUONTriggerCrateStore.h"
#include "AliMUONTriggerCrate.h"
#include "AliMUONLocalTriggerBoard.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONTriggerCircuit.h"

#include "AliMpSegmentation.h"
#include "AliMpVSegmentation.h"
#include "AliMpPad.h"
#include "AliMpDEManager.h"
#include "AliMpDDLStore.h"
#include "AliMpCathodType.h"

#include "AliRawReader.h"
#include "AliRawDataHeader.h"
#include "AliLog.h"
#include "AliRun.h"

#include <TList.h>


/// \cond CLASSIMP
ClassImp(AliMUONDigitMaker) // Class implementation in ROOT context
/// \endcond

//__________________________________________________________________________
AliMUONDigitMaker::AliMUONDigitMaker(Bool_t flag)
  : TObject(),
    fMUONData(0x0),
    fScalerEvent(kFALSE),
    fDigitFlag(flag),
    fRawStreamTracker(new AliMUONRawStreamTracker()),    
    fRawStreamTrigger(new AliMUONRawStreamTrigger()),    
    fDigit(new AliMUONDigit()),
    fLocalTrigger(new AliMUONLocalTrigger()),
    fGlobalTrigger(new AliMUONGlobalTrigger()),
    fCrateManager(0x0),
    fTrackerTimer(),
    fTriggerTimer(),
    fMappingTimer()
{
  /// ctor with AliMUONData as argument
  /// for reconstruction

  AliDebug(1,"");

  // Standard Constructor

  fTrackerTimer.Start(kTRUE); fTrackerTimer.Stop();
  fTriggerTimer.Start(kTRUE); fTriggerTimer.Stop();
  fMappingTimer.Start(kTRUE); fMappingTimer.Stop();

}

//__________________________________________________________________________
AliMUONDigitMaker::~AliMUONDigitMaker()
{
  /// clean up
  /// and time processing measure

  delete fRawStreamTracker;
  delete fRawStreamTrigger;

  delete fDigit;
  delete fLocalTrigger;
  delete fGlobalTrigger;

  AliDebug(1, Form("Execution time for MUON tracker : R:%.2fs C:%.2fs",
               fTrackerTimer.RealTime(),fTrackerTimer.CpuTime()));
  AliDebug(1, Form("   Execution time for MUON tracker (mapping calls part) "
               ": R:%.2fs C:%.2fs",
               fMappingTimer.RealTime(),fMappingTimer.CpuTime()));
  AliDebug(1, Form("Execution time for MUON trigger : R:%.2fs C:%.2fs",
               fTriggerTimer.RealTime(),fTriggerTimer.CpuTime()));

  return;
}

//____________________________________________________________________
Int_t AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader)
{
  /// Main method to creates digit
  /// for tracker 
  /// and trigger

  // generate digits
  ReadTrackerDDL(rawReader);

  // generate trigger
  ReadTriggerDDL(rawReader);

  return kTRUE;

}

//____________________________________________________________________
Int_t AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
{

  /// reading tracker DDL
  /// filling the TClonesArray in MUONData

  fTrackerTimer.Start(kFALSE);

  // elex info
  Int_t    buspatchId;
  UChar_t  channelId;
  UShort_t manuId;
  Char_t   parity;
  UShort_t charge; 
  Int_t    dataSize;

  Int_t iChamber;

  AliMUONDDLTracker*   ddlTracker = 0x0;
  AliMUONBlockHeader*  blkHeader  = 0x0;
  AliMUONDspHeader*    dspHeader  = 0x0;
  AliMUONBusStruct*    busStruct  = 0x0;


  fRawStreamTracker->SetReader(rawReader);

  while(fRawStreamTracker->NextDDL()) {

    ddlTracker =  fRawStreamTracker->GetDDLTracker();

    Int_t nBlock = ddlTracker->GetBlkHeaderEntries();
    for(Int_t iBlock = 0; iBlock < nBlock ;iBlock++){

      blkHeader = ddlTracker->GetBlkHeaderEntry(iBlock);
 
      Int_t nDsp = blkHeader->GetDspHeaderEntries();

      for(Int_t iDsp = 0; iDsp < nDsp ;iDsp++){   //DSP loop

	dspHeader =  blkHeader->GetDspHeaderEntry(iDsp);

	Int_t nBusPatch = dspHeader->GetBusPatchEntries();

	for(Int_t iBusPatch = 0; iBusPatch < nBusPatch; iBusPatch++) {  

	  busStruct = dspHeader->GetBusPatchEntry(iBusPatch);

	  dataSize   = busStruct->GetLength();
	  buspatchId = busStruct->GetBusPatchId();

	  for (Int_t iData = 0; iData < dataSize; iData++) {

	    // digits info
	    parity    = busStruct->GetParity(iData); // test later for parity
	    manuId    = busStruct->GetManuId(iData);
	    channelId = busStruct->GetChannelId(iData);
	    charge    = busStruct->GetCharge(iData);
	    // set charge
	    fDigit->SetSignal(charge);
	    fDigit->SetPhysicsSignal(charge);
	    fDigit->SetADC(charge);

	    // Get Back the hits at pads
	    Int_t error = GetMapping(buspatchId,manuId,channelId,fDigit); 
	    if (error) {
	      AliWarning("Mapping Error\n");
	      continue;
	    }
	    // debugging 
	    if (AliLog::GetGlobalDebugLevel() == 3) {
	      Int_t padX  = fDigit->PadX();
	      Int_t padY  = fDigit->PadY();
	      Int_t iCath = fDigit->Cathode();  
	      Int_t idDE  = fDigit->DetElemId();

	      AliDebug(1,Form("output  IdDE %d busPatchid %d PadX %d PadY %d iCath %d \n", 
			      idDE, buspatchId, padX, padY, iCath));
		
	      AliDebug(3,Form("idDE %d Padx %d Pady %d, Cath %d, charge %d",
			      idDE, padX, padY, iCath, charge));
	    }

	    // fill digits
	    iChamber = AliMpDEManager::GetChamberId(fDigit->DetElemId());

	    if (fDigitFlag)
	      fMUONData->AddDigit(iChamber, *fDigit);
	    else
	      fMUONData->AddSDigit(iChamber, *fDigit);


	  } // iData
	} // iBusPatch
      } // iDsp
    } // iBlock
  } // NextDDL

  fTrackerTimer.Stop();

  return kTRUE;
}
//____________________________________________________________________
Int_t AliMUONDigitMaker::GetMapping(Int_t busPatchId, UShort_t manuId, 
					 UChar_t channelId, AliMUONDigit* digit )
{
  /// mapping  for tracker

  fMappingTimer.Start(kFALSE);
  
  // getting DE from buspatch
  Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
  AliDebug(3,Form("detElemId: %d busPatchId %d\n", detElemId, busPatchId));

  const AliMpVSegmentation* seg 
    = AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId, manuId);  
  AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,channelId),kTRUE);

  if (!pad.IsValid())
  {
    AliWarning(Form("No pad for detElemId: %d, busPatchId %d, manuId: %d, channelId: %d\n",
		  detElemId, busPatchId, manuId, channelId));
    fMappingTimer.Stop();
    return kTRUE;
  } // return error

  // Getting padX, padY and cathode number.
  Int_t padX = pad.GetIndices().GetFirst();
  Int_t padY = pad.GetIndices().GetSecond();
  Int_t iCath = AliMpDEManager::GetCathod(detElemId,seg->PlaneType());

  // storing into digits
  digit->SetPadX(padX);
  digit->SetPadY(padY);
  digit->SetCathode(iCath);
  digit->SetDetElemId(detElemId);
  digit->SetElectronics(manuId,channelId);
  
  AliDebug(3,Form("detElemId: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d\n",
		  detElemId, busPatchId, manuId, channelId, padX, padY));
  StdoutToAliDebug(3,digit->Print(););
  
  fMappingTimer.Stop();
  return kFALSE;
}

//____________________________________________________________________
Int_t AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
{
  /// reading tracker DDL
  /// filling the TClonesArray in MUONData

  AliMUONDDLTrigger*       ddlTrigger      = 0x0;
  AliMUONDarcHeader*       darcHeader      = 0x0;
  AliMUONRegHeader*        regHeader       = 0x0;
  AliMUONLocalStruct*      localStruct     = 0x0;

  Int_t loCircuit;
  TList digitList;


  fTriggerTimer.Start(kFALSE);

  fRawStreamTrigger->SetReader(rawReader);

  while(fRawStreamTrigger->NextDDL()) {

    ddlTrigger = fRawStreamTrigger->GetDDLTrigger();
    darcHeader = ddlTrigger->GetDarcHeader();

    // fill global trigger information in Digit Tree
    if (fDigitFlag) {
      if (darcHeader->GetGlobalFlag()) {
	fGlobalTrigger->SetFromGlobalResponse(darcHeader->GetGlobalOutput());
	fMUONData->AddGlobalTrigger(*fGlobalTrigger);
      }
    }

    Int_t nReg = darcHeader->GetRegHeaderEntries();

    for(Int_t iReg = 0; iReg < nReg ;iReg++){   //reg loop

      // crate info
      if (!fCrateManager) AliFatal("Crate Store not defined");
      AliMUONTriggerCrate* crate = fCrateManager->Crate(fRawStreamTrigger->GetDDL(), iReg);
  
      if (!crate) 
	AliWarning(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));

      TObjArray *boards  = crate->Boards();


      regHeader =  darcHeader->GetRegHeaderEntry(iReg);

      Int_t nLocal = regHeader->GetLocalEntries();
      for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) {  

	localStruct = regHeader->GetLocalEntry(iLocal);

	// if card exist
	if (localStruct) {

	  AliMUONLocalTriggerBoard* localBoard = 
	    (AliMUONLocalTriggerBoard*)boards->At(localStruct->GetId()+1);

	  // skip copy cards
	  if( !(loCircuit = localBoard->GetNumber()) )
	     continue;

	  if (fDigitFlag) {
	    // fill local trigger
	    fLocalTrigger->SetLocalStruct(loCircuit, *localStruct);

	    fMUONData->AddLocalTrigger(*fLocalTrigger);

	  } else {
	    // Make SDigit

	    digitList.Clear();
	    
	    if( TriggerDigits(localBoard, localStruct, digitList) ) {

	      for (Int_t iEntry = 0; iEntry < digitList.GetEntries(); iEntry++) {

		AliMUONDigit* digit = (AliMUONDigit*)digitList.At(iEntry);
		
		// filling S container
		Int_t iChamber = AliMpDEManager::GetChamberId(digit->DetElemId());
		fMUONData->AddSDigit(iChamber, *digit);

	      }

	    } // trigger digits
	  } // S flag

	} // if triggerY
      } // iLocal
    } // iReg
  } // NextDDL

  fTriggerTimer.Stop();

  return kTRUE;

}
//____________________________________________________________________
void AliMUONDigitMaker::GetTriggerChamber(AliMUONLocalStruct* localStruct, Int_t& xyPattern, 
					  Int_t& iChamber, Int_t& iCath, Int_t icase)
{
  /// get chamber & cathode number, (chamber starts at 0 !)

    switch(icase) {
    case 0: 
      xyPattern =  localStruct->GetX1();
      iCath = 0;
      iChamber = 10;
      break;
    case 1: 
      xyPattern =  localStruct->GetX2();
      iCath = 0;
      iChamber = 11;
      break;
    case 2: 
      xyPattern =  localStruct->GetX3();
      iCath = 0;
      iChamber = 12;
      break;
    case 3: 
      xyPattern =  localStruct->GetX4();
      iCath = 0;
      iChamber = 13;
      break;
    case 4: 
      xyPattern =  localStruct->GetY1();
      iCath = 1;
      iChamber = 10;
      break;
    case 5: 
      xyPattern =  localStruct->GetY2();
      iCath = 1;
      iChamber = 11;
      break;
    case 6: 
      xyPattern =  localStruct->GetY3();
      iCath = 1;
      iChamber = 12;
      break;
    case 7: 
      xyPattern =  localStruct->GetY4();
      iCath = 1;
      iChamber = 13;
      break;
    }
}
//____________________________________________________________________
Int_t AliMUONDigitMaker::TriggerDigits(AliMUONLocalTriggerBoard* localBoard, 
				       AliMUONLocalStruct* localStruct,
				       TList& digitList)
{
  /// make (S)Digit for trigger

  Int_t detElemId;
  Int_t nBoard;
  Int_t iCath = -1;
  Int_t iChamber = 0;
  Int_t xyPattern = 0;

  // loop over x1-4 and y1-4
  for (Int_t icase = 0; icase < 8; icase++) {

    // get chamber, cathode and associated trigger response pattern
    GetTriggerChamber(localStruct, xyPattern, iChamber, iCath, icase);
  
    if (!xyPattern) continue;

    // get detElemId
    AliMUONTriggerCircuit triggerCircuit;
    detElemId = triggerCircuit.DetElemId(iChamber, localBoard->GetName());
    nBoard    = localBoard->GetNumber();

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

    // loop over the 16 bits of pattern
    for (Int_t ibitxy = 0; ibitxy < 16; ibitxy++) {
    
      if ((xyPattern >> ibitxy) & 0x1) {

	// not quite sure about this
	Int_t offset = 0;
	if (iCath && localBoard->GetSwitch(6)) offset = -8;

	AliMpPad pad = seg->PadByLocation(AliMpIntPair(nBoard,ibitxy+offset),kTRUE);

	AliMUONDigit* digit = new  AliMUONDigit();
	if (!pad.IsValid()) {
	  AliWarning(Form("No pad for detElemId: %d, nboard %d, ibitxy: %d\n",
			  detElemId, nBoard, ibitxy));
	  continue;
	} // 

	Int_t padX = pad.GetIndices().GetFirst();
	Int_t padY = pad.GetIndices().GetSecond();

	// file digit
	digit->SetPadX(padX);
	digit->SetPadY(padY);
	digit->SetCathode(iCath);
	digit->SetDetElemId(detElemId);
	digit->SetElectronics(nBoard, ibitxy);
	digitList.Add(digit);
	
      }// xyPattern
    }// ibitxy
  }// case

  return kTRUE;
} 
//____________________________________________________________________
void  AliMUONDigitMaker::GetCrateName(Char_t* name, Int_t iDDL, Int_t iReg) const
{
  /// set crate name from DDL & reg number
  /// method same as in RawWriter, not so nice
  /// should be put in AliMUONTriggerCrateStore

      switch(iReg) {
      case 0:
      case 1:
	sprintf(name,"%d", iReg+1);
	break;
      case 2:
	strcpy(name, "2-3");
	break;
      case 3:
      case 4:
      case 5:
      case 6:
      case 7:
	sprintf(name,"%d", iReg);
	break;
      }

      // crate Right for first DDL
      if (iDDL == 0)
	strcat(name, "R");
      else 
	strcat(name, "L"); 
}
Commit	Line	Data
a3283a4c	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
9265505b	16	/// \class AliMUONDigitMaker
8c51a32f	17	/// MUON Digit maker from rawdata.
a3283a4c	18	///
	19	/// Raw2Digits:
	20	/// Using real mapping for tracker
	21	/// Indranil Das (Adapted for runloader: Ch. Finck) july 05
8c51a32f	22	///
	23	/// Implemented non-constant buspatch numbers for tracking
	24	/// with correct DDL id.
	25	/// (Ch. Finck, dec 05)
	26	///
a3283a4c	27	/// Add reader for scaler trigger events
	28	/// Use memcpy instead of assignment elt by elt
	29	/// (Ch. Finck, Jan 06)
8c51a32f	30	///
	31	/// Using new interface with AliMUONRawStreamTracker(Trigger)
	32	/// (New interface of AliMUONRawReader class)
	33	/// (further details could be found in Alice-note)
	34	/// (Ch. Finck, March 06)
	35	///
	36	/// Add (S)Digit maker tracker (for free)
	37	/// and for trigger. Create trigger inverse mapping.
	38	/// (Ch. Finck, oct 06)
a3283a4c	39
a3283a4c	40	#include "AliMUONDigitMaker.h"
	41	#include "AliMUONDigit.h"
	42
	43	#include "AliMUONConstants.h"
	44	#include "AliMUONData.h"
	45
	46	#include "AliMUONRawStreamTracker.h"
	47	#include "AliMUONDDLTracker.h"
	48	#include "AliMUONDspHeader.h"
	49	#include "AliMUONBlockHeader.h"
	50	#include "AliMUONBusStruct.h"
	51
	52	#include "AliMUONRawStreamTrigger.h"
	53	#include "AliMUONDDLTrigger.h"
	54	#include "AliMUONDarcHeader.h"
	55	#include "AliMUONRegHeader.h"
	56	#include "AliMUONLocalStruct.h"
	57
d53fb0de	58	#include "AliMUONTriggerCrateStore.h"
	59	#include "AliMUONTriggerCrate.h"
	60	#include "AliMUONLocalTriggerBoard.h"
a3283a4c	61	#include "AliMUONLocalTrigger.h"
a3283a4c	62	#include "AliMUONGlobalTrigger.h"
e1a10d41	63	#include "AliMUONTriggerCircuit.h"
9265505b	64
9265505b	65	#include "AliMpSegmentation.h"
a3283a4c	66	#include "AliMpVSegmentation.h"
	67	#include "AliMpPad.h"
	68	#include "AliMpDEManager.h"
e5ced899	69	#include "AliMpDDLStore.h"
e5ced899	70	#include "AliMpCathodType.h"
a3283a4c	71
9265505b	72	#include "AliRawReader.h"
	73	#include "AliRawDataHeader.h"
	74	#include "AliLog.h"
	75	#include "AliRun.h"
	76
9265505b	77	#include <TList.h>
9265505b	78
9265505b	79
9265505b	80	/// \cond CLASSIMP
a3283a4c	81	ClassImp(AliMUONDigitMaker) // Class implementation in ROOT context
9265505b	82	/// \endcond
9265505b	83
a3283a4c	84	//__________________________________________________________________________
241560c2	85	AliMUONDigitMaker::AliMUONDigitMaker(Bool_t flag)
a3283a4c	86	: TObject(),
aa6ecf89	87	fMUONData(0x0),
9f5dcca3	88	fScalerEvent(kFALSE),
241560c2	89	fDigitFlag(flag),
9f5dcca3	90	fRawStreamTracker(new AliMUONRawStreamTracker()),
	91	fRawStreamTrigger(new AliMUONRawStreamTrigger()),
	92	fDigit(new AliMUONDigit()),
	93	fLocalTrigger(new AliMUONLocalTrigger()),
	94	fGlobalTrigger(new AliMUONGlobalTrigger()),
fe5010dd	95	fCrateManager(0x0),
9f5dcca3	96	fTrackerTimer(),
	97	fTriggerTimer(),
	98	fMappingTimer()
a3283a4c	99	{
9265505b	100	/// ctor with AliMUONData as argument
9265505b	101	/// for reconstruction
a3283a4c	102
	103	AliDebug(1,"");
	104
	105	// Standard Constructor
	106
a3283a4c	107	fTrackerTimer.Start(kTRUE); fTrackerTimer.Stop();
	108	fTriggerTimer.Start(kTRUE); fTriggerTimer.Stop();
	109	fMappingTimer.Start(kTRUE); fMappingTimer.Stop();
	110
	111	}
	112
a3283a4c	113	//__________________________________________________________________________
9f5dcca3	114	AliMUONDigitMaker::~AliMUONDigitMaker()
a3283a4c	115	{
9265505b	116	/// clean up
	117	/// and time processing measure
	118
a3283a4c	119	delete fRawStreamTracker;
	120	delete fRawStreamTrigger;
	121
	122	delete fDigit;
	123	delete fLocalTrigger;
	124	delete fGlobalTrigger;
	125
a7b01aa5	126	AliDebug(1, Form("Execution time for MUON tracker : R:%.2fs C:%.2fs",
a3283a4c	127	fTrackerTimer.RealTime(),fTrackerTimer.CpuTime()));
a7b01aa5	128	AliDebug(1, Form(" Execution time for MUON tracker (mapping calls part) "
a3283a4c	129	": R:%.2fs C:%.2fs",
a3283a4c	130	fMappingTimer.RealTime(),fMappingTimer.CpuTime()));
a7b01aa5	131	AliDebug(1, Form("Execution time for MUON trigger : R:%.2fs C:%.2fs",
a3283a4c	132	fTriggerTimer.RealTime(),fTriggerTimer.CpuTime()));
	133
	134	return;
	135	}
	136
	137	//____________________________________________________________________
	138	Int_t AliMUONDigitMaker::Raw2Digits(AliRawReader* rawReader)
	139	{
9265505b	140	/// Main method to creates digit
	141	/// for tracker
	142	/// and trigger
a3283a4c	143
	144	// generate digits
	145	ReadTrackerDDL(rawReader);
	146
	147	// generate trigger
d2d759cf	148	ReadTriggerDDL(rawReader);
a3283a4c	149
	150	return kTRUE;
	151
	152	}
	153
	154	//____________________________________________________________________
	155	Int_t AliMUONDigitMaker::ReadTrackerDDL(AliRawReader* rawReader)
	156	{
	157
9265505b	158	/// reading tracker DDL
	159	/// filling the TClonesArray in MUONData
	160
a3283a4c	161	fTrackerTimer.Start(kFALSE);
	162
	163	// elex info
	164	Int_t buspatchId;
	165	UChar_t channelId;
	166	UShort_t manuId;
	167	Char_t parity;
	168	UShort_t charge;
	169	Int_t dataSize;
	170
e6e1f642	171	Int_t iChamber;
e6e1f642	172
a3283a4c	173	AliMUONDDLTracker* ddlTracker = 0x0;
	174	AliMUONBlockHeader* blkHeader = 0x0;
	175	AliMUONDspHeader* dspHeader = 0x0;
	176	AliMUONBusStruct* busStruct = 0x0;
	177
	178
	179	fRawStreamTracker->SetReader(rawReader);
	180
	181	while(fRawStreamTracker->NextDDL()) {
	182
	183	ddlTracker = fRawStreamTracker->GetDDLTracker();
	184
	185	Int_t nBlock = ddlTracker->GetBlkHeaderEntries();
	186	for(Int_t iBlock = 0; iBlock < nBlock ;iBlock++){
	187
	188	blkHeader = ddlTracker->GetBlkHeaderEntry(iBlock);
	189
	190	Int_t nDsp = blkHeader->GetDspHeaderEntries();
	191
	192	for(Int_t iDsp = 0; iDsp < nDsp ;iDsp++){ //DSP loop
	193
	194	dspHeader = blkHeader->GetDspHeaderEntry(iDsp);
	195
	196	Int_t nBusPatch = dspHeader->GetBusPatchEntries();
	197
	198	for(Int_t iBusPatch = 0; iBusPatch < nBusPatch; iBusPatch++) {
	199
	200	busStruct = dspHeader->GetBusPatchEntry(iBusPatch);
	201
	202	dataSize = busStruct->GetLength();
	203	buspatchId = busStruct->GetBusPatchId();
	204
	205	for (Int_t iData = 0; iData < dataSize; iData++) {
	206
	207	// digits info
	208	parity = busStruct->GetParity(iData); // test later for parity
	209	manuId = busStruct->GetManuId(iData);
	210	channelId = busStruct->GetChannelId(iData);
	211	charge = busStruct->GetCharge(iData);
	212	// set charge
	213	fDigit->SetSignal(charge);
	214	fDigit->SetPhysicsSignal(charge);
	215	fDigit->SetADC(charge);
	216
	217	// Get Back the hits at pads
	218	Int_t error = GetMapping(buspatchId,manuId,channelId,fDigit);
84ceeb06	219	if (error) {
e6e1f642	220	AliWarning("Mapping Error\n");
84ceeb06	221	continue;
84ceeb06	222	}
a3283a4c	223	// debugging
	224	if (AliLog::GetGlobalDebugLevel() == 3) {
	225	Int_t padX = fDigit->PadX();
	226	Int_t padY = fDigit->PadY();
	227	Int_t iCath = fDigit->Cathode();
	228	Int_t idDE = fDigit->DetElemId();
	229
	230	AliDebug(1,Form("output IdDE %d busPatchid %d PadX %d PadY %d iCath %d \n",
	231	idDE, buspatchId, padX, padY, iCath));
	232
	233	AliDebug(3,Form("idDE %d Padx %d Pady %d, Cath %d, charge %d",
	234	idDE, padX, padY, iCath, charge));
	235	}
	236
	237	// fill digits
66f4c572	238	iChamber = AliMpDEManager::GetChamberId(fDigit->DetElemId());
241560c2	239
	240	if (fDigitFlag)
	241	fMUONData->AddDigit(iChamber, *fDigit);
	242	else
	243	fMUONData->AddSDigit(iChamber, *fDigit);
	244
a3283a4c	245
	246	} // iData
	247	} // iBusPatch
	248	} // iDsp
	249	} // iBlock
	250	} // NextDDL
	251
	252	fTrackerTimer.Stop();
	253
	254	return kTRUE;
	255	}
	256	//____________________________________________________________________
	257	Int_t AliMUONDigitMaker::GetMapping(Int_t busPatchId, UShort_t manuId,
	258	UChar_t channelId, AliMUONDigit* digit )
	259	{
9265505b	260	/// mapping for tracker
9265505b	261
a3283a4c	262	fMappingTimer.Start(kFALSE);
	263
	264	// getting DE from buspatch
e5ced899	265	Int_t detElemId = AliMpDDLStore::Instance()->GetDEfromBus(busPatchId);
a3283a4c	266	AliDebug(3,Form("detElemId: %d busPatchId %d\n", detElemId, busPatchId));
a3283a4c	267
9265505b	268	const AliMpVSegmentation* seg
9265505b	269	= AliMpSegmentation::Instance()->GetMpSegmentationByElectronics(detElemId, manuId);
a3283a4c	270	AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,channelId),kTRUE);
	271
	272	if (!pad.IsValid())
	273	{
	274	AliWarning(Form("No pad for detElemId: %d, busPatchId %d, manuId: %d, channelId: %d\n",
	275	detElemId, busPatchId, manuId, channelId));
	276	fMappingTimer.Stop();
	277	return kTRUE;
	278	} // return error
	279
	280	// Getting padX, padY and cathode number.
	281	Int_t padX = pad.GetIndices().GetFirst();
	282	Int_t padY = pad.GetIndices().GetSecond();
	283	Int_t iCath = AliMpDEManager::GetCathod(detElemId,seg->PlaneType());
	284
	285	// storing into digits
	286	digit->SetPadX(padX);
	287	digit->SetPadY(padY);
	288	digit->SetCathode(iCath);
	289	digit->SetDetElemId(detElemId);
	290	digit->SetElectronics(manuId,channelId);
	291
	292	AliDebug(3,Form("detElemId: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d\n",
	293	detElemId, busPatchId, manuId, channelId, padX, padY));
	294	StdoutToAliDebug(3,digit->Print(););
	295
	296	fMappingTimer.Stop();
	297	return kFALSE;
	298	}
	299
	300	//____________________________________________________________________
	301	Int_t AliMUONDigitMaker::ReadTriggerDDL(AliRawReader* rawReader)
	302	{
9265505b	303	/// reading tracker DDL
9265505b	304	/// filling the TClonesArray in MUONData
a3283a4c	305
	306	AliMUONDDLTrigger* ddlTrigger = 0x0;
	307	AliMUONDarcHeader* darcHeader = 0x0;
	308	AliMUONRegHeader* regHeader = 0x0;
	309	AliMUONLocalStruct* localStruct = 0x0;
	310
	311	Int_t loCircuit;
d2d759cf	312	TList digitList;
d2d759cf	313
a3283a4c	314
	315	fTriggerTimer.Start(kFALSE);
	316
	317	fRawStreamTrigger->SetReader(rawReader);
	318
	319	while(fRawStreamTrigger->NextDDL()) {
	320
	321	ddlTrigger = fRawStreamTrigger->GetDDLTrigger();
	322	darcHeader = ddlTrigger->GetDarcHeader();
	323
d2d759cf	324	// fill global trigger information in Digit Tree
	325	if (fDigitFlag) {
	326	if (darcHeader->GetGlobalFlag()) {
	327	fGlobalTrigger->SetFromGlobalResponse(darcHeader->GetGlobalOutput());
	328	fMUONData->AddGlobalTrigger(*fGlobalTrigger);
	329	}
a3283a4c	330	}
	331
	332	Int_t nReg = darcHeader->GetRegHeaderEntries();
	333
	334	for(Int_t iReg = 0; iReg < nReg ;iReg++){ //reg loop
	335
fe5010dd	336	// crate info
fe5010dd	337	if (!fCrateManager) AliFatal("Crate Store not defined");
aa6ecf89	338	AliMUONTriggerCrate* crate = fCrateManager->Crate(fRawStreamTrigger->GetDDL(), iReg);
d53fb0de	339
	340	if (!crate)
	341	AliWarning(Form("Missing crate number %d in DDL %d\n", iReg, fRawStreamTrigger->GetDDL()));
	342
	343	TObjArray *boards = crate->Boards();
	344
	345
a3283a4c	346	regHeader = darcHeader->GetRegHeaderEntry(iReg);
	347
	348	Int_t nLocal = regHeader->GetLocalEntries();
a3283a4c	349	for(Int_t iLocal = 0; iLocal < nLocal; iLocal++) {
	350
	351	localStruct = regHeader->GetLocalEntry(iLocal);
	352
5a92f8e6	353	// if card exist
5a92f8e6	354	if (localStruct) {
d2d759cf	355
d53fb0de	356	AliMUONLocalTriggerBoard* localBoard =
	357	(AliMUONLocalTriggerBoard*)boards->At(localStruct->GetId()+1);
	358
5a92f8e6	359	// skip copy cards
	360	if( !(loCircuit = localBoard->GetNumber()) )
	361	continue;
d2d759cf	362
	363	if (fDigitFlag) {
	364	// fill local trigger
	365	fLocalTrigger->SetLocalStruct(loCircuit, *localStruct);
	366
	367	fMUONData->AddLocalTrigger(*fLocalTrigger);
	368
	369	} else {
	370	// Make SDigit
	371
	372	digitList.Clear();
a3283a4c	373
d2d759cf	374	if( TriggerDigits(localBoard, localStruct, digitList) ) {
	375
	376	for (Int_t iEntry = 0; iEntry < digitList.GetEntries(); iEntry++) {
	377
	378	AliMUONDigit* digit = (AliMUONDigit*)digitList.At(iEntry);
	379
	380	// filling S container
66f4c572	381	Int_t iChamber = AliMpDEManager::GetChamberId(digit->DetElemId());
d2d759cf	382	fMUONData->AddSDigit(iChamber, *digit);
	383
	384	}
	385
	386	} // trigger digits
	387	} // S flag
a3283a4c	388
a3283a4c	389	} // if triggerY
	390	} // iLocal
	391	} // iReg
	392	} // NextDDL
	393
	394	fTriggerTimer.Stop();
	395
	396	return kTRUE;
	397
	398	}
d2d759cf	399	//____________________________________________________________________
	400	void AliMUONDigitMaker::GetTriggerChamber(AliMUONLocalStruct* localStruct, Int_t& xyPattern,
	401	Int_t& iChamber, Int_t& iCath, Int_t icase)
	402	{
9265505b	403	/// get chamber & cathode number, (chamber starts at 0 !)
a3283a4c	404
d2d759cf	405	switch(icase) {
	406	case 0:
	407	xyPattern = localStruct->GetX1();
	408	iCath = 0;
8c51a32f	409	iChamber = 10;
d2d759cf	410	break;
	411	case 1:
	412	xyPattern = localStruct->GetX2();
	413	iCath = 0;
8c51a32f	414	iChamber = 11;
d2d759cf	415	break;
	416	case 2:
	417	xyPattern = localStruct->GetX3();
	418	iCath = 0;
8c51a32f	419	iChamber = 12;
d2d759cf	420	break;
	421	case 3:
	422	xyPattern = localStruct->GetX4();
	423	iCath = 0;
8c51a32f	424	iChamber = 13;
d2d759cf	425	break;
	426	case 4:
	427	xyPattern = localStruct->GetY1();
	428	iCath = 1;
8c51a32f	429	iChamber = 10;
d2d759cf	430	break;
	431	case 5:
	432	xyPattern = localStruct->GetY2();
	433	iCath = 1;
8c51a32f	434	iChamber = 11;
d2d759cf	435	break;
	436	case 6:
	437	xyPattern = localStruct->GetY3();
	438	iCath = 1;
8c51a32f	439	iChamber = 12;
d2d759cf	440	break;
	441	case 7:
	442	xyPattern = localStruct->GetY4();
	443	iCath = 1;
8c51a32f	444	iChamber = 13;
d2d759cf	445	break;
	446	}
	447	}
	448	//____________________________________________________________________
	449	Int_t AliMUONDigitMaker::TriggerDigits(AliMUONLocalTriggerBoard* localBoard,
	450	AliMUONLocalStruct* localStruct,
	451	TList& digitList)
	452	{
9265505b	453	/// make (S)Digit for trigger
d2d759cf	454
	455	Int_t detElemId;
	456	Int_t nBoard;
	457	Int_t iCath = -1;
	458	Int_t iChamber = 0;
	459	Int_t xyPattern = 0;
	460
	461	// loop over x1-4 and y1-4
	462	for (Int_t icase = 0; icase < 8; icase++) {
	463
	464	// get chamber, cathode and associated trigger response pattern
	465	GetTriggerChamber(localStruct, xyPattern, iChamber, iCath, icase);
	466
	467	if (!xyPattern) continue;
	468
	469	// get detElemId
e1a10d41	470	AliMUONTriggerCircuit triggerCircuit;
d2d759cf	471	detElemId = triggerCircuit.DetElemId(iChamber, localBoard->GetName());
	472	nBoard = localBoard->GetNumber();
	473
9265505b	474	const AliMpVSegmentation* seg
e5ced899	475	= AliMpSegmentation::Instance()
e5ced899	476	->GetMpSegmentation(detElemId, AliMp::GetCathodType(iCath));
d2d759cf	477
	478	// loop over the 16 bits of pattern
	479	for (Int_t ibitxy = 0; ibitxy < 16; ibitxy++) {
	480
	481	if ((xyPattern >> ibitxy) & 0x1) {
	482
	483	// not quite sure about this
	484	Int_t offset = 0;
	485	if (iCath && localBoard->GetSwitch(6)) offset = -8;
	486
	487	AliMpPad pad = seg->PadByLocation(AliMpIntPair(nBoard,ibitxy+offset),kTRUE);
	488
	489	AliMUONDigit* digit = new AliMUONDigit();
	490	if (!pad.IsValid()) {
	491	AliWarning(Form("No pad for detElemId: %d, nboard %d, ibitxy: %d\n",
	492	detElemId, nBoard, ibitxy));
	493	continue;
	494	} //
	495
	496	Int_t padX = pad.GetIndices().GetFirst();
	497	Int_t padY = pad.GetIndices().GetSecond();
	498
	499	// file digit
	500	digit->SetPadX(padX);
	501	digit->SetPadY(padY);
	502	digit->SetCathode(iCath);
	503	digit->SetDetElemId(detElemId);
	504	digit->SetElectronics(nBoard, ibitxy);
	505	digitList.Add(digit);
	506
	507	}// xyPattern
	508	}// ibitxy
	509	}// case
	510
	511	return kTRUE;
	512	}
d53fb0de	513	//____________________________________________________________________
00e86732	514	void AliMUONDigitMaker::GetCrateName(Char_t* name, Int_t iDDL, Int_t iReg) const
d53fb0de	515	{
9265505b	516	/// set crate name from DDL & reg number
	517	/// method same as in RawWriter, not so nice
	518	/// should be put in AliMUONTriggerCrateStore
d53fb0de	519
	520	switch(iReg) {
	521	case 0:
	522	case 1:
	523	sprintf(name,"%d", iReg+1);
	524	break;
	525	case 2:
	526	strcpy(name, "2-3");
	527	break;
	528	case 3:
	529	case 4:
	530	case 5:
	531	case 6:
	532	case 7:
	533	sprintf(name,"%d", iReg);
	534	break;
	535	}
	536
	537	// crate Right for first DDL
	538	if (iDDL == 0)
	539	strcat(name, "R");
	540	else
	541	strcat(name, "L");
	542	}