[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 digits
  //
  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;

  Int_t idet = 0;
  Int_t iSMN = 0;
  Int_t indexsmn = 0;

  for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
    {

      if (indexDDL < 4)
	{
	  iSMN = 6;
	}
      else if (indexDDL >= 4)
	{
	  iSMN = 12;
	}
      Int_t ***precpvADC;
      precpvADC = new int **[iSMN];
      for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
      for (Int_t i=0; i<iSMN;i++)
	{
	  for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
	}
      for (Int_t i = 0; i < iSMN; i++)
	{
	  for (Int_t j = 0; j < kRow; j++)
	    {
	      for (Int_t k = 0; k < kCol; k++)
		{
		  precpvADC[i][j][k] = 0;
		}
	    }
	}
      
      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 - indexDDL * 6;
	    }
	  else if (indexDDL == 4)
	    {
	      if (det != 1)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      if (smn < 6)
		{
		  indexsmn = smn;
		}
	      else if (smn >= 18 && smn < 24)
		{
		  indexsmn = smn - 12;
		}
	    }
	  else if (indexDDL == 5)
	    {
	      if (det != 1)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      if (smn >= 6 && smn < 12)
		{
		  indexsmn = smn - 6;
		}
	      else if (smn >= 12 && smn < 18)
		{
		  indexsmn = smn - 6;
		}
	    }	      
	  precpvADC[indexsmn][row][col] = sig;
	}
      
      pmdddlcont.Clear();
      
      // Add the sdigits here

      Int_t ismn = 0;
      for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
	{
	  if (indexDDL < 4)
	    {
	      ismn = indexsmn + indexDDL * 6;
	      idet = 0;
	    }
	  else if (indexDDL == 4)
	    {
	      if (indexsmn < 6)
		{
		  ismn = indexsmn;
		}
	      else if (indexsmn >= 6 && indexsmn < 12)
		{
		  ismn = indexsmn + 12;
		}
	      idet = 1;
	    }
	  else if (indexDDL == 5)
	    {
	      if (indexsmn < 6)
		{
		  ismn = indexsmn + 6;
		}
	      else if (indexsmn >= 6 && indexsmn < 12)
		{
		  ismn = indexsmn + 6;
		}
	      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
		  Float_t edep = 0.;
		  if (sig1 > 0)
		    {
		      AdcToMeV(sig1,edep);
		      AddSDigit(trno,idet,ismn,irow,icol,edep);
		    }
		} // row
	    }     // col

	  treeS->Fill();
	  ResetSDigit();
	}	  
    } // DDL Loop

  pmdLoader->WriteSDigits("OVERWRITE");
  
}
// ------------------------------------------------------------------------- //
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;

  Int_t idet = 0;
  Int_t iSMN = 0;
  Int_t indexsmn = 0;

  for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
    {

      if (indexDDL < 4)
	{
	  iSMN = 6;
	}
      else if (indexDDL >= 4)
	{
	  iSMN = 12;
	}
      Int_t ***precpvADC;
      precpvADC = new int **[iSMN];
      for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
      for (Int_t i=0; i<iSMN;i++)
	{
	  for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
	}
      for (Int_t i = 0; i < iSMN; i++)
	{
	  for (Int_t j = 0; j < kRow; j++)
	    {
	      for (Int_t k = 0; k < kCol; k++)
		{
		  precpvADC[i][j][k] = 0;
		}
	    }
	}
      
      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 - indexDDL * 6;
	    }
	  else if (indexDDL == 4)
	    {
	      if (det != 1)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      if (smn < 6)
		{
		  indexsmn = smn;
		}
	      else if (smn >= 18 && smn < 24)
		{
		  indexsmn = smn - 12;
		}
	    }
	  else if (indexDDL == 5)
	    {
	      if (det != 1)
		AliError(Form("*DDL %d and Detector NUMBER %d NOT MATCHING *",
			      indexDDL, det));
	      if (smn >= 6 && smn < 12)
		{
		  indexsmn = smn - 6;
		}
	      else if (smn >= 12 && smn < 18)
		{
		  indexsmn = smn - 6;
		}
	    }	      
	  precpvADC[indexsmn][row][col] = sig;
	}
      
      pmdddlcont.Clear();
      
      // Add the digits here
      
      Int_t ismn = 0;
      for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
	{
	  if (indexDDL < 4)
	    {
	      ismn = indexsmn + indexDDL * 6;
	      idet = 0;
	    }
	  else if (indexDDL == 4)
	    {
	      if (indexsmn < 6)
		{
		  ismn = indexsmn;
		}
	      else if (indexsmn >= 6 && indexsmn < 12)
		{
		  ismn = indexsmn + 12;
		}
	      idet = 1;
	    }
	  else if (indexDDL == 5)
	    {
	      if (indexsmn < 6)
		{
		  ismn = indexsmn + 6;
		}
	      else if (indexsmn >= 6 && indexsmn < 12)
		{
		  ismn = indexsmn + 6;
		}
	      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();
	}	  
	  
    } // DDL Loop
  
  pmdLoader->WriteDigits("OVERWRITE");

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

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	{
98	// Converts RAW data to digits
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;
116
117	Int_t idet = 0;
118	Int_t iSMN = 0;
119	Int_t indexsmn = 0;
120
121	for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
122	{
123
124	if (indexDDL < 4)
125	{
126	iSMN = 6;
127	}
128	else if (indexDDL >= 4)
129	{
130	iSMN = 12;
131	}
132	Int_t ***precpvADC;
133	precpvADC = new int **[iSMN];
134	for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
135	for (Int_t i=0; i<iSMN;i++)
136	{
137	for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
138	}
139	for (Int_t i = 0; i < iSMN; i++)
140	{
141	for (Int_t j = 0; j < kRow; j++)
142	{
143	for (Int_t k = 0; k < kCol; k++)
144	{
145	precpvADC[i][j][k] = 0;
146	}
147	}
148	}
149
150	rawReader->Reset();
151	AliPMDRawStream pmdinput(rawReader);
152	rawReader->Select("PMD", indexDDL, indexDDL);
153
154	pmdinput.DdlData(indexDDL,&pmdddlcont);
155
156	Int_t ientries = pmdddlcont.GetEntries();
157	for (Int_t ient = 0; ient < ientries; ient++)
158	{
159	AliPMDddldata pmdddl = (AliPMDddldata)pmdddlcont.UncheckedAt(ient);
160
161	Int_t det = pmdddl->GetDetector();
162	Int_t smn = pmdddl->GetSMN();
163	//Int_t mcm = pmdddl->GetMCM();
164	//Int_t chno = pmdddl->GetChannel();
165	Int_t row = pmdddl->GetRow();
166	Int_t col = pmdddl->GetColumn();
167	Int_t sig = pmdddl->GetSignal();
168
169
170	if (indexDDL < 4)
171	{
172	if (det != 0)
173	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
174	indexDDL, det));
175	indexsmn = smn - indexDDL * 6;
176	}
177	else if (indexDDL == 4)
178	{
179	if (det != 1)
180	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
181	indexDDL, det));
182	if (smn < 6)
183	{
184	indexsmn = smn;
185	}
186	else if (smn >= 18 && smn < 24)
187	{
188	indexsmn = smn - 12;
189	}
190	}
191	else if (indexDDL == 5)
192	{
193	if (det != 1)
194	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
195	indexDDL, det));
196	if (smn >= 6 && smn < 12)
197	{
198	indexsmn = smn - 6;
199	}
200	else if (smn >= 12 && smn < 18)
201	{
202	indexsmn = smn - 6;
203	}
204	}
205	precpvADC[indexsmn][row][col] = sig;
206	}
207
208	pmdddlcont.Clear();
209
210	// Add the sdigits here
211
212	Int_t ismn = 0;
213	for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
214	{
215	if (indexDDL < 4)
216	{
217	ismn = indexsmn + indexDDL * 6;
218	idet = 0;
219	}
220	else if (indexDDL == 4)
221	{
222	if (indexsmn < 6)
223	{
224	ismn = indexsmn;
225	}
226	else if (indexsmn >= 6 && indexsmn < 12)
227	{
228	ismn = indexsmn + 12;
229	}
230	idet = 1;
231	}
232	else if (indexDDL == 5)
233	{
234	if (indexsmn < 6)
235	{
236	ismn = indexsmn + 6;
237	}
238	else if (indexsmn >= 6 && indexsmn < 12)
239	{
240	ismn = indexsmn + 6;
241	}
242	idet = 1;
243	}
244
245	for (Int_t irow = 0; irow < kRow; irow++)
246	{
247	for (Int_t icol = 0; icol < kCol; icol++)
248	{
249
250	Int_t trno = -99999;
251	Int_t sig1 = precpvADC[indexsmn][irow][icol];
252
253	// plug in a function to convert to adc to MeV
254	Float_t edep = 0.;
255	if (sig1 > 0)
256	{
257	AdcToMeV(sig1,edep);
258	AddSDigit(trno,idet,ismn,irow,icol,edep);
259	}
260	} // row
261	} // col
262
263	treeS->Fill();
264	ResetSDigit();
265	}
266	} // DDL Loop
267
268	pmdLoader->WriteSDigits("OVERWRITE");
269
270	}
271	// ------------------------------------------------------------------------- //
272	void AliPMDRawToSDigits::Raw2Digits(AliRunLoader runLoader, AliRawReader rawReader)
273	{
274	// Converts RAW data to digits
275	//
276	TObjArray pmdddlcont;
277
278	AliLoader *pmdLoader = runLoader->GetLoader("PMDLoader");
279
280	TTree* treeD = pmdLoader->TreeD();
281	if (treeD == 0x0)
282	{
283	pmdLoader->MakeTree("D");
284	treeD = pmdLoader->TreeD();
285	}
286	Int_t bufsize = 16000;
287	if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
288	treeD->Branch("PMDDigit", &fDigits, bufsize);
289
290	const Int_t kDDL = AliDAQ::NumberOfDdls("PMD");
291	const Int_t kRow = 48;
292	const Int_t kCol = 96;
293
294	Int_t idet = 0;
295	Int_t iSMN = 0;
296	Int_t indexsmn = 0;
297
298	for (Int_t indexDDL = 0; indexDDL < kDDL; indexDDL++)
299	{
300
301	if (indexDDL < 4)
302	{
303	iSMN = 6;
304	}
305	else if (indexDDL >= 4)
306	{
307	iSMN = 12;
308	}
309	Int_t ***precpvADC;
310	precpvADC = new int **[iSMN];
311	for (Int_t i=0; i<iSMN; i++) precpvADC[i] = new int *[kRow];
312	for (Int_t i=0; i<iSMN;i++)
313	{
314	for (Int_t j=0; j<kRow; j++) precpvADC[i][j] = new int [kCol];
315	}
316	for (Int_t i = 0; i < iSMN; i++)
317	{
318	for (Int_t j = 0; j < kRow; j++)
319	{
320	for (Int_t k = 0; k < kCol; k++)
321	{
322	precpvADC[i][j][k] = 0;
323	}
324	}
325	}
326
327	rawReader->Reset();
328	AliPMDRawStream pmdinput(rawReader);
329	rawReader->Select("PMD", indexDDL, indexDDL);
330
331	//pmdinput.DdlData(&pmdddlcont);
332	pmdinput.DdlData(indexDDL,&pmdddlcont);
333
334
335	Int_t ientries = pmdddlcont.GetEntries();
336	for (Int_t ient = 0; ient < ientries; ient++)
337	{
338	AliPMDddldata pmdddl = (AliPMDddldata)pmdddlcont.UncheckedAt(ient);
339
340	Int_t det = pmdddl->GetDetector();
341	Int_t smn = pmdddl->GetSMN();
342	//Int_t mcm = pmdddl->GetMCM();
343	//Int_t chno = pmdddl->GetChannel();
344	Int_t row = pmdddl->GetRow();
345	Int_t col = pmdddl->GetColumn();
346	Int_t sig = pmdddl->GetSignal();
347
348
349	if (indexDDL < 4)
350	{
351	if (det != 0)
352	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
353	indexDDL, det));
354	indexsmn = smn - indexDDL * 6;
355	}
356	else if (indexDDL == 4)
357	{
358	if (det != 1)
359	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
360	indexDDL, det));
361	if (smn < 6)
362	{
363	indexsmn = smn;
364	}
365	else if (smn >= 18 && smn < 24)
366	{
367	indexsmn = smn - 12;
368	}
369	}
370	else if (indexDDL == 5)
371	{
372	if (det != 1)
373	AliError(Form("DDL %d and Detector NUMBER %d NOT MATCHING ",
374	indexDDL, det));
375	if (smn >= 6 && smn < 12)
376	{
377	indexsmn = smn - 6;
378	}
379	else if (smn >= 12 && smn < 18)
380	{
381	indexsmn = smn - 6;
382	}
383	}
384	precpvADC[indexsmn][row][col] = sig;
385	}
386
387	pmdddlcont.Clear();
388
389	// Add the digits here
390
391	Int_t ismn = 0;
392	for (Int_t indexsmn = 0; indexsmn < iSMN; indexsmn++)
393	{
394	if (indexDDL < 4)
395	{
396	ismn = indexsmn + indexDDL * 6;
397	idet = 0;
398	}
399	else if (indexDDL == 4)
400	{
401	if (indexsmn < 6)
402	{
403	ismn = indexsmn;
404	}
405	else if (indexsmn >= 6 && indexsmn < 12)
406	{
407	ismn = indexsmn + 12;
408	}
409	idet = 1;
410	}
411	else if (indexDDL == 5)
412	{
413	if (indexsmn < 6)
414	{
415	ismn = indexsmn + 6;
416	}
417	else if (indexsmn >= 6 && indexsmn < 12)
418	{
419	ismn = indexsmn + 6;
420	}
421	idet = 1;
422	}
423
424	for (Int_t irow = 0; irow < kRow; irow++)
425	{
426	for (Int_t icol = 0; icol < kCol; icol++)
427	{
428	Int_t trno = -99999;
429	Int_t sig1 = precpvADC[indexsmn][irow][icol];
430
431	// plug in a function to convert to adc to MeV
432	if (sig1 > 0)
433	{
434	AddDigit(trno,idet,ismn,irow,icol,sig1);
435	}
436	} // row
437	} // col
438	treeD->Fill();
439	ResetDigit();
440	}
441
442	} // DDL Loop
443
444	pmdLoader->WriteDigits("OVERWRITE");
445
446	}
447	// ------------------------------------------------------------------------- //
448
449	void AliPMDRawToSDigits::AdcToMeV(Int_t adc, Float_t &edep)
450	{
451	// To be implemented, this is just for the test
452
453	const Float_t kConstant = 7.181;
454	// const Float_t kErConstant = 0.6899;
455	const Float_t kSlope = 35.93;
456	// const Float_t kErSlope = 0.306;
457
458
459
460	Float_t adc10bit = (Float_t) adc/4;
461	edep = (1000.0/kSlope)*(adc10bit - kConstant);
462	}
463
464	// ------------------------------------------------------------------------- //
465
466	void AliPMDRawToSDigits::AddSDigit(Int_t trnumber, Int_t det, Int_t smnumber,
467	Int_t irow, Int_t icol, Float_t adc)
468	{
469	// Add SDigit
470	//
471	if (!fSDigits) fSDigits = new TClonesArray("AliPMDsdigit", 1000);
472	TClonesArray &lsdigits = *fSDigits;
473	new(lsdigits[fNsdigit++]) AliPMDsdigit(trnumber,det,smnumber,irow,icol,adc);
474	}
475
476	// ------------------------------------------------------------------------- //
477	void AliPMDRawToSDigits::AddDigit(Int_t trnumber, Int_t det, Int_t smnumber,
478	Int_t irow, Int_t icol, Float_t adc)
479	{
480	// Add Digit
481	//
482	if (!fDigits) fDigits = new TClonesArray("AliPMDdigit", 1000);
483	TClonesArray &ldigits = *fDigits;
484	new(ldigits[fNdigit++]) AliPMDdigit(trnumber,det,smnumber,irow,icol,adc);
485	}
486
487	// ------------------------------------------------------------------------- //
488	void AliPMDRawToSDigits::ResetSDigit()
489	{
490	// Clears SDigits
491	fNsdigit = 0;
492	if (fSDigits) fSDigits->Clear();
493	}
494	// ------------------------------------------------------------------------- //
495	void AliPMDRawToSDigits::ResetDigit()
496	{
497	// Clears SDigits
498	fNdigit = 0;
499	if (fDigits) fDigits->Clear();
500	}