[u/mrichter/AliRoot.git] / PWGLF / FORWARD / analysis2 / AliForwardMCMultiplicityTask.cxx

// 
// Calculate the multiplicity in the forward regions event-by-event 
// 
// Inputs: 
//   - AliESDEvent 
//   - Kinematics
//   - Track references
//
// Outputs: 
//   - AliAODForwardMult 
// 
// Histograms 
//   
// Corrections used 
// 
#include "AliForwardMCMultiplicityTask.h"
#include "AliTriggerAnalysis.h"
#include "AliPhysicsSelection.h"
#include "AliLog.h"
#include "AliESDEvent.h"
#include "AliAODHandler.h"
#include "AliMultiplicity.h"
#include "AliInputEventHandler.h"
#include "AliForwardCorrectionManager.h"
#include "AliAnalysisManager.h"
#include <TH1.h>
#include <TDirectory.h>
#include <TTree.h>
#include <TROOT.h>
#define MCAOD_SLOT 4
#define PRIMARY_SLOT 5
#ifdef POST_AOD
# define DEFINE(N,C) DefineOutput(N,C)
# define POST(N,O)   PostData(N,O)
#else
# define DEFINE(N,C) do { } while(false)
# define POST(N,O)   do { } while(false)
#endif

//====================================================================
AliForwardMCMultiplicityTask::AliForwardMCMultiplicityTask()
  : AliForwardMultiplicityBase(),
    fESDFMD(),
    fMCESDFMD(),
    fMCHistos(),
    fMCAODFMD(),
    fMCRingSums(),
    fPrimary(0),
    fEventInspector(),
    fSharingFilter(),
    fDensityCalculator(),
    fCorrections(),
    fHistCollector(),
    fEventPlaneFinder()
{
  // 
  // Constructor
  //
}

//____________________________________________________________________
AliForwardMCMultiplicityTask::AliForwardMCMultiplicityTask(const char* name)
  : AliForwardMultiplicityBase(name), 
    fESDFMD(),
    fMCESDFMD(),
    fMCHistos(),
    fMCAODFMD(kTRUE),
    fMCRingSums(),
    fPrimary(0),
    fEventInspector("event"),
    fSharingFilter("sharing"), 
    fDensityCalculator("density"),
    fCorrections("corrections"),
    fHistCollector("collector"),
    fEventPlaneFinder("eventplane")
{
  // 
  // Constructor 
  // 
  // Parameters:
  //    name Name of task 
  //
  fPrimary = new TH2D("primary", "MC Primaries", 1,0,1,20,0,TMath::TwoPi());
  fPrimary->SetXTitle("#eta");
  fPrimary->SetYTitle("#varphi [radians]");
  fPrimary->SetZTitle("d^{2}N_{ch}/d#etad#phi");
  fPrimary->Sumw2();
  fPrimary->SetStats(0);
  fPrimary->SetDirectory(0);
  DEFINE(MCAOD_SLOT,AliAODForwardMult::Class());
  DEFINE(PRIM_SLOT, TH2D::Class());
}

//____________________________________________________________________
void
AliForwardMCMultiplicityTask::SetOnlyPrimary(Bool_t use)
{
  fSharingFilter.GetTrackDensity().SetUseOnlyPrimary(use);
  fCorrections.SetSecondaryForMC(!use);
}

//____________________________________________________________________
void
AliForwardMCMultiplicityTask::CreateBranches(AliAODHandler* ah)
{
  // 
  // Create output objects 
  // 
  //
  AliForwardMultiplicityBase::CreateBranches(ah);

  TObject* mcobj = &fMCAODFMD;
  ah->AddBranch("AliAODForwardMult", &mcobj);    
  ah->AddBranch("TH2D", &fPrimary);
}

//____________________________________________________________________
Bool_t
AliForwardMCMultiplicityTask::Book()
{
  Bool_t ret = AliForwardMultiplicityBase::Book();
  POST(MCAOD_SLOT, &fMCAODFMD);
  POST(PRIM_SLOT,  fPrimary);
  return ret;
}

//____________________________________________________________________
void
AliForwardMCMultiplicityTask::InitMembers(const TAxis& eta, const TAxis& vertex)
{
  // 
  // Initialise the sub objects and stuff.  Called on first event 
  // 
  //
  AliForwardMultiplicityBase::InitMembers(eta, vertex);

  fMCHistos.Init(eta);
  fMCAODFMD.Init(eta);
  fMCRingSums.Init(eta);

  AliForwardUtil::Histos::RebinEta(fPrimary, eta);
  DMSG(fDebug,0,"Primary histogram rebinned to %d,%f,%f eta axis %d,%f,%f", 
       fPrimary->GetXaxis()->GetNbins(), 
       fPrimary->GetXaxis()->GetXmin(),
       fPrimary->GetXaxis()->GetXmax(),
       eta.GetNbins(), 
       eta.GetXmin(),
       eta.GetXmax());


  TList* mcRings = new TList;
  mcRings->SetName("mcRingSums");
  mcRings->SetOwner();
  fList->Add(mcRings);

  mcRings->Add(fMCRingSums.Get(1, 'I'));
  mcRings->Add(fMCRingSums.Get(2, 'I'));
  mcRings->Add(fMCRingSums.Get(2, 'O'));
  mcRings->Add(fMCRingSums.Get(3, 'I'));
  mcRings->Add(fMCRingSums.Get(3, 'O'));
  fMCRingSums.Get(1, 'I')->SetMarkerColor(AliForwardUtil::RingColor(1, 'I'));
  fMCRingSums.Get(2, 'I')->SetMarkerColor(AliForwardUtil::RingColor(2, 'I'));
  fMCRingSums.Get(2, 'O')->SetMarkerColor(AliForwardUtil::RingColor(2, 'O'));
  fMCRingSums.Get(3, 'I')->SetMarkerColor(AliForwardUtil::RingColor(3, 'I'));
  fMCRingSums.Get(3, 'O')->SetMarkerColor(AliForwardUtil::RingColor(3, 'O'));
}

//____________________________________________________________________
Bool_t
AliForwardMCMultiplicityTask::PreEvent()
{
 if (fFirstEvent) 
    fEventInspector.ReadProductionDetails(MCEvent());
  // Clear stuff 
  fHistos.Clear();
  fESDFMD.Clear();
  fAODFMD.Clear();
  fAODEP.Clear();
  fMCHistos.Clear();
  fMCESDFMD.Clear();
  fMCAODFMD.Clear();
  fPrimary->Reset();
  return true;
}
//____________________________________________________________________
Bool_t
AliForwardMCMultiplicityTask::Event(AliESDEvent& esd)
{
  // 
  // Process each event 
  // 
  // Parameters:
  //    option Not used
  //  

  // Read production details 
    
  // Get the input data 
  AliMCEvent*  mcEvent = MCEvent();
  if (!mcEvent) return false;

  Bool_t   lowFlux   = kFALSE;
  UInt_t   triggers  = 0;
  UShort_t ivz       = 0;
  TVector3 ip(1024, 1024, 0);
  Double_t cent      = -1;
  UShort_t nClusters = 0;
  UInt_t   found     = fEventInspector.Process(&esd, triggers, lowFlux, 
					       ivz, ip, cent, nClusters);
  UShort_t ivzMC    = 0;
  Double_t vzMC     = 0;
  Double_t phiR     = 0;
  Double_t b        = 0;
  Double_t cMC      = 0;
  Int_t    npart    = 0;
  Int_t    nbin     = 0;
  // UInt_t   foundMC  = 
  fEventInspector.ProcessMC(mcEvent, triggers, ivzMC, vzMC, b, cMC,
			    npart, nbin, phiR);
  fEventInspector.CompareResults(ip.Z(), vzMC, cent, cMC, b, npart, nbin);
  
  //Store all events
  MarkEventForStore();
  
  Bool_t isAccepted = true;
  if (found & AliFMDEventInspector::kNoEvent)    isAccepted = false; // return;
  if (found & AliFMDEventInspector::kNoTriggers) isAccepted = false; // return;
  //MarkEventForStore();
  // Always set the B trigger - each MC event _is_ a collision 
  triggers |= AliAODForwardMult::kB;
  // Set trigger bits, and mark this event for storage 
  fAODFMD.SetTriggerBits(triggers);
  fAODFMD.SetSNN(fEventInspector.GetEnergy());
  fAODFMD.SetSystem(fEventInspector.GetCollisionSystem());
  fAODFMD.SetCentrality(cent);
  fAODFMD.SetNClusters(nClusters);

  fMCAODFMD.SetTriggerBits(triggers);
  fMCAODFMD.SetSNN(fEventInspector.GetEnergy());
  fMCAODFMD.SetSystem(fEventInspector.GetCollisionSystem());
  fMCAODFMD.SetCentrality(cent);
  fMCAODFMD.SetNClusters(nClusters);
  
  // Disable this check on SPD - will bias data 
  // if (found & AliFMDEventInspector::kNoSPD)  isAccepted = false; // return;
  if (found & AliFMDEventInspector::kNoFMD)     isAccepted = false; // return;
  if (found & AliFMDEventInspector::kNoVertex)  isAccepted = false; // return;

  if (isAccepted) {
    fAODFMD.SetIpZ(ip.Z());
    fMCAODFMD.SetIpZ(ip.Z());
  }
  if (found & AliFMDEventInspector::kBadVertex) isAccepted = false; // return;

  // We we do not want to use low flux specific code, we disable it here. 
  if (!fEnableLowFlux) lowFlux = false;
  
  
  // Get FMD data 
  AliESDFMD*  esdFMD  = esd.GetFMDData();

  // Apply the sharing filter (or hit merging or clustering if you like)
  if (isAccepted && !fSharingFilter.Filter(*esdFMD, lowFlux, fESDFMD,ip.Z())){
    AliWarning("Sharing filter failed!");
    return false;
  }
  if (!fSharingFilter.FilterMC(*esdFMD, *mcEvent, ip.Z(),fMCESDFMD,fPrimary)){
    AliWarning("MC Sharing filter failed!");
    return false;
  }

  // Store some MC parameters in corners of histogram :-)
  fPrimary->SetBinContent(0,                      0,                    vzMC);
  fPrimary->SetBinContent(fPrimary->GetNbinsX()+1,0,                    phiR);
  fPrimary->SetBinContent(fPrimary->GetNbinsX()+1,fPrimary->GetNbinsY(),cMC);
  

  if (!isAccepted) 
    // Exit on MC event w/o trigger, vertex, data - since there's no more 
    // to be done for MC 
    return false; 
  
  //MarkEventForStore();
  fSharingFilter.CompareResults(fESDFMD, fMCESDFMD);

  // Calculate the inclusive charged particle density 
  if (!fDensityCalculator.Calculate(fESDFMD, fHistos, lowFlux, cent, ip)) { 
    AliWarning("Density calculator failed!");
    return false;
  }
  if (!fDensityCalculator.CalculateMC(fMCESDFMD, fMCHistos)) { 
    AliWarning("MC Density calculator failed!");
    return false;
  }
  fDensityCalculator.CompareResults(fHistos, fMCHistos);
  
  if (fEventInspector.GetCollisionSystem() == AliFMDEventInspector::kPbPb) {
    if (!fEventPlaneFinder.FindEventplane(&esd, fAODEP, 
					  &(fAODFMD.GetHistogram()), &fHistos))
      AliWarning("Eventplane finder failed!");
  }

  // Do the secondary and other corrections. 
  if (!fCorrections.Correct(fHistos, ivz)) { 
    AliWarning("Corrections failed");
    return false;
  }
  if (!fCorrections.CorrectMC(fMCHistos, ivz)) { 
    AliWarning("MC Corrections failed");
    return false;
  }
  fCorrections.CompareResults(fHistos, fMCHistos);
    
  if (!fHistCollector.Collect(fHistos, fRingSums, 
			      ivz, fAODFMD.GetHistogram(),
			      fAODFMD.GetCentrality())) {
    AliWarning("Histogram collector failed");
    return false;
  }
  if (!fHistCollector.Collect(fMCHistos, fMCRingSums, 
			      ivz, fMCAODFMD.GetHistogram(), -1, true)) {
    AliWarning("MC Histogram collector failed");
    return false;
  }
#if 0
  // Copy underflow bins to overflow bins - always full phi coverage 
  TH2&  hMC  = fMCAODFMD.GetHistogram();
  Int_t nEta = hMC.GetNbinsX();
  Int_t nY   = hMC.GetNbinsY();
  for (Int_t iEta = 1; iEta <= nEta; iEta++) {
    hMC.SetBinContent(iEta, nY+1, hMC.GetBinContent(iEta, 0));
  }
#endif

  if (fAODFMD.IsTriggerBits(AliAODForwardMult::kInel))
    fHData->Add(&(fAODFMD.GetHistogram()));

  return true;
}

//____________________________________________________________________
Bool_t
AliForwardMCMultiplicityTask::PostEvent()
{
  Bool_t ret = AliForwardMultiplicityBase::PostEvent();
  POST(MCAOD_SLOT, &fMCAODFMD);
  POST(PRIMARY_SLOT, fPrimary);
  return ret;
}

//____________________________________________________________________
void
AliForwardMCMultiplicityTask::EstimatedNdeta(const TList* input, 
					     TList*       output) const
{
  AliForwardMultiplicityBase::EstimatedNdeta(input, output);
  MakeRingdNdeta(input, "mcRingSums", output, "mcRingResults", 24);
}


//
// EOF
//
Commit	Line	Data
7984e5f7	1	//
	2	// Calculate the multiplicity in the forward regions event-by-event
	3	//
	4	// Inputs:
	5	// - AliESDEvent
	6	// - Kinematics
	7	// - Track references
	8	//
	9	// Outputs:
	10	// - AliAODForwardMult
	11	//
	12	// Histograms
	13	//
	14	// Corrections used
	15	//
285e7b27	16	#include "AliForwardMCMultiplicityTask.h"
	17	#include "AliTriggerAnalysis.h"
	18	#include "AliPhysicsSelection.h"
	19	#include "AliLog.h"
285e7b27	20	#include "AliESDEvent.h"
	21	#include "AliAODHandler.h"
	22	#include "AliMultiplicity.h"
	23	#include "AliInputEventHandler.h"
	24	#include "AliForwardCorrectionManager.h"
	25	#include "AliAnalysisManager.h"
	26	#include <TH1.h>
	27	#include <TDirectory.h>
	28	#include <TTree.h>
	29	#include <TROOT.h>
a19faec0	30	#define MCAOD_SLOT 4
	31	#define PRIMARY_SLOT 5
	32	#ifdef POST_AOD
	33	# define DEFINE(N,C) DefineOutput(N,C)
	34	# define POST(N,O) PostData(N,O)
	35	#else
	36	# define DEFINE(N,C) do { } while(false)
	37	# define POST(N,O) do { } while(false)
	38	#endif
285e7b27	39
	40	//====================================================================
	41	AliForwardMCMultiplicityTask::AliForwardMCMultiplicityTask()
	42	: AliForwardMultiplicityBase(),
285e7b27	43	fESDFMD(),
285e7b27	44	fMCESDFMD(),
	45	fMCHistos(),
	46	fMCAODFMD(),
5bb5d1f6	47	fMCRingSums(),
4cbdf467	48	fPrimary(0),
285e7b27	49	fEventInspector(),
285e7b27	50	fSharingFilter(),
	51	fDensityCalculator(),
	52	fCorrections(),
	53	fHistCollector(),
8449e3e0	54	fEventPlaneFinder()
285e7b27	55	{
7984e5f7	56	//
	57	// Constructor
	58	//
285e7b27	59	}
	60
	61	//____________________________________________________________________
	62	AliForwardMCMultiplicityTask::AliForwardMCMultiplicityTask(const char* name)
	63	: AliForwardMultiplicityBase(name),
285e7b27	64	fESDFMD(),
285e7b27	65	fMCESDFMD(),
	66	fMCHistos(),
	67	fMCAODFMD(kTRUE),
5bb5d1f6	68	fMCRingSums(),
4cbdf467	69	fPrimary(0),
285e7b27	70	fEventInspector("event"),
285e7b27	71	fSharingFilter("sharing"),
	72	fDensityCalculator("density"),
	73	fCorrections("corrections"),
	74	fHistCollector("collector"),
8449e3e0	75	fEventPlaneFinder("eventplane")
285e7b27	76	{
7984e5f7	77	//
	78	// Constructor
	79	//
	80	// Parameters:
	81	// name Name of task
	82	//
f71c22f5 CHC	83	fPrimary = new TH2D("primary", "MC Primaries", 1,0,1,20,0,TMath::TwoPi());
	84	fPrimary->SetXTitle("#eta");
	85	fPrimary->SetYTitle("#varphi [radians]");
	86	fPrimary->SetZTitle("d^{2}N_{ch}/d#etad#phi");
	87	fPrimary->Sumw2();
	88	fPrimary->SetStats(0);
	89	fPrimary->SetDirectory(0);
a19faec0	90	DEFINE(MCAOD_SLOT,AliAODForwardMult::Class());
a19faec0	91	DEFINE(PRIM_SLOT, TH2D::Class());
285e7b27	92	}
285e7b27	93
285e7b27	94	//____________________________________________________________________
285e7b27	95	void
8449e3e0	96	AliForwardMCMultiplicityTask::SetOnlyPrimary(Bool_t use)
285e7b27	97	{
8449e3e0	98	fSharingFilter.GetTrackDensity().SetUseOnlyPrimary(use);
8449e3e0	99	fCorrections.SetSecondaryForMC(!use);
285e7b27	100	}
8449e3e0	101
5bb5d1f6	102	//____________________________________________________________________
5bb5d1f6	103	void
8449e3e0	104	AliForwardMCMultiplicityTask::CreateBranches(AliAODHandler* ah)
5bb5d1f6	105	{
8449e3e0	106	//
	107	// Create output objects
	108	//
	109	//
	110	AliForwardMultiplicityBase::CreateBranches(ah);
	111
	112	TObject* mcobj = &fMCAODFMD;
f71c22f5	113	ah->AddBranch("AliAODForwardMult", &mcobj);
8449e3e0	114	ah->AddBranch("TH2D", &fPrimary);
5bb5d1f6	115	}
5bb5d1f6	116
a19faec0	117	//____________________________________________________________________
	118	Bool_t
	119	AliForwardMCMultiplicityTask::Book()
	120	{
	121	Bool_t ret = AliForwardMultiplicityBase::Book();
	122	POST(MCAOD_SLOT, &fMCAODFMD);
	123	POST(PRIM_SLOT, fPrimary);
	124	return ret;
	125	}
8449e3e0	126
285e7b27	127	//____________________________________________________________________
8449e3e0	128	void
c8b1a7db	129	AliForwardMCMultiplicityTask::InitMembers(const TAxis& eta, const TAxis& vertex)
285e7b27	130	{
7984e5f7	131	//
	132	// Initialise the sub objects and stuff. Called on first event
	133	//
	134	//
c8b1a7db	135	AliForwardMultiplicityBase::InitMembers(eta, vertex);
1174780f	136
c8b1a7db	137	fMCHistos.Init(eta);
	138	fMCAODFMD.Init(eta);
	139	fMCRingSums.Init(eta);
	140
	141	AliForwardUtil::Histos::RebinEta(fPrimary, eta);
	142	DMSG(fDebug,0,"Primary histogram rebinned to %d,%f,%f eta axis %d,%f,%f",
	143	fPrimary->GetXaxis()->GetNbins(),
	144	fPrimary->GetXaxis()->GetXmin(),
	145	fPrimary->GetXaxis()->GetXmax(),
	146	eta.GetNbins(),
	147	eta.GetXmin(),
	148	eta.GetXmax());
285e7b27	149
5bb5d1f6	150
	151	TList* mcRings = new TList;
	152	mcRings->SetName("mcRingSums");
	153	mcRings->SetOwner();
	154	fList->Add(mcRings);
	155
	156	mcRings->Add(fMCRingSums.Get(1, 'I'));
	157	mcRings->Add(fMCRingSums.Get(2, 'I'));
	158	mcRings->Add(fMCRingSums.Get(2, 'O'));
	159	mcRings->Add(fMCRingSums.Get(3, 'I'));
	160	mcRings->Add(fMCRingSums.Get(3, 'O'));
	161	fMCRingSums.Get(1, 'I')->SetMarkerColor(AliForwardUtil::RingColor(1, 'I'));
	162	fMCRingSums.Get(2, 'I')->SetMarkerColor(AliForwardUtil::RingColor(2, 'I'));
	163	fMCRingSums.Get(2, 'O')->SetMarkerColor(AliForwardUtil::RingColor(2, 'O'));
	164	fMCRingSums.Get(3, 'I')->SetMarkerColor(AliForwardUtil::RingColor(3, 'I'));
	165	fMCRingSums.Get(3, 'O')->SetMarkerColor(AliForwardUtil::RingColor(3, 'O'));
285e7b27	166	}
285e7b27	167
285e7b27	168	//____________________________________________________________________
c8b1a7db	169	Bool_t
	170	AliForwardMCMultiplicityTask::PreEvent()
	171	{
	172	if (fFirstEvent)
	173	fEventInspector.ReadProductionDetails(MCEvent());
	174	// Clear stuff
	175	fHistos.Clear();
	176	fESDFMD.Clear();
	177	fAODFMD.Clear();
	178	fAODEP.Clear();
	179	fMCHistos.Clear();
	180	fMCESDFMD.Clear();
	181	fMCAODFMD.Clear();
	182	fPrimary->Reset();
	183	return true;
	184	}
	185	//____________________________________________________________________
	186	Bool_t
	187	AliForwardMCMultiplicityTask::Event(AliESDEvent& esd)
285e7b27	188	{
7984e5f7	189	//
	190	// Process each event
	191	//
	192	// Parameters:
	193	// option Not used
	194	//
	195
f7cfc454	196	// Read production details
f7cfc454	197
285e7b27	198	// Get the input data
e1f47419	199	AliMCEvent* mcEvent = MCEvent();
c8b1a7db	200	if (!mcEvent) return false;
285e7b27	201
5bb5d1f6	202	Bool_t lowFlux = kFALSE;
	203	UInt_t triggers = 0;
	204	UShort_t ivz = 0;
5ca83fee	205	TVector3 ip(1024, 1024, 0);
21d778b1	206	Double_t cent = -1;
5bb5d1f6	207	UShort_t nClusters = 0;
c8b1a7db	208	UInt_t found = fEventInspector.Process(&esd, triggers, lowFlux,
5ca83fee	209	ivz, ip, cent, nClusters);
e1f47419	210	UShort_t ivzMC = 0;
	211	Double_t vzMC = 0;
	212	Double_t phiR = 0;
	213	Double_t b = 0;
241cca4d	214	Double_t cMC = 0;
e308a636	215	Int_t npart = 0;
e308a636	216	Int_t nbin = 0;
e1f47419	217	// UInt_t foundMC =
241cca4d	218	fEventInspector.ProcessMC(mcEvent, triggers, ivzMC, vzMC, b, cMC,
e308a636	219	npart, nbin, phiR);
73b32206	220	fEventInspector.CompareResults(ip.Z(), vzMC, cent, cMC, b, npart, nbin);
1dbfc345	221
e333578d	222	//Store all events
148c39de	223	MarkEventForStore();
e333578d	224
	225	Bool_t isAccepted = true;
	226	if (found & AliFMDEventInspector::kNoEvent) isAccepted = false; // return;
	227	if (found & AliFMDEventInspector::kNoTriggers) isAccepted = false; // return;
148c39de	228	//MarkEventForStore();
b30dee70	229	// Always set the B trigger - each MC event _is_ a collision
b30dee70	230	triggers \|= AliAODForwardMult::kB;
285e7b27	231	// Set trigger bits, and mark this event for storage
285e7b27	232	fAODFMD.SetTriggerBits(triggers);
e308a636	233	fAODFMD.SetSNN(fEventInspector.GetEnergy());
e308a636	234	fAODFMD.SetSystem(fEventInspector.GetCollisionSystem());
e58000b7	235	fAODFMD.SetCentrality(cent);
5bb5d1f6	236	fAODFMD.SetNClusters(nClusters);
e308a636	237
	238	fMCAODFMD.SetTriggerBits(triggers);
	239	fMCAODFMD.SetSNN(fEventInspector.GetEnergy());
	240	fMCAODFMD.SetSystem(fEventInspector.GetCollisionSystem());
	241	fMCAODFMD.SetCentrality(cent);
5bb5d1f6	242	fMCAODFMD.SetNClusters(nClusters);
e58000b7	243
e1f47419	244	// Disable this check on SPD - will bias data
e1f47419	245	// if (found & AliFMDEventInspector::kNoSPD) isAccepted = false; // return;
e333578d	246	if (found & AliFMDEventInspector::kNoFMD) isAccepted = false; // return;
	247	if (found & AliFMDEventInspector::kNoVertex) isAccepted = false; // return;
	248
	249	if (isAccepted) {
5ca83fee	250	fAODFMD.SetIpZ(ip.Z());
5ca83fee	251	fMCAODFMD.SetIpZ(ip.Z());
e333578d	252	}
e333578d	253	if (found & AliFMDEventInspector::kBadVertex) isAccepted = false; // return;
285e7b27	254
	255	// We we do not want to use low flux specific code, we disable it here.
	256	if (!fEnableLowFlux) lowFlux = false;
148c39de	257
148c39de	258
285e7b27	259
285e7b27	260	// Get FMD data
c8b1a7db	261	AliESDFMD* esdFMD = esd.GetFMDData();
e1f47419	262
285e7b27	263	// Apply the sharing filter (or hit merging or clustering if you like)
c8b1a7db	264	if (isAccepted && !fSharingFilter.Filter(*esdFMD, lowFlux, fESDFMD,ip.Z())){
285e7b27	265	AliWarning("Sharing filter failed!");
c8b1a7db	266	return false;
285e7b27	267	}
c8b1a7db	268	if (!fSharingFilter.FilterMC(esdFMD, mcEvent, ip.Z(),fMCESDFMD,fPrimary)){
285e7b27	269	AliWarning("MC Sharing filter failed!");
c8b1a7db	270	return false;
285e7b27	271	}
dd556bcd	272
	273	// Store some MC parameters in corners of histogram :-)
	274	fPrimary->SetBinContent(0, 0, vzMC);
	275	fPrimary->SetBinContent(fPrimary->GetNbinsX()+1,0, phiR);
	276	fPrimary->SetBinContent(fPrimary->GetNbinsX()+1,fPrimary->GetNbinsY(),cMC);
	277
	278
c8b1a7db	279	if (!isAccepted)
	280	// Exit on MC event w/o trigger, vertex, data - since there's no more
	281	// to be done for MC
	282	return false;
1dbfc345	283
148c39de	284	//MarkEventForStore();
285e7b27	285	fSharingFilter.CompareResults(fESDFMD, fMCESDFMD);
285e7b27	286
285e7b27	287	// Calculate the inclusive charged particle density
5934a3e3	288	if (!fDensityCalculator.Calculate(fESDFMD, fHistos, lowFlux, cent, ip)) {
285e7b27	289	AliWarning("Density calculator failed!");
c8b1a7db	290	return false;
285e7b27	291	}
	292	if (!fDensityCalculator.CalculateMC(fMCESDFMD, fMCHistos)) {
	293	AliWarning("MC Density calculator failed!");
c8b1a7db	294	return false;
285e7b27	295	}
	296	fDensityCalculator.CompareResults(fHistos, fMCHistos);
	297
2b556440	298	if (fEventInspector.GetCollisionSystem() == AliFMDEventInspector::kPbPb) {
c8b1a7db	299	if (!fEventPlaneFinder.FindEventplane(&esd, fAODEP,
c8b1a7db	300	&(fAODFMD.GetHistogram()), &fHistos))
2b556440	301	AliWarning("Eventplane finder failed!");
	302	}
	303
285e7b27	304	// Do the secondary and other corrections.
	305	if (!fCorrections.Correct(fHistos, ivz)) {
	306	AliWarning("Corrections failed");
c8b1a7db	307	return false;
285e7b27	308	}
	309	if (!fCorrections.CorrectMC(fMCHistos, ivz)) {
	310	AliWarning("MC Corrections failed");
c8b1a7db	311	return false;
285e7b27	312	}
	313	fCorrections.CompareResults(fHistos, fMCHistos);
	314
5bb5d1f6	315	if (!fHistCollector.Collect(fHistos, fRingSums,
8449e3e0	316	ivz, fAODFMD.GetHistogram(),
8449e3e0	317	fAODFMD.GetCentrality())) {
285e7b27	318	AliWarning("Histogram collector failed");
c8b1a7db	319	return false;
285e7b27	320	}
5bb5d1f6	321	if (!fHistCollector.Collect(fMCHistos, fMCRingSums,
c8b1a7db	322	ivz, fMCAODFMD.GetHistogram(), -1, true)) {
285e7b27	323	AliWarning("MC Histogram collector failed");
c8b1a7db	324	return false;
285e7b27	325	}
c8b1a7db	326	#if 0
29132080	327	// Copy underflow bins to overflow bins - always full phi coverage
bfab35d9	328	TH2& hMC = fMCAODFMD.GetHistogram();
29132080	329	Int_t nEta = hMC.GetNbinsX();
	330	Int_t nY = hMC.GetNbinsY();
	331	for (Int_t iEta = 1; iEta <= nEta; iEta++) {
	332	hMC.SetBinContent(iEta, nY+1, hMC.GetBinContent(iEta, 0));
	333	}
c8b1a7db	334	#endif
285e7b27	335
	336	if (fAODFMD.IsTriggerBits(AliAODForwardMult::kInel))
	337	fHData->Add(&(fAODFMD.GetHistogram()));
	338
c8b1a7db	339	return true;
285e7b27	340	}
285e7b27	341
a19faec0	342	//____________________________________________________________________
	343	Bool_t
	344	AliForwardMCMultiplicityTask::PostEvent()
	345	{
	346	Bool_t ret = AliForwardMultiplicityBase::PostEvent();
	347	POST(MCAOD_SLOT, &fMCAODFMD);
	348	POST(PRIMARY_SLOT, fPrimary);
	349	return ret;
	350	}
	351
285e7b27	352	//____________________________________________________________________
285e7b27	353	void
8449e3e0	354	AliForwardMCMultiplicityTask::EstimatedNdeta(const TList* input,
8449e3e0	355	TList* output) const
285e7b27	356	{
8449e3e0	357	AliForwardMultiplicityBase::EstimatedNdeta(input, output);
8449e3e0	358	MakeRingdNdeta(input, "mcRingSums", output, "mcRingResults", 24);
285e7b27	359	}
285e7b27	360
285e7b27	361
8449e3e0	362
285e7b27	363	//
	364	// EOF
	365	//