[u/mrichter/AliRoot.git] / VZERO / AliVZERODigitizer.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$ */

///_________________________________________________________________________
///
/// This class constructs Digits out of Hits
///
///

// --- Standard library ---

// --- ROOT system ---
#include <TMath.h>
#include <TTree.h>
#include <TGeoManager.h>
#include <TGeoPhysicalNode.h>
#include <AliGeomManager.h>
#include <TRandom.h>

// --- AliRoot header files ---
#include "AliVZEROConst.h"
#include "AliRun.h"
#include "AliVZERO.h"
#include "AliVZEROhit.h"
#include "AliRunLoader.h"
#include "AliLoader.h"
#include "AliRunDigitizer.h"
#include "AliCDBManager.h"
#include "AliCDBStorage.h"
#include "AliCDBEntry.h"
#include "AliVZEROCalibData.h"

#include "AliVZEROdigit.h"
#include "AliVZERODigitizer.h"

ClassImp(AliVZERODigitizer)

 AliVZERODigitizer::AliVZERODigitizer()
   :AliDigitizer(),
    fCalibData(GetCalibData()),
    fPhotoCathodeEfficiency(0.18),
    fPMVoltage(768.0),
    fPMGain(TMath::Power((fPMVoltage / 112.5) ,7.04277)),
    fNdigits(0),
    fDigits(0)
   
{
  // default constructor

//    fNdigits = 0;
//    fDigits  = 0;
//   
//    fPhotoCathodeEfficiency =   0.18;
//    fPMVoltage              =  768.0;
//    fPMGain = TMath::Power((fPMVoltage / 112.5) ,7.04277); 
   
//   fCalibData = GetCalibData();
}

//____________________________________________________________________________ 
  AliVZERODigitizer::AliVZERODigitizer(AliRunDigitizer* manager)
                    :AliDigitizer(manager),
		     fCalibData(GetCalibData()),
                     fPhotoCathodeEfficiency(0.18),
                     fPMVoltage(768.0),
                     fPMGain(TMath::Power((fPMVoltage / 112.5) ,7.04277)),
		     fNdigits(0),
                     fDigits(0)
		                        
{
  // constructor
  
//   fNdigits = 0;
//   fDigits  = 0;
//   
//   fPhotoCathodeEfficiency =   0.18;
//   fPMVoltage              =  768.0;
//   fPMGain = TMath::Power( (fPMVoltage / 112.5) ,7.04277 );
  
//  fCalibData = GetCalibData();
  
}
           
//____________________________________________________________________________ 
  AliVZERODigitizer::~AliVZERODigitizer()
{
  // destructor
  
  if (fDigits) {
    fDigits->Delete();
    delete fDigits;
    fDigits=0; 
  }
}

//_____________________________________________________________________________
Bool_t AliVZERODigitizer::Init()
{
  // Initialises the digitizer

  // Initialises the Digit array
  fDigits = new TClonesArray ("AliVZEROdigit", 1000);
  
  //  TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
  //  im->Print();
  
  return kTRUE;
}

//____________________________________________________________________________
void AliVZERODigitizer::Exec(Option_t* /*option*/) 
{   
  // Creates digits from hits
     
  Int_t       map[80];    // 48 values on V0C + 32 on V0A
  Int_t       adc[64];    // 32 PMs on V0C + 32 PMs on V0A
  Float_t     time[80], time_ref[80], time2[64];
  Float_t     adc_gain[80]; 
  Float_t     adc_pedestal[64],adc_sigma[64];    
  fNdigits     =    0;  
  Float_t     PMGain_smeared[64];  
  Float_t     cPM[80];
  
  // Smearing of the PM tubes intrinsic characteristics
  
  for(Int_t ii=0; ii<64; ii++) {
      PMGain_smeared[ii] = gRandom->Gaus(fPMGain, fPMGain/5); }
              
  // Retrieval of ADC gain values and pedestal information from local CDB 
  // I use only the first 64th values of the calibration array in CDB 
  // as I have no beam burst structure - odd or even beam burst number
  
  // Reminder : We have 16 scintillating cells mounted on 8 PMs 
  // on Ring 3 and Ring 4 in V0C -  added to produce  ADC outputs 
  // on these rings... 
   
  for(Int_t i=0; i<16; i++) { 
            adc_gain[i] = fCalibData->GetGain(i); 
            cPM[i]      = fPhotoCathodeEfficiency * PMGain_smeared[i];}
  
  for(Int_t j=16; j<48; j=j+2) { 
            Int_t i=(j+17)/2;
            adc_gain[j]   = fCalibData->GetGain(i);	    
	    adc_gain[j+1] = fCalibData->GetGain(i); 
	    cPM[j]        = fPhotoCathodeEfficiency * PMGain_smeared[i];   
	    cPM[j+1]      = fPhotoCathodeEfficiency * PMGain_smeared[i]; }
	    
  for(Int_t i=48; i<80; i++){ 
            adc_gain[i] = fCalibData->GetGain(i-16); 
	    cPM[i]      = fPhotoCathodeEfficiency * PMGain_smeared[i-16];};
  
  for(Int_t  i=0; i<64; i++){ adc_pedestal[i] = fCalibData->GetPedestal(i); 
                              adc_sigma[i]    = fCalibData->GetSigma(i); }; 
                                
//  for(Int_t i=0; i<64; i++) { printf(" i = %d pedestal = %f sigma = %f \n\n", 
//                                       i, adc_pedestal[i], adc_sigma[i] );} 
            
  AliRunLoader* outRunLoader = 
    AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());    
  if (!outRunLoader) {
    Error("Exec", "Can not get output Run Loader");
    return;}
    
  AliLoader* outLoader = outRunLoader->GetLoader("VZEROLoader");
  if (!outLoader) {
    Error("Exec", "Can not get output VZERO Loader");
    return;}

  outLoader->LoadDigits("update");
  if (!outLoader->TreeD()) outLoader->MakeTree("D");
  outLoader->MakeDigitsContainer();
  TTree* treeD  = outLoader->TreeD();
  Int_t bufsize = 16000;
  treeD->Branch("VZERODigit", &fDigits, bufsize); 
  
  for (Int_t iInput = 0; iInput < fManager->GetNinputs(); iInput++) {
     AliRunLoader* runLoader = 
     AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
     AliLoader* loader = runLoader->GetLoader("VZEROLoader");
     if (!loader) {
       Error("Exec", "Can not get VZERO Loader for input %d", iInput);
       continue;}
      
     if (!runLoader->GetAliRun()) runLoader->LoadgAlice();

     AliVZERO* vzero = (AliVZERO*) runLoader->GetAliRun()->GetDetector("VZERO");
     if (!vzero) {
       Error("Exec", "No VZERO detector for input %d", iInput);
       continue;}
      
     loader->LoadHits();
     TTree* treeH = loader->TreeH();
     if (!treeH) {
       Error("Exec", "Cannot get TreeH for input %d", iInput);
       continue; }
       
     for(Int_t i=0; i<80; i++) {map[i] = 0; time[i] = 0.0;}
	      
     TClonesArray* hits = vzero->Hits();
             
//  Now makes Digits from hits
         
     Int_t nTracks = (Int_t) treeH->GetEntries();
     for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
         for (Int_t i=0; i<80; i++) {time_ref[i] = 999999.0;}   
         vzero->ResetHits();
         treeH->GetEvent(iTrack);
         Int_t nHits = hits->GetEntriesFast();
         for (Int_t iHit = 0; iHit < nHits; iHit++) {
	     AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
	     Int_t nPhot = hit->Nphot();
	     Int_t cell  = hit->Cell();                                    
	     map[cell] += nPhot;
	     Float_t dt_scintillator = gRandom->Gaus(0,0.7);
	     Float_t t = dt_scintillator + 1e9*hit->Tof();
	     if (t > 0.0) {
	        if(t < time_ref[cell]) time_ref[cell] = t;
	        time[cell] = TMath::Min(t,time_ref[cell]); }
         }           // hit   loop      
     }             // track loop

     loader->UnloadHits();

  }               // input loop

// Now builds the scintillator cell response (80 cells i.e. 80 responses)
         
   for (Int_t i=0; i<80; i++) {    
       Float_t q1 = Float_t ( map[i] )* cPM[i] * kQe;
       Float_t noise = gRandom->Gaus(10.5,3.22);
       Float_t pmResponse  =  q1/kC*TMath::Power(ktheta/kthau,1/(1-ktheta/kthau)) 
        + noise*1e-3; 	
       map[i] = Int_t( pmResponse * adc_gain[i]);
       if(map[i] > (110/2)) {map[i] = Int_t(gRandom->Gaus(map[i], 110/6));}
     }
      
// Now transforms 80 cell responses into 64 photomultiplier responses
// Also adds the ADC pedestals taken out of the calibration data base
	
   for (Int_t j=0; j<16; j++){
        adc[j]  = static_cast<Int_t>(map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]));
	time2[j]= time[j];}
	
   for (Int_t j=48; j<80; j++){
        adc[j-16]  = static_cast<Int_t>(map [j] 
					+ gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]));
	time2[j-16]= time[j]; }
	
   for (Int_t j=0; j<16; j++){
        adc[16+j] = static_cast<Int_t>(map [16+2*j]+ map [16+2*j+1] 
				       + gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]));
	Float_t min_time = TMath::Min(time [16+2*j],time [16+2*j+1]);
	time2[16+j] = min_time;
	if(min_time==0.0){time2[16+j]=TMath::Max(time[16+2*j],time[16+2*j+1]);}
   }
   	

// Now add digits to the digit Tree 
        
   for (Int_t i=0; i<64; i++) {      
      if(adc[i] > 0) {
//           printf(" Event, cell, adc, tof = %d %d %d %f\n", 
//                    outRunLoader->GetEventNumber(),i, map[i], time2[i]*10.0);
//           multiply by 10 to have 100 ps per channel :
             AddDigit(i, adc[i], Int_t(time2[i]*10.0)) ;}      
   }
    
  treeD->Fill();
  outLoader->WriteDigits("OVERWRITE");  
  outLoader->UnloadDigits();     
  ResetDigit();
}

//____________________________________________________________________________
void AliVZERODigitizer::AddDigit(Int_t PMnumber, Int_t adc, Int_t time) 
 { 
 
// Adds Digit 
 
  TClonesArray &ldigits = *fDigits;  
  new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time);
}
//____________________________________________________________________________
void AliVZERODigitizer::ResetDigit()
{
//
// Clears Digits
//
  fNdigits = 0;
  if (fDigits) fDigits->Delete();
}

//____________________________________________________________________________
AliVZEROCalibData* AliVZERODigitizer::GetCalibData() const

{
  AliCDBManager *man = AliCDBManager::Instance();

  AliCDBEntry *entry=0;

  entry = man->Get("VZERO/Calib/Data");

//   if(!entry){
//     AliWarning("Load of calibration data from default storage failed!");
//     AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
//     Int_t runNumber = man->GetRun();
//     entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
//       ->Get("VZERO/Calib/Data",runNumber);
// 	
//   }

  // Retrieval of data in directory VZERO/Calib/Data:


  AliVZEROCalibData *calibdata = 0;

  if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
  if (!calibdata)  AliFatal("No calibration data from calibration database !");

  return calibdata;

}
Commit	Line	Data
	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	/// This class constructs Digits out of Hits
	21	///
	22	///
	23
	24	// --- Standard library ---
	25
	26	// --- ROOT system ---
	27	#include <TMath.h>
	28	#include <TTree.h>
	29	#include <TGeoManager.h>
	30	#include <TGeoPhysicalNode.h>
	31	#include <AliGeomManager.h>
	32	#include <TRandom.h>
	33
	34	// --- AliRoot header files ---
	35	#include "AliVZEROConst.h"
	36	#include "AliRun.h"
	37	#include "AliVZERO.h"
	38	#include "AliVZEROhit.h"
	39	#include "AliRunLoader.h"
	40	#include "AliLoader.h"
	41	#include "AliRunDigitizer.h"
	42	#include "AliCDBManager.h"
	43	#include "AliCDBStorage.h"
	44	#include "AliCDBEntry.h"
	45	#include "AliVZEROCalibData.h"
	46
	47	#include "AliVZEROdigit.h"
	48	#include "AliVZERODigitizer.h"
	49
	50	ClassImp(AliVZERODigitizer)
	51
	52	AliVZERODigitizer::AliVZERODigitizer()
	53	:AliDigitizer(),
	54	fCalibData(GetCalibData()),
	55	fPhotoCathodeEfficiency(0.18),
	56	fPMVoltage(768.0),
	57	fPMGain(TMath::Power((fPMVoltage / 112.5) ,7.04277)),
	58	fNdigits(0),
	59	fDigits(0)
	60
	61	{
	62	// default constructor
	63
	64	// fNdigits = 0;
	65	// fDigits = 0;
	66	//
	67	// fPhotoCathodeEfficiency = 0.18;
	68	// fPMVoltage = 768.0;
	69	// fPMGain = TMath::Power((fPMVoltage / 112.5) ,7.04277);
	70
	71	// fCalibData = GetCalibData();
	72	}
	73
	74	//____________________________________________________________________________
	75	AliVZERODigitizer::AliVZERODigitizer(AliRunDigitizer* manager)
	76	:AliDigitizer(manager),
	77	fCalibData(GetCalibData()),
	78	fPhotoCathodeEfficiency(0.18),
	79	fPMVoltage(768.0),
	80	fPMGain(TMath::Power((fPMVoltage / 112.5) ,7.04277)),
	81	fNdigits(0),
	82	fDigits(0)
	83
	84	{
	85	// constructor
	86
	87	// fNdigits = 0;
	88	// fDigits = 0;
	89	//
	90	// fPhotoCathodeEfficiency = 0.18;
	91	// fPMVoltage = 768.0;
	92	// fPMGain = TMath::Power( (fPMVoltage / 112.5) ,7.04277 );
	93
	94	// fCalibData = GetCalibData();
	95
	96	}
	97
	98	//____________________________________________________________________________
	99	AliVZERODigitizer::~AliVZERODigitizer()
	100	{
	101	// destructor
	102
	103	if (fDigits) {
	104	fDigits->Delete();
	105	delete fDigits;
	106	fDigits=0;
	107	}
	108	}
	109
	110	//_____________________________________________________________________________
	111	Bool_t AliVZERODigitizer::Init()
	112	{
	113	// Initialises the digitizer
	114
	115	// Initialises the Digit array
	116	fDigits = new TClonesArray ("AliVZEROdigit", 1000);
	117
	118	// TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
	119	// im->Print();
	120
	121	return kTRUE;
	122	}
	123
	124	//____________________________________________________________________________
	125	void AliVZERODigitizer::Exec(Option_t* /option/)
	126	{
	127	// Creates digits from hits
	128
	129	Int_t map[80]; // 48 values on V0C + 32 on V0A
	130	Int_t adc[64]; // 32 PMs on V0C + 32 PMs on V0A
	131	Float_t time[80], time_ref[80], time2[64];
	132	Float_t adc_gain[80];
	133	Float_t adc_pedestal[64],adc_sigma[64];
	134	fNdigits = 0;
	135	Float_t PMGain_smeared[64];
	136	Float_t cPM[80];
	137
	138	// Smearing of the PM tubes intrinsic characteristics
	139
	140	for(Int_t ii=0; ii<64; ii++) {
	141	PMGain_smeared[ii] = gRandom->Gaus(fPMGain, fPMGain/5); }
	142
	143	// Retrieval of ADC gain values and pedestal information from local CDB
	144	// I use only the first 64th values of the calibration array in CDB
	145	// as I have no beam burst structure - odd or even beam burst number
	146
	147	// Reminder : We have 16 scintillating cells mounted on 8 PMs
	148	// on Ring 3 and Ring 4 in V0C - added to produce ADC outputs
	149	// on these rings...
	150
	151	for(Int_t i=0; i<16; i++) {
	152	adc_gain[i] = fCalibData->GetGain(i);
	153	cPM[i] = fPhotoCathodeEfficiency * PMGain_smeared[i];}
	154
	155	for(Int_t j=16; j<48; j=j+2) {
	156	Int_t i=(j+17)/2;
	157	adc_gain[j] = fCalibData->GetGain(i);
	158	adc_gain[j+1] = fCalibData->GetGain(i);
	159	cPM[j] = fPhotoCathodeEfficiency * PMGain_smeared[i];
	160	cPM[j+1] = fPhotoCathodeEfficiency * PMGain_smeared[i]; }
	161
	162	for(Int_t i=48; i<80; i++){
	163	adc_gain[i] = fCalibData->GetGain(i-16);
	164	cPM[i] = fPhotoCathodeEfficiency * PMGain_smeared[i-16];};
	165
	166	for(Int_t i=0; i<64; i++){ adc_pedestal[i] = fCalibData->GetPedestal(i);
	167	adc_sigma[i] = fCalibData->GetSigma(i); };
	168
	169	// for(Int_t i=0; i<64; i++) { printf(" i = %d pedestal = %f sigma = %f \n\n",
	170	// i, adc_pedestal[i], adc_sigma[i] );}
	171
	172	AliRunLoader* outRunLoader =
	173	AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
	174	if (!outRunLoader) {
	175	Error("Exec", "Can not get output Run Loader");
	176	return;}
	177
	178	AliLoader* outLoader = outRunLoader->GetLoader("VZEROLoader");
	179	if (!outLoader) {
	180	Error("Exec", "Can not get output VZERO Loader");
	181	return;}
	182
	183	outLoader->LoadDigits("update");
	184	if (!outLoader->TreeD()) outLoader->MakeTree("D");
	185	outLoader->MakeDigitsContainer();
	186	TTree* treeD = outLoader->TreeD();
	187	Int_t bufsize = 16000;
	188	treeD->Branch("VZERODigit", &fDigits, bufsize);
	189
	190	for (Int_t iInput = 0; iInput < fManager->GetNinputs(); iInput++) {
	191	AliRunLoader* runLoader =
	192	AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
	193	AliLoader* loader = runLoader->GetLoader("VZEROLoader");
	194	if (!loader) {
	195	Error("Exec", "Can not get VZERO Loader for input %d", iInput);
	196	continue;}
	197
	198	if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
	199
	200	AliVZERO* vzero = (AliVZERO*) runLoader->GetAliRun()->GetDetector("VZERO");
	201	if (!vzero) {
	202	Error("Exec", "No VZERO detector for input %d", iInput);
	203	continue;}
	204
	205	loader->LoadHits();
	206	TTree* treeH = loader->TreeH();
	207	if (!treeH) {
	208	Error("Exec", "Cannot get TreeH for input %d", iInput);
	209	continue; }
	210
	211	for(Int_t i=0; i<80; i++) {map[i] = 0; time[i] = 0.0;}
	212
	213	TClonesArray* hits = vzero->Hits();
	214
	215	// Now makes Digits from hits
	216
	217	Int_t nTracks = (Int_t) treeH->GetEntries();
	218	for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
	219	for (Int_t i=0; i<80; i++) {time_ref[i] = 999999.0;}
	220	vzero->ResetHits();
	221	treeH->GetEvent(iTrack);
	222	Int_t nHits = hits->GetEntriesFast();
	223	for (Int_t iHit = 0; iHit < nHits; iHit++) {
	224	AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
	225	Int_t nPhot = hit->Nphot();
	226	Int_t cell = hit->Cell();
	227	map[cell] += nPhot;
	228	Float_t dt_scintillator = gRandom->Gaus(0,0.7);
	229	Float_t t = dt_scintillator + 1e9*hit->Tof();
	230	if (t > 0.0) {
	231	if(t < time_ref[cell]) time_ref[cell] = t;
	232	time[cell] = TMath::Min(t,time_ref[cell]); }
	233	} // hit loop
	234	} // track loop
	235
	236	loader->UnloadHits();
	237
	238	} // input loop
	239
	240	// Now builds the scintillator cell response (80 cells i.e. 80 responses)
	241
	242	for (Int_t i=0; i<80; i++) {
	243	Float_t q1 = Float_t ( map[i] )* cPM[i] * kQe;
	244	Float_t noise = gRandom->Gaus(10.5,3.22);
	245	Float_t pmResponse = q1/kC*TMath::Power(ktheta/kthau,1/(1-ktheta/kthau))
	246	+ noise*1e-3;
	247	map[i] = Int_t( pmResponse * adc_gain[i]);
	248	if(map[i] > (110/2)) {map[i] = Int_t(gRandom->Gaus(map[i], 110/6));}
	249	}
	250
	251	// Now transforms 80 cell responses into 64 photomultiplier responses
	252	// Also adds the ADC pedestals taken out of the calibration data base
	253
	254	for (Int_t j=0; j<16; j++){
	255	adc[j] = static_cast<Int_t>(map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]));
	256	time2[j]= time[j];}
	257
	258	for (Int_t j=48; j<80; j++){
	259	adc[j-16] = static_cast<Int_t>(map [j]
	260	+ gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]));
	261	time2[j-16]= time[j]; }
	262
	263	for (Int_t j=0; j<16; j++){
	264	adc[16+j] = static_cast<Int_t>(map [16+2j]+ map [16+2j+1]
	265	+ gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]));
	266	Float_t min_time = TMath::Min(time [16+2j],time [16+2j+1]);
	267	time2[16+j] = min_time;
	268	if(min_time==0.0){time2[16+j]=TMath::Max(time[16+2j],time[16+2j+1]);}
	269	}
	270
	271
	272	// Now add digits to the digit Tree
	273
	274	for (Int_t i=0; i<64; i++) {
	275	if(adc[i] > 0) {
	276	// printf(" Event, cell, adc, tof = %d %d %d %f\n",
	277	// outRunLoader->GetEventNumber(),i, map[i], time2[i]*10.0);
	278	// multiply by 10 to have 100 ps per channel :
	279	AddDigit(i, adc[i], Int_t(time2[i]*10.0)) ;}
	280	}
	281
	282	treeD->Fill();
	283	outLoader->WriteDigits("OVERWRITE");
	284	outLoader->UnloadDigits();
	285	ResetDigit();
	286	}
	287
	288	//____________________________________________________________________________
	289	void AliVZERODigitizer::AddDigit(Int_t PMnumber, Int_t adc, Int_t time)
	290	{
	291
	292	// Adds Digit
	293
	294	TClonesArray &ldigits = *fDigits;
	295	new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time);
	296	}
	297	//____________________________________________________________________________
	298	void AliVZERODigitizer::ResetDigit()
	299	{
	300	//
	301	// Clears Digits
	302	//
	303	fNdigits = 0;
	304	if (fDigits) fDigits->Delete();
	305	}
	306
	307	//____________________________________________________________________________
	308	AliVZEROCalibData* AliVZERODigitizer::GetCalibData() const
	309
	310	{
	311	AliCDBManager *man = AliCDBManager::Instance();
	312
	313	AliCDBEntry *entry=0;
	314
	315	entry = man->Get("VZERO/Calib/Data");
	316
	317	// if(!entry){
	318	// AliWarning("Load of calibration data from default storage failed!");
	319	// AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
	320	// Int_t runNumber = man->GetRun();
	321	// entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
	322	// ->Get("VZERO/Calib/Data",runNumber);
	323	//
	324	// }
	325
	326	// Retrieval of data in directory VZERO/Calib/Data:
	327
	328
	329	AliVZEROCalibData *calibdata = 0;
	330
	331	if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
	332	if (!calibdata) AliFatal("No calibration data from calibration database !");
	333
	334	return calibdata;
	335
	336	}
	337