[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 <TString.h>
#include <TSystem.h>

#include "AliLog.h"
#include "AliRawDataHeader.h"
#include "AliBitPacking.h"
#include "AliPMDdigit.h"
#include "AliPMDRawStream.h"
#include "AliPMDDDLRawData.h"
#include "AliDAQ.h"

ClassImp(AliPMDDDLRawData)

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

}
//____________________________________________________________________________

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

}

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

  ofstream outfile;

  TBranch *branch = treeD->GetBranch("PMDDigit");
  if (!branch)
    {
      AliError("PMD Digit branch not found");
      return;
    }
  branch->SetAddress(&fDigits);  
  
  Int_t   nmodules = (Int_t) treeD->GetEntries();
  AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));

  const Int_t kDDL          = AliDAQ::NumberOfDdls("PMD");
  Int_t modulePerDDL        = 0;


  AliRawDataHeader header;
  UInt_t sizeRawData = 0;
  
  const Int_t kSize = 1536;
  UInt_t buffer[kSize];

  UInt_t busPatch[50][1536];

  Int_t contentsBus[50];

  Char_t filename[80];


  Int_t mmodule = 0;
  for(Int_t iddl = 0; iddl < kDDL; iddl++)
    {
      strcpy(filename,AliDAQ::DdlFileName("PMD",iddl));
#ifndef __DECCXX
      outfile.open(filename,ios::binary);
#else
      outfile.open(filename);
#endif
      
      if (iddl < 4)
	{
	  modulePerDDL = 6;
	  mmodule = 6*iddl;
	}
      else if (iddl == 4)
	{
	  modulePerDDL = 12;
	  mmodule = 24;
	}
      else if (iddl == 5)
	{
	  modulePerDDL = 12;
	  mmodule = 30;
	}


      // Write the Dummy Data Header into the file
      Int_t bHPosition = outfile.tellp();
      outfile.write((char*)(&header),sizeof(header));

      for (Int_t ibus = 0; ibus < 50; ibus++)
	{
	  contentsBus[ibus] = 0;
	  for (Int_t ich = 0; ich < 1536; ich++)
	    {
	      busPatch[ibus][ich] = 0;
	    }
	}

      for(Int_t ium = 0; ium < modulePerDDL; ium++)
	{
	  if (iddl == 4 && ium == 6) mmodule = 42;

	  // 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, iddl, contentsBus, busPatch);
	  mmodule++;
	}

      
      Int_t ij = 0;
      Int_t dsp[10];
      Int_t dspBus[10];
      for (Int_t i = 0; i < 10; i++)
	{
	  dsp[i] = 0;
	  dspBus[i] = 0;
	  for (Int_t ibus=0; ibus < 5; ibus++)
	    {
	      if (contentsBus[ij] > 0)
		{
		  dsp[i] += contentsBus[ij];
		  dspBus[i]++;
		}
	      ij++;
	    }
	  // Add the patch Bus header to the DSP contents
	  dsp[i] += 4*dspBus[i];
	}

      Int_t dspBlockARDL = 0;
      Int_t dspBlockBRDL = 0;
      
      for (Int_t i = 0; i < 5; i++)
	{
	  Int_t ieven = 2*i;
	  Int_t iodd  = 2*i + 1;
	  if (dsp[ieven] > 0)
	    {
	      dspBlockARDL += dsp[ieven];
	      dspBlockARDL += 8;
	    }
	  if (dsp[iodd] > 0)
	    {
	      dspBlockBRDL += dsp[iodd];
	      dspBlockBRDL += 8;
	    }
	}
      
      // Start writing the DDL file
      UInt_t dspRDL = 0;
      UInt_t dspBlockHeader[8];
      UInt_t dspHeader[8];
      UInt_t patchBusHeader[4];
      Int_t iskip[5];

      for (Int_t iblock = 0; iblock < 2; iblock++)
	{
	  // DSP Block Header
	  
	  for (Int_t i=0; i<8; i++)
	    {
	      dspBlockHeader[i] = 0;
	      if (i == 1)
		{
		  if (iblock == 0)
		    {
		      dspBlockHeader[1] = (UInt_t) dspBlockARDL;
		    }
		  else if (iblock == 1)
		    {
		      dspBlockHeader[1] = (UInt_t) dspBlockBRDL;
		    }
		}
	    }

	  outfile.write((char*)(&dspBlockHeader),8*sizeof(UInt_t));

	  if (iblock == 0)
	    {
	      iskip[0] = 0;
	      iskip[1] = 10;
	      iskip[2] = 20;
	      iskip[3] = 30;
	      iskip[4] = 40;
	    }
	  else if (iblock == 1)
	    {
	      iskip[0] = 5;
	      iskip[1] = 15;
	      iskip[2] = 25;
	      iskip[3] = 35;
	      iskip[4] = 45;
	    }

	  for (Int_t idsp = 0; idsp < 5; idsp++)
	    {
	      // DSP Header
	      Int_t dspno = 0;
	      if (iblock == 0)
		{
		  dspno = 2*idsp;
		  dspRDL = (UInt_t) dsp[dspno];
		}
	      else if (iblock == 1)
		{
		  dspno = 2*idsp + 1;
		  dspRDL = (UInt_t) dsp[dspno];
		}

	      for (Int_t i=0; i<8; i++)
		{
		  dspHeader[i] = 0;
		}
	      dspHeader[1] = dspRDL;
	      dspHeader[6] = dspno;
	      outfile.write((char*)(&dspHeader),8*sizeof(UInt_t));
	      
	      for (Int_t ibus = 0; ibus < 5; ibus++)
		{
		  // Patch Bus Header
		  Int_t busno = iskip[idsp] + ibus;
		  Int_t patchbusRDL = contentsBus[busno];
		  
		  for (Int_t i=0; i<4; i++)
		    {
		      patchBusHeader[i] = 0;
		    }
		  patchBusHeader[1] = (UInt_t) patchbusRDL;
		  patchBusHeader[2] = (UInt_t) busno;

		  outfile.write((char*)(&patchBusHeader),4*sizeof(UInt_t));

		  for (Int_t iword = 0; iword < patchbusRDL; iword++)
		    {
		      buffer[iword] = busPatch[busno][iword];
		    }
		  
		  outfile.write((char*)buffer,patchbusRDL*sizeof(UInt_t));
		  
		}
	    }
	}
      
      
      // Write real data header
      // take the pointer to the beginning of the data 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 - sizeof(header);

      header.fSize = cFPosition - bHPosition;
      header.SetAttribute(0);  // valid data
      outfile.seekp(bHPosition);
      outfile.write((char*)(&header),sizeof(header));
      outfile.seekp(cFPosition);

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


}
//____________________________________________________________________________
void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
				       Int_t ddlno, Int_t *contentsBus,
				       UInt_t busPatch[][1536])
{
  // Retrives digits data UnitModule by UnitModule
  UInt_t baseword;
  UInt_t mcmno, chno;
  UInt_t adc;
  Int_t  det, smn, irow, icol;

  const Int_t kMaxBus = 50;
  Int_t totPatchBus, bPatchBus, ePatchBus;
  Int_t ibus, totmcm, rows, cols, rowe, cole;
  Int_t moduleno;
  Int_t busno = 0;
  Int_t patchBusNo[kMaxBus], mcmperBus[kMaxBus];
  Int_t startRowBus[kMaxBus], startColBus[kMaxBus];
  Int_t endRowBus[kMaxBus], endColBus[kMaxBus];

  Int_t beginPatchBus = -1;
  Int_t endPatchBus   = -1;
  for(Int_t i = 0; i < kMaxBus; i++)
    {
      patchBusNo[i]  = -1;
      mcmperBus[i]   = -1;
      startRowBus[i] = -1;
      startColBus[i] = -1;
      endRowBus[i]   = -1;
      endColBus[i]   = -1;
    }
  Int_t modulePerDDL = 0;
  if (ddlno < 4)
    {
      modulePerDDL = 6;
    }
  else if (ddlno == 4 || ddlno == 5)
    {
      modulePerDDL = 12;
    }


  TString fileName(gSystem->Getenv("ALICE_ROOT"));

  if(ddlno == 0)
    {
      fileName += "/PMD/PMD_Mapping_ddl0.dat";
    }
  else if(ddlno == 1)
    {
      fileName += "/PMD/PMD_Mapping_ddl1.dat";
    }
  else if(ddlno == 2)
    {
      fileName += "/PMD/PMD_Mapping_ddl2.dat";
    }
  else if(ddlno == 3)
    {
      fileName += "/PMD/PMD_Mapping_ddl3.dat";
    }
  else if(ddlno == 4)
    {
      fileName += "/PMD/PMD_Mapping_ddl4.dat";
    }
  else if(ddlno == 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",ddlno));

  for (Int_t im = 0; im < modulePerDDL; im++)
    {
      infile >> moduleno;
      infile >> totPatchBus >> bPatchBus >> ePatchBus;

      if (moduleno == imodule)
	{
	  beginPatchBus = bPatchBus;
	  endPatchBus   = ePatchBus;
	}
      
      for(Int_t i=0; i<totPatchBus; i++)
	{
	  infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;

	  if (moduleno == imodule)
	    {
	      patchBusNo[ibus]   = ibus;
	      mcmperBus[ibus]    = totmcm;
	      startRowBus[ibus]  = rows;
	      startColBus[ibus]  = cols;
	      endRowBus[ibus]    = rowe;
	      endColBus[ibus]    = cole;
	    }
	}

    }

  infile.close();

  treeD->GetEntry(imodule); 
  Int_t nentries = fDigits->GetLast();
  Int_t 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();

      TransformS2H(smn,irow,icol);

      GetMCMCh(ddlno, irow, icol, beginPatchBus, endPatchBus,
	       mcmperBus, startRowBus, startColBus,
	       endRowBus, endColBus, busno, mcmno, chno);

      baseword = 0;
      AliBitPacking::PackWord(adc,baseword,0,11);
      AliBitPacking::PackWord(chno,baseword,12,17);
      AliBitPacking::PackWord(mcmno,baseword,18,28);
      AliBitPacking::PackWord(0,baseword,29,30);
      AliBitPacking::PackWord(1,baseword,31,31);

      Int_t jj = contentsBus[busno];
      busPatch[busno][jj] = baseword;

      contentsBus[busno]++;
    }

}

//____________________________________________________________________________
void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
{
  // Does the Software to Hardware coordinate transformation
  //

  Int_t  irownew = 0;
  Int_t  icolnew = 0;

  // First in digits we have all dimension 48x96
  // Transform into the realistic one, i.e, For SM 0&1 96(row)x48(col)
  // and for SM 2&3 48(row)x96(col)
  // 
  if(smn < 12)
    {
      irownew = icol;
      icolnew = irow;
    }
  else if( smn >= 12 && smn < 24)
    {
      irownew = irow;
      icolnew = icol;
    }

  // In the new geometry always Geant (0,0) and Hardware (0,0) start
  // from the top left corner

  irow = irownew;
  icol = icolnew;

}


//____________________________________________________________________________

void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t row, Int_t col,
				Int_t beginPatchBus, Int_t endPatchBus,
				Int_t *mcmperBus,
				Int_t *startRowBus, Int_t *startColBus,
				Int_t *endRowBus, Int_t *endColBus,
				Int_t & busno, 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

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


  for (Int_t ibus = beginPatchBus; ibus <= endPatchBus; ibus++)
    {
      Int_t srow = startRowBus[ibus];
      Int_t erow = endRowBus[ibus];
      Int_t scol = startColBus[ibus];
      Int_t ecol = endColBus[ibus];
      Int_t tmcm = mcmperBus[ibus];
      if ((row >= srow && row <= erow) && (col >= scol && col <= ecol))
	{
	  busno = ibus;

	  // Find out the MCM Number
	  //

	  if (ddlno == 0 || ddlno == 1)
	    {
	      // PRE plane, SU Mod = 0, 1
	      Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
	      if(rowdiff > 16)
		{
		  Int_t midrow = srow + 16;
		  if(row >= srow && row < midrow)
		    {
		      mcmno = 12 + (col-scol)/4;
		    }
		  else if(row >= midrow && row < erow)
		    {
		      mcmno = (col-scol)/4;
		    }
		}
	      else
		{
		  mcmno = (col-scol)/4;
		}
	    } // end of ddl 0 and 1
	  else if (ddlno == 2)
	    {
	      // PRE plane,  SU Mod = 2
	      
	      Int_t icolnew = (col - scol)/4;
	      mcmno = tmcm - 1 - icolnew;
	    }
	  else if (ddlno == 3)
	    {
	      // PRE plane,  SU Mod = 3
	      
	      Int_t icolnew = (col - scol)/4;
	      mcmno = tmcm - 1 - icolnew;
	    }
	  else if (ddlno == 4)
	    {
	      // CPV plane,  SU Mod = 0, 3 : ddl = 4
	      
	      if(ibus <= 20)
		{
		  Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
		  if(rowdiff > 16)
		    {
		      Int_t midrow = srow + 16;
		      if(row >= srow && row < midrow)
			{
			  mcmno = 12 + (col-scol)/4;
			}
		      else if(row >= midrow && row < erow)
			{
			  mcmno = (col-scol)/4;
			}
		    }
		  else
		    {
		      mcmno = (col-scol)/4;
		    }
		}
	      else if (ibus > 20)
		{
		  Int_t icolnew = (col - scol)/4;
		  mcmno = tmcm - 1 - icolnew;
		}
	    }
	  else if (ddlno == 5)
	    {
	      // CPV plane,  SU Mod = 2, 1 : ddl = 5
	      
	      if(ibus <= 20)
		{
		  Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
		  if(rowdiff > 16)
		    {
		      Int_t midrow = srow + 16;
		      if(row >= srow && row < midrow)
			{
			  mcmno = 12 + (col-scol)/4;
			}
		      else if(row >= midrow && row < erow)
			{
			  mcmno = (col-scol)/4;
			}
		    }
		  else
		    {
		      mcmno = (col-scol)/4;
		    }
		}
	      else if (ibus > 20)
		{
		  Int_t icolnew = (col - scol)/4;
		  mcmno = tmcm - 1 - icolnew;
		}
	    }
	}  
    }
  
}
//____________________________________________________________________________
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>
95ec17e6	21	#include <TString.h>
95ec17e6	22	#include <TSystem.h>
28328eeb	23
ecee2a1a	24	#include "AliLog.h"
a4e4efaa	25	#include "AliRawDataHeader.h"
cff75ba7	26	#include "AliBitPacking.h"
28328eeb	27	#include "AliPMDdigit.h"
a4e4efaa	28	#include "AliPMDRawStream.h"
28328eeb	29	#include "AliPMDDDLRawData.h"
362c9d61	30	#include "AliDAQ.h"
28328eeb	31
	32	ClassImp(AliPMDDDLRawData)
	33
	34	AliPMDDDLRawData::AliPMDDDLRawData():
	35	fDigits(new TClonesArray("AliPMDdigit", 1000))
	36	{
	37	// Default Constructor
	38	//
a4e4efaa	39
28328eeb	40	}
	41	//____________________________________________________________________________
	42
	43	AliPMDDDLRawData::~AliPMDDDLRawData()
	44	{
	45	// Default Destructor
	46	//
	47
	48	}
	49
	50	//____________________________________________________________________________
a4e4efaa	51	void AliPMDDDLRawData::WritePMDRawData(TTree *treeD)
28328eeb	52	{
	53	// write digits into raw data format
	54
	55	ofstream outfile;
	56
	57	TBranch *branch = treeD->GetBranch("PMDDigit");
ecee2a1a	58	if (!branch)
	59	{
	60	AliError("PMD Digit branch not found");
	61	return;
	62	}
28328eeb	63	branch->SetAddress(&fDigits);
28328eeb	64
ecee2a1a	65	Int_t nmodules = (Int_t) treeD->GetEntries();
ecee2a1a	66	AliDebug(1,Form("Number of modules inside treeD = %d",nmodules));
28328eeb	67
362c9d61	68	const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
28328eeb	69	Int_t modulePerDDL = 0;
	70
	71
a4e4efaa	72	AliRawDataHeader header;
28328eeb	73	UInt_t sizeRawData = 0;
95ec17e6	74
95ec17e6	75	const Int_t kSize = 1536;
28328eeb	76	UInt_t buffer[kSize];
28328eeb	77
95ec17e6	78	UInt_t busPatch[50][1536];
	79
	80	Int_t contentsBus[50];
	81
28328eeb	82	Char_t filename[80];
28328eeb	83
95ec17e6	84
28328eeb	85	Int_t mmodule = 0;
	86	for(Int_t iddl = 0; iddl < kDDL; iddl++)
	87	{
362c9d61	88	strcpy(filename,AliDAQ::DdlFileName("PMD",iddl));
28328eeb	89	#ifndef __DECCXX
	90	outfile.open(filename,ios::binary);
	91	#else
	92	outfile.open(filename);
	93	#endif
	94
	95	if (iddl < 4)
	96	{
	97	modulePerDDL = 6;
	98	mmodule = 6*iddl;
28328eeb	99	}
	100	else if (iddl == 4)
	101	{
	102	modulePerDDL = 12;
	103	mmodule = 24;
28328eeb	104	}
	105	else if (iddl == 5)
	106	{
	107	modulePerDDL = 12;
a4e4efaa	108	mmodule = 30;
28328eeb	109	}
28328eeb	110
28328eeb	111
95ec17e6	112
a4e4efaa	113	// Write the Dummy Data Header into the file
28328eeb	114	Int_t bHPosition = outfile.tellp();
a4e4efaa	115	outfile.write((char*)(&header),sizeof(header));
28328eeb	116
95ec17e6	117	for (Int_t ibus = 0; ibus < 50; ibus++)
	118	{
	119	contentsBus[ibus] = 0;
	120	for (Int_t ich = 0; ich < 1536; ich++)
	121	{
	122	busPatch[ibus][ich] = 0;
	123	}
	124	}
28328eeb	125
	126	for(Int_t ium = 0; ium < modulePerDDL; ium++)
	127	{
95ec17e6	128	if (iddl == 4 && ium == 6) mmodule = 42;
a4e4efaa	129
28328eeb	130	// Extract energy deposition per cell and pack it
	131	// in a 32-bit word and returns all the total words
	132	// per one unit-module
	133
95ec17e6	134	GetUMDigitsData(treeD, mmodule, iddl, contentsBus, busPatch);
28328eeb	135	mmodule++;
95ec17e6	136	}
28328eeb	137
95ec17e6	138
	139
	140	Int_t ij = 0;
	141	Int_t dsp[10];
	142	Int_t dspBus[10];
	143	for (Int_t i = 0; i < 10; i++)
	144	{
	145	dsp[i] = 0;
	146	dspBus[i] = 0;
	147	for (Int_t ibus=0; ibus < 5; ibus++)
	148	{
	149	if (contentsBus[ij] > 0)
	150	{
	151	dsp[i] += contentsBus[ij];
	152	dspBus[i]++;
	153	}
	154	ij++;
	155	}
	156	// Add the patch Bus header to the DSP contents
	157	dsp[i] += 4*dspBus[i];
	158	}
	159
	160	Int_t dspBlockARDL = 0;
	161	Int_t dspBlockBRDL = 0;
	162
	163	for (Int_t i = 0; i < 5; i++)
	164	{
	165	Int_t ieven = 2*i;
	166	Int_t iodd = 2*i + 1;
	167	if (dsp[ieven] > 0)
	168	{
	169	dspBlockARDL += dsp[ieven];
	170	dspBlockARDL += 8;
	171	}
	172	if (dsp[iodd] > 0)
	173	{
	174	dspBlockBRDL += dsp[iodd];
	175	dspBlockBRDL += 8;
	176	}
28328eeb	177	}
95ec17e6	178
	179	// Start writing the DDL file
	180	UInt_t dspRDL = 0;
	181	UInt_t dspBlockHeader[8];
	182	UInt_t dspHeader[8];
	183	UInt_t patchBusHeader[4];
	184	Int_t iskip[5];
	185
	186	for (Int_t iblock = 0; iblock < 2; iblock++)
	187	{
	188	// DSP Block Header
	189
	190	for (Int_t i=0; i<8; i++)
	191	{
	192	dspBlockHeader[i] = 0;
	193	if (i == 1)
	194	{
	195	if (iblock == 0)
	196	{
	197	dspBlockHeader[1] = (UInt_t) dspBlockARDL;
	198	}
	199	else if (iblock == 1)
	200	{
	201	dspBlockHeader[1] = (UInt_t) dspBlockBRDL;
	202	}
	203	}
	204	}
	205
	206	outfile.write((char)(&dspBlockHeader),8sizeof(UInt_t));
	207
	208	if (iblock == 0)
	209	{
	210	iskip[0] = 0;
	211	iskip[1] = 10;
	212	iskip[2] = 20;
	213	iskip[3] = 30;
	214	iskip[4] = 40;
	215	}
	216	else if (iblock == 1)
	217	{
	218	iskip[0] = 5;
	219	iskip[1] = 15;
	220	iskip[2] = 25;
	221	iskip[3] = 35;
	222	iskip[4] = 45;
	223	}
28328eeb	224
95ec17e6	225	for (Int_t idsp = 0; idsp < 5; idsp++)
	226	{
	227	// DSP Header
	228	Int_t dspno = 0;
	229	if (iblock == 0)
	230	{
	231	dspno = 2*idsp;
	232	dspRDL = (UInt_t) dsp[dspno];
	233	}
	234	else if (iblock == 1)
	235	{
	236	dspno = 2*idsp + 1;
	237	dspRDL = (UInt_t) dsp[dspno];
	238	}
	239
	240	for (Int_t i=0; i<8; i++)
	241	{
	242	dspHeader[i] = 0;
	243	}
	244	dspHeader[1] = dspRDL;
	245	dspHeader[6] = dspno;
	246	outfile.write((char)(&dspHeader),8sizeof(UInt_t));
	247
	248	for (Int_t ibus = 0; ibus < 5; ibus++)
	249	{
	250	// Patch Bus Header
	251	Int_t busno = iskip[idsp] + ibus;
	252	Int_t patchbusRDL = contentsBus[busno];
	253
	254	for (Int_t i=0; i<4; i++)
	255	{
	256	patchBusHeader[i] = 0;
	257	}
	258	patchBusHeader[1] = (UInt_t) patchbusRDL;
	259	patchBusHeader[2] = (UInt_t) busno;
	260
	261	outfile.write((char)(&patchBusHeader),4sizeof(UInt_t));
	262
	263	for (Int_t iword = 0; iword < patchbusRDL; iword++)
	264	{
	265	buffer[iword] = busPatch[busno][iword];
	266	}
	267
	268	outfile.write((char)buffer,patchbusRDLsizeof(UInt_t));
	269
	270	}
	271	}
	272	}
	273
	274
a4e4efaa	275	// Write real data header
a4e4efaa	276	// take the pointer to the beginning of the data header
28328eeb	277	// write the total number of words per ddl and bring the
	278	// pointer to the current file position and close it
	279	UInt_t cFPosition = outfile.tellp();
a4e4efaa	280	sizeRawData = cFPosition - bHPosition - sizeof(header);
95ec17e6	281
a4e4efaa	282	header.fSize = cFPosition - bHPosition;
a4e4efaa	283	header.SetAttribute(0); // valid data
28328eeb	284	outfile.seekp(bHPosition);
a4e4efaa	285	outfile.write((char*)(&header),sizeof(header));
28328eeb	286	outfile.seekp(cFPosition);
	287
	288	outfile.close();
	289	} // DDL Loop over
	290
	291
	292	}
	293	//____________________________________________________________________________
95ec17e6	294	void AliPMDDDLRawData::GetUMDigitsData(TTree *treeD, Int_t imodule,
	295	Int_t ddlno, Int_t *contentsBus,
	296	UInt_t busPatch[][1536])
28328eeb	297	{
e54787da	298	// Retrives digits data UnitModule by UnitModule
cff75ba7	299	UInt_t baseword;
28328eeb	300	UInt_t mcmno, chno;
28328eeb	301	UInt_t adc;
28328eeb	302	Int_t det, smn, irow, icol;
28328eeb	303
95ec17e6	304	const Int_t kMaxBus = 50;
	305	Int_t totPatchBus, bPatchBus, ePatchBus;
	306	Int_t ibus, totmcm, rows, cols, rowe, cole;
	307	Int_t moduleno;
	308	Int_t busno = 0;
	309	Int_t patchBusNo[kMaxBus], mcmperBus[kMaxBus];
	310	Int_t startRowBus[kMaxBus], startColBus[kMaxBus];
	311	Int_t endRowBus[kMaxBus], endColBus[kMaxBus];
	312
	313	Int_t beginPatchBus = -1;
	314	Int_t endPatchBus = -1;
	315	for(Int_t i = 0; i < kMaxBus; i++)
	316	{
	317	patchBusNo[i] = -1;
	318	mcmperBus[i] = -1;
	319	startRowBus[i] = -1;
	320	startColBus[i] = -1;
	321	endRowBus[i] = -1;
	322	endColBus[i] = -1;
	323	}
	324	Int_t modulePerDDL = 0;
	325	if (ddlno < 4)
	326	{
	327	modulePerDDL = 6;
	328	}
	329	else if (ddlno == 4 \|\| ddlno == 5)
	330	{
	331	modulePerDDL = 12;
	332	}
	333
	334
	335
	336
	337
	338	TString fileName(gSystem->Getenv("ALICE_ROOT"));
	339
	340	if(ddlno == 0)
	341	{
	342	fileName += "/PMD/PMD_Mapping_ddl0.dat";
	343	}
	344	else if(ddlno == 1)
	345	{
	346	fileName += "/PMD/PMD_Mapping_ddl1.dat";
	347	}
	348	else if(ddlno == 2)
	349	{
	350	fileName += "/PMD/PMD_Mapping_ddl2.dat";
	351	}
	352	else if(ddlno == 3)
	353	{
	354	fileName += "/PMD/PMD_Mapping_ddl3.dat";
	355	}
	356	else if(ddlno == 4)
	357	{
	358	fileName += "/PMD/PMD_Mapping_ddl4.dat";
	359	}
	360	else if(ddlno == 5)
	361	{
	362	fileName += "/PMD/PMD_Mapping_ddl5.dat";
	363	}
	364
	365	ifstream infile;
	366	infile.open(fileName.Data(), ios::in); // ascii file
	367	if(!infile)
368	AliError(Form("Could not read the mapping file for DDL No = %d",ddlno));
369
370	for (Int_t im = 0; im < modulePerDDL; im++)
371	{
372	infile >> moduleno;
373	infile >> totPatchBus >> bPatchBus >> ePatchBus;
374
375	if (moduleno == imodule)
376	{
377	beginPatchBus = bPatchBus;
378	endPatchBus = ePatchBus;
379	}
380
381	for(Int_t i=0; i<totPatchBus; i++)
382	{
383	infile >> ibus >> totmcm >> rows >> rowe >> cols >> cole;
384
385	if (moduleno == imodule)
386	{
387	patchBusNo[ibus] = ibus;
388	mcmperBus[ibus] = totmcm;
389	startRowBus[ibus] = rows;
390	startColBus[ibus] = cols;
391	endRowBus[ibus] = rowe;
392	endColBus[ibus] = cole;
393	}
394	}
395
396	}
397
398	infile.close();
399
28328eeb	400	treeD->GetEntry(imodule);
28328eeb	401	Int_t nentries = fDigits->GetLast();
95ec17e6	402	Int_t totword = nentries+1;
28328eeb	403
	404	for (Int_t ient = 0; ient < totword; ient++)
	405	{
	406	fPMDdigit = (AliPMDdigit*)fDigits->UncheckedAt(ient);
	407
	408	det = fPMDdigit->GetDetector();
	409	smn = fPMDdigit->GetSMNumber();
	410	irow = fPMDdigit->GetRow();
	411	icol = fPMDdigit->GetColumn();
	412	adc = (UInt_t) fPMDdigit->GetADC();
	413
e54787da	414	TransformS2H(smn,irow,icol);
95ec17e6	415
	416	GetMCMCh(ddlno, irow, icol, beginPatchBus, endPatchBus,
	417	mcmperBus, startRowBus, startColBus,
	418	endRowBus, endColBus, busno, mcmno, chno);
28328eeb	419
28328eeb	420	baseword = 0;
cff75ba7	421	AliBitPacking::PackWord(adc,baseword,0,11);
	422	AliBitPacking::PackWord(chno,baseword,12,17);
	423	AliBitPacking::PackWord(mcmno,baseword,18,28);
	424	AliBitPacking::PackWord(0,baseword,29,30);
	425	AliBitPacking::PackWord(1,baseword,31,31);
95ec17e6	426
	427	Int_t jj = contentsBus[busno];
	428	busPatch[busno][jj] = baseword;
	429
	430	contentsBus[busno]++;
28328eeb	431	}
28328eeb	432
e54787da	433	}
95ec17e6	434
e54787da	435	//____________________________________________________________________________
	436	void AliPMDDDLRawData::TransformS2H(Int_t smn, Int_t &irow, Int_t &icol)
	437	{
	438	// Does the Software to Hardware coordinate transformation
	439	//
95ec17e6	440
e54787da	441	Int_t irownew = 0;
e54787da	442	Int_t icolnew = 0;
e54787da	443
e54787da	444	// First in digits we have all dimension 48x96
95ec17e6	445	// Transform into the realistic one, i.e, For SM 0&1 96(row)x48(col)
95ec17e6	446	// and for SM 2&3 48(row)x96(col)
e54787da	447	//
	448	if(smn < 12)
	449	{
95ec17e6	450	irownew = icol;
95ec17e6	451	icolnew = irow;
e54787da	452	}
	453	else if( smn >= 12 && smn < 24)
	454	{
95ec17e6	455	irownew = irow;
95ec17e6	456	icolnew = icol;
e54787da	457	}
e54787da	458
95ec17e6	459	// In the new geometry always Geant (0,0) and Hardware (0,0) start
	460	// from the top left corner
	461
e54787da	462	irow = irownew;
e54787da	463	icol = icolnew;
28328eeb	464
28328eeb	465	}
e54787da	466
e54787da	467
28328eeb	468	//____________________________________________________________________________
e54787da	469
95ec17e6	470	void AliPMDDDLRawData::GetMCMCh(Int_t ddlno, Int_t row, Int_t col,
	471	Int_t beginPatchBus, Int_t endPatchBus,
	472	Int_t *mcmperBus,
	473	Int_t startRowBus, Int_t startColBus,
	474	Int_t endRowBus, Int_t endColBus,
	475	Int_t & busno, UInt_t &mcmno, UInt_t &chno)
28328eeb	476	{
	477	// This part will be modified once the final track layout on the PCB is
	478	// designed. This will only change the coordinate of the individual cell
a4e4efaa	479
	480	static const UInt_t kCh[16][4] = { {12, 13, 18, 19},
	481	{11, 15, 17, 21},
	482	{10, 14, 16, 22},
	483	{8, 9, 20, 23},
	484	{7, 4, 25, 24},
	485	{6, 0, 30, 26},
	486	{5, 1, 31, 27},
	487	{3, 2, 29, 28},
	488	{44, 45, 50, 51},
	489	{43, 47, 49, 53},
	490	{42, 46, 48, 54},
	491	{40, 41, 52, 55},
	492	{39, 36, 57, 56},
	493	{38, 32, 62, 58},
	494	{37, 33, 63, 59},
	495	{35, 34, 61, 60} };
28328eeb	496
95ec17e6	497	Int_t irownew = row%16;
	498	Int_t icolnew = col%4;
	499
	500	chno = kCh[irownew][icolnew];
28328eeb	501
28328eeb	502
95ec17e6	503	for (Int_t ibus = beginPatchBus; ibus <= endPatchBus; ibus++)
	504	{
	505	Int_t srow = startRowBus[ibus];
	506	Int_t erow = endRowBus[ibus];
	507	Int_t scol = startColBus[ibus];
	508	Int_t ecol = endColBus[ibus];
	509	Int_t tmcm = mcmperBus[ibus];
	510	if ((row >= srow && row <= erow) && (col >= scol && col <= ecol))
a4e4efaa	511	{
95ec17e6	512	busno = ibus;
28328eeb	513
95ec17e6	514	// Find out the MCM Number
	515	//
	516
	517	if (ddlno == 0 \|\| ddlno == 1)
	518	{
	519	// PRE plane, SU Mod = 0, 1
	520	Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
	521	if(rowdiff > 16)
	522	{
	523	Int_t midrow = srow + 16;
	524	if(row >= srow && row < midrow)
	525	{
	526	mcmno = 12 + (col-scol)/4;
	527	}
	528	else if(row >= midrow && row < erow)
	529	{
	530	mcmno = (col-scol)/4;
	531	}
	532	}
	533	else
	534	{
	535	mcmno = (col-scol)/4;
	536	}
	537	} // end of ddl 0 and 1
	538	else if (ddlno == 2)
	539	{
	540	// PRE plane, SU Mod = 2
	541
	542	Int_t icolnew = (col - scol)/4;
	543	mcmno = tmcm - 1 - icolnew;
	544	}
	545	else if (ddlno == 3)
	546	{
	547	// PRE plane, SU Mod = 3
	548
	549	Int_t icolnew = (col - scol)/4;
	550	mcmno = tmcm - 1 - icolnew;
	551	}
	552	else if (ddlno == 4)
	553	{
	554	// CPV plane, SU Mod = 0, 3 : ddl = 4
	555
	556	if(ibus <= 20)
	557	{
	558	Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
	559	if(rowdiff > 16)
	560	{
	561	Int_t midrow = srow + 16;
	562	if(row >= srow && row < midrow)
	563	{
	564	mcmno = 12 + (col-scol)/4;
	565	}
	566	else if(row >= midrow && row < erow)
	567	{
	568	mcmno = (col-scol)/4;
	569	}
	570	}
	571	else
	572	{
	573	mcmno = (col-scol)/4;
	574	}
	575	}
	576	else if (ibus > 20)
	577	{
578	Int_t icolnew = (col - scol)/4;
579	mcmno = tmcm - 1 - icolnew;
580	}
581	}
582	else if (ddlno == 5)
583	{
584	// CPV plane, SU Mod = 2, 1 : ddl = 5
585
586	if(ibus <= 20)
587	{
588	Int_t rowdiff = endRowBus[ibus] - startRowBus[ibus];
589	if(rowdiff > 16)
590	{
591	Int_t midrow = srow + 16;
592	if(row >= srow && row < midrow)
593	{
594	mcmno = 12 + (col-scol)/4;
595	}
596	else if(row >= midrow && row < erow)
597	{
598	mcmno = (col-scol)/4;
599	}
600	}
601	else
602	{
603	mcmno = (col-scol)/4;
604	}
605	}
606	else if (ibus > 20)
607	{
608	Int_t icolnew = (col - scol)/4;
609	mcmno = tmcm - 1 - icolnew;
610	}
611	}
612	}
613	}
614
28328eeb	615	}
	616	//____________________________________________________________________________
	617