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

#include <Riostream.h>
#include <TClonesArray.h>
#include <TTree.h>
#include <TBranch.h>
#include <TMath.h>

#include "AliPMDdigit.h"
#include "AliPMDDDLRawData.h"


ClassImp(AliPMDDDLRawData)

AliPMDDDLRawData::AliPMDDDLRawData():
  fDigits(new TClonesArray("AliPMDdigit", 1000))
{
  // Default Constructor
  //
}
//____________________________________________________________________________

AliPMDDDLRawData::~AliPMDDDLRawData()
{
  // Default Destructor
  //

}

//____________________________________________________________________________
void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
{
  // write digits into raw data format

  ofstream outfile;

  TBranch *branch = treeD->GetBranch("PMDDigit");
  if (!branch) return;
  branch->SetAddress(&fDigits);  
  
  Int_t   nmodules = (Int_t) treeD->GetEntries();
  //  cout << " nmodules = " << nmodules << endl;

  const Int_t kSize         = 4608;
  const Int_t kDDL          = 6;
  Int_t modulePerDDL        = 0;


  UInt_t sizeRawData = 0;
  UInt_t magicWord   = 0x123456;
  UInt_t detectorID  = 0;
  UInt_t ddlID       = 0;
  Int_t  flag        = 0;
  Int_t  version     = 1;
  UInt_t mHSize      = 3*sizeof(UInt_t);
  Int_t  totword     = 0;

  UInt_t miniHeader[3];
  UInt_t buffer[kSize];

  Char_t filename[80];

  Int_t mmodule = 0;
  for(Int_t iddl = 0; iddl < kDDL; iddl++)
    {
      sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
#ifndef __DECCXX
      outfile.open(filename,ios::binary);
#else
      outfile.open(filename);
#endif
      
      if (iddl < 4)
	{
	  modulePerDDL = 6;
	  mmodule = 6*iddl;
	  detectorID = 0;
	}
      else if (iddl == 4)
	{
	  modulePerDDL = 12;
	  mmodule = 24;
	  detectorID = 1;
	}
      else if (iddl == 5)
	{
	  modulePerDDL = 12;
	  mmodule = 36;
	  detectorID = 1;
	}

      miniHeader[0] = sizeRawData;
      PackWord(0,23,magicWord,miniHeader[1]);
      PackWord(24,31,detectorID,miniHeader[1]);
      ddlID = iddl;
      PackWord(0,15,ddlID,miniHeader[2]);
      PackWord(16,23,flag,miniHeader[2]);
      PackWord(24,31,version,miniHeader[2]);


      // Write the Dummy Mini Header into the file
      Int_t bHPosition = outfile.tellp();
      outfile.write((char*)(miniHeader),mHSize);


      for(Int_t ium = 0; ium < modulePerDDL; ium++)
	{
	  
	  for (Int_t i = 0; i < kSize; i++)
	    {
	      buffer[i] = 0;
	    }
	  // Extract energy deposition per cell and pack it
	  // in a 32-bit word and returns all the total words
	  // per one unit-module
	  
	  GetUMDigitsData(treeD, mmodule, ium, iddl, totword, buffer);
	  
	  outfile.write((char*)buffer,totword*sizeof(UInt_t));

	  mmodule++;

	}

      // Write real mini header
      // take the pointer to the beginning of the mini header
      // write the total number of words per ddl and bring the
      // pointer to the current file position and close it
      UInt_t cFPosition = outfile.tellp();
      sizeRawData = cFPosition - bHPosition - mHSize;
      outfile.seekp(bHPosition);
      outfile.write((char*)(&sizeRawData),sizeof(UInt_t));
      outfile.seekp(cFPosition);

      outfile.close();
    } // DDL Loop over


}
//____________________________________________________________________________

void AliPMDDDLRawData::ReadPMDRawData(Int_t evtno)
{
  // reads the raw data
  ifstream infile;

  Char_t filename[80];

  const Int_t kDDL = 6;
  Int_t imodule = 0;

  for(Int_t iddl = 0; iddl < kDDL; iddl++)
    {
      sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
#ifndef __DECCXX
      infile.open(filename,ios::binary);
#else
      infile.open(filename);
#endif
      
      Int_t  ium;
      Int_t  irow;
      Int_t  icol;
      UInt_t baseword;
      UInt_t miniHeader[3];
      UInt_t sizeRawData;
      UInt_t mHSize = 3*sizeof(UInt_t);

      infile.read((char*)(miniHeader), mHSize);
      
      sizeRawData = miniHeader[0];
      Int_t totword = sizeRawData/4;
      
      UInt_t adc;
      UInt_t chno;
      UInt_t mcmno;
      
      for (Int_t iword = 0; iword < totword; iword++)
	{
	  infile.read((char*)(&baseword),sizeof(UInt_t));
	  
	  UnpackWord(0,11,adc,baseword);
	  UnpackWord(12,17,chno,baseword);
	  UnpackWord(18,28,mcmno,baseword);
	  
	  GetRowCol(iddl, mcmno, chno, ium, irow, icol);
	  if (iddl < 4)
	    {
	      imodule = iddl*6 + ium;
	    }
	  else if (iddl == 4)
	    {
	      imodule = 24 + ium;
	    }
	  else if (iddl == 5)
	    {
	      imodule = 36 + ium;
	    }

	  
	}

    } // ddl loop
}
//____________________________________________________________________________
void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
				       Int_t ddlno, Int_t & totword,
				       UInt_t *buffer)
{

  UInt_t dataword, baseword;

  UInt_t mcmno, chno;
  UInt_t adc;
  Int_t  irownew = 0;
  Int_t  icolnew = 0;
  Int_t  det, smn, irow, icol;


  treeD->GetEntry(imodule); 
  Int_t nentries = fDigits->GetLast();
  totword = nentries+1;

  for (Int_t ient = 0; ient < totword; ient++)
    {
      fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
      
      det    = fPMDdigit->GetDetector();
      smn    = fPMDdigit->GetSMNumber();
      irow   = fPMDdigit->GetRow();
      icol   = fPMDdigit->GetColumn();
      adc    = (UInt_t) fPMDdigit->GetADC();

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


      GetMCMCh(ddlno, ium, irownew, icolnew, mcmno, chno);


      baseword = 0;
      dataword = adc;
      PackWord(0, 11,dataword,baseword);
      dataword = chno;
      PackWord(12,17,dataword,baseword);
      dataword = mcmno;
      PackWord(18,28,dataword,baseword);
      dataword = 0;
      PackWord(29,29,dataword,baseword);
      dataword = 0;
      PackWord(30,30,dataword,baseword);
      dataword = 1;
      PackWord(31,31,dataword,baseword);
      
      buffer[ient] = baseword;
      

    }


}
//____________________________________________________________________________
void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
				Int_t row, Int_t col,
				UInt_t &mcmno, UInt_t &chno)
{
  // This part will be modified once the final track layout on the PCB is
  // designed. This will only change the coordinate of the individual cell
  UInt_t ch[16][4] = { {3, 2, 29, 28},
		       {5, 1, 31, 27},
		       {6, 0, 30, 26},
		       {7, 4, 25, 24},
		       {8, 9, 20, 23},
		       {10, 14, 16, 22},
		       {11, 15, 17, 21},
		       {12, 13, 18, 19},
		       {35, 34, 61, 60},
		       {37, 33, 63, 59},
		       {38, 32, 62, 58},
		       {39, 36, 57, 56},
		       {40, 41, 52, 55},
		       {42, 46, 48, 54},
		       {43, 47, 49, 53},
		       {44, 45, 50, 51} };
  
  if (ddlno == 0 || ddlno == 1)
    {
      // PRE plane, SU Mod = 1, 2
      Int_t irownew = row%16;
      Int_t icolnew = col%4;
      Int_t irowdiv = row/16;
      Int_t icoldiv = col/4;

      mcmno = 72*um + 6*icoldiv + irowdiv;
      chno  = ch[irownew][icolnew];
    }
  else if (ddlno == 2 || ddlno == 3)
    {
      // PRE plane,  SU Mod = 3, 4
      Int_t irownew = row%16;
      Int_t icolnew = col%4;
      Int_t irowdiv = row/16;
      Int_t icoldiv = col/4;
      
      mcmno = 72*um + 3*icoldiv + irowdiv;
      chno  = ch[irownew][icolnew];
    }
  else if (ddlno == 4)
    {
      // CPV plane,  SU Mod = 1, 2
      Int_t irownew = row%16;
      Int_t icolnew = col%4;
      Int_t irowdiv = row/16;
      Int_t icoldiv = col/4;

      mcmno = 72*um + 6*icoldiv + irowdiv;
      chno  = ch[irownew][icolnew];
    }
  else if (ddlno == 5)
    {
      // CPV plane,  SU Mod = 3, 4
      Int_t irownew = row%16;
      Int_t icolnew = col%4;
      Int_t irowdiv = row/16;
      Int_t icoldiv = col/4;
      
      mcmno = 72*um + 3*icoldiv + irowdiv;
      chno  = ch[irownew][icolnew];
    }

}
//____________________________________________________________________________

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

  if (ddlno == 1 || ddlno == 2)
    {
      um  = mcmno/72;
      Int_t mcmnonew = mcmno - 72*um;
      Int_t rowcol  = ch[chno];
      Int_t irownew = rowcol/4;
      Int_t icolnew = rowcol%4;
      
      Int_t remmcm  = mcmnonew%6;
      Int_t divmcm  = mcmnonew/6;
      
      row = 16*remmcm + irownew;
      col =  4*divmcm + icolnew;
    }
  else   if (ddlno == 3 || ddlno == 4)
    {
      um  = mcmno/72;
      Int_t mcmnonew = mcmno - 72*um;
      Int_t rowcol  = ch[chno];
      Int_t irownew = rowcol/4;
      Int_t icolnew = rowcol%4;
      
      Int_t remmcm  = mcmnonew%3;
      Int_t divmcm  = mcmnonew/3;
      
      row = 16*remmcm + irownew;
      col =  4*divmcm + icolnew;
    }
  else if (ddlno == 4)
    {
      um  = mcmno/144;
      Int_t mcmnonew = mcmno - 72*um;
      Int_t rowcol  = ch[chno];
      Int_t irownew = rowcol/4;
      Int_t icolnew = rowcol%4;
      
      Int_t remmcm  = mcmnonew%6;
      Int_t divmcm  = mcmnonew/6;
      
      row = 16*remmcm + irownew;
      col =  4*divmcm + icolnew;
    }
  else if (ddlno == 5)
    {
      um  = mcmno/144;
      Int_t mcmnonew = mcmno - 72*um;
      Int_t rowcol  = ch[chno];
      Int_t irownew = rowcol/4;
      Int_t icolnew = rowcol%4;
      
      Int_t remmcm  = mcmnonew%3;
      Int_t divmcm  = mcmnonew/3;
      
      row = 16*remmcm + irownew;
      col =  4*divmcm + icolnew;
    }


}
//____________________________________________________________________________

void AliPMDDDLRawData::PackWord(UInt_t startbit, UInt_t stopbit, 
				UInt_t dataword, UInt_t &packedword)
{
  UInt_t bitLength  = stopbit - startbit + 1;
  UInt_t bitContent = (UInt_t) (TMath::Power(2,bitLength) - 1);
  if(bitContent < dataword)
    {
      cout << " *** ERROR *** bitContent is less than the dataword" << endl;
      return;
    }
  UInt_t packedBits = 0;
  if (packedword != 0)
    packedBits = (UInt_t) (TMath::Log(packedword)/TMath::Log(2));

  UInt_t counter;
  if (packedBits <= stopbit)
    {
      counter   = 31 - stopbit;
    }
  else
    {
      counter   = 31 - packedBits;
    }
  UInt_t dummyword = 0xFFFFFFFF;
  dummyword >>= counter;
  UInt_t lword = dataword << startbit;
  UInt_t nword = lword | packedword;
  packedword = dummyword & nword;


}
//____________________________________________________________________________
void AliPMDDDLRawData::UnpackWord(UInt_t startbit, UInt_t stopbit, 
				UInt_t &dataword, UInt_t packedword)
{
  UInt_t bitLength  = stopbit - startbit + 1;
  UInt_t bitContent = (UInt_t) (TMath::Power(2,bitLength) - 1);
  bitContent <<= startbit;
  dataword = packedword & bitContent;
  dataword >>= startbit;

}
//____________________________________________________________________________
Commit	Line	Data
28328eeb	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	#include <Riostream.h>
	17	#include <TClonesArray.h>
	18	#include <TTree.h>
	19	#include <TBranch.h>
	20	#include <TMath.h>
	21
	22	#include "AliPMDdigit.h"
	23	#include "AliPMDDDLRawData.h"
	24
	25
	26	ClassImp(AliPMDDDLRawData)
	27
	28	AliPMDDDLRawData::AliPMDDDLRawData():
	29	fDigits(new TClonesArray("AliPMDdigit", 1000))
	30	{
	31	// Default Constructor
	32	//
	33	}
	34	//____________________________________________________________________________
	35
	36	AliPMDDDLRawData::~AliPMDDDLRawData()
	37	{
	38	// Default Destructor
	39	//
	40
	41	}
	42
	43	//____________________________________________________________________________
	44	void AliPMDDDLRawData::WritePMDRawData(TTree *treeD, Int_t evtno)
	45	{
	46	// write digits into raw data format
	47
	48	ofstream outfile;
	49
	50	TBranch *branch = treeD->GetBranch("PMDDigit");
	51	if (!branch) return;
	52	branch->SetAddress(&fDigits);
	53
	54	Int_t nmodules = (Int_t) treeD->GetEntries();
	55	// cout << " nmodules = " << nmodules << endl;
	56
	57	const Int_t kSize = 4608;
	58	const Int_t kDDL = 6;
	59	Int_t modulePerDDL = 0;
	60
	61
	62	UInt_t sizeRawData = 0;
	63	UInt_t magicWord = 0x123456;
	64	UInt_t detectorID = 0;
65	UInt_t ddlID = 0;
66	Int_t flag = 0;
67	Int_t version = 1;
68	UInt_t mHSize = 3*sizeof(UInt_t);
69	Int_t totword = 0;
70
71	UInt_t miniHeader[3];
72	UInt_t buffer[kSize];
73
74	Char_t filename[80];
75
76	Int_t mmodule = 0;
77	for(Int_t iddl = 0; iddl < kDDL; iddl++)
78	{
79	sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
80	#ifndef __DECCXX
81	outfile.open(filename,ios::binary);
82	#else
83	outfile.open(filename);
84	#endif
85
86	if (iddl < 4)
87	{
88	modulePerDDL = 6;
89	mmodule = 6*iddl;
90	detectorID = 0;
91	}
92	else if (iddl == 4)
93	{
94	modulePerDDL = 12;
95	mmodule = 24;
96	detectorID = 1;
97	}
98	else if (iddl == 5)
99	{
100	modulePerDDL = 12;
101	mmodule = 36;
102	detectorID = 1;
103	}
104
105	miniHeader[0] = sizeRawData;
106	PackWord(0,23,magicWord,miniHeader[1]);
107	PackWord(24,31,detectorID,miniHeader[1]);
108	ddlID = iddl;
109	PackWord(0,15,ddlID,miniHeader[2]);
110	PackWord(16,23,flag,miniHeader[2]);
111	PackWord(24,31,version,miniHeader[2]);
112
113
114	// Write the Dummy Mini Header into the file
115	Int_t bHPosition = outfile.tellp();
116	outfile.write((char*)(miniHeader),mHSize);
117
118
119	for(Int_t ium = 0; ium < modulePerDDL; ium++)
120	{
121
122	for (Int_t i = 0; i < kSize; i++)
123	{
124	buffer[i] = 0;
125	}
126	// Extract energy deposition per cell and pack it
127	// in a 32-bit word and returns all the total words
128	// per one unit-module
129
130	GetUMDigitsData(treeD, mmodule, ium, iddl, totword, buffer);
131
132	outfile.write((char)buffer,totwordsizeof(UInt_t));
133
134	mmodule++;
135
136	}
137
138	// Write real mini header
139	// take the pointer to the beginning of the mini header
140	// write the total number of words per ddl and bring the
141	// pointer to the current file position and close it
142	UInt_t cFPosition = outfile.tellp();
143	sizeRawData = cFPosition - bHPosition - mHSize;
144	outfile.seekp(bHPosition);
145	outfile.write((char*)(&sizeRawData),sizeof(UInt_t));
146	outfile.seekp(cFPosition);
147
148	outfile.close();
149	} // DDL Loop over
150
151
152	}
153	//____________________________________________________________________________
154
155	void AliPMDDDLRawData::ReadPMDRawData(Int_t evtno)
156	{
157	// reads the raw data
158	ifstream infile;
159
160	Char_t filename[80];
161
162	const Int_t kDDL = 6;
163	Int_t imodule = 0;
164
165	for(Int_t iddl = 0; iddl < kDDL; iddl++)
166	{
167	sprintf(filename,"Ev%dPMDddl%d.dat",evtno,iddl);
168	#ifndef __DECCXX
169	infile.open(filename,ios::binary);
170	#else
171	infile.open(filename);
172	#endif
173
174	Int_t ium;
175	Int_t irow;
176	Int_t icol;
177	UInt_t baseword;
178	UInt_t miniHeader[3];
179	UInt_t sizeRawData;
180	UInt_t mHSize = 3*sizeof(UInt_t);
181
182	infile.read((char*)(miniHeader), mHSize);
183
184	sizeRawData = miniHeader[0];
185	Int_t totword = sizeRawData/4;
186
187	UInt_t adc;
188	UInt_t chno;
189	UInt_t mcmno;
190
191	for (Int_t iword = 0; iword < totword; iword++)
192	{
193	infile.read((char*)(&baseword),sizeof(UInt_t));
194
195	UnpackWord(0,11,adc,baseword);
196	UnpackWord(12,17,chno,baseword);
197	UnpackWord(18,28,mcmno,baseword);
198
199	GetRowCol(iddl, mcmno, chno, ium, irow, icol);
200	if (iddl < 4)
201	{
202	imodule = iddl*6 + ium;
203	}
204	else if (iddl == 4)
205	{
206	imodule = 24 + ium;
207	}
208	else if (iddl == 5)
209	{
210	imodule = 36 + ium;
211	}
212
28328eeb	213
	214	}
	215
	216	} // ddl loop
	217	}
	218	//____________________________________________________________________________
	219	void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule, Int_t ium,
	220	Int_t ddlno, Int_t & totword,
	221	UInt_t *buffer)
	222	{
	223
	224	UInt_t dataword, baseword;
	225
	226	UInt_t mcmno, chno;
	227	UInt_t adc;
	228	Int_t irownew = 0;
	229	Int_t icolnew = 0;
	230	Int_t det, smn, irow, icol;
	231
	232
	233	treeD->GetEntry(imodule);
	234	Int_t nentries = fDigits->GetLast();
	235	totword = nentries+1;
	236
	237	for (Int_t ient = 0; ient < totword; ient++)
	238	{
	239	fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
	240
	241	det = fPMDdigit->GetDetector();
	242	smn = fPMDdigit->GetSMNumber();
	243	irow = fPMDdigit->GetRow();
	244	icol = fPMDdigit->GetColumn();
	245	adc = (UInt_t) fPMDdigit->GetADC();
	246
	247	if(smn < 12)
	248	{
	249	irownew = icol;
	250	icolnew = irow;
	251	}
	252	else if( smn >= 12 && smn < 24)
	253	{
	254	irownew = irow;
	255	icolnew = icol;
	256	}
	257
	258
	259
	260	GetMCMCh(ddlno, ium, irownew, icolnew, mcmno, chno);
	261
28328eeb	262
	263	baseword = 0;
	264	dataword = adc;
	265	PackWord(0, 11,dataword,baseword);
	266	dataword = chno;
	267	PackWord(12,17,dataword,baseword);
	268	dataword = mcmno;
	269	PackWord(18,28,dataword,baseword);
	270	dataword = 0;
	271	PackWord(29,29,dataword,baseword);
	272	dataword = 0;
	273	PackWord(30,30,dataword,baseword);
	274	dataword = 1;
	275	PackWord(31,31,dataword,baseword);
	276
	277	buffer[ient] = baseword;
	278
	279
	280
28328eeb	281
	282	}
	283
	284
	285	}
	286	//____________________________________________________________________________
	287	void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t um,
	288	Int_t row, Int_t col,
	289	UInt_t &mcmno, UInt_t &chno)
	290	{
	291	// This part will be modified once the final track layout on the PCB is
	292	// designed. This will only change the coordinate of the individual cell
	293	UInt_t ch[16][4] = { {3, 2, 29, 28},
	294	{5, 1, 31, 27},
	295	{6, 0, 30, 26},
	296	{7, 4, 25, 24},
	297	{8, 9, 20, 23},
	298	{10, 14, 16, 22},
	299	{11, 15, 17, 21},
	300	{12, 13, 18, 19},
	301	{35, 34, 61, 60},
	302	{37, 33, 63, 59},
	303	{38, 32, 62, 58},
	304	{39, 36, 57, 56},
	305	{40, 41, 52, 55},
	306	{42, 46, 48, 54},
	307	{43, 47, 49, 53},
	308	{44, 45, 50, 51} };
	309
	310	if (ddlno == 0 \|\| ddlno == 1)
	311	{
	312	// PRE plane, SU Mod = 1, 2
	313	Int_t irownew = row%16;
	314	Int_t icolnew = col%4;
	315	Int_t irowdiv = row/16;
	316	Int_t icoldiv = col/4;
	317
	318	mcmno = 72um + 6icoldiv + irowdiv;
	319	chno = ch[irownew][icolnew];
	320	}
	321	else if (ddlno == 2 \|\| ddlno == 3)
	322	{
	323	// PRE plane, SU Mod = 3, 4
	324	Int_t irownew = row%16;
	325	Int_t icolnew = col%4;
	326	Int_t irowdiv = row/16;
	327	Int_t icoldiv = col/4;
	328
	329	mcmno = 72um + 3icoldiv + irowdiv;
	330	chno = ch[irownew][icolnew];
	331	}
	332	else if (ddlno == 4)
	333	{
	334	// CPV plane, SU Mod = 1, 2
	335	Int_t irownew = row%16;
	336	Int_t icolnew = col%4;
	337	Int_t irowdiv = row/16;
	338	Int_t icoldiv = col/4;
	339
	340	mcmno = 72um + 6icoldiv + irowdiv;
	341	chno = ch[irownew][icolnew];
	342	}
	343	else if (ddlno == 5)
	344	{
345	// CPV plane, SU Mod = 3, 4
346	Int_t irownew = row%16;
347	Int_t icolnew = col%4;
348	Int_t irowdiv = row/16;
349	Int_t icoldiv = col/4;
350
351	mcmno = 72um + 3icoldiv + irowdiv;
352	chno = ch[irownew][icolnew];
353	}
354
355	}
356	//____________________________________________________________________________
357
358	void AliPMDDDLRawData::GetRowCol(Int_t ddlno, UInt_t mcmno, UInt_t chno,
359	Int_t &um, Int_t &row, Int_t &col)
360	{
361	UInt_t ch[64] = { 9, 5, 1, 0, 13, 4, 8, 12,
362	16, 17, 20, 24, 28, 29, 21, 25,
363	22, 26, 30, 31, 18, 27, 23, 19,
364	15, 14, 11, 7, 3, 2, 10, 6,
365	41, 37, 33, 32, 45, 36, 40, 44,
366	48, 49, 52, 56, 60, 61, 53, 57,
367	54, 58, 62, 63, 50, 59, 55, 51,
368	47, 46, 43, 39, 35, 34, 42, 38 };
369
370	if (ddlno == 1 \|\| ddlno == 2)
371	{
372	um = mcmno/72;
373	Int_t mcmnonew = mcmno - 72*um;
374	Int_t rowcol = ch[chno];
375	Int_t irownew = rowcol/4;
376	Int_t icolnew = rowcol%4;
377
378	Int_t remmcm = mcmnonew%6;
379	Int_t divmcm = mcmnonew/6;
380
381	row = 16*remmcm + irownew;
382	col = 4*divmcm + icolnew;
383	}
384	else if (ddlno == 3 \|\| ddlno == 4)
385	{
386	um = mcmno/72;
387	Int_t mcmnonew = mcmno - 72*um;
388	Int_t rowcol = ch[chno];
389	Int_t irownew = rowcol/4;
390	Int_t icolnew = rowcol%4;
391
392	Int_t remmcm = mcmnonew%3;
393	Int_t divmcm = mcmnonew/3;
394
395	row = 16*remmcm + irownew;
396	col = 4*divmcm + icolnew;
397	}
398	else if (ddlno == 4)
399	{
400	um = mcmno/144;
401	Int_t mcmnonew = mcmno - 72*um;
402	Int_t rowcol = ch[chno];
403	Int_t irownew = rowcol/4;
404	Int_t icolnew = rowcol%4;
405
406	Int_t remmcm = mcmnonew%6;
407	Int_t divmcm = mcmnonew/6;
408
409	row = 16*remmcm + irownew;
410	col = 4*divmcm + icolnew;
411	}
412	else if (ddlno == 5)
413	{
414	um = mcmno/144;
415	Int_t mcmnonew = mcmno - 72*um;
416	Int_t rowcol = ch[chno];
417	Int_t irownew = rowcol/4;
418	Int_t icolnew = rowcol%4;
419
420	Int_t remmcm = mcmnonew%3;
421	Int_t divmcm = mcmnonew/3;
422
423	row = 16*remmcm + irownew;
424	col = 4*divmcm + icolnew;
425	}
426
427
428	}
429	//____________________________________________________________________________
430
431	void AliPMDDDLRawData::PackWord(UInt_t startbit, UInt_t stopbit,
432	UInt_t dataword, UInt_t &packedword)
433	{
434	UInt_t bitLength = stopbit - startbit + 1;
435	UInt_t bitContent = (UInt_t) (TMath::Power(2,bitLength) - 1);
436	if(bitContent < dataword)
437	{
438	cout << " * ERROR * bitContent is less than the dataword" << endl;
439	return;
440	}
441	UInt_t packedBits = 0;
442	if (packedword != 0)
443	packedBits = (UInt_t) (TMath::Log(packedword)/TMath::Log(2));
444
445	UInt_t counter;
446	if (packedBits <= stopbit)
447	{
448	counter = 31 - stopbit;
449	}
450	else
451	{
452	counter = 31 - packedBits;
453	}
454	UInt_t dummyword = 0xFFFFFFFF;
455	dummyword >>= counter;
456	UInt_t lword = dataword << startbit;
457	UInt_t nword = lword \| packedword;
458	packedword = dummyword & nword;
459
460
461	}
462	//____________________________________________________________________________
463	void AliPMDDDLRawData::UnpackWord(UInt_t startbit, UInt_t stopbit,
464	UInt_t &dataword, UInt_t packedword)
465	{
466	UInt_t bitLength = stopbit - startbit + 1;
467	UInt_t bitContent = (UInt_t) (TMath::Power(2,bitLength) - 1);
468	bitContent <<= startbit;
469	dataword = packedword & bitContent;
470	dataword >>= startbit;
471
472	}
473	//____________________________________________________________________________
474