[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)
	    {
	      row = startRowBus[pbusid] + irownew;
	      col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	    }
	  else
	    {
	      // Add 16 to skip the 1st 15 rows
	      row = startRowBus[pbusid] + irownew + 16;
	      col = startColBus[pbusid] + (mcmno)*4 + icolnew;
	    }
	}
      else if(pbusid > 17)
	{
	  if(mcmno > 11)
	    {
	      row = endRowBus[pbusid] - (15 - irownew)  ;
	      col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
	    }
	  else 
	    {
	      if(endRowBus[pbusid] - startRowBus[pbusid] > 16)
		row = endRowBus[pbusid] - (15 - irownew) - 16 ;
	      else
		row = endRowBus[pbusid] - (15 - irownew) ;
	      col = endColBus[pbusid] - mcmno*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
	163
	164	for (Int_t ibus = 0; ibus < kNPatchBus; ibus++)
	165	{
	166	mcmperBus[ibus] = -1;
	167	startRowBus[ibus] = -1;
	168	endRowBus[ibus] = -1;
	169	startColBus[ibus] = -1;
	170	endColBus[ibus] = -1;
	171	}
	172
	173
	174	for (Int_t im = 0; im < modulePerDDL; im++)
	175	{
	176	infile >> modno;
	177	infile >> totPatchBus >> bPatchBus >> ePatchBus;
9ac124a2	178
34ab69dd	179	for(Int_t i=0; i<totPatchBus; i++)
	180	{
	181	infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
	182
	183	moduleNo[ibus] = modno;
	184	mcmperBus[ibus] = totmcm;
	185	startRowBus[ibus] = rows;
	186	endRowBus[ibus] = rowe;
	187	startColBus[ibus] = cols;
	188	endColBus[ibus] = cole;
	189	}
	190	}
	191
9ac124a2	192
9ac124a2	193
34ab69dd	194	infile.close();
	195
	196
	197	AliPMDBlockHeader blockHeader;
	198	AliPMDDspHeader dspHeader;
	199	AliPMDPatchBusHeader pbusHeader;
	200
0a666212	201	const Int_t kblHLen = blockHeader.GetHeaderLength();
	202	const Int_t kdspHLen = dspHeader.GetHeaderLength();
	203	const Int_t kpbusHLen = pbusHeader.GetHeaderLength();
	204
a98f9d26	205	Int_t parity;
34ab69dd	206	Int_t idet, ismn;
	207	Int_t irow = -1;
	208	Int_t icol = -1;
	209
0a666212	210	Int_t blHeaderWord[8];
	211	Int_t dspHeaderWord[10];
	212	Int_t pbusHeaderWord[4];
34ab69dd	213
	214	Int_t ilowLimit = 0;
	215	Int_t iuppLimit = 0;
9ac124a2	216
	217	Int_t blRawDataLength = 0;
	218	Int_t iwordcount = 0;
	219
	220
34ab69dd	221	for (Int_t iblock = 0; iblock < 2; iblock++)
	222	{
	223	ilowLimit = iuppLimit;
0a666212	224	iuppLimit = ilowLimit + kblHLen;
34ab69dd	225
9ac124a2	226
34ab69dd	227	for (Int_t i = ilowLimit; i < iuppLimit; i++)
34ab69dd	228	{
0a666212	229	blHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
34ab69dd	230	}
9ac124a2	231
0a666212	232	blockHeader.SetHeader(blHeaderWord);
9ac124a2	233
	234	blRawDataLength = blockHeader.GetRawDataLength();
	235
34ab69dd	236	for (Int_t idsp = 0; idsp < 5; idsp++)
	237	{
	238	ilowLimit = iuppLimit;
0a666212	239	iuppLimit = ilowLimit + kdspHLen;
34ab69dd	240
	241	for (Int_t i = ilowLimit; i < iuppLimit; i++)
	242	{
9ac124a2	243	iwordcount++;
0a666212	244	dspHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
34ab69dd	245	}
0a666212	246	dspHeader.SetHeader(dspHeaderWord);
34ab69dd	247
	248	for (Int_t ibus = 0; ibus < 5; ibus++)
	249	{
	250
	251	ilowLimit = iuppLimit;
0a666212	252	iuppLimit = ilowLimit + kpbusHLen;
34ab69dd	253
	254	for (Int_t i = ilowLimit; i < iuppLimit; i++)
	255	{
9ac124a2	256	iwordcount++;
0a666212	257	pbusHeaderWord[i-ilowLimit] = (Int_t) buffer[i];
34ab69dd	258	}
0a666212	259	pbusHeader.SetHeader(pbusHeaderWord);
34ab69dd	260	Int_t rawdatalength = pbusHeader.GetRawDataLength();
	261	Int_t pbusid = pbusHeader.GetPatchBusId();
	262
	263	ilowLimit = iuppLimit;
	264	iuppLimit = ilowLimit + rawdatalength;
	265
	266	Int_t imodule = moduleNo[pbusid];
	267
	268
	269	for (Int_t iword = ilowLimit; iword < iuppLimit; iword++)
	270	{
9ac124a2	271	iwordcount++;
34ab69dd	272	data = buffer[iword];
	273
	274	Int_t isig = data & 0x0FFF;
	275	Int_t ich = (data >> 12) & 0x003F;
	276	Int_t imcm = (data >> 18) & 0x07FF;
	277	Int_t ibit = (data >> 31) & 0x0001;
a98f9d26	278	parity = ComputeParity(data);
	279	if (ibit != parity)
	280	{
	281	AliWarning("ComputeParity:: Parity Error");
	282	}
34ab69dd	283	GetRowCol(iddl, pbusid, imcm, ich,
	284	startRowBus, endRowBus,
	285	startColBus, endColBus,
	286	irow, icol);
	287
	288	ConvertDDL2SMN(iddl, imodule, ismn, idet);
	289	TransformH2S(ismn, irow, icol);
	290
	291	pmdddldata = new AliPMDddldata();
	292
	293	pmdddldata->SetDetector(idet);
	294	pmdddldata->SetSMN(ismn);
	295	pmdddldata->SetModule(imodule);
	296	pmdddldata->SetPatchBusId(pbusid);
	297	pmdddldata->SetMCM(imcm);
	298	pmdddldata->SetChannel(ich);
	299	pmdddldata->SetRow(irow);
	300	pmdddldata->SetColumn(icol);
	301	pmdddldata->SetSignal(isig);
	302	pmdddldata->SetParityBit(ibit);
	303
	304	pmdddlcont->Add(pmdddldata);
	305
0a666212	306	} // data word loop
9ac124a2	307
	308	if (iwordcount == blRawDataLength) break;
	309
0a666212	310	} // patch bus loop
34ab69dd	311
0a666212	312	if (dspHeader.GetPaddingWord() == 1) iuppLimit++;
9ac124a2	313	if (iwordcount == blRawDataLength) break;
34ab69dd	314
0a666212	315	} // end of DSP
9ac124a2	316	if (iwordcount == blRawDataLength) break;
34ab69dd	317
	318	} // end of BLOCK
	319
	320
	321	delete [] buffer;
a09a2da4	322
9ac124a2	323	return kTRUE;
a09a2da4	324	}
a09a2da4	325	//_____________________________________________________________________________
34ab69dd	326	void AliPMDRawStream::GetRowCol(Int_t ddlno, Int_t pbusid,
	327	UInt_t mcmno, UInt_t chno,
	328	Int_t startRowBus[], Int_t endRowBus[],
	329	Int_t startColBus[], Int_t endColBus[],
	330	Int_t &row, Int_t &col) const
a09a2da4	331	{
34ab69dd	332	// decode: ddlno, patchbusid, mcmno, chno -> um, row, col
a09a2da4	333
a09a2da4	334
9ac124a2	335	static const UInt_t kCh[64] = { 53, 58, 57, 54, 61, 62, 60, 63,
	336	49, 59, 56, 55, 52, 50, 48, 51,
	337	44, 47, 45, 43, 40, 39, 36, 46,
	338	32, 35, 33, 34, 41, 38, 37, 42,
	339	21, 26, 25, 22, 29, 30, 28, 31,
	340	17, 27, 24, 23, 20, 18, 16, 19,
	341	12, 15, 13, 11, 8, 7, 4, 14,
	342	0, 3, 1, 2, 9, 6, 5, 10 };
	343
a09a2da4	344
34ab69dd	345	Int_t rowcol = kCh[chno];
	346	Int_t irownew = rowcol/4;
	347	Int_t icolnew = rowcol%4;
a09a2da4	348
a0a6a406	349	if (ddlno == 0 )
a09a2da4	350	{
a0a6a406	351	row = startRowBus[pbusid] + irownew;
a0a6a406	352	col = startColBus[pbusid] + mcmno*4 + icolnew;
a09a2da4	353	}
34ab69dd	354	else if (ddlno == 1)
a09a2da4	355	{
a0a6a406	356	row = endRowBus[pbusid] - (15 - irownew);
	357	col = startColBus[pbusid] + mcmno*4 + icolnew;
	358
a09a2da4	359	}
a0a6a406	360	else if (ddlno == 2 )
e54787da	361	{
34ab69dd	362	row = startRowBus[pbusid] + irownew;
	363	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
	364	}
	365	else if (ddlno == 3)
	366	{
a0a6a406	367	row = endRowBus[pbusid] - (15 - irownew);
a0a6a406	368	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
e54787da	369	}
a0a6a406	370	else if (ddlno == 4 )
e54787da	371	{
a0a6a406	372	if (pbusid < 18)
e54787da	373	{
a0a6a406	374	if(mcmno > 11)
34ab69dd	375	{
	376	row = startRowBus[pbusid] + irownew;
	377	col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	378	}
	379	else
	380	{
	381	// Add 16 to skip the 1st 15 rows
	382	row = startRowBus[pbusid] + irownew + 16;
a0a6a406	383	col = startColBus[pbusid] + (mcmno)*4 + icolnew;
34ab69dd	384	}
e54787da	385	}
a0a6a406	386	else if(pbusid > 17)
e54787da	387	{
a0a6a406	388	if(mcmno > 11)
	389	{
	390	row = endRowBus[pbusid] - (15 - irownew) ;
	391	col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
	392	}
	393	else
	394	{
	395	if(endRowBus[pbusid] - startRowBus[pbusid] > 16)
	396	row = endRowBus[pbusid] - (15 - irownew) - 16 ;
	397	else
	398	row = endRowBus[pbusid] - (15 - irownew) ;
	399	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
	400	}
e54787da	401	}
e54787da	402	}
a0a6a406	403
34ab69dd	404	else if (ddlno == 5)
e54787da	405	{
a0a6a406	406	if (pbusid <= 17)
34ab69dd	407	{
a0a6a406	408	if (mcmno > 11)
34ab69dd	409	{
a0a6a406	410	// Subtract 16 to skip the 1st 15 rows
a0a6a406	411	row = endRowBus[pbusid] - 16 -(15 - irownew);
34ab69dd	412	col = startColBus[pbusid] + (mcmno-12)*4 + icolnew;
	413	}
	414	else
	415	{
a0a6a406	416	row = endRowBus[pbusid] - (15 - irownew) ;
34ab69dd	417	col = startColBus[pbusid] + mcmno*4 + icolnew;
	418	}
	419	}
a0a6a406	420
a0a6a406	421	else if (pbusid > 17)
e54787da	422	{
a0a6a406	423	if(mcmno > 11)
	424	{
	425	// Add 16 to skip the 1st 15 rows
	426	row = startRowBus[pbusid] + irownew + 16;
	427	col = endColBus[pbusid] - (mcmno - 12)*4 - (3 - icolnew);
	428	}
	429	else
	430	{
	431	row = startRowBus[pbusid] + irownew ;
	432	col = endColBus[pbusid] - mcmno*4 - (3 - icolnew);
	433	}
e54787da	434	}
34ab69dd	435	}
a0a6a406	436
34ab69dd	437	}
	438	//_____________________________________________________________________________
	439	void AliPMDRawStream::ConvertDDL2SMN(Int_t iddl, Int_t imodule,
	440	Int_t &smn, Int_t &detector) const
	441	{
	442	// This converts the DDL number (0 to 5), Module Number (0-47)
	443	// to Serial module number in one detector (SMN : 0-23) and
	444	// detector number (0:PRE plane, 1:CPV plane)
	445	if (iddl < 4)
	446	{
	447	smn = imodule;
	448	detector = 0;
	449	}
	450	else
	451	{
	452	smn = imodule - 24;
e54787da	453	detector = 1;
	454	}
	455	}
	456	//_____________________________________________________________________________
	457	void AliPMDRawStream::TransformH2S(Int_t smn, Int_t &row, Int_t &col) const
	458	{
34ab69dd	459	// This does the transformation of the hardware coordinate to
	460	// software
	461	// i.e., For SuperModule 0 &1, instead of 96x48(hardware),
	462	// it is 48x96 (software)
e54787da	463	// For Supermodule 3 & 4, 48x96
e54787da	464
e54787da	465	Int_t irownew = 0;
e54787da	466	Int_t icolnew = 0;
34ab69dd	467
e54787da	468	if(smn < 12)
e54787da	469	{
34ab69dd	470	irownew = col;
34ab69dd	471	icolnew = row;
e54787da	472	}
34ab69dd	473	else if(smn >= 12 && smn < 24)
e54787da	474	{
34ab69dd	475	irownew = row;
34ab69dd	476	icolnew = col;
e54787da	477	}
	478
	479	row = irownew;
	480	col = icolnew;
	481	}
a98f9d26	482	//_____________________________________________________________________________
a0a6a406	483	Int_t AliPMDRawStream::ComputeParity(Int_t data)
a98f9d26	484	{
	485	// Calculate the parity bit
	486
	487	Int_t count = 0;
	488	for(Int_t j = 0; j<29; j++)
	489	{
	490	if (data & 0x01 ) count++;
	491	data >>= 1;
	492	}
	493
	494	Int_t parity = count%2;
	495
	496	return parity;
	497	}
	498
e54787da	499	//_____________________________________________________________________________