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

// 
// Calculate the multiplicity in the forward regions event-by-event 
// 
// Inputs: 
//   - AliESDEvent 
//
// Outputs: 
//   - AliAODForwardMult 
// 
// Histograms 
//   
// Corrections used 
//
#include "AliForwardQATask.h"
#include "AliForwardUtil.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 "AliAODForwardMult.h"
#include <TH1.h>
#include <TDirectory.h>
#include <TTree.h>
#include <TROOT.h>
#include <TStopwatch.h>

//====================================================================
AliForwardQATask::AliForwardQATask()
  : AliAnalysisTaskSE(),
    fEnableLowFlux(false), 
    fFirstEvent(true),
    fCorrManager(0),
    fESDFMD(),
    fHistos(),
    fEventInspector(),
    fEnergyFitter(),
    fSharingFilter(),
    fDensityCalculator(),
    fList(0),
    fDebug(0)
{
  // 
  // Constructor
  //
}

//____________________________________________________________________
AliForwardQATask::AliForwardQATask(const char* name)
  : AliAnalysisTaskSE(name),
    fEnableLowFlux(false), 
    fFirstEvent(true),
    fCorrManager(0),
    fESDFMD(),
    fHistos(),
    fEventInspector("event"),
    fEnergyFitter("energy"),
    fSharingFilter("sharing"), 
    fDensityCalculator("density"),
    fList(0),
    fDebug(0)
{
  // 
  // Constructor 
  // 
  // Parameters:
  //    name Name of task 
  //
  DefineOutput(1, TList::Class());
  DefineOutput(2, TList::Class());
  fCorrManager = &AliForwardCorrectionManager::Instance(); 
  fEnergyFitter.SetNParticles(1); // Just find the 1st peak 
  fEnergyFitter.SetDoMakeObject(false); 
  fEnergyFitter.SetUseIncreasingBins(true);
  fEnergyFitter.SetDoFits(kTRUE);
  fEnergyFitter.SetLowCut(0.4);
  fEnergyFitter.SetFitRangeBinWidth(4);
  fEnergyFitter.SetMinEntries(1000);
}

//____________________________________________________________________
AliForwardQATask::AliForwardQATask(const AliForwardQATask& o)
  : AliAnalysisTaskSE(o),
    fEnableLowFlux(o.fEnableLowFlux), 
    fFirstEvent(o.fFirstEvent),
    fCorrManager(o.fCorrManager),
    fESDFMD(o.fESDFMD),
    fHistos(o.fHistos),
    fEventInspector(o.fEventInspector),
    fEnergyFitter(o.fEnergyFitter),
    fSharingFilter(o.fSharingFilter),
    fDensityCalculator(o.fDensityCalculator),
    fList(o.fList),
    fDebug(o.fDebug) 
{
  // 
  // Copy constructor 
  // 
  // Parameters:
  //    o Object to copy from 
  //
  DefineOutput(1, TList::Class());
  DefineOutput(2, TList::Class());
}

//____________________________________________________________________
AliForwardQATask&
AliForwardQATask::operator=(const AliForwardQATask& o)
{
  // 
  // Assignment operator 
  // 
  // Parameters:
  //    o Object to assign from 
  // 
  // Return:
  //    Reference to this object 
  //
  if (&o == this) return *this;
  AliAnalysisTaskSE::operator=(o);

  fEnableLowFlux     = o.fEnableLowFlux;
  fFirstEvent        = o.fFirstEvent;
  fCorrManager       = o.fCorrManager;
  fEventInspector    = o.fEventInspector;
  fEnergyFitter      = o.fEnergyFitter;
  fSharingFilter     = o.fSharingFilter;
  fDensityCalculator = o.fDensityCalculator;
  fHistos            = o.fHistos;
  fList              = o.fList;
  fDebug             = o.fDebug;

  return *this;
}

//____________________________________________________________________
void
AliForwardQATask::SetDebug(Int_t dbg)
{
  // 
  // Set debug level 
  // 
  // Parameters:
  //    dbg Debug level
  //
  fDebug = dbg;
  fEventInspector.SetDebug(dbg);
  fEnergyFitter.SetDebug(dbg);
  fSharingFilter.SetDebug(dbg);
  fDensityCalculator.SetDebug(dbg);
}

//____________________________________________________________________
Bool_t 
AliForwardQATask::CheckCorrections(UInt_t what) const
{
  // 
  // Check if all needed corrections are there and accounted for.  If not,
  // do a Fatal exit 
  // 
  // Parameters:
  //    what Which corrections is needed
  // 
  // Return:
  //    true if all present, false otherwise
  //  

  AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
  // Check that we have the energy loss fits, needed by 
  //   AliFMDSharingFilter 
  //   AliFMDDensityCalculator 
  if (what & AliForwardCorrectionManager::kELossFits && !fcm.GetELossFit()) { 
    AliWarning("No energy loss fits");
    return false;
  }
  return true;
}

//____________________________________________________________________
Bool_t
AliForwardQATask::ReadCorrections(const TAxis*& pe, 
				  const TAxis*& pv, 
				  Bool_t        mc)
{
  //
  // Read corrections
  //
  //
  UInt_t what = AliForwardCorrectionManager::kAll;
  what ^= AliForwardCorrectionManager::kDoubleHit;
  what ^= AliForwardCorrectionManager::kVertexBias;
  what ^= AliForwardCorrectionManager::kAcceptance;
  what ^= AliForwardCorrectionManager::kMergingEfficiency;

  AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
  if (!fcm.Init(GetEventInspector().GetCollisionSystem(),
		GetEventInspector().GetEnergy(),
		GetEventInspector().GetField(),
		mc,
		what)) return false;
  if (!CheckCorrections(what)) {
    return false;
  }

  // Sett our persistency pointer 
  // fCorrManager = &fcm;

  // Get the eta axis from the secondary maps - if read in
  if (!pe) {
    pe = fcm.GetEtaAxis();
    if (!pe) AliFatal("No eta axis defined");
  }
  // Get the vertex axis from the secondary maps - if read in
  if (!pv) {
    pv = fcm.GetVertexAxis();
    if (!pv) AliFatal("No vertex axis defined");
  }

  return true;
}

//____________________________________________________________________
AliESDEvent*
AliForwardQATask::GetESDEvent()
{
  //
  // Get the ESD event. IF this is the first event, initialise
  //
  if (IsZombie()) return 0;
  AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
  if (!esd) {
    AliWarning("No ESD event found for input event");
    return 0;
  }

  // On the first event, initialize the parameters
  if (fFirstEvent && esd->GetESDRun()) {
    GetEventInspector().ReadRunDetails(esd);

    AliInfoF("Initializing with parameters from the ESD:\n"
	     "         AliESDEvent::GetBeamEnergy()   ->%f\n"
	     "         AliESDEvent::GetBeamType()     ->%s\n"
	     "         AliESDEvent::GetCurrentL3()    ->%f\n"
	     "         AliESDEvent::GetMagneticField()->%f\n"
	     "         AliESDEvent::GetRunNumber()    ->%d",
	     esd->GetBeamEnergy(),
	     esd->GetBeamType(),
	     esd->GetCurrentL3(),
	     esd->GetMagneticField(),
	     esd->GetRunNumber());


    if (!InitializeSubs()) {
      AliWarning("Initialisation of sub algorithms failed!");
      SetZombie(true);
      esd = 0;
      return 0;
    }
    AliInfoF("Clearing first event flag from %s to false", 
	     fFirstEvent ? "true" : "false");
    fFirstEvent = false;
  }
  return esd;
}
//____________________________________________________________________
Bool_t
AliForwardQATask::InitializeSubs()
{
  // 
  // Initialise the sub objects and stuff.  Called on first event 
  // 
  //
  const TAxis* pe = 0;
  const TAxis* pv = 0;

  if (!ReadCorrections(pe,pv))  { 
    AliWarning("Using default binning");
    pv = new TAxis(10,-10, 10);
    pe = new TAxis(240,-6,6);
  }

  fHistos.Init(*pe);

  fEventInspector.Init(*pv);
  fEnergyFitter.Init(*pe);
  fSharingFilter.Init();
  fDensityCalculator.Init(*pe);

  this->Print();

  return true;
}

//____________________________________________________________________
void
AliForwardQATask::UserCreateOutputObjects()
{
  // 
  // Create output objects 
  // 
  //
  fList = new TList;
  fList->SetOwner();
  
  fEventInspector.DefineOutput(fList);
  fEnergyFitter.DefineOutput(fList);
  fSharingFilter.DefineOutput(fList);
  fDensityCalculator.DefineOutput(fList);

  PostData(1, fList);
}
//____________________________________________________________________
void
AliForwardQATask::UserExec(Option_t*)
{
  // 
  // Process each event 
  // 
  // Parameters:
  //    option Not used
  //  

  // static Int_t cnt = 0;
  // cnt++;
  // Get the input data 
  AliESDEvent* esd = GetESDEvent();
  if (!esd) { 
    AliWarning("Got no ESD event");
    return;
  }
  if (fFirstEvent) { 
    // If the first event flag wasn't cleared in the above call to
    // GetESDEvent, we should not do anything, since nothing has been
    // initialised yet, so we opt out here (with a warning) 
    AliWarning("Nothing has been initialized yet, opt'ing out");
    return;
  }

  // Clear stuff 
  fHistos.Clear();
  fESDFMD.Clear();
  
  Bool_t   lowFlux   = kFALSE;
  UInt_t   triggers  = 0;
  UShort_t ivz       = 0;
  Double_t vz        = 0;
  Double_t cent      = -1;
  UShort_t nClusters = 0;
  UInt_t   found     = fEventInspector.Process(esd, triggers, lowFlux, 
					       ivz, vz, cent, nClusters);
  
  if (found & AliFMDEventInspector::kNoEvent)    return;
  if (found & AliFMDEventInspector::kNoTriggers) return;
  if (found & AliFMDEventInspector::kNoSPD)      return;
  if (found & AliFMDEventInspector::kNoFMD)      return;
  if (found & AliFMDEventInspector::kNoVertex)   return;
  if (triggers & AliAODForwardMult::kPileUp)     return;
  if (found & AliFMDEventInspector::kBadVertex)  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();
  
  // Run the energy loss fitter 
  if (!fEnergyFitter.Accumulate(*esdFMD, cent, 
				triggers & AliAODForwardMult::kEmpty)) {
    AliWarning("Energy fitter failed");
    return;
  }
  
  //  // Apply the sharing filter (or hit merging or clustering if you like)
  if (!fSharingFilter.Filter(*esdFMD, lowFlux, fESDFMD, vz)) { 
    AliWarning("Sharing filter failed!");
    return;
  }
 
  // Calculate the inclusive charged particle density 
  if (!fDensityCalculator.Calculate(fESDFMD, fHistos, ivz, lowFlux)) { 
    // if (!fDensityCalculator.Calculate(*esdFMD, fHistos, ivz, lowFlux)) { 
    AliWarning("Density calculator failed!");
    return;
  }
  
  PostData(1, fList);
}

//____________________________________________________________________
void
AliForwardQATask::Terminate(Option_t*)
{
  // 
  // End of job
  // 
  // Parameters:
  //    option Not used 
  //
  if (fDebug) AliInfo("In Forwards terminate");
  TStopwatch swt;
  swt.Start();

  TList* list = dynamic_cast<TList*>(GetOutputData(1));
  if (!list) {
    AliError(Form("No output list defined (%p)", GetOutputData(1)));
    if (GetOutputData(1)) GetOutputData(1)->Print();
    return;
  }
  
  // Get our histograms from the container 
  TH1I* hEventsTr    = 0;//static_cast<TH1I*>(list->FindObject("nEventsTr"));
  TH1I* hEventsTrVtx = 0;//static_cast<TH1I*>(list->FindObject("nEventsTrVtx"));
  TH1I* hTriggers    = 0;
  if (!fEventInspector.FetchHistograms(list, hEventsTr, 
				       hEventsTrVtx, hTriggers)) { 
    AliError(Form("Didn't get histograms from event selector "
		  "(hEventsTr=%p,hEventsTrVtx=%p)", 
		  hEventsTr, hEventsTrVtx));
    return;
  }

  TStopwatch swf;
  swf.Start();
  fEnergyFitter.Fit(list);
  swf.Stop();
  AliInfoF("Fitting took %d real-time seconds, and %f CPU seconds", 
	   Int_t(swf.RealTime()), swf.CpuTime());

  fSharingFilter.ScaleHistograms(list,Int_t(hEventsTr->Integral()));
  fDensityCalculator.ScaleHistograms(list,Int_t(hEventsTrVtx->Integral()));

  // Make a deep copy and post that as output 2 
  TList* list2 = static_cast<TList*>(list->Clone(Form("%sResults", 
						      list->GetName())));
  if (fDebug) AliInfoF("Posting post processing results to %s", 
		       list2->GetName());
  list2->SetOwner();
  PostData(2, list2);

  swt.Stop();
  AliInfoF("Terminate took %d real-time seconds, and %f CPU seconds", 
	   Int_t(swt.RealTime()), swt.CpuTime());

}

//____________________________________________________________________
void
AliForwardQATask::Print(Option_t* option) const
{
  // 
  // Print information 
  // 
  // Parameters:
  //    option Not used
  //
  
  std::cout << ClassName() << ": " << GetName() << "\n" 
	    << "  Enable low flux code:   " << (fEnableLowFlux ? "yes" : "no") 
	    << "\n"
	    << "  Off-line trigger mask:  0x" 
	    << std::hex     << std::setfill('0') 
	    << std::setw (8) << fOfflineTriggerMask 
	    << std::dec     << std::setfill (' ') << std::endl;
  gROOT->IncreaseDirLevel();
  if (fCorrManager) fCorrManager->Print();
  else  
    std::cout << "  Correction manager not set yet" << std::endl;
  GetEventInspector()   .Print(option);
  GetEnergyFitter()     .Print(option);
  GetSharingFilter()    .Print(option);
  gROOT->DecreaseDirLevel();
}

//
// EOF
//
Commit	Line	Data
96624385	1	//
	2	// Calculate the multiplicity in the forward regions event-by-event
	3	//
	4	// Inputs:
	5	// - AliESDEvent
	6	//
	7	// Outputs:
	8	// - AliAODForwardMult
	9	//
	10	// Histograms
	11	//
	12	// Corrections used
	13	//
	14	#include "AliForwardQATask.h"
	15	#include "AliForwardUtil.h"
	16	#include "AliTriggerAnalysis.h"
	17	#include "AliPhysicsSelection.h"
	18	#include "AliLog.h"
	19	#include "AliESDEvent.h"
	20	#include "AliAODHandler.h"
	21	#include "AliMultiplicity.h"
	22	#include "AliInputEventHandler.h"
	23	#include "AliForwardCorrectionManager.h"
	24	#include "AliAnalysisManager.h"
	25	#include "AliAODForwardMult.h"
	26	#include <TH1.h>
	27	#include <TDirectory.h>
	28	#include <TTree.h>
	29	#include <TROOT.h>
e2213ed5	30	#include <TStopwatch.h>
96624385	31
	32	//====================================================================
	33	AliForwardQATask::AliForwardQATask()
	34	: AliAnalysisTaskSE(),
	35	fEnableLowFlux(false),
	36	fFirstEvent(true),
	37	fCorrManager(0),
	38	fESDFMD(),
	39	fHistos(),
	40	fEventInspector(),
	41	fEnergyFitter(),
	42	fSharingFilter(),
	43	fDensityCalculator(),
9b2f2e39	44	fList(0),
9b2f2e39	45	fDebug(0)
96624385	46	{
	47	//
	48	// Constructor
	49	//
	50	}
	51
	52	//____________________________________________________________________
	53	AliForwardQATask::AliForwardQATask(const char* name)
	54	: AliAnalysisTaskSE(name),
	55	fEnableLowFlux(false),
	56	fFirstEvent(true),
	57	fCorrManager(0),
	58	fESDFMD(),
	59	fHistos(),
	60	fEventInspector("event"),
	61	fEnergyFitter("energy"),
	62	fSharingFilter("sharing"),
	63	fDensityCalculator("density"),
9b2f2e39	64	fList(0),
9b2f2e39	65	fDebug(0)
96624385	66	{
	67	//
	68	// Constructor
	69	//
	70	// Parameters:
	71	// name Name of task
	72	//
	73	DefineOutput(1, TList::Class());
	74	DefineOutput(2, TList::Class());
	75	fCorrManager = &AliForwardCorrectionManager::Instance();
	76	fEnergyFitter.SetNParticles(1); // Just find the 1st peak
	77	fEnergyFitter.SetDoMakeObject(false);
	78	fEnergyFitter.SetUseIncreasingBins(true);
	79	fEnergyFitter.SetDoFits(kTRUE);
	80	fEnergyFitter.SetLowCut(0.4);
	81	fEnergyFitter.SetFitRangeBinWidth(4);
	82	fEnergyFitter.SetMinEntries(1000);
	83	}
	84
	85	//____________________________________________________________________
	86	AliForwardQATask::AliForwardQATask(const AliForwardQATask& o)
	87	: AliAnalysisTaskSE(o),
	88	fEnableLowFlux(o.fEnableLowFlux),
	89	fFirstEvent(o.fFirstEvent),
	90	fCorrManager(o.fCorrManager),
	91	fESDFMD(o.fESDFMD),
	92	fHistos(o.fHistos),
	93	fEventInspector(o.fEventInspector),
	94	fEnergyFitter(o.fEnergyFitter),
	95	fSharingFilter(o.fSharingFilter),
	96	fDensityCalculator(o.fDensityCalculator),
9b2f2e39	97	fList(o.fList),
9b2f2e39	98	fDebug(o.fDebug)
96624385	99	{
	100	//
	101	// Copy constructor
	102	//
	103	// Parameters:
	104	// o Object to copy from
	105	//
	106	DefineOutput(1, TList::Class());
	107	DefineOutput(2, TList::Class());
	108	}
	109
	110	//____________________________________________________________________
	111	AliForwardQATask&
	112	AliForwardQATask::operator=(const AliForwardQATask& o)
	113	{
	114	//
	115	// Assignment operator
	116	//
	117	// Parameters:
	118	// o Object to assign from
	119	//
	120	// Return:
	121	// Reference to this object
	122	//
d015ecfe	123	if (&o == this) return *this;
96624385	124	AliAnalysisTaskSE::operator=(o);
	125
	126	fEnableLowFlux = o.fEnableLowFlux;
	127	fFirstEvent = o.fFirstEvent;
	128	fCorrManager = o.fCorrManager;
	129	fEventInspector = o.fEventInspector;
	130	fEnergyFitter = o.fEnergyFitter;
	131	fSharingFilter = o.fSharingFilter;
	132	fDensityCalculator = o.fDensityCalculator;
	133	fHistos = o.fHistos;
	134	fList = o.fList;
9b2f2e39	135	fDebug = o.fDebug;
96624385	136
	137	return *this;
	138	}
	139
	140	//____________________________________________________________________
	141	void
	142	AliForwardQATask::SetDebug(Int_t dbg)
	143	{
	144	//
	145	// Set debug level
	146	//
	147	// Parameters:
	148	// dbg Debug level
	149	//
9b2f2e39	150	fDebug = dbg;
96624385	151	fEventInspector.SetDebug(dbg);
	152	fEnergyFitter.SetDebug(dbg);
	153	fSharingFilter.SetDebug(dbg);
	154	fDensityCalculator.SetDebug(dbg);
	155	}
	156
	157	//____________________________________________________________________
	158	Bool_t
	159	AliForwardQATask::CheckCorrections(UInt_t what) const
	160	{
	161	//
	162	// Check if all needed corrections are there and accounted for. If not,
	163	// do a Fatal exit
	164	//
	165	// Parameters:
	166	// what Which corrections is needed
	167	//
	168	// Return:
	169	// true if all present, false otherwise
	170	//
	171
	172	AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
	173	// Check that we have the energy loss fits, needed by
	174	// AliFMDSharingFilter
	175	// AliFMDDensityCalculator
	176	if (what & AliForwardCorrectionManager::kELossFits && !fcm.GetELossFit()) {
460a5c02	177	AliWarning("No energy loss fits");
96624385	178	return false;
	179	}
	180	return true;
	181	}
	182
	183	//____________________________________________________________________
	184	Bool_t
	185	AliForwardQATask::ReadCorrections(const TAxis*& pe,
	186	const TAxis*& pv,
	187	Bool_t mc)
	188	{
	189	//
	190	// Read corrections
	191	//
	192	//
	193	UInt_t what = AliForwardCorrectionManager::kAll;
	194	what ^= AliForwardCorrectionManager::kDoubleHit;
	195	what ^= AliForwardCorrectionManager::kVertexBias;
	196	what ^= AliForwardCorrectionManager::kAcceptance;
	197	what ^= AliForwardCorrectionManager::kMergingEfficiency;
	198
	199	AliForwardCorrectionManager& fcm = AliForwardCorrectionManager::Instance();
	200	if (!fcm.Init(GetEventInspector().GetCollisionSystem(),
	201	GetEventInspector().GetEnergy(),
	202	GetEventInspector().GetField(),
	203	mc,
	204	what)) return false;
460a5c02	205	if (!CheckCorrections(what)) {
	206	return false;
	207	}
96624385	208
	209	// Sett our persistency pointer
	210	// fCorrManager = &fcm;
	211
	212	// Get the eta axis from the secondary maps - if read in
	213	if (!pe) {
	214	pe = fcm.GetEtaAxis();
	215	if (!pe) AliFatal("No eta axis defined");
	216	}
	217	// Get the vertex axis from the secondary maps - if read in
	218	if (!pv) {
	219	pv = fcm.GetVertexAxis();
	220	if (!pv) AliFatal("No vertex axis defined");
	221	}
	222
	223	return true;
	224	}
	225
	226	//____________________________________________________________________
	227	AliESDEvent*
	228	AliForwardQATask::GetESDEvent()
	229	{
	230	//
	231	// Get the ESD event. IF this is the first event, initialise
	232	//
6ff251d8	233	if (IsZombie()) return 0;
96624385	234	AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
	235	if (!esd) {
	236	AliWarning("No ESD event found for input event");
	237	return 0;
	238	}
	239
	240	// On the first event, initialize the parameters
	241	if (fFirstEvent && esd->GetESDRun()) {
	242	GetEventInspector().ReadRunDetails(esd);
	243
422a78c8	244	AliInfoF("Initializing with parameters from the ESD:\n"
	245	" AliESDEvent::GetBeamEnergy() ->%f\n"
	246	" AliESDEvent::GetBeamType() ->%s\n"
	247	" AliESDEvent::GetCurrentL3() ->%f\n"
	248	" AliESDEvent::GetMagneticField()->%f\n"
6ff251d8	249	" AliESDEvent::GetRunNumber() ->%d",
422a78c8	250	esd->GetBeamEnergy(),
	251	esd->GetBeamType(),
	252	esd->GetCurrentL3(),
	253	esd->GetMagneticField(),
	254	esd->GetRunNumber());
96624385	255
96624385	256
422a78c8	257	if (!InitializeSubs()) {
422a78c8	258	AliWarning("Initialisation of sub algorithms failed!");
6ff251d8	259	SetZombie(true);
6ff251d8	260	esd = 0;
422a78c8	261	return 0;
422a78c8	262	}
460a5c02	263	AliInfoF("Clearing first event flag from %s to false",
	264	fFirstEvent ? "true" : "false");
	265	fFirstEvent = false;
96624385	266	}
	267	return esd;
	268	}
	269	//____________________________________________________________________
422a78c8	270	Bool_t
96624385	271	AliForwardQATask::InitializeSubs()
	272	{
	273	//
	274	// Initialise the sub objects and stuff. Called on first event
	275	//
	276	//
	277	const TAxis* pe = 0;
	278	const TAxis* pv = 0;
	279
d70d2a44	280	if (!ReadCorrections(pe,pv)) {
	281	AliWarning("Using default binning");
	282	pv = new TAxis(10,-10, 10);
	283	pe = new TAxis(240,-6,6);
460a5c02	284	}
96624385	285
	286	fHistos.Init(*pe);
	287
	288	fEventInspector.Init(*pv);
	289	fEnergyFitter.Init(*pe);
	290	fSharingFilter.Init();
	291	fDensityCalculator.Init(*pe);
	292
	293	this->Print();
422a78c8	294
422a78c8	295	return true;
96624385	296	}
	297
	298	//____________________________________________________________________
	299	void
	300	AliForwardQATask::UserCreateOutputObjects()
	301	{
	302	//
	303	// Create output objects
	304	//
	305	//
	306	fList = new TList;
	307	fList->SetOwner();
	308
	309	fEventInspector.DefineOutput(fList);
	310	fEnergyFitter.DefineOutput(fList);
	311	fSharingFilter.DefineOutput(fList);
	312	fDensityCalculator.DefineOutput(fList);
	313
	314	PostData(1, fList);
	315	}
	316	//____________________________________________________________________
	317	void
	318	AliForwardQATask::UserExec(Option_t*)
	319	{
	320	//
	321	// Process each event
	322	//
	323	// Parameters:
	324	// option Not used
	325	//
	326
	327	// static Int_t cnt = 0;
	328	// cnt++;
	329	// Get the input data
	330	AliESDEvent* esd = GetESDEvent();
422a78c8	331	if (!esd) {
	332	AliWarning("Got no ESD event");
	333	return;
	334	}
460a5c02	335	if (fFirstEvent) {
	336	// If the first event flag wasn't cleared in the above call to
	337	// GetESDEvent, we should not do anything, since nothing has been
	338	// initialised yet, so we opt out here (with a warning)
	339	AliWarning("Nothing has been initialized yet, opt'ing out");
	340	return;
	341	}
96624385	342
	343	// Clear stuff
	344	fHistos.Clear();
	345	fESDFMD.Clear();
	346
	347	Bool_t lowFlux = kFALSE;
	348	UInt_t triggers = 0;
	349	UShort_t ivz = 0;
	350	Double_t vz = 0;
	351	Double_t cent = -1;
	352	UShort_t nClusters = 0;
	353	UInt_t found = fEventInspector.Process(esd, triggers, lowFlux,
	354	ivz, vz, cent, nClusters);
	355
	356	if (found & AliFMDEventInspector::kNoEvent) return;
	357	if (found & AliFMDEventInspector::kNoTriggers) return;
	358	if (found & AliFMDEventInspector::kNoSPD) return;
	359	if (found & AliFMDEventInspector::kNoFMD) return;
	360	if (found & AliFMDEventInspector::kNoVertex) return;
	361	if (triggers & AliAODForwardMult::kPileUp) return;
	362	if (found & AliFMDEventInspector::kBadVertex) return;
	363
	364	// We we do not want to use low flux specific code, we disable it here.
	365	if (!fEnableLowFlux) lowFlux = false;
	366
	367	// Get FMD data
	368	AliESDFMD* esdFMD = esd->GetFMDData();
	369
	370	// Run the energy loss fitter
	371	if (!fEnergyFitter.Accumulate(*esdFMD, cent,
	372	triggers & AliAODForwardMult::kEmpty)) {
	373	AliWarning("Energy fitter failed");
	374	return;
	375	}
4077f3e8	376
96624385	377	// // Apply the sharing filter (or hit merging or clustering if you like)
6f4a5c0d	378	if (!fSharingFilter.Filter(*esdFMD, lowFlux, fESDFMD, vz)) {
96624385	379	AliWarning("Sharing filter failed!");
	380	return;
	381	}
4077f3e8	382
96624385	383	// Calculate the inclusive charged particle density
	384	if (!fDensityCalculator.Calculate(fESDFMD, fHistos, ivz, lowFlux)) {
	385	// if (!fDensityCalculator.Calculate(*esdFMD, fHistos, ivz, lowFlux)) {
	386	AliWarning("Density calculator failed!");
	387	return;
	388	}
4077f3e8	389
96624385	390	PostData(1, fList);
	391	}
	392
	393	//____________________________________________________________________
	394	void
	395	AliForwardQATask::Terminate(Option_t*)
	396	{
	397	//
	398	// End of job
	399	//
	400	// Parameters:
	401	// option Not used
	402	//
9b2f2e39	403	if (fDebug) AliInfo("In Forwards terminate");
e2213ed5	404	TStopwatch swt;
e2213ed5	405	swt.Start();
96624385	406
	407	TList* list = dynamic_cast<TList*>(GetOutputData(1));
	408	if (!list) {
	409	AliError(Form("No output list defined (%p)", GetOutputData(1)));
	410	if (GetOutputData(1)) GetOutputData(1)->Print();
	411	return;
	412	}
	413
	414	// Get our histograms from the container
	415	TH1I* hEventsTr = 0;//static_cast<TH1I*>(list->FindObject("nEventsTr"));
	416	TH1I* hEventsTrVtx = 0;//static_cast<TH1I*>(list->FindObject("nEventsTrVtx"));
	417	TH1I* hTriggers = 0;
	418	if (!fEventInspector.FetchHistograms(list, hEventsTr,
	419	hEventsTrVtx, hTriggers)) {
	420	AliError(Form("Didn't get histograms from event selector "
	421	"(hEventsTr=%p,hEventsTrVtx=%p)",
	422	hEventsTr, hEventsTrVtx));
	423	return;
	424	}
	425
e2213ed5	426	TStopwatch swf;
e2213ed5	427	swf.Start();
96624385	428	fEnergyFitter.Fit(list);
e2213ed5	429	swf.Stop();
	430	AliInfoF("Fitting took %d real-time seconds, and %f CPU seconds",
	431	Int_t(swf.RealTime()), swf.CpuTime());
96624385	432
	433	fSharingFilter.ScaleHistograms(list,Int_t(hEventsTr->Integral()));
	434	fDensityCalculator.ScaleHistograms(list,Int_t(hEventsTrVtx->Integral()));
	435
	436	// Make a deep copy and post that as output 2
	437	TList* list2 = static_cast<TList*>(list->Clone(Form("%sResults",
	438	list->GetName())));
9b2f2e39	439	if (fDebug) AliInfoF("Posting post processing results to %s",
9b2f2e39	440	list2->GetName());
96624385	441	list2->SetOwner();
	442	PostData(2, list2);
	443
e2213ed5	444	swt.Stop();
	445	AliInfoF("Terminate took %d real-time seconds, and %f CPU seconds",
	446	Int_t(swt.RealTime()), swt.CpuTime());
	447
96624385	448	}
	449
	450	//____________________________________________________________________
	451	void
	452	AliForwardQATask::Print(Option_t* option) const
	453	{
	454	//
	455	// Print information
	456	//
	457	// Parameters:
	458	// option Not used
	459	//
	460
	461	std::cout << ClassName() << ": " << GetName() << "\n"
	462	<< " Enable low flux code: " << (fEnableLowFlux ? "yes" : "no")
	463	<< "\n"
	464	<< " Off-line trigger mask: 0x"
	465	<< std::hex << std::setfill('0')
	466	<< std::setw (8) << fOfflineTriggerMask
	467	<< std::dec << std::setfill (' ') << std::endl;
	468	gROOT->IncreaseDirLevel();
	469	if (fCorrManager) fCorrManager->Print();
	470	else
	471	std::cout << " Correction manager not set yet" << std::endl;
	472	GetEventInspector() .Print(option);
	473	GetEnergyFitter() .Print(option);
	474	GetSharingFilter() .Print(option);
	475	gROOT->DecreaseDirLevel();
	476	}
	477
	478	//
	479	// EOF
	480	//