# Lines that do not start with #Module are ignored, except those in embedded
macro blocks
#Module.Begin QAsym
-#Module.Libs PWG1
+#Module.Libs PWGPP
#Module.Deps PhysicsSelection
#Module.DataTypes ESD, AOD, MC
-#Module.MacroName $ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C
+#Module.MacroName $ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C
#Module.MacroArgs 0, AliVEvent::kAnyINT, AliVEvent::kHighMult, AliVEvent::kEMC7, AliVEvent::kMUU7
#Module.OutputFile
#Module.TerminateFile
// TPC QA (E. Sicking)
//
if (config & kCar00) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0);
taskqasim->SelectCollisionCandidates();
}
// VZERO QA (C. Cheshkov)
//
if (config & kCar01) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskVZEROQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
// Vertexing (A. Dainese)
//
if (config & kCar02) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskVertexESD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD();
taskvertexesd->SelectCollisionCandidates();
}
// SPD (A. Mastroserio)
//
if (config & kCar03) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskSPDQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSE* taskspdqa = AddTaskSPDQA();
taskspdqa->SelectCollisionCandidates();
}
// SDD (F. Prino)
//
if (config & kCar04) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddSDDPoints.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates();
}
// SSD dEdx (Marek Chojnacki)
//
if (config & kCar05) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskdEdxSSDQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates();
}
// FMD (Hans Hjersing Dalsgaard)
//
if (config & kCar06) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskFMD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskFMD.C");
AliAnalysisTaskSE* taskfmd = AddTaskFMD();
taskfmd->SelectCollisionCandidates();
}
// ITS
//
if (config & kCar07) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceITS.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(kFALSE);
}
//
// TPC (Jacek Otwinowski)
//
if (config & kCar08) {
- gROOT->LoadMacro("$(ALICE_ROOT)/PWG1/TPC/macros/AddTaskPerformanceTPCQA.C");
+ gROOT->LoadMacro("$(ALICE_ROOT)/PWGPP/TPC/macros/AddTaskPerformanceTPCQA.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPCQA(kFALSE, kTRUE);
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(config & kCar09) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTrainPerformanceTRD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
AddTrainPerformanceTRD("ALL");
}
//
if(config & kCar11) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
//
if (doV0) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskV0QA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kFALSE);
}
*/
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG2.so");
gSystem->Load("libPWG2forward.so");
gSystem->Load("libEMCALUtils");
# Standard Modules
# ------------------------------
-set(ALIROOTMODULES STEER PHOS TRD TPC ZDC MUON PMD FMD TOF ITS ACORDE HMPID T0 BCM STRUCT VZERO THijing THbtp EMCAL THerwig TEPEMGEN FASTSIM TPHIC RAW MONITOR ANALYSIS JETAN HLT STAT TTherminator CORRFW DPMJET TDPMjet PWG0 PWG1 PWG2 PWG3 PWG4 TRIGGER PYTHIA8 TAmpt OADB MFT)
+set(ALIROOTMODULES STEER PHOS TRD TPC ZDC MUON PMD FMD TOF ITS ACORDE HMPID T0 BCM STRUCT VZERO THijing THbtp EMCAL THerwig TEPEMGEN FASTSIM TPHIC RAW MONITOR ANALYSIS JETAN HLT STAT TTherminator CORRFW DPMJET TDPMjet PWG0 PWGPP PWG2 PWG3 PWG4 TRIGGER PYTHIA8 TAmpt OADB MFT)
if(THydjet)
list(APPEND ALIROOTMODULES THydjet)
THijing THbtp EMCAL
THerwig TEPEMGEN FASTSIM TPHIC RAW MONITOR ANALYSIS
JETAN HLT LHC ESDCheck STAT TTherminator CORRFW DPMJET TDPMjet
- PWG0 PWG1 PWG2 PWG3 PWG4 TRIGGER
+ PWG0 PWGPP PWG2 PWG3 PWG4 TRIGGER
TUHKMgen EPOS PYTHIA8 EVE TFluka
THydjet SHUTTLE PYTHIA6
LHAPDF HIJING MICROCERN HERWIG
#include <EveDet/AliEveTRDTrackList.h>
#include <EveDet/AliEveTRDTrackListEditor.h>
-#include <../PWG1/TRD/AliTRDrecoTask.h>
-#include <../PWG1/TRD/AliTRDpwg1Helper.h>
+#include <../PWGPP/TRD/AliTRDrecoTask.h>
+#include <../PWGPP/TRD/AliTRDpwgppHelper.h>
ClassImp(AliEveTRDTrackList)
// use the return value of AddMacro (NOT_EXIST_ERROR is returned, if file does not exist)
// (-> You can also check for other return values (see AddMacro(...)))
- const Char_t *libs[] = {"libANALYSIS.so", "libANALYSISalice.so", "libCORRFW", "libTENDER.so", "libPWG1.so"};
+ const Char_t *libs[] = {"libANALYSIS.so", "libANALYSISalice.so", "libCORRFW", "libTENDER.so", "libPWGPP.so"};
Int_t nlibs = static_cast<Int_t>(sizeof(libs)/sizeof(Char_t *));
for(Int_t ilib=0; ilib<nlibs; ilib++){
if(gSystem->Load(libs[ilib]) >= 0) continue;
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for either
-// HLT or offline TPC performance QA to run on PWG1 QA train.
+// HLT or offline TPC performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
// gROOT->LoadMacro("$ALICE_ROOT/HLT/QA/tasks/macros/AddTaskPerformanceTPC.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPC("kTRUE","kTRUE", "kTRUE"¸"triggerClass");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libHLTbase.so");
- gSystem->AddIncludePath("-I$ALICE_ROOT/HLT/BASE -I$ALICE_ROOT/PWG1/TPC -I. -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS");
+ gSystem->AddIncludePath("-I$ALICE_ROOT/HLT/BASE -I$ALICE_ROOT/PWGPP/TPC -I. -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS");
gSystem->Load("libTPCcalib.so");
gSystem->Load("libTRDbase.so");
gSystem->Load("libITSbase.so");
gSystem->Load("libITSrec.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gROOT->ProcessLine(".include $ALICE_ROOT/include");
//gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPhysicsSelection.C");
- Bool_t bPHOS = kFALSE, bGLOBAL = kFALSE, bEMCAL = kFALSE, bPWG1 = kFALSE, bD0 = kFALSE, bCB = kFALSE;
+ Bool_t bPHOS = kFALSE, bGLOBAL = kFALSE, bEMCAL = kFALSE, bPWGPP = kFALSE, bD0 = kFALSE, bCB = kFALSE;
TString allArgs = detectorTask;
TString argument;
bGLOBAL = kTRUE;
continue;
}
- if(argument.CompareTo("pwg1", TString::kIgnoreCase)==0){
- bPWG1 = kTRUE;
+ if(argument.CompareTo("pwgpp", TString::kIgnoreCase)==0){
+ bPWGPP = kTRUE;
continue;
}
if(argument.CompareTo("D0", TString::kIgnoreCase)==0){
cout << "\n========= You are loading the following task --> "<< (taskFolder+strTask).Chop() << endl;
}
- if(bPWG1) gROOT->LoadMacro("$ALICE_ROOT/HLT/QA/tasks/macros/AddTaskPerformance.C");
+ if(bPWGPP) gROOT->LoadMacro("$ALICE_ROOT/HLT/QA/tasks/macros/AddTaskPerformance.C");
if(file.BeginsWith("alien://")) TGrid::Connect("alien://");
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
AliESDInputHandler *esdH = new AliESDInputHandler;
- //For the PWG1 task, setting HLT is handled inside AliPerformanceTask.C
- if(!bPWG1) esdH->SetReadHLT();
+ //For the PWGPP task, setting HLT is handled inside AliPerformanceTask.C
+ if(!bPWGPP) esdH->SetReadHLT();
esdH->SetReadFriends(kFALSE);
mgr->SetInputEventHandler(esdH);
mgr->SetNSysInfo(1000);
mgr->ConnectOutput(taskGLOBAL,1,coutputGLOBAL);
}
- if(bPWG1){
+ if(bPWGPP){
Bool_t hasMC=kFALSE;
// -- Add Task for HLT and Offline
AliPerformanceTask *HLTtpcQA = AddTaskPerformance(hasMC,kFALSE,kTRUE);
// $Id$
/*
* Plotting macro for comparing offline- and HLT- ESD trees from
- * HLT-OFFLINE-GLOBAL-comparison.root produced using pwg1-task:
- * compare-HLT-offline-local.C'("./AliESDs.root","pwg1")'
+ * HLT-OFFLINE-GLOBAL-comparison.root produced using pwgpp-task:
+ * compare-HLT-offline-local.C'("./AliESDs.root","pwgpp")'
*
* It allows you to choose from a detailed list of cuts or a combination of cuts.
*
*
*
* Usage:
- * Running requires that you have the .root-files produced from the pwg1-task
+ * Running requires that you have the .root-files produced from the pwgpp-task
* in your local folder.
*
* Run options:
gSystem->Load("libANALYSISalice");
gSystem->Load("libTENDER");
gSystem->Load("libCORRFW");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
gROOT->Reset();
gROOT->SetStyle("Plain");
Float_t fVertexerFastSmearY; // gaussian sigma for y MC vertex smearing
Float_t fVertexerFastSmearZ; // gaussian sigma for z MC vertex smearing
- // PWG1/AliAlignmentDataFilterITS configuration
+ // PWGPP/AliAlignmentDataFilterITS configuration
Bool_t fAlignFilterCosmics; // flag for cosmics case
Bool_t fAlignFilterCosmicMergeTracks; // merge cosmic tracks
Int_t fAlignFilterMinITSPoints; // min points per track
TList *listin=0x0;\r
listin=(TList*)file_data->Get("output");\r
if(!listin)\r
- listin=(TList*)file_data->Get("PWG1dEdxSSDQA/output");\r
+ listin=(TList*)file_data->Get("PWGPPdEdxSSDQA/output");\r
if(!listin) \r
- listin=(TList*)file_data->Get("PWG1dEdxSSDQA/SSDdEdxQA");\r
+ listin=(TList*)file_data->Get("PWGPPdEdxSSDQA/SSDdEdxQA");\r
if(!listin) \r
listin=(TList*)file_data->Get("SSDdEdxQA");\r
if(!listin) \r
TString fTitleMc = "";
-void PlotSPDpwg1QA(TString data, TString mc, TString titleData = "[Data]", TString titleMc = "[MC]", Bool_t isGeneralTrain = kFALSE){
+void PlotSPDpwgppQA(TString data, TString mc, TString titleData = "[Data]", TString titleMc = "[MC]", Bool_t isGeneralTrain = kFALSE){
fTitleData=titleData;
fTitleMc=titleMc;
set ( EINCLUDE ANALYSIS STEER/STEERBase)
# Install data to destination
-install (DIRECTORY COMMON PWG1 PWG2 PWG3 PWG4
+install (DIRECTORY COMMON PWGPP PWG2 PWG3 PWG4
DESTINATION OADB
PATTERN ".svn" EXCLUDE)
//load required libraries
//load required libraries
- gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
gSystem->Load("libCore");
gSystem->Load("libPhysics");
//load required libraries
//load required libraries
- gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
gSystem->Load("libCore");
gSystem->Load("libPhysics");
/*
//load required libraries
//load required libraries
- gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
gSystem->Load("libCore");
gSystem->Load("libPhysics");
//load required libraries
//load required libraries
- gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
gSystem->Load("libCore");
gSystem->Load("libPhysics");
//load required libraries
//load required libraries
- gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
+ gSystem->AddIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/ -I$ALICE_ROOT/include -I$ALICE_ROOT/STEER -I$ALICE_ROOT/ANALYSIS -I$ALICE_ROOT/PWG0 -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWG2 -I$ALICE_ROOT/PWG3 -I$ALICE_ROOT/PWG3/vertexingHF -I$ALICE_ROOT/PWG4 -I$ALICE_ROOT/CORRFW -I$ALICE_ROOT/TPC -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG3/muon -I$ALICE_ROOT/JETAN -I$ALICE_ROOT/ANALYSIS/Tender");
gSystem->Load("libCore");
gSystem->Load("libPhysics");
CheckLoadLibrary("libPWG0base");
CheckLoadLibrary("libPWG0dep");
CheckLoadLibrary("libPWG0selectors");
- //CheckLoadLibrary("libPWG1");
+ //CheckLoadLibrary("libPWGPP");
}
Int_t CheckLoadLibrary(const char* library) {
gSystem->Load("libPWG2spectra");
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPbPb"));
- gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
+ gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
// Load helper classes
// TODO: replace this by a list of TOBJStrings
TString taskName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskTriggerStudy.cxx+");
TString histoManName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbTrackHistoManager.cxx+");
TString centrName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbCentralitySelector.cxx+");
- TString listName("$ALICE_ROOT/PWG1/background/AliHistoListWrapper.cxx+");
+ TString listName("$ALICE_ROOT/PWGPP/background/AliHistoListWrapper.cxx+");
gSystem->ExpandPathName(taskName);
// gSystem->ExpandPathName(histoManName);
gSystem->Load("libPWG0base");
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPbPb"));
- gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
+ gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG2/SPECTRA/Fit"));
// Load helper classes
TString taskName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskMultPbTracks.cxx+");
TString histoManName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbTrackHistoManager.cxx+");
TString centrName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbCentralitySelector.cxx+");
- TString listName("$ALICE_ROOT/PWG1/background/AliHistoListWrapper.cxx+");
+ TString listName("$ALICE_ROOT/PWGPP/background/AliHistoListWrapper.cxx+");
gSystem->ExpandPathName(taskName);
gSystem->ExpandPathName(histoManName);
// Custom stuff to be loaded
listToLoad->Add(new TObjString("$ALICE_ROOT/ANALYSIS/AliCentralitySelectionTask.cxx+"));
- listToLoad->Add(new TObjString("$ALICE_ROOT/PWG1/background/AliHistoListWrapper.cxx+"));
+ listToLoad->Add(new TObjString("$ALICE_ROOT/PWGPP/background/AliHistoListWrapper.cxx+"));
listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbTrackHistoManager.cxx+"));
listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisMultPbCentralitySelector.cxx+"));
listToLoad->Add(new TObjString("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskMultPbTracks.cxx+"));
// gProof->UploadPackage("$ALICE_ROOT/obj/PWG0base");
// gProof->EnablePackage("$ALICE_ROOT/obj/PWG0base");
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
- gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
+ gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
}
else
{
// gSystem->Load("libPWG0base");
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
- gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
- // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background/"));
+ gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
+ // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background/"));
}
// Load helper classes
TIterator * iter = listToLoad->MakeIterator();
// gProof->UploadPackage("$ALICE_ROOT/PWG0base");
// gProof->EnablePackage("$ALICE_ROOT/PWG0base");
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
- gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
+ gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/include "));
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/TOF "));
gSystem->Load("libPWG0base");
gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
- gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
- // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background/"));
+ gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
+ // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background/"));
}
// Load helper classes
// TODO: replace this by a list of TOBJStrings
TString taskName("$ALICE_ROOT/PWG0/multPbPb/AliAnalysisTaskTriggerStudy.cxx+");
- TString listName("$ALICE_ROOT/PWG1/background/AliHistoListWrapper.cxx+");
+ TString listName("$ALICE_ROOT/PWGPP/background/AliHistoListWrapper.cxx+");
gSystem->ExpandPathName(taskName);
gSystem->ExpandPathName(listName);
+++ /dev/null
-#
-# Merging Stage 0
-#
-# Merging in separate process for each detector
-# log files - merge<detector>.log and syswatch<detector>.log stored also
-# per detector
-#
-#
-# arguments of the merge macros:
-#
-# 1 - input list of the files
-# 2 - name of output root file with merged calibration
-# 3 - name filter - what to merge
-# 4 - reject mask
-# 5 - flag single key for Obj array
-#
-#
-# merge T0
-#
-aliroot -b -q $ALICE_ROOT/PWG1/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsT0.root\",\"T0Calib\",\"AliESDfriends\",kTRUE\) >> mergeT0.log
-cp syswatch.log syswatchT0.log
-#
-# merge TOF
-#
-aliroot -b -q $ALICE_ROOT/PWG1/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsTOF.root\",\"TOFHistos\",\"AliESDfriends\",kTRUE\) >> mergeTOF.log
-cp syswatch.log syswatchTOF.log
-#
-# merge TPC
-#
-aliroot -b -q $ALICE_ROOT/PWG1/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsTPC.root\",\"TPCCalib\",\"AliESDfriends\",kFALSE\) >> mergeTPC.log
-cp syswatch.log syswatchTPC.log
-#
-# merge TRD
-#
-aliroot -b -q $ALICE_ROOT/PWG1/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsTRD.root\",\"TRDcalib\",\"AliESDfriends\",kFALSE\) >> mergeTRD.log
-cp syswatch.log syswatchTRD.log
+++ /dev/null
-$ALICE_ROOT/PWG1/macros/AddTaskTrackMatchingTPCITS.C
-$ALICE_ROOT/PWG1/macros/AddTaskAlignmentDataFilterITS.C
-$ALICE_ROOT/PWG1/macros/AddTaskV0QA.C
-$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPC.C
-$ALICE_ROOT/PWG1/macros/AddTaskVertexESD.C
-$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C
-$ALICE_ROOT/PWG1/macros/AddTaskPerformanceITS.C
-$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPCPtCalib.C
-$ALICE_ROOT/PWG1/macros/AddTaskGlobalQA.C
-$ALICE_ROOT/PWG1/macros/AddTaskIntSpotESD.C
-$ALICE_ROOT/PWG1/PilotTrain/AddTaskFMD.C
-$ALICE_ROOT/PWG1/PilotTrain/AddTaskVZEROQA.C
-$ALICE_ROOT/PWG1/PilotTrain/AddTaskPhysicsSelection.C
-$ALICE_ROOT/PWG1/PilotTrain/AddTaskSPDQA.C
-$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C
-$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPCQA.C
-$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPC.C
-$ALICE_ROOT/PWG1/TRD/macros/AddTrainPerformanceTRD.C
-
-
-
-
-
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
-set ( EINCLUDE PWG2/DIFFRACTIVE ITS PWG1/ITS STEER/STEER STEER/CDB STEER/STEERBase)
+set ( EINCLUDE PWG2/DIFFRACTIVE ITS PWGPP/ITS STEER/STEER STEER/CDB STEER/STEERBase)
set ( DHDR PWG2diffractiveLinkDef.h )
gSystem->Load("libANALYSISalice");
gSystem->Load("libTENDER");
// gSystem->Load("libTENDERSupplies");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
gSystem->Load("libPWG3base");
TFile* file = TFile::Open("${inp}", "READ");
if (!file) {
//
// Optionally highMult axis can be used by setting the 3st
// argument to true (for PbPb)
- gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/TPC/macros",
+ gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TPC/macros",
gROOT->GetMacroPath()));
CreateTaskAndSetCollisionCandidates("AddTaskPerformanceTPCdEdxQA.C(kFALSE,kTRUE,kFALSE)");
}
void CreateTRD()
{
// TRD (Alex Bercuci, M. Fasel)
- gSystem->AddIncludePath("-I${ALICE_ROOT}/PWG1/TRD");
+ gSystem->AddIncludePath("-I${ALICE_ROOT}/PWGPP/TRD");
gROOT->Macro("AddTrainPerformanceTRD.C(\"ESD DET EFF RES PID\")");
}
void CreateZDC()
{
// ZDC (Chiara Oppedisano)
- gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/ZDC",
+ gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/ZDC",
gROOT->GetMacroPath()));
CreateTaskAndSetCollisionCandidates("AddTaskZDCQA.C");
}
void CreateTOF()
{
// TOF (Francesca Bellini)
- gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/TOF",
+ gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/TOF",
gROOT->GetMacroPath()));
CreateTaskAndSetCollisionCandidates("AddTaskTOFQA.C");
}
void CreateHMPID()
{
// HMPID QA (Giacomo Volpe)
- gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/HMPID",
+ gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/HMPID",
gROOT->GetMacroPath()));
CreateTaskAndSetCollisionCandidates("AddTaskHmpidQA.C");
}
void CreateT0()
{
// T0 QA (Alla Mayevskaya)
- gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/T0",
+ gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/T0",
gROOT->GetMacroPath()));
CreateTaskAndSetCollisionCandidates("AddTaskT0QA.C");
}
LoadLibrary("PWG0base", mode, par);
LoadLibrary("PWG0dep", mode, par);
LoadLibrary("PWG0selectors", mode, par);
- LoadLibrary("PWG1", mode, par);
+ LoadLibrary("PWGPP", mode, par);
- gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWG1/PilotTrain"
- ":$(ALICE_ROOT)/PWG1/macros",
+ gROOT->SetMacroPath(Form("%s:$(ALICE_ROOT)/PWGPP/PilotTrain"
+ ":$(ALICE_ROOT)/PWGPP/macros",
gROOT->GetMacroPath()));
mgr->AddStatisticsTask(fTriggerMask);
// gProof->UploadPackage("$ALICE_ROOT/obj/PWG0base");
// gProof->EnablePackage("$ALICE_ROOT/obj/PWG0base");
// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
- // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
+ // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
}
else
{
// gSystem->Load("libPWG0base");
// gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG0/multPb"));
- // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background"));
- // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWG1/background/"));
+ // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background"));
+ // gROOT->ProcessLine(gSystem->ExpandPathName(".include $ALICE_ROOT/PWGPP/background/"));
}
// Load helper classes
TIterator * iter = listToLoad->MakeIterator();
// TString includePath = "-I${ALICE_ROOT}/PWG3/base/ "; gSystem->SetIncludePath(includePath.Data());
-// The macro reads the PWG1 QA train output, produces a merged root files for the full period
+// The macro reads the PWGPP QA train output, produces a merged root files for the full period
// for event and track counters as well as separate root files run per run with all MUON_TRK related histograms.
// The results is stored under the directory "results". Then use PlotMUONQA.C, to draw QA histograms.
//
// if ( outTaskFilename.Contains("QAresults.root") ) {
const Int_t kNlibs = 5; // 1
//TString loadLibs[kNlibs] = {"libPWG3base.so"};
- //TString loadLibs[kNlibs] = {"libANALYSIS.so", "libANALYSISalice.so", "libTENDER.so", "libPWG1.so", "libPWG3base.so"};
+ //TString loadLibs[kNlibs] = {"libANALYSIS.so", "libANALYSISalice.so", "libTENDER.so", "libPWGPP.so", "libPWG3base.so"};
TString loadLibs[kNlibs] = {"libANALYSIS.so", "libOADB.so", "libANALYSISalice.so", "libCORRFW.so", "libPWG3base.so"};
for ( Int_t ilib=0; ilib<kNlibs; ilib++ ) {
Int_t exitVal = gSystem->Load(loadLibs[ilib].Data());
gROOT->LoadMacro("$ALICE_ROOT/PWG3/muon/AddTaskMuonQA.C");
AliAnalysisTaskMuonQA* muonQATask = AddTaskMuonQA();
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff* trigChEffTask = AddTaskMTRchamberEfficiency();
#endif
//------------------------------------------------------------------------
-// PWG1 QA train produces QA histograms QAresults.root, where PHOS
+// PWGPP QA train produces QA histograms QAresults.root, where PHOS
// histograms for two events types are stored in
// TObjArray *PHOSCellsQA_AnyInt and TObjArray *PHOSCellsQA_PHI7
// As each a root file for eah run contains, by design, unique histograms
// and per event type.
//
// Usage:
-// 1) Create a list of files QAresults.root produced by the PWG1 QA train,
+// 1) Create a list of files QAresults.root produced by the PWGPP QA train,
// to a text file, let say QAresults.txt
// 2) Compile this macro:
// .L ExtractPHOSCellQA.C++
-PHOS QA class for using in PbPb runs in the PWG1 QA train.
+PHOS QA class for using in PbPb runs in the PWGPP QA train.
The main objective is to provide a user with an input for pi0 mass,
width and number-of-pi0-per-event trend plots in PbPb
AliAnalysisTaskPHOSPbPbQA* AddTaskPHOSPbPbQA(char* fname="PHOSPbPbQA.root",
char* contname=NULL)
{
- //Add PHOS PbPb QA task to the PWG1 QA train.
+ //Add PHOS PbPb QA task to the PWGPP QA train.
//See PHOSPbPb.C how to run it locally or standalone.
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
//------------------------------------------------------------------------
-// PWG1 QA train produces QA histograms QAresults.root, where PHOS
+// PWGPP QA train produces QA histograms QAresults.root, where PHOS
// histograms for two events types are stored in
// TObjArray *PHOSCellsQA_AnyInt,
// TObjArray *PHOSCellsQA_PHI7 and
// and per event type.
//
// Usage:
-// 1) Create a list of files QAresults.root produced by the PWG1 QA train,
+// 1) Create a list of files QAresults.root produced by the PWGPP QA train,
// to a text file, let say QAresults.txt
// 2) Compile this macro:
// .L ExtractPHOSQA.C++
const char* cModule="")
{
//---------------------------------------------------------------------------
- // This macro processes PWG1 QA output of the analysis task PHOSPbPbQA
+ // This macro processes PWGPP QA output of the analysis task PHOSPbPbQA
// (see analysis code in the class AliAnalysisTaskPHOSPbPbQA).
// It fits Real/Mixed ratio, normalize Mixed and subtract it from Real
// Arguments:
TString kJetSubtractMask2 = "B%d";
Int_t iDIJETAN = 1;
Int_t iJETANLib = 1;
-Int_t iPWG1QASym = 0; // Eva's QA task compiled on the fly...
+Int_t iPWGPPQASym = 0; // Eva's QA task compiled on the fly...
Int_t iPWG4FastEmbedding = 0; // Generate non-standard AOD for embedding
Int_t iPWG4JetTasks = 0; // all jet tasks flag for lib laoding
Int_t iPWG4JetServices = 0; // jet spectrum analysis
printf(printMask,"PAR files", (UInt_t)kUsePAR);
printf(printMask,"AliEn plugin", (UInt_t)kPluginUse);
printf(printMask,"JETAN subtract", (UInt_t)iJETSUBTRACT);
- printf(printMask,"PWG1 QA sym", iPWG1QASym);
+ printf(printMask,"PWGPP QA sym", iPWGPPQASym);
printf(printMask,"PWG4 Source Sara",iPWG4TmpSourceSara);
printf(printMask,"PWG4 Fragmentation",iPWG4Fragmentation);
printf(printMask,"PWG4 Jet Chem",iPWG4JetChem);
}
}
- if(iPWG1QASym){
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
+ if(iPWGPPQASym){
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskQASym *taskQASym = AddTaskQAsym(-1);
if (!taskQASym) ::Warning("AnalysisTrainPWG4Jets", "AliAnalysisTaskQASym cannot run for this train conditions - EXCLUDED");
}
if (iPWG4omega3pi)
::Info("AnalysisTrainNew.C::CheckModuleFlags", "PWG4omega3pi disabled on AOD's");
iPWG4omega3pi = 0;
- if(iPWG1QASym)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWG1 QA Sym disabled in analysis on AOD's");
+ if(iPWGPPQASym)::Info("AnalysisTrainPWG4Jets.C::CheckModuleFlags", "PWGPP QA Sym disabled in analysis on AOD's");
if (iPWG4GammaConv)::Info("AnalysisPWG4Jets.C::CheckModuleFlags", "PWG4gammaconv disabled on AOD's");
iPWG4GammaConv = 0;
- iPWG1QASym = 0;
+ iPWGPPQASym = 0;
iCentralitySelection = 0;
} else {
// ESD analysis
if (!LoadLibrary("PWG4JetTasks", mode, kTRUE)) return kFALSE;
}
- if(iPWG1QASym){
- if (!LoadSource(Form("%s/PWG1/AliAnalysisTaskQASym.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
+ if(iPWGPPQASym){
+ if (!LoadSource(Form("%s/PWGPP/AliAnalysisTaskQASym.cxx",gSystem->ExpandPathName("$ALICE_ROOT")), mode, kTRUE))return kFALSE;
}
if(iPWG4TmpSourceSara){
if(!kUsePAR)gSystem->AddIncludePath("-I$ALICE_ROOT/include/JetTasks"); // ugly hack!!
iJETAN = 3;
iDIJETAN = 1; // only run on one JetFinder for the moment
- iPWG1QASym = 0; // excluded since also on QA train
+ iPWGPPQASym = 0; // excluded since also on QA train
iPWG4TmpSourceSara = 0;
iPWG4JetServices = 1;
iPWG4Fragmentation = 0;
kGridRunsPerMaster = 1; // To have the separate configs for eacj run in separate dirs
if(bRun<100){ // private MC
- iPWG1QASym = 0;
+ iPWGPPQASym = 0;
iPWG4TmpSourceSara = 0;
iPWG4JetChem = 0;
iPWG4UE = 0;
iPWG4JCORRAN = 0; // TMP OFF: Writes a Tree
iPWG4CaloConv = 0; // 25.08. off: Output size 03.09 crashes
iPWG4omega3pi = 0; // OFF no feedback
- iPWG1QASym = 0; // excluded since also on QA train
+ iPWGPPQASym = 0; // excluded since also on QA train
kDeltaAODJetName = ""; // for OTF we do not need to write a delta/saves some extension gymnastics in the tasks
if(ckbConfig){
// switch off all but my analyses
iPWG4KMeans = 0;
- iPWG1QASym = 0;
+ iPWGPPQASym = 0;
iPWG4TmpSourceSara = 0;
iPWG4UE = 0;
iPWG4PtQAMC = 0;
# -*- mode: CMake -*-
#--------------------------------------------------------------------------------#
-# Package File for PWG1 #
+# Package File for PWGPP #
# Author : Johny Jose (johny.jose@cern.ch) #
# Variables Defined : #
# #
string ( REPLACE ".cxx" ".h" HDRS "${SRCS}" )
-set ( DHDR PWG1LinkDef.h)
+set ( DHDR PWGPPLinkDef.h)
set ( EINCLUDE
TPC
TRD/Cal
ANALYSIS/Tender
ANALYSIS
- PWG1/comparison
- PWG1/cosmic
- PWG1/global
- PWG1/tender
- PWG1/ITS
- PWG1/TPC
- PWG1/TOF
- PWG1/TRD
- PWG1/TRD/info
- PWG1/background
- PWG1/Centrality
+ PWGPP/comparison
+ PWGPP/cosmic
+ PWGPP/global
+ PWGPP/tender
+ PWGPP/ITS
+ PWGPP/TPC
+ PWGPP/TOF
+ PWGPP/TRD
+ PWGPP/TRD/info
+ PWGPP/background
+ PWGPP/Centrality
HMPID
- PWG1/ZDC
- PWG1/T0
- PWG1/VZERO
+ PWGPP/ZDC
+ PWGPP/T0
+ PWGPP/VZERO
PWG4/PartCorrBase
STEER/STEER
STEER/AOD
# 1. Create file list
# alien_find /alice/data/2010/LHC10h/000138795/pass0_2 root_ar | grep root > file.list
# 2. run script with timeout 60 and n processes 10 and the sarting diectory -current directory
-# $ALICE_ROOT/PWG1/CalibMacros/MergeCalibration/alienDownloadTimeOut.sh file.list 60 30 `pwd`
+# $ALICE_ROOT/PWGPP/CalibMacros/MergeCalibration/alienDownloadTimeOut.sh file.list 60 30 `pwd`
#
fileList=$1
--- /dev/null
+#
+# Merging Stage 0
+#
+# Merging in separate process for each detector
+# log files - merge<detector>.log and syswatch<detector>.log stored also
+# per detector
+#
+#
+# arguments of the merge macros:
+#
+# 1 - input list of the files
+# 2 - name of output root file with merged calibration
+# 3 - name filter - what to merge
+# 4 - reject mask
+# 5 - flag single key for Obj array
+#
+#
+# merge T0
+#
+aliroot -b -q $ALICE_ROOT/PWGPP/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsT0.root\",\"T0Calib\",\"AliESDfriends\",kTRUE\) >> mergeT0.log
+cp syswatch.log syswatchT0.log
+#
+# merge TOF
+#
+aliroot -b -q $ALICE_ROOT/PWGPP/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsTOF.root\",\"TOFHistos\",\"AliESDfriends\",kTRUE\) >> mergeTOF.log
+cp syswatch.log syswatchTOF.log
+#
+# merge TPC
+#
+aliroot -b -q $ALICE_ROOT/PWGPP/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsTPC.root\",\"TPCCalib\",\"AliESDfriends\",kFALSE\) >> mergeTPC.log
+cp syswatch.log syswatchTPC.log
+#
+# merge TRD
+#
+aliroot -b -q $ALICE_ROOT/PWGPP/CalibMacros/MergeCalibration/mergeCustom.C\(\"calib.list\",\"CalibObjectsTRD.root\",\"TRDcalib\",\"AliESDfriends\",kFALSE\) >> mergeTRD.log
+cp syswatch.log syswatchTRD.log
gSystem->Load("libT0calib");
gSystem->Load("libTOFcalib");
//
- // PWG1 libraries
+ // PWGPP libraries
//
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libANALYSIScalib.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG4PartCorrBase.so");
gSystem->Load("libHMPIDbase.so");
}
ouput: TimeGain and TimeVdrift calibration objects for TPC and TRD
Example:
- .L $ALICE_ROOT/PWG1/CalibMacros/Pass0/makeOCDB.C
+ .L $ALICE_ROOT/PWGPP/CalibMacros/Pass0/makeOCDB.C
makeOCDB("105160");
*/
ouput: TimeGain and TimeVdrift calibration objects for TPC and TRD
Example:
- .L $ALICE_ROOT/PWG1/CalibMacros/Pass0/makeOCDB.C
+ .L $ALICE_ROOT/PWGPP/CalibMacros/Pass0/makeOCDB.C
makeOCDB("105160");
*/
return;
}
- //load MC header for ESD;//see $ALICE_ROOT/PWG1/global/AliAnalysisTaskSEVertexESD.cxx
+ //load MC header for ESD;//see $ALICE_ROOT/PWGPP/global/AliAnalysisTaskSEVertexESD.cxx
AliHeader *mcHeader = eventHandler->MCEvent()->Header();
if (!mcHeader) {
AliDebug(AliLog::kError, "Header not available");
cnum=1;
clist=new TCanvas*[1];
- TDirectoryFile* df=(TDirectoryFile*)fildat->Get("PWG1dEdxSSDQA");
+ TDirectoryFile* df=(TDirectoryFile*)fildat->Get("PWGPPdEdxSSDQA");
TList* listin=(TList*)df->Get("SSDdEdxQA");
if(!listin) return;
TH2F* fHistQ=0x0;
//TFile* fSSD=TFile::Open(fileNameLong.Data());
- //TDirectoryFile* dfSSD=(TDirectoryFile*)fSSD->Get("PWG1dEdxSSDQA");
- TDirectoryFile* dfSSD=(TDirectoryFile*)f->Get("PWG1dEdxSSDQA");
+ //TDirectoryFile* dfSSD=(TDirectoryFile*)fSSD->Get("PWGPPdEdxSSDQA");
+ TDirectoryFile* dfSSD=(TDirectoryFile*)f->Get("PWGPPdEdxSSDQA");
if(!dfSSD){
printf("Run %d SDD_Performance MISSING -> Exit\n",iRun);
continue;
// TRD performance classes
#pragma link C++ class AliTenderSupplyTRD+;
-#pragma link C++ class AliTRDpwg1Helper+;
+#pragma link C++ class AliTRDpwgppHelper+;
#pragma link C++ class AliTRDtrendValue+;
#pragma link C++ class AliTRDtrendingManager+;
#pragma link C++ class AliTRDclusterInfo+;
0. Build the MC info tree
gSystem->Load("libANALYSIS.so");
-gSystem->Load("libPWG1.so")
+gSystem->Load("libPWGPP.so")
AliGenInfoMaker *t = new AliGenInfoMaker("galice.root","genTracks.root",0,0)
t->Exec();
1. Build the reconstructed info tree
gSystem->Load("libANALYSIS.so");
-gSystem->Load("libPWG1.so");
+gSystem->Load("libPWGPP.so");
//
AliRecInfoMaker *t2 = new AliRecInfoMaker("genTracks.root","cmpESDTracks.root","galice.root",0,0);
t2->Exec();
2. Make a chain of the information tree
gSystem->Load("libANALYSIS.so");
-gSystem->Load("libPWG1.so");
+gSystem->Load("libPWGPP.so");
//GSI example
.x ~/rootlogon.C
AliXRDPROOFtoolkit tool;
TChain * chain = tool.MakeChain("cmp.txt","ESDcmpTracks",0,1000)
chain->Lookup();
- .L $ALICE_ROOT/PWG1/AliComparisonSelector.cxx+
+ .L $ALICE_ROOT/PWGPP/AliComparisonSelector.cxx+
3.
a.) Use AliTreeDraw for fast prototyping the queries - analysis type:
-gSystem->Load("libPWG1.so");
+gSystem->Load("libPWGPP.so");
AliTreeDraw comp;
comp.SetTree(tree)
b.) Or use Selector
-chain->Process("$ALICE_ROOT/PWG1/AliComparisonSelector.cxx+")
+chain->Process("$ALICE_ROOT/PWGPP/AliComparisonSelector.cxx+")
TFile f("Output.root");
--- /dev/null
+$ALICE_ROOT/PWGPP/macros/AddTaskTrackMatchingTPCITS.C
+$ALICE_ROOT/PWGPP/macros/AddTaskAlignmentDataFilterITS.C
+$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C
+$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPC.C
+$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C
+$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C
+$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C
+$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPCPtCalib.C
+$ALICE_ROOT/PWGPP/macros/AddTaskGlobalQA.C
+$ALICE_ROOT/PWGPP/macros/AddTaskIntSpotESD.C
+$ALICE_ROOT/PWGPP/PilotTrain/AddTaskFMD.C
+$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C
+$ALICE_ROOT/PWGPP/PilotTrain/AddTaskPhysicsSelection.C
+$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C
+$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C
+$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCQA.C
+$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPC.C
+$ALICE_ROOT/PWGPP/TRD/macros/AddTrainPerformanceTRD.C
+
+
+
+
+
-Macros and scripts to run PWG1 train in $ALICE_ROOT/PWG1/PWG1macros
+Macros and scripts to run PWGPP train in $ALICE_ROOT/PWGPP/PWGPPmacros
-runPWG1Train.C - Steerring macro
+runPWGPPTrain.C - Steerring macro
- Load configuration for all tasks from file ConfigTask.txt
- macro does not configure tasks - default arguments has to be provided
- run Analysis
ConfigTask.txt -
-Add<PWG1>*.C - Macros to configure user tasks
+Add<PWGPP>*.C - Macros to configure user tasks
- All macros should have default parameters - otherwise they are ignored
- Task can get run number information, trigger information during analysis from ESDs
- To add:
-User can commit to $ALICE_ROOT/PWG1/PWG1macros/ConfigTask.txt once fullfill previous criteria.
+User can commit to $ALICE_ROOT/PWGPP/PWGPPmacros/ConfigTask.txt once fullfill previous criteria.
Not all of the macros will be used for production.
Only certified macros will be coppied to the production directory.
- 4. Make summary log files
- Not implemented part
- 3. Copy certified Add*.C to certified directory
- - 5. Write e-amil
\ No newline at end of file
+ - 5. Write e-amil
amacro=$1
esdList=$2
echo Get certificate for $amacro
-aliroot -l -b -q runPWG1Train.C\(\"$amacro\", \"$esdList\"\) 2>&1 | tee out.log
+aliroot -l -b -q runPWGPPTrain.C\(\"$amacro\", \"$esdList\"\) 2>&1 | tee out.log
makeSummary.sh > summary.log
#
# 1. copy all task ans shell scirpts
#
-cp /u/miranov/AliRoot/trunk/PWG1/PWG1macros/*.* .
+cp /u/miranov/AliRoot/trunk/PWGPP/PWGPPmacros/*.* .
#
mkdirhier $dname
cd $dname
#
- cp $workdir/runPWG1Train.C .
+ cp $workdir/runPWGPPTrain.C .
cp $workdir/*.sh .
cp $workdir/esd.list .
cp $workdir/ConfigTask.txt .
/*
- Macros to run PWG1 train:
+ Macros to run PWGPP train:
- void runPWG1Train(const char *macros = "AddTask*.C", const char *fname="AliESDs.root");
+ void runPWGPPTrain(const char *macros = "AddTask*.C", const char *fname="AliESDs.root");
//Parameters:
// macros: run the train for selected tasks
// tasks are expected to be in the working directory
// fname : name of the input file or input list
- .L $ALICE_ROOT/PWG1/PWG1macros/runPWG1Train.C
+ .L $ALICE_ROOT/PWGPP/PWGPPmacros/runPWGPPTrain.C
*/
//
// load libraries needed for train
//
- gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG1/TRD/macros/ ");
+ gSystem->SetIncludePath("-I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWGPP/TRD/macros/ ");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libTENDER.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG2.so");
gSystem->Load("libPWG3muon.so");
gSystem->Load("libPWG3muondep.so");
printf("SysInfoTime:\t%f\n",f1->GetParameter(1));
}
-void runPWG1Train(const char *macros = "AddTask*.C", TString inputList ="esd.list", Int_t debugLevel=0) {
+void runPWGPPTrain(const char *macros = "AddTask*.C", TString inputList ="esd.list", Int_t debugLevel=0) {
//Parameters:
// macros: run the train for selected tasks
// tasks are expected to be in the working directory
// Local creation e.g using:
//
- .L $ALICE_ROOT/PWG1/PWG1macros/syswatchEvalTrain.C
+ .L $ALICE_ROOT/PWGPP/PWGPPmacros/syswatchEvalTrain.C
*/
else{
cout0 = mgr->CreateContainer("QAsymHists_Global",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
cout0HM = mgr->CreateContainer("QAsymHists_Global_HighMult",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
cout0EM = mgr->CreateContainer("QAsymHists_Global_Emcal",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
cout0MU = mgr->CreateContainer("QAsymHists_Global_Muon",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
cout1 = mgr->CreateContainer("QAsymHists_ITS",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
cout1sa = mgr->CreateContainer("QAsymHists_ITS_SA",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
cout2 = mgr->CreateContainer("QAsymHists_TPC",TList::Class(),
AliAnalysisManager::kOutputContainer,
- Form("%s:PWG1_QAsymHists",AliAnalysisManager::GetCommonFileName()));
+ Form("%s:PWGPP_QAsymHists",AliAnalysisManager::GetCommonFileName()));
}
mgr->AddTask(taskdEdxSSDQA);
TString outputFileName = AliAnalysisManager::GetCommonFileName();
- outputFileName+=":PWG1dEdxSSDQA";
+ outputFileName+=":PWGPPdEdxSSDQA";
AliAnalysisDataContainer *cinput1 = mgr->CreateContainer("cchain1",TChain::Class(),AliAnalysisManager::kInputContainer);
AliAnalysisDataContainer *coutput1 = mgr->CreateContainer("SSDdEdxQA", TList::Class(),AliAnalysisManager::kOutputContainer,outputFileName);
// visible name. ("sim", "pp", ...)
// Name in train page (DON'T CHANGE)
TString visible_name = Form("QA$2_$3%s", train_tag.Data()); //# FIXED #
-TString job_comment = "PWG1 QA kAnyInt, QAsym(add kMUU7 and kEMC7) CALO (add kEMC7) triggers"; // Can add observations here
+TString job_comment = "PWGPP QA kAnyInt, QAsym(add kMUU7 and kEMC7) CALO (add kEMC7) triggers"; // Can add observations here
// Job tag (DON'T CHANGE)
TString job_tag = Form("%s: %s", visible_name.Data(), job_comment.Data());
// Package versions - Modify as needed
out.close();
// Load libraries
- gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG1");
+ gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWGPP");
LoadLibraries();
// Create manager
AliAnalysisManager *mgr = new AliAnalysisManager("PilotAnalysis", "Production train");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
if (doCALO) {
gSystem->Load("libEMCALUtils");
// CDB connection
//
if (doCDBconnect) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskCDBconnect.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
if (!taskCDB) return;
taskCDB->SetRunNumber(runNumbers[0]);
// Vertexing (A. Dainese)
//
if (doVertex) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskVertexESD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD(kFALSE, kTriggerMask);
taskvertexesd->SelectCollisionCandidates(kTriggerMask);
}
//
if (doQAsym) {
// offline trigger in AddTask
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
// taskqasim->SelectCollisionCandidates(); // Set by AddTask
}
// VZERO QA (C. Cheshkov)
//
if (doVZERO) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskVZEROQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
// to false
// Optionally highMult axis can be used by setting the 3st argument to true (for PbPb)
if (doTPC) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
// low multiplicity (pp)
//AliPerformanceTask *tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE);
// high multiplicity (Pb-Pb)
// SPD (A. Mastroserio)
//
if (doSPD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskSPDQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSE* taskspdqa = AddTaskSPDQA();
taskspdqa->SelectCollisionCandidates(kTriggerMask);
}
// SDD (F. Prino)
//
if (doSDD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddSDDPoints.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates(kTriggerMask);
}
// SSD dEdx (Marek Chojnacki)
//
if (doSSDdEdx) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskdEdxSSDQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates(kTriggerMask);
}
//
if (doITS) {
// hardcoded non-zero trigger mask
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceITS.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent0010 = 0;
AliAnalysisTaskITSTrackingCheck *itsQACent3050 = 0;
//
if (doITSsaTracks) {
// offline trigger in AddTask
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskITSsaTracks.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSsaTracks.C");
AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kFALSE,kFALSE);
itssaTracks->SelectCollisionCandidates(kTriggerMask);
}
if (doITSalign) {
// no offline trigger selection
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskITSAlign.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSAlign.C");
AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
}
//
//
if(doTRD) {
// no offline trigger selection
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTrainPerformanceTRD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
// steer individual TRD tasks
Bool_t
doCheckESD(kTRUE), // AliTRDcheckESD
//
if(doZDC) {
// hardcoded kMB trigger mask
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/ZDC/AddTaskZDCQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/ZDC/AddTaskZDCQA.C");
AliAnalysisTaskSE *taskZDC = AddTaskZDCQA();
taskZDC->SelectCollisionCandidates(kTriggerMask);
}
if(doMUONTrig) {
// no offline trigger selection
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
//
if (doV0) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskV0QA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kFALSE);
}
//
// Impact parameter resolution (xianbao.yuan@pd.infn.it, andrea.dainese@pd.infn.it)
//
if (doImpParRes) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskImpParRes.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskImpParRes.C");
AliAnalysisTaskSE* taskimpparres=0;
if(iCollisionType==0) {
taskimpparres= AddTaskImpParRes();
// TOF (Francesca Bellini)
//
if (doTOF) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TOF/AddTaskTOFQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA();
tofQA->SelectCollisionCandidates(kTriggerMask);
}
// HMPID QA (Giacomo Volpe)
//
if (doHMPID) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/HMPID/AddTaskHmpidQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/HMPID/AddTaskHmpidQA.C");
AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kFALSE);
// offline mask set in AddTask to kMB
taskhmpidqa->SelectCollisionCandidates(kTriggerMask);
// T0 QA (Alla Mayevskaya)
if (doT0) {
// no offline trigger selection
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/T0/AddTaskT0QA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/T0/AddTaskT0QA.C");
AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
taskt0qa->SelectCollisionCandidates(kTriggerMask);
}
plugin->SetDataPattern(data_pattern);
// ...then add run numbers to be considered
// if (!iAODanalysis) plugin->SetRunRange(run_range[0], run_range[1]);
-// plugin->SetOutputSingleFolder("outpu$ALICE_ROOT/PWG1/T0/Addt");
+// plugin->SetOutputSingleFolder("outpu$ALICE_ROOT/PWGPP/T0/Addt");
if (!useProductionMode) {
plugin->SetRunPrefix("000");
plugin->SetOutputToRunNo();
// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
plugin->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD");
- plugin->SetAdditionalLibs("libCORRFW.so libTENDER.so libPWG0base.so libPWG0dep.so libPWG0selectors.so libPWG1.so \
+ plugin->SetAdditionalLibs("libCORRFW.so libTENDER.so libPWG0base.so libPWG0dep.so libPWG0selectors.so libPWGPP.so \
libEMCALUtils.so libPHOSUtils.so libPWG4PartCorrBase.so libPWG4PartCorrDep.so \
libPWG3base.so libPWG3muon.so libPWG3muondep.so libPWG2forward2.so");
// May request ClearPackages (individual ClearPackage not supported)
plugin->SetClearPackages(kFALSE);
// Plugin test mode works only providing a file containing test file locations
- plugin->SetFileForTestMode(gSystem->ExpandPathName("$ALICE_ROOT/PWG1/PilotTrain/files.txt"));
+ plugin->SetFileForTestMode(gSystem->ExpandPathName("$ALICE_ROOT/PWGPP/PilotTrain/files.txt"));
return plugin;
}
// visible name. ("sim", "pp", ...)
// Name in train page (DON'T CHANGE)
TString visible_name = Form("QA$2_$3%s", train_tag.Data()); //# FIXED #
-TString job_comment = "PWG1 QA train"; // Can add observations here
+TString job_comment = "PWGPP QA train"; // Can add observations here
// Job tag (DON'T CHANGE)
TString job_tag = Form("%s: %s", visible_name.Data(), job_comment.Data());
// Package versions - Modify as needed
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG2.so");
gSystem->Load("libPWG2forward.so");
// Vertexing (A. Dainese)
//
if (doVertex) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskVertexESD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD* taskvertexesd = AddTaskVertexESD();
taskvertexesd->SelectCollisionCandidates();
}
// TPC QA (E. Sicking)
//
if (doQAsym) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0);
taskqasim->SelectCollisionCandidates();
}
// VZERO QA (C. Cheshkov)
//
if (doVZERO) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskVZEROQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
// taskv0qa->SelectCollisionCandidates();
}
// TPC (Jacek Otwinowski & Michael Knichel)
//
if (doTPC) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE);
tpcQA->SelectCollisionCandidates();
}
// SPD (A. Mastroserio)
//
if (doSPD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskSPDQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
AliAnalysisTaskSE* taskspdqa = AddTaskSPDQA();
taskspdqa->SelectCollisionCandidates();
}
// SDD (F. Prino)
//
if (doSDD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddSDDPoints.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
AliAnalysisTaskSE* tasksdd = AddSDDPoints();
tasksdd->SelectCollisionCandidates();
}
// SSD dEdx (Marek Chojnacki)
//
if (doSSDdEdx) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskdEdxSSDQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
taskssddedx->SelectCollisionCandidates();
}
// ITS
//
if (doITS) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceITS.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(kFALSE);
}
//
// TRD (Alex Bercuci, M. Fasel)
//
if(doTRD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTrainPerformanceTRD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
// steer individual TRD tasks
Bool_t
doCheckESD(kTRUE), // AliTRDcheckESD
//
if(doMUONTrig) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
//
if (doV0) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskV0QA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kFALSE);
}
// Impact parameter resolution (xianbao.yuan@pd.infn.it, andrea.dainese@pd.infn.it)
//
if (doImpParRes) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskImpParRes.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskImpParRes.C");
AliAnalysisTaskSE* taskimpparres= AddTaskImpParRes();
taskimpparres->SelectCollisionCandidates();
}
// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
plugin->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD");
- plugin->SetAdditionalLibs("libTENDER.so libPWG0base.so libPWG0dep.so libPWG0selectors.so libPWG1.so libPWG2.so \
+ plugin->SetAdditionalLibs("libTENDER.so libPWG0base.so libPWG0dep.so libPWG0selectors.so libPWGPP.so libPWG2.so \
libPWG2forward.so libEMCALUtils.so libPWG4PartCorrBase.so libPWG4PartCorrDep.so \
libPWG3base.so libPWG3muon.so libPWG3muondep.so");
// May request ClearPackages (individual ClearPackage not supported)
plugin->SetClearPackages(kFALSE);
// Plugin test mode works only providing a file containing test file locations
- plugin->SetFileForTestMode(gSystem->ExpandPathName("$ALICE_ROOT/PWG1/PilotTrain/files.txt"));
+ plugin->SetFileForTestMode(gSystem->ExpandPathName("$ALICE_ROOT/PWGPP/PilotTrain/files.txt"));
return plugin;
}
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG2.so");
gSystem->Load("libPWG2forward.so");
gSystem->Load("libEMCALUtils.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG2.so");
gSystem->Load("libPWG3muon.so");
gSystem->Load("libPWG3muondep.so");
TChain* chain = new TChain("esdTree");
//chain->AddFile("alien:///alice/data/2009/LHC09d/000104321/ESDs/pass1/09000104321018.10/AliESDs.root");
//chain->AddFile("alien:///alice/data/2009/LHC09d/000104321/ESDs/pass1/09000104321018.20/AliESDs.root");
- chain->AddFile("/home/morsch/AliRoot/trunk/PWG1/PilotTrain/data/AliESDs.root");
+ chain->AddFile("/home/morsch/AliRoot/trunk/PWGPP/PilotTrain/data/AliESDs.root");
//
// Vertexing (A. Dainese)
//
if (doVertex) {
- gROOT->LoadMacro("$(ALICE_ROOT)/PWG1/macros/AddTaskVertexESD.C");
+ gROOT->LoadMacro("$(ALICE_ROOT)/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD* task3 = AddTaskVertexESD();
task3->SelectCollisionCandidates();
}
// ITS
//
if (doITS) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceITS.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(kFALSE);
}
if (doTPC) {
//
// Optionally MC information can be used by setting the 1st argument to true
- gROOT->LoadMacro("$(ALICE_ROOT)/PWG1/TPC/macros/AddTaskPerformanceTPCQA.C");
+ gROOT->LoadMacro("$(ALICE_ROOT)/PWGPP/TPC/macros/AddTaskPerformanceTPCQA.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPCQA(kFALSE, kTRUE);
}
// TRD (Alex Bercuci, M. Fasel)
//
if(doTRD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTrainPerformanceTRD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
AddTrainPerformanceTRD("ALL");
}
}
if(doMUONTrig) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
}
}
if (doV0) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskV0QA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(kFALSE);
}
const char *module_name[NMODS] = {"SPD_Performance",
"CaloQA",
"Vertex_Performance",
- "PWG1_QAsymHists",
+ "PWGPP_QAsymHists",
"VZERO_Performance",
"TPC_PerformanceQA",
"SDD_Performance",
- "PWG1dEdxSSDQA",
+ "PWGPPdEdxSSDQA",
"ITS_Performance",
"TRD_Performance",
"MUON.TriggerEfficiencyMap",
if (!strcmp(task_name, "SPD_Performance")) folder = "coutput1";
if (!strcmp(task_name, "CaloQA")) folder = "CaloQA";
if (!strcmp(task_name, "Vertex_Performance")) folder = "cOutputVtxESD";
- if (!strcmp(task_name, "PWG1_QAsymHists")) folder = "QAsymHists_Global QAsymHists_ITS QAsymHists_ITS_SA QAsymHists_TPC";
+ if (!strcmp(task_name, "PWGPP_QAsymHists")) folder = "QAsymHists_Global QAsymHists_ITS QAsymHists_ITS_SA QAsymHists_TPC";
if (!strcmp(task_name, "VZERO_Performance")) folder = "QAVZEROHists";
if (!strcmp(task_name, "TPC_PerformanceQA")) folder = "TPCQA";
if (!strcmp(task_name, "SDD_Performance")) folder = "coutputRP";
- if (!strcmp(task_name, "PWG1dEdxSSDQA")) folder = "SSDdEdxQA";
+ if (!strcmp(task_name, "PWGPPdEdxSSDQA")) folder = "SSDdEdxQA";
if (!strcmp(task_name, "ITS_Performance")) folder = "cOutputITS";
if (!strcmp(task_name, "TRD_Performance")) folder = "checkESD infoGen checkDET TRDefficiency TRDresolution checkPID";
if (!strcmp(task_name, "MUON.TriggerEfficiencyMap")) folder = "triggerChamberEff";
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libPWG2.so");
gSystem->Load("libPWG2forward.so");
gSystem->Load("libEMCALUtils.so");
// tree->SetAlias("T","stampSec-first");
// tree->SetAlias("deltaVM","(pI.fMemVirtual-pIOld.fMemVirtual)");
// tree->SetAlias("VM","pI.fMemVirtual");
- TCanvas *c = new TCanvas("SysInfo","PWG1 QA train, run #127719 (2.84 M events)" ,10,10,1200,800);
+ TCanvas *c = new TCanvas("SysInfo","PWGPP QA train, run #127719 (2.84 M events)" ,10,10,1200,800);
tree->SetMarkerStyle(kFullSquare);
tree->SetMarkerColor(kRed);
tree->SetMarkerSize(1.5);
/*
after running analysis, read the file, and get component
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
TFile f("Output.root");
AliComparisonDraw * comp = (AliComparisonDraw*)f.Get("AliComparisonDraw");
TF1 fl("fl","((min(250./(abs(x+0.000001)),250)-90))",0,2); // length function
// Load macros
//
gSystem->Load("libSTAT.so");
- .L $ALICE_ROOT/PWG1/AliESDresolParams.cxx+
- .L $ALICE_ROOT/PWG1/AliESDresolMakerFast.cxx+
+ .L $ALICE_ROOT/PWGPP/AliESDresolParams.cxx+
+ .L $ALICE_ROOT/PWGPP/AliESDresolMakerFast.cxx+
TCut cutDCA="Tracks[].fCchi2<100&&abs(Tracks[].fP[4])<8&&abs(Tracks[].fP[3])<1&&sqrt(Tracks[].fC[0])/(0.2+abs(Tracks[].fP[4]))<0.02&&abs(Tracks[].fX)<3&&Tracks[].fITSncls>4&&Tracks.fTPCncls>40"
//
// Create resolution
---Usage outside of the analysis framework
gSystem->Load("libANALYSIS.so")
-gSystem->Load("libPWG1.so")
+gSystem->Load("libPWGPP.so")
AliGenInfoMaker *t = new AliGenInfoMaker("galice.root","genTracks.root",0,0)
t->Exec();
/*
// after running comparison task, read the file, and get component
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
LoadMyLibs();
TFile f("Output.root");
AliPerformanceDCA * compObj = (AliPerformanceDCA*)coutput->FindObject("AliPerformanceDCA");
/*
// after running comparison task, read the file, and get component
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
LoadMyLibs();
TFile f("Output.root");
//AliPerformanceDEdx * compObj = (AliPerformanceDEdx*)f.Get("AliPerformanceDEdx");
/*\r
\r
// after running comparison task, read the file, and get component\r
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");\r
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");\r
LoadMyLibs();\r
TFile f("Output.root");\r
AliPerformanceEff * compObj = (AliPerformanceEff*)coutput->FindObject("AliPerformanceEff");\r
/*
// after running comparison task, read the file, and get component
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
LoadMyLibs();
TFile f("Output.root");
/*
// after running comparison task, read the file, and get component
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
LoadMyLibs();
TFile f("Output.root");
/*
// after running comparison task, read the file, and get component
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
LoadMyLibs();
TFile f("Output.root");
/*
// after running comparison task, read the file, and get component
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/Macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/Macros/LoadMyLibs.C");
LoadMyLibs();
TFile f("Output.root");
-gSystem->Load("libPWG1.so");
+gSystem->Load("libPWGPP.so");
//
AliRecInfoMaker *t2 = new AliRecInfoMaker("genTracks.root","cmpESDTracks.root","galice.root",0,0);
t2->Exec();
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC performance QA to run on PWG1 QA train.
+// TPC performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPC.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPC.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPC("kTRUE","kTRUE","triggerClass");
//
// Output:
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC and TPC+ITS performance QA to run on PWG1 QA train.
+// TPC and TPC+ITS performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPCITSQA.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPCITSQA.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPC("kFALSE","kTRUE","triggerClass");
//
// Output:
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC performance QA to run on PWG1 QA train.
+// TPC performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPCPbPb.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCPbPb.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPCPbPb("kFALSE","kTRUE","triggerClass");
//
// Output:
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC performance QA to run on PWG1 QA train.
+// TPC performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPCQA.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPCQA.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPC("kFALSE","kTRUE","triggerClass");
//
// Output:
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC performance QA to run on PWG1 QA train.
+// TPC performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPCdEdxQA("kFALSE","kTRUE","kFALSE","triggerClass",kFALSE);
//
// Output:
- the geometry and mag. field initialized from GRP
Example:
- .L $ALICE_ROOT/PWG1/TPC/macros/ConfigOCDB.C
+ .L $ALICE_ROOT/PWGPP/TPC/macros/ConfigOCDB.C
ConfigOCDB(129160,"raw://");
*/
gSystem->Load("libTPCcalib.so");
gSystem->Load("libTENDER");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
gSystem->Load("libPHOSUtils");
gSystem->Load("libEMCALUtils");
CheckLoadLibrary("libMFTrec");
CheckLoadLibrary("libMFTsim");
#endif
- CheckLoadLibrary("libPWG1");
+ CheckLoadLibrary("libPWGPP");
}
Int_t CheckLoadLibrary(const char* library) {
void MakePerformanceSummary(const char *infile, Int_t run, const char* outfile) {
- gSystem->AddIncludePath("-I$ALICE_ROOT/PWG1/TPC");
+ gSystem->AddIncludePath("-I$ALICE_ROOT/PWGPP/TPC");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libTENDER.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libTPCcalib");
AliTPCPerformanceSummary::MakeReport(infile, outfile, run);
/*
- //gSystem->AddIncludePath("-I$ALICE_ROOT/PWG1/TPC");
- //.L $ALICE_ROOT/PWG1/TPC/macros/MakeReportTPC.C+
+ //gSystem->AddIncludePath("-I$ALICE_ROOT/PWGPP/TPC");
+ //.L $ALICE_ROOT/PWGPP/TPC/macros/MakeReportTPC.C+
//
//MakeReportTPC();
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libTPCcalib");
// gSystem->Setenv("alien_CLOSE_SE","ALICE::GSI::SE");
// TGrid::Connect("alien://",0,0,"t");
gSystem->Load("libTENDER");
gSystem->Load("libTPCcalib.so");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
// Merge performance objects
MergeOutput(filename, comp, max);
void MakeTrendGraph(const char *infilelist, const char* outfile) {
- gSystem->AddIncludePath("-I$ALICE_ROOT/PWG1/TPC");
+ gSystem->AddIncludePath("-I$ALICE_ROOT/PWGPP/TPC");
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libTENDER.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libTPCcalib");
AliTPCPerformanceSummary::ProduceTrends(infilelist, outfile);
gProof->AddIncludePath(Form("%s/TPC", location));
gProof->AddIncludePath(Form("%s/TRD", location));
gProof->AddIncludePath(Form("%s/TRD/Cal", location));
- gProof->AddIncludePath(Form("%s/PWG1", location));
+ gProof->AddIncludePath(Form("%s/PWGPP", location));
gProof->AddIncludePath(Form("%s/ANALYSIS", location));
gProof->AddDynamicPath(Form("%s/lib/tgt_linuxx8664gcc", location));
// load all libraries
- gProof->Exec("gROOT->Macro(\"$ALICE_ROOT/PWG1/TPC/macros/LoadMyLibs.C\")",kTRUE);
+ gProof->Exec("gROOT->Macro(\"$ALICE_ROOT/PWGPP/TPC/macros/LoadMyLibs.C\")",kTRUE);
}
//1. Run locally e.g.
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/LoadMyLibs.C");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain("esds_test.txt",10, 0);
chain->Lookup();
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/RunPerformanceTask.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/RunPerformanceTask.C");
RunPerformanceTask(chain, kFALSE, kTRUE, kFALSE);
//2. Run on PROOF Lite e.g.
TProof::Open("");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/ProofEnableAliRoot.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/ProofEnableAliRoot.C");
ProofEnableAliRoot("/u/jacek/alice/AliRoot/trunk");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain("list_flatP_JB.txt",20, 0);
chain->Lookup();
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/RunPerformanceTask.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/RunPerformanceTask.C");
RunPerformanceTask(chain, kTRUE, kTRUE, kTRUE);
TProof * proof = proofmgr->CreateSession();
proof->SetParameter("PROOF_MaxSlavesPerNode", (Long_t)10000);
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/ProofEnableAliRoot.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/ProofEnableAliRoot.C");
ProofEnableAliRoot("/d/alice11/jacek/alice/x86_64/AliRoot/trunk");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain("../input/ffprod_v4-17-Rev-19_900kPythia6D6T.list", 200, 0);
chain->Lookup();
- //gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/RunPerformanceTask.C");
+ //gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/RunPerformanceTask.C");
gROOT->LoadMacro("/d/alice11/jacek/alice/TPC/macros/RunPerformanceTask.C");
RunPerformanceTask(chain, kFALSE, kTRUE, kTRUE);
//
// Add task to AliAnalysisManager
//
- //gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPC.C");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/AddTaskPerformanceTPCQA.C");
+ //gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPC.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCQA.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPCQA(bUseMCInfo,bUseESDfriend);
if(!tpcQA) {
Error("runTPCQA","TaskPerformanceTPC not created!");
/*
//1. Run locally e.g.
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/LoadMyLibs.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/LoadMyLibs.C");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain("list_flatP_JB.txt", 500, 0);
// set magnetic field
TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", 1., 1., AliMagF::k5kG));
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/RunPerformanceTaskMC.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/RunPerformanceTaskMC.C");
RunPerformanceTaskMC(chain, kTRUE, kFALSE, kFALSE, 0);
//2. Run on PROOF Lite e.g.
TProof::Open("");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/ProofEnableAliRoot.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/ProofEnableAliRoot.C");
ProofEnableAliRoot("/d/alice11/jacek/alice/x86_64/AliRoot/trunkJB");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
// TGeoGlobalMagField::Instance()->SetField(new AliMagF("Maps","Maps", 1., 1., AliMagF::k5kG));
gProof->Exec("gROOT->Macro(\"MagField.C\")");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/RunPerformanceTaskMC.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/RunPerformanceTaskMC.C");
RunPerformanceTaskMC(chain, kTRUE, kTRUE, kTRUE,0);
//3. Run only on static PROOF at GSI e.g.
TProof * proof = proofmgr->CreateSession();
proof->SetParameter("PROOF_MaxSlavesPerNode", (Long_t)10000);
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/ProofEnableAliRoot.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/ProofEnableAliRoot.C");
ProofEnableAliRoot("/u/jacek/alice/AliRoot/HEADJB/");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
// set magnetic field
gProof->Exec("gROOT->ProcessLine(\"TGeoGlobalMagField::Instance()->SetField(new AliMagF(\"Maps\",\"Maps\", 1., 1., AliMagF::k5kG))\")");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/RunPerformanceTaskMC.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/RunPerformanceTaskMC.C");
RunPerformanceTaskMC(chain, kTRUE, kTRUE, kTRUE);
//4. Make final spectra and store them in the
gSystem->Load("libANALYSISalice");
gSystem->Load("libTENDER");
gSystem->Load("libCORRFW");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
TChain* chain = CreateESDChain("esds.txt",10, 0);
//TChain* chain = CreateESDChain("/u/jacek/alice/dNdPt/input/LHC10a8/esds_104867_MC_LHC10a8.txt",3, 0);
chain->Lookup();
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TPC/macros/RunPerformanceTaskResEffMC.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/RunPerformanceTaskResEffMC.C");
RunPerformanceTaskResEffMC(chain, kTRUE, kFALSE, kFALSE);
//2. Make final spectra and store them in the
gSystem->Load("libPWG0base");
gSystem->Load("libPWG0dep");
gSystem->Load("libPWG0selectors");
- .L $ALICE_ROOT/PWG1/TPC/macros/compareTracks.C+
+ .L $ALICE_ROOT/PWGPP/TPC/macros/compareTracks.C+
//
compareTracks("compare.list");
//
mkdir dir$a
cd dir$a
mv ../$a compare.list
- bsub -q proof -oo outcompare.log aliroot -b -q $ALICE_ROOT/PWG1/TPC/macroscompareTracks.C+
+ bsub -q proof -oo outcompare.log aliroot -b -q $ALICE_ROOT/PWGPP/TPC/macroscompareTracks.C+
cd $wdir
done;
#include "info/AliTRDeventInfo.h"
#include "AliTRDinfoGen.h"
#include "AliTRDcheckDET.h"
-#include "AliTRDpwg1Helper.h"
+#include "AliTRDpwgppHelper.h"
#include <cstdio>
#include <iostream>
#include "AliTRDseedV1.h"\r
#include "AliTRDcluster.h"\r
#include "AliTRDinfoGen.h"\r
-#include "AliTRDpwg1Helper.h"\r
+#include "AliTRDpwgppHelper.h"\r
#include "info/AliTRDtrackInfo.h"\r
#include "info/AliTRDeventInfo.h"\r
#include "info/AliTRDv0Info.h"\r
// Default constructor\r
//\r
SetTitle("MC-REC TRD-track list generator");\r
- DefineOutput(AliTRDpwg1Helper::kTracksBarrel, TObjArray::Class());\r
- DefineOutput(AliTRDpwg1Helper::kTracksSA, TObjArray::Class());\r
- DefineOutput(AliTRDpwg1Helper::kTracksKink, TObjArray::Class());\r
- DefineOutput(AliTRDpwg1Helper::kEventInfo, AliTRDeventInfo::Class());\r
- DefineOutput(AliTRDpwg1Helper::kV0List, TObjArray::Class());\r
- DefineOutput(AliTRDpwg1Helper::kClusters, TObjArray::Class());\r
- DefineOutput(AliTRDpwg1Helper::kMonitor, TObjArray::Class()); // histogram list\r
+ DefineOutput(AliTRDpwgppHelper::kTracksBarrel, TObjArray::Class());\r
+ DefineOutput(AliTRDpwgppHelper::kTracksSA, TObjArray::Class());\r
+ DefineOutput(AliTRDpwgppHelper::kTracksKink, TObjArray::Class());\r
+ DefineOutput(AliTRDpwgppHelper::kEventInfo, AliTRDeventInfo::Class());\r
+ DefineOutput(AliTRDpwgppHelper::kV0List, TObjArray::Class());\r
+ DefineOutput(AliTRDpwgppHelper::kClusters, TObjArray::Class());\r
+ DefineOutput(AliTRDpwgppHelper::kMonitor, TObjArray::Class()); // histogram list\r
}\r
\r
//____________________________________________________________________\r
//____________________________________________________________________\r
Bool_t AliTRDinfoGen::GetRefFigure(Int_t)\r
{\r
-// General graphs for PWG1/TRD train\r
+// General graphs for PWGPP/TRD train\r
if(!gPad){\r
AliWarning("Please provide a canvas to draw results.");\r
return kFALSE;\r
chmb->SetName("Chambers"); chmb->SetOwner();\r
fContainer->AddAt(chmb, kChmb);\r
\r
- PostData(AliTRDpwg1Helper::kTracksBarrel, fTracksBarrel);\r
- PostData(AliTRDpwg1Helper::kTracksSA, fTracksSA);\r
- PostData(AliTRDpwg1Helper::kTracksKink, fTracksKink);\r
- PostData(AliTRDpwg1Helper::kEventInfo, fEventInfo);\r
- PostData(AliTRDpwg1Helper::kV0List, fV0List);\r
- PostData(AliTRDpwg1Helper::kClusters, fClusters);\r
- PostData(AliTRDpwg1Helper::kMonitor, fContainer);\r
+ PostData(AliTRDpwgppHelper::kTracksBarrel, fTracksBarrel);\r
+ PostData(AliTRDpwgppHelper::kTracksSA, fTracksSA);\r
+ PostData(AliTRDpwgppHelper::kTracksKink, fTracksKink);\r
+ PostData(AliTRDpwgppHelper::kEventInfo, fEventInfo);\r
+ PostData(AliTRDpwgppHelper::kV0List, fV0List);\r
+ PostData(AliTRDpwgppHelper::kClusters, fClusters);\r
+ PostData(AliTRDpwgppHelper::kMonitor, fContainer);\r
}\r
\r
//____________________________________________________________________\r
Int_t es(reco->GetEventSpecie());\r
if(!(es&fESDev->GetEventSpecie())) continue;\r
fgReconstructor->SetRecoParam(reco);\r
- if(AliLog::GetDebugLevel("PWG1/TRD", "AliTRDinfoGen")>5) reco->Dump();\r
+ if(AliLog::GetDebugLevel("PWGPP/TRD", "AliTRDinfoGen")>5) reco->Dump();\r
TString s;\r
if(es&AliRecoParam::kLowMult){ s="LowMult"; h->Fill(0);}\r
else if(es&AliRecoParam::kHighMult){ s="HighMult"; h->Fill(1);}\r
{\r
// Process run information\r
AliInfo("");\r
- if(!(fContainer = dynamic_cast<TObjArray *>(GetOutputData(AliTRDpwg1Helper::kMonitor)))) return;\r
+ if(!(fContainer = dynamic_cast<TObjArray *>(GetOutputData(AliTRDpwgppHelper::kMonitor)))) return;\r
AliInfo(Form("fContainer(%p)", (void*)fContainer));\r
if(UseLocalEvSelection()){\r
TH1 *h1 = (TH1*)fContainer->At(kTrigger); TAxis *ax(h1->GetXaxis());\r
////////////////////////////////////////////////////////////////////////////
// //
-// Helper class for PWG1 TRD train //
+// Helper class for PWGPP TRD train //
// //
// Authors: //
// Markus Fasel <M.Fasel@gsi.de> //
#include <cstring>
#include <fstream>
-#include "AliTRDpwg1Helper.h"
+#include "AliTRDpwgppHelper.h"
-const Char_t * AliTRDpwg1Helper::fgkTRDtaskClassName[AliTRDpwg1Helper::kNTRDTASKS] = {
+const Char_t * AliTRDpwgppHelper::fgkTRDtaskClassName[AliTRDpwgppHelper::kNTRDTASKS] = {
"AliTRDcheckESD"
,"AliTRDinfoGen"
,"AliTRDcheckDET"
,"AliTRDmultiplicity"
};
-const Char_t * AliTRDpwg1Helper::fgkTRDtaskOpt[AliTRDpwg1Helper::kNTRDTASKS+1] = {
+const Char_t * AliTRDpwgppHelper::fgkTRDtaskOpt[AliTRDpwgppHelper::kNTRDTASKS+1] = {
"ESD"
,"GEN"
,"DET"
};
//______________________________________________________
-Bool_t AliTRDpwg1Helper::DoTask(Int_t idx, Int_t map)
+Bool_t AliTRDpwgppHelper::DoTask(Int_t idx, Int_t map)
{
return TESTBIT(map, idx);
}
//______________________________________________________
-Int_t AliTRDpwg1Helper::ParseOptions(const Char_t *trd)
+Int_t AliTRDpwgppHelper::ParseOptions(const Char_t *trd)
{
// Parse space separated options.
// Possible options are:
foundOpt = kTRUE;
break;
}
- if(!foundOpt) Warning("AliTRDpwg1Helper::ParseOptions()", "TRD task %s not implemented (yet).", s.Data());
+ if(!foundOpt) Warning("AliTRDpwgppHelper::ParseOptions()", "TRD task %s not implemented (yet).", s.Data());
}
}
// extra rules for calibration tasks
}
//______________________________________________________
-void AliTRDpwg1Helper::MergeProd(const Char_t *mark, const Char_t *files, const Int_t nBatch, Int_t level)
+void AliTRDpwgppHelper::MergeProd(const Char_t *mark, const Char_t *files, const Int_t nBatch, Int_t level)
{
// Recursively merge files named "mark" from list in "files" in groups of "nBatch" files.
// parameter "level" is used to index recurent calls of this function.
Int_t first(0);
for(Int_t ibatch(0); ibatch<nBatches; ibatch++){
first = ibatch*nBatch;
- if(gSystem->Exec(Form("aliroot -b -q \'$ALICE_ROOT/PWG1/TRD/macros/mergeBatch.C(\"%s\", \"%s\", %d, %d)\'", mark, lPURGE, nBatch, first))) continue;
+ if(gSystem->Exec(Form("aliroot -b -q \'$ALICE_ROOT/PWGPP/TRD/macros/mergeBatch.C(\"%s\", \"%s\", %d, %d)\'", mark, lPURGE, nBatch, first))) continue;
gSystem->Exec(Form("mv %d_%s merge/%d_%d_%s", first, mark, level, first, mark));
gSystem->Exec(Form("echo %s/merge/%d_%d_%s >> %s", gSystem->ExpandPathName("$PWD"), level, first, mark, lMERGE));
}
if(nBatches==1){
- Info("AliTRDpwg1Helper::MergeProd()", "Rename 1 merged file.");
+ Info("AliTRDpwgppHelper::MergeProd()", "Rename 1 merged file.");
gSystem->Exec(Form("mv merge/%d_%d_%s %s", level, first, mark, mark));
} else if(nBatches<=nBatch){
- Info("AliTRDpwg1Helper::MergeProd()", "Merge %d files in 1 batch.", nBatches);
- if(!gSystem->Exec(Form("aliroot -b -q \'$ALICE_ROOT/PWG1/TRD/macros/mergeBatch.C(\"%s\", \"%s\", %d, 0, kFALSE)\'", mark, lMERGE, nBatches))) return;
+ Info("AliTRDpwgppHelper::MergeProd()", "Merge %d files in 1 batch.", nBatches);
+ if(!gSystem->Exec(Form("aliroot -b -q \'$ALICE_ROOT/PWGPP/TRD/macros/mergeBatch.C(\"%s\", \"%s\", %d, 0, kFALSE)\'", mark, lMERGE, nBatches))) return;
gSystem->Exec(Form("mv 0_%s %s", mark, mark));
} else {
level++;
- Info("AliTRDpwg1Helper::MergeProd()", "Merge level %d.", level);
+ Info("AliTRDpwgppHelper::MergeProd()", "Merge level %d.", level);
MergeProd(mark, lMERGE, nBatch, level);
}
gSystem->Exec(Form("rm -fv %s %s", lMERGE, lPURGE));
//______________________________________________________
-Int_t AliTRDpwg1Helper::MergeBatch(const Char_t *mark, const Char_t *files, const Int_t nfiles, const Int_t first, Bool_t kSVN, Bool_t kCLEAR)
+Int_t AliTRDpwgppHelper::MergeBatch(const Char_t *mark, const Char_t *files, const Int_t nfiles, const Int_t first, Bool_t kSVN, Bool_t kCLEAR)
{
// Merge files specified in the file list "files" by the token "mark".
// The script will merge "nfiles" files starting from the "first" file.
if(kSVN){ // download SVN info for trending
if(gSystem->Exec(Form("if [ ! -f svnInfo.log ]; then cp -v %s/svnInfo.log %s; fi", Dirname(filename.c_str()), gSystem->ExpandPathName("$PWD"))) == 0) kSVN=kFALSE;
}
- Info("AliTRDpwg1Helper::MergeBatch()", "%s", filename.c_str());
+ Info("AliTRDpwgppHelper::MergeBatch()", "%s", filename.c_str());
if(!fFM.AddFile(filename.c_str())) return NULL;
arr.Add(new TObjString(filename.c_str()));
nbatch++;
if(nbatch==nfiles) break;
}
if(!nbatch){
- Warning("AliTRDpwg1Helper::MergeBatch()", "NOTHING TO MERGE"); return NULL;
+ Warning("AliTRDpwgppHelper::MergeBatch()", "NOTHING TO MERGE"); return NULL;
} else {
- Info("AliTRDpwg1Helper::MergeBatch()", "MERGING FILES[%d] START[%d] %s ... ", nbatch, first, ((nbatch<nfiles)?"INCOMPLETE":""));
+ Info("AliTRDpwgppHelper::MergeBatch()", "MERGING FILES[%d] START[%d] %s ... ", nbatch, first, ((nbatch<nfiles)?"INCOMPLETE":""));
}
if(!fFM.Merge()){
- Info("AliTRDpwg1Helper::MergeBatch()", "Failed [%s]", fFM.GetOutputFileName());
+ Info("AliTRDpwgppHelper::MergeBatch()", "Failed [%s]", fFM.GetOutputFileName());
return 1;
}
- Info("AliTRDpwg1Helper::MergeBatch()", "Done [%s]", fFM.GetOutputFileName());
+ Info("AliTRDpwgppHelper::MergeBatch()", "Done [%s]", fFM.GetOutputFileName());
if(kCLEAR){
for(Int_t ifile(0); ifile<arr.GetEntries(); ifile++){
}
//______________________________________________________
-const Char_t* AliTRDpwg1Helper::Basename(const char* filepath)
+const Char_t* AliTRDpwgppHelper::Basename(const char* filepath)
{
// Implementation of shell "basename" builtin
TString s(filepath);
}
//______________________________________________________
-const Char_t* AliTRDpwg1Helper::Dirname(const char* filepath)
+const Char_t* AliTRDpwgppHelper::Dirname(const char* filepath)
{
// Implementation of shell "dirname" builtin
TString s(filepath);
}
//______________________________________________________
-Int_t AliTRDpwg1Helper::GetTaskIndex(const Char_t *name)
+Int_t AliTRDpwgppHelper::GetTaskIndex(const Char_t *name)
{
// Give index in TRD train of task class "name"
for(Int_t it(0); it<kNTRDTASKS; it++){
}
//______________________________________________________
-Bool_t AliTRDpwg1Helper::HasReadMCData(const Char_t *opt)
+Bool_t AliTRDpwgppHelper::HasReadMCData(const Char_t *opt)
{
// Use MC data option
return !(Bool_t)strstr(opt, "NOMC");
}
//____________________________________________
-Bool_t AliTRDpwg1Helper::HasReadFriendData(const Char_t *opt)
+Bool_t AliTRDpwgppHelper::HasReadFriendData(const Char_t *opt)
{
// Use friends data option
return !(Bool_t)strstr(opt, "NOFR");
-#ifndef ALITRDPWG1HELPER_H
-#define ALITRDPWG1HELPER_H
+#ifndef ALITRDPWGPPHELPER_H
+#define ALITRDPWGPPHELPER_H
////////////////////////////////////////////////////////////////////////////
// //
-// Helper class for PWG1 TRD train //
+// Helper class for PWGPP TRD train //
// //
// Authors: //
// Markus Fasel <M.Fasel@gsi.de> //
// //
////////////////////////////////////////////////////////////////////////////
-class AliTRDpwg1Helper{
+class AliTRDpwgppHelper{
public:
enum ETRDinfoGenOutSlots {
kEventInfo = 1
kNTRDTASKS = kNTRDQATASKS + kNTRDCALIBTASKS
};
- AliTRDpwg1Helper();
- ~AliTRDpwg1Helper();
+ AliTRDpwgppHelper();
+ ~AliTRDpwgppHelper();
static Bool_t DoTask(Int_t idx, Int_t map);
static Int_t GetTaskIndex(const Char_t *name);
static Int_t ParseOptions(const Char_t *trd);
private:
- AliTRDpwg1Helper(const AliTRDpwg1Helper& ref);
- const AliTRDpwg1Helper& operator=(const AliTRDpwg1Helper& ref);
+ AliTRDpwgppHelper(const AliTRDpwgppHelper& ref);
+ const AliTRDpwgppHelper& operator=(const AliTRDpwgppHelper& ref);
static const Char_t * fgkTRDtaskOpt[kNTRDTASKS + 1]; //! task options
static const Char_t * fgkTRDtaskClassName[kNTRDTASKS];//! task class name
};
// with the minimum chi2/ndf is choosen
if(!h2) {
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>0) printf("D-AliTRDresolution::Process() : NULL pointer input container.\n");
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>0) printf("D-AliTRDresolution::Process() : NULL pointer input container.\n");
return kFALSE;
}
if(!Int_t(h2->GetEntries())){
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>0) printf("D-AliTRDresolution::Process() : Empty h[%s - %s].\n", h2->GetName(), h2->GetTitle());
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>0) printf("D-AliTRDresolution::Process() : Empty h[%s - %s].\n", h2->GetName(), h2->GetTitle());
return kFALSE;
}
if(!g || !g[0]|| !g[1]) {
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>0) printf("D-AliTRDresolution::Process() : NULL pointer output container.\n");
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>0) printf("D-AliTRDresolution::Process() : NULL pointer output container.\n");
return kFALSE;
}
// prepare
h = h2->ProjectionY("py", ix, ix);
if((n=(Int_t)h->GetEntries())<stat){
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>1) printf("I-AliTRDresolution::Process() : Low statistics @ x[%f] stat[%d]=%d [%d].\n", x, ix, n, stat);
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>1) printf("I-AliTRDresolution::Process() : Low statistics @ x[%f] stat[%d]=%d [%d].\n", x, ix, n, stat);
continue;
}
// looking for a first order mean value
//
if(np<40){
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>1) printf("D-AliTRDresolution::FitTrack: Not enough clusters to fit a track [%d].\n", np);
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>1) printf("D-AliTRDresolution::FitTrack: Not enough clusters to fit a track [%d].\n", np);
return kFALSE;
}
TLinearFitter yfitter(2, "pol1"), zfitter(2, "pol1");
Double_t dydx = yfitter.GetParameter(1);
param[0] = x0; param[1] = y0; param[2] = z0; param[3] = dydx; param[4] = dzdx;
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>3) printf("D-AliTRDresolution::FitTrack: x0[%f] y0[%f] z0[%f] dydx[%f] dzdx[%f].\n", x0, y0, z0, dydx, dzdx);
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>3) printf("D-AliTRDresolution::FitTrack: x0[%f] y0[%f] z0[%f] dydx[%f] dzdx[%f].\n", x0, y0, z0, dydx, dzdx);
return kTRUE;
}
nly++;
}
if(nly<10){
- if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>1) printf("D-AliTRDresolution::FitTracklet: Not enough clusters to fit a tracklet [%d].\n", nly);
+ if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>1) printf("D-AliTRDresolution::FitTracklet: Not enough clusters to fit a tracklet [%d].\n", nly);
return kFALSE;
}
// set radial reference for fit
// }
// cwd->cd();
//
-// if(AliLog::GetDebugLevel("PWG1", "AliTRDresolution")>=2){
+// if(AliLog::GetDebugLevel("PWGPP", "AliTRDresolution")>=2){
// for(Int_t il(0); il<184; il++) printf("-"); printf("\n");
// printf("DET|");for(Int_t it(0); it<30; it++) printf(" tb%02d|", it); printf("\n");
// for(Int_t il(0); il<184; il++) printf("-"); printf("\n");
Int_t fVertexN; // Min number of contributors to Vertex
Double_t fVertexZ; // Max Abs(z) of the reconstructed Vertex
- ClassDef(AliTRDeventCuts, 1) //Event Cut class for TRD PWG1 Train
+ ClassDef(AliTRDeventCuts, 1) //Event Cut class for TRD PWGPP Train
};
#endif
#include "AliLog.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "PWG1/TRD/AliTRDpwg1Helper.h"
-#include "PWG1/TRD/AliTRDcheckDET.h"
-#include "PWG1/TRD/AliTRDcalibration.h"
+#include "PWGPP/TRD/AliTRDpwgppHelper.h"
+#include "PWGPP/TRD/AliTRDcheckDET.h"
+#include "PWGPP/TRD/AliTRDcalibration.h"
#endif
void AddTRDcheckDET(AliAnalysisManager *mgr, Int_t map, AliAnalysisDataContainer **ci/*, AliAnalysisDataContainer **co*/)
// CALIBRATION
- if(!(TESTBIT(map, AliTRDpwg1Helper::kCalibration))) return;
+ if(!(TESTBIT(map, AliTRDpwgppHelper::kCalibration))) return;
AliTRDcalibration *ctask(NULL);
mgr->AddTask(ctask = new AliTRDcalibration((char*)"calibration"));
ctask->SetHisto2d(kTRUE);
#include "AliAnalysisDataContainer.h"
#include "AliAnalysisCuts.h"
#include "AliESDtrackCuts.h"
-#include "PWG1/TRD/AliTRDcheckESD.h"
+#include "PWGPP/TRD/AliTRDcheckESD.h"
#endif
AliESDtrackCuts* SetupESDcuts();
#include "AliLog.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "PWG1/TRD/AliTRDpwg1Helper.h"
-#include "PWG1/TRD/AliTRDcheckPID.h"
-#include "PWG1/TRD/AliTRDpidRefMaker.h"
-#include "PWG1/TRD/AliTRDpidRefMakerNN.h"
-#include "PWG1/TRD/AliTRDpidRefMakerLQ.h"
+#include "PWGPP/TRD/AliTRDpwgppHelper.h"
+#include "PWGPP/TRD/AliTRDcheckPID.h"
+#include "PWGPP/TRD/AliTRDpidRefMaker.h"
+#include "PWGPP/TRD/AliTRDpidRefMakerNN.h"
+#include "PWGPP/TRD/AliTRDpidRefMakerLQ.h"
#endif
void AddTRDcheckPID(AliAnalysisManager *mgr, Int_t map, AliAnalysisDataContainer **ci, AliAnalysisDataContainer **co)
mgr->ConnectOutput(pid, 1, mgr->CreateContainer(pid->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("%s:TRD_Performance",mgr->GetCommonFileName())));
mgr->ConnectOutput(pid, 2, co[0]);
- if(TESTBIT(map, AliTRDpwg1Helper::kPIDRefMaker)){
+ if(TESTBIT(map, AliTRDpwgppHelper::kPIDRefMaker)){
//AliLog::SetClassDebugLevel("AliTRDpidRefMaker", 3);
//AliLog::SetClassDebugLevel("AliTRDpidRefMakerNN", 3);
#include "AliAnalysisDataContainer.h"
#include "TRD/AliTRDtrackerV1.h"
#include "TRD/AliTRDtransform.h"
-#include "PWG1/TRD/AliTRDcheckTRK.h"
+#include "PWGPP/TRD/AliTRDcheckTRK.h"
#endif
void AddTRDcheckTRK(AliAnalysisManager *mgr, Int_t /*map*/, AliAnalysisDataContainer **ci/*, AliAnalysisDataContainer **co*/)
#include "TError.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "PWG1/TRD/AliTRDpwg1Helper.h"
-#include "PWG1/TRD/AliTRDefficiency.h"
-#include "PWG1/TRD/AliTRDefficiencyMC.h"
-#include "PWG1/TRD/AliTRDmultiplicity.h"
+#include "PWGPP/TRD/AliTRDpwgppHelper.h"
+#include "PWGPP/TRD/AliTRDefficiency.h"
+#include "PWGPP/TRD/AliTRDefficiencyMC.h"
+#include "PWGPP/TRD/AliTRDmultiplicity.h"
#endif
void AddTRDefficiency(AliAnalysisManager *mgr, Int_t map, AliAnalysisDataContainer **ci/*, AliAnalysisDataContainer **co*/)
// TRD combined tracking efficiency
- if(mgr->GetMCtruthEventHandler() && TESTBIT(map, AliTRDpwg1Helper::kEfficiencyMC)) {
+ if(mgr->GetMCtruthEventHandler() && TESTBIT(map, AliTRDpwgppHelper::kEfficiencyMC)) {
mgr->AddTask(eff = new AliTRDefficiencyMC((char*)"TRDefficiencyMC"));
eff->SetDebugLevel(0);
//AliLog::SetClassDebugLevel("AliTRDefficiencyMC", 5);
}
// TRD single track selection
- if(!(TESTBIT(map, AliTRDpwg1Helper::kMultiplicity))) return;
+ if(!(TESTBIT(map, AliTRDpwgppHelper::kMultiplicity))) return;
mgr->AddTask(eff = new AliTRDmultiplicity((char*)"TRDmultiplicity"));
eff->SetDebugLevel(0);
#include "AliLog.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "PWG1/TRD/AliTRDinfoGen.h"
-#include "PWG1/TRD/AliTRDpwg1Helper.h"
-#include "PWG1/TRD/info/AliTRDeventInfo.h"
-#include "PWG1/TRD/info/AliTRDeventCuts.h"
+#include "PWGPP/TRD/AliTRDinfoGen.h"
+#include "PWGPP/TRD/AliTRDpwgppHelper.h"
+#include "PWGPP/TRD/info/AliTRDeventInfo.h"
+#include "PWGPP/TRD/info/AliTRDeventCuts.h"
#endif
void AddTRDinfoGen(AliAnalysisManager *mgr, Int_t /*map*/, AliAnalysisDataContainer **/*ci*/, AliAnalysisDataContainer **co)
// Connect IO slots
mgr->ConnectInput (info, 0, mgr->GetCommonInputContainer());
- co[AliTRDpwg1Helper::kEventInfo] = mgr->CreateContainer("eventInfo", AliTRDeventInfo::Class(), AliAnalysisManager::kExchangeContainer);
- co[AliTRDpwg1Helper::kTracksBarrel] = mgr->CreateContainer("tracksBarrel", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
- co[AliTRDpwg1Helper::kTracksSA] = mgr->CreateContainer("tracksSA", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
- co[AliTRDpwg1Helper::kTracksKink] = mgr->CreateContainer("tracksKink", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
- co[AliTRDpwg1Helper::kV0List] = mgr->CreateContainer("v0List", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
- co[AliTRDpwg1Helper::kClusters] = mgr->CreateContainer("clusters", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
- for(Int_t ios(1);ios<AliTRDpwg1Helper::kNOutSlots-1;ios++) mgr->ConnectOutput(info, ios, co[ios]);
+ co[AliTRDpwgppHelper::kEventInfo] = mgr->CreateContainer("eventInfo", AliTRDeventInfo::Class(), AliAnalysisManager::kExchangeContainer);
+ co[AliTRDpwgppHelper::kTracksBarrel] = mgr->CreateContainer("tracksBarrel", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
+ co[AliTRDpwgppHelper::kTracksSA] = mgr->CreateContainer("tracksSA", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
+ co[AliTRDpwgppHelper::kTracksKink] = mgr->CreateContainer("tracksKink", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
+ co[AliTRDpwgppHelper::kV0List] = mgr->CreateContainer("v0List", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
+ co[AliTRDpwgppHelper::kClusters] = mgr->CreateContainer("clusters", TObjArray::Class(), AliAnalysisManager::kExchangeContainer);
+ for(Int_t ios(1);ios<AliTRDpwgppHelper::kNOutSlots-1;ios++) mgr->ConnectOutput(info, ios, co[ios]);
// add last monitor container
AliAnalysisDataContainer *mon=mgr->CreateContainer(info->GetName(), TObjArray::Class(), AliAnalysisManager::kOutputContainer, Form("%s:TRD_Performance",mgr->GetCommonFileName()));
- mgr->ConnectOutput(info, AliTRDpwg1Helper::kNOutSlots-1, mon);
+ mgr->ConnectOutput(info, AliTRDpwgppHelper::kNOutSlots-1, mon);
}
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
#include "TRD/AliTRDgeometry.h"
-#include "PWG1/TRD/AliTRDpwg1Helper.h"
-#include "PWG1/TRD/AliTRDresolution.h"
-#include "PWG1/TRD/AliTRDclusterResolution.h"
-#include "PWG1/TRD/AliTRDalignmentTask.h"
+#include "PWGPP/TRD/AliTRDpwgppHelper.h"
+#include "PWGPP/TRD/AliTRDresolution.h"
+#include "PWGPP/TRD/AliTRDclusterResolution.h"
+#include "PWGPP/TRD/AliTRDalignmentTask.h"
#endif
void AddTRDresolution(AliAnalysisManager *mgr, Int_t map, AliAnalysisDataContainer **ci)
TObjArray *coa = mgr->GetContainers();
// Cluster Error Parameterization
- if(TESTBIT(map, AliTRDpwg1Helper::kClErrParam)){
+ if(TESTBIT(map, AliTRDpwgppHelper::kClErrParam)){
AliTRDclusterResolution *taskCl(NULL);
AliLog::SetClassDebugLevel("AliTRDclusterResolution", 2);
for(Int_t idet(10); idet<11/*AliTRDgeometry::kNdet*/; idet++){
}
// TRD alignment
- if(TESTBIT(map, AliTRDpwg1Helper::kAlignment)){
+ if(TESTBIT(map, AliTRDpwgppHelper::kAlignment)){
AliTRDalignmentTask *taskAlign(NULL);
mgr->AddTask(taskAlign = new AliTRDalignmentTask((char*)"TRDalignment"));
taskAlign->SetDebugLevel(0);
return 0x0;
}
- // gROOT->LoadMacro("$ALICE_ROOT/PWG1/TRD/AliTRDtaskTrackletFilter.cxx++g");
+ // gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TRD/AliTRDtaskTrackletFilter.cxx++g");
AliTRDonlineTrackletFilter *task = new AliTRDonlineTrackletFilter("tracklet-filter");
mgr->AddTask(task);
return 0x0;
}
- // gROOT->LoadMacro("$ALICE_ROOT/PWG1/TRD/AliTRDtrklQA.cxx++g");
+ // gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TRD/AliTRDtrklQA.cxx++g");
AliTRDonlineTrackletQA *task = new AliTRDonlineTrackletQA("trklQA");
mgr->AddTask(task);
#include "AliLog.h"
#include "AliAnalysisManager.h"
#include "AliAnalysisDataContainer.h"
-#include "PWG1/TRD/AliTRDv0Monitor.h"
+#include "PWGPP/TRD/AliTRDv0Monitor.h"
#endif
void AddTRDv0Monitor(AliAnalysisManager *mgr, Int_t /*map*/, AliAnalysisDataContainer **ci/*, AliAnalysisDataContainer **co*/)
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
/* AliCDBManager *cdb(AliCDBManager::Instance());
}
tm->Print();
//tm->Save();
-}
\ No newline at end of file
+}
// gSystem->Load("libANALYSISalice.so")
// gSystem->Load("libTENDER.so")
// gSystem->Load("libSTAT.so")
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
// gSystem->Load("libNetx.so") ;
// gSystem->Load("libRAliEn.so");
//
#if ! defined (__CINT__) || defined (__MAKECINT__)
#include "AliLog.h"
-#include "PWG1/TRD/AliTRDrecoTask.h"
+#include "PWGPP/TRD/AliTRDrecoTask.h"
#include <fstream>
#include <TCanvas.h>
#include <TStyle.h>
#endif
-Char_t const *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libANALYSISalice.so", "libTENDER.so", "libSTAT.so", "libPWG1.so"};
+Char_t const *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libANALYSISalice.so", "libTENDER.so", "libSTAT.so", "libPWGPP.so"};
// define setup
TClass *ctask = new TClass;
if(!c) c=new TCanvas("c", "Calibration", 10, 10, 800, 500);
- for(Int_t itask = AliTRDpwg1Helper::kNTRDQATASKS; itask<AliTRDpwg1Helper::NTRDTASKS; itask++){
+ for(Int_t itask = AliTRDpwgppHelper::kNTRDQATASKS; itask<AliTRDpwgppHelper::NTRDTASKS; itask++){
if(!TESTBIT(fSteerTask, itask)) continue;
switch(itask){
- case AliTRDpwg1Helper::kPIDRefMaker:
+ case AliTRDpwgppHelper::kPIDRefMaker:
calibrateTRD(itask, "AliTRDpidRefMakerLQ", "PIDrefMaker");
//calibrateTRD(itask, "AliTRDpidRefMakerNN", "PIDrefMaker");
break;
//______________________________________________________
void calibrateTRD(Int_t itask, Char_t const* ntask, Char_t const* nfile)
{
- if(!ntask) ntask=AliTRDpwg1Helper::fgkTRDtaskClassName[itask];
+ if(!ntask) ntask=AliTRDpwgppHelper::fgkTRDtaskClassName[itask];
new(ctask) TClass(ntask);
if(!ctask){
Error("makeCalibResults.C", Form("Asking for wrong class name [%s].", ntask));
// gSystem->Load("libANALYSIS.so")
// gSystem->Load("libANALYSISalice.so")
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
// gSystem->Load("libCORRFW.so");
// gSystem->Load("libNetx.so") ;
// gSystem->Load("libRAliEn.so");
#include "AliLog.h"
-#include "PWG1/TRD/AliTRDpwg1Helper.h"
-#include "PWG1/TRD/AliTRDrecoTask.h"
-#include "PWG1/TRD/AliTRDcheckESD.h"
-#include "PWG1/TRD/AliTRDinfoGen.h"
+#include "PWGPP/TRD/AliTRDpwgppHelper.h"
+#include "PWGPP/TRD/AliTRDrecoTask.h"
+#include "PWGPP/TRD/AliTRDcheckESD.h"
+#include "PWGPP/TRD/AliTRDinfoGen.h"
#endif
-const Char_t *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libANALYSISalice.so", "libCORRFW", "libTENDER.so", "libPWG1.so"};
+const Char_t *libs[] = {"libProofPlayer.so", "libANALYSIS.so", "libANALYSISalice.so", "libCORRFW", "libTENDER.so", "libPWGPP.so"};
// define setup
TCanvas *c(NULL);
Bool_t mc(kFALSE), friends(kFALSE);
return;
}
- mc = AliTRDpwg1Helper::HasReadMCData(opt);
- friends = AliTRDpwg1Helper::HasReadFriendData(opt);
+ mc = AliTRDpwgppHelper::HasReadMCData(opt);
+ friends = AliTRDpwgppHelper::HasReadFriendData(opt);
gStyle->SetOptStat(0);
gStyle->SetOptFit(0);
TString outputFile;
if(!TString(files).EndsWith(".root")){
outputFile = Form("%s/QAResults.root", gSystem->ExpandPathName("$PWD"));
- AliTRDpwg1Helper::MergeProd("QAResults.root", files);
+ AliTRDpwgppHelper::MergeProd("QAResults.root", files);
} else {
outputFile = files;
}
- Int_t fSteerTask = AliTRDpwg1Helper::ParseOptions(opt);
+ Int_t fSteerTask = AliTRDpwgppHelper::ParseOptions(opt);
if(!dosummary){
summary = kFALSE;
TClass *ctask = new TClass;
AliAnalysisTask *task = 0x0;
- for(Int_t itask = AliTRDpwg1Helper::kNTRDQATASKS; itask--;){
- if(!AliTRDpwg1Helper::DoTask(itask, fSteerTask)) continue;
- new(ctask) TClass(AliTRDpwg1Helper::TaskClassName(itask));
+ for(Int_t itask = AliTRDpwgppHelper::kNTRDQATASKS; itask--;){
+ if(!AliTRDpwgppHelper::DoTask(itask, fSteerTask)) continue;
+ new(ctask) TClass(AliTRDpwgppHelper::TaskClassName(itask));
task = (AliAnalysisTask*)ctask->New();
task->SetName(Form("%s%s", task->GetName(), cid));
printf(" *** task %s, output file %s\n", task->GetName(), outputFile.Data());
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libCORRFW.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
Int_t ntry(0);
- while(AliTRDpwg1Helper::MergeBatch(mark, files, nfiles, first, kSVN, kCLEAR) && ntry<5) ntry++;
+ while(AliTRDpwgppHelper::MergeBatch(mark, files, nfiles, first, kSVN, kCLEAR) && ntry<5) ntry++;
}
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libCORRFW.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
TDatime dt; gRandom->SetSeed(dt.Get());
gSystem->Exec("mkdir -p merge; rm -rf merge/*");
- AliTRDpwg1Helper::MergeProd(file, files, 5);
+ AliTRDpwgppHelper::MergeProd(file, files, 5);
gSystem->Exec("rm -rfv merge");
-}
\ No newline at end of file
+}
// gSystem->Load("libANALYSIS.so")
// gSystem->Load("libANALYSISalice.so")
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
// gSystem->Load("libNetx.so") ;
// gSystem->Load("libRAliEn.so");
//
#include "TRD/AliTRDtrackerV1.h"
#include "TRD/AliTRDcalibDB.h"
-#include "PWG1/TRD/macros/AddTRDcheckESD.C"
-#include "PWG1/TRD/macros/AddTRDinfoGen.C"
-#include "PWG1/TRD/macros/AddTRDcheckDET.C"
-#include "PWG1/TRD/macros/AddTRDefficiency.C"
-#include "PWG1/TRD/macros/AddTRDresolution.C"
-#include "PWG1/TRD/macros/AddTRDcheckPID.C"
+#include "PWGPP/TRD/macros/AddTRDcheckESD.C"
+#include "PWGPP/TRD/macros/AddTRDinfoGen.C"
+#include "PWGPP/TRD/macros/AddTRDcheckDET.C"
+#include "PWGPP/TRD/macros/AddTRDefficiency.C"
+#include "PWGPP/TRD/macros/AddTRDresolution.C"
+#include "PWGPP/TRD/macros/AddTRDcheckPID.C"
#endif
Bool_t MEM = kFALSE;
if(gSystem->Load("libANALYSIS.so")<0) return;
if(gSystem->Load("libANALYSISalice.so")<0) return;
if(gSystem->Load("libTENDER.so")<0) return;
- if(gSystem->Load("libPWG1.so")<0) return;
+ if(gSystem->Load("libPWGPP.so")<0) return;
if(gSystem->Load("libCORRFW.so")<0) return;
Bool_t fHasMCdata = UseMC(optList);
mgr->SetSkipTerminate(kTRUE);
// add CDB task
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskCDBconnect.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
if (!taskCDB) return;
taskCDB->SetRunNumber(run);
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTrainPerformanceTRD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
if(!AddTrainPerformanceTRD(optList)) {
Error("run.C", "Error loading TRD train.");
return;
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libTENDER");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
AliLog::SetGlobalLogLevel(AliLog::kError);
gROOT->LoadMacro(Form("%s/PWG0/CreateESDChain.C", gSystem->ExpandPathName("$ALICE_ROOT")));
TChain *chain = CreateESDChain(esdlist, -1);
TString &filestr = file->String();
TString runstr = filestr(2,9);
return runstr.Atoi();
-}
\ No newline at end of file
+}
mgr->SetMCtruthEventHandler(mch);
}
// assign simple task
- gProof->Load(gSystem->ExpandPathName("$(ALICE_ROOT)/PWG1/background/AliHistoListWrapper.cxx++g"));
- gProof->Load(gSystem->ExpandPathName("$(ALICE_ROOT)/PWG1/background/AliAnalysisTaskBGvsTime.cxx++g"));
+ gProof->Load(gSystem->ExpandPathName("$(ALICE_ROOT)/PWGPP/background/AliHistoListWrapper.cxx++g"));
+ gProof->Load(gSystem->ExpandPathName("$(ALICE_ROOT)/PWGPP/background/AliAnalysisTaskBGvsTime.cxx++g"));
//____________________________________________//
// assign simple task
AliAnalysisTaskBGvsTime * task = new AliAnalysisTaskBGvsTime("TaskBG");
\subsection{Reconstruction Performance}
A comparison of Monte-Carlo (MC) and reconstruction information is necessary to
-check the performance of the reconstruction algorithms. The PWG1 library has been started to make
+check the performance of the reconstruction algorithms. The PWGPP library has been started to make
MC vs reconstruction comparison, to tune selection criteria (cuts) and to find the best representation
of the data (observables, correlations between observables, parametrisations, etc.). The main goal is to
get the best track reconstruction performance in the central barrel.
-\subsection{PWG1 library}
+\subsection{PWGPP library}
-Current implementation of PWG1 allows us to run comparison for TPC and TPC-tracks.
+Current implementation of PWGPP allows us to run comparison for TPC and TPC-tracks.
The comparison of MC and reconstructed tracks is done in 4 steps:
\begin{itemize}
\end{itemize}
In order to perform these steps the following
-components (classes) have been implemented in PWG1 library:
+components (classes) have been implemented in PWGPP library:
\begin{itemize}
\item The $AliGenInfoMaker$ collects MC information stored in
ESD production. Then the comparison task can be run many times (e.g. on Proof)
to tune selection criteria and to find the best representation of data.
-The basic components of the PWG1 library are: makers ($AliGenInfoMaker$, $AliRecInfoMaker$),
+The basic components of the PWGPP library are: makers ($AliGenInfoMaker$, $AliRecInfoMaker$),
tasks ($AliAnalysisTask$), cuts ($AliAnalysisCuts$) and comparison objects ($AliComparisonObject$).
The makers derive from TObject ROOT class and have functionality to collect and correlate MC and reconstruction
\subsection{User implementation}
-One has to implement the following classes to run its own analysis using PWG1 library:
+One has to implement the following classes to run its own analysis using PWGPP library:
\begin{itemize}
-\item[1.] Implement comparison object which contains control histograms and its own cut object (ex: $PWG1/AliComparisonDCA.h$)
-\item[2.] Implement (if needed) cut object which contains all cuts which will be applied while filling comparison object. It is recommended to use $IsSelected(TObject*)$ method of the cut object while applying the cuts (ex: $PWG1/AliMCInfoCuts.h$).
+\item[1.] Implement comparison object which contains control histograms and its own cut object (ex: $PWGPP/AliComparisonDCA.h$)
+\item[2.] Implement (if needed) cut object which contains all cuts which will be applied while filling comparison object. It is recommended to use $IsSelected(TObject*)$ method of the cut object while applying the cuts (ex: $PWGPP/AliMCInfoCuts.h$).
\end{itemize}
\subsection{Quick Start}
\begin{itemize}
-\item[1.] Prepare input by running $AliGenInfoMaker$ and then $AliRecInfoMaker$ makers ($PWG1/Macros/RunMakers.C$)
+\item[1.] Prepare input by running $AliGenInfoMaker$ and then $AliRecInfoMaker$ makers ($PWGPP/Macros/RunMakers.C$)
\item[2.] Create comparison objects
\item[3.] Create cut objects and pass them to corresponding comparison objects
-\item[4.] Add comparison objects to comparison task \newline ($PWG1/Macros/RunAliComparisonTask.C$)
-\item[5.] Run comparison analysis ($PWG1/Macros/RunGSI.C$)
+\item[4.] Add comparison objects to comparison task \newline ($PWGPP/Macros/RunAliComparisonTask.C$)
+\item[5.] Run comparison analysis ($PWGPP/Macros/RunGSI.C$)
\end{itemize}
// Get and connect other common input/output containers via the manager as below
//===========================================================================
TString outputFileName = AliAnalysisManager::GetCommonFileName();
- outputFileName += ":PWG1GlobalQA";
+ outputFileName += ":PWGPPGlobalQA";
//if (lCollidingSystems) outputFileName += "_AA";
//else outputFileName += "_PP";
if (mgr->GetMCtruthEventHandler()) outputFileName += "_MC";
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC performance QA to run on PWG1 QA train.
+// TPC performance QA to run on PWGPP QA train.
//
// Input: ESDs, ESDfriends (optional), Kinematics (optional), TrackRefs (optional)
// ESD and MC input handlers must be attached to AliAnalysisManager
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
// gSystem->Load("libTENDER.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPC.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPC.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPC("kTRUE","kTRUE","triggerClass");
//
// Output:
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliPerformanceTask for
-// TPC performance QA to run on PWG1 QA train.
+// TPC performance QA to run on PWGPP QA train.
//
// By default 1 performance component is added to
// the task:
// gSystem->Load("libANALYSIS");
// gSystem->Load("libANALYSISalice");
// gSystem->Load("libTPCcalib.so");
-// gSystem->Load("libPWG1.so");
+// gSystem->Load("libPWGPP.so");
//
-// gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPCPtCalib.C");
+// gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPCPtCalib.C");
// AliPerformanceTask *tpcQA = AddTaskPerformanceTPCPtCalib("kTRUE","kTRUE","CINT1B-ABCE-NOPF-ALL");
//
// Output:
///////////////////////////////////////////////////////////////////////////////
// Macro to setup AliAnalysisTaskV0QA for
-// V0 performance QA to run on PWG1 QA train.
+// V0 performance QA to run on PWGPP QA train.
// ESD and MC input handlers must be attached to AliAnalysisManager
//
// Output:
//
// The file contains 4 THnSparse generic histograms which
// have to be analysed using the macros
-// PWG1/macros/plotSparseK0.C
-// PWG1/macros/plotSparseGamma.C
-// PWG1/macros/plotSparseL.C
-// PWG1/macros/plotSparseAL.C
+// PWGPP/macros/plotSparseK0.C
+// PWGPP/macros/plotSparseGamma.C
+// PWGPP/macros/plotSparseL.C
+// PWGPP/macros/plotSparseAL.C
//
// 14.10.09 A. Marin a.marin@gsi.de
///////////////////////////////////////
// gSystem->Load("libMemStatGui.so")\r
// gSystem->Load("libANALYSIS.so")\r
// gSystem->Load("libANALYSISalice.so")\r
-// gSystem->Load("libPWG1.so");\r
+// gSystem->Load("libPWGPP.so");\r
//\r
// Authors:\r
// Alex Bercuci (A.Bercuci@gsi.de) \r
#include "TRD/AliTRDtrackerV1.h"\r
#include "TRD/AliTRDcalibDB.h"\r
\r
-#include "PWG1/TRD/macros/AddTRDcheckESD.C"\r
-#include "PWG1/TRD/macros/AddTRDinfoGen.C"\r
-#include "PWG1/TRD/macros/AddTRDcheckDET.C"\r
-#include "PWG1/TRD/macros/AddTRDefficiency.C"\r
-#include "PWG1/TRD/macros/AddTRDresolution.C"\r
-#include "PWG1/TRD/macros/AddTRDcheckPID.C"\r
-#include "PWG1/TRD/macros/AddTRDcheckTRK.C"\r
-#include "PWG1/TRD/macros/AddTRDv0Monitor.C"\r
+#include "PWGPP/TRD/macros/AddTRDcheckESD.C"\r
+#include "PWGPP/TRD/macros/AddTRDinfoGen.C"\r
+#include "PWGPP/TRD/macros/AddTRDcheckDET.C"\r
+#include "PWGPP/TRD/macros/AddTRDefficiency.C"\r
+#include "PWGPP/TRD/macros/AddTRDresolution.C"\r
+#include "PWGPP/TRD/macros/AddTRDcheckPID.C"\r
+#include "PWGPP/TRD/macros/AddTRDcheckTRK.C"\r
+#include "PWGPP/TRD/macros/AddTRDv0Monitor.C"\r
#endif\r
\r
TString opt("");\r
const Char_t* Translate(Bool_t doCheckESD=kTRUE, Bool_t doCheckDET=kTRUE, Bool_t doEffic=kTRUE, Bool_t doResolution=kTRUE, Bool_t doCheckPID=kTRUE, Bool_t doV0Monitor=kTRUE);\r
-Bool_t AddTrainPerformanceTRD(Char_t *trd="ALL", const Char_t *addMacroPath = "$ALICE_ROOT/PWG1/TRD/macros")\r
+Bool_t AddTrainPerformanceTRD(Char_t *trd="ALL", const Char_t *addMacroPath = "$ALICE_ROOT/PWGPP/TRD/macros")\r
{\r
AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();\r
if(!mgr) { \r
}\r
\r
// TRD data containers\r
- AliAnalysisDataContainer *ci[AliTRDpwg1Helper::kNOutSlots];\r
+ AliAnalysisDataContainer *ci[AliTRDpwgppHelper::kNOutSlots];\r
AliAnalysisDataContainer *ce[5];\r
\r
Info("AddTrainPerformanceTRD", Form("Add Macros taken from %s", addMacroPath));\r
Info("AddTrainPerformanceTRD", Form("TRD wagons \"%s\"", trd));\r
- Int_t bitmap = AliTRDpwg1Helper::ParseOptions(trd);\r
- for(Int_t it=0; it<AliTRDpwg1Helper::kNTRDQATASKS; it++){\r
- if(gROOT->LoadMacro(Form("%s/Add%s.C+", addMacroPath, TString(AliTRDpwg1Helper::TaskClassName(it))(3,20).Data()))) {\r
- Error("AddTrainPerformanceTRD()", Form("Error loading %s task.", AliTRDpwg1Helper::TaskClassName(it)));\r
+ Int_t bitmap = AliTRDpwgppHelper::ParseOptions(trd);\r
+ for(Int_t it=0; it<AliTRDpwgppHelper::kNTRDQATASKS; it++){\r
+ if(gROOT->LoadMacro(Form("%s/Add%s.C+", addMacroPath, TString(AliTRDpwgppHelper::TaskClassName(it))(3,20).Data()))) {\r
+ Error("AddTrainPerformanceTRD()", Form("Error loading %s task.", AliTRDpwgppHelper::TaskClassName(it)));\r
return kFALSE;\r
} \r
- if(!AliTRDpwg1Helper::DoTask(it, bitmap)) continue;\r
+ if(!AliTRDpwgppHelper::DoTask(it, bitmap)) continue;\r
\r
switch(it){\r
- case AliTRDpwg1Helper::kCheckESD:\r
+ case AliTRDpwgppHelper::kCheckESD:\r
AddTRDcheckESD(mgr); break;\r
- case AliTRDpwg1Helper::kInfoGen:\r
+ case AliTRDpwgppHelper::kInfoGen:\r
AddTRDinfoGen(mgr, 0, NULL, ci); break;\r
- case AliTRDpwg1Helper::kCheckDET:\r
+ case AliTRDpwgppHelper::kCheckDET:\r
// map slots\r
- ce[0]=ci[AliTRDpwg1Helper::kTracksBarrel];\r
- ce[1]=ci[AliTRDpwg1Helper::kTracksSA];\r
- ce[2]=ci[AliTRDpwg1Helper::kTracksKink];\r
- ce[3]=ci[AliTRDpwg1Helper::kEventInfo];\r
- ce[4]=ci[AliTRDpwg1Helper::kClusters];\r
+ ce[0]=ci[AliTRDpwgppHelper::kTracksBarrel];\r
+ ce[1]=ci[AliTRDpwgppHelper::kTracksSA];\r
+ ce[2]=ci[AliTRDpwgppHelper::kTracksKink];\r
+ ce[3]=ci[AliTRDpwgppHelper::kEventInfo];\r
+ ce[4]=ci[AliTRDpwgppHelper::kClusters];\r
AddTRDcheckDET(mgr, bitmap, ce);\r
break;\r
- case AliTRDpwg1Helper::kEfficiency:\r
+ case AliTRDpwgppHelper::kEfficiency:\r
// map slots\r
- ce[0]=ci[AliTRDpwg1Helper::kTracksBarrel];\r
- ce[1]=ci[AliTRDpwg1Helper::kTracksSA];\r
- ce[2]=ci[AliTRDpwg1Helper::kTracksKink];\r
- ce[3]=ci[AliTRDpwg1Helper::kEventInfo];\r
- ce[4]=ci[AliTRDpwg1Helper::kClusters];\r
+ ce[0]=ci[AliTRDpwgppHelper::kTracksBarrel];\r
+ ce[1]=ci[AliTRDpwgppHelper::kTracksSA];\r
+ ce[2]=ci[AliTRDpwgppHelper::kTracksKink];\r
+ ce[3]=ci[AliTRDpwgppHelper::kEventInfo];\r
+ ce[4]=ci[AliTRDpwgppHelper::kClusters];\r
AddTRDefficiency(mgr, bitmap, ce);\r
break;\r
- case AliTRDpwg1Helper::kResolution:\r
+ case AliTRDpwgppHelper::kResolution:\r
// map slots\r
- ce[0]=ci[AliTRDpwg1Helper::kTracksBarrel];\r
- ce[1]=ci[AliTRDpwg1Helper::kTracksSA];\r
- ce[2]=ci[AliTRDpwg1Helper::kTracksKink];\r
- ce[3]=ci[AliTRDpwg1Helper::kEventInfo];\r
- ce[4]=ci[AliTRDpwg1Helper::kClusters];\r
+ ce[0]=ci[AliTRDpwgppHelper::kTracksBarrel];\r
+ ce[1]=ci[AliTRDpwgppHelper::kTracksSA];\r
+ ce[2]=ci[AliTRDpwgppHelper::kTracksKink];\r
+ ce[3]=ci[AliTRDpwgppHelper::kEventInfo];\r
+ ce[4]=ci[AliTRDpwgppHelper::kClusters];\r
AddTRDresolution(mgr, bitmap, ce); \r
break;\r
- case AliTRDpwg1Helper::kCheckPID:\r
+ case AliTRDpwgppHelper::kCheckPID:\r
// map slots\r
- ce[0]=ci[AliTRDpwg1Helper::kTracksBarrel];\r
- ce[1]=ci[AliTRDpwg1Helper::kEventInfo];\r
- ce[2]=ci[AliTRDpwg1Helper::kV0List];\r
+ ce[0]=ci[AliTRDpwgppHelper::kTracksBarrel];\r
+ ce[1]=ci[AliTRDpwgppHelper::kEventInfo];\r
+ ce[2]=ci[AliTRDpwgppHelper::kV0List];\r
AddTRDcheckPID(mgr, bitmap, ce, &ce[3]);\r
break;\r
- case AliTRDpwg1Helper::kCheckTRK:\r
+ case AliTRDpwgppHelper::kCheckTRK:\r
// map slots\r
- ce[0]=ci[AliTRDpwg1Helper::kTracksBarrel];\r
- ce[1]=ci[AliTRDpwg1Helper::kEventInfo];\r
- ce[2]=ci[AliTRDpwg1Helper::kClusters];\r
+ ce[0]=ci[AliTRDpwgppHelper::kTracksBarrel];\r
+ ce[1]=ci[AliTRDpwgppHelper::kEventInfo];\r
+ ce[2]=ci[AliTRDpwgppHelper::kClusters];\r
AddTRDcheckTRK(mgr, 0, ce);\r
break;\r
- case AliTRDpwg1Helper::kV0Monitor:\r
+ case AliTRDpwgppHelper::kV0Monitor:\r
// slots already mapped by checkPID\r
AddTRDv0Monitor(mgr, 0, ce);\r
break;\r
void LoadLibraries()
{
- gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG1 -I$ALICE_ROOT/PWG1/TRD");
+ gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWGPP -I$ALICE_ROOT/PWGPP/TRD");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libCORRFW");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
}
void AddAnalysisTasks()
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE /*MC*/);
//
// add standard ITSAlignQA task with only SDD calibration histos activated
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskITSAlign.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSAlign.C");
AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011,kTRUE);
itsAlign->SetLoadGeometryFromOCDB(kFALSE);
itsAlign->SetDoSPDResiduals(kFALSE);
Long64_t nentries=1000000000000000,firstentry=0;
Bool_t useAlienPlugin=kTRUE;
- Bool_t uselibPWG1=kFALSE;
+ Bool_t uselibPWGPP=kFALSE;
TString loadMacroPath="../../";
Bool_t readHLT=kFALSE;
//
// Load analysis libraries
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
- if(uselibPWG1) {gSystem->Load("libTENDER.so");gSystem->Load("libPWG1.so");}
+ if(uselibPWGPP) {gSystem->Load("libTENDER.so");gSystem->Load("libPWGPP.so");}
// Create Alien plugin, if requested
if(useAlienPlugin) {
- AliAnalysisGrid *alienHandler = CreateAlienHandler(pluginmode,uselibPWG1,firstrun,lastrun);
+ AliAnalysisGrid *alienHandler = CreateAlienHandler(pluginmode,uselibPWGPP,firstrun,lastrun);
if(!alienHandler) return;
}
TString taskName;
if(runAlign) {
- if(!uselibPWG1) gROOT->LoadMacro("AliAlignmentDataFilterITS.cxx++g");
+ if(!uselibPWGPP) gROOT->LoadMacro("AliAlignmentDataFilterITS.cxx++g");
taskName="AddTaskAlignmentDataFilterITS.C";
taskName.Prepend(loadMacroPath.Data());
gROOT->LoadMacro(taskName.Data());
AliAlignmentDataFilterITS *alignTask = AddTaskAlignmentDataFilterITS();
}
if(runITS) {
- if(!uselibPWG1) gROOT->LoadMacro("AliAnalysisTaskITSTrackingCheck.cxx++g");
+ if(!uselibPWGPP) gROOT->LoadMacro("AliAnalysisTaskITSTrackingCheck.cxx++g");
taskName="AddTaskPerformanceITS.C";
taskName.Prepend(loadMacroPath.Data());
gROOT->LoadMacro(taskName.Data());
AliAnalysisTaskITSTrackingCheck *itsTask = AddTaskPerformanceITS(readMC,kFALSE,kFALSE);
}
if(runImpPar) {
- if(!uselibPWG1) gROOT->LoadMacro("AliAnalysisTaskSEImpParRes.cxx++g");
+ if(!uselibPWGPP) gROOT->LoadMacro("AliAnalysisTaskSEImpParRes.cxx++g");
taskName="AddTaskImpParRes.C";
taskName.Prepend(loadMacroPath.Data());
gROOT->LoadMacro(taskName.Data());
AliAnalysisTaskSEImpParRes *d0Task = AddTaskImpParRes(readMC,-1,kFALSE);
}
if(runVtx) {
- if(!uselibPWG1) gROOT->LoadMacro("AliAnalysisTaskVertexESD.cxx++g");
+ if(!uselibPWGPP) gROOT->LoadMacro("AliAnalysisTaskVertexESD.cxx++g");
taskName="AddTaskVertexESD.C";
taskName.Prepend(loadMacroPath.Data());
gROOT->LoadMacro(taskName.Data());
AliAnalysisTaskVertexESD *vtxTask = AddTaskVertexESD(readMC);
}
if(runSPD) {
- if(!uselibPWG1) gROOT->LoadMacro("AliAnalysisTaskSPD.cxx++g");
+ if(!uselibPWGPP) gROOT->LoadMacro("AliAnalysisTaskSPD.cxx++g");
taskName="AddTaskSPDQA.C";
- taskName.Prepend("$ALICE_ROOT/PWG1/PilotTrain/");
+ taskName.Prepend("$ALICE_ROOT/PWGPP/PilotTrain/");
gROOT->LoadMacro(taskName.Data());
AliAnalysisTaskSPD *spdTask = AddTaskSPDQA();
}
/*
- if(!uselibPWG1) gROOT->LoadMacro("AliTrackMatchingTPCITSCosmics.cxx++g");
+ if(!uselibPWGPP) gROOT->LoadMacro("AliTrackMatchingTPCITSCosmics.cxx++g");
taskName="AddTaskTrackMatchingTPCITS.C";
taskName.Prepend(loadMacroPath.Data());
gROOT->LoadMacro(taskName.Data());
//_____________________________________________________________________________
//
AliAnalysisGrid* CreateAlienHandler(TString pluginmode="test",
- Bool_t uselibPWG1=kFALSE,
+ Bool_t uselibPWGPP=kFALSE,
Int_t firstrun,Int_t lastrun)
{
// Check if user has a valid token, otherwise make one. This has limitations.
// plugin->AddDataFile("/alice/data/2008/LHC08c/000057657/raw/Run57657.Merged.RAW.tag.root");
// Declare the analysis source files names separated by blancs. To be compiled runtime
// using ACLiC on the worker nodes.
- if(!uselibPWG1) {
+ if(!uselibPWGPP) {
plugin->SetAnalysisSource("AliAnalysisTaskITSTrackingCheck.cxx AliAlignmentDataFilterITS.cxx AliAnalysisTaskSEImpParRes.cxx AliAnalysisTaskVertexESD.cxx");
//plugin->SetAnalysisSource("AliAnalysisTaskVertexESD.cxx");
//plugin->SetAnalysisSource("AliAlignmentDataFilterITS.cxx");
// loaded by the generated analysis macro. Add all extra files (task .cxx/.h) here.
//plugin->SetAdditionalLibs("AliAlignmentDataFilterITS.h AliAlignmentDataFilterITS.cxx libProof.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEER.so libITSbase.so libITSrec.so");
plugin->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TPC -I$ALICE_ROOT/CONTAINERS -I$ALICE_ROOT/STEER -I$ALICE_ROOT/TRD -I$ALICE_ROOT/macros -I$ALICE_ROOT/ANALYSIS -g");
- if(!uselibPWG1) {
+ if(!uselibPWGPP) {
//plugin->SetAdditionalLibs("AliAlignmentDataFilterITS.h AliAlignmentDataFilterITS.cxx libProof.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEER.so libITSbase.so libITSrec.so");
plugin->SetAdditionalLibs("AliAlignmentDataFilterITS.h AliAlignmentDataFilterITS.cxx AliAnalysisTaskITSTrackingCheck.h AliAnalysisTaskITSTrackingCheck.cxx AliAnalysisTaskSEImpParRes.h AliAnalysisTaskSEImpParRes.cxx AliAnalysisTaskVertexESD.h AliAnalysisTaskVertexESD.cxx libGui.so libProof.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEER.so libITSbase.so libITSrec.so");
//plugin->SetAdditionalLibs("AliAnalysisTaskVertexESD.h AliAnalysisTaskVertexESD.cxx libProof.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEER.so libITSbase.so libITSrec.so");
} else {
- plugin->SetAdditionalLibs("libGui.so libProof.so libMinuit.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEER.so libITSbase.so libITSrec.so libTPCbase.so libTPCrec.so libTRDbase.so libTRDrec.so libTENDER.so libPWG1.so");
+ plugin->SetAdditionalLibs("libGui.so libProof.so libMinuit.so libRAWDatabase.so libRAWDatarec.so libCDB.so libSTEER.so libITSbase.so libITSrec.so libTPCbase.so libTPCrec.so libTRDbase.so libTRDrec.so libTENDER.so libPWGPP.so");
}
// Declare the output file names separated by blancs.
// (can be like: file.root or file.root@ALICE::Niham::File)
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
//
TChain *chainESD = 0;
gROOT->LoadMacro("$ALICE_ROOT/PWG0/CreateESDChain.C");
esdH->SetActiveBranches("ESDfriend");
//
mgr->SetInputEventHandler(esdH);
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskIntSpotESD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskIntSpotESD.C");
AliAnalysisTaskIPInfo* iptask = AddTaskIntSpotESD();
if(!mgr->InitAnalysis()) return;
-// Run this macro to correlate MC and reconstruction information (PWG1 library).
+// Run this macro to correlate MC and reconstruction information (PWGPP library).
// Macro must be run in directory containing MC and ESD trees
//
RunMakers()
// load AliRoot libraries
gSystem->Load("libANALYSIS.so");
gSystem->Load("libANALYSISalice.so");
-gSystem->Load("libPWG1.so");
+gSystem->Load("libPWGPP.so");
// collect MC information
AliGenInfoMaker *infoMC = new AliGenInfoMaker("galice.root","genTracks.root",0,0);
//
// Train Configuration
//
- Int_t iPWG1perfTPC = 1; // Test TPC performance
- Int_t iPWG1perfTRD = 0; // Test TRD performance
- Int_t iPWG1perfITS = 0; // Test ITS performance
- Int_t iPWG1perfCalo = 0; // Test Calo performance
- Int_t iPWG1perfMuonTrig = 0; // Test Muon Trigger performance
- Int_t iPWG1perfMuonEff = 0; // Test Muon Efficiency performance
- Int_t iPWG1perfTOF = 0; // Test TOF-TPC matching performance
- Int_t iPWG1perfPrimVertex = 0; // Test Primary Vertex performance
- Int_t iPWG1v0QA = 0; // V0 algorithm QA task
+ Int_t iPWGPPperfTPC = 1; // Test TPC performance
+ Int_t iPWGPPperfTRD = 0; // Test TRD performance
+ Int_t iPWGPPperfITS = 0; // Test ITS performance
+ Int_t iPWGPPperfCalo = 0; // Test Calo performance
+ Int_t iPWGPPperfMuonTrig = 0; // Test Muon Trigger performance
+ Int_t iPWGPPperfMuonEff = 0; // Test Muon Efficiency performance
+ Int_t iPWGPPperfTOF = 0; // Test TOF-TPC matching performance
+ Int_t iPWGPPperfPrimVertex = 0; // Test Primary Vertex performance
+ Int_t iPWGPPv0QA = 0; // V0 algorithm QA task
//
// Load Libraries
gSystem->Load("libCORRFW");
gSystem->Load("libTPCcalib.so");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
gSystem->Load("libPHOSUtils");
gSystem->Load("libEMCALUtils");
//
// TPC performance
//
- if(iPWG1perfTPC) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceTPC.C");
+ if(iPWGPPperfTPC) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceTPC.C");
AliPerformanceTask *tpcQA = AddTaskPerformanceTPC(bUseMCInfo,bUseESDfriend,triggerClass);
if(!tpcQA) {
Error("RunPerformanceTrain","AliPerformanceTask not created!");
//
// TRD perormance
//
- if(iPWG1perfTRD) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTrainPerformanceTRD.C");
+ if(iPWGPPperfTRD) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
if(!AddTrainPerformanceTRD(bUseMCInfo,bUseESDfriend)) {
Error("RunPerformanceTrain","TrainPerformanceTRD not created!");
return;
//
// ITS performance
//
- if(iPWG1perfITS) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskPerformanceITS.C");
+ if(iPWGPPperfITS) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
AliAnalysisTaskITSTrackingCheck *itsQA = AddTaskPerformanceITS(bUseMCInfo);
if(!itsQA) {
Error("RunPerformanceTrain","AliAnalysisTaskITSTrackingCheck not created!");
//
// Calorimeter Performance
//
- if(iPWG1perfCalo) {
+ if(iPWGPPperfCalo) {
gROOT->LoadMacro("$ALICE_ROOT/PWG4/macros/AddTaskCalorimeterQA.C");
AliAnalysisTaskParticleCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD",bUseMCInfo,kFALSE);
if(!taskCaloQA) {
//
// Muon Trigger
//
- if(iPWG1perfMuonTrig) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskMTRchamberEfficiency.C");
+ if(iPWGPPperfMuonTrig) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
if(!taskMuonTrig) {
Error("RunPerformanceTrain","AliAnalysisTaskTrigChEff not created!");
//
// Muon Efficiency
//
- if(iPWG1perfMuonEff) {
+ if(iPWGPPperfMuonEff) {
gROOT->LoadMacro("$ALICE_ROOT/PWG3/muondep/AddTaskMUONTrackingEfficiency.C");
AliAnalysisTaskMuonTrackingEff *taskMuonTrackEff = AliAnalysisTaskMuonTrackingEff();
if(!taskMuonTrackEff) {
//
// TOF performance
//
- if(iPWG1perfTOF) {
+ if(iPWGPPperfTOF) {
//
}
else {
Printf("RunPerformanceTrain: TOF - EXCLUDED!");
}
//
- // PWG1 Primary Vertex
+ // PWGPP Primary Vertex
//
- if(iPWG1perfPrimVertex) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskVertexESD.C");
+ if(iPWGPPperfPrimVertex) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskVertexESD *taskPrimVertex = AddTaskVertexESD();
if(!taskPrimVertex) {
Error("RunPerformanceTrain","AliAnalysisTaskVertexESD not created!");
Printf("RunPerformanceTrain: AliAnalysisTaskVertexESD - EXCLUDED!");
}
//
- // PWG1 V0 QA
+ // PWGPP V0 QA
//
- if (iPWG1v0QA) {
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskV0QA.C");
+ if (iPWGPPv0QA) {
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskV0QA.C");
AliAnalysisTaskV0QA *taskv0QA = AddTaskV0QA(bUseMCInfo);
if(!taskv0QA) {
Error("RunPerformanceTrain","AliAnalysisTaskV0QA not created!");
gSystem->Load("libHMPIDbase");
gSystem->Load("libTENDER");
gSystem->Load("libTENDERSupplies");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
gSystem->AddIncludePath("-I$ALICE_ROOT/include");
//gROOT->LoadMacro("AliRelAlignerKalman.cxx++");
gSystem->Load("libHMPIDbase");
gSystem->Load("libTENDER");
gSystem->Load("libTENDERSupplies");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
// Use AliRoot includes to compile our task
gSystem->AddIncludePath("-I$ALICE_ROOT/include");
gSystem->Load("libANALYSIS");
gSystem->Load("libANALYSISalice");
gSystem->Load("libTENDER");
- gSystem->Load("libPWG1");
+ gSystem->Load("libPWGPP");
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
AliAnalysisManager *mgr = new AliAnalysisManager("TestManager");
- gProof->Load("$ALICE_ROOT/PWG1/global/AliAnalysisTaskGlobalQA.cxx++g");
+ gProof->Load("$ALICE_ROOT/PWGPP/global/AliAnalysisTaskGlobalQA.cxx++g");
AliAnalysisTask *task = new AliAnalysisTaskGlobalQA();
mgr->AddTask(task);
/*
- Sequence hot to se the PWG1 analysis tasks:
+ Sequence hot to se the PWGPP analysis tasks:
//1. Load libraries if needed:
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
AliLog::SetGlobalLogLevel(AliLog::kError);
//3. Make a analysis manager with attached task:
- .L $ALICE_ROOT/PWG1/macros/taskComp.C
+ .L $ALICE_ROOT/PWGPP/macros/taskComp.C
Init();
AliAnalysisManager *mgr = MakeManager();
gProof->Exec("gSystem->Load(\"libANALYSISalice.so\")",kTRUE);
gProof->Exec("gSystem->Load(\"libPWG0base.so\")",kTRUE);
gProof->Exec("gSystem->Load(\"libPWG0dep.so\")",kTRUE);
- gProof->Exec("gSystem->Load(\"libPWG1.so\")",kTRUE);
+ gProof->Exec("gSystem->Load(\"libPWGPP.so\")",kTRUE);
TString path=gSystem->pwd();
TString execCDB="gROOT->Macro(\"";
.x ~/NimStyle.C
.x ~/UliStyle.C
- .L $ALICE_ROOT/PWG1/Macros/tpcPIDResol.C+
+ .L $ALICE_ROOT/PWGPP/Macros/tpcPIDResol.C+
Init();
//
// custom draw GetProjection(THnSparse*his, Int_t i0, Int_t i1, Float_t type0, Float_t type1, Float_t p0, Float_t p1, Float_t eta0, Float_t eta1, Int_t ncl0, Int_t ncl1)
.x ~/NimStyle.C
.x ~/UliStyle.C
- .L $ALICE_ROOT/PWG1/Macros/tpcQA.C+
+ .L $ALICE_ROOT/PWGPP/Macros/tpcQA.C+
Init();
// 0 - chi2
// Create task
- gProof->Load(Form("%s/PWG1/AliAnaFwdDetsQA.cxx++g",
+ gProof->Load(Form("%s/PWGPP/AliAnaFwdDetsQA.cxx++g",
gSystem->Getenv("ALICE_ROOT")));
AliAnalysisTask *task = new AliAnaFwdDetsQA("AliAnaFwdDetsQA");
Bool_t debug=kFALSE;
- /*access qa PWG1 output files - saved locally or on grid as specified by the second argument */
+ /*access qa PWGPP output files - saved locally or on grid as specified by the second argument */
char defaultQAoutput[30]="QAresults.root";
if (IsOnGrid) TGrid::Connect("alien://");
void RunTOFqa(const char* plugin_mode="full") {
// macro to run the TOF qa
- gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWG1");
+ gSystem->SetIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD -I$ALICE_ROOT/PWGPP");
//
TString trainName = "TOFqa";
TString analysisMode = "grid"; // "local", "grid", or "proof"
AliPhysicsSelectionTask* physSelTask = AddTaskPhysicsSelection(kFALSE /*MC*/);
// TOF qa task
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/TOF/AddTaskTOFQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA();
tofQA->SelectCollisionCandidates(kTriggerMask);
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
gSystem->Load("libPWG0selectors.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
}
plugin->SetROOTVersion("v5-30-03-1");
plugin->SetAliROOTVersion("v5-02-08-AN");
plugin->AddIncludePath("-I. -I$ROOTSYS/include -I$ALICE_ROOT/include -I$ALICE_ROOT/ITS -I$ALICE_ROOT/TRD");
- plugin->SetAdditionalLibs("libCORRFW.so libTENDER.so libPWG0base.so libPWG0dep.so libPWG0selectors.so libPWG1.so");
+ plugin->SetAdditionalLibs("libCORRFW.so libTENDER.so libPWG0base.so libPWG0dep.so libPWG0selectors.so libPWGPP.so");
// Declare input data to be processed.
plugin->SetGridDataDir(grid_datadir); // specify LHC period
plugin->SetDataPattern(data_pattern); // specify reco pass and AOD set
TFile f("TPCCalibTracksGain.root")
-gSystem->Load("libPWG1.so")
+gSystem->Load("libPWGPP.so")
AliTreeDraw comp
comp.SetTree(dEdx)
Double_t chi2;
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
AliGenInfoMaker *t = new AliGenInfoMaker("galice.root","genTracks.root",0,0);
t->Exec();
}
gSystem->Load("libANALYSISalice.so");
gSystem->Load("libPWG0base.so");
gSystem->Load("libPWG0dep.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
AliRecInfoMaker *t2 = new AliRecInfoMaker("genTracks.root","cmpESDTracks.root","galice.root",0,0);
t2->Exec();
\begin{itemize}
\item PWG0 \textbf{first physics};
-\item PWG1 \textbf{detector performance};
+\item PWGPP \textbf{detector performance};
\item PWG2 \textbf{global event characteristics:} particle multiplicity,
centrality, energy density, nuclear stopping; \textbf{soft physics:} chemical composition (particle and resonance
production, particle ratios and spectra, strangeness enhancement),
gSystem->Load("libPWG0selectors.so");
gSystem->Load("libTENDER.so");
- gSystem->Load("libPWG1.so");
+ gSystem->Load("libPWGPP.so");
gSystem->Load("libCORRFW.so");
gSystem->Load("libPWG2AOD.so");
//____________________________________________//
// 1st Cosmic task
if (doCosmic) {
- TFile::Cp("$ALICE_ROOT/PWG1/cosmic/AliAnalysisTaskCosmic.h",
+ TFile::Cp("$ALICE_ROOT/PWGPP/cosmic/AliAnalysisTaskCosmic.h",
"file:AliAnalysisTaskCosmic.h");
- TFile::Cp("$ALICE_ROOT/PWG1/cosmic/AliAnalysisTaskCosmic.cxx",
+ TFile::Cp("$ALICE_ROOT/PWGPP/cosmic/AliAnalysisTaskCosmic.cxx",
"file:AliAnalysisTaskCosmic.cxx");
gProof->Load("AliAnalysisTaskCosmic.cxx++g");
if (doQASym) {
//____________________________________________//
// QA task for central barrel tracking exploiting symmetries
- TFile::Cp("$ALICE_ROOT/PWG1/AliAnalysisTaskQASym.h",
+ TFile::Cp("$ALICE_ROOT/PWGPP/AliAnalysisTaskQASym.h",
"file:AliAnalysisTaskQASym.h");
- TFile::Cp("$ALICE_ROOT/PWG1/AliAnalysisTaskQASym.cxx",
+ TFile::Cp("$ALICE_ROOT/PWGPP/AliAnalysisTaskQASym.cxx",
"file:AliAnalysisTaskQASym.cxx");
gProof->Load("AliAnalysisTaskQASym.cxx++g");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskQAsym.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
AliAnalysisTaskSE* taskqasym = AddTaskQAsym();
//
// QA task for VZERO
- TFile::Cp("$ALICE_ROOT/PWG1/AliAnaVZEROQA.h",
+ TFile::Cp("$ALICE_ROOT/PWGPP/AliAnaVZEROQA.h",
"file:AliAnaVZEROQA.h");
- TFile::Cp("$ALICE_ROOT/PWG1/AliAnaVZEROQA.cxx",
+ TFile::Cp("$ALICE_ROOT/PWGPP/AliAnaVZEROQA.cxx",
"file:AliAnaVZEROQA.cxx");
gProof->Load("AliAnaVZEROQA.cxx++g");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/PilotTrain/AddTaskVZEROQA.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
AliAnalysisTaskSE* taskvzeroqa = AddTaskVZEROQA(runNumber);
//
// QA task for vertexing
- TFile::Cp("$ALICE_ROOT/PWG1/global/AliAnalysisTaskVertexESD.h",
+ TFile::Cp("$ALICE_ROOT/PWGPP/global/AliAnalysisTaskVertexESD.h",
"file:AliAnalysisTaskVertexESD.h");
- TFile::Cp("$ALICE_ROOT/PWG1/global/AliAnalysisTaskVertexESD.cxx",
+ TFile::Cp("$ALICE_ROOT/PWGPP/global/AliAnalysisTaskVertexESD.cxx",
"file:AliAnalysisTaskVertexESD.cxx");
gProof->Load("AliAnalysisTaskVertexESD.cxx++g");
- gROOT->LoadMacro("$ALICE_ROOT/PWG1/macros/AddTaskVertexESD.C");
+ gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
AliAnalysisTaskSE* taskvertex = AddTaskVertexESD();
}
if (!mgr->InitAnalysis()) return;
// 0. Global tracks\r
// 1. ITS tracks (SA or Pure SA)\r
// 2. TPC only tracks\r
- // Track selection copied from PWG1/AliAnalysisTaskQAsym\r
+ // Track selection copied from PWGPP/AliAnalysisTaskQAsym\r
\r
if(fTrackType==0){\r
//Fill all histograms with global tracks\r