TENDER becomes Tender, removing .so
[u/mrichter/AliRoot.git] / ANALYSIS / macros / QAtrain_duo.C
index b17fc68..54355f2 100644 (file)
 //      -> event_stat_outer.root trending_outer.root 145230_145230_0_132897.stat
 #include "Riostream.h"
 void LoadLibraries();
-void AddAnalysisTasks(const char *); 
+void AddAnalysisTasks(const char *, const char *); 
 void QAmerge(const char *,const char *, Int_t);
+void ProcessEnvironmentVars();
+void SetDoQA(Bool_t &var, Bool_t onoff, const char* name);
+Bool_t CheckEnvS(const char* var,TString& envString);
 
 Int_t iCollisionType = 0; // 0=pp, 1=PbPb
 // Trigger mask.
 
 UInt_t kTriggerInt = AliVEvent::kAnyINT;
-UInt_t kTriggerMuonBarell = AliVEvent::kMUU7;
-UInt_t kTriggerEMC   = AliVEvent::kEMC7 | AliVEvent::kEMCEJE | AliVEvent::kEMCEGA;
+UInt_t kTriggerMuonBarrel = AliVEvent::kMUU7 | AliVEvent::kMuonUnlikeLowPt8 | AliVEvent::kMuonUnlikeLowPt0;
+UInt_t kTriggerEMC   = AliVEvent::kEMC7 | AliVEvent::kEMC8 | AliVEvent::kEMCEJE | AliVEvent::kEMCEGA;
 UInt_t kTriggerHM   = AliVEvent::kHighMult;
 // Main trigger mask used:
 UInt_t kTriggerMask = kTriggerInt;
 
 Int_t runNumbers[5] = {158626};
 
+Bool_t doStatistics   = 1;
 Bool_t doCDBconnect   = 1;
 Bool_t doEventStat    = 1;
-Bool_t doCentrality   = 1;
-Bool_t doQAsym        = 1;
+Bool_t doCentrality   = 0;
+Bool_t doQAsym        = 0;
 Bool_t doVZERO        = 1;   // there is a 2nd file
 Bool_t doVZEROPbPb    = 1; 
 Bool_t doVertex       = 1;
@@ -72,24 +76,38 @@ Bool_t doPIDqa        = 1; //new
 Bool_t doFMD          = 1; // new
 Bool_t doPHOS         = 1; // new
 Bool_t doPHOSTrig     = 1; // new
-Bool_t doEMCAL        = 1;
+Bool_t doEMCAL        = 0;
 Bool_t doFBFqa        = 1; // new - not ported yet to revision
 
+Bool_t doTaskFilteredTree        = 0;      // high pt filter task
+
                // Debug level
 Int_t       debug_level        = 1;        // Debugging
 Int_t       run_number = 0;
 
+
 void QAtrain_duo(const char *suffix="", Int_t run = 0, 
              const char *xmlfile   = "wn.xml",
-             Int_t  stage          = 0) /*0 = QA train, 1...n - merging stage*/
+             Int_t  stage          = 0, /*0 = QA train, 1...n - merging stage*/
+             const char *cdb     = "raw://")
+//             const char *cdb     = "local://$ALICE_ROOT/OCDB")
 {
   run_number = run;
+  TString ss(suffix);
+  ss.ToLower();
+  Bool_t ibarrel = (ss.Contains("barrel"))?kTRUE:kFALSE;
 
-  TGrid::Connect("alien://");
-  if (!gGrid || !gGrid->IsConnected()) {
-    ::Error("QAtrain", "No grid connection");
-    return;
-  }   
+  ProcessEnvironmentVars();
+
+  TString cdbString(cdb);
+  if (cdbString.Contains("raw://"))
+  {
+    TGrid::Connect("alien://");
+    if (!gGrid || !gGrid->IsConnected()) {
+      ::Error("QAtrain", "No grid connection");
+      return;
+    }  
+  }
   // Set temporary merging directory to current one
   gSystem->Setenv("TMPDIR", gSystem->pwd());
   // Set temporary compilation directory to current one
@@ -100,15 +118,19 @@ void QAtrain_duo(const char *suffix="", Int_t run = 0,
   // Create manager
   AliAnalysisManager *mgr  = new AliAnalysisManager("PilotAnalysis", "Production train");
   mgr->SetRunFromPath(run_number);
+  mgr->SetCacheSize(0);
   // Input handler
   AliESDInputHandlerRP *esdHandler = new AliESDInputHandlerRP();
-  esdHandler->SetReadFriends(kTRUE);
-  esdHandler->SetActiveBranches("ESDfriend");
+  if (ibarrel) {
+    esdHandler->SetReadFriends(kTRUE);
+    esdHandler->SetActiveBranches("ESDfriend");
+  }
   mgr->SetInputEventHandler(esdHandler);
   mgr->SetDebugLevel(debug_level);
+  mgr->SetFileInfoLog("fileinfo.log"); 
   
   // AnalysisTasks
-  AddAnalysisTasks(suffix);
+  AddAnalysisTasks(suffix, cdb);
   if (stage>0) {
     QAmerge(suffix, xmlfile, stage);
     return;
@@ -121,7 +143,7 @@ void QAtrain_duo(const char *suffix="", Int_t run = 0,
   if (mgr->InitAnalysis()) {                                                                                                              
     mgr->PrintStatus(); 
     mgr->SetSkipTerminate(kTRUE);
-//    mgr->SetNSysInfo(1);
+ //   mgr->SetNSysInfo(100);
     mgr->StartAnalysis("local", chain);
   }
   timer.Print();
@@ -129,13 +151,14 @@ void QAtrain_duo(const char *suffix="", Int_t run = 0,
 
 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/PWGPP -I$ALICE_ROOT/PWGPP/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 -I$ALICE_ROOT/ANALYSIS");
   gSystem->Load("libANALYSIS");
   gSystem->Load("libANALYSISalice");
+  gSystem->Load("libESDfilter");
   gSystem->Load("libCORRFW");
-  gSystem->Load("libTENDER");
-  gSystem->Load("libPWGPP.so");
-  gSystem->Load("libAliHLTTrigger.so");
+  gSystem->Load("libTender");
+  gSystem->Load("libPWGPP");
+  gSystem->Load("libAliHLTTrigger");
 
   if (doEMCAL || doPHOS || doCALO) {
      gSystem->Load("libEMCALUtils");
@@ -144,6 +167,8 @@ void LoadLibraries()
      gSystem->Load("libPWGGACaloTrackCorrelations");
      gSystem->Load("libPWGGACaloTasks");
      gSystem->Load("libPWGGAPHOSTasks");
+     gSystem->Load("libPWGTools");
+     gSystem->Load("libPWGEMCAL");
      gSystem->Load("libPWGGAEMCALTasks");
   }  
   if(doMUON || doMUONTrig) {
@@ -156,25 +181,35 @@ void LoadLibraries()
   }      
 }
 
-void AddAnalysisTasks(const char *suffix)
+void AddAnalysisTasks(const char *suffix, const char *cdb_location)
 {
   TString ss(suffix);
   ss.ToLower();
   Bool_t ibarrel = (ss.Contains("barrel"))?kTRUE:kFALSE;
+  Bool_t iall = ss.IsNull();
   AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
   mgr->SetCommonFileName(Form("QAresults%s.root",suffix));
   // Statistics task
-  mgr->AddStatisticsTask(kTriggerMask);
+  if (doStatistics) mgr->AddStatisticsTask(kTriggerMask);
+
+  // Clean Geometry: Ruben
+  gROOT->LoadMacro("$ALICE_ROOT/PWGPP/CalibMacros/commonMacros/CleanGeom.C++");
+  CleanGeom* clgmTask = new CleanGeom("cleanGeom");
+  mgr->AddTask(clgmTask);
+  AliAnalysisDataContainer *dummyInp = mgr->GetCommonInputContainer();
+  if (dummyInp) mgr->ConnectInput(clgmTask,0,dummyInp);  
+
   //
   // CDB connection
   //
   if (doCDBconnect) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskCDBconnect.C");
-    AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
+    AliTaskCDBconnect *taskCDB = AddTaskCDBconnect(cdb_location, run_number);    
+//    AliTaskCDBconnect *taskCDB = AddTaskCDBconnect();
     if (!taskCDB) return;
-    AliCDBManager *cdb = AliCDBManager::Instance();
-    cdb->SetDefaultStorage("raw://");
-    taskCDB->SetRunNumber(run_number);
+//    AliCDBManager *cdb = AliCDBManager::Instance();
+//    cdb->SetDefaultStorage(cdb_location);
+//    taskCDB->SetRunNumber(run_number);
   }    
   
   //
@@ -187,22 +222,35 @@ void AddAnalysisTasks(const char *suffix)
       cstatsout->SetFileName(Form("EventStat_temp%s.root", suffix));
   }
   
+   //
+  // PIDResponse(JENS)
+  //
+  if (doPIDResponse && (ibarrel || iall)) {
+    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); 
+    AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
+    PIDResponse->SetUserDataRecoPass(1);
+    PIDResponse->SelectCollisionCandidates(kTriggerMask);
+  }  
+
+
   //
   // Centrality (A. Toia)
   //
   if (doCentrality) {
-     if (!iCollisionType) {
-        printf("Disabling centrality task for p-p\n");
-        doCentrality = kFALSE;
-     } else {           
+//     if (!iCollisionType) {
+//        printf("Disabling centrality task for p-p\n");
+//        doCentrality = kFALSE;
+//     } else {           
         gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskCentrality.C");
         AliCentralitySelectionTask *taskCentrality = AddTaskCentrality();
-     }   
+      AliAnalysisDataContainer *centralityout = (AliAnalysisDataContainer*)mgr->GetOutputs()->FindObject("CentralityStat");
+      centralityout->SetFileName(Form("EventStat_temp%s.root", suffix));
+//     }   
   }   
   
   // Vertexing (A. Dainese)
   // 
-  if (doVertex) {
+  if (doVertex && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskVertexESD.C");
     AliAnalysisTaskVertexESD* taskvertexesd =  AddTaskVertexESD(kFALSE, kTriggerMask);
     taskvertexesd->SelectCollisionCandidates(kTriggerMask);
@@ -210,27 +258,31 @@ void AddAnalysisTasks(const char *suffix)
 
   // TPC QA (E. Sicking)
   //
-  if (doQAsym) {
+  if (doQAsym && (ibarrel || iall)) {
   // offline trigger in AddTask
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskQAsym.C");
-    AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarell);
+    AliAnalysisTaskSE * taskqasim = AddTaskQAsym(0, kTriggerMask, kTriggerHM, kTriggerEMC, kTriggerMuonBarrel);
   }  
   //
   // VZERO QA  (C. Cheshkov)
   //
-  if (doVZERO && ibarrel) {
+  if (doVZERO && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQA.C");
     AliAnalysisTaskSE * taskv0qa = AddTaskVZEROQA(0);
 //  taskv0qa->SelectCollisionCandidates();
+    gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskVZEROQATrig.C");
+    AliAnaVZEROQA *taskv0qatrig = AddTaskVZEROQATrig(0);
+    taskv0qatrig->SelectCollisionCandidates(AliVEvent::kINT8);
+
   }
-  if (doVZEROPbPb && iCollisionType==1) {
+  if (doVZEROPbPb && iCollisionType==0) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/VZERO/AddTaskVZEROPbPb.C");
-    AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(0);
+    AliAnaVZEROPbPb* taskV0PbPb = (AliAnaVZEROPbPb*)AddTaskVZEROPbPb(run_number);
 //    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVLNWU-,CVLN-");
 //    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU,CPBI2,CPBI1WU-,CPBI1-,CVHNWU,CVHN,CVLNWU,CVLN");
 //    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_B2-,CVLNWU_B2-");
 //    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-");
-    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
+//    taskV0PbPb->SetClassesNames("CTRUE-,C0HWU-,CPBI2WU-,CPBI2-,CPBI2WU_B1-,CPBI2_B1-,CPBI1WU-,CPBI1-,CVHNWU-,CVHN-,CVHN_R2-,CVHNWU_R2-,CVLNWU-,CVLN-,CVLN_R1-,CVLN_B2-,CVLNWU_R1-,CVLNWU_B2-,CSEMI_R1-,CSEMIWU_R1-,CCENT_R2-,CCENTWU_R2-");
   }
   //
   // TPC (Jacek Otwinowski & Michael Knichel)
@@ -240,7 +292,7 @@ void AddAnalysisTasks(const char *suffix)
   // Optionally friends information can be switched off by setting the 2st argument 
   // to false
   // Optionally highMult axis can be used by setting the 3st argument to true (for PbPb)
-  if (doTPC && ibarrel) {
+  if (doTPC && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
     AliPerformanceTask *tpcQA = 0;
     if (iCollisionType) {
@@ -254,7 +306,7 @@ void AddAnalysisTasks(const char *suffix)
   }  
 
   // HLT (Alberica Toia)
-  if (doHLT && ibarrel) {
+  if (doHLT && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TPC/macros/AddTaskPerformanceTPCdEdxQA.C");
     AliPerformanceTask *hltQA = AddTaskPerformanceTPCdEdxQA(kFALSE, kTRUE, kFALSE,0,kTRUE);
     hltQA->SelectCollisionCandidates(kTriggerMask);
@@ -262,18 +314,18 @@ void AddAnalysisTasks(const char *suffix)
   //
   // SPD (A. Mastroserio)
   //
-  if (doSPD) {
+  if (doSPD && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskSPDQA.C");
     AliAnalysisTaskSPD* taskspdqa = (AliAnalysisTaskSPD*)AddTaskSPDQA();
     // Request from Annalisa
     if (iCollisionType) taskspdqa->SetHeavyIonMode();
     taskspdqa->SelectCollisionCandidates(kTriggerMask);
-    taskspdqa->SetOCDBInfo(run_number, "raw://");
+    taskspdqa->SetOCDBInfo(run_number, cdb_location);
   }  
   //
   // SDD (F. Prino)
   //
-  if (doSDD) {
+  if (doSDD && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddSDDPoints.C");
     AliAnalysisTaskSE* tasksdd = AddSDDPoints();
     tasksdd->SelectCollisionCandidates(kTriggerMask);
@@ -281,7 +333,7 @@ void AddAnalysisTasks(const char *suffix)
   //
   // SSD dEdx (Marek Chojnacki)
   //
-  if (doSSDdEdx) {
+  if (doSSDdEdx && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskdEdxSSDQA.C");
     AliAnalysisTaskSE* taskssddedx = AddTaskdEdxSSDQA();
     taskssddedx->SelectCollisionCandidates(kTriggerMask);
@@ -290,7 +342,7 @@ void AddAnalysisTasks(const char *suffix)
   //
   // ITS
   //
-  if (doITS) {
+  if (doITS && (ibarrel || iall)) {
   // hardcoded non-zero trigger mask
       gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskPerformanceITS.C");
       AliAnalysisTaskITSTrackingCheck *itsQA = 0;
@@ -309,21 +361,21 @@ void AddAnalysisTasks(const char *suffix)
   //
   // ITS saTracks, align (F.Prino)
   //
-  if (doITSsaTracks) {
+  if (doITSsaTracks && (ibarrel || iall)) {
   // offline trigger in AddTask
      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSsaTracks.C");
      AliAnalysisTaskITSsaTracks *itssaTracks = AddTaskITSsaTracks(kFALSE,kFALSE);
      itssaTracks->SelectCollisionCandidates(kTriggerMask);
   }   
-  if (doITSalign) {
+  if (doITSalign && (ibarrel || iall)) {
   // no offline trigger selection
      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskITSAlign.C");
-     AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2011);
+     AliAnalysisTaskITSAlignQA *itsAlign = AddTaskITSAlign(0,2012);
   }   
   //
   // TRD (Alex Bercuci, M. Fasel) 
   //
-  if(doTRD && ibarrel) {
+  if(doTRD && (ibarrel || iall)) {
   // no offline trigger selection
       gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTrainPerformanceTRD.C");
       // steer individual TRD tasks
@@ -340,7 +392,7 @@ void AddAnalysisTasks(const char *suffix)
   //
   // ZDC (Chiara Oppedisano) 
   //
-  if(doZDC && ibarrel) {
+  if(doZDC && (ibarrel || iall)) {
   // hardcoded kMB trigger mask
      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/ZDC/AddTaskZDCQA.C");
      AliAnalysisTaskSE *taskZDC = AddTaskZDCQA();
@@ -351,15 +403,35 @@ void AddAnalysisTasks(const char *suffix)
   //
 
   if(doCALO) {
+  // - In case of MC analysis, it skips the triggered events wagon (given that
+  //the normal wagon is always suffixed as "default")
+  //- No need to pass the type of data
+  //- No need to specify the year. In principle the year is only needed when
+  //setting the size of some histograms (change in number of SM along the years),
+  //I do not know how to access automatically the run number when the histograms
+  // are created in the UserCreateOutput. By default I set them to the maximum
+  //expected size, but I still let the possibility to check the year.
+
+  //So the way to initialize the task in trunk is now
+
+  //AddTaskCalorimeterQA(Bool_t kSimulation = kFALSE,
+                                   //  const char *suffix="default",
+                                   // TString outputFile = "", 
+                                   //  Int_t year = 2012, 
+                                   //  Bool_t kPrintSettings = kFALSE)
+
+  //So, in principle only the first 2 need to be specified.
+
+  
       gROOT->LoadMacro("$ALICE_ROOT/PWGGA/CaloTrackCorrelations/macros/QA/AddTaskCalorimeterQA.C");
-      AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE);
+      AliAnalysisTaskCaloTrackCorrelation *taskCaloQA = AddTaskCalorimeterQA("default");
       taskCaloQA->SetDebugLevel(0);
       // offline mask set in AddTask to kMB
       taskCaloQA->SelectCollisionCandidates(kTriggerMask);
       // Add a new calo task with EMC1 trigger only
-      taskCaloQA = AddTaskCalorimeterQA("ESD", 2011, kFALSE, kFALSE, "", "EMC7");
+      // taskCaloQA = AddTaskCalorimeterQA("trigEMC");        // for 2011 data, not 2010
+      // taskCaloQA->SelectCollisionCandidates(kTriggerEMC);  // for 2011 data, not 2010
       taskCaloQA->SetDebugLevel(0);
-      taskCaloQA->SelectCollisionCandidates(kTriggerEMC);
   }
 
   //
@@ -370,12 +442,13 @@ void AddAnalysisTasks(const char *suffix)
   // no offline trigger selection
       gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskMTRchamberEfficiency.C");
       AliAnalysisTaskTrigChEff *taskMuonTrig = AddTaskMTRchamberEfficiency();
+//      taskMuonTrig->GetMuonTrackCuts()->SetCustomParamFromRun(160000,2);       
   }
 
   //
   // Impact parameter resolution (xianbao.yuan@pd.infn.it, andrea.dainese@pd.infn.it)
   //
-  if (doImpParRes && ibarrel) {
+  if (doImpParRes && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskImpParRes.C");
     AliAnalysisTaskSE* taskimpparres=0;
     if(iCollisionType==0) {
@@ -391,29 +464,21 @@ void AddAnalysisTasks(const char *suffix)
   if (doMUON) {
   // trigger analysis internal
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/PilotTrain/AddTaskMuonQA.C");
-    AliAnalysisTaskSE* taskmuonqa= AddTaskMuonQA();
+    AliAnalysisTaskMuonQA* taskmuonqa= AddTaskMuonQA();
+//    taskmuonqa->GetTrackCuts()->SetCustomParamFromRun(160000,2);
   }  
   //
   // TOF (Francesca Bellini)
   //
-  if (doTOF && ibarrel) {
+  if (doTOF && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/TOF/AddTaskTOFQA.C");
-    AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA();
+    AliAnalysisTaskTOFqa *tofQA = AddTaskTOFQA(kFALSE);
     tofQA->SelectCollisionCandidates(kTriggerMask);
   } 
-   //
-  // PIDResponse(JENS)
-  //
-  if (doPIDResponse && ibarrel) {
-    gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDResponse.C"); 
-    AliAnalysisTaskPIDResponse *PIDResponse = AddTaskPIDResponse();
-    PIDResponse->SelectCollisionCandidates(kTriggerMask);
-  }  
-
   //
   // PIDqa(JENS)
   //
-  if (doPIDqa && ibarrel) {
+  if (doPIDqa && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/ANALYSIS/macros/AddTaskPIDqa.C");
     AliAnalysisTaskPIDqa *PIDQA = AddTaskPIDqa();
     PIDQA->SelectCollisionCandidates(kTriggerMask);
@@ -422,7 +487,7 @@ void AddAnalysisTasks(const char *suffix)
   //
   // HMPID QA (Giacomo Volpe)
   //
-  if (doHMPID && ibarrel) {
+  if (doHMPID && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/HMPID/AddTaskHmpidQA.C");
     AliAnalysisTaskSE* taskhmpidqa= AddTaskHmpidQA(kFALSE);
       // offline mask set in AddTask to kMB
@@ -431,17 +496,18 @@ void AddAnalysisTasks(const char *suffix)
   
   
   // T0 QA (Alla Mayevskaya)
-  if (doT0 && ibarrel) {
+  if (doT0 && (ibarrel || iall)) {
   // no offline trigger selection
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/T0/AddTaskT0QA.C");
     AliT0AnalysisTaskQA* taskt0qa= AddTaskT0QA();
     taskt0qa->SelectCollisionCandidates(kTriggerMask);
   }      
   // FMD QA (Christian Holm Christiansen)
-  if (doFMD && ibarrel) {
+  if (doFMD && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGLF/FORWARD/analysis2/AddTaskForwardQA.C");
     // Parameters: usemc, usecentrality
-    AliAnalysisTaskSE *forwardQA = (AliAnalysisTaskSE *)AddTaskForwardQA(kFALSE, kFALSE);
+    AliForwardQATask *forwardQA = (AliAnalysisTaskSE *)AddTaskForwardQA(kFALSE, kFALSE);
+    forwardQA->SetDebug(0);
     // No offline trigger config. needed (see #84077)
   }
    //     
@@ -456,7 +522,7 @@ void AddAnalysisTasks(const char *suffix)
     taskPHOSCellQA2->SelectCollisionCandidates(AliVEvent::kPHI7);
     taskPHOSCellQA2->GetCaloCellsQA()->SetClusterEnergyCuts(0.3,0.3,1.0);
     // Pi0 QA fo PbPb
-    if (iCollisionType) {
+    if (iCollisionType == 0) {
       gROOT->LoadMacro("$ALICE_ROOT/PWGGA/PHOSTasks/PHOS_PbPbQA/macros/AddTaskPHOSPbPb.C");
       AliAnalysisTaskPHOSPbPbQA* phosPbPb = AddTaskPHOSPbPbQA(0);
     }
@@ -471,11 +537,12 @@ void AddAnalysisTasks(const char *suffix)
   if (doEMCAL) {
      gROOT->LoadMacro("$ALICE_ROOT/PWGGA/EMCALTasks/macros/AddTaskEMCALTriggerQA.C");
      AliAnalysisTaskEMCALTriggerQA *emctrig = AddTaskEMCALTriggerQA();
+//     emctrig->GetRecoUtils()->SwitchOffBadChannelsRemoval();
   }   
   //     
   // FLOW and BF QA (C.Perez && A.Rodriguez)
   //
-  if (doFBFqa && ibarrel) {
+  if (doFBFqa && (ibarrel || iall)) {
     gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskFBFqa.C");
     AliAnalysisTaskSE *qaFBFMB = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFmb",kFALSE);
     qaFBFMB->SelectCollisionCandidates(AliVEvent::kMB);
@@ -484,6 +551,14 @@ void AddAnalysisTasks(const char *suffix)
     AliAnalysisTaskSE *qaFBFCE = (AliAnalysisTaskSE*) AddTaskFBFqa("qaFBFce",kFALSE);
     qaFBFCE->SelectCollisionCandidates(AliVEvent::kCentral);
   }
+  
+//Jacek
+   if (gSystem->Getenv("QA_TaskFilteredTree")) doTaskFilteredTree=1;
+   if (doTaskFilteredTree) {
+      gROOT->LoadMacro("$ALICE_ROOT/PWGPP/macros/AddTaskFilteredTree.C");
+      AddTaskFilteredTree("FilterEvents_Trees.root");
+   }   
+   
 }
 
 void QAmerge(const char *suffix, const char *dir, Int_t stage)
@@ -492,7 +567,7 @@ void QAmerge(const char *suffix, const char *dir, Int_t stage)
   TStopwatch timer;
   timer.Start();
   TString outputDir = dir;
-  TString outputFiles = Form("QAresults%s.root,EventStat_temp%s.root,RecoQAresults%s.root",suffix,suffix,suffix);
+  TString outputFiles = Form("QAresults%s.root,EventStat_temp%s.root,RecoQAresults%s.root,FilterEvents_trees%s.root",suffix,suffix,suffix);
   TString mergeExcludes = "";
   TObjArray *list = outputFiles.Tokenize(",");
   TIter *iter = new TIter(list);
@@ -508,12 +583,14 @@ void QAmerge(const char *suffix, const char *dir, Int_t stage)
     }
     if (mergeExcludes.Contains(outputFile.Data())) continue;
     merged = AliAnalysisAlien::MergeOutput(outputFile, outputDir, 10, stage);
-    if (!merged && !outputFile.Contains("RecoQAresults")) {
+    if (!merged && !outputFile.Contains("RecoQAresults") && !outputFile.Contains("FilterEvents_trees")) {
        printf("ERROR: Cannot merge %s\n", outputFile.Data());
        return;
     }
   }
   // read the analysis manager from file
+  TString infolog = "fileinfo.log";
+  AliAnalysisAlien::MergeInfo(infolog, dir); 
   if (!outputDir.Contains("Stage")) {
     ofstream out;
     out.open("outputs_valid", ios::out);
@@ -527,6 +604,7 @@ void QAmerge(const char *suffix, const char *dir, Int_t stage)
   mgr->PrintStatus();
   AliLog::SetGlobalLogLevel(AliLog::kError);
   TTree *tree = NULL;
+  gROOT->cd();
   mgr->StartAnalysis("gridterminate", tree);
   if (strlen(suffix)) {
      if (gSystem->Exec(Form("mv trending.root trending%s.root", suffix)))
@@ -539,3 +617,349 @@ void QAmerge(const char *suffix, const char *dir, Int_t stage)
   out.close();
   timer.Print();
 }
+
+void ProcessEnvironmentVars()
+{
+  int var=0;
+  TString envS;
+  //
+  if ( !(envS=gSystem->Getenv("CDBconnect")).IsNull() && CheckEnvS("CDBconnect",envS) ) {
+    doCDBconnect = atoi(envS.Data());
+    printf("Set doCDBconnect=%d according to environment variables\n",doCDBconnect);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("Statistics")).IsNull() && CheckEnvS("Statistics",envS) ) {
+    doStatistics = atoi(envS.Data());
+    printf("Set doStatistics=%d according to environment variables\n",doStatistics);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("EventStat")).IsNull() && CheckEnvS("EventStat",envS) ) {
+    doEventStat = atoi(envS.Data());
+    printf("Set doEventStat=%d according to environment variables\n",doEventStat);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("Centrality")).IsNull() && CheckEnvS("Centrality",envS) ) {
+    doCentrality = atoi(envS.Data());
+    printf("Set doCentrality=%d according to environment variables\n",doCentrality);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("QAsym")).IsNull() && CheckEnvS("QAsym",envS) ) {
+    doQAsym = atoi(envS.Data());
+    printf("Set doQAsym=%d according to environment variables\n",doQAsym);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("VZERO")).IsNull() && CheckEnvS("VZERO",envS) ) {
+    doVZERO = atoi(envS.Data());
+    printf("Set doVZERO=%d according to environment variables\n",doVZERO);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("VZEROPbPb")).IsNull() && CheckEnvS("VZEROPbPb",envS) ) {
+    doVZEROPbPb = atoi(envS.Data());
+    printf("Set doVZEROPbPb=%d according to environment variables\n",doVZEROPbPb);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("Vertex")).IsNull() && CheckEnvS("Vertex",envS) ) {
+    doVertex = atoi(envS.Data());
+    printf("Set doVertex=%d according to environment variables\n",doVertex);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("SPD")).IsNull() && CheckEnvS("SPD",envS) ) {
+    doSPD = atoi(envS.Data());
+    printf("Set doSPD=%d according to environment variables\n",doSPD);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("TPC")).IsNull() && CheckEnvS("TPC",envS) ) {
+    doTPC = atoi(envS.Data());
+    printf("Set doTPC=%d according to environment variables\n",doTPC);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("HLT")).IsNull() && CheckEnvS("HLT",envS) ) {
+    doHLT = atoi(envS.Data());
+    printf("Set doHLT=%d according to environment variables\n",doHLT);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("SDD")).IsNull() && CheckEnvS("SDD",envS) ) {
+    doSDD = atoi(envS.Data());
+    printf("Set doSDD=%d according to environment variables\n",doSDD);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("SSDdEdx")).IsNull() && CheckEnvS("SSDdEdx",envS) ) {
+    doSSDdEdx = atoi(envS.Data());
+    printf("Set doSSDdEdx=%d according to environment variables\n",doSSDdEdx);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("TRD")).IsNull() && CheckEnvS("TRD",envS) ) {
+    doTRD = atoi(envS.Data());
+    printf("Set doTRD=%d according to environment variables\n",doTRD);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("ITS")).IsNull() && CheckEnvS("ITS",envS) ) {
+    doITS = atoi(envS.Data());
+    printf("Set doITS=%d according to environment variables\n",doITS);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("ITSsaTracks")).IsNull() && CheckEnvS("ITSsaTracks",envS) ) {
+    doITSsaTracks = atoi(envS.Data());
+    printf("Set doITSsaTracks=%d according to environment variables\n",doITSsaTracks);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("ITSalign")).IsNull() && CheckEnvS("ITSalign",envS) ) {
+    doITSalign = atoi(envS.Data());
+    printf("Set doITSalign=%d according to environment variables\n",doITSalign);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("CALO")).IsNull() && CheckEnvS("CALO",envS) ) {
+    doCALO = atoi(envS.Data());
+    printf("Set doCALO=%d according to environment variables\n",doCALO);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("MUONTrig")).IsNull() && CheckEnvS("MUONTrig",envS) ) {
+    doMUONTrig = atoi(envS.Data());
+    printf("Set doMUONTrig=%d according to environment variables\n",doMUONTrig);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("ImpParRes")).IsNull() && CheckEnvS("ImpParRes",envS) ) {
+    doImpParRes = atoi(envS.Data());
+    printf("Set doImpParRes=%d according to environment variables\n",doImpParRes);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("MUON")).IsNull() && CheckEnvS("MUON",envS) ) {
+    doMUON = atoi(envS.Data());
+    printf("Set doMUON=%d according to environment variables\n",doMUON);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("TOF")).IsNull() && CheckEnvS("TOF",envS) ) {
+    doTOF = atoi(envS.Data());
+    printf("Set doTOF=%d according to environment variables\n",doTOF);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("HMPID")).IsNull() && CheckEnvS("HMPID",envS) ) {
+    doHMPID = atoi(envS.Data());
+    printf("Set doHMPID=%d according to environment variables\n",doHMPID);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("T0")).IsNull() && CheckEnvS("T0",envS) ) {
+    doT0 = atoi(envS.Data());
+    printf("Set doT0=%d according to environment variables\n",doT0);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("ZDC")).IsNull() && CheckEnvS("ZDC",envS) ) {
+    doZDC = atoi(envS.Data());
+    printf("Set doZDC=%d according to environment variables\n",doZDC);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("PIDResponse")).IsNull() && CheckEnvS("PIDResponse",envS) ) {
+    doPIDResponse = atoi(envS.Data());
+    printf("Set doPIDResponse=%d according to environment variables\n",doPIDResponse);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("PIDqa")).IsNull() && CheckEnvS("PIDqa",envS) ) {
+    doPIDqa = atoi(envS.Data());
+    printf("Set doPIDqa=%d according to environment variables\n",doPIDqa);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("FMD")).IsNull() && CheckEnvS("FMD",envS) ) {
+    doFMD = atoi(envS.Data());
+    printf("Set doFMD=%d according to environment variables\n",doFMD);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("PHOS")).IsNull() && CheckEnvS("PHOS",envS) ) {
+    doPHOS = atoi(envS.Data());
+    printf("Set doPHOS=%d according to environment variables\n",doPHOS);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("PHOSTrig")).IsNull() && CheckEnvS("PHOSTrig",envS) ) {
+    doPHOSTrig = atoi(envS.Data());
+    printf("Set doPHOSTrig=%d according to environment variables\n",doPHOSTrig);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("EMCAL")).IsNull() && CheckEnvS("EMCAL",envS) ) {
+    doEMCAL = atoi(envS.Data());
+    printf("Set doEMCAL=%d according to environment variables\n",doEMCAL);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("FBFqa")).IsNull() && CheckEnvS("FBFqa",envS) ) {
+    doFBFqa = atoi(envS.Data());
+    printf("Set doFBFqa=%d according to environment variables\n",doFBFqa);
+  }
+  //
+  if ( !(envS=gSystem->Getenv("TaskFilteredTree")).IsNull() && CheckEnvS("TaskFilteredTree",envS) ) {
+    doTaskFilteredTree = atoi(envS.Data());
+    printf("Set doTaskFilteredTree=%d according to environment variables\n",doTaskFilteredTree);
+  }
+  //-----------------------------------------------------------  
+  // combinations
+  if ( !(envS=gSystem->Getenv("QAGROUP")).IsNull() ) {
+    int qaGRP = atoi(envS.Data());
+    switch (qaGRP) {
+    case 0: 
+      SetDoQA(doStatistics,  1, "Statistics");
+      SetDoQA(doVZERO,       1, "VZERO");
+      SetDoQA(doVZEROPbPb,   1, "VZEROPbPb");
+      SetDoQA(doVertex,      1, "Vertex");
+      SetDoQA(doSPD,         1, "SPD");
+      SetDoQA(doTPC,         0, "TPC");
+      SetDoQA(doHLT,         0, "HLT");
+      SetDoQA(doSDD,         0, "SDD");
+      SetDoQA(doSSDdEdx,     0, "SSDdEdx");
+      SetDoQA(doTRD,         1, "TRD");
+      SetDoQA(doITS,         0, "ITS");
+      SetDoQA(doITSsaTracks, 0, "ITSsaTracks");
+      SetDoQA(doITSalign,    0, "ITSalign");
+      SetDoQA(doCALO ,       1, "CALO");
+      SetDoQA(doMUONTrig,    0, "MUONTrig");
+      SetDoQA(doImpParRes,   1, "ImpParRes");
+      SetDoQA(doMUON,        0, "MUON");
+      SetDoQA(doTOF,         0, "TOF");
+      SetDoQA(doHMPID,       1, "HMPID");
+      SetDoQA(doT0,          1, "T0");
+      SetDoQA(doZDC,         1, "ZDC");
+      //      SetDoQA(doPIDResponse, 1, "PIDResponse");
+      SetDoQA(doPIDqa,       1, "PIDqa");
+      SetDoQA(doFMD,         1, "FMD");
+      SetDoQA(doPHOS,        1, "PHOS");
+      SetDoQA(doPHOSTrig,    1, "PHOSTrig");
+      SetDoQA(doEMCAL,       0, "EMCAL");
+      SetDoQA(doFBFqa,       1, "FBFqa");
+      break;
+    case 1: 
+      SetDoQA(doStatistics,  0, "Statistics");
+      SetDoQA(doVZERO,       0, "VZERO");
+      SetDoQA(doVZEROPbPb,   0, "VZEROPbPb");
+      SetDoQA(doVertex,      0, "Vertex");
+      SetDoQA(doSPD,         0, "SPD");
+      SetDoQA(doTPC,         1, "TPC");
+      SetDoQA(doHLT,         1, "HLT");
+      SetDoQA(doSDD,         0, "SDD");
+      SetDoQA(doSSDdEdx,     0, "SSDdEdx");
+      SetDoQA(doTRD,         0, "TRD");
+      SetDoQA(doITS,         0, "ITS");
+      SetDoQA(doITSsaTracks, 0, "ITSsaTracks");
+      SetDoQA(doITSalign,    0, "ITSalign");
+      SetDoQA(doCALO ,       0, "CALO");
+      SetDoQA(doMUONTrig,    0, "MUONTrig");
+      SetDoQA(doImpParRes,   0, "ImpParRes");
+      SetDoQA(doMUON,        0, "MUON");
+      SetDoQA(doTOF,         0, "TOF");
+      SetDoQA(doHMPID,       0, "HMPID");
+      SetDoQA(doT0,          0, "T0");
+      SetDoQA(doZDC,         0, "ZDC");
+      //      SetDoQA(doPIDResponse, 0, "PIDResponse");
+      SetDoQA(doPIDqa,       0, "PIDqa");
+      SetDoQA(doFMD,         0, "FMD");
+      SetDoQA(doPHOS,        0, "PHOS");
+      SetDoQA(doPHOSTrig,    0, "PHOSTrig");
+      SetDoQA(doEMCAL,       0, "EMCAL");
+      SetDoQA(doFBFqa,       0, "FBFqa");
+      break;
+    case 2: 
+      SetDoQA(doStatistics,  0, "Statistics");
+      SetDoQA(doVZERO,       0, "VZERO");
+      SetDoQA(doVZEROPbPb,   0, "VZEROPbPb");
+      SetDoQA(doVertex,      0, "Vertex");
+      SetDoQA(doSPD,         0, "SPD");
+      SetDoQA(doTPC,         0, "TPC");
+      SetDoQA(doHLT,         0, "HLT");
+      SetDoQA(doSDD,         0, "SDD");
+      SetDoQA(doSSDdEdx,     0, "SSDdEdx");
+      SetDoQA(doTRD,         0, "TRD");
+      SetDoQA(doITS,         0, "ITS");
+      SetDoQA(doITSsaTracks, 1, "ITSsaTracks");
+      SetDoQA(doITSalign,    1, "ITSalign");
+      SetDoQA(doCALO ,       0, "CALO");
+      SetDoQA(doMUONTrig,    0, "MUONTrig");
+      SetDoQA(doImpParRes,   0, "ImpParRes");
+      SetDoQA(doMUON,        0, "MUON");
+      SetDoQA(doTOF,         0, "TOF");
+      SetDoQA(doHMPID,       0, "HMPID");
+      SetDoQA(doT0,          0, "T0");
+      SetDoQA(doZDC,         0, "ZDC");
+      //      SetDoQA(doPIDResponse, 0, "PIDResponse");
+      SetDoQA(doPIDqa,       0, "PIDqa");
+      SetDoQA(doFMD,         0, "FMD");
+      SetDoQA(doPHOS,        0, "PHOS");
+      SetDoQA(doPHOSTrig,    0, "PHOSTrig");
+      SetDoQA(doEMCAL,       0, "EMCAL");
+      SetDoQA(doFBFqa,       0, "FBFqa");
+      break;
+    case 3: 
+      SetDoQA(doStatistics,  0, "Statistics");
+      SetDoQA(doVZERO,       0, "VZERO");
+      SetDoQA(doVZEROPbPb,   0, "VZEROPbPb");
+      SetDoQA(doVertex,      0, "Vertex");
+      SetDoQA(doSPD,         0, "SPD");
+      SetDoQA(doTPC,         0, "TPC");
+      SetDoQA(doHLT,         0, "HLT");
+      SetDoQA(doSDD,         1, "SDD");
+      SetDoQA(doSSDdEdx,     1, "SSDdEdx");
+      SetDoQA(doTRD,         0, "TRD");
+      SetDoQA(doITS,         1, "ITS");
+      SetDoQA(doITSsaTracks, 0, "ITSsaTracks");
+      SetDoQA(doITSalign,    0, "ITSalign");
+      SetDoQA(doCALO ,       0, "CALO");
+      SetDoQA(doMUONTrig,    0, "MUONTrig");
+      SetDoQA(doImpParRes,   0, "ImpParRes");
+      SetDoQA(doMUON,        0, "MUON");
+      SetDoQA(doTOF,         1, "TOF");
+      SetDoQA(doHMPID,       0, "HMPID");
+      SetDoQA(doT0,          0, "T0");
+      SetDoQA(doZDC,         0, "ZDC");
+      //      SetDoQA(doPIDResponse, 0, "PIDResponse");
+      SetDoQA(doPIDqa,       0, "PIDqa");
+      SetDoQA(doFMD,         0, "FMD");
+      SetDoQA(doPHOS,        0, "PHOS");
+      SetDoQA(doPHOSTrig,    0, "PHOSTrig");
+      SetDoQA(doEMCAL,       0, "EMCAL");
+      SetDoQA(doFBFqa,       0, "FBFqa");
+      break;
+    case 4: 
+      SetDoQA(doStatistics,  0, "Statistics");
+      SetDoQA(doVZERO,       0, "VZERO");
+      SetDoQA(doVZEROPbPb,   0, "VZEROPbPb");
+      SetDoQA(doVertex,      0, "Vertex");
+      SetDoQA(doSPD,         0, "SPD");
+      SetDoQA(doTPC,         0, "TPC");
+      SetDoQA(doHLT,         0, "HLT");
+      SetDoQA(doSDD,         0, "SDD");
+      SetDoQA(doSSDdEdx,     0, "SSDdEdx");
+      SetDoQA(doTRD,         0, "TRD");
+      SetDoQA(doITS,         0, "ITS");
+      SetDoQA(doITSsaTracks, 0, "ITSsaTracks");
+      SetDoQA(doITSalign,    0, "ITSalign");
+      SetDoQA(doCALO ,       0, "CALO");
+      SetDoQA(doMUONTrig,    1, "MUONTrig");
+      SetDoQA(doImpParRes,   0, "ImpParRes");
+      SetDoQA(doMUON,        1, "MUON");
+      SetDoQA(doTOF,         0, "TOF");
+      SetDoQA(doHMPID,       0, "HMPID");
+      SetDoQA(doT0,          0, "T0");
+      SetDoQA(doZDC,         0, "ZDC");
+      //      SetDoQA(doPIDResponse, 0, "PIDResponse");
+      SetDoQA(doPIDqa,       0, "PIDqa");
+      SetDoQA(doFMD,         0, "FMD");
+      SetDoQA(doPHOS,        0, "PHOS");
+      SetDoQA(doPHOSTrig,    0, "PHOSTrig");
+      SetDoQA(doEMCAL,       1, "EMCAL");
+      SetDoQA(doFBFqa,       0, "FBFqa");
+      break;
+    };
+
+    printf("Set doTaskFilteredTree=%d according to environment variables\n",doTaskFilteredTree);
+  }
+
+
+}
+
+void SetDoQA(Bool_t& var, Bool_t onoff, const char* name)
+{
+  // set to ON only if previous value is not off
+  if (var) var = onoff;
+  if (name) printf("Set %-15s to %s\n",name,var ? "ON":"OFF");
+}
+
+Bool_t CheckEnvS(const char* var,TString& envString)
+{
+  if (envString=="0" || envString=="1") return kTRUE;
+  else printf("Ignoring wrong value %s for environment variable %s\n",envString.Data(),var);
+  return kFALSE;
+}