[u/mrichter/AliRoot.git] / PWG2 / FEMTOSCOPY / AliFemto / AliAnalysisTaskFemto.cxx

//------------------------------------------------------\r
// AliAnalysisTaskFemto - A task for the analysis framework\r
// from the FEMTOSCOPY analysis of PWG2. Creates the necessary\r
// connection between the ESD or AOD input and the femtoscopic\r
// code.\r
// Author: Adam Kisiel, OSU; Adam.Kisiel@cern.ch\r
//------------------------------------------------------\r
#include "TROOT.h"\r
#include "TChain.h"\r
#include "TH1.h"\r
#include "TCanvas.h"\r
#include "TSystem.h"\r
#include "TFile.h"\r
#include "TInterpreter.h"\r
\r
#include "AliAnalysisTask.h"\r
\r
#include "AliESDEvent.h"\r
\r
#include "AliFemtoAnalysis.h"\r
#include "AliAnalysisTaskFemto.h"\r
#include "AliVHeader.h"\r
#include "AliGenEventHeader.h"\r
#include "AliGenHijingEventHeader.h"\r
#include "AliGenCocktailEventHeader.h"\r
\r
ClassImp(AliAnalysisTaskFemto)\r
\r
// Default name for the setup macro of femto analysis  \r
// This function MUST be defined in the separate file !!!\r
// extern AliFemtoManager *ConfigFemtoAnalysis();\r
\r
//________________________________________________________________________\r
AliAnalysisTaskFemto::AliAnalysisTaskFemto(const char *name, const char *aConfigMacro, const char *aConfigParams):\r
    AliAnalysisTask(name,""), \r
    fESD(0), \r
    fAOD(0),\r
    fStack(0),\r
    fOutputList(0), \r
    fReader(0x0),\r
    fManager(0x0),\r
    fAnalysisType(0),\r
    fConfigMacro(0),\r
    fConfigParams(0)\r
{\r
  // Constructor.\r
  // Input slot #0 works with an Ntuple\r
  DefineInput(0, TChain::Class());\r
  // Output slot #0 writes into a TH1 container\r
  DefineOutput(0, TList::Class());\r
  fConfigMacro = (char *) malloc(sizeof(char) * strlen(aConfigMacro));\r
  strcpy(fConfigMacro, aConfigMacro);\r
  fConfigParams = (char *) malloc(sizeof(char) * strlen(aConfigParams));\r
  strcpy(fConfigParams, aConfigParams);\r
}\r
//________________________________________________________________________\r
AliAnalysisTaskFemto::AliAnalysisTaskFemto(const char *name, const char *aConfigMacro="ConfigFemtoAnalysis.C"): \r
    AliAnalysisTask(name,""), \r
    fESD(0), \r
    fAOD(0),\r
    fStack(0),\r
    fOutputList(0), \r
    fReader(0x0),\r
    fManager(0x0),\r
    fAnalysisType(0),\r
    fConfigMacro(0),\r
    fConfigParams(0)\r
{\r
  // Constructor.\r
  // Input slot #0 works with an Ntuple\r
  DefineInput(0, TChain::Class());\r
  // Output slot #0 writes into a TH1 container\r
  DefineOutput(0, TList::Class());\r
  fConfigMacro = (char *) malloc(sizeof(char) * strlen(aConfigMacro));\r
  strcpy(fConfigMacro, aConfigMacro);\r
  fConfigParams = (char *) malloc(sizeof(char) * 2);\r
  strcpy(fConfigParams, "");\r
}\r
\r
AliAnalysisTaskFemto::AliAnalysisTaskFemto(const AliAnalysisTaskFemto& aFemtoTask):\r
    AliAnalysisTask(aFemtoTask), \r
    fESD(0), \r
    fAOD(0),\r
    fStack(0),\r
    fOutputList(0), \r
    fReader(0x0),\r
    fManager(0x0),\r
    fAnalysisType(0),\r
    fConfigMacro(0),\r
    fConfigParams(0)\r
{\r
  // copy constructor\r
  fESD = aFemtoTask.fESD; \r
  fAOD = aFemtoTask.fAOD; \r
  fStack = aFemtoTask.fStack;\r
  fOutputList = aFemtoTask.fOutputList;   \r
  fReader = aFemtoTask.fReader;       \r
  fManager = aFemtoTask.fManager;      \r
  fAnalysisType = aFemtoTask.fAnalysisType; \r
  fConfigMacro = (char *) malloc(sizeof(char) * strlen(aFemtoTask.fConfigMacro));\r
  strcpy(fConfigMacro, aFemtoTask.fConfigMacro);\r
  fConfigParams = (char *) malloc(sizeof(char) * strlen(aFemtoTask.fConfigParams));\r
  strcpy(fConfigParams, aFemtoTask.fConfigParams);\r
}\r
\r
\r
AliAnalysisTaskFemto& AliAnalysisTaskFemto::operator=(const AliAnalysisTaskFemto& aFemtoTask){\r
  // assignment operator\r
  if (this == &aFemtoTask)\r
    return *this;\r
\r
  fESD = aFemtoTask.fESD; \r
  fAOD = aFemtoTask.fAOD; \r
  fStack = aFemtoTask.fStack;\r
  fOutputList = aFemtoTask.fOutputList;   \r
  fReader = aFemtoTask.fReader;       \r
  fManager = aFemtoTask.fManager;      \r
  fAnalysisType = aFemtoTask.fAnalysisType; \r
  if (fConfigMacro) free(fConfigMacro);\r
  fConfigMacro = (char *) malloc(sizeof(char) * strlen(aFemtoTask.fConfigMacro));\r
  strcpy(fConfigMacro, aFemtoTask.fConfigMacro);\r
  if (fConfigParams) free(fConfigParams);\r
  fConfigParams = (char *) malloc(sizeof(char) * strlen(aFemtoTask.fConfigParams));\r
  strcpy(fConfigParams, aFemtoTask.fConfigParams);\r
\r
  return *this;\r
}\r
\r
AliAnalysisTaskFemto::~AliAnalysisTaskFemto() \r
{\r
  if (fConfigMacro) free(fConfigMacro);\r
  if (fConfigParams) free(fConfigParams);\r
}\r
\r
\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::ConnectInputData(Option_t *) {\r
  AliInfo(Form("   ConnectInputData %s\n", GetName()));\r
\r
  fESD = 0;\r
  fAOD = 0;\r
  fAnalysisType = 0;\r
\r
  TTree* tree = dynamic_cast<TTree*> (GetInputData(0));\r
  if (!tree) {\r
    AliWarning("Could not read chain from input slot 0");\r
    return;\r
  } \r
\r
  if ((dynamic_cast<AliFemtoEventReaderESDChain *> (fReader)) ||\r
      (dynamic_cast<AliFemtoEventReaderESDChainKine *> (fReader))) {\r
    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
    \r
    if(esdH) {\r
      AliInfo("Selected ESD analysis");\r
      fAnalysisType = 1;\r
      \r
//       if (!esdH) {\r
// 	AliWarning("Could not get ESDInputHandler");\r
//       } \r
//       else {\r
	fESD = esdH->GetEvent();\r
//       }\r
    }\r
  }\r
  \r
  if (dynamic_cast<AliFemtoEventReaderAODChain *> (fReader)) {\r
    AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
	\r
    if (!aodH) {\r
      TObject *handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();\r
      AliInfo("Has output handler ");\r
      if( handler && handler->InheritsFrom("AliAODHandler") ) {\r
	AliInfo("Selected AOD analysis");\r
\r
	fAOD = ((AliAODHandler*)handler)->GetAOD();\r
	fAnalysisType = 2;\r
      }\r
      else {\r
	AliWarning("Selected AOD reader but no AOD handler found");\r
      }\r
    } \r
    else {\r
      AliInfo("Selected AOD analysis");\r
      fAnalysisType = 2;\r
      \r
      fAOD = aodH->GetEvent();\r
    }\r
  }\r
\r
  if ((!fAOD) && (!fESD)) {\r
    AliWarning("Wrong analysis type: Only ESD and AOD types are allowed!");\r
  }\r
}\r
\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::CreateOutputObjects() {\r
  AliInfo("Creating Femto Analysis objects\n");\r
\r
  gSystem->SetIncludePath("-I$ROOTSYS/include -I./STEERBase/ -I./ESD/ -I./AOD/ -I./ANALYSIS/ -I./ANALYSISalice/ -I./PWG2AOD/AOD -I./PWG2femtoscopy/FEMTOSCOPY/AliFemto -I./PWG2femtoscopyUser/FEMTOSCOPY/AliFemtoUser");\r
  //  char fcm[2000];\r
//   sprintf(fcm, "%s++", fConfigMacro);\r
//   gROOT->LoadMacro(fcm);\r
  gROOT->LoadMacro(fConfigMacro);\r
  //  fJetFinder = (AliJetFinder*) gInterpreter->ProcessLine("ConfigJetAnalysis()");\r
  if (!fConfigParams)\r
    SetFemtoManager((AliFemtoManager *) gInterpreter->ProcessLine("ConfigFemtoAnalysis()"));\r
  else\r
    SetFemtoManager((AliFemtoManager *) gInterpreter->ProcessLine(Form("ConfigFemtoAnalysis(%s)", fConfigParams)));\r
\r
  TList *tOL;\r
  fOutputList = fManager->Analysis(0)->GetOutputList();\r
\r
  for (unsigned int ian = 1; ian<fManager->AnalysisCollection()->size(); ian++) {\r
    tOL = fManager->Analysis(ian)->GetOutputList();\r
\r
    TIter nextListCf(tOL);\r
    while (TObject *obj = nextListCf()) {\r
      fOutputList->Add(obj);\r
    }\r
\r
    delete tOL;\r
  }\r
\r
  PostData(0, fOutputList);\r
}\r
\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::Exec(Option_t *) {\r
  // Task making a femtoscopic analysis.\r
\r
  if (fAnalysisType==1) {\r
    if (!fESD) {\r
      AliWarning("fESD not available");\r
      return;\r
    }\r
\r
    //Get MC data\r
    AliMCEventHandler*    mctruth = (AliMCEventHandler*) \r
      ((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());\r
    \r
    AliGenHijingEventHeader *hdh = 0;\r
    if(mctruth) {\r
      fStack = mctruth->MCEvent()->Stack();\r
\r
      AliGenCocktailEventHeader *hd = dynamic_cast<AliGenCocktailEventHeader *> (mctruth->MCEvent()->GenEventHeader());\r
      \r
      if (hd) {\r
	\r
	//	AliInfo ("Got MC cocktail event header %p\n", (void *) hd);\r
	TList *lhd = hd->GetHeaders();\r
	//	AliInfo ("Got list of headers %d\n", lhd->GetEntries());\r
	\r
	for (int iterh=0; iterh<lhd->GetEntries(); iterh++) \r
	  {\r
	    hdh = dynamic_cast<AliGenHijingEventHeader *> (lhd->At(iterh));\r
	    //	    AliInfo ("HIJING header at %i is %p\n", iterh, (void *) hdh);\r
	  }\r
      }    \r
    }\r
\r
    // Get ESD\r
    AliESDInputHandler *esdH = dynamic_cast<AliESDInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
    \r
    if (!esdH) {\r
      AliWarning("Could not get ESDInputHandler");\r
      return;\r
    } \r
    else {\r
      fESD = esdH->GetEvent();\r
    }\r
\r
    AliInfo(Form("Tracks in ESD: %d \n",fESD->GetNumberOfTracks()));\r
\r
    if (fESD->GetNumberOfTracks() >= 0) {\r
    \r
      if (!fReader) {\r
 	AliWarning("No ESD reader for ESD analysis !\n");\r
      }\r
      \r
      AliFemtoEventReaderESDChain* fesdc = dynamic_cast<AliFemtoEventReaderESDChain *> (fReader);\r
      if (fesdc)\r
	{\r
	  // Process the event with no Kine information\r
	  fesdc->SetESDSource(fESD);\r
	  fManager->ProcessEvent();\r
	}\r
      AliFemtoEventReaderESDChainKine* fesdck = dynamic_cast<AliFemtoEventReaderESDChainKine *> (fReader);\r
      if (fesdck) \r
	{\r
	  // Process the event with Kine information\r
	  fesdck->SetESDSource(fESD);\r
	  fesdck->SetStackSource(fStack);\r
	  \r
	  fesdck->SetGenEventHeader(hdh);\r
	  fManager->ProcessEvent();\r
	}\r
      AliFemtoEventReaderStandard* fstd = dynamic_cast<AliFemtoEventReaderStandard *> (fReader);\r
      if (fstd) \r
	{\r
	  // Process the event with Kine information\r
	  fstd->SetESDSource(fESD);\r
	  if (mctruth) {\r
	    fstd->SetStackSource(fStack);\r
	    fstd->SetGenEventHeader(hdh);\r
	    fstd->SetInputType(AliFemtoEventReaderStandard::kESDKine);\r
	  }\r
	  else\r
	    fstd->SetInputType(AliFemtoEventReaderStandard::kESD);\r
	  fManager->ProcessEvent();\r
	}\r
    } \r
\r
    // Post the output histogram list\r
    PostData(0, fOutputList);\r
  }\r
\r
  if (fAnalysisType==2) {    \r
    if (!fAOD) {\r
      AliWarning("fAOD not available");\r
      return;\r
    }\r
\r
    // Get AOD\r
//     AliAODInputHandler *aodH = dynamic_cast<AliAODInputHandler*> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
      \r
//     if (!aodH) {\r
//       AliWarning("Could not get AODInputHandler");\r
//       return;\r
//     } \r
//     else {\r
\r
//       fAOD = aodH->GetEvent();\r
//     }\r
\r
    AliInfo(Form("Tracks in AOD: %d \n",fAOD->GetNumberOfTracks()));\r
    \r
    if (fAOD->GetNumberOfTracks() > 0) {\r
      if (!fReader) {\r
	AliWarning("No AOD reader for AOD analysis! \n");\r
      }\r
      else {\r
	AliFemtoEventReaderAODChain* faodc = dynamic_cast<AliFemtoEventReaderAODChain *> (fReader);\r
\r
	if (faodc) {\r
	  // Process the event\r
	  faodc->SetAODSource(fAOD);\r
	  fManager->ProcessEvent();\r
	}\r
	AliFemtoEventReaderStandard* fstd = dynamic_cast<AliFemtoEventReaderStandard *> (fReader);\r
\r
	if (fstd) {\r
	  // Process the event\r
	  fstd->SetAODSource(fAOD);\r
	  fstd->SetInputType(AliFemtoEventReaderStandard::kAOD);\r
	  fManager->ProcessEvent();\r
	}\r
      }\r
    } \r
\r
    // Post the output histogram list\r
    PostData(0, fOutputList);\r
  }\r
}      \r
\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::Terminate(Option_t *) {\r
  // Do the final processing\r
  if (fManager) {\r
    fManager->Finish();\r
  }\r
}\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto:: FinishTaskOutput() {\r
  // Do the final processing\r
  if (fManager) {\r
    fManager->Finish();\r
  }\r
}\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::SetFemtoReaderESD(AliFemtoEventReaderESDChain *aReader)\r
{\r
  AliInfo("Selecting Femto reader for ESD\n");\r
  fReader = aReader;\r
}\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::SetFemtoReaderESDKine(AliFemtoEventReaderESDChainKine *aReader)\r
{\r
  AliInfo("Selecting Femto reader for ESD with Kinematics information\n");\r
  fReader = aReader;\r
}\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::SetFemtoReaderAOD(AliFemtoEventReaderAODChain *aReader)\r
{\r
  AliInfo("Selecting Femto reader for AOD\n");\r
  fReader = aReader;\r
}\r
void AliAnalysisTaskFemto::SetFemtoReaderStandard(AliFemtoEventReaderStandard *aReader)\r
{\r
  AliInfo("Selecting Standard all-purpose Femto reader\n");\r
  fReader = aReader;\r
}\r
//________________________________________________________________________\r
void AliAnalysisTaskFemto::SetFemtoManager(AliFemtoManager *aManager)\r
{\r
  fManager = aManager;\r
  AliInfo(Form("Got reader %p\n", (void *) aManager->EventReader()));\r
  AliFemtoEventReaderESDChain     *tReaderESDChain     = dynamic_cast<AliFemtoEventReaderESDChain *> (aManager->EventReader());\r
  AliFemtoEventReaderESDChainKine *tReaderESDChainKine = dynamic_cast<AliFemtoEventReaderESDChainKine *> (aManager->EventReader());\r
  AliFemtoEventReaderAODChain     *tReaderAODChain     = dynamic_cast<AliFemtoEventReaderAODChain *> (aManager->EventReader());\r
  AliFemtoEventReaderStandard     *tReaderStandard     = dynamic_cast<AliFemtoEventReaderStandard *> (aManager->EventReader());\r
\r
  if ((!tReaderESDChain) && (!tReaderESDChainKine) && (!tReaderAODChain) && (!tReaderStandard)) {\r
    AliWarning("No AliFemto event reader created. Will not run femto analysis.\n");\r
    return;\r
  }\r
  if (tReaderESDChain) SetFemtoReaderESD(tReaderESDChain);\r
  if (tReaderESDChainKine) SetFemtoReaderESDKine(tReaderESDChainKine);\r
  if (tReaderAODChain) SetFemtoReaderAOD(tReaderAODChain);\r
  if (tReaderStandard) SetFemtoReaderStandard(tReaderStandard);\r
}\r
\r
Commit	Line	Data
83f5f758	1	//------------------------------------------------------\r
	2	// AliAnalysisTaskFemto - A task for the analysis framework\r
	3	// from the FEMTOSCOPY analysis of PWG2. Creates the necessary\r
	4	// connection between the ESD or AOD input and the femtoscopic\r
	5	// code.\r
	6	// Author: Adam Kisiel, OSU; Adam.Kisiel@cern.ch\r
	7	//------------------------------------------------------\r
77f44ccf	8	#include "TROOT.h"\r
	9	#include "TChain.h"\r
	10	#include "TH1.h"\r
	11	#include "TCanvas.h"\r
	12	#include "TSystem.h"\r
	13	#include "TFile.h"\r
06b454c7	14	#include "TInterpreter.h"\r
77f44ccf	15	\r
	16	#include "AliAnalysisTask.h"\r
	17	\r
	18	#include "AliESDEvent.h"\r
	19	\r
83f5f758	20	#include "AliFemtoAnalysis.h"\r
77f44ccf	21	#include "AliAnalysisTaskFemto.h"\r
78add4e9	22	#include "AliVHeader.h"\r
	23	#include "AliGenEventHeader.h"\r
	24	#include "AliGenHijingEventHeader.h"\r
	25	#include "AliGenCocktailEventHeader.h"\r
77f44ccf	26	\r
	27	ClassImp(AliAnalysisTaskFemto)\r
	28	\r
78add4e9	29	// Default name for the setup macro of femto analysis \r
78add4e9	30	// This function MUST be defined in the separate file !!!\r
06b454c7	31	// extern AliFemtoManager *ConfigFemtoAnalysis();\r
78add4e9	32	\r
77f44ccf	33	//________________________________________________________________________\r
62e790f1	34	AliAnalysisTaskFemto::AliAnalysisTaskFemto(const char name, const char aConfigMacro, const char *aConfigParams):\r
83f5f758	35	AliAnalysisTask(name,""), \r
	36	fESD(0), \r
	37	fAOD(0),\r
5e301b78	38	fStack(0),\r
83f5f758	39	fOutputList(0), \r
78add4e9	40	fReader(0x0),\r
83f5f758	41	fManager(0x0),\r
817751c7	42	fAnalysisType(0),\r
62e790f1	43	fConfigMacro(0),\r
62e790f1	44	fConfigParams(0)\r
83f5f758	45	{\r
77f44ccf	46	// Constructor.\r
	47	// Input slot #0 works with an Ntuple\r
	48	DefineInput(0, TChain::Class());\r
77f44ccf	49	// Output slot #0 writes into a TH1 container\r
83f5f758	50	DefineOutput(0, TList::Class());\r
817751c7	51	fConfigMacro = (char ) malloc(sizeof(char) strlen(aConfigMacro));\r
817751c7	52	strcpy(fConfigMacro, aConfigMacro);\r
62e790f1	53	fConfigParams = (char ) malloc(sizeof(char) strlen(aConfigParams));\r
	54	strcpy(fConfigParams, aConfigParams);\r
	55	}\r
	56	//________________________________________________________________________\r
	57	AliAnalysisTaskFemto::AliAnalysisTaskFemto(const char name, const char aConfigMacro="ConfigFemtoAnalysis.C"): \r
	58	AliAnalysisTask(name,""), \r
	59	fESD(0), \r
	60	fAOD(0),\r
	61	fStack(0),\r
	62	fOutputList(0), \r
	63	fReader(0x0),\r
	64	fManager(0x0),\r
	65	fAnalysisType(0),\r
	66	fConfigMacro(0),\r
	67	fConfigParams(0)\r
	68	{\r
	69	// Constructor.\r
	70	// Input slot #0 works with an Ntuple\r
	71	DefineInput(0, TChain::Class());\r
	72	// Output slot #0 writes into a TH1 container\r
	73	DefineOutput(0, TList::Class());\r
	74	fConfigMacro = (char ) malloc(sizeof(char) strlen(aConfigMacro));\r
	75	strcpy(fConfigMacro, aConfigMacro);\r
	76	fConfigParams = (char ) malloc(sizeof(char) 2);\r
	77	strcpy(fConfigParams, "");\r
77f44ccf	78	}\r
77f44ccf	79	\r
04328c66	80	AliAnalysisTaskFemto::AliAnalysisTaskFemto(const AliAnalysisTaskFemto& aFemtoTask):\r
	81	AliAnalysisTask(aFemtoTask), \r
	82	fESD(0), \r
	83	fAOD(0),\r
	84	fStack(0),\r
	85	fOutputList(0), \r
	86	fReader(0x0),\r
	87	fManager(0x0),\r
817751c7	88	fAnalysisType(0),\r
62e790f1	89	fConfigMacro(0),\r
62e790f1	90	fConfigParams(0)\r
04328c66	91	{\r
5e301b78	92	// copy constructor\r
	93	fESD = aFemtoTask.fESD; \r
	94	fAOD = aFemtoTask.fAOD; \r
	95	fStack = aFemtoTask.fStack;\r
	96	fOutputList = aFemtoTask.fOutputList; \r
	97	fReader = aFemtoTask.fReader; \r
	98	fManager = aFemtoTask.fManager; \r
	99	fAnalysisType = aFemtoTask.fAnalysisType; \r
817751c7	100	fConfigMacro = (char ) malloc(sizeof(char) strlen(aFemtoTask.fConfigMacro));\r
817751c7	101	strcpy(fConfigMacro, aFemtoTask.fConfigMacro);\r
62e790f1	102	fConfigParams = (char ) malloc(sizeof(char) strlen(aFemtoTask.fConfigParams));\r
62e790f1	103	strcpy(fConfigParams, aFemtoTask.fConfigParams);\r
5e301b78	104	}\r
	105	\r
	106	\r
	107	AliAnalysisTaskFemto& AliAnalysisTaskFemto::operator=(const AliAnalysisTaskFemto& aFemtoTask){\r
	108	// assignment operator\r
	109	if (this == &aFemtoTask)\r
	110	return *this;\r
	111	\r
	112	fESD = aFemtoTask.fESD; \r
	113	fAOD = aFemtoTask.fAOD; \r
	114	fStack = aFemtoTask.fStack;\r
	115	fOutputList = aFemtoTask.fOutputList; \r
	116	fReader = aFemtoTask.fReader; \r
	117	fManager = aFemtoTask.fManager; \r
	118	fAnalysisType = aFemtoTask.fAnalysisType; \r
817751c7	119	if (fConfigMacro) free(fConfigMacro);\r
	120	fConfigMacro = (char ) malloc(sizeof(char) strlen(aFemtoTask.fConfigMacro));\r
	121	strcpy(fConfigMacro, aFemtoTask.fConfigMacro);\r
62e790f1	122	if (fConfigParams) free(fConfigParams);\r
	123	fConfigParams = (char ) malloc(sizeof(char) strlen(aFemtoTask.fConfigParams));\r
	124	strcpy(fConfigParams, aFemtoTask.fConfigParams);\r
5e301b78	125	\r
	126	return *this;\r
	127	}\r
	128	\r
817751c7	129	AliAnalysisTaskFemto::~AliAnalysisTaskFemto() \r
	130	{\r
	131	if (fConfigMacro) free(fConfigMacro);\r
62e790f1	132	if (fConfigParams) free(fConfigParams);\r
817751c7	133	}\r
	134	\r
	135	\r
77f44ccf	136	//________________________________________________________________________\r
77f44ccf	137	void AliAnalysisTaskFemto::ConnectInputData(Option_t *) {\r
21d75c5c	138	AliInfo(Form(" ConnectInputData %s\n", GetName()));\r
77f44ccf	139	\r
83f5f758	140	fESD = 0;\r
	141	fAOD = 0;\r
	142	fAnalysisType = 0;\r
77f44ccf	143	\r
83f5f758	144	TTree* tree = dynamic_cast<TTree*> (GetInputData(0));\r
83f5f758	145	if (!tree) {\r
21d75c5c	146	AliWarning("Could not read chain from input slot 0");\r
21d75c5c	147	return;\r
83f5f758	148	} \r
21d75c5c	149	\r
	150	if ((dynamic_cast<AliFemtoEventReaderESDChain *> (fReader)) \|\|\r
	151	(dynamic_cast<AliFemtoEventReaderESDChainKine *> (fReader))) {\r
83f5f758	152	AliESDInputHandler esdH = dynamic_cast<AliESDInputHandler> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
	153	\r
	154	if(esdH) {\r
21d75c5c	155	AliInfo("Selected ESD analysis");\r
83f5f758	156	fAnalysisType = 1;\r
83f5f758	157	\r
21d75c5c	158	// if (!esdH) {\r
	159	// AliWarning("Could not get ESDInputHandler");\r
	160	// } \r
	161	// else {\r
83f5f758	162	fESD = esdH->GetEvent();\r
21d75c5c	163	// }\r
83f5f758	164	}\r
21d75c5c	165	}\r
	166	\r
	167	if (dynamic_cast<AliFemtoEventReaderAODChain *> (fReader)) {\r
	168	AliAODInputHandler aodH = dynamic_cast<AliAODInputHandler> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
	169	\r
	170	if (!aodH) {\r
	171	TObject *handler = AliAnalysisManager::GetAnalysisManager()->GetOutputEventHandler();\r
	172	AliInfo("Has output handler ");\r
	173	if( handler && handler->InheritsFrom("AliAODHandler") ) {\r
	174	AliInfo("Selected AOD analysis");\r
77f44ccf	175	\r
21d75c5c	176	fAOD = ((AliAODHandler*)handler)->GetAOD();\r
21d75c5c	177	fAnalysisType = 2;\r
83f5f758	178	}\r
21d75c5c	179	else {\r
	180	AliWarning("Selected AOD reader but no AOD handler found");\r
	181	}\r
	182	} \r
	183	else {\r
	184	AliInfo("Selected AOD analysis");\r
	185	fAnalysisType = 2;\r
	186	\r
	187	fAOD = aodH->GetEvent();\r
83f5f758	188	}\r
83f5f758	189	}\r
21d75c5c	190	\r
	191	if ((!fAOD) && (!fESD)) {\r
	192	AliWarning("Wrong analysis type: Only ESD and AOD types are allowed!");\r
	193	}\r
77f44ccf	194	}\r
	195	\r
	196	//________________________________________________________________________\r
	197	void AliAnalysisTaskFemto::CreateOutputObjects() {\r
21d75c5c	198	AliInfo("Creating Femto Analysis objects\n");\r
78add4e9	199	\r
e7155bf6	200	gSystem->SetIncludePath("-I$ROOTSYS/include -I./STEERBase/ -I./ESD/ -I./AOD/ -I./ANALYSIS/ -I./ANALYSISalice/ -I./PWG2AOD/AOD -I./PWG2femtoscopy/FEMTOSCOPY/AliFemto -I./PWG2femtoscopyUser/FEMTOSCOPY/AliFemtoUser");\r
bf6aad35	201	// char fcm[2000];\r
69c1c8ff	202	// sprintf(fcm, "%s++", fConfigMacro);\r
69c1c8ff	203	// gROOT->LoadMacro(fcm);\r
817751c7	204	gROOT->LoadMacro(fConfigMacro);\r
06b454c7	205	// fJetFinder = (AliJetFinder*) gInterpreter->ProcessLine("ConfigJetAnalysis()");\r
8690dc7f	206	if (!fConfigParams)\r
62e790f1	207	SetFemtoManager((AliFemtoManager *) gInterpreter->ProcessLine("ConfigFemtoAnalysis()"));\r
	208	else\r
	209	SetFemtoManager((AliFemtoManager *) gInterpreter->ProcessLine(Form("ConfigFemtoAnalysis(%s)", fConfigParams)));\r
2f496816	210	\r
	211	TList *tOL;\r
	212	fOutputList = fManager->Analysis(0)->GetOutputList();\r
	213	\r
	214	for (unsigned int ian = 1; ian<fManager->AnalysisCollection()->size(); ian++) {\r
	215	tOL = fManager->Analysis(ian)->GetOutputList();\r
	216	\r
	217	TIter nextListCf(tOL);\r
	218	while (TObject *obj = nextListCf()) {\r
	219	fOutputList->Add(obj);\r
	220	}\r
	221	\r
	222	delete tOL;\r
	223	}\r
327e3aa7	224	\r
327e3aa7	225	PostData(0, fOutputList);\r
77f44ccf	226	}\r
	227	\r
	228	//________________________________________________________________________\r
	229	void AliAnalysisTaskFemto::Exec(Option_t *) {\r
83f5f758	230	// Task making a femtoscopic analysis.\r
78add4e9	231	\r
83f5f758	232	if (fAnalysisType==1) {\r
83f5f758	233	if (!fESD) {\r
21d75c5c	234	AliWarning("fESD not available");\r
83f5f758	235	return;\r
	236	}\r
	237	\r
78add4e9	238	//Get MC data\r
	239	AliMCEventHandler* mctruth = (AliMCEventHandler*) \r
	240	((AliAnalysisManager::GetAnalysisManager())->GetMCtruthEventHandler());\r
	241	\r
5e301b78	242	AliGenHijingEventHeader *hdh = 0;\r
78add4e9	243	if(mctruth) {\r
	244	fStack = mctruth->MCEvent()->Stack();\r
	245	\r
	246	AliGenCocktailEventHeader hd = dynamic_cast<AliGenCocktailEventHeader > (mctruth->MCEvent()->GenEventHeader());\r
	247	\r
	248	if (hd) {\r
	249	\r
21d75c5c	250	// AliInfo ("Got MC cocktail event header %p\n", (void *) hd);\r
78add4e9	251	TList *lhd = hd->GetHeaders();\r
21d75c5c	252	// AliInfo ("Got list of headers %d\n", lhd->GetEntries());\r
78add4e9	253	\r
	254	for (int iterh=0; iterh<lhd->GetEntries(); iterh++) \r
	255	{\r
	256	hdh = dynamic_cast<AliGenHijingEventHeader *> (lhd->At(iterh));\r
21d75c5c	257	// AliInfo ("HIJING header at %i is %p\n", iterh, (void *) hdh);\r
78add4e9	258	}\r
	259	} \r
	260	}\r
	261	\r
dcbc2957	262	// Get ESD\r
	263	AliESDInputHandler esdH = dynamic_cast<AliESDInputHandler> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
	264	\r
	265	if (!esdH) {\r
21d75c5c	266	AliWarning("Could not get ESDInputHandler");\r
dcbc2957	267	return;\r
	268	} \r
	269	else {\r
	270	fESD = esdH->GetEvent();\r
	271	}\r
	272	\r
21d75c5c	273	AliInfo(Form("Tracks in ESD: %d \n",fESD->GetNumberOfTracks()));\r
78add4e9	274	\r
83f5f758	275	if (fESD->GetNumberOfTracks() >= 0) {\r
77f44ccf	276	\r
78add4e9	277	if (!fReader) {\r
21d75c5c	278	AliWarning("No ESD reader for ESD analysis !\n");\r
83f5f758	279	}\r
78add4e9	280	\r
	281	AliFemtoEventReaderESDChain* fesdc = dynamic_cast<AliFemtoEventReaderESDChain *> (fReader);\r
	282	if (fesdc)\r
	283	{\r
	284	// Process the event with no Kine information\r
	285	fesdc->SetESDSource(fESD);\r
	286	fManager->ProcessEvent();\r
	287	}\r
	288	AliFemtoEventReaderESDChainKine* fesdck = dynamic_cast<AliFemtoEventReaderESDChainKine *> (fReader);\r
	289	if (fesdck) \r
	290	{\r
	291	// Process the event with Kine information\r
	292	fesdck->SetESDSource(fESD);\r
	293	fesdck->SetStackSource(fStack);\r
	294	\r
	295	fesdck->SetGenEventHeader(hdh);\r
	296	fManager->ProcessEvent();\r
	297	}\r
03decc29	298	AliFemtoEventReaderStandard* fstd = dynamic_cast<AliFemtoEventReaderStandard *> (fReader);\r
	299	if (fstd) \r
	300	{\r
	301	// Process the event with Kine information\r
	302	fstd->SetESDSource(fESD);\r
	303	if (mctruth) {\r
	304	fstd->SetStackSource(fStack);\r
	305	fstd->SetGenEventHeader(hdh);\r
	306	fstd->SetInputType(AliFemtoEventReaderStandard::kESDKine);\r
	307	}\r
	308	else\r
	309	fstd->SetInputType(AliFemtoEventReaderStandard::kESD);\r
	310	fManager->ProcessEvent();\r
	311	}\r
83f5f758	312	} \r
2f496816	313	\r
78add4e9	314	// Post the output histogram list\r
83f5f758	315	PostData(0, fOutputList);\r
83f5f758	316	}\r
21d75c5c	317	\r
83f5f758	318	if (fAnalysisType==2) { \r
83f5f758	319	if (!fAOD) {\r
21d75c5c	320	AliWarning("fAOD not available");\r
83f5f758	321	return;\r
83f5f758	322	}\r
dcbc2957	323	\r
dcbc2957	324	// Get AOD\r
21d75c5c	325	// AliAODInputHandler aodH = dynamic_cast<AliAODInputHandler> (AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());\r
dcbc2957	326	\r
21d75c5c	327	// if (!aodH) {\r
	328	// AliWarning("Could not get AODInputHandler");\r
	329	// return;\r
	330	// } \r
	331	// else {\r
dcbc2957	332	\r
21d75c5c	333	// fAOD = aodH->GetEvent();\r
21d75c5c	334	// }\r
dcbc2957	335	\r
21d75c5c	336	AliInfo(Form("Tracks in AOD: %d \n",fAOD->GetNumberOfTracks()));\r
83f5f758	337	\r
83f5f758	338	if (fAOD->GetNumberOfTracks() > 0) {\r
78add4e9	339	if (!fReader) {\r
21d75c5c	340	AliWarning("No AOD reader for AOD analysis! \n");\r
83f5f758	341	}\r
83f5f758	342	else {\r
78add4e9	343	AliFemtoEventReaderAODChain* faodc = dynamic_cast<AliFemtoEventReaderAODChain *> (fReader);\r
	344	\r
	345	if (faodc) {\r
	346	// Process the event\r
	347	faodc->SetAODSource(fAOD);\r
	348	fManager->ProcessEvent();\r
	349	}\r
03decc29	350	AliFemtoEventReaderStandard* fstd = dynamic_cast<AliFemtoEventReaderStandard *> (fReader);\r
	351	\r
	352	if (fstd) {\r
	353	// Process the event\r
	354	fstd->SetAODSource(fAOD);\r
	355	fstd->SetInputType(AliFemtoEventReaderStandard::kAOD);\r
	356	fManager->ProcessEvent();\r
	357	}\r
83f5f758	358	}\r
83f5f758	359	} \r
2f496816	360	\r
2f496816	361	// Post the output histogram list\r
83f5f758	362	PostData(0, fOutputList);\r
77f44ccf	363	}\r
	364	} \r
	365	\r
	366	//________________________________________________________________________\r
	367	void AliAnalysisTaskFemto::Terminate(Option_t *) {\r
83f5f758	368	// Do the final processing\r
81401f04	369	if (fManager) {\r
	370	fManager->Finish();\r
	371	}\r
	372	}\r
	373	//________________________________________________________________________\r
	374	void AliAnalysisTaskFemto:: FinishTaskOutput() {\r
	375	// Do the final processing\r
	376	if (fManager) {\r
	377	fManager->Finish();\r
	378	}\r
77f44ccf	379	}\r
77f44ccf	380	//________________________________________________________________________\r
83f5f758	381	void AliAnalysisTaskFemto::SetFemtoReaderESD(AliFemtoEventReaderESDChain *aReader)\r
77f44ccf	382	{\r
21d75c5c	383	AliInfo("Selecting Femto reader for ESD\n");\r
78add4e9	384	fReader = aReader;\r
	385	}\r
	386	//________________________________________________________________________\r
	387	void AliAnalysisTaskFemto::SetFemtoReaderESDKine(AliFemtoEventReaderESDChainKine *aReader)\r
	388	{\r
21d75c5c	389	AliInfo("Selecting Femto reader for ESD with Kinematics information\n");\r
78add4e9	390	fReader = aReader;\r
83f5f758	391	}\r
	392	//________________________________________________________________________\r
	393	void AliAnalysisTaskFemto::SetFemtoReaderAOD(AliFemtoEventReaderAODChain *aReader)\r
	394	{\r
21d75c5c	395	AliInfo("Selecting Femto reader for AOD\n");\r
78add4e9	396	fReader = aReader;\r
77f44ccf	397	}\r
03decc29	398	void AliAnalysisTaskFemto::SetFemtoReaderStandard(AliFemtoEventReaderStandard *aReader)\r
03decc29	399	{\r
21d75c5c	400	AliInfo("Selecting Standard all-purpose Femto reader\n");\r
03decc29	401	fReader = aReader;\r
03decc29	402	}\r
77f44ccf	403	//________________________________________________________________________\r
	404	void AliAnalysisTaskFemto::SetFemtoManager(AliFemtoManager *aManager)\r
	405	{\r
	406	fManager = aManager;\r
21d75c5c	407	AliInfo(Form("Got reader %p\n", (void *) aManager->EventReader()));\r
78add4e9	408	AliFemtoEventReaderESDChain tReaderESDChain = dynamic_cast<AliFemtoEventReaderESDChain > (aManager->EventReader());\r
	409	AliFemtoEventReaderESDChainKine tReaderESDChainKine = dynamic_cast<AliFemtoEventReaderESDChainKine > (aManager->EventReader());\r
	410	AliFemtoEventReaderAODChain tReaderAODChain = dynamic_cast<AliFemtoEventReaderAODChain > (aManager->EventReader());\r
03decc29	411	AliFemtoEventReaderStandard tReaderStandard = dynamic_cast<AliFemtoEventReaderStandard > (aManager->EventReader());\r
78add4e9	412	\r
03decc29	413	if ((!tReaderESDChain) && (!tReaderESDChainKine) && (!tReaderAODChain) && (!tReaderStandard)) {\r
21d75c5c	414	AliWarning("No AliFemto event reader created. Will not run femto analysis.\n");\r
78add4e9	415	return;\r
	416	}\r
	417	if (tReaderESDChain) SetFemtoReaderESD(tReaderESDChain);\r
	418	if (tReaderESDChainKine) SetFemtoReaderESDKine(tReaderESDChainKine);\r
	419	if (tReaderAODChain) SetFemtoReaderAOD(tReaderAODChain);\r
03decc29	420	if (tReaderStandard) SetFemtoReaderStandard(tReaderStandard);\r
77f44ccf	421	}\r
77f44ccf	422	\r