[u/mrichter/AliRoot.git] / PWGUD / multVScentPbPb / MyAnalysisMacroUni.C

Bool_t needRecPoints = kFALSE;

void MyAnalysisMacroUni
(
 TString dataset="/alice/sim/LHC10f8c_130844",
 TString outFName = "trbg.root",
 TString noMergeDir = "",
 Int_t   nEvents   = -1,
 Bool_t  useMC     = kTRUE,          // fill MC info (doRec=kTRUE)
 Float_t etaMin     =-0.5,        // min eta range to fill in histos
 Float_t etaMax     = 0.5,        // max eta range to fill in histos
 Float_t zMin       = -7,         // process events with Z vertex min
 Float_t zMax       =  7,         //                     max positions
 Int_t  ntMin       = 1,
 Int_t  ntMax       = 999999,
 float  injScale    = 1.,     // inject injScale*Ncl(Lr1/Lr2) hits
 Bool_t scaleDTheta = kTRUE,       // scale dTheta by 1/sin^2(theta) in trackleting
 float  nStdDev     = 25.,         // number of st.dev. for tracklet cut to keep
 float  dphi        = 0.06,        // dphi window (sigma of tracklet cut)
 float  dtht        = 0.025,       // dtheta .... (if negative, abs will be used with additional cut on |dthetaX|, apart from w.distance
 float  phishift    = 0.0045,      // bending shift
 Bool_t remOvl      = kTRUE,       
 float  ovlPhiCut   = 0.005, 
 float  ovlZetaCut  = 0.05,
 Float_t scaleMCV0  = 0.8,     // rescale MC V0 to match data
 Bool_t checkReconstructables = kFALSE//kTRUE, // fill histos for reconstructable (needs useMC and doRec) 
 )
{
  //  
  //
  needRecPoints = kTRUE; //doRec || doInj || doRot || doMix;
    //
  printf("Start Analysis for %s, max %d Events, Event Cuts: %.1f<eta<%.1f, %.2f<Zv<%.2f\n",
	 dataset.Data(),nEvents,etaMin,etaMax,zMin,zMax);
  printf("Tracklet cuts: dPhi:%.3f dTheta:%.3f phiShift:%.4f | Keep %.1f NstDev\n"
	 "Scale dTheta: %s\n", 
	 dphi,dtht,phishift,nStdDev,scaleDTheta ? "ON":"OFF");
  //
  printf("UseMC: %s. V0 scale: %.4f\n",useMC ? "ON":"OFF",scaleMCV0);
  //
  if (nEvents<0) nEvents = int(1e9);
  TString format = GetFormatFromDataSet(dataset);
  //
  // ALICE stuff
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) mgr = new AliAnalysisManager("Test train");
  //
  InputHandlerSetup(format,useMC);
  // compile our task
  gProof->Load("AliITSMultRecBg.cxx++");
  gProof->Load("AliTrackletTaskUni.cxx++");
  //
  // load and run AddTask macro
  gROOT->LoadMacro("AddMultTaskTrackletUni.C");
  //
  // create our task
  AliTrackletTaskUni *mltTask = AddMultTaskTrackletUni(outFName.Data(),noMergeDir);
  
  //
  mltTask->SetDoNormalReco(kTRUE);
  mltTask->SetDoInjection(kTRUE);
  mltTask->SetDoRotation(kFALSE);
  mltTask->SetDoMixing(kFALSE);  
  //
  mltTask->SetUseMC(useMC);
  mltTask->SetCheckReconstructables(checkReconstructables);
  //
  mltTask->SetEtaMin(etaMin);
  mltTask->SetEtaMax(etaMax);
  mltTask->SetZVertexMin(zMin);
  mltTask->SetZVertexMax(zMax);
  //
  mltTask->SetMultCutMin(ntMin);
  mltTask->SetMultCutMax(ntMax);
  //
  //  mltTask->SetNStdCut(cutSigNStd);
  mltTask->SetScaleMCV0(scaleMCV0);
  //
  mltTask->SetScaleDThetaBySin2T(scaleDTheta);
  mltTask->SetNStdDev(nStdDev);
  mltTask->SetPhiWindow(dphi);
  mltTask->SetThetaWindow(dtht);
  mltTask->SetPhiShift(phishift);
  mltTask->SetPhiOverlapCut(ovlPhiCut);
  mltTask->SetZetaOverlapCut(ovlZetaCut);
  mltTask->SetInjScale(injScale);
  mltTask->SetRemoveOverlaps(remOvl);
  //
  printf("new Task: %p\n",mltTask);
  //
  printf("Requesting physics selection in %s mode\n",useMC ? "MC":"Data");
  gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
  //  /*
  //gROOT->ProcessLine(".L AddTaskPhysicsSelection.C");
  AliPhysicsSelectionTask* physicsSelectionTask = AddTaskPhysicsSelection(useMC,0);
  mltTask->SelectCollisionCandidates();//AliVEvent::kMB);
  //
  //  */
  // Run analysis
  mgr->InitAnalysis();
  // process dataset  
  mgr->StartAnalysis("proof", dataset.Data(), nEvents, 0); 
  //
  TString evstCmd = "if [ -e event_stat.root ]; then \nmv event_stat.root evstat_"; 
  evstCmd += outFName;  evstCmd += " \nfi";
  gSystem->Exec( evstCmd.Data() );
  
}


TString GetFormatFromDataSet(TString dataset) {
  
//   Info("runAAF.C","Detecting format from dataset (may take while, depends on network connection)...");
  TString dsTreeName;
  if (dataset.Contains("#")) {
    Info("runAAF.C",Form("Detecting format from dataset name '%s' ...",dataset.Data()));
    dsTreeName=dataset(dataset.Last('#'),dataset.Length());
  } else {
    Info("runAAF.C",Form("Detecting format from dataset '%s' (may take while, depends on network connection) ...",dataset.Data()));
    TFileCollection *ds = gProof->GetDataSet(dataset.Data());
    if (!ds) {
      Error(Form("Dataset %s doesn't exist on proof cluster!!!!",dataset.Data()));
      return "";
    }
    dsTreeName = ds->GetDefaultTreeName();
  }

  if (dsTreeName.Contains("esdTree")) {
    Info("runAAF.C","ESD input format detected ...");
    return "ESD";
  } else if (dsTreeName.Contains("aodTree"))  {
    Info("runAAF.C","AOD input format detected ...");
    return "AOD";
  } else {
    Error("runAAF.C",Form("Tree %s is not supported !!!",dsTreeName.Data()));
    Error("runAAF.C",Form("Maybe set your DS to %s#esdTree or %s#aodTree",dataset.Data(),dataset.Data()));
  }
  
  return "";
}

Bool_t InputHandlerSetup(TString format = "esd", Bool_t useKine = kTRUE)
{
  format.ToLower();

  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();

  AliAnalysisDataContainer *cin = mgr->GetCommonInputContainer();

  if (cin) return;

  if (!format.CompareTo("esd"))
  {
    AliESDInputHandler *esdInputHandler = dynamic_cast<AliESDInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());

    if (!esdInputHandler)
    {
      Info("CustomAnalysisTaskInputSetup", "Creating esdInputHandler ...");
      if (needRecPoints)
	esdInputHandler = new AliESDInputHandlerRP();
      else 
	esdInputHandler = new AliESDInputHandler();
      //
      mgr->SetInputEventHandler(esdInputHandler);
    }
    //
    if (useKine)
    {
      AliMCEventHandler* mcInputHandler = dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());

      if (!mcInputHandler)
      {
        Info("CustomAnalysisTaskInputSetup", "Creating mcInputHandler ...");
        AliMCEventHandler* mcInputHandler = new AliMCEventHandler();
        mgr->SetMCtruthEventHandler(mcInputHandler);
      }
    }

  }
  else if (!format.CompareTo("aod"))
  {
    AliAODInputHandler *aodInputHandler = dynamic_cast<AliAODInputHandler*>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());

    if (!aodInputHandler)
    {
      Info("CustomAnalysisTaskInputSetup", "Creating aodInputHandler ...");
      aodInputHandler = new AliAODInputHandler();
      mgr->SetInputEventHandler(aodInputHandler);
    }
  }
  else
  {
    Info("Wrong input format!!! Only ESD and AOD are supported. Skipping Task ...");
    return kFALSE;
  }

  return kTRUE;
}

void MixHandlerSetup(float ntMin,float ntMax,float ntMixBinSz,
		     float zMin, float zMax, float zMixBinSz)
{
  AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
  if (!mgr) return;
  int bufferSize = 1;
  AliESDInputHandlerRP *esdH = dynamic_cast<AliESDInputHandlerRP*>(mgr->GetInputEventHandler());
  if (!esdH) return;
  //
  AliMixEventInputHandler *esdMixH = new AliMixEventInputHandler(bufferSize);
  esdMixH->SetInputHandlerForMixing(esdH);
  AliMixEventPool *evPool = new AliMixEventPool("MyPool");
  AliMixEventCutObj *tracklets = new AliMixEventCutObj(AliMixEventCutObj::kNumberTracklets, ntMin,ntMax,ntMixBinSz);
  AliMixEventCutObj *zvertex = new AliMixEventCutObj(AliMixEventCutObj::kZVertex, zMin,zMax, zMixBinSz);
  //  evPool->AddCut(tracklets);
  evPool->AddCut(zvertex);
  //evPool->Init();
  evPool->Print();
  esdMixH->SetEventPool(evPool);
  esdH->SetMixingHandler(esdMixH);
}

void AddPhysicsSelection(Bool_t isMC)
{
  // physics selection a la Michele
  if(!isMC) {
    //AliPhysicsSelection * physSel = physicsSelectionTask->GetPhysicsSelection();
    //    physSel->AddCollisionTriggerClass("+CMBAC-B-NOPF-ALL");
    /*
    physSel->AddCollisionTriggerClass("+CMBS1C-B-NOPF-ALL");
    physSel->AddCollisionTriggerClass("+CMBS1A-B-NOPF-ALL");
    */
    //
    //    physSel->AddCollisionTriggerClass("+CMBS2C-B-NOPF-ALL");
    //    physSel->AddCollisionTriggerClass("+CMBS2A-B-NOPF-ALL");
    //
    // This are needed only to fill the statistics tables
    //    physSel->AddBGTriggerClass("+CMBAC-C-NOPF-ALL");
    //    physSel->AddBGTriggerClass("+CMBAC-A-NOPF-ALL");
    //    physSel->AddBGTriggerClass("+CMBAC-E-NOPF-ALL");
    //
    /*
    physSel->AddBGTriggerClass("+CMBS1C-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1C-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1C-E-NOPF-ALL");
    //
    physSel->AddBGTriggerClass("+CMBS1A-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1A-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS1A-E-NOPF-ALL");
    //
    */
    /*
    //
    physSel->AddBGTriggerClass("+CMBS2C-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS2C-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS2C-E-NOPF-ALL");
    //
    physSel->AddBGTriggerClass("+CMBS2A-C-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS2A-A-NOPF-ALL");
    physSel->AddBGTriggerClass("+CMBS2A-E-NOPF-ALL");
    */
  } 
  // if you use the following line, your task only gets the selected events
  //  task->SelectCollisionCandidates(AliVEvent::kUserDefined);
  //  task->SelectCollisionCandidates();
  //
  //Alternatively, in the UserExec of your task:
  //Bool_t isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kUserDefined);
  //
}
Commit	Line	Data
3c78f321	1	Bool_t needRecPoints = kFALSE;
	2
	3	void MyAnalysisMacroUni
	4	(
	5	TString dataset="/alice/sim/LHC10f8c_130844",
	6	TString outFName = "trbg.root",
	7	TString noMergeDir = "",
	8	Int_t nEvents = -1,
	9	Bool_t useMC = kTRUE, // fill MC info (doRec=kTRUE)
	10	Float_t etaMin =-0.5, // min eta range to fill in histos
	11	Float_t etaMax = 0.5, // max eta range to fill in histos
	12	Float_t zMin = -7, // process events with Z vertex min
	13	Float_t zMax = 7, // max positions
	14	Int_t ntMin = 1,
	15	Int_t ntMax = 999999,
	16	float injScale = 1., // inject injScale*Ncl(Lr1/Lr2) hits
	17	Bool_t scaleDTheta = kTRUE, // scale dTheta by 1/sin^2(theta) in trackleting
	18	float nStdDev = 25., // number of st.dev. for tracklet cut to keep
	19	float dphi = 0.06, // dphi window (sigma of tracklet cut)
	20	float dtht = 0.025, // dtheta .... (if negative, abs will be used with additional cut on \|dthetaX\|, apart from w.distance
	21	float phishift = 0.0045, // bending shift
	22	Bool_t remOvl = kTRUE,
	23	float ovlPhiCut = 0.005,
	24	float ovlZetaCut = 0.05,
	25	Float_t scaleMCV0 = 0.8, // rescale MC V0 to match data
	26	Bool_t checkReconstructables = kFALSE//kTRUE, // fill histos for reconstructable (needs useMC and doRec)
	27	)
	28	{
	29	//
	30	//
	31	needRecPoints = kTRUE; //doRec \|\| doInj \|\| doRot \|\| doMix;
	32	//
	33	printf("Start Analysis for %s, max %d Events, Event Cuts: %.1f<eta<%.1f, %.2f<Zv<%.2f\n",
	34	dataset.Data(),nEvents,etaMin,etaMax,zMin,zMax);
	35	printf("Tracklet cuts: dPhi:%.3f dTheta:%.3f phiShift:%.4f \| Keep %.1f NstDev\n"
	36	"Scale dTheta: %s\n",
	37	dphi,dtht,phishift,nStdDev,scaleDTheta ? "ON":"OFF");
	38	//
	39	printf("UseMC: %s. V0 scale: %.4f\n",useMC ? "ON":"OFF",scaleMCV0);
	40	//
	41	if (nEvents<0) nEvents = int(1e9);
	42	TString format = GetFormatFromDataSet(dataset);
	43	//
	44	// ALICE stuff
	45	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
	46	if (!mgr) mgr = new AliAnalysisManager("Test train");
	47	//
	48	InputHandlerSetup(format,useMC);
	49	// compile our task
	50	gProof->Load("AliITSMultRecBg.cxx++");
	51	gProof->Load("AliTrackletTaskUni.cxx++");
	52	//
	53	// load and run AddTask macro
	54	gROOT->LoadMacro("AddMultTaskTrackletUni.C");
	55	//
	56	// create our task
	57	AliTrackletTaskUni *mltTask = AddMultTaskTrackletUni(outFName.Data(),noMergeDir);
	58
	59	//
	60	mltTask->SetDoNormalReco(kTRUE);
	61	mltTask->SetDoInjection(kTRUE);
	62	mltTask->SetDoRotation(kFALSE);
	63	mltTask->SetDoMixing(kFALSE);
	64	//
65	mltTask->SetUseMC(useMC);
66	mltTask->SetCheckReconstructables(checkReconstructables);
67	//
68	mltTask->SetEtaMin(etaMin);
69	mltTask->SetEtaMax(etaMax);
70	mltTask->SetZVertexMin(zMin);
71	mltTask->SetZVertexMax(zMax);
72	//
73	mltTask->SetMultCutMin(ntMin);
74	mltTask->SetMultCutMax(ntMax);
75	//
76	// mltTask->SetNStdCut(cutSigNStd);
77	mltTask->SetScaleMCV0(scaleMCV0);
78	//
79	mltTask->SetScaleDThetaBySin2T(scaleDTheta);
80	mltTask->SetNStdDev(nStdDev);
81	mltTask->SetPhiWindow(dphi);
82	mltTask->SetThetaWindow(dtht);
83	mltTask->SetPhiShift(phishift);
84	mltTask->SetPhiOverlapCut(ovlPhiCut);
85	mltTask->SetZetaOverlapCut(ovlZetaCut);
86	mltTask->SetInjScale(injScale);
87	mltTask->SetRemoveOverlaps(remOvl);
88	//
89	printf("new Task: %p\n",mltTask);
90	//
91	printf("Requesting physics selection in %s mode\n",useMC ? "MC":"Data");
92	gROOT->ProcessLine(".L $ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
93	// /*
94	//gROOT->ProcessLine(".L AddTaskPhysicsSelection.C");
95	AliPhysicsSelectionTask* physicsSelectionTask = AddTaskPhysicsSelection(useMC,0);
96	mltTask->SelectCollisionCandidates();//AliVEvent::kMB);
97	//
98	// */
99	// Run analysis
100	mgr->InitAnalysis();
101	// process dataset
102	mgr->StartAnalysis("proof", dataset.Data(), nEvents, 0);
103	//
104	TString evstCmd = "if [ -e event_stat.root ]; then \nmv event_stat.root evstat_";
105	evstCmd += outFName; evstCmd += " \nfi";
106	gSystem->Exec( evstCmd.Data() );
107
108	}
109
110
111	TString GetFormatFromDataSet(TString dataset) {
112
113	// Info("runAAF.C","Detecting format from dataset (may take while, depends on network connection)...");
114	TString dsTreeName;
115	if (dataset.Contains("#")) {
116	Info("runAAF.C",Form("Detecting format from dataset name '%s' ...",dataset.Data()));
117	dsTreeName=dataset(dataset.Last('#'),dataset.Length());
118	} else {
119	Info("runAAF.C",Form("Detecting format from dataset '%s' (may take while, depends on network connection) ...",dataset.Data()));
120	TFileCollection *ds = gProof->GetDataSet(dataset.Data());
121	if (!ds) {
122	Error(Form("Dataset %s doesn't exist on proof cluster!!!!",dataset.Data()));
123	return "";
124	}
125	dsTreeName = ds->GetDefaultTreeName();
126	}
127
128	if (dsTreeName.Contains("esdTree")) {
129	Info("runAAF.C","ESD input format detected ...");
130	return "ESD";
131	} else if (dsTreeName.Contains("aodTree")) {
132	Info("runAAF.C","AOD input format detected ...");
133	return "AOD";
134	} else {
135	Error("runAAF.C",Form("Tree %s is not supported !!!",dsTreeName.Data()));
136	Error("runAAF.C",Form("Maybe set your DS to %s#esdTree or %s#aodTree",dataset.Data(),dataset.Data()));
137	}
138
139	return "";
140	}
141
142	Bool_t InputHandlerSetup(TString format = "esd", Bool_t useKine = kTRUE)
143	{
144	format.ToLower();
145
146	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
147
148	AliAnalysisDataContainer *cin = mgr->GetCommonInputContainer();
149
150	if (cin) return;
151
152	if (!format.CompareTo("esd"))
153	{
154	AliESDInputHandler esdInputHandler = dynamic_cast<AliESDInputHandler>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
155
156	if (!esdInputHandler)
157	{
158	Info("CustomAnalysisTaskInputSetup", "Creating esdInputHandler ...");
159	if (needRecPoints)
160	esdInputHandler = new AliESDInputHandlerRP();
161	else
162	esdInputHandler = new AliESDInputHandler();
163	//
164	mgr->SetInputEventHandler(esdInputHandler);
165	}
166	//
167	if (useKine)
168	{
169	AliMCEventHandler* mcInputHandler = dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
170
171	if (!mcInputHandler)
172	{
173	Info("CustomAnalysisTaskInputSetup", "Creating mcInputHandler ...");
174	AliMCEventHandler* mcInputHandler = new AliMCEventHandler();
175	mgr->SetMCtruthEventHandler(mcInputHandler);
176	}
177	}
178
179	}
180	else if (!format.CompareTo("aod"))
181	{
182	AliAODInputHandler aodInputHandler = dynamic_cast<AliAODInputHandler>(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler());
183
184	if (!aodInputHandler)
185	{
186	Info("CustomAnalysisTaskInputSetup", "Creating aodInputHandler ...");
187	aodInputHandler = new AliAODInputHandler();
188	mgr->SetInputEventHandler(aodInputHandler);
189	}
190	}
191	else
192	{
193	Info("Wrong input format!!! Only ESD and AOD are supported. Skipping Task ...");
194	return kFALSE;
195	}
196
197	return kTRUE;
198	}
199
200	void MixHandlerSetup(float ntMin,float ntMax,float ntMixBinSz,
201	float zMin, float zMax, float zMixBinSz)
202	{
203	AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
204	if (!mgr) return;
205	int bufferSize = 1;
206	AliESDInputHandlerRP esdH = dynamic_cast<AliESDInputHandlerRP>(mgr->GetInputEventHandler());
207	if (!esdH) return;
208	//
209	AliMixEventInputHandler *esdMixH = new AliMixEventInputHandler(bufferSize);
210	esdMixH->SetInputHandlerForMixing(esdH);
211	AliMixEventPool *evPool = new AliMixEventPool("MyPool");
212	AliMixEventCutObj *tracklets = new AliMixEventCutObj(AliMixEventCutObj::kNumberTracklets, ntMin,ntMax,ntMixBinSz);
213	AliMixEventCutObj *zvertex = new AliMixEventCutObj(AliMixEventCutObj::kZVertex, zMin,zMax, zMixBinSz);
214	// evPool->AddCut(tracklets);
215	evPool->AddCut(zvertex);
216	//evPool->Init();
217	evPool->Print();
218	esdMixH->SetEventPool(evPool);
219	esdH->SetMixingHandler(esdMixH);
220	}
221
222	void AddPhysicsSelection(Bool_t isMC)
223	{
224	// physics selection a la Michele
225	if(!isMC) {
226	//AliPhysicsSelection * physSel = physicsSelectionTask->GetPhysicsSelection();
227	// physSel->AddCollisionTriggerClass("+CMBAC-B-NOPF-ALL");
228	/*
229	physSel->AddCollisionTriggerClass("+CMBS1C-B-NOPF-ALL");
230	physSel->AddCollisionTriggerClass("+CMBS1A-B-NOPF-ALL");
231	*/
232	//
233	// physSel->AddCollisionTriggerClass("+CMBS2C-B-NOPF-ALL");
234	// physSel->AddCollisionTriggerClass("+CMBS2A-B-NOPF-ALL");
235	//
236	// This are needed only to fill the statistics tables
237	// physSel->AddBGTriggerClass("+CMBAC-C-NOPF-ALL");
238	// physSel->AddBGTriggerClass("+CMBAC-A-NOPF-ALL");
239	// physSel->AddBGTriggerClass("+CMBAC-E-NOPF-ALL");
240	//
241	/*
242	physSel->AddBGTriggerClass("+CMBS1C-C-NOPF-ALL");
243	physSel->AddBGTriggerClass("+CMBS1C-A-NOPF-ALL");
244	physSel->AddBGTriggerClass("+CMBS1C-E-NOPF-ALL");
245	//
246	physSel->AddBGTriggerClass("+CMBS1A-C-NOPF-ALL");
247	physSel->AddBGTriggerClass("+CMBS1A-A-NOPF-ALL");
248	physSel->AddBGTriggerClass("+CMBS1A-E-NOPF-ALL");
249	//
250	*/
251	/*
252	//
253	physSel->AddBGTriggerClass("+CMBS2C-C-NOPF-ALL");
254	physSel->AddBGTriggerClass("+CMBS2C-A-NOPF-ALL");
255	physSel->AddBGTriggerClass("+CMBS2C-E-NOPF-ALL");
256	//
257	physSel->AddBGTriggerClass("+CMBS2A-C-NOPF-ALL");
258	physSel->AddBGTriggerClass("+CMBS2A-A-NOPF-ALL");
259	physSel->AddBGTriggerClass("+CMBS2A-E-NOPF-ALL");
260	*/
261	}
262	// if you use the following line, your task only gets the selected events
263	// task->SelectCollisionCandidates(AliVEvent::kUserDefined);
264	// task->SelectCollisionCandidates();
265	//
266	//Alternatively, in the UserExec of your task:
267	//Bool_t isSelected = (((AliInputEventHandler*)(AliAnalysisManager::GetAnalysisManager()->GetInputEventHandler()))->IsEventSelected() & AliVEvent::kUserDefined);
268	//
269	}