[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 "AliLoader.h"
#include "AliBitPacking.h" 
#include "AliRawReader.h"
#include "AliLog.h"
#include "AliRun.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"


ClassImp(AliMUONRawReader) // Class implementation in ROOT context
//__________________________________________________________________________
AliMUONRawReader::AliMUONRawReader(AliLoader* loader,  AliMUONData* data)
  : TObject(),
    fScalerEvent(kFALSE)
{
  // Standard Constructor
 
  // initialize loader's
  fLoader = loader;

  // initialize segmentation factory
  fSegFactory = new AliMpSegFactory();

  // initialize container
  fMUONData  = data;

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

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

}

//__________________________________________________________________________
AliMUONRawReader::AliMUONRawReader()
  : TObject(),
    fMUONData(0),
    fLoader(0),    
    fSegFactory(0),
    fDDLTracker(0),
    fDDLTrigger(0),
    fBusPatchManager(0),
    fScalerEvent(kFALSE)
{
  // Default Constructor
  
}

//_______________________________________________________________________
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(void)
{
  if (fSegFactory) 
    fSegFactory->DeleteSegmentations();
  delete fSegFactory;  

  if (fDDLTracker)
    delete fDDLTracker;
  if (fDDLTrigger)
    delete fDDLTrigger;

  fBusPatchManager->Delete();

  return;
}

//____________________________________________________________________
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
  //

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

		      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 idDE  = digit->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
		      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;

  return kTRUE;
}

//____________________________________________________________________
Int_t AliMUONRawReader::GetMapping(Int_t busPatchId, UShort_t manuId, 
					 UChar_t channelId, AliMUONDigit* digit )
{

 // mapping  for tracker

  // getting DE from buspatch
  Int_t  idDE = fBusPatchManager->GetDEfromBus(busPatchId);
  AliDebug(3,Form("idDE: %d busPatchId %d\n", idDE, busPatchId));

  // segmentation
  Int_t iCath;
  Int_t iCath1 = 0;
  Int_t iCath2 = 1;

  if (idDE < 500) { // should use GetDirection somehow (ChF)
    if ( ((idDE % 100) % 2) != 0 ) {
      iCath1 = 1;
      iCath2 = 0;
    }
  }

  iCath = (manuId > 1000) ? iCath2 : iCath1;

  if (manuId > 1000) manuId -= 1000; // back to normal manuId

  // Could the above logic be simplified ???
  //AliMpVSegmentation* seg = AliMUONSegmentationManager::Segmentation(idDE, plane);
  AliMpVSegmentation* seg = fSegFactory->CreateMpSegmentation(idDE, iCath);  
  AliMpPad pad = seg->PadByLocation(AliMpIntPair(manuId,(Int_t)channelId),kTRUE);

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

  // Getting padX
  Int_t padX = pad.GetIndices().GetFirst();

 // Getting padY
  Int_t padY = pad.GetIndices().GetSecond();
     
  if (idDE >= 500) { // Since in AliMpSlat pads begin at (0,0) 
    padX++;         // while in AliMUONSt345Seg. they begin at (1,1)
    padY++;
  }
  // storing into digits
  digit->SetPadX(padX);
  digit->SetPadY(padY);
  digit->SetCathode(iCath);
  digit->SetDetElemId(idDE);

  AliDebug(3,Form("idDE: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d\n",
		  idDE, busPatchId, manuId, channelId, padX, padY));
  return kFALSE;
}

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

  // reading DDL for trigger

  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;

  if(fScalerEvent)
    delete scalerEvent;

  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 & (0x1 << i);
    globalSingleMinus[i] = gloTrigPat & (0x1 << i+3);
    globalSingleUndef[i] = gloTrigPat & (0x1 << i+6);
    globalPairUnlike[i]  = gloTrigPat & (0x1 << i+9);
    globalPairLike[i]    = gloTrigPat & (0x1 << i+12);
  }

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