[u/mrichter/AliRoot.git] / PWG2 / FORWARD / analysis2 / AliCentralMultiplicityTask.cxx

//====================================================================
// 
// Base class for classes that calculate the multiplicity in the
// central region event-by-event
// 
// Inputs: 
//   - AliESDEvent 
//
// Outputs: 
//   - AliAODCentralMult 
// 
// Histograms 
//   
// Corrections used 
#include "AliCentralMultiplicityTask.h"
#include "AliForwardCorrectionManager.h"
#include "AliForwardUtil.h"
#include "AliLog.h"
#include "AliAODHandler.h"
#include "AliInputEventHandler.h"
#include "AliESDInputHandler.h"
#include "AliAnalysisManager.h"
#include "AliESDEvent.h"
#include "AliMultiplicity.h"
#include "AliFMDEventInspector.h"
#include <TROOT.h>
#include <TFile.h>
#include <TError.h>
#include <iostream>
#include <iomanip>

//====================================================================
AliCentralMultiplicityTask::AliCentralMultiplicityTask(const char* name) 
  : AliAnalysisTaskSE(name),
    fData(0),
    fList(0),
    fAODCentral(kFALSE),
    fManager(),
    fUseSecondary(true),
    fUseAcceptance(true),
    fFirstEventSeen(false)
{
  // 
  // Constructor 
  //   
  DefineOutput(1, TList::Class());
  fBranchNames = 
    "ESD:AliESDRun.,AliESDHeader.,AliMultiplicity.,"
    "SPDVertex.,PrimaryVertex.";
}
//____________________________________________________________________
AliCentralMultiplicityTask::AliCentralMultiplicityTask() 
  : AliAnalysisTaskSE(),
    fData(0),
    fList(0),
    fAODCentral(),
    fManager(),
    fUseSecondary(true),
    fUseAcceptance(true),
    fFirstEventSeen(false)
{
  // 
  // Constructor 
  // 
}
//____________________________________________________________________
AliCentralMultiplicityTask::AliCentralMultiplicityTask(const AliCentralMultiplicityTask& o)
  : AliAnalysisTaskSE(o),
    fData(o.fData),
    fList(o.fList),
    fAODCentral(o.fAODCentral),
    fManager(o.fManager),
    fUseSecondary(o.fUseSecondary),
    fUseAcceptance(o.fUseAcceptance),
    fFirstEventSeen(o.fFirstEventSeen)
{
  //
  // Copy constructor 
  // 
}
//____________________________________________________________________
AliCentralMultiplicityTask&
AliCentralMultiplicityTask::operator=(const AliCentralMultiplicityTask& o)
{
  // 
  // Assignment operator 
  //
  fData           = o.fData;
  fList           = o.fList;
  fAODCentral     = o.fAODCentral;
  fManager        = o.fManager;
  fUseSecondary   = o.fUseSecondary;
  fUseAcceptance  = o.fUseAcceptance;
  fFirstEventSeen = o.fFirstEventSeen;
  return *this;
}
//____________________________________________________________________
void AliCentralMultiplicityTask::UserCreateOutputObjects() 
{
  // 
  // Create output objects 
  // 
  //

  AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
  AliAODHandler*      ah = 
    dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
  if (!ah) AliFatal("No AOD output handler set in analysis manager");
  
  
  TObject* obj = &fAODCentral;
  ah->AddBranch("AliAODCentralMult", &obj);
  
  fList = new TList();
  fList->SetOwner();
  PostData(1,fList);
  
}
//____________________________________________________________________
void AliCentralMultiplicityTask::UserExec(Option_t* /*option*/) 
{
  // 
  // Process each event 
  // 
  // Parameters:
  //    option Not used
  //  
  
  AliESDInputHandler* eventHandler = 
    dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()
				       ->GetInputEventHandler());
  if (!eventHandler) {
    AliWarning("No inputhandler found for this event!");
    return;}
  
  AliESDEvent* esd = eventHandler->GetEvent();
  
  if(!GetManager().IsInit() && !fFirstEventSeen) {
    AliFMDEventInspector inspector;
    inspector.ReadRunDetails(esd);
    GetManager().Init(inspector.GetCollisionSystem(),
		      inspector.GetEnergy(),
		      inspector.GetField());
    
    AliInfo("Manager of corrections in AliCentralMultiplicityTask init");
    fFirstEventSeen = kTRUE;
  }
  
  //Selecting only events with |valid vertex| < 10 cm
  const AliESDVertex* vertex = esd->GetPrimaryVertexSPD();
  if (!vertex) return;
  if(!(vertex->GetStatus())) return;
  if(vertex->GetNContributors() <= 0) return ;
  if(vertex->GetZRes() > 0.1 ) return;
  Double_t vertexXYZ[3]={0,0,0};
  vertex->GetXYZ(vertexXYZ);
  if(TMath::Abs(vertexXYZ[2]) > 10) return;
  
  Double_t delta           = 2 ;
  Double_t vertexBinDouble = (vertexXYZ[2] + 10) / delta;
  //HHD: The vtxbins are 1-10, not 0-9
  Int_t    vtxbin          = Int_t(vertexBinDouble + 1) ; 
  
  // Make sure AOD is filled
  AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
  AliAODHandler*      ah = 
    dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
  if (!ah)  
    AliFatal("No AOD output handler set in analysis manager");
  
  ah->SetFillAOD(kTRUE);
  
  //Doing analysis
  fAODCentral.Clear("");
  TH2D *aodHist = &(fAODCentral.GetHistogram());
  
  const AliMultiplicity* spdmult = esd->GetMultiplicity();
  //Filling clusters in layer 1 used for tracklets...
  for(Int_t j = 0; j< spdmult->GetNumberOfTracklets();j++)
    aodHist->Fill(spdmult->GetEta(j),spdmult->GetPhi(j));

  //...and then the unused ones in layer 1 
  for(Int_t j = 0; j< spdmult->GetNumberOfSingleClusters();j++) 
    aodHist->Fill(-TMath::Log(TMath::Tan(spdmult->GetThetaSingle(j)/2.)),
		  spdmult->GetPhiSingle(j));
  
  
  // Corrections
  TH1D* hAcceptance = fManager.GetAcceptanceCorrection(vtxbin);
  TH2D* hSecMap     = fManager.GetSecMapCorrection(vtxbin);
  
  if (!hSecMap)     AliFatal("No secondary map!");
  if (!hAcceptance) AliFatal("No acceptance!");
    
  if (fUseSecondary && hSecMap) aodHist->Divide(hSecMap);
  
  for(Int_t nx = 1; nx <= aodHist->GetNbinsX(); nx++) {
    Float_t accCor = hAcceptance->GetBinContent(nx);
    Float_t accErr = hAcceptance->GetBinError(nx);
    
    Bool_t etabinSeen = kFALSE;  
    for(Int_t ny = 1; ny <= aodHist->GetNbinsY(); ny++) {
      // Get currrent value 
      Float_t aodValue = aodHist->GetBinContent(nx,ny);
      Float_t aodErr   = aodHist->GetBinError(nx,ny);

      // Set underflow bin
      Float_t secCor   = 0;
      if(hSecMap) secCor   = hSecMap->GetBinContent(nx,ny);
      if (secCor > 0.5) etabinSeen = kTRUE;
      if (aodValue < 0.000001) { aodHist->SetBinContent(nx,ny, 0); continue; }

      if (!fUseAcceptance) continue; 

      // Acceptance correction 
      if (accCor   < 0.000001) accCor = 1;
      Float_t aodNew   = aodValue / accCor ;
      Float_t error    = aodNew*TMath::Sqrt(TMath::Power(aodErr/aodValue,2) +
					    TMath::Power(accErr/accCor,2) );
      aodHist->SetBinContent(nx,ny, aodNew);
      //test
      aodHist->SetBinError(nx,ny,error);
      aodHist->SetBinError(nx,ny,aodErr);
      
    }
    //Filling underflow bin if we eta bin is in range
    if(etabinSeen) aodHist->SetBinContent(nx,0, 1.);
  }  

  PostData(1,fList);
}
//____________________________________________________________________
void AliCentralMultiplicityTask::Terminate(Option_t* /*option*/) 
{
  // 
  // End of job
  // 
  // Parameters:
  //    option Not used 
  //
}
//____________________________________________________________________
void
AliCentralMultiplicityTask::Print(Option_t* /*option*/) const
{
  // 
  // Print information 
  // 
  // Parameters:
  //    option Not used
  //
}
//====================================================================
AliCentralMultiplicityTask::Manager::Manager() :
  fAcceptancePath("$ALICE_ROOT/PWG2/FORWARD/corrections/CentralAcceptance"),
  fSecMapPath("$ALICE_ROOT/PWG2/FORWARD/corrections/CentralSecMap"),
  fAcceptance(),
  fSecmap(),
  fAcceptanceName("centralacceptance"),
  fSecMapName("centralsecmap"),
  fIsInit(kFALSE)
{
  //
  // Constructor 
  // 
}
//____________________________________________________________________
AliCentralMultiplicityTask::Manager::Manager(const Manager& o) 
  :fAcceptancePath(o.fAcceptancePath),
   fSecMapPath(o.fSecMapPath),
   fAcceptance(o.fAcceptance),
   fSecmap(o.fSecmap),
   fAcceptanceName(o.fAcceptanceName),
   fSecMapName(o.fSecMapName),
   fIsInit(o.fIsInit)
{
  //
  // Copy Constructor 
  // 
}
//____________________________________________________________________
AliCentralMultiplicityTask::Manager&
AliCentralMultiplicityTask::Manager::operator=(const Manager& o)
{
  //
  // Assignment operator  
  // 
  fAcceptancePath = o.fAcceptancePath;
  fSecMapPath     = o.fSecMapPath;
  fAcceptance     = o.fAcceptance;
  fSecmap         = o.fSecmap;
  fAcceptanceName = o.fAcceptanceName;
  fSecMapName     = o.fSecMapName;
  fIsInit         = o.fIsInit;
  return *this;
}

//____________________________________________________________________
const char* 
AliCentralMultiplicityTask::Manager::GetFullFileName(UShort_t what, 
						     UShort_t sys, 
						     UShort_t sNN,  
						     Short_t  field) const
{
  // 
  // Get full path name to object file 
  // 
  // Parameters:
  //    what   What to get 
  //    sys    Collision system
  //    sNN    Center of mass energy 
  //    field  Magnetic field 
  // 
  // Return:
  //    
  //
  return Form("%s/%s",
	      what == 0 ? GetSecMapPath() : GetAcceptancePath(), 
	      GetFileName(what, sys, sNN, field));
}

//____________________________________________________________________
const char* 
AliCentralMultiplicityTask::Manager::GetFileName(UShort_t  what ,
						 UShort_t  sys, 
						 UShort_t  sNN,
						 Short_t   field) const
{
  // 
  // Get the full path name 
  // 
  // Parameters:
  //    what   What to get
  //    sys    Collision system
  //    sNN    Center of mass energy 
  //    field  Magnetic field 
  // 
  // Return:
  //    
  //
  // Must be static - otherwise the data may disappear on return from
  // this member function
  static TString fname = "";
  
  fname = "";
  switch(what) {
  case 0:  fname.Append(fSecMapName.Data());     break;
  case 1:  fname.Append(fAcceptanceName.Data()); break;
  default:
    ::Error("GetFileName", 
	    "Invalid indentifier %d for central object, must be 0 or 1!", what);
    break;
  }
  fname.Append(Form("_%s_%04dGeV_%c%1dkG.root", 
		    AliForwardUtil::CollisionSystemString(sys), 
		    sNN, (field < 0 ? 'm' : 'p'), TMath::Abs(field)));
  
  return fname.Data();
}

//____________________________________________________________________
TH2D* 
AliCentralMultiplicityTask::Manager::GetSecMapCorrection(UShort_t vtxbin) const
{
  // 
  // Get the secondary map
  // 
  // Parameters:
  //    vtxbin 
  // 
  // Return:
  //    
  //
  if (!fSecmap) { 
    ::Warning("GetSecMapCorrection","No secondary map defined");
    return 0;
  }
  return fSecmap->GetCorrection(vtxbin);
}
//____________________________________________________________________
TH1D* 
AliCentralMultiplicityTask::Manager::GetAcceptanceCorrection(UShort_t vtxbin) 
  const 
{
  // 
  // Get the acceptance correction 
  // 
  // Parameters:
  //    vtxbin 
  // 
  // Return:
  //    
  //
  if (!fAcceptance) { 
    ::Warning("GetAcceptanceCorrection","No acceptance map defined");
    return 0;
  }
  return fAcceptance->GetCorrection(vtxbin);
}

//____________________________________________________________________
void 
AliCentralMultiplicityTask::Manager::Init(UShort_t  sys, 
					  UShort_t  sNN,
					  Short_t   field) 
{
  // 
  // Initialize 
  // 
  // Parameters:
  //    sys    Collision system (1: pp, 2: PbPb)
  //    sNN    Center of mass energy per nucleon pair [GeV]
  //    field  Magnetic field [kG]
  //
  if(fIsInit) ::Warning("Init","Already initialised - overriding...");
  
  TFile fsec(GetFullFileName(0,sys,sNN,field));
  fSecmap = 
    dynamic_cast<AliCentralCorrSecondaryMap*>(fsec.Get(fSecMapName.Data()));  
  if(!fSecmap) {
    ::Error("Init", "no central Secondary Map found!") ;
    return;
  }
  TFile facc(GetFullFileName(1,sys,sNN,field));
  fAcceptance = 
    dynamic_cast<AliCentralCorrAcceptance*>(facc.Get(fAcceptanceName.Data()));
  if(!fAcceptance) {
    ::Error("Init", "no central Acceptance found!") ;
    return;
  }
  
  if(fSecmap && fAcceptance) {
    fIsInit = kTRUE;
    ::Info("Init", 
	   "Central Manager initialised for sys %d, energy %d, field %d",sys,sNN,field);

  }
  
}
//
// EOF
//
Commit	Line	Data
6f791cc3	1	//====================================================================
	2	//
	3	// Base class for classes that calculate the multiplicity in the
	4	// central region event-by-event
	5	//
	6	// Inputs:
	7	// - AliESDEvent
	8	//
	9	// Outputs:
	10	// - AliAODCentralMult
	11	//
	12	// Histograms
	13	//
	14	// Corrections used
	15	#include "AliCentralMultiplicityTask.h"
	16	#include "AliForwardCorrectionManager.h"
	17	#include "AliForwardUtil.h"
	18	#include "AliLog.h"
	19	#include "AliAODHandler.h"
	20	#include "AliInputEventHandler.h"
	21	#include "AliESDInputHandler.h"
	22	#include "AliAnalysisManager.h"
	23	#include "AliESDEvent.h"
	24	#include "AliMultiplicity.h"
e58000b7	25	#include "AliFMDEventInspector.h"
6f791cc3	26	#include <TROOT.h>
6f791cc3	27	#include <TFile.h>
3e478dba	28	#include <TError.h>
6f791cc3	29	#include <iostream>
	30	#include <iomanip>
	31
	32	//====================================================================
	33	AliCentralMultiplicityTask::AliCentralMultiplicityTask(const char* name)
	34	: AliAnalysisTaskSE(name),
	35	fData(0),
	36	fList(0),
	37	fAODCentral(kFALSE),
3b2bfb07	38	fManager(),
e58000b7	39	fUseSecondary(true),
9453b19e	40	fUseAcceptance(true),
fb3430ac	41	fFirstEventSeen(false)
6f791cc3	42	{
fb3430ac	43	//
	44	// Constructor
	45	//
6f791cc3	46	DefineOutput(1, TList::Class());
a59cbd24	47	fBranchNames =
	48	"ESD:AliESDRun.,AliESDHeader.,AliMultiplicity.,"
	49	"SPDVertex.,PrimaryVertex.";
6f791cc3	50	}
6f791cc3	51	//____________________________________________________________________
9c825779	52	AliCentralMultiplicityTask::AliCentralMultiplicityTask()
	53	: AliAnalysisTaskSE(),
	54	fData(0),
	55	fList(0),
	56	fAODCentral(),
3b2bfb07	57	fManager(),
e58000b7	58	fUseSecondary(true),
9453b19e	59	fUseAcceptance(true),
fb3430ac	60	fFirstEventSeen(false)
9c825779	61	{
fb3430ac	62	//
	63	// Constructor
	64	//
9c825779	65	}
	66	//____________________________________________________________________
	67	AliCentralMultiplicityTask::AliCentralMultiplicityTask(const AliCentralMultiplicityTask& o)
	68	: AliAnalysisTaskSE(o),
	69	fData(o.fData),
	70	fList(o.fList),
	71	fAODCentral(o.fAODCentral),
3b2bfb07	72	fManager(o.fManager),
e58000b7	73	fUseSecondary(o.fUseSecondary),
9453b19e	74	fUseAcceptance(o.fUseAcceptance),
fb3430ac	75	fFirstEventSeen(o.fFirstEventSeen)
9c825779	76	{
fb3430ac	77	//
	78	// Copy constructor
	79	//
9c825779	80	}
	81	//____________________________________________________________________
	82	AliCentralMultiplicityTask&
	83	AliCentralMultiplicityTask::operator=(const AliCentralMultiplicityTask& o)
	84	{
fb3430ac	85	//
	86	// Assignment operator
	87	//
9453b19e	88	fData = o.fData;
	89	fList = o.fList;
	90	fAODCentral = o.fAODCentral;
	91	fManager = o.fManager;
	92	fUseSecondary = o.fUseSecondary;
	93	fUseAcceptance = o.fUseAcceptance;
fb3430ac	94	fFirstEventSeen = o.fFirstEventSeen;
9c825779	95	return *this;
	96	}
	97	//____________________________________________________________________
3e478dba	98	void AliCentralMultiplicityTask::UserCreateOutputObjects()
3e478dba	99	{
fb3430ac	100	//
	101	// Create output objects
	102	//
	103	//
6f791cc3	104
	105	AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
	106	AliAODHandler* ah =
	107	dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
	108	if (!ah) AliFatal("No AOD output handler set in analysis manager");
	109
	110
	111	TObject* obj = &fAODCentral;
	112	ah->AddBranch("AliAODCentralMult", &obj);
	113
	114	fList = new TList();
9d05ffeb	115	fList->SetOwner();
6f791cc3	116	PostData(1,fList);
	117
	118	}
	119	//____________________________________________________________________
3e478dba	120	void AliCentralMultiplicityTask::UserExec(Option_t* /option/)
3e478dba	121	{
fb3430ac	122	//
	123	// Process each event
	124	//
	125	// Parameters:
	126	// option Not used
	127	//
6f791cc3	128
	129	AliESDInputHandler* eventHandler =
	130	dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()
	131	->GetInputEventHandler());
	132	if (!eventHandler) {
	133	AliWarning("No inputhandler found for this event!");
	134	return;}
	135
	136	AliESDEvent* esd = eventHandler->GetEvent();
	137
fb3430ac	138	if(!GetManager().IsInit() && !fFirstEventSeen) {
e58000b7	139	AliFMDEventInspector inspector;
	140	inspector.ReadRunDetails(esd);
	141	GetManager().Init(inspector.GetCollisionSystem(),
	142	inspector.GetEnergy(),
	143	inspector.GetField());
	144
e58000b7	145	AliInfo("Manager of corrections in AliCentralMultiplicityTask init");
fb3430ac	146	fFirstEventSeen = kTRUE;
e58000b7	147	}
e58000b7	148
6f791cc3	149	//Selecting only events with \|valid vertex\| < 10 cm
	150	const AliESDVertex* vertex = esd->GetPrimaryVertexSPD();
	151	if (!vertex) return;
	152	if(!(vertex->GetStatus())) return;
	153	if(vertex->GetNContributors() <= 0) return ;
	154	if(vertex->GetZRes() > 0.1 ) return;
	155	Double_t vertexXYZ[3]={0,0,0};
	156	vertex->GetXYZ(vertexXYZ);
	157	if(TMath::Abs(vertexXYZ[2]) > 10) return;
	158
3e478dba	159	Double_t delta = 2 ;
6f791cc3	160	Double_t vertexBinDouble = (vertexXYZ[2] + 10) / delta;
3e478dba	161	//HHD: The vtxbins are 1-10, not 0-9
3e478dba	162	Int_t vtxbin = Int_t(vertexBinDouble + 1) ;
6f791cc3	163
	164	// Make sure AOD is filled
	165	AliAnalysisManager* am = AliAnalysisManager::GetAnalysisManager();
	166	AliAODHandler* ah =
	167	dynamic_cast<AliAODHandler*>(am->GetOutputEventHandler());
	168	if (!ah)
	169	AliFatal("No AOD output handler set in analysis manager");
	170
	171	ah->SetFillAOD(kTRUE);
	172
	173	//Doing analysis
	174	fAODCentral.Clear("");
	175	TH2D *aodHist = &(fAODCentral.GetHistogram());
	176
	177	const AliMultiplicity* spdmult = esd->GetMultiplicity();
	178	//Filling clusters in layer 1 used for tracklets...
3e478dba	179	for(Int_t j = 0; j< spdmult->GetNumberOfTracklets();j++)
6f791cc3	180	aodHist->Fill(spdmult->GetEta(j),spdmult->GetPhi(j));
3e478dba	181
6f791cc3	182	//...and then the unused ones in layer 1
3e478dba	183	for(Int_t j = 0; j< spdmult->GetNumberOfSingleClusters();j++)
6f791cc3	184	aodHist->Fill(-TMath::Log(TMath::Tan(spdmult->GetThetaSingle(j)/2.)),
3e478dba	185	spdmult->GetPhiSingle(j));
6f791cc3	186
6f791cc3	187
3e478dba	188	// Corrections
6f791cc3	189	TH1D* hAcceptance = fManager.GetAcceptanceCorrection(vtxbin);
9453b19e	190	TH2D* hSecMap = fManager.GetSecMapCorrection(vtxbin);
12fffad7	191
9453b19e	192	if (!hSecMap) AliFatal("No secondary map!");
9453b19e	193	if (!hAcceptance) AliFatal("No acceptance!");
dbe8d9ed	194
9453b19e	195	if (fUseSecondary && hSecMap) aodHist->Divide(hSecMap);
6f791cc3	196
6f791cc3	197	for(Int_t nx = 1; nx <= aodHist->GetNbinsX(); nx++) {
3b2bfb07	198	Float_t accCor = hAcceptance->GetBinContent(nx);
9453b19e	199	Float_t accErr = hAcceptance->GetBinError(nx);
6f791cc3	200
	201	Bool_t etabinSeen = kFALSE;
	202	for(Int_t ny = 1; ny <= aodHist->GetNbinsY(); ny++) {
9453b19e	203	// Get currrent value
3b2bfb07	204	Float_t aodValue = aodHist->GetBinContent(nx,ny);
9453b19e	205	Float_t aodErr = aodHist->GetBinError(nx,ny);
	206
	207	// Set underflow bin
12fffad7	208	Float_t secCor = 0;
12fffad7	209	if(hSecMap) secCor = hSecMap->GetBinContent(nx,ny);
3b2bfb07	210	if (secCor > 0.5) etabinSeen = kTRUE;
3b2bfb07	211	if (aodValue < 0.000001) { aodHist->SetBinContent(nx,ny, 0); continue; }
9453b19e	212
	213	if (!fUseAcceptance) continue;
	214
	215	// Acceptance correction
3b2bfb07	216	if (accCor < 0.000001) accCor = 1;
3b2bfb07	217	Float_t aodNew = aodValue / accCor ;
12fffad7	218	Float_t error = aodNew*TMath::Sqrt(TMath::Power(aodErr/aodValue,2) +
12fffad7	219	TMath::Power(accErr/accCor,2) );
9453b19e	220	aodHist->SetBinContent(nx,ny, aodNew);
12fffad7	221	//test
6f791cc3	222	aodHist->SetBinError(nx,ny,error);
12fffad7	223	aodHist->SetBinError(nx,ny,aodErr);
6f791cc3	224
	225	}
	226	//Filling underflow bin if we eta bin is in range
	227	if(etabinSeen) aodHist->SetBinContent(nx,0, 1.);
6f791cc3	228	}
	229
	230	PostData(1,fList);
6f791cc3	231	}
6f791cc3	232	//____________________________________________________________________
3e478dba	233	void AliCentralMultiplicityTask::Terminate(Option_t* /option/)
3e478dba	234	{
fb3430ac	235	//
	236	// End of job
	237	//
	238	// Parameters:
	239	// option Not used
	240	//
6f791cc3	241	}
	242	//____________________________________________________________________
	243	void
	244	AliCentralMultiplicityTask::Print(Option_t* /option/) const
	245	{
fb3430ac	246	//
	247	// Print information
	248	//
	249	// Parameters:
	250	// option Not used
	251	//
6f791cc3	252	}
3e478dba	253	//====================================================================
6f791cc3	254	AliCentralMultiplicityTask::Manager::Manager() :
	255	fAcceptancePath("$ALICE_ROOT/PWG2/FORWARD/corrections/CentralAcceptance"),
	256	fSecMapPath("$ALICE_ROOT/PWG2/FORWARD/corrections/CentralSecMap"),
	257	fAcceptance(),
	258	fSecmap(),
	259	fAcceptanceName("centralacceptance"),
e58000b7	260	fSecMapName("centralsecmap"),
e58000b7	261	fIsInit(kFALSE)
6f791cc3	262	{
fb3430ac	263	//
	264	// Constructor
	265	//
6f791cc3	266	}
6f791cc3	267	//____________________________________________________________________
3e478dba	268	AliCentralMultiplicityTask::Manager::Manager(const Manager& o)
	269	:fAcceptancePath(o.fAcceptancePath),
	270	fSecMapPath(o.fSecMapPath),
	271	fAcceptance(o.fAcceptance),
	272	fSecmap(o.fSecmap),
	273	fAcceptanceName(o.fAcceptanceName),
e58000b7	274	fSecMapName(o.fSecMapName),
e58000b7	275	fIsInit(o.fIsInit)
fb3430ac	276	{
	277	//
	278	// Copy Constructor
	279	//
	280	}
3e478dba	281	//____________________________________________________________________
	282	AliCentralMultiplicityTask::Manager&
	283	AliCentralMultiplicityTask::Manager::operator=(const Manager& o)
	284	{
fb3430ac	285	//
	286	// Assignment operator
	287	//
3e478dba	288	fAcceptancePath = o.fAcceptancePath;
	289	fSecMapPath = o.fSecMapPath;
	290	fAcceptance = o.fAcceptance;
	291	fSecmap = o.fSecmap;
	292	fAcceptanceName = o.fAcceptanceName;
	293	fSecMapName = o.fSecMapName;
e58000b7	294	fIsInit = o.fIsInit;
3e478dba	295	return *this;
	296	}
	297
	298	//____________________________________________________________________
	299	const char*
	300	AliCentralMultiplicityTask::Manager::GetFullFileName(UShort_t what,
	301	UShort_t sys,
	302	UShort_t sNN,
	303	Short_t field) const
	304	{
fb3430ac	305	//
	306	// Get full path name to object file
	307	//
	308	// Parameters:
	309	// what What to get
	310	// sys Collision system
	311	// sNN Center of mass energy
	312	// field Magnetic field
	313	//
	314	// Return:
	315	//
	316	//
3e478dba	317	return Form("%s/%s",
	318	what == 0 ? GetSecMapPath() : GetAcceptancePath(),
	319	GetFileName(what, sys, sNN, field));
	320	}
	321
	322	//____________________________________________________________________
	323	const char*
	324	AliCentralMultiplicityTask::Manager::GetFileName(UShort_t what ,
	325	UShort_t sys,
	326	UShort_t sNN,
	327	Short_t field) const
	328	{
fb3430ac	329	//
	330	// Get the full path name
	331	//
	332	// Parameters:
	333	// what What to get
	334	// sys Collision system
	335	// sNN Center of mass energy
	336	// field Magnetic field
	337	//
	338	// Return:
	339	//
	340	//
3e478dba	341	// Must be static - otherwise the data may disappear on return from
	342	// this member function
	343	static TString fname = "";
6f791cc3	344
dbe8d9ed	345	fname = "";
6f791cc3	346	switch(what) {
3e478dba	347	case 0: fname.Append(fSecMapName.Data()); break;
3e478dba	348	case 1: fname.Append(fAcceptanceName.Data()); break;
6f791cc3	349	default:
3e478dba	350	::Error("GetFileName",
3e478dba	351	"Invalid indentifier %d for central object, must be 0 or 1!", what);
6f791cc3	352	break;
	353	}
	354	fname.Append(Form("_%s_%04dGeV_%c%1dkG.root",
	355	AliForwardUtil::CollisionSystemString(sys),
	356	sNN, (field < 0 ? 'm' : 'p'), TMath::Abs(field)));
	357
	358	return fname.Data();
6f791cc3	359	}
3e478dba	360
6f791cc3	361	//____________________________________________________________________
3e478dba	362	TH2D*
	363	AliCentralMultiplicityTask::Manager::GetSecMapCorrection(UShort_t vtxbin) const
	364	{
fb3430ac	365	//
	366	// Get the secondary map
	367	//
	368	// Parameters:
	369	// vtxbin
	370	//
	371	// Return:
	372	//
	373	//
3e478dba	374	if (!fSecmap) {
	375	::Warning("GetSecMapCorrection","No secondary map defined");
	376	return 0;
	377	}
	378	return fSecmap->GetCorrection(vtxbin);
	379	}
	380	//____________________________________________________________________
	381	TH1D*
	382	AliCentralMultiplicityTask::Manager::GetAcceptanceCorrection(UShort_t vtxbin)
	383	const
	384	{
fb3430ac	385	//
	386	// Get the acceptance correction
	387	//
	388	// Parameters:
	389	// vtxbin
	390	//
	391	// Return:
	392	//
	393	//
3e478dba	394	if (!fAcceptance) {
	395	::Warning("GetAcceptanceCorrection","No acceptance map defined");
	396	return 0;
	397	}
	398	return fAcceptance->GetCorrection(vtxbin);
	399	}
	400
	401	//____________________________________________________________________
	402	void
	403	AliCentralMultiplicityTask::Manager::Init(UShort_t sys,
	404	UShort_t sNN,
	405	Short_t field)
	406	{
fb3430ac	407	//
	408	// Initialize
	409	//
	410	// Parameters:
	411	// sys Collision system (1: pp, 2: PbPb)
	412	// sNN Center of mass energy per nucleon pair [GeV]
	413	// field Magnetic field [kG]
	414	//
e58000b7	415	if(fIsInit) ::Warning("Init","Already initialised - overriding...");
e58000b7	416
6f791cc3	417	TFile fsec(GetFullFileName(0,sys,sNN,field));
3e478dba	418	fSecmap =
3e478dba	419	dynamic_cast<AliCentralCorrSecondaryMap*>(fsec.Get(fSecMapName.Data()));
6f791cc3	420	if(!fSecmap) {
3e478dba	421	::Error("Init", "no central Secondary Map found!") ;
6f791cc3	422	return;
	423	}
	424	TFile facc(GetFullFileName(1,sys,sNN,field));
3e478dba	425	fAcceptance =
	426	dynamic_cast<AliCentralCorrAcceptance*>(facc.Get(fAcceptanceName.Data()));
	427	if(!fAcceptance) {
	428	::Error("Init", "no central Acceptance found!") ;
	429	return;
	430	}
e58000b7	431
	432	if(fSecmap && fAcceptance) {
	433	fIsInit = kTRUE;
	434	::Info("Init",
	435	"Central Manager initialised for sys %d, energy %d, field %d",sys,sNN,field);
6f791cc3	436
e58000b7	437	}
e58000b7	438
6f791cc3	439	}
	440	//
	441	// EOF
	442	//