[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 <TMap.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 "AliGRPObject.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),
                    fCollisionMode(0),
                    fBeamEnergy(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),
		     fCollisionMode(0),
                     fBeamEnergy(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();

  GetCollisionMode();
  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       pmNumber[80];
  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; 	
	if(fCollisionMode >0) adc_gain[i] = adc_gain[i]/70.0; // reduce dynamics in Ion Collision Mode
        map[i] = Int_t( pmResponse * adc_gain[i]);
        Float_t MIP = 1.0/fCalibData->GetMIPperADC(GetPMNumber(i));
	if(fCollisionMode >0) MIP=2.0;
//	printf("cell = %d,  ADC = %d, TDC = %f \n",i,map[i], time[i]*10.0 );
        if(map[i] > (int(( MIP/2 ) + 0.5)) )
	          {map[i] = Int_t(gRandom->Gaus(map[i], (int(( MIP/6 ) + 0.5)) ));}
   }
      
// 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) +0.5)) ;}      
   }
    
  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();
}

//____________________________________________________________________________
void AliVZERODigitizer::GetCollisionMode()
{
// Retrieves the collision mode from GRP data

// Initialization of the GRP entry 

   Int_t run = AliCDBManager::Instance()->GetRun();
  
//   printf("\n ++++++ Run Number retrieved as %d \n",run); 
 
  AliCDBEntry*  entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run);
  AliGRPObject* grpData = 0x0;
   
  if(entry){
    TMap* m = dynamic_cast<TMap*>(entry->GetObject());  // old GRP entry
    if(m){
       m->Print();
       grpData = new AliGRPObject();
       grpData->ReadValuesFromMap(m);
    }
    else{
       grpData = dynamic_cast<AliGRPObject*>(entry->GetObject());  // new GRP entry
       entry->SetOwner(0);
    }
    AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
  }

  if(!grpData) AliError("No GRP entry found in OCDB!");

// Retrieval of collision mode

  TString beamType = grpData->GetBeamType();
  if(beamType==AliGRPObject::GetInvalidString()){
     AliError("GRP/GRP/Data entry:  missing value for the beam type !");
     AliError("\t VZERO cannot retrieve beam type\n");
     return;
  }

   if( (beamType.CompareTo("P-P") ==0)  || (beamType.CompareTo("p-p") ==0) ){
       fCollisionMode=0;
  }
   else if( (beamType.CompareTo("Pb-Pb") ==0)  || (beamType.CompareTo("A-A") ==0) ){
       fCollisionMode=1;
   }
    
  fBeamEnergy = grpData->GetBeamEnergy();
  if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) {
     AliError("GRP/GRP/Data entry:  missing value for the beam energy ! Using 0");
     fBeamEnergy = 0.;
  }
  
//     printf("\n ++++++ Beam type and collision mode retrieved as %s %d @ %1.3f GeV ++++++\n\n",beamType.Data(), fCollisionMode, fBeamEnergy);

}

//____________________________________________________________________________
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;

}

//____________________________________________________________________________
Int_t AliVZERODigitizer::GetPMNumber(Int_t cell) const

{
   
  Int_t pmNumber[80] = { 0,  1,  2,  3,  4,  5,  6,  7,
                          8,  9, 10, 11, 12, 13, 14, 15, 
			 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 
			 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31,
			 32, 33, 34, 35, 36, 37, 38, 39,
		         40, 41, 42, 43, 44, 45, 46, 47, 
			 48, 49, 50, 51, 52, 53, 54, 55,
			 56, 57, 58, 59, 60, 61, 62, 63 };
			      
  return pmNumber[cell];	
}
Commit	Line	Data
9e04c3b6	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
090026bf	16	/* $Id$ */
090026bf	17
b0d2c2d3	18	///_________________________________________________________________________
	19	///
	20	/// This class constructs Digits out of Hits
	21	///
	22	///
9e04c3b6	23
9e04c3b6	24	// --- Standard library ---
9e04c3b6	25
9e04c3b6	26	// --- ROOT system ---
090026bf	27	#include <TMath.h>
9e04c3b6	28	#include <TTree.h>
fe0adf2a	29	#include <TMap.h>
8bd3e27a	30	#include <TGeoManager.h>
	31	#include <TGeoPhysicalNode.h>
	32	#include <AliGeomManager.h>
e939a978	33	#include <TRandom.h>
9e04c3b6	34
	35	// --- AliRoot header files ---
	36	#include "AliVZEROConst.h"
	37	#include "AliRun.h"
	38	#include "AliVZERO.h"
	39	#include "AliVZEROhit.h"
9e04c3b6	40	#include "AliRunLoader.h"
9e04c3b6	41	#include "AliLoader.h"
fe0adf2a	42	#include "AliGRPObject.h"
9e04c3b6	43	#include "AliRunDigitizer.h"
ce7090f5	44	#include "AliCDBManager.h"
	45	#include "AliCDBStorage.h"
	46	#include "AliCDBEntry.h"
	47	#include "AliVZEROCalibData.h"
	48
9e04c3b6	49	#include "AliVZEROdigit.h"
b0d2c2d3	50	#include "AliVZERODigitizer.h"
9e04c3b6	51
	52	ClassImp(AliVZERODigitizer)
	53
	54	AliVZERODigitizer::AliVZERODigitizer()
fe0adf2a	55	:AliDigitizer(),
	56	fCalibData(GetCalibData()),
	57	fPhotoCathodeEfficiency(0.18),
	58	fPMVoltage(768.0),
	59	fPMGain(TMath::Power((fPMVoltage / 112.5) ,7.04277)),
	60	fNdigits(0),
	61	fDigits(0),
	62	fCollisionMode(0),
	63	fBeamEnergy(0.)
0b2bea8b	64
9e04c3b6	65	{
b0d2c2d3	66	// default constructor
b0d2c2d3	67
0b2bea8b	68	// fNdigits = 0;
	69	// fDigits = 0;
	70	//
	71	// fPhotoCathodeEfficiency = 0.18;
	72	// fPMVoltage = 768.0;
	73	// fPMGain = TMath::Power((fPMVoltage / 112.5) ,7.04277);
ce7090f5	74
0b2bea8b	75	// fCalibData = GetCalibData();
9e04c3b6	76	}
	77
	78	//____________________________________________________________________________
	79	AliVZERODigitizer::AliVZERODigitizer(AliRunDigitizer* manager)
0b2bea8b	80	:AliDigitizer(manager),
	81	fCalibData(GetCalibData()),
	82	fPhotoCathodeEfficiency(0.18),
	83	fPMVoltage(768.0),
	84	fPMGain(TMath::Power((fPMVoltage / 112.5) ,7.04277)),
	85	fNdigits(0),
fe0adf2a	86	fDigits(0),
	87	fCollisionMode(0),
	88	fBeamEnergy(0.)
0b2bea8b	89
9e04c3b6	90	{
	91	// constructor
	92
0b2bea8b	93	// fNdigits = 0;
	94	// fDigits = 0;
	95	//
	96	// fPhotoCathodeEfficiency = 0.18;
	97	// fPMVoltage = 768.0;
	98	// fPMGain = TMath::Power( (fPMVoltage / 112.5) ,7.04277 );
ce7090f5	99
0b2bea8b	100	// fCalibData = GetCalibData();
ce7090f5	101
9e04c3b6	102	}
	103
	104	//____________________________________________________________________________
	105	AliVZERODigitizer::~AliVZERODigitizer()
	106	{
	107	// destructor
	108
	109	if (fDigits) {
	110	fDigits->Delete();
	111	delete fDigits;
b0d2c2d3	112	fDigits=0;
b0d2c2d3	113	}
9e04c3b6	114	}
9e04c3b6	115
b0d2c2d3	116	//_____________________________________________________________________________
b0d2c2d3	117	Bool_t AliVZERODigitizer::Init()
9e04c3b6	118	{
b0d2c2d3	119	// Initialises the digitizer
9e04c3b6	120
b0d2c2d3	121	// Initialises the Digit array
9e04c3b6	122	fDigits = new TClonesArray ("AliVZEROdigit", 1000);
8bd3e27a	123
c61a7285	124	// TGeoHMatrix *im = AliGeomManager::GetMatrix("VZERO/V0C");
c61a7285	125	// im->Print();
fe0adf2a	126
fe0adf2a	127	GetCollisionMode();
b0d2c2d3	128	return kTRUE;
9e04c3b6	129	}
	130
	131	//____________________________________________________________________________
b0d2c2d3	132	void AliVZERODigitizer::Exec(Option_t* /option/)
ce7090f5	133	{
b0d2c2d3	134	// Creates digits from hits
ce7090f5	135
20277079	136	Int_t map[80]; // 48 values on V0C + 32 on V0A
f25f4990	137	// Int_t pmNumber[80];
20277079	138	Int_t adc[64]; // 32 PMs on V0C + 32 PMs on V0A
8bd3e27a	139	Float_t time[80], time_ref[80], time2[64];
	140	Float_t adc_gain[80];
	141	Float_t adc_pedestal[64],adc_sigma[64];
ce7090f5	142	fNdigits = 0;
8adc9b44	143	Float_t pmGain_smeared[64];
8bd3e27a	144	Float_t cPM[80];
	145
	146	// Smearing of the PM tubes intrinsic characteristics
	147
	148	for(Int_t ii=0; ii<64; ii++) {
8adc9b44	149	pmGain_smeared[ii] = gRandom->Gaus(fPMGain, fPMGain/5); }
8bd3e27a	150
8bd3e27a	151	// Retrieval of ADC gain values and pedestal information from local CDB
ce7090f5	152	// I use only the first 64th values of the calibration array in CDB
ce7090f5	153	// as I have no beam burst structure - odd or even beam burst number
b0d2c2d3	154
ce7090f5	155	// Reminder : We have 16 scintillating cells mounted on 8 PMs
20277079	156	// on Ring 3 and Ring 4 in V0C - added to produce ADC outputs
20277079	157	// on these rings...
ce7090f5	158
8bd3e27a	159	for(Int_t i=0; i<16; i++) {
8bd3e27a	160	adc_gain[i] = fCalibData->GetGain(i);
8adc9b44	161	cPM[i] = fPhotoCathodeEfficiency * pmGain_smeared[i];}
ce7090f5	162
	163	for(Int_t j=16; j<48; j=j+2) {
	164	Int_t i=(j+17)/2;
8bd3e27a	165	adc_gain[j] = fCalibData->GetGain(i);
8bd3e27a	166	adc_gain[j+1] = fCalibData->GetGain(i);
8adc9b44	167	cPM[j] = fPhotoCathodeEfficiency * pmGain_smeared[i];
8adc9b44	168	cPM[j+1] = fPhotoCathodeEfficiency * pmGain_smeared[i]; }
8bd3e27a	169
	170	for(Int_t i=48; i<80; i++){
	171	adc_gain[i] = fCalibData->GetGain(i-16);
8adc9b44	172	cPM[i] = fPhotoCathodeEfficiency * pmGain_smeared[i-16];};
ce7090f5	173
8bd3e27a	174	for(Int_t i=0; i<64; i++){ adc_pedestal[i] = fCalibData->GetPedestal(i);
	175	adc_sigma[i] = fCalibData->GetSigma(i); };
	176
	177	// for(Int_t i=0; i<64; i++) { printf(" i = %d pedestal = %f sigma = %f \n\n",
	178	// i, adc_pedestal[i], adc_sigma[i] );}
ce7090f5	179
b0d2c2d3	180	AliRunLoader* outRunLoader =
	181	AliRunLoader::GetRunLoader(fManager->GetOutputFolderName());
	182	if (!outRunLoader) {
	183	Error("Exec", "Can not get output Run Loader");
ce7090f5	184	return;}
ce7090f5	185
b0d2c2d3	186	AliLoader* outLoader = outRunLoader->GetLoader("VZEROLoader");
	187	if (!outLoader) {
	188	Error("Exec", "Can not get output VZERO Loader");
ce7090f5	189	return;}
b0d2c2d3	190
	191	outLoader->LoadDigits("update");
	192	if (!outLoader->TreeD()) outLoader->MakeTree("D");
	193	outLoader->MakeDigitsContainer();
ce7090f5	194	TTree* treeD = outLoader->TreeD();
b0d2c2d3	195	Int_t bufsize = 16000;
b0d2c2d3	196	treeD->Branch("VZERODigit", &fDigits, bufsize);
c299dbe4	197
b0d2c2d3	198	for (Int_t iInput = 0; iInput < fManager->GetNinputs(); iInput++) {
8bd3e27a	199	AliRunLoader* runLoader =
	200	AliRunLoader::GetRunLoader(fManager->GetInputFolderName(iInput));
	201	AliLoader* loader = runLoader->GetLoader("VZEROLoader");
	202	if (!loader) {
	203	Error("Exec", "Can not get VZERO Loader for input %d", iInput);
	204	continue;}
ce7090f5	205
8bd3e27a	206	if (!runLoader->GetAliRun()) runLoader->LoadgAlice();
b0d2c2d3	207
8bd3e27a	208	AliVZERO* vzero = (AliVZERO*) runLoader->GetAliRun()->GetDetector("VZERO");
	209	if (!vzero) {
	210	Error("Exec", "No VZERO detector for input %d", iInput);
	211	continue;}
9e04c3b6	212
8bd3e27a	213	loader->LoadHits();
	214	TTree* treeH = loader->TreeH();
	215	if (!treeH) {
	216	Error("Exec", "Cannot get TreeH for input %d", iInput);
	217	continue; }
c299dbe4	218
8bd3e27a	219	for(Int_t i=0; i<80; i++) {map[i] = 0; time[i] = 0.0;}
fe0adf2a	220
8bd3e27a	221	TClonesArray* hits = vzero->Hits();
9e04c3b6	222
b0d2c2d3	223	// Now makes Digits from hits
fe0adf2a	224
8bd3e27a	225	Int_t nTracks = (Int_t) treeH->GetEntries();
	226	for (Int_t iTrack = 0; iTrack < nTracks; iTrack++) {
	227	for (Int_t i=0; i<80; i++) {time_ref[i] = 999999.0;}
	228	vzero->ResetHits();
	229	treeH->GetEvent(iTrack);
	230	Int_t nHits = hits->GetEntriesFast();
	231	for (Int_t iHit = 0; iHit < nHits; iHit++) {
	232	AliVZEROhit* hit = (AliVZEROhit *)hits->UncheckedAt(iHit);
	233	Int_t nPhot = hit->Nphot();
fe0adf2a	234	Int_t cell = hit->Cell();
8bd3e27a	235	map[cell] += nPhot;
	236	Float_t dt_scintillator = gRandom->Gaus(0,0.7);
	237	Float_t t = dt_scintillator + 1e9*hit->Tof();
	238	if (t > 0.0) {
	239	if(t < time_ref[cell]) time_ref[cell] = t;
	240	time[cell] = TMath::Min(t,time_ref[cell]); }
	241	} // hit loop
	242	} // track loop
b0d2c2d3	243
8bd3e27a	244	loader->UnloadHits();
b0d2c2d3	245
b0d2c2d3	246	} // input loop
20277079	247
20277079	248	// Now builds the scintillator cell response (80 cells i.e. 80 responses)
841137ce	249
20277079	250	for (Int_t i=0; i<80; i++) {
8adc9b44	251	Float_t q1 = Float_t ( map[i] )* cPM[i] * kQe;
	252	Float_t noise = gRandom->Gaus(10.5,3.22);
	253	Float_t pmResponse = q1/kC*TMath::Power(ktheta/kthau,1/(1-ktheta/kthau))
8bd3e27a	254	+ noise*1e-3;
fe0adf2a	255	if(fCollisionMode >0) adc_gain[i] = adc_gain[i]/70.0; // reduce dynamics in Ion Collision Mode
8adc9b44	256	map[i] = Int_t( pmResponse * adc_gain[i]);
fe0adf2a	257	Float_t MIP = 1.0/fCalibData->GetMIPperADC(GetPMNumber(i));
	258	if(fCollisionMode >0) MIP=2.0;
	259	// printf("cell = %d, ADC = %d, TDC = %f \n",i,map[i], time[i]*10.0 );
	260	if(map[i] > (int(( MIP/2 ) + 0.5)) )
	261	{map[i] = Int_t(gRandom->Gaus(map[i], (int(( MIP/6 ) + 0.5)) ));}
8adc9b44	262	}
c299dbe4	263
8bd3e27a	264	// Now transforms 80 cell responses into 64 photomultiplier responses
8bd3e27a	265	// Also adds the ADC pedestals taken out of the calibration data base
20277079	266
8bd3e27a	267	for (Int_t j=0; j<16; j++){
c61a7285	268	adc[j] = static_cast<Int_t>(map [j] + gRandom->Gaus(adc_pedestal[j], adc_sigma[j]));
20277079	269	time2[j]= time[j];}
	270
	271	for (Int_t j=48; j<80; j++){
c61a7285	272	adc[j-16] = static_cast<Int_t>(map [j]
c61a7285	273	+ gRandom->Gaus(adc_pedestal[j-16],adc_sigma[j-16]));
8bd3e27a	274	time2[j-16]= time[j]; }
20277079	275
20277079	276	for (Int_t j=0; j<16; j++){
c61a7285	277	adc[16+j] = static_cast<Int_t>(map [16+2j]+ map [16+2j+1]
c61a7285	278	+ gRandom->Gaus(adc_pedestal[16+j], adc_sigma[16+j]));
c299dbe4	279	Float_t min_time = TMath::Min(time [16+2j],time [16+2j+1]);
c299dbe4	280	time2[16+j] = min_time;
8bd3e27a	281	if(min_time==0.0){time2[16+j]=TMath::Max(time[16+2j],time[16+2j+1]);}
c299dbe4	282	}
	283
	284
20277079	285	// Now add digits to the digit Tree
	286
	287	for (Int_t i=0; i<64; i++) {
	288	if(adc[i] > 0) {
8bd3e27a	289	// printf(" Event, cell, adc, tof = %d %d %d %f\n",
	290	// outRunLoader->GetEventNumber(),i, map[i], time2[i]*10.0);
	291	// multiply by 10 to have 100 ps per channel :
fe0adf2a	292	AddDigit(i, adc[i], Int_t((time2[i]*10.0) +0.5)) ;}
20277079	293	}
c299dbe4	294
b0d2c2d3	295	treeD->Fill();
	296	outLoader->WriteDigits("OVERWRITE");
	297	outLoader->UnloadDigits();
	298	ResetDigit();
9e04c3b6	299	}
	300
	301	//____________________________________________________________________________
20277079	302	void AliVZERODigitizer::AddDigit(Int_t PMnumber, Int_t adc, Int_t time)
9e04c3b6	303	{
	304
	305	// Adds Digit
	306
	307	TClonesArray &ldigits = *fDigits;
20277079	308	new(ldigits[fNdigits++]) AliVZEROdigit(PMnumber,adc,time);
9e04c3b6	309	}
	310	//____________________________________________________________________________
	311	void AliVZERODigitizer::ResetDigit()
	312	{
fe0adf2a	313
9e04c3b6	314	// Clears Digits
fe0adf2a	315
9e04c3b6	316	fNdigits = 0;
b0d2c2d3	317	if (fDigits) fDigits->Delete();
9e04c3b6	318	}
ce7090f5	319
fe0adf2a	320	//____________________________________________________________________________
	321	void AliVZERODigitizer::GetCollisionMode()
	322	{
	323	// Retrieves the collision mode from GRP data
	324
	325	// Initialization of the GRP entry
	326
	327	Int_t run = AliCDBManager::Instance()->GetRun();
	328
	329	// printf("\n ++++++ Run Number retrieved as %d \n",run);
	330
	331	AliCDBEntry* entry = AliCDBManager::Instance()->Get("GRP/GRP/Data",run);
	332	AliGRPObject* grpData = 0x0;
	333
	334	if(entry){
	335	TMap* m = dynamic_cast<TMap*>(entry->GetObject()); // old GRP entry
	336	if(m){
	337	m->Print();
	338	grpData = new AliGRPObject();
	339	grpData->ReadValuesFromMap(m);
	340	}
	341	else{
	342	grpData = dynamic_cast<AliGRPObject*>(entry->GetObject()); // new GRP entry
	343	entry->SetOwner(0);
	344	}
	345	AliCDBManager::Instance()->UnloadFromCache("GRP/GRP/Data");
	346	}
	347
	348	if(!grpData) AliError("No GRP entry found in OCDB!");
	349
	350	// Retrieval of collision mode
	351
	352	TString beamType = grpData->GetBeamType();
	353	if(beamType==AliGRPObject::GetInvalidString()){
	354	AliError("GRP/GRP/Data entry: missing value for the beam type !");
	355	AliError("\t VZERO cannot retrieve beam type\n");
	356	return;
	357	}
	358
	359	if( (beamType.CompareTo("P-P") ==0) \|\| (beamType.CompareTo("p-p") ==0) ){
	360	fCollisionMode=0;
	361	}
	362	else if( (beamType.CompareTo("Pb-Pb") ==0) \|\| (beamType.CompareTo("A-A") ==0) ){
	363	fCollisionMode=1;
	364	}
	365
	366	fBeamEnergy = grpData->GetBeamEnergy();
	367	if(fBeamEnergy==AliGRPObject::GetInvalidFloat()) {
	368	AliError("GRP/GRP/Data entry: missing value for the beam energy ! Using 0");
	369	fBeamEnergy = 0.;
	370	}
	371
	372	// printf("\n ++++++ Beam type and collision mode retrieved as %s %d @ %1.3f GeV ++++++\n\n",beamType.Data(), fCollisionMode, fBeamEnergy);
	373
	374	}
	375
ce7090f5	376	//____________________________________________________________________________
	377	AliVZEROCalibData* AliVZERODigitizer::GetCalibData() const
	378
	379	{
c0b82b5a	380	AliCDBManager *man = AliCDBManager::Instance();
ce7090f5	381
c0b82b5a	382	AliCDBEntry *entry=0;
ce7090f5	383
c0b82b5a	384	entry = man->Get("VZERO/Calib/Data");
c0b82b5a	385
df791951	386	// if(!entry){
	387	// AliWarning("Load of calibration data from default storage failed!");
	388	// AliWarning("Calibration data will be loaded from local storage ($ALICE_ROOT)");
	389	// Int_t runNumber = man->GetRun();
162637e4	390	// entry = man->GetStorage("local://$ALICE_ROOT/OCDB")
df791951	391	// ->Get("VZERO/Calib/Data",runNumber);
	392	//
	393	// }
c0b82b5a	394
c0b82b5a	395	// Retrieval of data in directory VZERO/Calib/Data:
ce7090f5	396
ce7090f5	397
c0b82b5a	398	AliVZEROCalibData *calibdata = 0;
ce7090f5	399
c0b82b5a	400	if (entry) calibdata = (AliVZEROCalibData*) entry->GetObject();
df791951	401	if (!calibdata) AliFatal("No calibration data from calibration database !");
ce7090f5	402
c0b82b5a	403	return calibdata;
ce7090f5	404
	405	}
	406
8adc9b44	407	//____________________________________________________________________________
	408	Int_t AliVZERODigitizer::GetPMNumber(Int_t cell) const
	409
	410	{
	411
	412	Int_t pmNumber[80] = { 0, 1, 2, 3, 4, 5, 6, 7,
	413	8, 9, 10, 11, 12, 13, 14, 15,
	414	16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23,
	415	24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 30, 30, 31, 31,
	416	32, 33, 34, 35, 36, 37, 38, 39,
	417	40, 41, 42, 43, 44, 45, 46, 47,
	418	48, 49, 50, 51, 52, 53, 54, 55,
	419	56, 57, 58, 59, 60, 61, 62, 63 };
	420
	421	return pmNumber[cell];
	422	}
	423
	424