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

////////////////////////////////////
//
// MUON Raw Data reader in ALICE-MUON
// Class version 3 (further details could be found in Alice-note)
//
// Implemented non-constant buspatch numbers for tracking
// with correct DDL id (first guess)
// (Ch. Finck, dec 2005)
//
//
// Raw2Digits:
// Using real mapping  for tracker
// Indranil Das (Adapted for runloader: Ch. Finck) july 05
// Add reader for scaler trigger events
// Use memcpy instead of assignment elt by elt
// (Ch. Finck, Jan 06)
// 
////////////////////////////////////

#include <fstream>
#include <string>

#include <TClonesArray.h>

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

#include "AliMpBusPatch.h"

#include "AliMUON.h"
#include "AliMUONRawReader.h"
#include "AliMUONDigit.h"

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

#include "AliMUONSubEventTracker.h"
#include "AliMUONScalerEventTrigger.h"
#include "AliMUONSubEventTrigger.h"
#include "AliMUONDDLTracker.h"
#include "AliMUONDDLTrigger.h"

#include "AliMUONLocalTrigger.h"
#include "AliMUONGlobalTrigger.h"

#include "AliMUONGeometrySegmentation.h"
#include "AliMUONGeometryModule.h"
#include "AliMUONGeometryStore.h"
#include "AliMpSegFactory.h"
#include "AliMpPlaneType.h"
#include "AliMpVSegmentation.h"
#include "AliMpHelper.h"
#include "AliMpPad.h"
#include "AliMpDEManager.h"

ClassImp(AliMUONRawReader) // Class implementation in ROOT context
//__________________________________________________________________________
AliMUONRawReader::AliMUONRawReader(AliMUONData* data)
: TObject(),
  fScalerEvent(kFALSE)
{
  AliDebug(1,"");
      
  // Standard Constructor
 
  // initialize segmentation factory
  fSegFactory = new AliMpSegFactory();

  // initialize container
  fMUONData  = data;

  // ddl pointer
  fDDLTracker = new AliMUONDDLTracker();
  fDDLTrigger = new AliMUONDDLTrigger();

  fBusPatchManager = new AliMpBusPatch();
  fBusPatchManager->ReadBusPatchFile();

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

//__________________________________________________________________________
AliMUONRawReader::AliMUONRawReader()
  : TObject(),
    fMUONData(0),
    fSegFactory(0),
    fDDLTracker(0),
    fDDLTrigger(0),
    fBusPatchManager(0),
    fScalerEvent(kFALSE)
{
  // Default Constructor
      AliDebug(1,""); 
      fTrackerTimer.Start(kTRUE); fTrackerTimer.Stop();
      fTriggerTimer.Start(kTRUE); fTriggerTimer.Stop();
      fMappingTimer.Start(kTRUE); fMappingTimer.Stop();
}

//_______________________________________________________________________
AliMUONRawReader::AliMUONRawReader (const AliMUONRawReader& rhs)
  : TObject(rhs)
{
// Protected copy constructor

  AliFatal("Not implemented.");
}

//_______________________________________________________________________
AliMUONRawReader & 
AliMUONRawReader::operator=(const AliMUONRawReader& rhs)
{
// Protected assignement operator

  if (this == &rhs) return *this;

  AliFatal("Not implemented.");
    
  return *this;  
}

//__________________________________________________________________________
AliMUONRawReader::~AliMUONRawReader()
{
  delete fSegFactory;  

  delete fDDLTracker;
  delete fDDLTrigger;

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

}

//____________________________________________________________________
Int_t AliMUONRawReader::Raw2Digits(AliRawReader* rawReader)
{

  // generate digits
  ReadTrackerDDL(rawReader);

  // generate trigger
  ReadTriggerDDL(rawReader);

  return kTRUE;

}

//____________________________________________________________________
Int_t AliMUONRawReader::ReadTrackerDDL(AliRawReader* rawReader)
{
  // reading tracker DDL
  // filling the TClonesArray in MUONData
  //
  fTrackerTimer.Start(kFALSE);
  
  AliMUONSubEventTracker* subEventTracker = new AliMUONSubEventTracker();
  AliMUONDigit* digit = new AliMUONDigit();


  //Read Header Size of DDL,Block,DSP and BusPatch (put k before constant imb'cile)

  Int_t kDDLHeaderSize      = fDDLTracker->GetHeaderSize();
  Int_t kBlockHeaderSize    = fDDLTracker->GetBlkHeaderLength();
  Int_t kDspHeaderSize      = fDDLTracker->GetDspHeaderLength();
  Int_t kBusPatchHeaderSize = subEventTracker->GetHeaderLength();

  Int_t totalDDLSize, totalBlockSize, totalDspSize , totalBusPatchSize, dataSize; 


  Int_t iBusPerDSP[5];//number of bus patches per DSP
  Int_t iDspMax; //number max of DSP per block

  // minimum data size (only header's)
  Int_t blankDDLSize;
  Int_t blankBlockSize;
  Int_t blankDspSize;  

  for(Int_t iDDL = 0; iDDL < 20; iDDL++) { // DDL loop

    AliDebug(3, Form("Chamber %d\n", iDDL/2 +1 ));

    // getting DSP info
    fBusPatchManager->GetDspInfo(iDDL/2, iDspMax, iBusPerDSP);

    //   Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most and each of DSP has at most 5 buspatches.
    //   This information is used to calculate the size of headers (DDL,Block and DSP) which has no interesting data.
    blankDDLSize   = kDDLHeaderSize + 2*kBlockHeaderSize + 2*iDspMax*kDspHeaderSize;
    blankBlockSize = kBlockHeaderSize + iDspMax*kDspHeaderSize;

    for (Int_t i = 0; i < iDspMax; i++) {
      blankDDLSize   += 2*iBusPerDSP[i]*kBusPatchHeaderSize;
      blankBlockSize +=   iBusPerDSP[i]*kBusPatchHeaderSize;
    }

    rawReader->Select(0X9, iDDL, iDDL);  //Select the DDL file to be read  

    rawReader->ReadHeader();

    totalDDLSize = (rawReader->GetDataSize() + sizeof(AliRawDataHeader))/4; // 4 is multiplied to convert byte 2 words

    if(totalDDLSize > blankDDLSize) {      // Compare the DDL header with an empty DDL header size to read the file

      Int_t totalDataWord = rawReader->GetDataSize(); // in bytes
      UInt_t *buffer = new UInt_t[totalDataWord/4];
  
      rawReader->ReadNext((UChar_t*)buffer, totalDataWord); 

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

      // indexes
      Int_t indexDsp;
      Int_t indexBusPatch;
      Int_t index = 0;

      for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){  // loop over 2 blocks
	totalBlockSize = buffer[index];
	  
	if(totalBlockSize > blankBlockSize) {        // compare block header
	  index += kBlockHeaderSize;

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

	    totalDspSize = buffer[index];
	    indexDsp = index;

	    blankDspSize =  kDspHeaderSize + iBusPerDSP[iDsp]*kBusPatchHeaderSize; // no data just header

	    if(totalDspSize > blankDspSize) {       // Compare DSP Header
	      index += kDspHeaderSize;
		
	      for(Int_t iBusPatch = 0; iBusPatch < iBusPerDSP[iDsp]; iBusPatch++) {  

		//copy buffer into header structure
		memcpy(subEventTracker->GetBusPatchHeader(), &buffer[index], kBusPatchHeaderSize*4);

		totalBusPatchSize = subEventTracker->GetTotalLength();
		buspatchId        = subEventTracker->GetBusPatchId();
		indexBusPatch     = index;
		

		if(totalBusPatchSize > kBusPatchHeaderSize) {    //Check Buspatch header, not empty events

		  index   += kBusPatchHeaderSize;
		  dataSize = subEventTracker->GetLength();

		  if(dataSize>0) { // check data present

		    //copy buffer into data structure
		    memcpy(subEventTracker->GetData(), &buffer[index], dataSize*4); 
		    index += dataSize;

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

		      // digits info
		      parity    = subEventTracker->GetParity(iData); // test later for parity
		      manuId    = subEventTracker->GetManuId(iData);
		      channelId = subEventTracker->GetChannelId(iData);
		      charge    = subEventTracker->GetCharge(iData);
		      // set charge
		      digit->SetSignal(charge);
          digit->SetPhysicsSignal(charge);
          digit->SetADC(charge);
		      Int_t error = GetMapping(buspatchId,manuId,channelId,digit); // Get Back the hits at pads
		      if (error) continue;

		      // debugging 
		      if (AliLog::GetGlobalDebugLevel() == 3) {
			Int_t padX  = digit->PadX();
			Int_t padY  = digit->PadY();
			Int_t iCath = digit->Cathode();  
			Int_t detElemId  = digit->DetElemId();

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

		      // fill digits
		      fMUONData->AddDigit(iDDL/2, *digit);

		    } // data loop
		  } // dataSize test
		} // testing buspatch

		index = indexBusPatch + totalBusPatchSize;

	      }  //buspatch loop
		
	    }  // dsp test

	    index = indexDsp + totalDspSize;
	      
	  }  // dsp loop

	}   //block test

	index = totalBlockSize;

      }  //block loop

      delete[] buffer;
    } //loop checking the header size of DDL

    //delete rawReader;
  } // DDL loop


  delete subEventTracker;
  delete digit;

  fTrackerTimer.Stop();
  
  return kTRUE;
}

//____________________________________________________________________
Int_t AliMUONRawReader::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 = fBusPatchManager->GetDEfromBus(busPatchId);
  AliDebug(3,Form("detElemId: %d busPatchId %d\n", detElemId, busPatchId));

  AliMpVSegmentation* seg = fSegFactory->CreateMpSegmentationByElectronics(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 AliMUONRawReader::ReadTriggerDDL(AliRawReader* rawReader)
{

  // reading DDL for trigger

  fTriggerTimer.Start(kFALSE);
  
  AliMUONSubEventTrigger* subEventTrigger = new AliMUONSubEventTrigger();
  AliMUONScalerEventTrigger* scalerEvent = 0x0;

  AliMUONGlobalTrigger* globalTrigger = 0x0;
  AliMUONLocalTrigger* localTrigger = new  AliMUONLocalTrigger();


  //Int_t kDDLHeaderSize = fDDLTrigger->GetHeaderSize();    
  // we dont need this, as size of ddl data is same for triger and no trigger

  Int_t kDDLEnhanceHeaderSize = fDDLTrigger->GetHeaderLength(); 
  Int_t kRegHeaderSize        = subEventTrigger->GetRegHeaderLength() ;

  Int_t loCircuit, loStripX, loDev, loStripY, loLpt, loHpt;
  Char_t loDecision; 

  UShort_t x1Pattern, x2Pattern, x3Pattern, x4Pattern;
  UShort_t y1Pattern, y2Pattern, y3Pattern, y4Pattern;

  // loop over the two ddl's
  for(Int_t iDDL = 0; iDDL < 2; iDDL++) { //DDL loop

    rawReader->Select(0XA,iDDL,iDDL);  //Select the DDL file to be read  

    rawReader->ReadHeader();

    Int_t totalDataWord = rawReader->GetDataSize(); // in bytes
    UInt_t *buffer = new UInt_t[totalDataWord/4];

    rawReader->ReadNext((UChar_t*)buffer, totalDataWord); 
  
    Int_t index = 0;
    fDDLTrigger->SetDDLWord(buffer[index++]);

    if(fDDLTrigger->GetEventType() == 2) {
      fScalerEvent = kTRUE;
      scalerEvent = new  AliMUONScalerEventTrigger();
    } else
      fScalerEvent = kFALSE;

    if(fScalerEvent) {
      // 6 DARC scaler words
      memcpy(scalerEvent->GetDarcScalers(), &buffer[index], scalerEvent->GetDarcScalerLength()*4);
      index += scalerEvent->GetDarcScalerLength();
    }

    // 4 words of global board input + Global board output
    memcpy(fDDLTrigger->GetGlobalInput(), &buffer[index], (kDDLEnhanceHeaderSize-1)*4); 
    index += kDDLEnhanceHeaderSize - 1; // kind tricky cos scaler info in-between Darc header

    if(fScalerEvent) {
      // 10 Global scaler words
      memcpy(scalerEvent->GetGlobalScalers(), &buffer[index], scalerEvent->GetGlobalScalerLength()*4);
      index += scalerEvent->GetGlobalScalerLength();
    }

    // fill global trigger information
    globalTrigger = GetGlobalTriggerPattern(fDDLTrigger->GetGlobalOuput());
    fMUONData->AddGlobalTrigger(*globalTrigger);
    
    // 8 regional boards
    for (Int_t iReg = 0; iReg < 8; iReg++) {           //loop over regeonal card

      memcpy(subEventTrigger->GetRegHeader(), &buffer[index], kRegHeaderSize*4);
      index += kRegHeaderSize;

     // 11 regional scaler word
      if(fScalerEvent) {
	memcpy(scalerEvent->GetRegScalers(), &buffer[index], scalerEvent->GetRegScalerLength()*4);
	index += scalerEvent->GetRegScalerLength();
      }

      // 16 local cards per regional board
      for (Int_t iLoc = 0; iLoc < 16; iLoc++) {         //loop over local card
	  
	Int_t iLocIndex = index;

	// 5 word trigger information
	for(Int_t iData = 0; iData < 5 ;iData++ ){
	  subEventTrigger->SetLocalData(buffer[index++],5*iLoc+iData);   //read local data
	}

	if(buffer[iLocIndex] > 0) {

	  loCircuit = (Int_t)subEventTrigger->GetLocalId(iLoc)+ 16*iReg + 128*iDDL; 
	  loStripX  = (Int_t)subEventTrigger->GetXPos(iLoc);
	  loStripY  = (Int_t)subEventTrigger->GetYPos(iLoc);
	  loDev     = (Int_t)subEventTrigger->GetXDev(iLoc);
	    
	  // fill local trigger
	  localTrigger->SetLoCircuit(loCircuit);
	  localTrigger->SetLoStripX(loStripX );
	  localTrigger->SetLoStripY(loStripY);
	  localTrigger->SetLoDev(loDev);

	  loDecision = subEventTrigger->GetLocalDec(iLoc);
	  loLpt =  loDecision       & 0x3;
	  loHpt = (loDecision >> 2) & 0x3; 
	    
	  // fill local trigger
	  localTrigger->SetLoLpt(loLpt);
	  localTrigger->SetLoHpt(loHpt);

	  //getting pattern from subvent
	  x1Pattern = subEventTrigger->GetX1(iLoc);
	  x2Pattern = subEventTrigger->GetX2(iLoc);
	  x3Pattern = subEventTrigger->GetX3(iLoc);
	  x4Pattern = subEventTrigger->GetX4(iLoc);
	    
	  y1Pattern = subEventTrigger->GetY1(iLoc);
	  y2Pattern = subEventTrigger->GetY2(iLoc);
	  y3Pattern = subEventTrigger->GetY3(iLoc);
	  y4Pattern = subEventTrigger->GetY4(iLoc);

	  // fill local trigger
	  localTrigger->SetX1Pattern(x1Pattern);
	  localTrigger->SetX2Pattern(x2Pattern);
	  localTrigger->SetX3Pattern(x3Pattern);
	  localTrigger->SetX4Pattern(x4Pattern);

	  localTrigger->SetY1Pattern(y1Pattern);
	  localTrigger->SetY2Pattern(y2Pattern);
	  localTrigger->SetY3Pattern(y3Pattern);
	  localTrigger->SetY4Pattern(y4Pattern);
	  fMUONData->AddLocalTrigger(*localTrigger);

	} // if buffer[] > 0

	// 45 regional scaler word
	if(fScalerEvent) {
	  memcpy(scalerEvent->GetLocalScalers(), &buffer[index], scalerEvent->GetLocalScalerLength()*4);
	  index += scalerEvent->GetLocalScalerLength();
	}
	  
      } // local card loop
	
    } // regional card loop
      
    delete [] buffer;
  } // DDL loop

  delete subEventTrigger;
  delete globalTrigger;
  delete localTrigger;

  delete scalerEvent;

  fTriggerTimer.Stop();
  return kTRUE;

}
//____________________________________________________________________
AliMUONGlobalTrigger* AliMUONRawReader::GetGlobalTriggerPattern(Int_t gloTrigPat) const
{
  // global trigger pattern calculation

  Int_t globalSinglePlus[3];  // tot num of single plus
  Int_t globalSingleMinus[3]; // tot num of single minus
  Int_t globalSingleUndef[3]; // tot num of single undefined
  Int_t globalPairUnlike[3];  // tot num of unlike-sign pairs
  Int_t globalPairLike[3];    // tot num of like-sign pairs


  for (Int_t i = 0; i < 3; i++) {

    globalSinglePlus[i]  = (gloTrigPat >> i) & 0x1;
    globalSingleMinus[i] = (gloTrigPat >> (i+3)) & 0x1;
    globalSingleUndef[i] = (gloTrigPat >> (i+6)) & 0x1;
    globalPairUnlike[i]  = (gloTrigPat >> (i+9)) & 0x1;
    globalPairLike[i]    = (gloTrigPat >> (i+12)) & 0x1;
  }

  return (new AliMUONGlobalTrigger(globalSinglePlus, globalSingleMinus,
				   globalSingleUndef, globalPairUnlike, 
				   globalPairLike));  

}
Commit	Line	Data
a19e2543	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	////////////////////////////////////
	17	//
ced309a5	18	// MUON Raw Data reader in ALICE-MUON
ced309a5	19	// Class version 3 (further details could be found in Alice-note)
a19e2543	20	//
	21	// Implemented non-constant buspatch numbers for tracking
	22	// with correct DDL id (first guess)
	23	// (Ch. Finck, dec 2005)
	24	//
a19e2543	25	//
	26	// Raw2Digits:
	27	// Using real mapping for tracker
	28	// Indranil Das (Adapted for runloader: Ch. Finck) july 05
ced309a5	29	// Add reader for scaler trigger events
	30	// Use memcpy instead of assignment elt by elt
	31	// (Ch. Finck, Jan 06)
a19e2543	32	//
	33	////////////////////////////////////
	34
	35	#include <fstream>
	36	#include <string>
	37
	38	#include <TClonesArray.h>
	39
a19e2543	40	#include "AliBitPacking.h"
	41	#include "AliRawReader.h"
	42	#include "AliLog.h"
	43	#include "AliRun.h"
	44
2cbb173f	45	#include "AliMpBusPatch.h"
2cbb173f	46
a19e2543	47	#include "AliMUON.h"
	48	#include "AliMUONRawReader.h"
	49	#include "AliMUONDigit.h"
	50
	51	#include "AliMUONConstants.h"
	52	#include "AliMUONData.h"
	53
	54	#include "AliMUONSubEventTracker.h"
ced309a5	55	#include "AliMUONScalerEventTrigger.h"
a19e2543	56	#include "AliMUONSubEventTrigger.h"
	57	#include "AliMUONDDLTracker.h"
	58	#include "AliMUONDDLTrigger.h"
	59
	60	#include "AliMUONLocalTrigger.h"
	61	#include "AliMUONGlobalTrigger.h"
	62
	63	#include "AliMUONGeometrySegmentation.h"
	64	#include "AliMUONGeometryModule.h"
	65	#include "AliMUONGeometryStore.h"
	66	#include "AliMpSegFactory.h"
	67	#include "AliMpPlaneType.h"
	68	#include "AliMpVSegmentation.h"
	69	#include "AliMpHelper.h"
	70	#include "AliMpPad.h"
2cbb173f	71	#include "AliMpDEManager.h"
a19e2543	72
	73	ClassImp(AliMUONRawReader) // Class implementation in ROOT context
	74	//__________________________________________________________________________
2cbb173f	75	AliMUONRawReader::AliMUONRawReader(AliMUONData* data)
	76	: TObject(),
	77	fScalerEvent(kFALSE)
a19e2543	78	{
2cbb173f	79	AliDebug(1,"");
2cbb173f	80
a19e2543	81	// Standard Constructor
a19e2543	82
a19e2543	83	// initialize segmentation factory
	84	fSegFactory = new AliMpSegFactory();
	85
	86	// initialize container
	87	fMUONData = data;
	88
	89	// ddl pointer
	90	fDDLTracker = new AliMUONDDLTracker();
	91	fDDLTrigger = new AliMUONDDLTrigger();
	92
	93	fBusPatchManager = new AliMpBusPatch();
	94	fBusPatchManager->ReadBusPatchFile();
	95
2cbb173f	96	fTrackerTimer.Start(kTRUE); fTrackerTimer.Stop();
	97	fTriggerTimer.Start(kTRUE); fTriggerTimer.Stop();
	98	fMappingTimer.Start(kTRUE); fMappingTimer.Stop();
a19e2543	99	}
	100
	101	//__________________________________________________________________________
	102	AliMUONRawReader::AliMUONRawReader()
	103	: TObject(),
	104	fMUONData(0),
a19e2543	105	fSegFactory(0),
a19e2543	106	fDDLTracker(0),
ced309a5	107	fDDLTrigger(0),
	108	fBusPatchManager(0),
	109	fScalerEvent(kFALSE)
a19e2543	110	{
a19e2543	111	// Default Constructor
2cbb173f	112	AliDebug(1,"");
	113	fTrackerTimer.Start(kTRUE); fTrackerTimer.Stop();
	114	fTriggerTimer.Start(kTRUE); fTriggerTimer.Stop();
	115	fMappingTimer.Start(kTRUE); fMappingTimer.Stop();
a19e2543	116	}
	117
	118	//_______________________________________________________________________
	119	AliMUONRawReader::AliMUONRawReader (const AliMUONRawReader& rhs)
	120	: TObject(rhs)
	121	{
	122	// Protected copy constructor
	123
	124	AliFatal("Not implemented.");
	125	}
	126
	127	//_______________________________________________________________________
	128	AliMUONRawReader &
	129	AliMUONRawReader::operator=(const AliMUONRawReader& rhs)
	130	{
	131	// Protected assignement operator
	132
	133	if (this == &rhs) return *this;
	134
	135	AliFatal("Not implemented.");
	136
	137	return *this;
	138	}
	139
	140	//__________________________________________________________________________
2cbb173f	141	AliMUONRawReader::~AliMUONRawReader()
a19e2543	142	{
a19e2543	143	delete fSegFactory;
a19e2543	144
2cbb173f	145	delete fDDLTracker;
2cbb173f	146	delete fDDLTrigger;
a19e2543	147
2cbb173f	148	delete fBusPatchManager;
	149
	150	AliInfo(Form("Execution time for MUON tracker : R:%.2fs C:%.2fs",
	151	fTrackerTimer.RealTime(),fTrackerTimer.CpuTime()));
	152	AliInfo(Form(" Execution time for MUON tracker (mapping calls part) "
	153	": R:%.2fs C:%.2fs",
	154	fMappingTimer.RealTime(),fMappingTimer.CpuTime()));
	155	AliInfo(Form("Execution time for MUON trigger : R:%.2fs C:%.2fs",
	156	fTriggerTimer.RealTime(),fTriggerTimer.CpuTime()));
a19e2543	157
a19e2543	158	}
	159
	160	//____________________________________________________________________
	161	Int_t AliMUONRawReader::Raw2Digits(AliRawReader* rawReader)
	162	{
	163
	164	// generate digits
	165	ReadTrackerDDL(rawReader);
	166
	167	// generate trigger
	168	ReadTriggerDDL(rawReader);
	169
	170	return kTRUE;
	171
	172	}
	173
	174	//____________________________________________________________________
	175	Int_t AliMUONRawReader::ReadTrackerDDL(AliRawReader* rawReader)
	176	{
	177	// reading tracker DDL
	178	// filling the TClonesArray in MUONData
	179	//
2cbb173f	180	fTrackerTimer.Start(kFALSE);
2cbb173f	181
a19e2543	182	AliMUONSubEventTracker* subEventTracker = new AliMUONSubEventTracker();
	183	AliMUONDigit* digit = new AliMUONDigit();
	184
	185
ced309a5	186	//Read Header Size of DDL,Block,DSP and BusPatch (put k before constant imb'cile)
a19e2543	187
ced309a5	188	Int_t kDDLHeaderSize = fDDLTracker->GetHeaderSize();
	189	Int_t kBlockHeaderSize = fDDLTracker->GetBlkHeaderLength();
	190	Int_t kDspHeaderSize = fDDLTracker->GetDspHeaderLength();
	191	Int_t kBusPatchHeaderSize = subEventTracker->GetHeaderLength();
a19e2543	192
	193	Int_t totalDDLSize, totalBlockSize, totalDspSize , totalBusPatchSize, dataSize;
	194
	195
	196	Int_t iBusPerDSP[5];//number of bus patches per DSP
	197	Int_t iDspMax; //number max of DSP per block
	198
	199	// minimum data size (only header's)
	200	Int_t blankDDLSize;
	201	Int_t blankBlockSize;
	202	Int_t blankDspSize;
	203
	204	for(Int_t iDDL = 0; iDDL < 20; iDDL++) { // DDL loop
	205
	206	AliDebug(3, Form("Chamber %d\n", iDDL/2 +1 ));
	207
	208	// getting DSP info
	209	fBusPatchManager->GetDspInfo(iDDL/2, iDspMax, iBusPerDSP);
	210
	211	// Each DDL is made with 2 Blocks each of which consists of 5 DSP's at most and each of DSP has at most 5 buspatches.
	212	// This information is used to calculate the size of headers (DDL,Block and DSP) which has no interesting data.
ced309a5	213	blankDDLSize = kDDLHeaderSize + 2kBlockHeaderSize + 2iDspMax*kDspHeaderSize;
ced309a5	214	blankBlockSize = kBlockHeaderSize + iDspMax*kDspHeaderSize;
a19e2543	215
a19e2543	216	for (Int_t i = 0; i < iDspMax; i++) {
ced309a5	217	blankDDLSize += 2iBusPerDSP[i]kBusPatchHeaderSize;
ced309a5	218	blankBlockSize += iBusPerDSP[i]*kBusPatchHeaderSize;
a19e2543	219	}
	220
	221	rawReader->Select(0X9, iDDL, iDDL); //Select the DDL file to be read
	222
	223	rawReader->ReadHeader();
	224
	225	totalDDLSize = (rawReader->GetDataSize() + sizeof(AliRawDataHeader))/4; // 4 is multiplied to convert byte 2 words
	226
	227	if(totalDDLSize > blankDDLSize) { // Compare the DDL header with an empty DDL header size to read the file
	228
ced309a5	229	Int_t totalDataWord = rawReader->GetDataSize(); // in bytes
	230	UInt_t *buffer = new UInt_t[totalDataWord/4];
	231
	232	rawReader->ReadNext((UChar_t*)buffer, totalDataWord);
a19e2543	233
	234	// elex info
	235	Int_t buspatchId;
	236	UChar_t channelId;
	237	UShort_t manuId;
	238	Char_t parity;
	239	UShort_t charge;
	240
	241	// indexes
	242	Int_t indexDsp;
	243	Int_t indexBusPatch;
	244	Int_t index = 0;
	245
	246	for(Int_t iBlock = 0; iBlock < 2 ;iBlock++){ // loop over 2 blocks
	247	totalBlockSize = buffer[index];
	248
	249	if(totalBlockSize > blankBlockSize) { // compare block header
ced309a5	250	index += kBlockHeaderSize;
a19e2543	251
	252	for(Int_t iDsp = 0; iDsp < iDspMax ;iDsp++){ //DSP loop
	253
	254	totalDspSize = buffer[index];
	255	indexDsp = index;
	256
ced309a5	257	blankDspSize = kDspHeaderSize + iBusPerDSP[iDsp]*kBusPatchHeaderSize; // no data just header
a19e2543	258
a19e2543	259	if(totalDspSize > blankDspSize) { // Compare DSP Header
ced309a5	260	index += kDspHeaderSize;
a19e2543	261
	262	for(Int_t iBusPatch = 0; iBusPatch < iBusPerDSP[iDsp]; iBusPatch++) {
	263
ced309a5	264	//copy buffer into header structure
	265	memcpy(subEventTracker->GetBusPatchHeader(), &buffer[index], kBusPatchHeaderSize*4);
	266
	267	totalBusPatchSize = subEventTracker->GetTotalLength();
	268	buspatchId = subEventTracker->GetBusPatchId();
a19e2543	269	indexBusPatch = index;
ced309a5	270
a19e2543	271
ced309a5	272	if(totalBusPatchSize > kBusPatchHeaderSize) { //Check Buspatch header, not empty events
a19e2543	273
ced309a5	274	index += kBusPatchHeaderSize;
ced309a5	275	dataSize = subEventTracker->GetLength();
a19e2543	276
	277	if(dataSize>0) { // check data present
	278
ced309a5	279	//copy buffer into data structure
	280	memcpy(subEventTracker->GetData(), &buffer[index], dataSize*4);
	281	index += dataSize;
	282
a19e2543	283	for(Int_t iData = 0; iData < dataSize; iData++) {
a19e2543	284
a19e2543	285	// digits info
	286	parity = subEventTracker->GetParity(iData); // test later for parity
	287	manuId = subEventTracker->GetManuId(iData);
	288	channelId = subEventTracker->GetChannelId(iData);
	289	charge = subEventTracker->GetCharge(iData);
	290	// set charge
	291	digit->SetSignal(charge);
2cbb173f	292	digit->SetPhysicsSignal(charge);
2cbb173f	293	digit->SetADC(charge);
a19e2543	294	Int_t error = GetMapping(buspatchId,manuId,channelId,digit); // Get Back the hits at pads
	295	if (error) continue;
	296
	297	// debugging
	298	if (AliLog::GetGlobalDebugLevel() == 3) {
	299	Int_t padX = digit->PadX();
	300	Int_t padY = digit->PadY();
	301	Int_t iCath = digit->Cathode();
2cbb173f	302	Int_t detElemId = digit->DetElemId();
a19e2543	303
2cbb173f	304	AliDebug(1,Form("output detElemId %d busPatchid %d PadX %d PadY %d iCath %d \n",
2cbb173f	305	detElemId, buspatchId, padX, padY, iCath));
a19e2543	306
2cbb173f	307	AliDebug(3,Form("detElemId %d Padx %d Pady %d, Cath %d, charge %d",detElemId, padX, padY, iCath, charge));
a19e2543	308	}
	309
	310	// fill digits
	311	fMUONData->AddDigit(iDDL/2, *digit);
	312
	313	} // data loop
	314	} // dataSize test
	315	} // testing buspatch
	316
	317	index = indexBusPatch + totalBusPatchSize;
	318
	319	} //buspatch loop
	320
	321	} // dsp test
	322
	323	index = indexDsp + totalDspSize;
	324
	325	} // dsp loop
	326
	327	} //block test
	328
	329	index = totalBlockSize;
	330
	331	} //block loop
	332
	333	delete[] buffer;
	334	} //loop checking the header size of DDL
	335
	336	//delete rawReader;
	337	} // DDL loop
	338
	339
	340	delete subEventTracker;
	341	delete digit;
	342
2cbb173f	343	fTrackerTimer.Stop();
2cbb173f	344
a19e2543	345	return kTRUE;
	346	}
	347
	348	//____________________________________________________________________
	349	Int_t AliMUONRawReader::GetMapping(Int_t busPatchId, UShort_t manuId,
	350	UChar_t channelId, AliMUONDigit* digit )
	351	{
	352
	353	// mapping for tracker
	354
2cbb173f	355	fMappingTimer.Start(kFALSE);
2cbb173f	356
a19e2543	357	// getting DE from buspatch
2cbb173f	358	Int_t detElemId = fBusPatchManager->GetDEfromBus(busPatchId);
2cbb173f	359	AliDebug(3,Form("detElemId: %d busPatchId %d\n", detElemId, busPatchId));
a19e2543	360
2cbb173f	361	AliMpVSegmentation* seg = fSegFactory->CreateMpSegmentationByElectronics(detElemId, manuId);
2cbb173f	362	AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,channelId),kTRUE);
a19e2543	363
2cbb173f	364	if (!pad.IsValid())
	365	{
	366	AliWarning(Form("No pad for detElemId: %d, busPatchId %d, manuId: %d, channelId: %d\n",
	367	detElemId, busPatchId, manuId, channelId));
	368	fMappingTimer.Stop();
a19e2543	369	return kTRUE;
	370	} // return error
	371
2cbb173f	372	// Getting padX, padY and cathode number.
a19e2543	373	Int_t padX = pad.GetIndices().GetFirst();
a19e2543	374	Int_t padY = pad.GetIndices().GetSecond();
2cbb173f	375	Int_t iCath = AliMpDEManager::GetCathod(detElemId,seg->PlaneType());
2cbb173f	376
a19e2543	377	// storing into digits
	378	digit->SetPadX(padX);
	379	digit->SetPadY(padY);
	380	digit->SetCathode(iCath);
2cbb173f	381	digit->SetDetElemId(detElemId);
	382	digit->SetElectronics(manuId,channelId);
	383
	384	AliDebug(3,Form("detElemId: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d\n",
	385	detElemId, busPatchId, manuId, channelId, padX, padY));
	386	StdoutToAliDebug(3,digit->Print(););
	387
	388	fMappingTimer.Stop();
a19e2543	389	return kFALSE;
	390	}
	391
	392	//____________________________________________________________________
	393	Int_t AliMUONRawReader::ReadTriggerDDL(AliRawReader* rawReader)
	394	{
	395
	396	// reading DDL for trigger
	397
2cbb173f	398	fTriggerTimer.Start(kFALSE);
2cbb173f	399
a19e2543	400	AliMUONSubEventTrigger* subEventTrigger = new AliMUONSubEventTrigger();
ced309a5	401	AliMUONScalerEventTrigger* scalerEvent = 0x0;
ced309a5	402
a19e2543	403	AliMUONGlobalTrigger* globalTrigger = 0x0;
	404	AliMUONLocalTrigger* localTrigger = new AliMUONLocalTrigger();
	405
	406
ced309a5	407	//Int_t kDDLHeaderSize = fDDLTrigger->GetHeaderSize();
a19e2543	408	// we dont need this, as size of ddl data is same for triger and no trigger
a19e2543	409
ced309a5	410	Int_t kDDLEnhanceHeaderSize = fDDLTrigger->GetHeaderLength();
ced309a5	411	Int_t kRegHeaderSize = subEventTrigger->GetRegHeaderLength() ;
a19e2543	412
	413	Int_t loCircuit, loStripX, loDev, loStripY, loLpt, loHpt;
	414	Char_t loDecision;
	415
	416	UShort_t x1Pattern, x2Pattern, x3Pattern, x4Pattern;
	417	UShort_t y1Pattern, y2Pattern, y3Pattern, y4Pattern;
	418
a19e2543	419	// loop over the two ddl's
	420	for(Int_t iDDL = 0; iDDL < 2; iDDL++) { //DDL loop
	421
	422	rawReader->Select(0XA,iDDL,iDDL); //Select the DDL file to be read
	423
	424	rawReader->ReadHeader();
	425
ced309a5	426	Int_t totalDataWord = rawReader->GetDataSize(); // in bytes
ced309a5	427	UInt_t *buffer = new UInt_t[totalDataWord/4];
a19e2543	428
ced309a5	429	rawReader->ReadNext((UChar_t*)buffer, totalDataWord);
a19e2543	430
a19e2543	431	Int_t index = 0;
ced309a5	432	fDDLTrigger->SetDDLWord(buffer[index++]);
	433
	434	if(fDDLTrigger->GetEventType() == 2) {
	435	fScalerEvent = kTRUE;
	436	scalerEvent = new AliMUONScalerEventTrigger();
	437	} else
	438	fScalerEvent = kFALSE;
	439
	440	if(fScalerEvent) {
	441	// 6 DARC scaler words
	442	memcpy(scalerEvent->GetDarcScalers(), &buffer[index], scalerEvent->GetDarcScalerLength()*4);
	443	index += scalerEvent->GetDarcScalerLength();
	444	}
	445
	446	// 4 words of global board input + Global board output
	447	memcpy(fDDLTrigger->GetGlobalInput(), &buffer[index], (kDDLEnhanceHeaderSize-1)*4);
	448	index += kDDLEnhanceHeaderSize - 1; // kind tricky cos scaler info in-between Darc header
a19e2543	449
ced309a5	450	if(fScalerEvent) {
	451	// 10 Global scaler words
	452	memcpy(scalerEvent->GetGlobalScalers(), &buffer[index], scalerEvent->GetGlobalScalerLength()*4);
	453	index += scalerEvent->GetGlobalScalerLength();
	454	}
a19e2543	455
	456	// fill global trigger information
	457	globalTrigger = GetGlobalTriggerPattern(fDDLTrigger->GetGlobalOuput());
	458	fMUONData->AddGlobalTrigger(*globalTrigger);
ced309a5	459
a19e2543	460	// 8 regional boards
	461	for (Int_t iReg = 0; iReg < 8; iReg++) { //loop over regeonal card
	462
ced309a5	463	memcpy(subEventTrigger->GetRegHeader(), &buffer[index], kRegHeaderSize*4);
ced309a5	464	index += kRegHeaderSize;
a19e2543	465
ced309a5	466	// 11 regional scaler word
	467	if(fScalerEvent) {
	468	memcpy(scalerEvent->GetRegScalers(), &buffer[index], scalerEvent->GetRegScalerLength()*4);
	469	index += scalerEvent->GetRegScalerLength();
	470	}
a19e2543	471
	472	// 16 local cards per regional board
	473	for (Int_t iLoc = 0; iLoc < 16; iLoc++) { //loop over local card
	474
	475	Int_t iLocIndex = index;
	476
	477	// 5 word trigger information
	478	for(Int_t iData = 0; iData < 5 ;iData++ ){
	479	subEventTrigger->SetLocalData(buffer[index++],5*iLoc+iData); //read local data
	480	}
	481
	482	if(buffer[iLocIndex] > 0) {
	483
	484	loCircuit = (Int_t)subEventTrigger->GetLocalId(iLoc)+ 16iReg + 128iDDL;
ced309a5	485	loStripX = (Int_t)subEventTrigger->GetXPos(iLoc);
	486	loStripY = (Int_t)subEventTrigger->GetYPos(iLoc);
	487	loDev = (Int_t)subEventTrigger->GetXDev(iLoc);
a19e2543	488
	489	// fill local trigger
	490	localTrigger->SetLoCircuit(loCircuit);
	491	localTrigger->SetLoStripX(loStripX );
	492	localTrigger->SetLoStripY(loStripY);
	493	localTrigger->SetLoDev(loDev);
	494
	495	loDecision = subEventTrigger->GetLocalDec(iLoc);
	496	loLpt = loDecision & 0x3;
	497	loHpt = (loDecision >> 2) & 0x3;
	498
	499	// fill local trigger
	500	localTrigger->SetLoLpt(loLpt);
	501	localTrigger->SetLoHpt(loHpt);
	502
	503	//getting pattern from subvent
	504	x1Pattern = subEventTrigger->GetX1(iLoc);
	505	x2Pattern = subEventTrigger->GetX2(iLoc);
	506	x3Pattern = subEventTrigger->GetX3(iLoc);
	507	x4Pattern = subEventTrigger->GetX4(iLoc);
	508
	509	y1Pattern = subEventTrigger->GetY1(iLoc);
	510	y2Pattern = subEventTrigger->GetY2(iLoc);
	511	y3Pattern = subEventTrigger->GetY3(iLoc);
	512	y4Pattern = subEventTrigger->GetY4(iLoc);
	513
	514	// fill local trigger
	515	localTrigger->SetX1Pattern(x1Pattern);
	516	localTrigger->SetX2Pattern(x2Pattern);
	517	localTrigger->SetX3Pattern(x3Pattern);
	518	localTrigger->SetX4Pattern(x4Pattern);
	519
	520	localTrigger->SetY1Pattern(y1Pattern);
	521	localTrigger->SetY2Pattern(y2Pattern);
	522	localTrigger->SetY3Pattern(y3Pattern);
	523	localTrigger->SetY4Pattern(y4Pattern);
	524	fMUONData->AddLocalTrigger(*localTrigger);
	525
ced309a5	526	} // if buffer[] > 0
	527
	528	// 45 regional scaler word
	529	if(fScalerEvent) {
	530	memcpy(scalerEvent->GetLocalScalers(), &buffer[index], scalerEvent->GetLocalScalerLength()*4);
	531	index += scalerEvent->GetLocalScalerLength();
a19e2543	532	}
	533
	534	} // local card loop
	535
	536	} // regional card loop
	537
	538	delete [] buffer;
	539	} // DDL loop
	540
	541	delete subEventTrigger;
	542	delete globalTrigger;
	543	delete localTrigger;
	544
2cbb173f	545	delete scalerEvent;
ced309a5	546
2cbb173f	547	fTriggerTimer.Stop();
a19e2543	548	return kTRUE;
	549
	550	}
	551	//____________________________________________________________________
	552	AliMUONGlobalTrigger* AliMUONRawReader::GetGlobalTriggerPattern(Int_t gloTrigPat) const
	553	{
	554	// global trigger pattern calculation
	555
	556	Int_t globalSinglePlus[3]; // tot num of single plus
	557	Int_t globalSingleMinus[3]; // tot num of single minus
	558	Int_t globalSingleUndef[3]; // tot num of single undefined
	559	Int_t globalPairUnlike[3]; // tot num of unlike-sign pairs
	560	Int_t globalPairLike[3]; // tot num of like-sign pairs
	561
	562
	563	for (Int_t i = 0; i < 3; i++) {
c14da03e	564
	565	globalSinglePlus[i] = (gloTrigPat >> i) & 0x1;
	566	globalSingleMinus[i] = (gloTrigPat >> (i+3)) & 0x1;
	567	globalSingleUndef[i] = (gloTrigPat >> (i+6)) & 0x1;
	568	globalPairUnlike[i] = (gloTrigPat >> (i+9)) & 0x1;
	569	globalPairLike[i] = (gloTrigPat >> (i+12)) & 0x1;
a19e2543	570	}
	571
	572	return (new AliMUONGlobalTrigger(globalSinglePlus, globalSingleMinus,
	573	globalSingleUndef, globalPairUnlike,
	574	globalPairLike));
	575
	576	}
	577