[u/mrichter/AliRoot.git] / PWG2 / 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
  //
  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\n",
	     esd->GetBeamEnergy(),
	     esd->GetBeamType(),
	     esd->GetCurrentL3(),
	     esd->GetMagneticField(),
	     esd->GetRunNumber());


    if (!InitializeSubs()) {
      AliWarning("Initialisation of sub algorithms failed!");
      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("Failed to read corrections");
    return false;
  }

  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)) { 
    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	//
	233	AliESDEvent* esd = dynamic_cast<AliESDEvent*>(InputEvent());
	234	if (!esd) {
	235	AliWarning("No ESD event found for input event");
	236	return 0;
	237	}
	238
	239	// On the first event, initialize the parameters
	240	if (fFirstEvent && esd->GetESDRun()) {
	241	GetEventInspector().ReadRunDetails(esd);
	242
422a78c8	243	AliInfoF("Initializing with parameters from the ESD:\n"
	244	" AliESDEvent::GetBeamEnergy() ->%f\n"
	245	" AliESDEvent::GetBeamType() ->%s\n"
	246	" AliESDEvent::GetCurrentL3() ->%f\n"
	247	" AliESDEvent::GetMagneticField()->%f\n"
	248	" AliESDEvent::GetRunNumber() ->%d\n",
	249	esd->GetBeamEnergy(),
	250	esd->GetBeamType(),
	251	esd->GetCurrentL3(),
	252	esd->GetMagneticField(),
	253	esd->GetRunNumber());
96624385	254
96624385	255
422a78c8	256	if (!InitializeSubs()) {
	257	AliWarning("Initialisation of sub algorithms failed!");
	258	return 0;
	259	}
460a5c02	260	AliInfoF("Clearing first event flag from %s to false",
	261	fFirstEvent ? "true" : "false");
	262	fFirstEvent = false;
96624385	263	}
	264	return esd;
	265	}
	266	//____________________________________________________________________
422a78c8	267	Bool_t
96624385	268	AliForwardQATask::InitializeSubs()
	269	{
	270	//
	271	// Initialise the sub objects and stuff. Called on first event
	272	//
	273	//
	274	const TAxis* pe = 0;
	275	const TAxis* pv = 0;
	276
460a5c02	277	if (!ReadCorrections(pe,pv)) {
	278	AliWarning("Failed to read corrections");
	279	return false;
	280	}
96624385	281
	282	fHistos.Init(*pe);
	283
	284	fEventInspector.Init(*pv);
	285	fEnergyFitter.Init(*pe);
	286	fSharingFilter.Init();
	287	fDensityCalculator.Init(*pe);
	288
	289	this->Print();
422a78c8	290
422a78c8	291	return true;
96624385	292	}
	293
	294	//____________________________________________________________________
	295	void
	296	AliForwardQATask::UserCreateOutputObjects()
	297	{
	298	//
	299	// Create output objects
	300	//
	301	//
	302	fList = new TList;
	303	fList->SetOwner();
	304
	305	fEventInspector.DefineOutput(fList);
	306	fEnergyFitter.DefineOutput(fList);
	307	fSharingFilter.DefineOutput(fList);
	308	fDensityCalculator.DefineOutput(fList);
	309
	310	PostData(1, fList);
	311	}
	312	//____________________________________________________________________
	313	void
	314	AliForwardQATask::UserExec(Option_t*)
	315	{
	316	//
	317	// Process each event
	318	//
	319	// Parameters:
	320	// option Not used
	321	//
	322
	323	// static Int_t cnt = 0;
	324	// cnt++;
	325	// Get the input data
	326	AliESDEvent* esd = GetESDEvent();
422a78c8	327	if (!esd) {
	328	AliWarning("Got no ESD event");
	329	return;
	330	}
460a5c02	331	if (fFirstEvent) {
	332	// If the first event flag wasn't cleared in the above call to
	333	// GetESDEvent, we should not do anything, since nothing has been
	334	// initialised yet, so we opt out here (with a warning)
	335	AliWarning("Nothing has been initialized yet, opt'ing out");
	336	return;
	337	}
96624385	338
	339	// Clear stuff
	340	fHistos.Clear();
	341	fESDFMD.Clear();
	342
	343	Bool_t lowFlux = kFALSE;
	344	UInt_t triggers = 0;
	345	UShort_t ivz = 0;
	346	Double_t vz = 0;
	347	Double_t cent = -1;
	348	UShort_t nClusters = 0;
	349	UInt_t found = fEventInspector.Process(esd, triggers, lowFlux,
	350	ivz, vz, cent, nClusters);
	351
	352	if (found & AliFMDEventInspector::kNoEvent) return;
	353	if (found & AliFMDEventInspector::kNoTriggers) return;
	354	if (found & AliFMDEventInspector::kNoSPD) return;
	355	if (found & AliFMDEventInspector::kNoFMD) return;
	356	if (found & AliFMDEventInspector::kNoVertex) return;
	357	if (triggers & AliAODForwardMult::kPileUp) return;
	358	if (found & AliFMDEventInspector::kBadVertex) return;
	359
	360	// We we do not want to use low flux specific code, we disable it here.
	361	if (!fEnableLowFlux) lowFlux = false;
	362
	363	// Get FMD data
	364	AliESDFMD* esdFMD = esd->GetFMDData();
	365
	366	// Run the energy loss fitter
	367	if (!fEnergyFitter.Accumulate(*esdFMD, cent,
	368	triggers & AliAODForwardMult::kEmpty)) {
	369	AliWarning("Energy fitter failed");
	370	return;
	371	}
	372
	373	// // Apply the sharing filter (or hit merging or clustering if you like)
	374	if (!fSharingFilter.Filter(*esdFMD, lowFlux, fESDFMD)) {
	375	AliWarning("Sharing filter failed!");
	376	return;
	377	}
	378
	379	// Calculate the inclusive charged particle density
	380	if (!fDensityCalculator.Calculate(fESDFMD, fHistos, ivz, lowFlux)) {
	381	// if (!fDensityCalculator.Calculate(*esdFMD, fHistos, ivz, lowFlux)) {
	382	AliWarning("Density calculator failed!");
	383	return;
	384	}
	385	PostData(1, fList);
	386	}
	387
	388	//____________________________________________________________________
	389	void
	390	AliForwardQATask::Terminate(Option_t*)
	391	{
	392	//
	393	// End of job
	394	//
	395	// Parameters:
	396	// option Not used
	397	//
9b2f2e39	398	if (fDebug) AliInfo("In Forwards terminate");
e2213ed5	399	TStopwatch swt;
e2213ed5	400	swt.Start();
96624385	401
	402	TList* list = dynamic_cast<TList*>(GetOutputData(1));
	403	if (!list) {
	404	AliError(Form("No output list defined (%p)", GetOutputData(1)));
	405	if (GetOutputData(1)) GetOutputData(1)->Print();
	406	return;
	407	}
	408
	409	// Get our histograms from the container
	410	TH1I* hEventsTr = 0;//static_cast<TH1I*>(list->FindObject("nEventsTr"));
	411	TH1I* hEventsTrVtx = 0;//static_cast<TH1I*>(list->FindObject("nEventsTrVtx"));
	412	TH1I* hTriggers = 0;
	413	if (!fEventInspector.FetchHistograms(list, hEventsTr,
	414	hEventsTrVtx, hTriggers)) {
	415	AliError(Form("Didn't get histograms from event selector "
	416	"(hEventsTr=%p,hEventsTrVtx=%p)",
	417	hEventsTr, hEventsTrVtx));
	418	return;
	419	}
	420
e2213ed5	421	TStopwatch swf;
e2213ed5	422	swf.Start();
96624385	423	fEnergyFitter.Fit(list);
e2213ed5	424	swf.Stop();
	425	AliInfoF("Fitting took %d real-time seconds, and %f CPU seconds",
	426	Int_t(swf.RealTime()), swf.CpuTime());
96624385	427
	428	fSharingFilter.ScaleHistograms(list,Int_t(hEventsTr->Integral()));
	429	fDensityCalculator.ScaleHistograms(list,Int_t(hEventsTrVtx->Integral()));
	430
	431	// Make a deep copy and post that as output 2
	432	TList* list2 = static_cast<TList*>(list->Clone(Form("%sResults",
	433	list->GetName())));
9b2f2e39	434	if (fDebug) AliInfoF("Posting post processing results to %s",
9b2f2e39	435	list2->GetName());
96624385	436	list2->SetOwner();
	437	PostData(2, list2);
	438
e2213ed5	439	swt.Stop();
	440	AliInfoF("Terminate took %d real-time seconds, and %f CPU seconds",
	441	Int_t(swt.RealTime()), swt.CpuTime());
	442
96624385	443	}
	444
	445	//____________________________________________________________________
	446	void
	447	AliForwardQATask::Print(Option_t* option) const
	448	{
	449	//
	450	// Print information
	451	//
	452	// Parameters:
	453	// option Not used
	454	//
	455
	456	std::cout << ClassName() << ": " << GetName() << "\n"
	457	<< " Enable low flux code: " << (fEnableLowFlux ? "yes" : "no")
	458	<< "\n"
	459	<< " Off-line trigger mask: 0x"
	460	<< std::hex << std::setfill('0')
	461	<< std::setw (8) << fOfflineTriggerMask
	462	<< std::dec << std::setfill (' ') << std::endl;
	463	gROOT->IncreaseDirLevel();
	464	if (fCorrManager) fCorrManager->Print();
	465	else
	466	std::cout << " Correction manager not set yet" << std::endl;
	467	GetEventInspector() .Print(option);
	468	GetEnergyFitter() .Print(option);
	469	GetSharingFilter() .Print(option);
	470	gROOT->DecreaseDirLevel();
	471	}
	472
	473	//
	474	// EOF
	475	//