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

/* History of cvs commits:
 *
 * $Log$
 * Revision 1.2  2007/08/17 12:40:04  schutz
 * New analysis classes by Gustavo Conesa
 *
 * Revision 1.1.2.1  2007/07/26 10:32:09  schutz
 * new analysis classes in the the new analysis framework
 *
 *
 */

//_________________________________________________________________________
// Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and 
// Central Barrel Tracking detectors.
// Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
// Mother class of : AliGammaDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
//                 : AliGammaMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
//                 : AliGammaMCDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS) 
//                             and MC data in other 3 TClonesArray
//*-- Author: Gustavo Conesa (LNF-INFN) 
//////////////////////////////////////////////////////////////////////////////


// --- ROOT system ---
#include <TFormula.h>
#include <TMath.h>

//---- ANALYSIS system ----
#include "AliGammaReader.h"

ClassImp(AliGammaReader)


//____________________________________________________________________________
AliGammaReader::AliGammaReader() : 
  TObject(), fDataType(0),
  fSwitchOnEMCAL(0),  fSwitchOnPHOS(0),  fSwitchOnCTS(0),
  fCTSEtaCut(0.), fEMCALEtaCut(0.), fPHOSEtaCut(0.),
  fNeutralPtCut(0.), fChargedPtCut(0.),
  fEMCALIPDistance(0.),   fPHOSIPDistance(0.), 
  fEMCALMinAngle(0.),   fPHOSMinAngle(0.), 
  fEMCALPID(0),fPHOSPID(0),
  fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.),  fEMCALElectronWeight(0.),  
  fEMCALChargeWeight(0.),fEMCALNeutralWeight(0.),
  fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.),  fPHOSElectronWeight(0.), 
  fPHOSChargeWeight(0.) , fPHOSNeutralWeight(0.) ,
  fPHOSWeightFormula(0), fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0) 
{
  //Ctor

  fPhiEMCALCut[0]=0.;
  fPhiEMCALCut[1]=0.;
  fPhiPHOSCut[0]=0.;
  fPhiPHOSCut[1]=0.;
 
  //Initialize parameters
  InitParameters();
}

//____________________________________________________________________________
AliGammaReader::AliGammaReader(const AliGammaReader & g) :   
  TObject(g), fDataType(g.fDataType),
  fSwitchOnEMCAL(g.fSwitchOnEMCAL),  fSwitchOnPHOS(g.fSwitchOnPHOS),  fSwitchOnCTS(g.fSwitchOnCTS),
  fCTSEtaCut(g.fCTSEtaCut),  fEMCALEtaCut(g.fEMCALEtaCut),  fPHOSEtaCut(g.fPHOSEtaCut),
  fNeutralPtCut(g.fNeutralPtCut), fChargedPtCut(g.fChargedPtCut),
  fEMCALIPDistance(g.fEMCALIPDistance),  fPHOSIPDistance(g.fPHOSIPDistance),  
  fEMCALMinAngle(g.fEMCALMinAngle),  fPHOSMinAngle(g.fPHOSMinAngle), 
  fEMCALPID(g.fEMCALPID), 
  fPHOSPID(g.fPHOSPID),
  fEMCALPhotonWeight(g.fEMCALPhotonWeight), 
  fEMCALPi0Weight(g.fEMCALPi0Weight), 
  fEMCALElectronWeight(g.fEMCALElectronWeight), 
  fEMCALChargeWeight(g.fEMCALChargeWeight), 
  fEMCALNeutralWeight(g.fEMCALNeutralWeight), 
  fPHOSPhotonWeight(g.fPHOSPhotonWeight),
  fPHOSPi0Weight(g.fPHOSPi0Weight),
  fPHOSElectronWeight(g.fPHOSElectronWeight), 
  fPHOSChargeWeight(g.fPHOSChargeWeight),
  fPHOSNeutralWeight(g.fPHOSNeutralWeight),
  fPHOSWeightFormula(g.fPHOSWeightFormula), 
  fPHOSPhotonWeightFormula(g.fPHOSPhotonWeightFormula), 
  fPHOSPi0WeightFormula(g.fPHOSPi0WeightFormula) 
{
  // cpy ctor

  fPhiEMCALCut[0]=g.fPhiEMCALCut[0];
  fPhiEMCALCut[1]=g.fPhiEMCALCut[1];
  fPhiPHOSCut[0]=g.fPhiPHOSCut[0];
  fPhiPHOSCut[1]=g.fPhiPHOSCut[1];
}

//_________________________________________________________________________
AliGammaReader & AliGammaReader::operator = (const AliGammaReader & source)
{
  // assignment operator

  if(&source == this) return *this;

  fDataType = source.fDataType ;

  fSwitchOnEMCAL = source.fSwitchOnEMCAL;  
  fSwitchOnPHOS = source.fSwitchOnPHOS;
  fSwitchOnCTS = source.fSwitchOnCTS;

  fCTSEtaCut = source.fCTSEtaCut;  
  fEMCALEtaCut = source.fEMCALEtaCut;  
  fPHOSEtaCut = source.fPHOSEtaCut;
  fNeutralPtCut = source.fNeutralPtCut;
  fChargedPtCut = source.fChargedPtCut; 

  fPhiEMCALCut[0]=source.fPhiEMCALCut[0];
  fPhiEMCALCut[1]=source.fPhiEMCALCut[1];
  fPhiPHOSCut[0]=source.fPhiPHOSCut[0];
  fPhiPHOSCut[1]=source.fPhiPHOSCut[1];

  fEMCALIPDistance = source.fEMCALIPDistance; 
  fPHOSIPDistance = source.fPHOSIPDistance; 
  fEMCALMinAngle = source.fEMCALMinAngle; 
  fPHOSMinAngle = source.fPHOSMinAngle; 

  fEMCALPID = source.fEMCALPID ;
  fPHOSPID = source.fPHOSPID ;

  fEMCALPhotonWeight = source. fEMCALPhotonWeight ;
  fEMCALPi0Weight = source.fEMCALPi0Weight ;
  fEMCALElectronWeight = source.fEMCALElectronWeight; 
  fEMCALChargeWeight = source.fEMCALChargeWeight;
  fEMCALNeutralWeight = source.fEMCALNeutralWeight;

  fPHOSPhotonWeight = source.fPHOSPhotonWeight ;
  fPHOSPi0Weight = source.fPHOSPi0Weight ;
  fPHOSElectronWeight = source.fPHOSElectronWeight; 
  fPHOSChargeWeight = source.fPHOSChargeWeight;
  fPHOSNeutralWeight = source.fPHOSNeutralWeight;

  fPHOSWeightFormula       = source.fPHOSWeightFormula; 
  fPHOSPhotonWeightFormula = source.fPHOSPhotonWeightFormula; 
  fPHOSPi0WeightFormula    = source.fPHOSPi0WeightFormula;


  return *this;

}

//_______________________________________________________________
void AliGammaReader::InitParameters()
{
 
  //Initialize the parameters of the analysis.
  fDataType = kData ;

  fSwitchOnEMCAL = kTRUE ;  
  fSwitchOnPHOS = kTRUE ;
  fSwitchOnCTS = kTRUE ;

  fCTSEtaCut         = 0.7 ;  
  fEMCALEtaCut         = 0.7 ;  
  fPHOSEtaCut         = 0.12 ;
  fPhiEMCALCut[0] = 80 *TMath::DegToRad();
  fPhiEMCALCut[1] = 190*TMath::DegToRad();
  fPhiPHOSCut[0] = 220. *TMath::DegToRad();
  fPhiPHOSCut[1] = 320.*TMath::DegToRad();
  fNeutralPtCut   = 0.5 ;
  fChargedPtCut   = 0.5 ;

  fEMCALMinAngle    =   2.5 * TMath::DegToRad() ;  
  fPHOSMinAngle    = 0.45 * TMath::DegToRad() ; //3.6 ;
  fEMCALIPDistance    = 450. ;//cm  
  fPHOSIPDistance    = 445. ;//cm 460 (EMCA) - 15 (CPV)

  //pid, only for ESD data
  fEMCALPID = kFALSE;
  fPHOSPID = kFALSE;

  fEMCALPhotonWeight = 0.8 ;
  fEMCALPi0Weight = 0.5 ;
  fEMCALElectronWeight = 0.8 ;
  fEMCALChargeWeight = 0.5 ;
  fEMCALNeutralWeight = 0.5 ;

  fPHOSPhotonWeight = 0.75 ;
  fPHOSPi0Weight = 0.8 ;
  fPHOSElectronWeight = 0.5 ;
  fPHOSChargeWeight = 0.5 ;
  fPHOSNeutralWeight = 0.5 ;

  //Formula to set the PID weight threshold for photon or pi0
  fPHOSWeightFormula = kTRUE;
  fPHOSPhotonWeightFormula = 
    new TFormula("photonWeight","0.98*(x<40)+ 0.68*(x>=100)+(x>=40 && x<100)*(0.98+x*(6e-3)-x*x*(2e-04)+x*x*x*(1.1e-06))");
  fPHOSPi0WeightFormula = 
    new TFormula("pi0Weight","0.98*(x<65)+ 0.915*(x>=100)+(x>=65 && x-x*(1.95e-3)-x*x*(4.31e-05)+x*x*x*(3.61e-07))");

}


//________________________________________________________________
void AliGammaReader::Print(const Option_t * opt) const
{

  //Print some relevant parameters set for the analysis
  if(! opt)
    return;

  Info("Print", "%s %s", GetName(), GetTitle() ) ;
  printf("Data type           : %d\n", fDataType) ;

  printf(" EMCAL on?          : %d\n", fSwitchOnEMCAL) ;
  printf(" PHOS on?          : %d\n", fSwitchOnPHOS) ;
  printf(" CTS on?          : %d\n", fSwitchOnCTS) ;

  printf("CTS Eta cut           : %f\n", fCTSEtaCut) ;
  printf("EMCAL Eta cut           : %f\n", fEMCALEtaCut) ;
  printf("PHOS Eta cut           : %f\n", fPHOSEtaCut) ;
  printf("Phi EMCAL cut           : [%f, %f]\n", fPhiEMCALCut[0],fPhiEMCALCut[1]) ;
  printf("Phi PHOS cut           : [%f, %f]\n", fPhiPHOSCut[0],fPhiPHOSCut[1]) ;
  printf("pT neutral cut           : %f GeV/c\n", fNeutralPtCut) ;
  printf("pT charged cut           : %f GeV/c\n", fChargedPtCut) ;

  if(fDataType == kMC || fDataType == kMCData){
    printf("IP distance to PHOS         : %f\n", fPHOSIPDistance) ;
    printf("IP distance to EMCAL         : %f\n", fEMCALIPDistance) ;
    printf("Min gamma decay aperture angle in PHOS         : %f\n", fPHOSMinAngle) ;
    printf("Min gamma decay aperture angle in EMCAL         : %f\n", fEMCALMinAngle) ;
  }
  
  if(fDataType != kMC){
    printf("PHOS PID on?               =     %d\n",  fPHOSPID) ; 
    printf("EMCAL PID  on?         =     %d\n",  fEMCALPID) ;
    printf("PHOS PID weight , photon %f, pi0 %f, e %f, charge %f, neutral %f \n",  
	   fPHOSPhotonWeight,  fPHOSPi0Weight, 
	   fPHOSElectronWeight,  fPHOSChargeWeight,   fPHOSNeutralWeight) ; 
    printf("EMCAL PID weight, photon %f, pi0 %f, e %f, charge %f, neutral %f\n",   
	   fEMCALPhotonWeight,  fEMCALPi0Weight, 
	   fEMCALElectronWeight,  fEMCALChargeWeight,  fEMCALNeutralWeight) ; 
    
    printf("PHOS Parametrized weight on?               =     %d\n",  fPHOSWeightFormula) ; 
    if(fPHOSWeightFormula){
      printf(">>>>>>>>>>> Photon weight formula<<<<<<<<<<<<\n");
      fPHOSPhotonWeightFormula->Print();
      printf(">>>>>>>>>>> Pi0    weight formula<<<<<<<<<<<<\n");
      fPHOSPhotonWeightFormula->Print();
    }
  }

}
Commit	Line	Data
bdcfac30	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	/* $Id$ */
	16
	17	/* History of cvs commits:
	18	*
	19	* $Log$
4b707925	20	* Revision 1.2 2007/08/17 12:40:04 schutz
	21	* New analysis classes by Gustavo Conesa
	22	*
bdcfac30	23	* Revision 1.1.2.1 2007/07/26 10:32:09 schutz
	24	* new analysis classes in the the new analysis framework
	25	*
	26	*
	27	*/
	28
	29	//_________________________________________________________________________
3bb2c538	30	// Base class for reading data: MonteCarlo, ESD or AOD, of PHOS EMCAL and
	31	// Central Barrel Tracking detectors.
	32	// Not all MC particles/tracks/clusters are kept, some kinematical restrictions are done.
	33	// Mother class of : AliGammaDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
	34	// : AliGammaMCReader: Fills Kinematics data in 3 TClonesArrays (PHOS, EMCAL, CTS)
	35	// : AliGammaMCDataReader: Fills ESD data in 3 TClonesArrays (PHOS, EMCAL, CTS)
	36	// and MC data in other 3 TClonesArray
bdcfac30	37	//*-- Author: Gustavo Conesa (LNF-INFN)
	38	//////////////////////////////////////////////////////////////////////////////
	39
	40
	41	// --- ROOT system ---
3bb2c538	42	#include <TFormula.h>
3bb2c538	43	#include <TMath.h>
bdcfac30	44
bdcfac30	45	//---- ANALYSIS system ----
bdcfac30	46	#include "AliGammaReader.h"
	47
	48	ClassImp(AliGammaReader)
	49
	50
	51	//____________________________________________________________________________
	52	AliGammaReader::AliGammaReader() :
	53	TObject(), fDataType(0),
3bb2c538	54	fSwitchOnEMCAL(0), fSwitchOnPHOS(0), fSwitchOnCTS(0),
bdcfac30	55	fCTSEtaCut(0.), fEMCALEtaCut(0.), fPHOSEtaCut(0.),
4b707925	56	fNeutralPtCut(0.), fChargedPtCut(0.),
	57	fEMCALIPDistance(0.), fPHOSIPDistance(0.),
	58	fEMCALMinAngle(0.), fPHOSMinAngle(0.),
	59	fEMCALPID(0),fPHOSPID(0),
	60	fEMCALPhotonWeight(0.), fEMCALPi0Weight(0.), fEMCALElectronWeight(0.),
	61	fEMCALChargeWeight(0.),fEMCALNeutralWeight(0.),
	62	fPHOSPhotonWeight(0.), fPHOSPi0Weight(0.), fPHOSElectronWeight(0.),
	63	fPHOSChargeWeight(0.) , fPHOSNeutralWeight(0.) ,
	64	fPHOSWeightFormula(0), fPHOSPhotonWeightFormula(0x0), fPHOSPi0WeightFormula(0x0)
bdcfac30	65	{
	66	//Ctor
	67
	68	fPhiEMCALCut[0]=0.;
	69	fPhiEMCALCut[1]=0.;
	70	fPhiPHOSCut[0]=0.;
	71	fPhiPHOSCut[1]=0.;
	72
	73	//Initialize parameters
	74	InitParameters();
	75	}
	76
	77	//____________________________________________________________________________
	78	AliGammaReader::AliGammaReader(const AliGammaReader & g) :
	79	TObject(g), fDataType(g.fDataType),
3bb2c538	80	fSwitchOnEMCAL(g.fSwitchOnEMCAL), fSwitchOnPHOS(g.fSwitchOnPHOS), fSwitchOnCTS(g.fSwitchOnCTS),
bdcfac30	81	fCTSEtaCut(g.fCTSEtaCut), fEMCALEtaCut(g.fEMCALEtaCut), fPHOSEtaCut(g.fPHOSEtaCut),
4b707925	82	fNeutralPtCut(g.fNeutralPtCut), fChargedPtCut(g.fChargedPtCut),
	83	fEMCALIPDistance(g.fEMCALIPDistance), fPHOSIPDistance(g.fPHOSIPDistance),
	84	fEMCALMinAngle(g.fEMCALMinAngle), fPHOSMinAngle(g.fPHOSMinAngle),
	85	fEMCALPID(g.fEMCALPID),
	86	fPHOSPID(g.fPHOSPID),
	87	fEMCALPhotonWeight(g.fEMCALPhotonWeight),
	88	fEMCALPi0Weight(g.fEMCALPi0Weight),
	89	fEMCALElectronWeight(g.fEMCALElectronWeight),
	90	fEMCALChargeWeight(g.fEMCALChargeWeight),
	91	fEMCALNeutralWeight(g.fEMCALNeutralWeight),
	92	fPHOSPhotonWeight(g.fPHOSPhotonWeight),
	93	fPHOSPi0Weight(g.fPHOSPi0Weight),
	94	fPHOSElectronWeight(g.fPHOSElectronWeight),
	95	fPHOSChargeWeight(g.fPHOSChargeWeight),
	96	fPHOSNeutralWeight(g.fPHOSNeutralWeight),
	97	fPHOSWeightFormula(g.fPHOSWeightFormula),
	98	fPHOSPhotonWeightFormula(g.fPHOSPhotonWeightFormula),
	99	fPHOSPi0WeightFormula(g.fPHOSPi0WeightFormula)
bdcfac30	100	{
	101	// cpy ctor
	102
	103	fPhiEMCALCut[0]=g.fPhiEMCALCut[0];
	104	fPhiEMCALCut[1]=g.fPhiEMCALCut[1];
	105	fPhiPHOSCut[0]=g.fPhiPHOSCut[0];
	106	fPhiPHOSCut[1]=g.fPhiPHOSCut[1];
	107	}
	108
	109	//_________________________________________________________________________
	110	AliGammaReader & AliGammaReader::operator = (const AliGammaReader & source)
	111	{
	112	// assignment operator
	113
	114	if(&source == this) return *this;
	115
	116	fDataType = source.fDataType ;
3bb2c538	117
	118	fSwitchOnEMCAL = source.fSwitchOnEMCAL;
	119	fSwitchOnPHOS = source.fSwitchOnPHOS;
	120	fSwitchOnCTS = source.fSwitchOnCTS;
	121
bdcfac30	122	fCTSEtaCut = source.fCTSEtaCut;
	123	fEMCALEtaCut = source.fEMCALEtaCut;
	124	fPHOSEtaCut = source.fPHOSEtaCut;
	125	fNeutralPtCut = source.fNeutralPtCut;
	126	fChargedPtCut = source.fChargedPtCut;
	127
	128	fPhiEMCALCut[0]=source.fPhiEMCALCut[0];
	129	fPhiEMCALCut[1]=source.fPhiEMCALCut[1];
	130	fPhiPHOSCut[0]=source.fPhiPHOSCut[0];
	131	fPhiPHOSCut[1]=source.fPhiPHOSCut[1];
	132
4b707925	133	fEMCALIPDistance = source.fEMCALIPDistance;
	134	fPHOSIPDistance = source.fPHOSIPDistance;
	135	fEMCALMinAngle = source.fEMCALMinAngle;
	136	fPHOSMinAngle = source.fPHOSMinAngle;
	137
	138	fEMCALPID = source.fEMCALPID ;
	139	fPHOSPID = source.fPHOSPID ;
	140
	141	fEMCALPhotonWeight = source. fEMCALPhotonWeight ;
	142	fEMCALPi0Weight = source.fEMCALPi0Weight ;
	143	fEMCALElectronWeight = source.fEMCALElectronWeight;
	144	fEMCALChargeWeight = source.fEMCALChargeWeight;
	145	fEMCALNeutralWeight = source.fEMCALNeutralWeight;
	146
	147	fPHOSPhotonWeight = source.fPHOSPhotonWeight ;
	148	fPHOSPi0Weight = source.fPHOSPi0Weight ;
	149	fPHOSElectronWeight = source.fPHOSElectronWeight;
	150	fPHOSChargeWeight = source.fPHOSChargeWeight;
	151	fPHOSNeutralWeight = source.fPHOSNeutralWeight;
	152
	153	fPHOSWeightFormula = source.fPHOSWeightFormula;
	154	fPHOSPhotonWeightFormula = source.fPHOSPhotonWeightFormula;
	155	fPHOSPi0WeightFormula = source.fPHOSPi0WeightFormula;
	156
	157
bdcfac30	158	return *this;
	159
	160	}
	161
	162	//_______________________________________________________________
	163	void AliGammaReader::InitParameters()
	164	{
	165
	166	//Initialize the parameters of the analysis.
	167	fDataType = kData ;
3bb2c538	168
	169	fSwitchOnEMCAL = kTRUE ;
	170	fSwitchOnPHOS = kTRUE ;
	171	fSwitchOnCTS = kTRUE ;
	172
bdcfac30	173	fCTSEtaCut = 0.7 ;
	174	fEMCALEtaCut = 0.7 ;
	175	fPHOSEtaCut = 0.12 ;
	176	fPhiEMCALCut[0] = 80 *TMath::DegToRad();
	177	fPhiEMCALCut[1] = 190*TMath::DegToRad();
	178	fPhiPHOSCut[0] = 220. *TMath::DegToRad();
	179	fPhiPHOSCut[1] = 320.*TMath::DegToRad();
	180	fNeutralPtCut = 0.5 ;
	181	fChargedPtCut = 0.5 ;
	182
4b707925	183	fEMCALMinAngle = 2.5 * TMath::DegToRad() ;
	184	fPHOSMinAngle = 0.45 * TMath::DegToRad() ; //3.6 ;
	185	fEMCALIPDistance = 450. ;//cm
	186	fPHOSIPDistance = 445. ;//cm 460 (EMCA) - 15 (CPV)
	187
	188	//pid, only for ESD data
	189	fEMCALPID = kFALSE;
	190	fPHOSPID = kFALSE;
	191
	192	fEMCALPhotonWeight = 0.8 ;
	193	fEMCALPi0Weight = 0.5 ;
	194	fEMCALElectronWeight = 0.8 ;
	195	fEMCALChargeWeight = 0.5 ;
	196	fEMCALNeutralWeight = 0.5 ;
	197
	198	fPHOSPhotonWeight = 0.75 ;
	199	fPHOSPi0Weight = 0.8 ;
	200	fPHOSElectronWeight = 0.5 ;
	201	fPHOSChargeWeight = 0.5 ;
	202	fPHOSNeutralWeight = 0.5 ;
	203
	204	//Formula to set the PID weight threshold for photon or pi0
	205	fPHOSWeightFormula = kTRUE;
	206	fPHOSPhotonWeightFormula =
	207	new TFormula("photonWeight","0.98(x<40)+ 0.68(x>=100)+(x>=40 && x<100)(0.98+x(6e-3)-xx(2e-04)+xxx*(1.1e-06))");
	208	fPHOSPi0WeightFormula =
	209	new TFormula("pi0Weight","0.98(x<65)+ 0.915(x>=100)+(x>=65 && x-x(1.95e-3)-xx(4.31e-05)+xxx(3.61e-07))");
	210
bdcfac30	211	}
	212
	213
	214	//________________________________________________________________
	215	void AliGammaReader::Print(const Option_t * opt) const
	216	{
	217
	218	//Print some relevant parameters set for the analysis
	219	if(! opt)
	220	return;
	221
	222	Info("Print", "%s %s", GetName(), GetTitle() ) ;
	223	printf("Data type : %d\n", fDataType) ;
3bb2c538	224
	225	printf(" EMCAL on? : %d\n", fSwitchOnEMCAL) ;
	226	printf(" PHOS on? : %d\n", fSwitchOnPHOS) ;
	227	printf(" CTS on? : %d\n", fSwitchOnCTS) ;
	228
bdcfac30	229	printf("CTS Eta cut : %f\n", fCTSEtaCut) ;
	230	printf("EMCAL Eta cut : %f\n", fEMCALEtaCut) ;
	231	printf("PHOS Eta cut : %f\n", fPHOSEtaCut) ;
	232	printf("Phi EMCAL cut : [%f, %f]\n", fPhiEMCALCut[0],fPhiEMCALCut[1]) ;
	233	printf("Phi PHOS cut : [%f, %f]\n", fPhiPHOSCut[0],fPhiPHOSCut[1]) ;
	234	printf("pT neutral cut : %f GeV/c\n", fNeutralPtCut) ;
	235	printf("pT charged cut : %f GeV/c\n", fChargedPtCut) ;
	236
4b707925	237	if(fDataType == kMC \|\| fDataType == kMCData){
	238	printf("IP distance to PHOS : %f\n", fPHOSIPDistance) ;
	239	printf("IP distance to EMCAL : %f\n", fEMCALIPDistance) ;
	240	printf("Min gamma decay aperture angle in PHOS : %f\n", fPHOSMinAngle) ;
	241	printf("Min gamma decay aperture angle in EMCAL : %f\n", fEMCALMinAngle) ;
	242	}
	243
	244	if(fDataType != kMC){
	245	printf("PHOS PID on? = %d\n", fPHOSPID) ;
	246	printf("EMCAL PID on? = %d\n", fEMCALPID) ;
	247	printf("PHOS PID weight , photon %f, pi0 %f, e %f, charge %f, neutral %f \n",
	248	fPHOSPhotonWeight, fPHOSPi0Weight,
	249	fPHOSElectronWeight, fPHOSChargeWeight, fPHOSNeutralWeight) ;
	250	printf("EMCAL PID weight, photon %f, pi0 %f, e %f, charge %f, neutral %f\n",
	251	fEMCALPhotonWeight, fEMCALPi0Weight,
	252	fEMCALElectronWeight, fEMCALChargeWeight, fEMCALNeutralWeight) ;
	253
	254	printf("PHOS Parametrized weight on? = %d\n", fPHOSWeightFormula) ;
	255	if(fPHOSWeightFormula){
	256	printf(">>>>>>>>>>> Photon weight formula<<<<<<<<<<<<\n");
	257	fPHOSPhotonWeightFormula->Print();
	258	printf(">>>>>>>>>>> Pi0 weight formula<<<<<<<<<<<<\n");
	259	fPHOSPhotonWeightFormula->Print();
	260	}
	261	}
	262
bdcfac30	263	}
	264
	265