[u/mrichter/AliRoot.git] / T0 / AliT0.cxx

/**************************************************************************
 * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
 *                                                                        *
 * Author: The ALICE Off-line Project.                                    *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

/* $Id$ */

///////////////////////////////////////////////////////////////////////////////
//                                                                           //
//  T0 (T-Zero) Detector                                            //
//  This class contains the base procedures for the T0     //
//  detector                                                                 //
//                                                                           //
//Begin_Html
/*
<img src="gif/AliT0Class.gif">
</pre>
<br clear=left>
<font size=+2 color=red>
<p>The responsible person for this module is
<a href="mailto:Alla.Maevskaia@cern.ch">Alla Maevskaia</a>.
</font>
<pre>
*/
//End_Html
//                                                                           //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////

#include "TClonesArray.h"
#include "TString.h"

#include "AliLoader.h"
#include "AliLog.h"
#include "AliLog.h"
#include "AliMC.h"
#include "AliRun.h"
#include "AliT0.h"
#include "AliT0Digitizer.h"
#include "AliT0RawData.h"
#include "AliT0RecPoint.h"
#include "AliT0digit.h"
#include "AliT0hit.h"
ClassImp(AliT0)

  //static  AliT0digit *digits; 

//_____________________________________________________________________________
AliT0::AliT0()
  : AliDetector(), fIdSens(0), fDigits(NULL), fRecPoints(NULL)
{
  //
  // Default constructor for class AliT0
  //
  fIshunt   = 1;
  fHits     = 0;
  fDigits   = 0;
  fRecPoints = 0;
}
 
//_____________________________________________________________________________
AliT0::AliT0(const char *name, const char *title)
  : AliDetector(name,title), fIdSens(0), fDigits(new AliT0digit()), fRecPoints(new AliT0RecPoint())
{
  //
  // Standard constructor for T0 Detector
  //

  
  //
  // Initialise Hit array
  fHits       = new TClonesArray("AliT0hit",  405);
  gAlice->GetMCApp()->AddHitList(fHits);
  //  fDigits    = new AliT0digit();
  //  fRecPoints = new AliT0RecPoint();
  fIshunt     =  1;
  //  fIdSens   =  0;
  //PH  SetMarkerColor(kRed);
}

//_____________________________________________________________________________
AliT0::~AliT0() {
  
  //destructor
  if (fHits) {
    fHits->Delete();
    delete fHits;
  }
  /*
  if (fDigits) {
    fDigits->Delete();
    delete fDigits;
    cout<<" delete fDigits; "<<endl;
  }
  if (fRecPoints) {
   fRecPoints ->Delete();
    delete fRecPoints;
    cout<<" delete fRecPoints; "<<endl;
  }
  */ 
}

//_____________________________________________________________________________
void AliT0::AddHit(Int_t track, Int_t *vol, Float_t *hits)
{
  //
  // Add a T0 hit
  //
  TClonesArray &lhits = *fHits;
  new(lhits[fNhits++]) AliT0hit(fIshunt,track,vol,hits);
}


//_____________________________________________________________________________

void AliT0::AddDigit(Int_t besttimeright, Int_t besttimeleft, Int_t meantime, 
		     Int_t timediff, Int_t sumMult, Int_t refpoint,
			TArrayI *timeCFD, TArrayI *qt0, TArrayI *timeLED, TArrayI *qt1)
{
  
  //  Add a T0 digit to the list.
 //
  
  if (!fDigits) {
    fDigits = new AliT0digit();
  }
  fDigits-> SetTimeBestA(besttimeright);
  fDigits->SetTimeBestC(besttimeleft);
  fDigits-> SetMeanTime(meantime);
  fDigits-> SetDiffTime(timediff);
  fDigits-> SetSumMult(sumMult);
  fDigits->SetTimeCFD(*timeCFD);
  fDigits->SetTimeLED(*timeLED);
  fDigits->SetQT0(*qt0);
  fDigits->SetQT1(*qt1);
  fDigits->SetRefPoint(refpoint);
}

//-------------------------------------------------------------------------
void AliT0::Init()
{
  //
  // Initialis the T0 after it has been built
  Int_t i;
  //
  if(AliLog::GetGlobalDebugLevel()>0) {
    printf("\n%s: ",ClassName());
    for(i=0;i<35;i++) printf("*");
    printf(" T0_INIT ");
    for(i=0;i<35;i++) printf("*");
    printf("\n%s: ",ClassName());
    //
    // Here the T0 initialisation code (if any!)
    for(i=0;i<80;i++) printf("*");
    printf("\n");
  }
}

//---------------------------------------------------------------------------
void AliT0::MakeBranch(Option_t* option)
{
  //
// Create Tree branches for the T0.

 // Options:
  //
  //    H          Make a branch of TClonesArray of AliT0Hit's
  //    D          Make a branch of TClonesArray of AliT0Digit's
  //
  //    R         Make a branch of  AliT0RecPoints
  //
  //  char branchname[20];
  // sprintf(branchname,"%s",GetName());
  //  strncpy(branchname, GetName(), 20);
  TString branchname = Form("%s", GetName());

  const char *cH = strstr(option,"H");
  const char *cD = strstr(option,"D");
  const char *cR = strstr(option,"R");
  const char *cS = strstr(option,"S");

    if (cH && fLoader->TreeH())
  {
     if (fHits == 0x0) fHits  = new TClonesArray("AliT0hit",  405);
     AliDetector::MakeBranch(option);
  } 
    
    
  if (cD && fLoader->TreeD())
    {
      if (fDigits == 0x0) fDigits  = new AliT0digit();
      //     MakeBranchInTree(fLoader->TreeD(), branchname,
      //		       &fDigits, 405, 0);
      fLoader->TreeD()->Branch(branchname.Data(),"AliT0digit",&fDigits);
      //   fLoader->TreeD()->Print();
    } 
  if (cR && fLoader->TreeR())
    {
      if (fRecPoints == 0x0) fRecPoints  = new AliT0RecPoint();
      MakeBranchInTree(fLoader->TreeR(), branchname, &fRecPoints);
    } 
  if (cS && fLoader->TreeS())
    {
      if (fDigits == 0x0) fDigits  = new AliT0digit();
      //     MakeBranchInTree(fLoader->TreeD(), branchname,
      //		       &fDigits, 405, 0);
      fLoader->TreeS()->Branch(branchname,"AliT0digit",&fDigits);
      //   fLoader->TreeD()->Print();
    } 
  
}    

//_____________________________________________________________________________
void AliT0::ResetHits()
{
  //
  //reset hits
  //
  AliDetector::ResetHits();
  
}
//____________________________________________________________________
void AliT0::ResetDigits()
{
  //
  // Reset number of digits and the digits array for this detector
  //
  if (fDigits) fDigits->Clear();
}

//_____________________________________________________________________________
void AliT0::SetTreeAddress()
{

  TTree    *treeH = fLoader->TreeH();
  
  if (treeH)
    {
      if (fHits == 0x0) fHits  = new TClonesArray("AliT0hit",  405);
    }
    
  AliDetector::SetTreeAddress();
  TTree *treeD = fLoader->TreeD();
  if (treeD) {
    if (fDigits == 0x0)  fDigits  = new AliT0digit();
    TBranch* branch = treeD->GetBranch ("T0");
    if (branch) branch->SetAddress(&fDigits);
  }

  TTree *treeR = fLoader->TreeR();
  if (treeR) {
    if (fRecPoints == 0x0) fRecPoints  = new  AliT0RecPoint()  ;
    TBranch* branch = treeR->GetBranch ("T0");
    if (branch) branch->SetAddress(&fRecPoints);
  }
  // SDigitizer for Federico
  TTree *treeS = fLoader->TreeS();
  if (treeS) {
    if (fDigits == 0x0)  fDigits  = new AliT0digit();
    TBranch* branch = treeS->GetBranch ("T0");
    if (branch) branch->SetAddress(&fDigits);
  }
 
}


//_____________________________________________________________________________
void AliT0::MakeBranchInTreeD(TTree *treeD, const char *file)
{
    //
    // Create TreeD branches for the FMD
    //
    const Int_t kBufferSize = 4000;
    //   char branchname[20];
    // strncpy(branchname, GetName(), 20);
    TString branchname = Form("%s", GetName());
 //   sprintf(branchname,"%s",GetName());
    if(treeD)
     {
       MakeBranchInTree(treeD,  branchname.Data(),&fDigits, kBufferSize, file);
     }
}

//_____________________________________________________________________________
AliDigitizer* AliT0::CreateDigitizer(AliDigitizationInput* digInput) const
{
  return new AliT0Digitizer(digInput);
}
//____________________________________________________________________________
void AliT0::Digits2Raw()
{
//
// Starting from the T0 digits, writes the Raw Data objects
//
//  AliT0Loader* pStartLoader = (AliT0Loader*)fLoader;
  fLoader ->LoadDigits("read");
  TTree* treeD = fLoader->TreeD();
  if (!treeD) {
    AliError("no digits tree");
    return;
  }
  if (fDigits == 0x0)  fDigits  = new AliT0digit();
  
  TBranch *branch = treeD->GetBranch("T0");
  if (branch) {
    branch->SetAddress(&fDigits);
  }else{
    AliError("Branch T0 DIGIT not found");
    exit(111);
  } 
  AliT0RawData rawWriter;
  rawWriter.SetVerbose(0);
  
  AliDebug(2,Form(" Formatting raw data for T0 "));
  branch->GetEntry(0);
  //  rawWriter.RawDataT0(treeD->GetBranch("T0"));
  rawWriter.RawDataT0(fDigits);
  
  
  fLoader->UnloadDigits();
  
}

//____________________________________________________________________________
void AliT0::Raw2Digits(AliRawReader *rawReader,TTree* digitsTree)
{

 //T0 raw data-> digits conversion
 // reconstruct time information from raw data
 // cout<<"  AliT0::Raw2Digits(AliRawReader *rawReader,TTree* digitsTree) "<<
  // rawReader<<" "<<digitsTree<<endl;

 
  //  AliT0RawReader myrawreader(rawReader,digitsTree);
   AliT0RawReader myrawreader(rawReader);
   if (!myrawreader.Next())
     AliDebug(1,Form(" no raw data found!! %i", myrawreader.Next()));
   Int_t allData[110][5];
   for (Int_t i=0; i<110; i++) {
     allData[i][0]=myrawreader.GetData(i,0);
   }


   fDigits = new AliT0digit();
   digitsTree->Branch("T0","AliT0digit",&fDigits);
   
   
   TArrayI *timeLED = new TArrayI(24);
   TArrayI * timeCFD = new TArrayI(24);
   TArrayI *chargeQT0 = new TArrayI(24);
   TArrayI *chargeQT1 = new TArrayI(24);
   
   for (Int_t in=0; in<24; in++)
     {
       timeLED->AddAt(allData[in+1][0],in);
       timeCFD->AddAt(allData[in+25][0],in);
       chargeQT0->AddAt(allData[in+55][0],in);
       chargeQT1->AddAt(allData[in+79][0],in);
       AliDebug(2, Form(" readed Raw %i %i %i %i %i", in, timeLED->At(in),timeCFD->At(in),chargeQT0->At(in),chargeQT1->At(in)));
     }
  
   fDigits->SetTimeCFD(*timeCFD);
   fDigits->SetQT0(*chargeQT1);

   fDigits->SetTimeLED(*timeLED);
   fDigits->SetQT1(*chargeQT1);

   fDigits->SetMeanTime(allData[49][0]);
   fDigits->SetDiffTime(allData[50][0]);
   fDigits->SetTimeBestA(allData[51][0]);
   fDigits->SetTimeBestC(allData[52][0]);
   digitsTree->Fill();
   fDigits->Write();
 
   delete timeCFD ;
   delete chargeQT0;
   delete timeLED ;
   delete chargeQT1;


}
Commit	Line	Data
dc7ca31d	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15
	16	/* $Id$ */
	17
	18	///////////////////////////////////////////////////////////////////////////////
	19	// //
	20	// T0 (T-Zero) Detector //
	21	// This class contains the base procedures for the T0 //
	22	// detector //
	23	// //
	24	//Begin_Html
	25	/*
	26	<img src="gif/AliT0Class.gif">
	27	</pre>
	28	<br clear=left>
	29	<font size=+2 color=red>
	30	<p>The responsible person for this module is
	31	<a href="mailto:Alla.Maevskaia@cern.ch">Alla Maevskaia</a>.
	32	</font>
	33	<pre>
	34	*/
	35	//End_Html
	36	// //
	37	// //
	38	///////////////////////////////////////////////////////////////////////////////
	39
3e2e3ece	40	#include "TClonesArray.h"
950ce3fb	41	#include "TString.h"
dc7ca31d	42
3e2e3ece	43	#include "AliLoader.h"
3e2e3ece	44	#include "AliLog.h"
dc7ca31d	45	#include "AliLog.h"
dc7ca31d	46	#include "AliMC.h"
dc7ca31d	47	#include "AliRun.h"
dc7ca31d	48	#include "AliT0.h"
c2d9de6d	49	#include "AliT0Digitizer.h"
dc7ca31d	50	#include "AliT0RawData.h"
dc7ca31d	51	#include "AliT0RecPoint.h"
3e2e3ece	52	#include "AliT0digit.h"
3e2e3ece	53	#include "AliT0hit.h"
dc7ca31d	54	ClassImp(AliT0)
	55
	56	//static AliT0digit *digits;
	57
	58	//_____________________________________________________________________________
	59	AliT0::AliT0()
	60	: AliDetector(), fIdSens(0), fDigits(NULL), fRecPoints(NULL)
	61	{
	62	//
	63	// Default constructor for class AliT0
	64	//
	65	fIshunt = 1;
	66	fHits = 0;
	67	fDigits = 0;
	68	fRecPoints = 0;
	69	}
	70
	71	//_____________________________________________________________________________
	72	AliT0::AliT0(const char name, const char title)
	73	: AliDetector(name,title), fIdSens(0), fDigits(new AliT0digit()), fRecPoints(new AliT0RecPoint())
	74	{
	75	//
	76	// Standard constructor for T0 Detector
	77	//
	78
	79
	80	//
	81	// Initialise Hit array
	82	fHits = new TClonesArray("AliT0hit", 405);
	83	gAlice->GetMCApp()->AddHitList(fHits);
	84	// fDigits = new AliT0digit();
	85	// fRecPoints = new AliT0RecPoint();
	86	fIshunt = 1;
	87	// fIdSens = 0;
	88	//PH SetMarkerColor(kRed);
	89	}
	90
	91	//_____________________________________________________________________________
	92	AliT0::~AliT0() {
	93
94249139	94	//destructor
dc7ca31d	95	if (fHits) {
	96	fHits->Delete();
	97	delete fHits;
	98	}
	99	/*
	100	if (fDigits) {
	101	fDigits->Delete();
	102	delete fDigits;
	103	cout<<" delete fDigits; "<<endl;
	104	}
	105	if (fRecPoints) {
	106	fRecPoints ->Delete();
	107	delete fRecPoints;
	108	cout<<" delete fRecPoints; "<<endl;
	109	}
	110	*/
	111	}
	112
	113	//_____________________________________________________________________________
	114	void AliT0::AddHit(Int_t track, Int_t vol, Float_t hits)
	115	{
	116	//
	117	// Add a T0 hit
	118	//
	119	TClonesArray &lhits = *fHits;
	120	new(lhits[fNhits++]) AliT0hit(fIshunt,track,vol,hits);
	121	}
	122
	123
	124	//_____________________________________________________________________________
	125
	126	void AliT0::AddDigit(Int_t besttimeright, Int_t besttimeleft, Int_t meantime,
740f0839	127	Int_t timediff, Int_t sumMult, Int_t refpoint,
c41ceaac	128	TArrayI timeCFD, TArrayI qt0, TArrayI timeLED, TArrayI qt1)
dc7ca31d	129	{
	130
	131	// Add a T0 digit to the list.
	132	//
	133
	134	if (!fDigits) {
	135	fDigits = new AliT0digit();
	136	}
c41ceaac	137	fDigits-> SetTimeBestA(besttimeright);
c41ceaac	138	fDigits->SetTimeBestC(besttimeleft);
dc7ca31d	139	fDigits-> SetMeanTime(meantime);
	140	fDigits-> SetDiffTime(timediff);
	141	fDigits-> SetSumMult(sumMult);
c41ceaac	142	fDigits->SetTimeCFD(*timeCFD);
	143	fDigits->SetTimeLED(*timeLED);
	144	fDigits->SetQT0(*qt0);
	145	fDigits->SetQT1(*qt1);
740f0839	146	fDigits->SetRefPoint(refpoint);
dc7ca31d	147	}
dc7ca31d	148
dc7ca31d	149	//-------------------------------------------------------------------------
	150	void AliT0::Init()
	151	{
	152	//
	153	// Initialis the T0 after it has been built
	154	Int_t i;
	155	//
	156	if(AliLog::GetGlobalDebugLevel()>0) {
	157	printf("\n%s: ",ClassName());
	158	for(i=0;i<35;i++) printf("*");
	159	printf(" T0_INIT ");
	160	for(i=0;i<35;i++) printf("*");
	161	printf("\n%s: ",ClassName());
	162	//
	163	// Here the T0 initialisation code (if any!)
	164	for(i=0;i<80;i++) printf("*");
	165	printf("\n");
	166	}
	167	}
	168
	169	//---------------------------------------------------------------------------
	170	void AliT0::MakeBranch(Option_t* option)
	171	{
	172	//
	173	// Create Tree branches for the T0.
	174
	175	// Options:
	176	//
	177	// H Make a branch of TClonesArray of AliT0Hit's
	178	// D Make a branch of TClonesArray of AliT0Digit's
	179	//
	180	// R Make a branch of AliT0RecPoints
	181	//
950ce3fb	182	// char branchname[20];
f7350425	183	// sprintf(branchname,"%s",GetName());
950ce3fb	184	// strncpy(branchname, GetName(), 20);
	185	TString branchname = Form("%s", GetName());
	186
dc7ca31d	187	const char *cH = strstr(option,"H");
	188	const char *cD = strstr(option,"D");
	189	const char *cR = strstr(option,"R");
cb5f5d4d	190	const char *cS = strstr(option,"S");
dc7ca31d	191
	192	if (cH && fLoader->TreeH())
	193	{
	194	if (fHits == 0x0) fHits = new TClonesArray("AliT0hit", 405);
	195	AliDetector::MakeBranch(option);
	196	}
	197
	198
	199	if (cD && fLoader->TreeD())
	200	{
	201	if (fDigits == 0x0) fDigits = new AliT0digit();
	202	// MakeBranchInTree(fLoader->TreeD(), branchname,
	203	// &fDigits, 405, 0);
950ce3fb	204	fLoader->TreeD()->Branch(branchname.Data(),"AliT0digit",&fDigits);
dc7ca31d	205	// fLoader->TreeD()->Print();
	206	}
	207	if (cR && fLoader->TreeR())
	208	{
	209	if (fRecPoints == 0x0) fRecPoints = new AliT0RecPoint();
1b544d5a	210	MakeBranchInTree(fLoader->TreeR(), branchname, &fRecPoints);
dc7ca31d	211	}
cb5f5d4d	212	if (cS && fLoader->TreeS())
	213	{
	214	if (fDigits == 0x0) fDigits = new AliT0digit();
	215	// MakeBranchInTree(fLoader->TreeD(), branchname,
	216	// &fDigits, 405, 0);
1b544d5a	217	fLoader->TreeS()->Branch(branchname,"AliT0digit",&fDigits);
cb5f5d4d	218	// fLoader->TreeD()->Print();
cb5f5d4d	219	}
dc7ca31d	220
	221	}
	222
	223	//_____________________________________________________________________________
	224	void AliT0::ResetHits()
	225	{
94249139	226	//
	227	//reset hits
	228	//
dc7ca31d	229	AliDetector::ResetHits();
	230
	231	}
	232	//____________________________________________________________________
	233	void AliT0::ResetDigits()
	234	{
	235	//
	236	// Reset number of digits and the digits array for this detector
	237	//
	238	if (fDigits) fDigits->Clear();
	239	}
	240
	241	//_____________________________________________________________________________
	242	void AliT0::SetTreeAddress()
	243	{
	244
cb5b8b21	245	TTree *treeH = fLoader->TreeH();
dc7ca31d	246
	247	if (treeH)
	248	{
	249	if (fHits == 0x0) fHits = new TClonesArray("AliT0hit", 405);
	250	}
	251
	252	AliDetector::SetTreeAddress();
	253	TTree *treeD = fLoader->TreeD();
	254	if (treeD) {
	255	if (fDigits == 0x0) fDigits = new AliT0digit();
	256	TBranch* branch = treeD->GetBranch ("T0");
	257	if (branch) branch->SetAddress(&fDigits);
	258	}
	259
	260	TTree *treeR = fLoader->TreeR();
	261	if (treeR) {
	262	if (fRecPoints == 0x0) fRecPoints = new AliT0RecPoint() ;
	263	TBranch* branch = treeR->GetBranch ("T0");
	264	if (branch) branch->SetAddress(&fRecPoints);
	265	}
cb5f5d4d	266	// SDigitizer for Federico
	267	TTree *treeS = fLoader->TreeS();
	268	if (treeS) {
	269	if (fDigits == 0x0) fDigits = new AliT0digit();
	270	TBranch* branch = treeS->GetBranch ("T0");
	271	if (branch) branch->SetAddress(&fDigits);
	272	}
dc7ca31d	273
	274	}
	275
	276
	277	//_____________________________________________________________________________
	278	void AliT0::MakeBranchInTreeD(TTree treeD, const char file)
	279	{
	280	//
	281	// Create TreeD branches for the FMD
	282	//
	283	const Int_t kBufferSize = 4000;
950ce3fb	284	// char branchname[20];
	285	// strncpy(branchname, GetName(), 20);
	286	TString branchname = Form("%s", GetName());
	287	// sprintf(branchname,"%s",GetName());
dc7ca31d	288	if(treeD)
dc7ca31d	289	{
950ce3fb	290	MakeBranchInTree(treeD, branchname.Data(),&fDigits, kBufferSize, file);
dc7ca31d	291	}
	292	}
	293
c2d9de6d	294	//_____________________________________________________________________________
f21fc003	295	AliDigitizer* AliT0::CreateDigitizer(AliDigitizationInput* digInput) const
c2d9de6d	296	{
f21fc003	297	return new AliT0Digitizer(digInput);
c2d9de6d	298	}
dc7ca31d	299	//____________________________________________________________________________
	300	void AliT0::Digits2Raw()
	301	{
	302	//
	303	// Starting from the T0 digits, writes the Raw Data objects
	304	//
	305	// AliT0Loader* pStartLoader = (AliT0Loader*)fLoader;
	306	fLoader ->LoadDigits("read");
	307	TTree* treeD = fLoader->TreeD();
	308	if (!treeD) {
	309	AliError("no digits tree");
	310	return;
	311	}
	312	if (fDigits == 0x0) fDigits = new AliT0digit();
	313
	314	TBranch *branch = treeD->GetBranch("T0");
	315	if (branch) {
	316	branch->SetAddress(&fDigits);
	317	}else{
	318	AliError("Branch T0 DIGIT not found");
	319	exit(111);
	320	}
	321	AliT0RawData rawWriter;
	322	rawWriter.SetVerbose(0);
	323
	324	AliDebug(2,Form(" Formatting raw data for T0 "));
	325	branch->GetEntry(0);
	326	// rawWriter.RawDataT0(treeD->GetBranch("T0"));
	327	rawWriter.RawDataT0(fDigits);
	328
	329
	330	fLoader->UnloadDigits();
	331
	332	}
e0bba6cc	333
	334	//____________________________________________________________________________
	335	void AliT0::Raw2Digits(AliRawReader rawReader,TTree digitsTree)
	336	{
	337
	338	//T0 raw data-> digits conversion
	339	// reconstruct time information from raw data
	340	// cout<<" AliT0::Raw2Digits(AliRawReader rawReader,TTree digitsTree) "<<
	341	// rawReader<<" "<<digitsTree<<endl;
	342
	343
	344	// AliT0RawReader myrawreader(rawReader,digitsTree);
	345	AliT0RawReader myrawreader(rawReader);
	346	if (!myrawreader.Next())
	347	AliDebug(1,Form(" no raw data found!! %i", myrawreader.Next()));
	348	Int_t allData[110][5];
	349	for (Int_t i=0; i<110; i++) {
	350	allData[i][0]=myrawreader.GetData(i,0);
	351	}
	352
	353
c2337900	354	fDigits = new AliT0digit();
1b544d5a	355	digitsTree->Branch("T0","AliT0digit",&fDigits);
e0bba6cc	356
	357
	358	TArrayI *timeLED = new TArrayI(24);
	359	TArrayI * timeCFD = new TArrayI(24);
	360	TArrayI *chargeQT0 = new TArrayI(24);
	361	TArrayI *chargeQT1 = new TArrayI(24);
	362
	363	for (Int_t in=0; in<24; in++)
	364	{
	365	timeLED->AddAt(allData[in+1][0],in);
	366	timeCFD->AddAt(allData[in+25][0],in);
	367	chargeQT0->AddAt(allData[in+55][0],in);
	368	chargeQT1->AddAt(allData[in+79][0],in);
	369	AliDebug(2, Form(" readed Raw %i %i %i %i %i", in, timeLED->At(in),timeCFD->At(in),chargeQT0->At(in),chargeQT1->At(in)));
	370	}
	371
c41ceaac	372	fDigits->SetTimeCFD(*timeCFD);
c41ceaac	373	fDigits->SetQT0(*chargeQT1);
e0bba6cc	374
c41ceaac	375	fDigits->SetTimeLED(*timeLED);
c41ceaac	376	fDigits->SetQT1(*chargeQT1);
e0bba6cc	377
	378	fDigits->SetMeanTime(allData[49][0]);
	379	fDigits->SetDiffTime(allData[50][0]);
c41ceaac	380	fDigits->SetTimeBestA(allData[51][0]);
c41ceaac	381	fDigits->SetTimeBestC(allData[52][0]);
e0bba6cc	382	digitsTree->Fill();
	383	fDigits->Write();
	384
	385	delete timeCFD ;
	386	delete chargeQT0;
	387	delete timeLED ;
	388	delete chargeQT1;
	389
	390
	391	}