[u/mrichter/AliRoot.git] / PMD / AliPMDRawStream.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
///
/// This class provides access to PMD digits in raw data.
///
/// It loops over all PMD digits in the raw data given by the AliRawReader.
/// The Next method goes to the next digit. If there are no digits left
/// it returns kFALSE.
/// Several getters provide information about the current digit.
///
///////////////////////////////////////////////////////////////////////////////

#include <Riostream.h>
#include <TObjArray.h>
#include <TString.h>
#include <TSystem.h>

#include "AliLog.h"
#include "AliPMDBlockHeader.h"
#include "AliPMDDspHeader.h"
#include "AliPMDPatchBusHeader.h"
#include "AliPMDddldata.h"
#include "AliPMDRawStream.h"
#include "AliRawReader.h"

ClassImp(AliPMDRawStream)


//_____________________________________________________________________________
AliPMDRawStream::AliPMDRawStream(AliRawReader* rawReader) :
  fRawReader(rawReader)
{
// create an object to read PMD raw digits

  fRawReader->Select("PMD");
}

//_____________________________________________________________________________
AliPMDRawStream::AliPMDRawStream(const AliPMDRawStream& stream) :
  TObject(stream),
  fRawReader(NULL)
{
// copy constructor

  AliFatal("Copy constructor not implemented");
}

//_____________________________________________________________________________
AliPMDRawStream& AliPMDRawStream::operator = (const AliPMDRawStream& 
					      /* stream */)
{
// assignment operator

  AliFatal("operator = assignment operator not implemented");
  return *this;
}

//_____________________________________________________________________________
AliPMDRawStream::~AliPMDRawStream()
{
// destructor

}


//_____________________________________________________________________________

Bool_t AliPMDRawStream::DdlData(Int_t indexDDL, TObjArray *pmdddlcont)
{
// read the next raw digit
// returns kFALSE if there is no digit left

  AliPMDddldata *pmdddldata;

  if (!fRawReader->ReadHeader()) return kFALSE;
  Int_t  iddl  = fRawReader->GetDDLID();
  Int_t dataSize = fRawReader->GetDataSize();
  Int_t totaldataword = dataSize/4;

  if (dataSize <= 0) return kFALSE;
  if (indexDDL != iddl)
    {
      AliError("Mismatch in the DDL index");
      return kFALSE;
    }

  UInt_t *buffer;
  buffer = new UInt_t[totaldataword];
  UInt_t data;
  for (Int_t i = 0; i < totaldataword; i++)
    {
      fRawReader->ReadNextInt(data);
      buffer[i] = data;
    }

  // --- Open the mapping file

  TString fileName(gSystem->Getenv("ALICE_ROOT"));
  if(iddl == 0)
    {
      fileName += "/PMD/PMD_Mapping_ddl0.dat";
    }
  else if(iddl == 1)
    {
      fileName += "/PMD/PMD_Mapping_ddl1.dat";
    }
  else if(iddl == 2)
    {
      fileName += "/PMD/PMD_Mapping_ddl2.dat";
    }
  else if(iddl == 3)
    {
      fileName += "/PMD/PMD_Mapping_ddl3.dat";
    }
  else if(iddl == 4)
    {
      fileName += "/PMD/PMD_Mapping_ddl4.dat";
    }
  else if(iddl == 5)
    {
      fileName += "/PMD/PMD_Mapping_ddl5.dat";
    }

  ifstream infile;
  infile.open(fileName.Data(), ios::in); // ascii file
  if(!infile)
    AliError(Form("Could not read the mapping file for DDL No = %d",iddl));
  
  Int_t modulePerDDL = 0;
  if (iddl < 4)
    {
      modulePerDDL = 6;
    }
  else if (iddl == 4 || iddl == 5)
    {
      modulePerDDL = 12;
    }

  const Int_t kNPatchBus = 50;
  
  Int_t modno, totPatchBus, bPatchBus, ePatchBus;
  Int_t ibus, totmcm, rows, rowe, cols, cole;
  Int_t moduleNo[kNPatchBus], mcmperBus[kNPatchBus];
  Int_t startRowBus[kNPatchBus], endRowBus[kNPatchBus];
  Int_t startColBus[kNPatchBus], endColBus[kNPatchBus];

  for (Int_t ibus = 0; ibus < kNPatchBus; ibus++)
    {
      mcmperBus[ibus]   = -1;
      startRowBus[ibus] = -1;
      endRowBus[ibus]   = -1;
      startColBus[ibus] = -1;
      endColBus[ibus]   = -1;
    }

  for (Int_t im = 0; im < modulePerDDL; im++)
    {
      infile >> modno;
      infile >> totPatchBus >> bPatchBus >> ePatchBus;
      
      for(Int_t i=0; i<totPatchBus; i++)
	{
	  infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;

	  moduleNo[ibus]     = modno;
	  mcmperBus[ibus]    = totmcm;
	  startRowBus[ibus]  = rows;
	  endRowBus[ibus]    = rowe;
	  startColBus[ibus]  = cols;
	  endColBus[ibus]    = cole;
	}
    }

  infile.close();

  AliPMDBlockHeader    blockHeader;
  AliPMDDspHeader      dspHeader;
  AliPMDPatchBusHeader pbusHeader;

  const Int_t kblHLen   = blockHeader.GetHeaderLength();
  const Int_t kdspHLen  = dspHeader.GetHeaderLength();
  const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
  
  Int_t parity;
  Int_t idet, ismn;
  Int_t irow = -1;
  Int_t icol = -1;

  Int_t blHeaderWord[8];
  Int_t dspHeaderWord[10];
  Int_t pbusHeaderWord[4];

  Int_t ilowLimit       = 0;
  Int_t iuppLimit       = 0;
  Int_t blRawDataLength = 0;
  Int_t iwordcount      = 0;


  for (Int_t iblock = 0; iblock < 2; iblock++)
    {
      ilowLimit = iuppLimit;
      iuppLimit = ilowLimit + kblHLen;

      for (Int_t i = ilowLimit; i < iuppLimit; i++)
	{
	  blHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
	}

      blockHeader.SetHeader(blHeaderWord);

      blRawDataLength = blockHeader.GetRawDataLength();

      for (Int_t idsp = 0; idsp < 5; idsp++)
	{
	  ilowLimit = iuppLimit;
	  iuppLimit = ilowLimit + kdspHLen;

	  for (Int_t i = ilowLimit; i < iuppLimit; i++)
	    {
	      iwordcount++;
	      dspHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
	    }
	  dspHeader.SetHeader(dspHeaderWord);

	  for (Int_t ibus = 0; ibus < 5; ibus++)
	    {
	      ilowLimit = iuppLimit;
	      iuppLimit = ilowLimit + kpbusHLen;

	      for (Int_t i = ilowLimit; i < iuppLimit; i++)
		{
		  iwordcount++;
		  pbusHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
		}
	      pbusHeader.SetHeader(pbusHeaderWord);
	      Int_t rawdatalength = pbusHeader.GetRawDataLength();
	      Int_t pbusid = pbusHeader.GetPatchBusId();

	      ilowLimit = iuppLimit;
	      iuppLimit = ilowLimit + rawdatalength;

	      Int_t imodule = moduleNo[pbusid];


	      for (Int_t iword = ilowLimit; iword < iuppLimit; iword++)
		{
		  iwordcount++;
		  data = buffer[iword];

		  Int_t isig =  data & 0x0FFF;
		  Int_t ich  = (data >> 12) & 0x003F;
		  Int_t imcm = (data >> 18) & 0x07FF;
		  Int_t ibit = (data >> 31) & 0x0001;
		  parity = ComputeParity(data);
		  if (ibit != parity)
		    {
		      AliWarning("ComputeParity:: Parity Error");
		    }
		  GetRowCol(iddl, pbusid, imcm, ich, 
			    startRowBus, endRowBus,
			    startColBus, endColBus,
			    irow, icol);

		  ConvertDDL2SMN(iddl, imodule, ismn, idet);
		  TransformH2S(ismn, irow, icol);

		  pmdddldata = new AliPMDddldata();

		  pmdddldata->SetDetector(idet);
		  pmdddldata->SetSMN(ismn);
		  pmdddldata->SetModule(imodule);
		  pmdddldata->SetPatchBusId(pbusid);
		  pmdddldata->SetMCM(imcm);
		  pmdddldata->SetChannel(ich);
		  pmdddldata->SetRow(irow);
		  pmdddldata->SetColumn(icol);
		  pmdddldata->SetSignal(isig);
		  pmdddldata->SetParityBit(ibit);
		  
		  pmdddlcont->Add(pmdddldata);
		  
		} // data word loop

	      if (iwordcount == blRawDataLength) break;

	    } // patch bus loop

	  if (dspHeader.GetPaddingWord() == 1) iuppLimit++;
	  if (iwordcount == blRawDataLength) break;

	} // end of DSP
      if (iwordcount == blRawDataLength) break;

    } // end of BLOCK
  
  delete [] buffer;

  return kTRUE;
}
//_____________________________________________________________________________
void AliPMDRawStream::GetRowCol(Int_t ddlno, Int_t pbusid,
				UInt_t mcmno, UInt_t chno,
				Int_t startRowBus[], Int_t endRowBus[],
				Int_t startColBus[], Int_t endColBus[],
				Int_t &row, Int_t &col) const
{
// decode: ddlno, patchbusid, mcmno, chno -> um, row, col


  static const UInt_t kCh[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
				  49, 59, 56, 55, 52, 50, 48, 51,
				  44, 47, 45, 43, 40, 39, 36, 46,
				  32, 35, 33, 34, 41, 38, 37, 42,
				  21, 26, 25, 22, 29, 30, 28, 31,
				  17, 27, 24, 23, 20, 18, 16, 19,
				  12, 15, 13, 11,  8,  7,  4, 14,
				  0,   3,  1,  2,  9,  6,  5, 10 };


  Int_t rowcol  = kCh[chno];
  Int_t irownew = rowcol/4;
  Int_t icolnew = rowcol%4;

  if (ddlno == 0 )
    {
      row = startRowBus[pbusid] + irownew;
      col = startColBus[pbusid] + mcmno*4 + icolnew;
    }
  else if (ddlno == 1)
    {
    row = endRowBus[pbusid] - (15 - irownew);
    col = startColBus[pbusid] + mcmno*4 + icolnew;
    
    }
  else if (ddlno == 2 )
    {
      row = startRowBus[pbusid] + irownew;
      col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
    }
  else if (ddlno == 3)
    {
    row = endRowBus[pbusid] - (15 - irownew);
    col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
    }
  else if (ddlno == 4 )
    {
      if (pbusid  < 18)
	{
	  if (mcmno <= 11)
	    {
	      // Add 16 to skip the 1st 15 rows
	      row = startRowBus[pbusid] + irownew + 16;
	      col = startColBus[pbusid] + (mcmno)*4 + icolnew;
	    }
	  else if(mcmno > 11)
	    {
	      row = startRowBus[pbusid] + irownew;
	      col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	    }
	}
      else if(pbusid > 17)
	{
	  if (mcmno <= 11)
	    {
	      col = endColBus[pbusid] - mcmno*4 - (3 - icolnew); 

	      if(endRowBus[pbusid] - startRowBus[pbusid] > 16)
		row = endRowBus[pbusid] - (15 - irownew) - 16 ;
	      else
		row = endRowBus[pbusid] - (15 - irownew) ;
	      

	    }
	  else if(mcmno > 11)
	    {
	      row = endRowBus[pbusid] - (15 - irownew)  ;
	      col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
	    }
	}
    }
  else if (ddlno == 5)
    {
      if (pbusid  <= 17)
	{
	  if (mcmno > 11)
	    {
	      // Subtract 16 to skip the 1st 15 rows
	      row = endRowBus[pbusid] - 16 -(15 - irownew);
	      col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	    }
	  else
	    {
	      row = endRowBus[pbusid]  - (15 - irownew) ;
	      col = startColBus[pbusid] + mcmno*4 + icolnew;
	    }
	}
      
      else if (pbusid > 17)
	{
	  if(mcmno > 11)
	    {
	      // Add 16 to skip the 1st 15 rows
	      row = startRowBus[pbusid] + irownew + 16;
	      col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
	    }
	  else 
	    {
	      row = startRowBus[pbusid] + irownew ;
	      col = endColBus[pbusid] - mcmno*4 - (3 - icolnew); 
	    }
	}
    }
  
}
//_____________________________________________________________________________
void AliPMDRawStream::ConvertDDL2SMN(Int_t iddl, Int_t imodule,
				     Int_t &smn, Int_t &detector) const
{
  // This converts the DDL number (0 to 5), Module Number (0-47)
  // to Serial module number in one detector (SMN : 0-23) and
  // detector number (0:PRE plane, 1:CPV plane)
  if (iddl < 4)
    {
      smn = imodule;
      detector = 0;
    }
  else
    {
      smn = imodule - 24;
      detector = 1;
    }
}
//_____________________________________________________________________________
void AliPMDRawStream::TransformH2S(Int_t smn, Int_t &row, Int_t &col) const
{
  // This does the transformation of the hardware coordinate to
  // software 
  // i.e., For SuperModule 0 &1, instead of 96x48(hardware),
  // it is 48x96 (software)
  // For Supermodule 3 & 4, 48x96

  Int_t irownew  = 0;
  Int_t icolnew  = 0;

  if(smn < 12)
    {
      irownew = col;
      icolnew = row;
    }
  else if(smn >= 12 && smn < 24)
    {
      irownew = row;
      icolnew = col;
    }

  row = irownew;
  col = icolnew;
}
//_____________________________________________________________________________
Int_t AliPMDRawStream::ComputeParity(Int_t data)
{
// Calculate the parity bit

  Int_t count = 0;
  for(Int_t j = 0; j<29; j++)
    {
      if (data & 0x01 ) count++;
      data >>= 1;
    }
  
  Int_t parity = count%2;

  return parity;
}

//_____________________________________________________________________________
Commit	Line	Data
a09a2da4	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	///
	20	/// This class provides access to PMD digits in raw data.
	21	///
	22	/// It loops over all PMD digits in the raw data given by the AliRawReader.
	23	/// The Next method goes to the next digit. If there are no digits left
	24	/// it returns kFALSE.
	25	/// Several getters provide information about the current digit.
	26	///
	27	///////////////////////////////////////////////////////////////////////////////
	28
34ab69dd	29	#include <Riostream.h>
	30	#include <TObjArray.h>
	31	#include <TString.h>
	32	#include <TSystem.h>
	33
ecee2a1a	34	#include "AliLog.h"
34ab69dd	35	#include "AliPMDBlockHeader.h"
	36	#include "AliPMDDspHeader.h"
	37	#include "AliPMDPatchBusHeader.h"
	38	#include "AliPMDddldata.h"
a09a2da4	39	#include "AliPMDRawStream.h"
	40	#include "AliRawReader.h"
	41
	42	ClassImp(AliPMDRawStream)
	43
	44
	45	//_____________________________________________________________________________
	46	AliPMDRawStream::AliPMDRawStream(AliRawReader* rawReader) :
34ab69dd	47	fRawReader(rawReader)
a09a2da4	48	{
	49	// create an object to read PMD raw digits
	50
362c9d61	51	fRawReader->Select("PMD");
a09a2da4	52	}
	53
	54	//_____________________________________________________________________________
	55	AliPMDRawStream::AliPMDRawStream(const AliPMDRawStream& stream) :
	56	TObject(stream),
34ab69dd	57	fRawReader(NULL)
a09a2da4	58	{
	59	// copy constructor
	60
ecee2a1a	61	AliFatal("Copy constructor not implemented");
a09a2da4	62	}
	63
	64	//_____________________________________________________________________________
	65	AliPMDRawStream& AliPMDRawStream::operator = (const AliPMDRawStream&
	66	/* stream */)
	67	{
	68	// assignment operator
	69
ecee2a1a	70	AliFatal("operator = assignment operator not implemented");
a09a2da4	71	return *this;
	72	}
	73
	74	//_____________________________________________________________________________
	75	AliPMDRawStream::~AliPMDRawStream()
	76	{
	77	// destructor
	78
	79	}
	80
	81
	82	//_____________________________________________________________________________
34ab69dd	83
9ac124a2	84	Bool_t AliPMDRawStream::DdlData(Int_t indexDDL, TObjArray *pmdddlcont)
a09a2da4	85	{
	86	// read the next raw digit
	87	// returns kFALSE if there is no digit left
	88
34ab69dd	89	AliPMDddldata *pmdddldata;
34ab69dd	90
35341ad3	91	if (!fRawReader->ReadHeader()) return kFALSE;
34ab69dd	92	Int_t iddl = fRawReader->GetDDLID();
	93	Int_t dataSize = fRawReader->GetDataSize();
	94	Int_t totaldataword = dataSize/4;
9ac124a2	95
	96	if (dataSize <= 0) return kFALSE;
	97	if (indexDDL != iddl)
	98	{
	99	AliError("Mismatch in the DDL index");
	100	return kFALSE;
	101	}
a09a2da4	102
34ab69dd	103	UInt_t *buffer;
34ab69dd	104	buffer = new UInt_t[totaldataword];
a09a2da4	105	UInt_t data;
34ab69dd	106	for (Int_t i = 0; i < totaldataword; i++)
	107	{
	108	fRawReader->ReadNextInt(data);
	109	buffer[i] = data;
	110	}
a09a2da4	111
34ab69dd	112	// --- Open the mapping file
a09a2da4	113
34ab69dd	114	TString fileName(gSystem->Getenv("ALICE_ROOT"));
	115	if(iddl == 0)
	116	{
	117	fileName += "/PMD/PMD_Mapping_ddl0.dat";
	118	}
	119	else if(iddl == 1)
	120	{
	121	fileName += "/PMD/PMD_Mapping_ddl1.dat";
	122	}
	123	else if(iddl == 2)
	124	{
	125	fileName += "/PMD/PMD_Mapping_ddl2.dat";
	126	}
	127	else if(iddl == 3)
	128	{
	129	fileName += "/PMD/PMD_Mapping_ddl3.dat";
	130	}
	131	else if(iddl == 4)
	132	{
	133	fileName += "/PMD/PMD_Mapping_ddl4.dat";
	134	}
	135	else if(iddl == 5)
	136	{
	137	fileName += "/PMD/PMD_Mapping_ddl5.dat";
	138	}
	139
	140	ifstream infile;
	141	infile.open(fileName.Data(), ios::in); // ascii file
	142	if(!infile)
	143	AliError(Form("Could not read the mapping file for DDL No = %d",iddl));
	144
	145	Int_t modulePerDDL = 0;
	146	if (iddl < 4)
	147	{
	148	modulePerDDL = 6;
	149	}
	150	else if (iddl == 4 \|\| iddl == 5)
	151	{
	152	modulePerDDL = 12;
	153	}
	154
	155	const Int_t kNPatchBus = 50;
	156
	157	Int_t modno, totPatchBus, bPatchBus, ePatchBus;
	158	Int_t ibus, totmcm, rows, rowe, cols, cole;
	159	Int_t moduleNo[kNPatchBus], mcmperBus[kNPatchBus];
	160	Int_t startRowBus[kNPatchBus], endRowBus[kNPatchBus];
	161	Int_t startColBus[kNPatchBus], endColBus[kNPatchBus];
	162
34ab69dd	163	for (Int_t ibus = 0; ibus < kNPatchBus; ibus++)
	164	{
	165	mcmperBus[ibus] = -1;
	166	startRowBus[ibus] = -1;
	167	endRowBus[ibus] = -1;
	168	startColBus[ibus] = -1;
	169	endColBus[ibus] = -1;
	170	}
	171
34ab69dd	172	for (Int_t im = 0; im < modulePerDDL; im++)
	173	{
	174	infile >> modno;
	175	infile >> totPatchBus >> bPatchBus >> ePatchBus;
9ac124a2	176
34ab69dd	177	for(Int_t i=0; i<totPatchBus; i++)
	178	{
	179	infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
	180
	181	moduleNo[ibus] = modno;
	182	mcmperBus[ibus] = totmcm;
	183	startRowBus[ibus] = rows;
	184	endRowBus[ibus] = rowe;
	185	startColBus[ibus] = cols;
	186	endColBus[ibus] = cole;
	187	}
	188	}
	189
	190	infile.close();
	191
34ab69dd	192	AliPMDBlockHeader blockHeader;
	193	AliPMDDspHeader dspHeader;
	194	AliPMDPatchBusHeader pbusHeader;
	195
0a666212	196	const Int_t kblHLen = blockHeader.GetHeaderLength();
	197	const Int_t kdspHLen = dspHeader.GetHeaderLength();
	198	const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
	199
a98f9d26	200	Int_t parity;
34ab69dd	201	Int_t idet, ismn;
	202	Int_t irow = -1;
	203	Int_t icol = -1;
	204
0a666212	205	Int_t blHeaderWord[8];
	206	Int_t dspHeaderWord[10];
	207	Int_t pbusHeaderWord[4];
34ab69dd	208
93622f4a	209	Int_t ilowLimit = 0;
93622f4a	210	Int_t iuppLimit = 0;
9ac124a2	211	Int_t blRawDataLength = 0;
93622f4a	212	Int_t iwordcount = 0;
9ac124a2	213
9ac124a2	214
34ab69dd	215	for (Int_t iblock = 0; iblock < 2; iblock++)
	216	{
	217	ilowLimit = iuppLimit;
0a666212	218	iuppLimit = ilowLimit + kblHLen;
34ab69dd	219
	220	for (Int_t i = ilowLimit; i < iuppLimit; i++)
	221	{
0a666212	222	blHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
34ab69dd	223	}
9ac124a2	224
0a666212	225	blockHeader.SetHeader(blHeaderWord);
9ac124a2	226
	227	blRawDataLength = blockHeader.GetRawDataLength();
	228
34ab69dd	229	for (Int_t idsp = 0; idsp < 5; idsp++)
	230	{
	231	ilowLimit = iuppLimit;
0a666212	232	iuppLimit = ilowLimit + kdspHLen;
34ab69dd	233
	234	for (Int_t i = ilowLimit; i < iuppLimit; i++)
	235	{
9ac124a2	236	iwordcount++;
0a666212	237	dspHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
34ab69dd	238	}
0a666212	239	dspHeader.SetHeader(dspHeaderWord);
34ab69dd	240
	241	for (Int_t ibus = 0; ibus < 5; ibus++)
	242	{
34ab69dd	243	ilowLimit = iuppLimit;
0a666212	244	iuppLimit = ilowLimit + kpbusHLen;
34ab69dd	245
	246	for (Int_t i = ilowLimit; i < iuppLimit; i++)
	247	{
9ac124a2	248	iwordcount++;
0a666212	249	pbusHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
34ab69dd	250	}
0a666212	251	pbusHeader.SetHeader(pbusHeaderWord);
34ab69dd	252	Int_t rawdatalength = pbusHeader.GetRawDataLength();
	253	Int_t pbusid = pbusHeader.GetPatchBusId();
	254
	255	ilowLimit = iuppLimit;
	256	iuppLimit = ilowLimit + rawdatalength;
	257
	258	Int_t imodule = moduleNo[pbusid];
	259
	260
	261	for (Int_t iword = ilowLimit; iword < iuppLimit; iword++)
	262	{
9ac124a2	263	iwordcount++;
34ab69dd	264	data = buffer[iword];
	265
	266	Int_t isig = data & 0x0FFF;
	267	Int_t ich = (data >> 12) & 0x003F;
	268	Int_t imcm = (data >> 18) & 0x07FF;
	269	Int_t ibit = (data >> 31) & 0x0001;
a98f9d26	270	parity = ComputeParity(data);
	271	if (ibit != parity)
	272	{
	273	AliWarning("ComputeParity:: Parity Error");
	274	}
34ab69dd	275	GetRowCol(iddl, pbusid, imcm, ich,
	276	startRowBus, endRowBus,
	277	startColBus, endColBus,
	278	irow, icol);
	279
	280	ConvertDDL2SMN(iddl, imodule, ismn, idet);
	281	TransformH2S(ismn, irow, icol);
	282
	283	pmdddldata = new AliPMDddldata();
	284
	285	pmdddldata->SetDetector(idet);
	286	pmdddldata->SetSMN(ismn);
	287	pmdddldata->SetModule(imodule);
	288	pmdddldata->SetPatchBusId(pbusid);
	289	pmdddldata->SetMCM(imcm);
	290	pmdddldata->SetChannel(ich);
	291	pmdddldata->SetRow(irow);
	292	pmdddldata->SetColumn(icol);
	293	pmdddldata->SetSignal(isig);
	294	pmdddldata->SetParityBit(ibit);
	295
	296	pmdddlcont->Add(pmdddldata);
	297
0a666212	298	} // data word loop
9ac124a2	299
	300	if (iwordcount == blRawDataLength) break;
	301
0a666212	302	} // patch bus loop
34ab69dd	303
0a666212	304	if (dspHeader.GetPaddingWord() == 1) iuppLimit++;
9ac124a2	305	if (iwordcount == blRawDataLength) break;
34ab69dd	306
0a666212	307	} // end of DSP
9ac124a2	308	if (iwordcount == blRawDataLength) break;
34ab69dd	309
34ab69dd	310	} // end of BLOCK
34ab69dd	311
34ab69dd	312	delete [] buffer;
a09a2da4	313
9ac124a2	314	return kTRUE;
a09a2da4	315	}
a09a2da4	316	//_____________________________________________________________________________
34ab69dd	317	void AliPMDRawStream::GetRowCol(Int_t ddlno, Int_t pbusid,
	318	UInt_t mcmno, UInt_t chno,
	319	Int_t startRowBus[], Int_t endRowBus[],
	320	Int_t startColBus[], Int_t endColBus[],
	321	Int_t &row, Int_t &col) const
a09a2da4	322	{
34ab69dd	323	// decode: ddlno, patchbusid, mcmno, chno -> um, row, col
a09a2da4	324
a09a2da4	325
9ac124a2	326	static const UInt_t kCh[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
	327	49, 59, 56, 55, 52, 50, 48, 51,
	328	44, 47, 45, 43, 40, 39, 36, 46,
	329	32, 35, 33, 34, 41, 38, 37, 42,
	330	21, 26, 25, 22, 29, 30, 28, 31,
	331	17, 27, 24, 23, 20, 18, 16, 19,
	332	12, 15, 13, 11, 8, 7, 4, 14,
	333	0, 3, 1, 2, 9, 6, 5, 10 };
	334
a09a2da4	335
34ab69dd	336	Int_t rowcol = kCh[chno];
	337	Int_t irownew = rowcol/4;
	338	Int_t icolnew = rowcol%4;
a09a2da4	339
a0a6a406	340	if (ddlno == 0 )
a09a2da4	341	{
a0a6a406	342	row = startRowBus[pbusid] + irownew;
a0a6a406	343	col = startColBus[pbusid] + mcmno*4 + icolnew;
a09a2da4	344	}
34ab69dd	345	else if (ddlno == 1)
a09a2da4	346	{
a0a6a406	347	row = endRowBus[pbusid] - (15 - irownew);
	348	col = startColBus[pbusid] + mcmno*4 + icolnew;
	349
a09a2da4	350	}
a0a6a406	351	else if (ddlno == 2 )
e54787da	352	{
34ab69dd	353	row = startRowBus[pbusid] + irownew;
	354	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
	355	}
	356	else if (ddlno == 3)
	357	{
a0a6a406	358	row = endRowBus[pbusid] - (15 - irownew);
a0a6a406	359	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
e54787da	360	}
a0a6a406	361	else if (ddlno == 4 )
e54787da	362	{
a0a6a406	363	if (pbusid < 18)
e54787da	364	{
93622f4a	365	if (mcmno <= 11)
34ab69dd	366	{
	367	// Add 16 to skip the 1st 15 rows
	368	row = startRowBus[pbusid] + irownew + 16;
a0a6a406	369	col = startColBus[pbusid] + (mcmno)*4 + icolnew;
34ab69dd	370	}
93622f4a	371	else if(mcmno > 11)
	372	{
	373	row = startRowBus[pbusid] + irownew;
	374	col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	375	}
e54787da	376	}
a0a6a406	377	else if(pbusid > 17)
e54787da	378	{
93622f4a	379	if (mcmno <= 11)
a0a6a406	380	{
93622f4a	381	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
93622f4a	382
a0a6a406	383	if(endRowBus[pbusid] - startRowBus[pbusid] > 16)
	384	row = endRowBus[pbusid] - (15 - irownew) - 16 ;
	385	else
	386	row = endRowBus[pbusid] - (15 - irownew) ;
93622f4a	387
	388
	389	}
	390	else if(mcmno > 11)
	391	{
	392	row = endRowBus[pbusid] - (15 - irownew) ;
	393	col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
a0a6a406	394	}
e54787da	395	}
e54787da	396	}
34ab69dd	397	else if (ddlno == 5)
e54787da	398	{
a0a6a406	399	if (pbusid <= 17)
34ab69dd	400	{
a0a6a406	401	if (mcmno > 11)
34ab69dd	402	{
a0a6a406	403	// Subtract 16 to skip the 1st 15 rows
a0a6a406	404	row = endRowBus[pbusid] - 16 -(15 - irownew);
34ab69dd	405	col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	406	}
	407	else
	408	{
a0a6a406	409	row = endRowBus[pbusid] - (15 - irownew) ;
34ab69dd	410	col = startColBus[pbusid] + mcmno*4 + icolnew;
	411	}
	412	}
a0a6a406	413
a0a6a406	414	else if (pbusid > 17)
e54787da	415	{
a0a6a406	416	if(mcmno > 11)
	417	{
	418	// Add 16 to skip the 1st 15 rows
	419	row = startRowBus[pbusid] + irownew + 16;
	420	col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
	421	}
	422	else
	423	{
	424	row = startRowBus[pbusid] + irownew ;
	425	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
	426	}
e54787da	427	}
34ab69dd	428	}
a0a6a406	429
34ab69dd	430	}
	431	//_____________________________________________________________________________
	432	void AliPMDRawStream::ConvertDDL2SMN(Int_t iddl, Int_t imodule,
	433	Int_t &smn, Int_t &detector) const
	434	{
	435	// This converts the DDL number (0 to 5), Module Number (0-47)
	436	// to Serial module number in one detector (SMN : 0-23) and
	437	// detector number (0:PRE plane, 1:CPV plane)
	438	if (iddl < 4)
	439	{
	440	smn = imodule;
	441	detector = 0;
	442	}
	443	else
	444	{
	445	smn = imodule - 24;
e54787da	446	detector = 1;
	447	}
	448	}
	449	//_____________________________________________________________________________
	450	void AliPMDRawStream::TransformH2S(Int_t smn, Int_t &row, Int_t &col) const
	451	{
34ab69dd	452	// This does the transformation of the hardware coordinate to
	453	// software
	454	// i.e., For SuperModule 0 &1, instead of 96x48(hardware),
	455	// it is 48x96 (software)
e54787da	456	// For Supermodule 3 & 4, 48x96
e54787da	457
e54787da	458	Int_t irownew = 0;
e54787da	459	Int_t icolnew = 0;
34ab69dd	460
e54787da	461	if(smn < 12)
e54787da	462	{
34ab69dd	463	irownew = col;
34ab69dd	464	icolnew = row;
e54787da	465	}
34ab69dd	466	else if(smn >= 12 && smn < 24)
e54787da	467	{
34ab69dd	468	irownew = row;
34ab69dd	469	icolnew = col;
e54787da	470	}
	471
	472	row = irownew;
	473	col = icolnew;
	474	}
a98f9d26	475	//_____________________________________________________________________________
a0a6a406	476	Int_t AliPMDRawStream::ComputeParity(Int_t data)
a98f9d26	477	{
	478	// Calculate the parity bit
	479
	480	Int_t count = 0;
	481	for(Int_t j = 0; j<29; j++)
	482	{
	483	if (data & 0x01 ) count++;
	484	data >>= 1;
	485	}
	486
	487	Int_t parity = count%2;
	488
	489	return parity;
	490	}
	491
e54787da	492	//_____________________________________________________________________________