[u/mrichter/AliRoot.git] / MUON / AliMUONRawData.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 generator in ALICE-MUON
//
// This class version 1 (further details could be found in Alice-note coming soon right in our direction)
// Generates raw data for MUON tracker and finally for trigger
// * a simple mapping is used (see below)
// * the bus patch id is calculated with an absolute number 0 - 999
// * one DDL per 1/2 chamber is created for both cathode.
// For trigger there is no mapping (mapping could be found in AliMUONTriggerCircuit)
// don't need for digits2raw but needed in raw2Reco
// the position are given per local card
////////////////////////////////////

#include <TClonesArray.h>
#include "AliMUONRawData.h"
#include "AliMUONDigit.h"
#include "AliMUONTriggerDecision.h"
#include "AliMUONConstants.h"
#include "AliMUONData.h"
#include "AliRun.h" 
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliBitPacking.h" 
#include "AliMUONDDLTracker.h"
#include "AliMUONDDLTrigger.h"

#include "AliMUON.h"
#include "AliMUONLocalTrigger.h"
#include "AliMUONGlobalTrigger.h"
#include "AliMUONTriggerCircuit.h"

const Int_t AliMUONRawData::fgkDefaultPrintLevel = 0;

ClassImp(AliMUONRawData) // Class implementation in ROOT context

//__________________________________________________________________________
AliMUONRawData::AliMUONRawData(AliLoader* loader)
  : TObject(),
    fDebug(0)
{
  // Standard Constructor
 
  fPrintLevel = fgkDefaultPrintLevel;

  // initialize loader's
  fLoader = loader;

  // initialize container
  fMUONData  = new AliMUONData(fLoader,"MUON","MUON");

  // trigger decision, temp solution, local & global has to move to Digits Tree
//   fTrigDec = new AliMUONTriggerDecision(fLoader);
//   fTrigData = fTrigDec->GetMUONData();

  // initialize array
  fSubEventArray[0] = new TClonesArray("AliMUONSubEventTracker",1000);
  fSubEventArray[1] = new TClonesArray("AliMUONSubEventTracker",1000);

  // initialize array
  fSubEventTrigArray[0] = new TClonesArray("AliMUONSubEventTrigger",1000);
  fSubEventTrigArray[1] = new TClonesArray("AliMUONSubEventTrigger",1000);

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

//__________________________________________________________________________
AliMUONRawData::AliMUONRawData()
  : TObject(),
    fMUONData(0),
    fPrintLevel(fgkDefaultPrintLevel),
    fDebug(0),
    fLoader(0)
{
  // Default Constructor
}

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

  Fatal("AliMUONRawData", "Not implemented.");
}

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

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

  Fatal("operator=", "Not implemented.");
    
  return *this;  
}

//__________________________________________________________________________
AliMUONRawData::~AliMUONRawData(void)
{
  if (fMUONData)
    delete fMUONData;
  if (fSubEventArray[0])
    fSubEventArray[0]->Delete(); //using delete cos allocating memory in copy ctor.
  if (fSubEventArray[1])
    fSubEventArray[1]->Delete();

  if (fSubEventTrigArray[0])
    fSubEventTrigArray[0]->Delete();
  if (fSubEventTrigArray[1])
    fSubEventTrigArray[1]->Delete();

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

  return;
}
//____________________________________________________________________
Int_t AliMUONRawData::WriteRawData()
{
 // convert digits of the current event to raw data

  Int_t DDLId;
  Char_t name[20];

  fLoader->LoadDigits("READ");

  fMUONData->SetTreeAddress("D,GLT");


  // tracking chambers

  for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) {
 
    // open files
    DDLId = ich * 2  + 0x900;
    sprintf(name, "MUON_%d.ddl",DDLId);
    fFile1 = fopen(name,"w");

    DDLId = (ich * 2) + 1 + 0x900;
    sprintf(name, "MUON_%d.ddl",DDLId);
    fFile2 = fopen(name,"w");

    WriteTrackerDDL(ich);
  
    // reset and close
    fclose(fFile1);
    fclose(fFile2);
    fMUONData->ResetDigits();
  }
 
  // trigger chambers
 
  // open files
  DDLId = 0xA00;
  sprintf(name, "MUTR_%d.ddl",DDLId);
  fFile1 = fopen(name,"w");

  DDLId = 0xA00 + 1;
  sprintf(name, "MUTR_%d.ddl",DDLId);
  fFile2 = fopen(name,"w");

  WriteTriggerDDL();
  
  // reset and close
  fclose(fFile1);
  fclose(fFile2);
  fMUONData->ResetTrigger();
  
  fLoader->UnloadDigits();

  return kTRUE;
}
//____________________________________________________________________
Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh)
{
  // resets
  TClonesArray* muonDigits = 0;
  fSubEventArray[0]->Clear();
  fSubEventArray[1]->Clear();

  //
  TArrayI nbInBus[2];

  nbInBus[0].Set(5000);
  nbInBus[1].Set(5000);

  nbInBus[0].Reset();
  nbInBus[1].Reset();

  // DDL header
  AliRawDataHeader header = fDDLTracker->GetHeader();
  Int_t headerSize = fDDLTracker->GetHeaderSize();

  // DDL event one per half chamber
  AliMUONSubEventTracker* subEvent;

  // data format
  Char_t parity = 0x4;
  UShort_t manuId = 0;
  UChar_t channelId = 0;
  UShort_t charge = 0;
  Int_t busPatchId = 0;

  UInt_t word;
  Int_t nEntries = 0;
  Int_t* buffer = 0;
  Int_t index;
  Int_t indexDsp;
  Int_t indexBlk;

  Int_t nDigits;
  const AliMUONDigit* digit;

   if (fPrintLevel == 1)
      printf("WriteDDL chamber %d\n", iCh+1);

  for (Int_t iCath = 0; iCath < 2; iCath++) {

    fMUONData->ResetDigits();
    fMUONData->GetCathode(iCath);
    muonDigits = fMUONData->Digits(iCh);

    nDigits = muonDigits->GetEntriesFast();
    if (fPrintLevel == 2)
      printf("ndigits = %d\n",nDigits);

    // open DDL file, on per 1/2 chamber
 
    for (Int_t idig = 0; idig < nDigits; idig++) {

      digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig);

      // mapping
      GetDummyMapping(iCh, iCath, digit, busPatchId, manuId, channelId, charge);

      //packing word
      AliBitPacking::PackWord((UInt_t)parity,word,29,31);
      AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
      AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
      AliBitPacking::PackWord((UInt_t)charge,word,0,11);

      // set sub Event
      subEvent = new AliMUONSubEventTracker();
      subEvent->AddData(word);
      subEvent->SetBusPatchId(busPatchId);
      if (digit->PadX() > 0) {
	nbInBus[0][busPatchId]++;
	AddData1(subEvent);
      } else {
	nbInBus[1][busPatchId]++;
	AddData2(subEvent);
      }
      delete subEvent;
    }
  }
  fSubEventArray[0]->Sort();
  fSubEventArray[1]->Sort();

  // gather datas from same bus patch
   for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
    nEntries = fSubEventArray[iDDL]->GetEntriesFast();

    for (Int_t i = 0; i < nEntries; i++) {
      AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
      busPatchId = temp->GetBusPatchId();

      // add bus patch header, length and total length managed by subevent class
      temp->SetTriggerWord(0xdeadbeef);
      for (Int_t j = 0; j < nbInBus[iDDL][busPatchId]-1; j++) {
	AliMUONSubEventTracker* temp1 =  (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(++i);
	temp->AddData(temp1->GetData(0));
	fSubEventArray[iDDL]->RemoveAt(i) ;
      }
    }
    fSubEventArray[iDDL]->Compress();

    if (fPrintLevel == 3) {
      nEntries = fSubEventArray[iDDL]->GetEntriesFast();
      for (Int_t i = 0; i < nEntries; i++) {
	AliMUONSubEventTracker* temp =  (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
	printf("busPatchid back %d\n",temp->GetBusPatchId());
	for (Int_t j = 0; j < temp->GetLength(); j++) {
	  printf("manuId back %d, ",temp->GetManuId(j));
	  printf("channelId back %d, ",temp->GetChannelId(j));
	  printf("charge back %d\n",temp->GetCharge(j));
	}
      }
      printf("\n");
    }
  
  }
  
  Int_t iBusPatch;
  Int_t iEntries;

  for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
 

    // filling buffer
    nEntries = fSubEventArray[iDDL]->GetEntriesFast();
    buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most

    indexBlk = 0;
    indexDsp = 0;
    index = 0;
    iBusPatch = 0;
    iEntries = 0;

    for (Int_t iBlock = 0; iBlock < 2; iBlock++) {

      // block header
      fDDLTracker->SetTotalBlkLength(0xFFFFFFFF);
      memcpy(&buffer[index],fDDLTracker->GetBlkHeader(),32);
      indexBlk = index;
      index += 8; 

      for (Int_t iDsp = 0; iDsp < 5; iDsp++) {

	// DSP header
	fDDLTracker->SetTotalDspLength(0xEEEEEEEE);
	memcpy(&buffer[index],fDDLTracker->GetDspHeader(),32);
	indexDsp = index;
	index += 8; 

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

	  iBusPatch = i + iBlock*25 + iDsp*5 + 50*(2*iCh + iDDL);

	  AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(iEntries);
	  if (nEntries > 0) 
	    busPatchId = temp->GetBusPatchId();
	   else
	    busPatchId = -1;

	  if (busPatchId == iBusPatch) {
	    // add bus patch structure
	    memcpy(&buffer[index],temp->GetAddress(),16);
	    index+= 4;
	    for (Int_t j = 0; j < temp->GetLength(); j++) 
	      buffer[index++] =  temp->GetData(j);
	    if (iEntries < nEntries-1)
	      iEntries++;
	  } else {
	    buffer[index++] = 4; // total length
	    buffer[index++] = 0; // raw data length
	    buffer[index++] = iBusPatch; // bus patch
	    buffer[index++] = 0xdeadbeef; // trigger word
	  }
	} // bus patch
	buffer[indexDsp] = index - indexDsp;
	buffer[indexDsp+1] = index - indexDsp -8;
	if ((index - indexDsp) % 2 == 0)
	  buffer[indexDsp+7] = 0;
	else
	  buffer[indexDsp+7] = 1;
      } // dsp
      buffer[indexBlk] = index - indexBlk;
      buffer[indexBlk+1] = index - indexBlk -8;
    }
    if (iDDL == 0) {
      // write DDL 1
      header.fSize = index + headerSize;// total length in word
      fwrite((char*)(&header),headerSize*4,1,fFile1);
      fwrite(buffer,sizeof(int),index,fFile1);
    } 
    if (iDDL == 1) {
      // write DDL 2
      header.fSize = index + headerSize;// total length in word
      fwrite((char*)(&header),headerSize*4,1,fFile2);
      fwrite(buffer,sizeof(int),index,fFile2);
    }
    delete[] buffer;
  }

  return kTRUE;
}
//____________________________________________________________________
Int_t AliMUONRawData::WriteTriggerDDL()
{

 // DDL event one per half chamber
  AliMUONSubEventTrigger* subEvent = 0x0;


  // stored local id number 
  TArrayI isFired(256);
  isFired.Reset();


 // DDL header
  AliRawDataHeader header = fDDLTrigger->GetHeader();
  Int_t headerSize = fDDLTrigger->GetHeaderSize();

  TClonesArray* localTrigger;
  TClonesArray* globalTrigger;
  AliMUONGlobalTrigger* gloTrg;
  AliMUONLocalTrigger* locTrg = 0x0;

  fMUONData->GetTriggerD();

  // global trigger for trigger pattern
  globalTrigger = fMUONData->GlobalTrigger(); 
  gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
  Int_t gloTrigPat = GetGlobalTriggerPattern(gloTrg);

  // local trigger 
  localTrigger = fMUONData->LocalTrigger();    

  UInt_t word;
  Int_t* buffer = 0;
  Int_t index;
  Int_t iEntries = 0;
  Int_t iLocCard, locCard;
  Char_t locDec, trigY, posY, devX, posX;
  Int_t version = 1; // software version
  Int_t eventType =1; // trigger type: 1 for physics ?
  Int_t serialNb = 0xF; // serial nb of card: all bits on for the moment

  Int_t nEntries = (Int_t) (localTrigger->GetEntries());// 234 local cards
  // stored the local card id that's fired
  for (Int_t i = 0; i <  nEntries; i++) {
    locTrg = (AliMUONLocalTrigger*)localTrigger->At(i);
    isFired[locTrg->LoCircuit()] = 1;
  }

  if (!nEntries)
    Error("AliMUONRawData::WriteTriggerDDL","No Trigger information available");

  buffer = new Int_t [680]; // [16(local)*5 words + 4 words]*8(reg) + 7 words = 679

  for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
    
    index = 0; 

    // DDL enhanced header
    word =0;
    AliBitPacking::PackWord((UInt_t)iDDL+1,word,30,31); //see AliMUONDDLTrigger.h for details
    AliBitPacking::PackWord((UInt_t)version,word,22,29);
    AliBitPacking::PackWord((UInt_t)serialNb,word,18,21);
    AliBitPacking::PackWord((UInt_t)eventType,word,14,17);

    fDDLTrigger->SetDDLWord(word);
    fDDLTrigger->SetGlobalOutput(gloTrigPat);
    memcpy(&buffer[index],fDDLTrigger->GetEnhancedHeader(),24);
    index += 6; 

    for (Int_t iReg = 0; iReg < 8; iReg++) {

      subEvent = new AliMUONSubEventTrigger();

      // Regional card header
      word = 0;
      AliBitPacking::PackWord((UInt_t)serialNb,word,27,31); //see  AliMUONSubEventTrigger.h for details
      AliBitPacking::PackWord((UInt_t)iReg,word,22,26);
      AliBitPacking::PackWord((UInt_t)version,word,14,21);
      subEvent->SetRegWord(word);
      memcpy(&buffer[index++],subEvent->GetAddress(),4);

      for (Int_t iLoc = 0; iLoc < 16; iLoc++) {

	iLocCard = iLoc + iReg*16 + iDDL*128;

	if (isFired[iLocCard]) {
	  locTrg = (AliMUONLocalTrigger*)localTrigger->At(iEntries);
	  locCard = locTrg->LoCircuit();
	  locDec = locTrg->GetLoDecision();
	  trigY = 0;
	  posY = locTrg->LoStripY();
	  posX = locTrg->LoStripX();
	  devX = locTrg->LoDev();
	  if (fPrintLevel == 4) 
	    printf("loctrg %d, posX %d, posY %d, devX %d\n", 
		   locTrg-> LoCircuit(),locTrg->LoStripX(),locTrg->LoStripY(),locTrg->LoDev());
	} else { //no trigger (see PRR chpt 3.4)
	  locCard = -1;
	  locDec = 0;
	  trigY = 1;
	  posY = 15;
	  posX = 0;
	  devX = 0x8000;
	}

	//packing word
	word = 0;
	AliBitPacking::PackWord((UInt_t)(iLocCard % 16),word,19,22); //card id number in crate
	AliBitPacking::PackWord((UInt_t)locDec,word,15,18);
	AliBitPacking::PackWord((UInt_t)trigY,word,14,14);
	AliBitPacking::PackWord((UInt_t)posY,word,10,13);
	AliBitPacking::PackWord((UInt_t)devX,word,5,9);
	AliBitPacking::PackWord((UInt_t)posX,word,0,4);

	if (locCard == iLocCard) {
	  // add local cards structure
	  buffer[index++] = (locTrg->GetX1Pattern() | (locTrg->GetX2Pattern() << 16));
	  buffer[index++] = (locTrg->GetX3Pattern() | (locTrg->GetX4Pattern() << 16));
	  buffer[index++] = (locTrg->GetY1Pattern() | (locTrg->GetY2Pattern() << 16));
	  buffer[index++] = (locTrg->GetY3Pattern() | (locTrg->GetY4Pattern() << 16));
	  buffer[index++] = (Int_t)word; // data word
	  if (iEntries < nEntries-1)
	    iEntries++;
	} else {
	  buffer[index++] = 0; // 4 words for x1, x2, y1, y2
	  buffer[index++] = 0; 
	  buffer[index++] = 0; 
	  buffer[index++] = 0; 
	  buffer[index++] = (Int_t)word; // data word

	}
      } // local card 
      buffer[index++] = 0;// 2 words of regional input
      buffer[index++] = 0;
      buffer[index++] = 0;// regional output

      delete subEvent;	

    } // Regional card
    
    buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word

    
    if (iDDL == 0) {
      // write DDL 1
      header.fSize = index + headerSize;// total length in word
      fwrite((char*)(&header),headerSize*4,1,fFile1);
      fwrite(buffer,sizeof(int),index,fFile1);
    } 
    if (iDDL == 1) {
      // write DDL 2
      header.fSize = index + headerSize;// total length in word
      fwrite((char*)(&header),headerSize*4,1,fFile2);
      fwrite(buffer,sizeof(int),index,fFile2);
    }
  }
  delete[] buffer;

  return kTRUE;
}
//____________________________________________________________________
void AliMUONRawData::GetDummyMapping(Int_t iCh, Int_t iCath, const AliMUONDigit* digit,
				     Int_t &busPatchId, UShort_t &manuId, UChar_t &channelId, UShort_t &charge)
{

  Int_t offsetX = 0; // offet row
  Int_t offsetY = 0; // offset columns
  Int_t offsetCath = 0; //offset from one cathod to the other
  Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber
  Int_t id;
      switch (iCh+1) {
      case 1:
      case 2:
      case 3:
      case 4:
	offsetX = 512;
	offsetY = 256;
	offsetCath = 65536;
	maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath);
	break;
      case 5:
      case 6:
      case 7:
      case 8:
      case 9:
      case 10:
	offsetX = 1024;
	offsetY = 0;
	offsetCath = 65536;
	maxChannel = (256 * offsetX + offsetX + offsetCath);
	break;
      }
      // dummy mapping
      // manu Id directly from a matrix 8*8, same segmentation for B and NB
      // 50 buspatches for 1/2 chamber

      id =  (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
	     offsetCath * iCath);
      Int_t chPerBus = maxChannel/50;
      busPatchId = id/chPerBus; // start at zero 
      if (digit->PadX() > 0)
	busPatchId += 50*iCh*2;
      else 
	busPatchId += 50*(2*iCh+1);
      // 64 manu cards for one buspatch
      manuId = (id % chPerBus)/64; //start at zero 
      manuId &= 0x7FF; // 11 bits 

      // channel id
      channelId = (id % chPerBus) % 64; //start at zero 
      channelId &= 0x3F; // 6 bits

//       id =  (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
// 	     offsetCath * iCath);
//       busPatchId = id/50;

//       Int_t inBusId = id - (maxChannel/50 * busPatchId);// id channel in buspatch
//       Int_t manuPerBus = (maxChannel/(50*64)); // number of manus per buspatch

//       // 64 manu cards for one buspatch
//       manuId = inBusId/manuPerBus;
//       manuId &= 0x7FF; // 11 bits 

//       // channel id
//       channelId = (inBusId % manuPerBus);
//       channelId &= 0x3F; // 6 bits

      if (fPrintLevel == 2)
	printf("id: %d, busPatchId %d, manuId: %d, channelId: %d, maxchannel: %d, chPerBus %d\n",
	       id, busPatchId, manuId, channelId, maxChannel, chPerBus);
      // charge
      charge = digit->Signal();
      charge &= 0xFFF;

      if (fPrintLevel == 2)
	printf("id: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d, charge %d\n",
	       id, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal());

}

//____________________________________________________________________
Int_t AliMUONRawData::GetGlobalTriggerPattern(AliMUONGlobalTrigger* gloTrg)
{
  Int_t gloTrigPat = 0;

  if (gloTrg->SinglePlusLpt())  gloTrigPat|= 0x1;
  if (gloTrg->SinglePlusHpt())  gloTrigPat|= 0x2;
  if (gloTrg->SinglePlusApt())  gloTrigPat|= 0x4;
 
  if (gloTrg->SingleMinusLpt()) gloTrigPat|= 0x8;
  if (gloTrg->SingleMinusHpt()) gloTrigPat|= 0x10;
  if (gloTrg->SingleMinusApt()) gloTrigPat|= 0x20;
 
  if (gloTrg->SingleUndefLpt()) gloTrigPat|= 0x40;
  if (gloTrg->SingleUndefHpt()) gloTrigPat|= 0x80;
  if (gloTrg->SingleUndefApt()) gloTrigPat|= 0x100;
 
  if (gloTrg->PairUnlikeLpt())  gloTrigPat|= 0x200;
  if (gloTrg->PairUnlikeHpt())  gloTrigPat|= 0x400;
  if (gloTrg->PairUnlikeApt())  gloTrigPat|= 0x800;

  if (gloTrg->PairLikeLpt())    gloTrigPat|= 0x1000;
  if (gloTrg->PairLikeHpt())    gloTrigPat|= 0x2000;
  if (gloTrg->PairLikeApt())    gloTrigPat|= 0x4000;

  return gloTrigPat;
}
Commit	Line	Data
f6762c71	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	//
	18	// MUON Raw Data generator in ALICE-MUON
	19	//
c8b4255f	20	// This class version 1 (further details could be found in Alice-note coming soon right in our direction)
c8b4255f	21	// Generates raw data for MUON tracker and finally for trigger
f6762c71	22	// * a simple mapping is used (see below)
69be760c	23	// * the bus patch id is calculated with an absolute number 0 - 999
c8b4255f	24	// * one DDL per 1/2 chamber is created for both cathode.
	25	// For trigger there is no mapping (mapping could be found in AliMUONTriggerCircuit)
	26	// don't need for digits2raw but needed in raw2Reco
	27	// the position are given per local card
f6762c71	28	////////////////////////////////////
c8b4255f	29
69be760c	30	#include <TClonesArray.h>
f6762c71	31	#include "AliMUONRawData.h"
f6762c71	32	#include "AliMUONDigit.h"
69be760c	33	#include "AliMUONTriggerDecision.h"
f6762c71	34	#include "AliMUONConstants.h"
f6762c71	35	#include "AliMUONData.h"
f6762c71	36	#include "AliRun.h"
	37	#include "AliRunLoader.h"
	38	#include "AliLoader.h"
	39	#include "AliBitPacking.h"
69be760c	40	#include "AliMUONDDLTracker.h"
	41	#include "AliMUONDDLTrigger.h"
	42
c8b4255f	43	#include "AliMUON.h"
	44	#include "AliMUONLocalTrigger.h"
	45	#include "AliMUONGlobalTrigger.h"
	46	#include "AliMUONTriggerCircuit.h"
f6762c71	47
	48	const Int_t AliMUONRawData::fgkDefaultPrintLevel = 0;
	49
	50	ClassImp(AliMUONRawData) // Class implementation in ROOT context
	51
	52	//__________________________________________________________________________
	53	AliMUONRawData::AliMUONRawData(AliLoader* loader)
69be760c	54	: TObject(),
69be760c	55	fDebug(0)
f6762c71	56	{
	57	// Standard Constructor
	58
f6762c71	59	fPrintLevel = fgkDefaultPrintLevel;
	60
	61	// initialize loader's
	62	fLoader = loader;
	63
	64	// initialize container
	65	fMUONData = new AliMUONData(fLoader,"MUON","MUON");
69be760c	66
	67	// trigger decision, temp solution, local & global has to move to Digits Tree
	68	// fTrigDec = new AliMUONTriggerDecision(fLoader);
	69	// fTrigData = fTrigDec->GetMUONData();
	70
	71	// initialize array
	72	fSubEventArray[0] = new TClonesArray("AliMUONSubEventTracker",1000);
	73	fSubEventArray[1] = new TClonesArray("AliMUONSubEventTracker",1000);
	74
	75	// initialize array
	76	fSubEventTrigArray[0] = new TClonesArray("AliMUONSubEventTrigger",1000);
	77	fSubEventTrigArray[1] = new TClonesArray("AliMUONSubEventTrigger",1000);
	78
	79	// ddl pointer
	80	fDDLTracker = new AliMUONDDLTracker();
	81	fDDLTrigger= new AliMUONDDLTrigger();
f6762c71	82	}
	83
	84	//__________________________________________________________________________
	85	AliMUONRawData::AliMUONRawData()
	86	: TObject(),
f6762c71	87	fMUONData(0),
	88	fPrintLevel(fgkDefaultPrintLevel),
	89	fDebug(0),
	90	fLoader(0)
	91	{
	92	// Default Constructor
	93	}
	94
	95	//_______________________________________________________________________
	96	AliMUONRawData::AliMUONRawData (const AliMUONRawData& rhs)
	97	: TObject(rhs)
	98	{
	99	// Protected copy constructor
	100
	101	Fatal("AliMUONRawData", "Not implemented.");
	102	}
	103
	104	//_______________________________________________________________________
	105	AliMUONRawData &
	106	AliMUONRawData::operator=(const AliMUONRawData& rhs)
	107	{
	108	// Protected assignement operator
	109
	110	if (this == &rhs) return *this;
	111
	112	Fatal("operator=", "Not implemented.");
	113
	114	return *this;
	115	}
	116
	117	//__________________________________________________________________________
	118	AliMUONRawData::~AliMUONRawData(void)
	119	{
	120	if (fMUONData)
	121	delete fMUONData;
69be760c	122	if (fSubEventArray[0])
	123	fSubEventArray[0]->Delete(); //using delete cos allocating memory in copy ctor.
	124	if (fSubEventArray[1])
	125	fSubEventArray[1]->Delete();
	126
	127	if (fSubEventTrigArray[0])
	128	fSubEventTrigArray[0]->Delete();
	129	if (fSubEventTrigArray[1])
	130	fSubEventTrigArray[1]->Delete();
	131
	132	if (fDDLTracker)
	133	delete fDDLTracker;
	134	if (fDDLTrigger)
	135	delete fDDLTrigger;
	136
f6762c71	137	return;
	138	}
	139	//____________________________________________________________________
	140	Int_t AliMUONRawData::WriteRawData()
	141	{
	142	// convert digits of the current event to raw data
	143
f6762c71	144	Int_t DDLId;
	145	Char_t name[20];
	146
	147	fLoader->LoadDigits("READ");
69be760c	148
c8b4255f	149	fMUONData->SetTreeAddress("D,GLT");
f6762c71	150
f6762c71	151
c8b4255f	152	// tracking chambers
	153
	154	for (Int_t ich = 0; ich < AliMUONConstants::NTrackingCh(); ich++) {
	155
f6762c71	156	// open files
98724670	157	DDLId = ich * 2 + 0x900;
f6762c71	158	sprintf(name, "MUON_%d.ddl",DDLId);
	159	fFile1 = fopen(name,"w");
	160
69be760c	161	DDLId = (ich * 2) + 1 + 0x900;
f6762c71	162	sprintf(name, "MUON_%d.ddl",DDLId);
	163	fFile2 = fopen(name,"w");
	164
69be760c	165	WriteTrackerDDL(ich);
f6762c71	166
	167	// reset and close
	168	fclose(fFile1);
	169	fclose(fFile2);
	170	fMUONData->ResetDigits();
	171	}
69be760c	172
69be760c	173	// trigger chambers
c8b4255f	174
69be760c	175	// open files
c8b4255f	176	DDLId = 0xA00;
	177	sprintf(name, "MUTR_%d.ddl",DDLId);
	178	fFile1 = fopen(name,"w");
69be760c	179
c8b4255f	180	DDLId = 0xA00 + 1;
	181	sprintf(name, "MUTR_%d.ddl",DDLId);
	182	fFile2 = fopen(name,"w");
69be760c	183
c8b4255f	184	WriteTriggerDDL();
	185
	186	// reset and close
	187	fclose(fFile1);
	188	fclose(fFile2);
	189	fMUONData->ResetTrigger();
f6762c71	190
c8b4255f	191	fLoader->UnloadDigits();
69be760c	192
f6762c71	193	return kTRUE;
	194	}
	195	//____________________________________________________________________
69be760c	196	Int_t AliMUONRawData::WriteTrackerDDL(Int_t iCh)
f6762c71	197	{
69be760c	198	// resets
f6762c71	199	TClonesArray* muonDigits = 0;
69be760c	200	fSubEventArray[0]->Clear();
	201	fSubEventArray[1]->Clear();
	202
	203	//
	204	TArrayI nbInBus[2];
	205
	206	nbInBus[0].Set(5000);
	207	nbInBus[1].Set(5000);
	208
	209	nbInBus[0].Reset();
	210	nbInBus[1].Reset();
	211
	212	// DDL header
	213	AliRawDataHeader header = fDDLTracker->GetHeader();
	214	Int_t headerSize = fDDLTracker->GetHeaderSize();
f6762c71	215
f6762c71	216	// DDL event one per half chamber
69be760c	217	AliMUONSubEventTracker* subEvent;
f6762c71	218
	219	// data format
	220	Char_t parity = 0x4;
69be760c	221	UShort_t manuId = 0;
	222	UChar_t channelId = 0;
	223	UShort_t charge = 0;
	224	Int_t busPatchId = 0;
f6762c71	225
f6762c71	226	UInt_t word;
69be760c	227	Int_t nEntries = 0;
	228	Int_t* buffer = 0;
	229	Int_t index;
	230	Int_t indexDsp;
	231	Int_t indexBlk;
f6762c71	232
f6762c71	233	Int_t nDigits;
69be760c	234	const AliMUONDigit* digit;
f6762c71	235
c8b4255f	236	if (fPrintLevel == 1)
69be760c	237	printf("WriteDDL chamber %d\n", iCh+1);
f6762c71	238
	239	for (Int_t iCath = 0; iCath < 2; iCath++) {
	240
f6762c71	241	fMUONData->ResetDigits();
	242	fMUONData->GetCathode(iCath);
	243	muonDigits = fMUONData->Digits(iCh);
	244
	245	nDigits = muonDigits->GetEntriesFast();
69be760c	246	if (fPrintLevel == 2)
f6762c71	247	printf("ndigits = %d\n",nDigits);
	248
	249	// open DDL file, on per 1/2 chamber
	250
	251	for (Int_t idig = 0; idig < nDigits; idig++) {
	252
	253	digit = (AliMUONDigit*) muonDigits->UncheckedAt(idig);
	254
69be760c	255	// mapping
	256	GetDummyMapping(iCh, iCath, digit, busPatchId, manuId, channelId, charge);
	257
	258	//packing word
	259	AliBitPacking::PackWord((UInt_t)parity,word,29,31);
	260	AliBitPacking::PackWord((UInt_t)manuId,word,18,28);
	261	AliBitPacking::PackWord((UInt_t)channelId,word,12,17);
	262	AliBitPacking::PackWord((UInt_t)charge,word,0,11);
	263
	264	// set sub Event
	265	subEvent = new AliMUONSubEventTracker();
	266	subEvent->AddData(word);
	267	subEvent->SetBusPatchId(busPatchId);
	268	if (digit->PadX() > 0) {
	269	nbInBus[0][busPatchId]++;
	270	AddData1(subEvent);
	271	} else {
	272	nbInBus[1][busPatchId]++;
	273	AddData2(subEvent);
	274	}
	275	delete subEvent;
	276	}
	277	}
	278	fSubEventArray[0]->Sort();
	279	fSubEventArray[1]->Sort();
	280
	281	// gather datas from same bus patch
	282	for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
	283	nEntries = fSubEventArray[iDDL]->GetEntriesFast();
	284
	285	for (Int_t i = 0; i < nEntries; i++) {
	286	AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
	287	busPatchId = temp->GetBusPatchId();
	288
	289	// add bus patch header, length and total length managed by subevent class
	290	temp->SetTriggerWord(0xdeadbeef);
	291	for (Int_t j = 0; j < nbInBus[iDDL][busPatchId]-1; j++) {
	292	AliMUONSubEventTracker* temp1 = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(++i);
	293	temp->AddData(temp1->GetData(0));
	294	fSubEventArray[iDDL]->RemoveAt(i) ;
	295	}
	296	}
	297	fSubEventArray[iDDL]->Compress();
	298
	299	if (fPrintLevel == 3) {
	300	nEntries = fSubEventArray[iDDL]->GetEntriesFast();
	301	for (Int_t i = 0; i < nEntries; i++) {
	302	AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(i);
	303	printf("busPatchid back %d\n",temp->GetBusPatchId());
	304	for (Int_t j = 0; j < temp->GetLength(); j++) {
	305	printf("manuId back %d, ",temp->GetManuId(j));
	306	printf("channelId back %d, ",temp->GetChannelId(j));
	307	printf("charge back %d\n",temp->GetCharge(j));
	308	}
	309	}
	310	printf("\n");
	311	}
	312
	313	}
	314
	315	Int_t iBusPatch;
	316	Int_t iEntries;
	317
	318	for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
319
320
321	// filling buffer
322	nEntries = fSubEventArray[iDDL]->GetEntriesFast();
323	buffer = new Int_t [(2048+24)*50]; // 24 words in average for one buspatch and 2048 manu info at most
324
325	indexBlk = 0;
326	indexDsp = 0;
327	index = 0;
328	iBusPatch = 0;
329	iEntries = 0;
330
331	for (Int_t iBlock = 0; iBlock < 2; iBlock++) {
332
333	// block header
334	fDDLTracker->SetTotalBlkLength(0xFFFFFFFF);
335	memcpy(&buffer[index],fDDLTracker->GetBlkHeader(),32);
336	indexBlk = index;
337	index += 8;
338
339	for (Int_t iDsp = 0; iDsp < 5; iDsp++) {
340
341	// DSP header
342	fDDLTracker->SetTotalDspLength(0xEEEEEEEE);
343	memcpy(&buffer[index],fDDLTracker->GetDspHeader(),32);
344	indexDsp = index;
345	index += 8;
346
347	for (Int_t i = 0; i < 5; i++) {
348
349	iBusPatch = i + iBlock25 + iDsp5 + 50(2iCh + iDDL);
350
351	AliMUONSubEventTracker* temp = (AliMUONSubEventTracker*)fSubEventArray[iDDL]->At(iEntries);
352	if (nEntries > 0)
353	busPatchId = temp->GetBusPatchId();
354	else
355	busPatchId = -1;
356
357	if (busPatchId == iBusPatch) {
358	// add bus patch structure
359	memcpy(&buffer[index],temp->GetAddress(),16);
360	index+= 4;
361	for (Int_t j = 0; j < temp->GetLength(); j++)
362	buffer[index++] = temp->GetData(j);
363	if (iEntries < nEntries-1)
364	iEntries++;
365	} else {
366	buffer[index++] = 4; // total length
367	buffer[index++] = 0; // raw data length
368	buffer[index++] = iBusPatch; // bus patch
369	buffer[index++] = 0xdeadbeef; // trigger word
370	}
371	} // bus patch
372	buffer[indexDsp] = index - indexDsp;
373	buffer[indexDsp+1] = index - indexDsp -8;
374	if ((index - indexDsp) % 2 == 0)
375	buffer[indexDsp+7] = 0;
376	else
377	buffer[indexDsp+7] = 1;
378	} // dsp
379	buffer[indexBlk] = index - indexBlk;
380	buffer[indexBlk+1] = index - indexBlk -8;
381	}
382	if (iDDL == 0) {
383	// write DDL 1
384	header.fSize = index + headerSize;// total length in word
385	fwrite((char)(&header),headerSize4,1,fFile1);
386	fwrite(buffer,sizeof(int),index,fFile1);
387	}
388	if (iDDL == 1) {
389	// write DDL 2
390	header.fSize = index + headerSize;// total length in word
391	fwrite((char)(&header),headerSize4,1,fFile2);
392	fwrite(buffer,sizeof(int),index,fFile2);
393	}
394	delete[] buffer;
395	}
396
397	return kTRUE;
398	}
399	//____________________________________________________________________
400	Int_t AliMUONRawData::WriteTriggerDDL()
401	{
402
c8b4255f	403	// DDL event one per half chamber
c8b4255f	404	AliMUONSubEventTrigger* subEvent = 0x0;
69be760c	405
69be760c	406
c8b4255f	407	// stored local id number
	408	TArrayI isFired(256);
	409	isFired.Reset();
69be760c	410
69be760c	411
c8b4255f	412	// DDL header
	413	AliRawDataHeader header = fDDLTrigger->GetHeader();
	414	Int_t headerSize = fDDLTrigger->GetHeaderSize();
	415
	416	TClonesArray* localTrigger;
	417	TClonesArray* globalTrigger;
	418	AliMUONGlobalTrigger* gloTrg;
	419	AliMUONLocalTrigger* locTrg = 0x0;
	420
	421	fMUONData->GetTriggerD();
	422
	423	// global trigger for trigger pattern
	424	globalTrigger = fMUONData->GlobalTrigger();
	425	gloTrg = (AliMUONGlobalTrigger*)globalTrigger->UncheckedAt(0);
	426	Int_t gloTrigPat = GetGlobalTriggerPattern(gloTrg);
	427
	428	// local trigger
	429	localTrigger = fMUONData->LocalTrigger();
	430
	431	UInt_t word;
	432	Int_t* buffer = 0;
	433	Int_t index;
	434	Int_t iEntries = 0;
	435	Int_t iLocCard, locCard;
	436	Char_t locDec, trigY, posY, devX, posX;
	437	Int_t version = 1; // software version
	438	Int_t eventType =1; // trigger type: 1 for physics ?
	439	Int_t serialNb = 0xF; // serial nb of card: all bits on for the moment
	440
	441	Int_t nEntries = (Int_t) (localTrigger->GetEntries());// 234 local cards
	442	// stored the local card id that's fired
	443	for (Int_t i = 0; i < nEntries; i++) {
	444	locTrg = (AliMUONLocalTrigger*)localTrigger->At(i);
	445	isFired[locTrg->LoCircuit()] = 1;
	446	}
	447
	448	if (!nEntries)
	449	Error("AliMUONRawData::WriteTriggerDDL","No Trigger information available");
	450
	451	buffer = new Int_t [680]; // [16(local)5 words + 4 words]8(reg) + 7 words = 679
	452
	453	for (Int_t iDDL = 0; iDDL < 2; iDDL++) {
	454
	455	index = 0;
	456
	457	// DDL enhanced header
	458	word =0;
	459	AliBitPacking::PackWord((UInt_t)iDDL+1,word,30,31); //see AliMUONDDLTrigger.h for details
	460	AliBitPacking::PackWord((UInt_t)version,word,22,29);
	461	AliBitPacking::PackWord((UInt_t)serialNb,word,18,21);
	462	AliBitPacking::PackWord((UInt_t)eventType,word,14,17);
	463
	464	fDDLTrigger->SetDDLWord(word);
	465	fDDLTrigger->SetGlobalOutput(gloTrigPat);
	466	memcpy(&buffer[index],fDDLTrigger->GetEnhancedHeader(),24);
	467	index += 6;
	468
	469	for (Int_t iReg = 0; iReg < 8; iReg++) {
	470
	471	subEvent = new AliMUONSubEventTrigger();
	472
	473	// Regional card header
	474	word = 0;
	475	AliBitPacking::PackWord((UInt_t)serialNb,word,27,31); //see AliMUONSubEventTrigger.h for details
476	AliBitPacking::PackWord((UInt_t)iReg,word,22,26);
477	AliBitPacking::PackWord((UInt_t)version,word,14,21);
478	subEvent->SetRegWord(word);
479	memcpy(&buffer[index++],subEvent->GetAddress(),4);
480
481	for (Int_t iLoc = 0; iLoc < 16; iLoc++) {
482
483	iLocCard = iLoc + iReg16 + iDDL128;
484
485	if (isFired[iLocCard]) {
486	locTrg = (AliMUONLocalTrigger*)localTrigger->At(iEntries);
487	locCard = locTrg->LoCircuit();
488	locDec = locTrg->GetLoDecision();
489	trigY = 0;
490	posY = locTrg->LoStripY();
491	posX = locTrg->LoStripX();
492	devX = locTrg->LoDev();
493	if (fPrintLevel == 4)
494	printf("loctrg %d, posX %d, posY %d, devX %d\n",
495	locTrg-> LoCircuit(),locTrg->LoStripX(),locTrg->LoStripY(),locTrg->LoDev());
496	} else { //no trigger (see PRR chpt 3.4)
497	locCard = -1;
498	locDec = 0;
499	trigY = 1;
500	posY = 15;
501	posX = 0;
502	devX = 0x8000;
503	}
504
505	//packing word
506	word = 0;
507	AliBitPacking::PackWord((UInt_t)(iLocCard % 16),word,19,22); //card id number in crate
508	AliBitPacking::PackWord((UInt_t)locDec,word,15,18);
509	AliBitPacking::PackWord((UInt_t)trigY,word,14,14);
510	AliBitPacking::PackWord((UInt_t)posY,word,10,13);
511	AliBitPacking::PackWord((UInt_t)devX,word,5,9);
512	AliBitPacking::PackWord((UInt_t)posX,word,0,4);
513
514	if (locCard == iLocCard) {
515	// add local cards structure
516	buffer[index++] = (locTrg->GetX1Pattern() \| (locTrg->GetX2Pattern() << 16));
517	buffer[index++] = (locTrg->GetX3Pattern() \| (locTrg->GetX4Pattern() << 16));
518	buffer[index++] = (locTrg->GetY1Pattern() \| (locTrg->GetY2Pattern() << 16));
519	buffer[index++] = (locTrg->GetY3Pattern() \| (locTrg->GetY4Pattern() << 16));
520	buffer[index++] = (Int_t)word; // data word
521	if (iEntries < nEntries-1)
522	iEntries++;
523	} else {
524	buffer[index++] = 0; // 4 words for x1, x2, y1, y2
525	buffer[index++] = 0;
526	buffer[index++] = 0;
527	buffer[index++] = 0;
528	buffer[index++] = (Int_t)word; // data word
529
530	}
531	} // local card
532	buffer[index++] = 0;// 2 words of regional input
533	buffer[index++] = 0;
534	buffer[index++] = 0;// regional output
535
536	delete subEvent;
537
538	} // Regional card
539
540	buffer[index++] = fDDLTrigger->GetEoD(); // End of DDL word
541
542
543	if (iDDL == 0) {
544	// write DDL 1
545	header.fSize = index + headerSize;// total length in word
546	fwrite((char)(&header),headerSize4,1,fFile1);
547	fwrite(buffer,sizeof(int),index,fFile1);
548	}
549	if (iDDL == 1) {
550	// write DDL 2
551	header.fSize = index + headerSize;// total length in word
552	fwrite((char)(&header),headerSize4,1,fFile2);
553	fwrite(buffer,sizeof(int),index,fFile2);
554	}
555	}
556	delete[] buffer;
69be760c	557
	558	return kTRUE;
	559	}
	560	//____________________________________________________________________
	561	void AliMUONRawData::GetDummyMapping(Int_t iCh, Int_t iCath, const AliMUONDigit* digit,
	562	Int_t &busPatchId, UShort_t &manuId, UChar_t &channelId, UShort_t &charge)
	563	{
	564
	565	Int_t offsetX = 0; // offet row
	566	Int_t offsetY = 0; // offset columns
	567	Int_t offsetCath = 0; //offset from one cathod to the other
	568	Int_t maxChannel = 0; // maximum nb of channel in 1/2 chamber
	569	Int_t id;
f6762c71	570	switch (iCh+1) {
	571	case 1:
	572	case 2:
	573	case 3:
	574	case 4:
	575	offsetX = 512;
	576	offsetY = 256;
	577	offsetCath = 65536;
	578	maxChannel = (offsetY * offsetX + 2* offsetY + offsetCath);
	579	break;
	580	case 5:
	581	case 6:
	582	case 7:
	583	case 8:
	584	case 9:
	585	case 10:
	586	offsetX = 1024;
	587	offsetY = 0;
	588	offsetCath = 65536;
	589	maxChannel = (256 * offsetX + offsetX + offsetCath);
	590	break;
	591	}
	592	// dummy mapping
	593	// manu Id directly from a matrix 8*8, same segmentation for B and NB
	594	// 50 buspatches for 1/2 chamber
f6762c71	595
69be760c	596	id = (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
	597	offsetCath * iCath);
	598	Int_t chPerBus = maxChannel/50;
	599	busPatchId = id/chPerBus; // start at zero
	600	if (digit->PadX() > 0)
	601	busPatchId += 50iCh2;
	602	else
	603	busPatchId += 50(2iCh+1);
f6762c71	604	// 64 manu cards for one buspatch
69be760c	605	manuId = (id % chPerBus)/64; //start at zero
f6762c71	606	manuId &= 0x7FF; // 11 bits
	607
	608	// channel id
69be760c	609	channelId = (id % chPerBus) % 64; //start at zero
f6762c71	610	channelId &= 0x3F; // 6 bits
f6762c71	611
69be760c	612	// id = (TMath::Abs(digit->PadX()) * offsetX + digit->PadY() + offsetY +
	613	// offsetCath * iCath);
	614	// busPatchId = id/50;
	615
	616	// Int_t inBusId = id - (maxChannel/50 * busPatchId);// id channel in buspatch
	617	// Int_t manuPerBus = (maxChannel/(50*64)); // number of manus per buspatch
	618
	619	// // 64 manu cards for one buspatch
	620	// manuId = inBusId/manuPerBus;
	621	// manuId &= 0x7FF; // 11 bits
	622
	623	// // channel id
	624	// channelId = (inBusId % manuPerBus);
	625	// channelId &= 0x3F; // 6 bits
	626
	627	if (fPrintLevel == 2)
	628	printf("id: %d, busPatchId %d, manuId: %d, channelId: %d, maxchannel: %d, chPerBus %d\n",
	629	id, busPatchId, manuId, channelId, maxChannel, chPerBus);
f6762c71	630	// charge
	631	charge = digit->Signal();
	632	charge &= 0xFFF;
	633
69be760c	634	if (fPrintLevel == 2)
f6762c71	635	printf("id: %d, busPatchId %d, manuId: %d, channelId: %d, padx: %d pady %d, charge %d\n",
f6762c71	636	id, busPatchId, manuId, channelId, digit->PadX(), digit->PadY(), digit->Signal());
f6762c71	637
f6762c71	638	}
c8b4255f	639
	640	//____________________________________________________________________
	641	Int_t AliMUONRawData::GetGlobalTriggerPattern(AliMUONGlobalTrigger* gloTrg)
	642	{
	643	Int_t gloTrigPat = 0;
	644
	645	if (gloTrg->SinglePlusLpt()) gloTrigPat\|= 0x1;
	646	if (gloTrg->SinglePlusHpt()) gloTrigPat\|= 0x2;
	647	if (gloTrg->SinglePlusApt()) gloTrigPat\|= 0x4;
	648
	649	if (gloTrg->SingleMinusLpt()) gloTrigPat\|= 0x8;
	650	if (gloTrg->SingleMinusHpt()) gloTrigPat\|= 0x10;
	651	if (gloTrg->SingleMinusApt()) gloTrigPat\|= 0x20;
	652
	653	if (gloTrg->SingleUndefLpt()) gloTrigPat\|= 0x40;
	654	if (gloTrg->SingleUndefHpt()) gloTrigPat\|= 0x80;
	655	if (gloTrg->SingleUndefApt()) gloTrigPat\|= 0x100;
	656
	657	if (gloTrg->PairUnlikeLpt()) gloTrigPat\|= 0x200;
	658	if (gloTrg->PairUnlikeHpt()) gloTrigPat\|= 0x400;
	659	if (gloTrg->PairUnlikeApt()) gloTrigPat\|= 0x800;
	660
	661	if (gloTrg->PairLikeLpt()) gloTrigPat\|= 0x1000;
	662	if (gloTrg->PairLikeHpt()) gloTrigPat\|= 0x2000;
	663	if (gloTrg->PairLikeApt()) gloTrigPat\|= 0x4000;
	664
	665	return gloTrigPat;
	666	}