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

//-----------------------------------------------------//
//                                                     //
//           Date   : October 09 2006                  //
//       converts raw to sdigit and digit              //
//                                                     //
//-----------------------------------------------------//

#include <Riostream.h>
#include <TTree.h>
#include <TObjArray.h>
#include <TClonesArray.h>

#include "AliDAQ.h"
#include "AliLog.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliRawReader.h"

#include "AliPMDsdigit.h"
#include "AliPMDdigit.h"
#include "AliPMDRawToSDigits.h"
#include "AliPMDRawStream.h"
#include "AliPMDddldata.h"


ClassImp(AliPMDRawToSDigits)

AliPMDRawToSDigits::AliPMDRawToSDigits():
  fSDigits(new TClonesArray("AliPMDsdigit", 1000)),
  fDigits(new TClonesArray("AliPMDdigit", 1000)),
  fNsdigit(0),
  fNdigit(0)
{
  //
// Constructor
//

}
// ------------------------------------------------------------------------- //
AliPMDRawToSDigits::AliPMDRawToSDigits(const AliPMDRawToSDigits & /*pmdr2sd*/):
  TObject(/* pmdr2sd */),
  fSDigits(NULL),
  fDigits(NULL),
  fNsdigit(0),
  fNdigit(0)
{
  // copy constructor
  AliFatal("Copy constructor not implemented");
}
// ------------------------------------------------------------------------- //


AliPMDRawToSDigits &AliPMDRawToSDigits::operator=(const AliPMDRawToSDigits &/* pmdr2sd */)
{
  // assignment operator
  AliFatal("Assignment operator not implemented");
  return *this;
}

// ------------------------------------------------------------------------- //

AliPMDRawToSDigits::~AliPMDRawToSDigits()
{
  // Destructor
  if (fSDigits)
    {
      fSDigits->Delete();
      delete fSDigits;
      fSDigits=0;
    }
  if (fDigits)
    {
      fDigits->Delete();
      delete fDigits;
      fDigits=0;
    }

}
// ------------------------------------------------------------------------- //

void AliPMDRawToSDigits::Raw2SDigits(AliRunLoader *runLoader, AliRawReader *rawReader)
{
  // Converts RAW data to sdigits
  //
  TObjArray pmdddlcont;
  AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
  
  TTree* treeS = pmdLoader->TreeS();
  if (treeS == 0x0)
    {
      pmdLoader->MakeTree("S");
      treeS = pmdLoader->TreeS();
    }
  Int_t bufsize = 16000;
  if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
  treeS->Branch("PMDSDigit", &fSDigits, bufsize); 

  const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
  const Int_t kRow = 48;
  const Int_t kCol = 96;
  const Int_t kSMN = 48;

  Int_t idet = 0;
  Int_t indexsmn = 0;
  Int_t ismn = 0;
  
  Int_t ***precpvADC;
  precpvADC = new int **[kSMN];
  for (Int_t i=0; i<kSMN; i++) precpvADC[i] = new int *[kRow];
  for (Int_t i=0; i<kSMN;i++)
    {
      for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
    }
  for (Int_t i = 0; i < kSMN; i++)
    {
      for (Int_t j = 0; j < kRow; j++)
	{
	  for (Int_t k = 0; k < kCol; k++)
	    {
	      precpvADC[i][j][k] = 0;
	    }
	}
    }
  
  for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
    {

      rawReader->Reset();
      AliPMDRawStream pmdinput(rawReader);
      rawReader->Select("PMD", indexDDL, indexDDL);
      
      pmdinput.DdlData(indexDDL,&pmdddlcont);
      
      Int_t ientries = pmdddlcont.GetEntries();
      for (Int_t ient = 0; ient < ientries; ient++)
	{
	  AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
	  
	  Int_t det = pmdddl->GetDetector();
	  Int_t smn = pmdddl->GetSMN();
	  //Int_t mcm = pmdddl->GetMCM();
	  //Int_t chno = pmdddl->GetChannel();
	  Int_t row = pmdddl->GetRow();
	  Int_t col = pmdddl->GetColumn();
	  Int_t sig = pmdddl->GetSignal();
	  
	  if (indexDDL < 4)
	    {
	      if (det != 0)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      indexsmn = smn;
	    }
	  else if (indexDDL == 4 || indexDDL == 5)
	    {
	      if (det != 1)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      indexsmn = smn + 24;
	    }

	  precpvADC[indexsmn][row][col] = sig;
	}
      
      pmdddlcont.Clear();
      
    } // DDL Loop
      
  // Add the sdigits here
  
  for ( indexsmn = 0; indexsmn < kSMN; indexsmn++)
    {

      if (indexsmn < 23)
	{
	  idet = 0;
	  ismn = indexsmn;
	}
      else if (indexsmn > 23)
	{
	  idet = 0;
	  ismn = indexsmn - 24;
	}
      for (Int_t irow = 0; irow < kRow; irow++)
	{
	  for (Int_t icol = 0; icol < kCol; icol++)
	    {

	      Int_t trno = -99999;
	      Int_t sig1 = precpvADC[indexsmn][irow][icol];
	      
	      // plug in a function to convert to adc to MeV
	      Float_t edep = 0.;
	      if (sig1 > 0)
		{
		  AdcToMeV(sig1,edep);
		  AddSDigit(trno,idet,ismn,irow,icol,edep);
		}
	    } // row
	}     // col
      
      treeS->Fill();
      ResetSDigit();
    }

  pmdLoader->WriteSDigits("OVERWRITE");

  // Delete all the pointers
  
  for (Int_t i = 0; i < kSMN; i++)
    {
      for (Int_t j = 0; j < kRow; j++)
	{
	  delete [] precpvADC[i][j];
	}
    }
  for (Int_t j = 0; j < kSMN; j++)
    {
      delete [] precpvADC[j];
    }
  delete [] precpvADC;
  
}
// ------------------------------------------------------------------------- //
void AliPMDRawToSDigits::Raw2Digits(AliRunLoader *runLoader, AliRawReader *rawReader)
{
  // Converts RAW data to digits
  //
  TObjArray pmdddlcont;
  
  AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
  
  TTree* treeD = pmdLoader->TreeD();
  if (treeD == 0x0)
    {
      pmdLoader->MakeTree("D");
      treeD = pmdLoader->TreeD();
    }
  Int_t bufsize = 16000;
  if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
  treeD->Branch("PMDDigit", &fDigits, bufsize); 
  
  const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
  const Int_t kRow = 48;
  const Int_t kCol = 96;
  const Int_t kSMN = 48;
  
  Int_t idet = 0;
  Int_t ismn = 0;
  Int_t indexsmn = 0;
  
  Int_t ***precpvADC;
  precpvADC = new int **[kSMN];
  for (Int_t i=0; i<kSMN; i++) precpvADC[i] = new int *[kRow];
  for (Int_t i=0; i<kSMN;i++)
    {
      for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
    }
  for (Int_t i = 0; i < kSMN; i++)
    {
      for (Int_t j = 0; j < kRow; j++)
	{
	  for (Int_t k = 0; k < kCol; k++)
	    {
	      precpvADC[i][j][k] = 0;
	    }
	}
    }
  for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
    {    
      rawReader->Reset();
      AliPMDRawStream pmdinput(rawReader);
      rawReader->Select("PMD", indexDDL, indexDDL);
      
      //pmdinput.DdlData(&pmdddlcont);
      pmdinput.DdlData(indexDDL,&pmdddlcont);
      
      
      Int_t ientries = pmdddlcont.GetEntries();
      for (Int_t ient = 0; ient < ientries; ient++)
	{
	  AliPMDddldata *pmdddl = (AliPMDddldata*)pmdddlcont.UncheckedAt(ient);
	  
	  Int_t det = pmdddl->GetDetector();
	  Int_t smn = pmdddl->GetSMN();
	  //Int_t mcm = pmdddl->GetMCM();
	  //Int_t chno = pmdddl->GetChannel();
	  Int_t row = pmdddl->GetRow();
	  Int_t col = pmdddl->GetColumn();
	  Int_t sig = pmdddl->GetSignal();
	  
	  
	  if (indexDDL < 4)
	    {
	      if (det != 0)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      indexsmn = smn ;
	    }
	  else if (indexDDL == 4 || indexDDL == 5)
	    {
	      if (det != 1)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      indexsmn = smn + 24;
	    }	      
	  precpvADC[indexsmn][row][col] = sig;
	}
      
      pmdddlcont.Clear();
    } // DDL Loop  
      
  // Add the digits here
  for (indexsmn = 0; indexsmn < kSMN; indexsmn++)
    {
      if (indexsmn < 23)
	{
	  ismn = indexsmn;
	  idet = 0;
	}
      else if (indexsmn > 23)
	{
	  ismn = indexsmn -24;
	  idet = 1;
	}
      for (Int_t irow = 0; irow < kRow; irow++)
	{
	  for (Int_t icol = 0; icol < kCol; icol++)
	    {
	      Int_t trno = -99999;
	      Int_t sig1 = precpvADC[indexsmn][irow][icol];
	      
	      // plug in a function to convert to adc to MeV
	      if (sig1 > 0)
		{
		  AddDigit(trno,idet,ismn,irow,icol,sig1);
		}
	    } // row
	}     // col
      treeD->Fill();
      ResetDigit();
    }	  
  
  pmdLoader->WriteDigits("OVERWRITE");

  // Delete all the pointers

  for (Int_t i = 0; i < kSMN; i++)
    {
      for (Int_t j = 0; j < kRow; j++)
	{
	  delete [] precpvADC[i][j];
	}
    }
  for (Int_t j = 0; j < kSMN; j++)
    {
      delete [] precpvADC[j];
    }
  delete [] precpvADC;
}
// ------------------------------------------------------------------------- //

void AliPMDRawToSDigits::AdcToMeV(Int_t adc, Float_t &edep)
{
  // To be implemented, this is just for the test

  const Float_t kConstant   = 7.181;
  //  const Float_t kErConstant = 0.6899;
  const Float_t kSlope      = 35.93;
  //  const Float_t kErSlope    = 0.306;


  Float_t adc10bit = (Float_t) adc/4;
  edep     = (1000.0/kSlope)*(adc10bit - kConstant);
}

// ------------------------------------------------------------------------- //

void AliPMDRawToSDigits::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber, 
				   Int_t irow, Int_t icol, Float_t adc)
{
  // Add SDigit
  //
  if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
  TClonesArray &lsdigits = *fSDigits;
  new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,det,smnumber,irow,icol,adc);
}

// ------------------------------------------------------------------------- //
void AliPMDRawToSDigits::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber, 
				  Int_t irow, Int_t icol, Float_t adc)
{
  // Add Digit
  //
  if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
  TClonesArray &ldigits = *fDigits;
  new(ldigits[fNdigit++]) AliPMDdigit(trnumber,det,smnumber,irow,icol,adc);
}

// ------------------------------------------------------------------------- //
void AliPMDRawToSDigits::ResetSDigit()
{
  // Clears SDigits
  fNsdigit = 0;
  if (fSDigits) fSDigits->Clear();
}
// ------------------------------------------------------------------------- //
void AliPMDRawToSDigits::ResetDigit()
{
  // Clears SDigits
  fNdigit = 0;
  if (fDigits) fDigits->Clear();
}
Commit	Line	Data
1d9f57cc	1	/***************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	//-----------------------------------------------------//
	17	// //
	18	// Date : October 09 2006 //
	19	// converts raw to sdigit and digit //
	20	// //
	21	//-----------------------------------------------------//
	22
	23	#include <Riostream.h>
	24	#include <TTree.h>
	25	#include <TObjArray.h>
	26	#include <TClonesArray.h>
	27
	28	#include "AliDAQ.h"
	29	#include "AliLog.h"
	30	#include "AliRunLoader.h"
	31	#include "AliLoader.h"
	32	#include "AliRawReader.h"
	33
	34	#include "AliPMDsdigit.h"
	35	#include "AliPMDdigit.h"
	36	#include "AliPMDRawToSDigits.h"
	37	#include "AliPMDRawStream.h"
	38	#include "AliPMDddldata.h"
	39
	40
	41	ClassImp(AliPMDRawToSDigits)
	42
	43	AliPMDRawToSDigits::AliPMDRawToSDigits():
	44	fSDigits(new TClonesArray("AliPMDsdigit", 1000)),
	45	fDigits(new TClonesArray("AliPMDdigit", 1000)),
	46	fNsdigit(0),
	47	fNdigit(0)
	48	{
	49	//
	50	// Constructor
	51	//
	52
	53	}
	54	// ------------------------------------------------------------------------- //
	55	AliPMDRawToSDigits::AliPMDRawToSDigits(const AliPMDRawToSDigits & /pmdr2sd/):
	56	TObject(/* pmdr2sd */),
	57	fSDigits(NULL),
	58	fDigits(NULL),
	59	fNsdigit(0),
	60	fNdigit(0)
	61	{
	62	// copy constructor
	63	AliFatal("Copy constructor not implemented");
	64	}
65	// ------------------------------------------------------------------------- //
66
67
68	AliPMDRawToSDigits &AliPMDRawToSDigits::operator=(const AliPMDRawToSDigits &/* pmdr2sd */)
69	{
70	// assignment operator
71	AliFatal("Assignment operator not implemented");
72	return *this;
73	}
74
75	// ------------------------------------------------------------------------- //
76
77	AliPMDRawToSDigits::~AliPMDRawToSDigits()
78	{
79	// Destructor
80	if (fSDigits)
81	{
82	fSDigits->Delete();
83	delete fSDigits;
84	fSDigits=0;
85	}
86	if (fDigits)
87	{
88	fDigits->Delete();
89	delete fDigits;
90	fDigits=0;
91	}
92
93	}
94	// ------------------------------------------------------------------------- //
95
96	void AliPMDRawToSDigits::Raw2SDigits(AliRunLoader runLoader, AliRawReader rawReader)
97	{
93622f4a	98	// Converts RAW data to sdigits
1d9f57cc	99	//
	100	TObjArray pmdddlcont;
	101	AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
	102
	103	TTree* treeS = pmdLoader->TreeS();
	104	if (treeS == 0x0)
	105	{
	106	pmdLoader->MakeTree("S");
	107	treeS = pmdLoader->TreeS();
	108	}
	109	Int_t bufsize = 16000;
	110	if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
	111	treeS->Branch("PMDSDigit", &fSDigits, bufsize);
	112
	113	const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
	114	const Int_t kRow = 48;
	115	const Int_t kCol = 96;
93622f4a	116	const Int_t kSMN = 48;
1d9f57cc	117
1d9f57cc	118	Int_t idet = 0;
1d9f57cc	119	Int_t indexsmn = 0;
93622f4a	120	Int_t ismn = 0;
	121
	122	Int_t ***precpvADC;
	123	precpvADC = new int **[kSMN];
	124	for (Int_t i=0; i<kSMN; i++) precpvADC[i] = new int *[kRow];
	125	for (Int_t i=0; i<kSMN;i++)
1d9f57cc	126	{
93622f4a	127	for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
	128	}
	129	for (Int_t i = 0; i < kSMN; i++)
	130	{
	131	for (Int_t j = 0; j < kRow; j++)
1d9f57cc	132	{
93622f4a	133	for (Int_t k = 0; k < kCol; k++)
1d9f57cc	134	{
93622f4a	135	precpvADC[i][j][k] = 0;
1d9f57cc	136	}
1d9f57cc	137	}
93622f4a	138	}
	139
	140	for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
	141	{
	142
1d9f57cc	143	rawReader->Reset();
	144	AliPMDRawStream pmdinput(rawReader);
	145	rawReader->Select("PMD", indexDDL, indexDDL);
	146
	147	pmdinput.DdlData(indexDDL,&pmdddlcont);
	148
	149	Int_t ientries = pmdddlcont.GetEntries();
	150	for (Int_t ient = 0; ient < ientries; ient++)
	151	{
	152	AliPMDddldata pmdddl = (AliPMDddldata)pmdddlcont.UncheckedAt(ient);
	153
	154	Int_t det = pmdddl->GetDetector();
	155	Int_t smn = pmdddl->GetSMN();
	156	//Int_t mcm = pmdddl->GetMCM();
	157	//Int_t chno = pmdddl->GetChannel();
	158	Int_t row = pmdddl->GetRow();
	159	Int_t col = pmdddl->GetColumn();
	160	Int_t sig = pmdddl->GetSignal();
	161
1d9f57cc	162	if (indexDDL < 4)
	163	{
	164	if (det != 0)
	165	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
	166	indexDDL, det));
93622f4a	167	indexsmn = smn;
1d9f57cc	168	}
93622f4a	169	else if (indexDDL == 4 \|\| indexDDL == 5)
1d9f57cc	170	{
	171	if (det != 1)
	172	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
	173	indexDDL, det));
93622f4a	174	indexsmn = smn + 24;
1d9f57cc	175	}
93622f4a	176
1d9f57cc	177	precpvADC[indexsmn][row][col] = sig;
	178	}
	179
	180	pmdddlcont.Clear();
	181
93622f4a	182	} // DDL Loop
	183
	184	// Add the sdigits here
	185
	186	for ( indexsmn = 0; indexsmn < kSMN; indexsmn++)
	187	{
1d9f57cc	188
93622f4a	189	if (indexsmn < 23)
1d9f57cc	190	{
93622f4a	191	idet = 0;
	192	ismn = indexsmn;
	193	}
	194	else if (indexsmn > 23)
	195	{
	196	idet = 0;
	197	ismn = indexsmn - 24;
	198	}
	199	for (Int_t irow = 0; irow < kRow; irow++)
	200	{
	201	for (Int_t icol = 0; icol < kCol; icol++)
1d9f57cc	202	{
1d9f57cc	203
93622f4a	204	Int_t trno = -99999;
	205	Int_t sig1 = precpvADC[indexsmn][irow][icol];
	206
	207	// plug in a function to convert to adc to MeV
	208	Float_t edep = 0.;
	209	if (sig1 > 0)
1d9f57cc	210	{
93622f4a	211	AdcToMeV(sig1,edep);
	212	AddSDigit(trno,idet,ismn,irow,icol,edep);
	213	}
	214	} // row
	215	} // col
	216
	217	treeS->Fill();
	218	ResetSDigit();
	219	}
1d9f57cc	220
1d9f57cc	221	pmdLoader->WriteSDigits("OVERWRITE");
93622f4a	222
	223	// Delete all the pointers
	224
	225	for (Int_t i = 0; i < kSMN; i++)
	226	{
	227	for (Int_t j = 0; j < kRow; j++)
	228	{
	229	delete [] precpvADC[i][j];
	230	}
	231	}
	232	for (Int_t j = 0; j < kSMN; j++)
	233	{
	234	delete [] precpvADC[j];
	235	}
	236	delete [] precpvADC;
1d9f57cc	237
	238	}
	239	// ------------------------------------------------------------------------- //
	240	void AliPMDRawToSDigits::Raw2Digits(AliRunLoader runLoader, AliRawReader rawReader)
	241	{
	242	// Converts RAW data to digits
	243	//
	244	TObjArray pmdddlcont;
93622f4a	245
1d9f57cc	246	AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
	247
	248	TTree* treeD = pmdLoader->TreeD();
	249	if (treeD == 0x0)
	250	{
	251	pmdLoader->MakeTree("D");
	252	treeD = pmdLoader->TreeD();
	253	}
	254	Int_t bufsize = 16000;
	255	if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
	256	treeD->Branch("PMDDigit", &fDigits, bufsize);
93622f4a	257
1d9f57cc	258	const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
	259	const Int_t kRow = 48;
	260	const Int_t kCol = 96;
93622f4a	261	const Int_t kSMN = 48;
93622f4a	262
1d9f57cc	263	Int_t idet = 0;
93622f4a	264	Int_t ismn = 0;
1d9f57cc	265	Int_t indexsmn = 0;
93622f4a	266
	267	Int_t ***precpvADC;
	268	precpvADC = new int **[kSMN];
	269	for (Int_t i=0; i<kSMN; i++) precpvADC[i] = new int *[kRow];
	270	for (Int_t i=0; i<kSMN;i++)
1d9f57cc	271	{
93622f4a	272	for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
	273	}
	274	for (Int_t i = 0; i < kSMN; i++)
	275	{
	276	for (Int_t j = 0; j < kRow; j++)
1d9f57cc	277	{
93622f4a	278	for (Int_t k = 0; k < kCol; k++)
1d9f57cc	279	{
93622f4a	280	precpvADC[i][j][k] = 0;
1d9f57cc	281	}
1d9f57cc	282	}
93622f4a	283	}
	284	for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
	285	{
1d9f57cc	286	rawReader->Reset();
	287	AliPMDRawStream pmdinput(rawReader);
	288	rawReader->Select("PMD", indexDDL, indexDDL);
	289
	290	//pmdinput.DdlData(&pmdddlcont);
	291	pmdinput.DdlData(indexDDL,&pmdddlcont);
	292
	293
	294	Int_t ientries = pmdddlcont.GetEntries();
	295	for (Int_t ient = 0; ient < ientries; ient++)
	296	{
	297	AliPMDddldata pmdddl = (AliPMDddldata)pmdddlcont.UncheckedAt(ient);
	298
	299	Int_t det = pmdddl->GetDetector();
	300	Int_t smn = pmdddl->GetSMN();
	301	//Int_t mcm = pmdddl->GetMCM();
	302	//Int_t chno = pmdddl->GetChannel();
	303	Int_t row = pmdddl->GetRow();
	304	Int_t col = pmdddl->GetColumn();
	305	Int_t sig = pmdddl->GetSignal();
	306
	307
	308	if (indexDDL < 4)
	309	{
	310	if (det != 0)
	311	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
	312	indexDDL, det));
93622f4a	313	indexsmn = smn ;
1d9f57cc	314	}
93622f4a	315	else if (indexDDL == 4 \|\| indexDDL == 5)
1d9f57cc	316	{
	317	if (det != 1)
	318	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
	319	indexDDL, det));
93622f4a	320	indexsmn = smn + 24;
1d9f57cc	321	}
	322	precpvADC[indexsmn][row][col] = sig;
	323	}
	324
	325	pmdddlcont.Clear();
93622f4a	326	} // DDL Loop
1d9f57cc	327
93622f4a	328	// Add the digits here
	329	for (indexsmn = 0; indexsmn < kSMN; indexsmn++)
	330	{
	331	if (indexsmn < 23)
1d9f57cc	332	{
93622f4a	333	ismn = indexsmn;
	334	idet = 0;
	335	}
	336	else if (indexsmn > 23)
	337	{
	338	ismn = indexsmn -24;
	339	idet = 1;
	340	}
	341	for (Int_t irow = 0; irow < kRow; irow++)
	342	{
	343	for (Int_t icol = 0; icol < kCol; icol++)
1d9f57cc	344	{
93622f4a	345	Int_t trno = -99999;
	346	Int_t sig1 = precpvADC[indexsmn][irow][icol];
	347
	348	// plug in a function to convert to adc to MeV
	349	if (sig1 > 0)
1d9f57cc	350	{
93622f4a	351	AddDigit(trno,idet,ismn,irow,icol,sig1);
1d9f57cc	352	}
93622f4a	353	} // row
	354	} // col
	355	treeD->Fill();
	356	ResetDigit();
	357	}
1d9f57cc	358
	359	pmdLoader->WriteDigits("OVERWRITE");
	360
93622f4a	361	// Delete all the pointers
	362
	363	for (Int_t i = 0; i < kSMN; i++)
	364	{
	365	for (Int_t j = 0; j < kRow; j++)
	366	{
	367	delete [] precpvADC[i][j];
	368	}
	369	}
	370	for (Int_t j = 0; j < kSMN; j++)
	371	{
	372	delete [] precpvADC[j];
	373	}
	374	delete [] precpvADC;
1d9f57cc	375	}
	376	// ------------------------------------------------------------------------- //
	377
	378	void AliPMDRawToSDigits::AdcToMeV(Int_t adc, Float_t &edep)
	379	{
	380	// To be implemented, this is just for the test
	381
	382	const Float_t kConstant = 7.181;
	383	// const Float_t kErConstant = 0.6899;
	384	const Float_t kSlope = 35.93;
	385	// const Float_t kErSlope = 0.306;
	386
	387
	388
	389	Float_t adc10bit = (Float_t) adc/4;
	390	edep = (1000.0/kSlope)*(adc10bit - kConstant);
	391	}
	392
	393	// ------------------------------------------------------------------------- //
	394
	395	void AliPMDRawToSDigits::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber,
	396	Int_t irow, Int_t icol, Float_t adc)
	397	{
	398	// Add SDigit
	399	//
	400	if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
	401	TClonesArray &lsdigits = *fSDigits;
	402	new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,det,smnumber,irow,icol,adc);
	403	}
	404
	405	// ------------------------------------------------------------------------- //
	406	void AliPMDRawToSDigits::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber,
	407	Int_t irow, Int_t icol, Float_t adc)
	408	{
	409	// Add Digit
	410	//
	411	if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
	412	TClonesArray &ldigits = *fDigits;
	413	new(ldigits[fNdigit++]) AliPMDdigit(trnumber,det,smnumber,irow,icol,adc);
	414	}
	415
	416	// ------------------------------------------------------------------------- //
	417	void AliPMDRawToSDigits::ResetSDigit()
	418	{
	419	// Clears SDigits
	420	fNsdigit = 0;
	421	if (fSDigits) fSDigits->Clear();
	422	}
	423	// ------------------------------------------------------------------------- //
	424	void AliPMDRawToSDigits::ResetDigit()
	425	{
	426	// Clears SDigits
	427	fNdigit = 0;
	428	if (fDigits) fDigits->Clear();
	429	}