DataQuality/DataQualityConfigurations/config/HLT/HLTjet/heavyions_run.config

@@ -77,6 +77,8 @@ output top_level {
 
       output SHIFTER {
 	output HLT {
+	  output a4ionemsubjesFS {
+	  }	
 	  output j85_ion_L1TE50 {
 	  }
 	  output j85_ion_L1J20 {
@@ -85,6 +87,8 @@ output top_level {
 	output L1 {
 	  output L1_J20 {
 	  }
+	  output L1_J30 {
+	  }
 	  output L1_TE50 {
  	  }
 	} ## End L1
@@ -1234,53 +1238,53 @@ dir HLT {
         hist HLTJet_n@Shifter {
           display = LogY
           algorithm = HLTjet_KolmogorovTest_MaxDist
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
           description = Red means: mean of the histogram different from reference. NJet plot: this plot should be close to the reference. Red can be due to: 1) Low statistics wrt reference. 2) Current bunch spacing different from reference. 3) Strange shape. i.e. bumps at high multiplicity.
       	}
       	hist HLTJet_Et@Shifter {
           display = LogY
           algorithm = HLTjet_KolmogorovTest_MaxDist
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
           description = Red means: mean of the histogram different from reference. Et plot: This plot should be close to the reference. Red can be due to: 1) The histogram threshold is not the same as HLT threshold. 2) Slope of the histogram significantly different from reference. 3) Strange shape, i.e. bumps at high Et.
       	}
       	hist HLTJet_eta@Shifter {
           algorithm = HLTjet_KolmogorovTest_MaxDist
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
           description = Red means: mean of the histogram different from reference. Eta plot: this plot should be symmetrical. Red can be due to: 1) Distribution not simmetric. 2) Histogram significantly different from reference.
       	}
       	hist HLTJet_phi@Shifter {
           algorithm = HLTjet_KolmogorovTest_MaxDist
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
           description = Red means: mean of the histogram different from reference. Phi plot: this plot should be symmetrical and flat. Red can be due to: 1) Distribution not simmetric. 2) Histogram significantly different from reference. 3) Hotspots. i.e bins higher than average.
       	}
       	hist HLTJet_phi_vs_eta@Shifter {
           algorithm = HLTjet_Bins_Diff_FromAvg
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
           description = Red means: A critical number (1) bins is greater than average. Eta vs Phi plot: this distribution should not show hotspots. Check that there is sufficient statistics to claim an hotspot.
       	}
        	hist HLTJet_E_vs_eta@Shifter {
           algorithm = HLTjet_Histogram_Not_Empty_with_Ref&GatherData
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
       	}
        	hist HLTJet_E_vs_phi@Shifter {
           algorithm = HLTjet_Histogram_Not_Empty_with_Ref&GatherData
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
       	}
       	hist HLTJet_phi_vs_eta_LAr@Shifter {
           algorithm = HLTjet_Histogram_Not_Empty_with_Ref&GatherData
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
       	}	  	
 	hist HLTJet_emfrac@Shifter {
           algorithm = HLTjet_KolmogorovTest_MaxDist
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
       	}
 	hist HLTJet_hecfrac@Shifter {
           algorithm = HLTjet_KolmogorovTest_MaxDist
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
       	}
 	hist HLTSigma_vs_LB@Shifter {
           algorithm = HLTjet_Histogram_Not_Empty_with_Ref&GatherData
-          output = HLT/TRJET/SHIFTER/HLT/j85_ion_TE50
+          output = HLT/TRJET/SHIFTER/HLT/j85_ion_L1TE50
       	}
       } ## End j85_ion_TE50
       dir j85_ion_L1J20 {

DataQuality/DataQualityUtils/python/pix_defect.py

@@ -16,6 +16,7 @@ def find_standby(nlayer, hhits, lb_max, standby_lb):
           start = 0
           start_lb = 0
           end_lb = 0
+
           nbin = hhits[i].GetNbinsX()
 
           start_lb = 0
@@ -44,10 +45,12 @@ def find_standby(nlayer, hhits, lb_max, standby_lb):
 
 
 def find_notready(nlayer, hist, pct_low, pct_high, notready_lb):
+
      for i in range(0, nlayer):
           start = 0
           start_lb = 0
           end_lb = 0
+
           nbin = hist[i].GetNbinsX()
           if i == 2:
                for j in range(1, nbin-1):
@@ -144,6 +147,7 @@ def execute(run, sfile, lb_max):
 
      sdisabled = []
      sdisabled.append("InnerDetector/Pixel/PIXIBL/_Experts/DisableAndErrorsLB/DisabledAndSyncErrorsModules_per_lumi_IBL2D_byPostProcess")
+     #sdisabled.append("InnerDetector/Pixel/PIXIBL/DisableAndErrorsLB/DisabledAndSyncErrorsModules_per_lumi_IBL_byPostProcess")
      sdisabled.append("InnerDetector/Pixel/PIX0/DisableAndErrorsLB/DisabledAndSyncErrorsModules_per_lumi_B0_byPostProcess")
      sdisabled.append("InnerDetector/Pixel/PIX1/DisableAndErrorsLB/DisabledAndSyncErrorsModules_per_lumi_B1_byPostProcess")
      sdisabled.append("InnerDetector/Pixel/PIX2/DisableAndErrorsLB/DisabledAndSyncErrorsModules_per_lumi_B2_byPostProcess")
@@ -153,23 +157,36 @@ def execute(run, sfile, lb_max):
      nlayer = 6
      hhits = []
      hdisabled = []
+     fexist_hhits = True
+     fexist_hdisabled = True
      for i in range(0, nlayer):
+          if not file.Get(shits[i]):
+               fexist_hhits = False
+               continue
+ 
+          if not file.Get(sdisabled[i]):
+               fexist_hdisabled = False
+               continue
+
           hhits.append(file.Get(shits[i]))
           hdisabled.append(file.Get(sdisabled[i]))
 
      standby_lb = []
-     find_standby(nlayer, hhits, lb_max, standby_lb)
+     if fexist_hhits == True:
+          find_standby(nlayer, hhits, lb_max, standby_lb)
 
      notready5to7pct_lb = []
      notready7to10pct_lb = []
      notready10to20pct_lb = []
      notready20to30pct_lb = []
      notready_gt30pct_lb = []
-     find_notready(nlayer, hdisabled, 0.05, 0.07, notready5to7pct_lb)
-     find_notready(nlayer, hdisabled, 0.07, 0.1, notready7to10pct_lb)
-     find_notready(nlayer, hdisabled, 0.1, 0.2, notready10to20pct_lb)
-     find_notready(nlayer, hdisabled, 0.2, 0.3, notready20to30pct_lb)
-     find_notready(nlayer, hdisabled, 0.3, 1., notready_gt30pct_lb)
+
+     if fexist_hhits == True and fexist_hdisabled == True:
+          find_notready(nlayer, hdisabled, 0.05, 0.07, notready5to7pct_lb)
+          find_notready(nlayer, hdisabled, 0.07, 0.1, notready7to10pct_lb)
+          find_notready(nlayer, hdisabled, 0.1, 0.2, notready10to20pct_lb)
+          find_notready(nlayer, hdisabled, 0.2, 0.3, notready20to30pct_lb)
+          find_notready(nlayer, hdisabled, 0.3, 1., notready_gt30pct_lb)
 
      #print_def("standby", standby_lb)
      #user = "atlpixdq"

Event/xAOD/xAODPFlow/Root/PFO_v1.cxx

@@ -363,6 +363,21 @@ namespace xAOD {
     case PFODetails::PFOAttributes::eflowRec_LAYERENERGY_MINIFCAL1:
     case PFODetails::PFOAttributes::eflowRec_LAYERENERGY_MINIFCAL2:
     case PFODetails::PFOAttributes::eflowRec_LAYERENERGY_MINIFCAL3:
+    case PFODetails::PFOAttributes::eflowRec_ENERGY_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_ETA_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_PHI_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_SECOND_R_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_CENTER_LAMBDA_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_FIRST_ENG_DENS_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_ENG_FRAC_MAX_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_ISOLATION_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_ENG_BAD_CELLS_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_N_BAD_CELLS_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_BADLARQ_FRAC_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_ENG_POS_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_SIGNIFICANCE_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_AVG_LAR_Q_DigiHSTruth:
+    case PFODetails::PFOAttributes::eflowRec_AVG_TILE_Q_DigiHSTruth:
       return true;
     default:
       return false;
@@ -513,6 +528,81 @@ namespace xAOD {
       myAttribute = xAOD::PFODetails::eflowRec_EM_PROBABILITY;
       return true;
     }    
+
+
+    else if (momentType ==  xAOD::CaloCluster::ENERGY_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_ENERGY_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::PHI_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_PHI_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::ETA_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_ETA_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::FIRST_ENG_DENS_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_FIRST_ENG_DENS_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::CENTER_LAMBDA_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_CENTER_LAMBDA_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::SECOND_R_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_SECOND_R_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::SECOND_LAMBDA_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_SECOND_LAMBDA_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::ISOLATION_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_ISOLATION_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::ENG_FRAC_MAX_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_ENG_FRAC_MAX_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::ENG_BAD_CELLS_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_ENG_BAD_CELLS_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::N_BAD_CELLS_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_N_BAD_CELLS_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::BADLARQ_FRAC_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_BADLARQ_FRAC_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::ENG_POS_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_ENG_POS_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::SIGNIFICANCE_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_SIGNIFICANCE_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::CELL_SIGNIFICANCE_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_CELL_SIGNIFICANCE_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::CELL_SIG_SAMPLING_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_CELL_SIG_SAMPLING_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::AVG_LAR_Q_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_AVG_LAR_Q_DigiHSTruth;
+      return true;
+    }
+    else if (momentType ==  xAOD::CaloCluster::AVG_TILE_Q_DigiHSTruth) {
+      myAttribute = xAOD::PFODetails::eflowRec_AVG_TILE_Q_DigiHSTruth;
+      return true;
+    }
+
     else return false;
 
   }

Event/xAOD/xAODPFlow/xAODPFlow/PFODefs.h

@@ -87,6 +87,25 @@ namespace PFODetails
     eflowRec_LAYERENERGY_MINIFCAL2,
     eflowRec_LAYERENERGY_MINIFCAL3,
     eflowRec_EM_PROBABILITY,
+    /* These are all of the DigiTruth attributes */
+    eflowRec_ENERGY_DigiHSTruth,
+    eflowRec_ETA_DigiHSTruth,
+    eflowRec_PHI_DigiHSTruth,
+    eflowRec_SECOND_R_DigiHSTruth,
+    eflowRec_FIRST_ENG_DENS_DigiHSTruth,
+    eflowRec_CENTER_LAMBDA_DigiHSTruth,
+    eflowRec_SECOND_LAMBDA_DigiHSTruth,
+    eflowRec_ISOLATION_DigiHSTruth,
+    eflowRec_ENG_FRAC_MAX_DigiHSTruth,
+    eflowRec_ENG_BAD_CELLS_DigiHSTruth,
+    eflowRec_N_BAD_CELLS_DigiHSTruth,
+    eflowRec_BADLARQ_FRAC_DigiHSTruth,
+    eflowRec_ENG_POS_DigiHSTruth,
+    eflowRec_SIGNIFICANCE_DigiHSTruth,
+    eflowRec_CELL_SIGNIFICANCE_DigiHSTruth,
+    eflowRec_CELL_SIG_SAMPLING_DigiHSTruth,
+    eflowRec_AVG_LAR_Q_DigiHSTruth,
+    eflowRec_AVG_TILE_Q_DigiHSTruth,
     /** These variables belong to the cell-based particle flow algorithm */
     cellBased_FIRST_ETA = 400, 
     cellBased_SECOND_R, 
@@ -133,7 +152,7 @@ namespace PFODetails
     tauShots_mergedScore, 
     tauShots_signalScore, 
     tauShots_nPhotons,
-    tauShots_seedHash
+    tauShots_seedHash,
   };
 
   /** This enum is used to label the associated particles to the PFO object */

Event/xAOD/xAODPFlow/xAODPFlow/versions/PFOAttributesAccessor_v1.h

@@ -136,6 +136,22 @@ namespace xAOD{
 	DEFINE_PFO_ACCESSOR(tauShots_signalScore); 
 	DEFINE_PFO_ACCESSOR(tauShots_nPhotons); 
 	DEFINE_PFO_ACCESSOR(tauShots_seedHash);
+  DEFINE_PFO_ACCESSOR(eflowRec_ENERGY_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_ETA_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_PHI_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_FIRST_ENG_DENS_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_CENTER_LAMBDA_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_SECOND_R_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_SECOND_LAMBDA_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_ISOLATION_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_ENG_FRAC_MAX_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_ENG_BAD_CELLS_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_N_BAD_CELLS_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_BADLARQ_FRAC_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_ENG_POS_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_SIGNIFICANCE_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_AVG_LAR_Q_DigiHSTruth);
+  DEFINE_PFO_ACCESSOR(eflowRec_AVG_TILE_Q_DigiHSTruth);
 	default:
 	  std::cerr << "xAOD::PFO_v1 ERROR Unknown float/double variable (" << static_cast<int>(variable) << ") requested" << std::endl;
 	  return 0;

ForwardDetectors/ZDC/ZdcAnalysis/Root/ZdcAnalysisTool.cxx

@@ -380,9 +380,9 @@ namespace ZDC
     //
     zdcDataAnalyzer->SetPeak2ndDerivMinTolerances(2);
 
-    // We alwyas disable the 12EM (sideC) module which was not present (LHCf)
+    // We do not disable the 12EM (sideC) in 2018
     //
-    zdcDataAnalyzer->DisableModule(0,0);
+    //zdcDataAnalyzer->DisableModule(0,0);
 
     zdcDataAnalyzer->SetADCOverUnderflowValues(HGOverFlowADC, HGUnderFlowADC, LGOverFlowADC);
     zdcDataAnalyzer->SetTauT0Values(fixTau1Arr, fixTau2Arr, tau1Arr, tau2Arr, t0, t0);

HLT/Trigger/TrigMonitoring/TrigOnlineMonitor/src/TrigL1TopoWriteValData.cxx

@@ -20,6 +20,9 @@ TrigL1TopoWriteValData::TrigL1TopoWriteValData(const std::string& name, ISvcLoca
   declareProperty("SimTopoCTPLocation",
                   m_simTopoCTPLocation = LVL1::DEFAULT_L1TopoCTPLocation,
                   "StoreGate key of simulated topo decision output for CTP, defaults to default output key of L1TopoSimulation");
+  declareProperty("SimTopoOverflowCTPLocation", 
+		  m_simTopoOverflowCTPLocation = LVL1::DEFAULT_L1TopoOverflowCTPLocation,
+		  "StoreGate key of simulated topo overflow output for CTP" );
   declareProperty("HLTResultName",
                   m_HltResultName = "HLTResult_HLT",
                   "StoreGate key of HLT result" );
@@ -29,6 +32,7 @@ StatusCode TrigL1TopoWriteValData::initialize(){
   ATH_MSG_INFO ("initialize");
   ATH_MSG_DEBUG ("Properties:" );
   ATH_MSG_DEBUG ("SimTopoCTPLocation : "<<m_simTopoCTPLocation );
+  ATH_MSG_DEBUG ("SimTopoOverflowCTPLocation : "<<m_simTopoOverflowCTPLocation );
   ATH_MSG_DEBUG ("HLTResultName : "<<m_HltResultName );
   return StatusCode::SUCCESS;
 }
@@ -55,7 +59,8 @@ StatusCode TrigL1TopoWriteValData::finalize() {
 //----------------------------------------------------------
 StatusCode TrigL1TopoWriteValData::doWriteValData(){
   ATH_MSG_DEBUG( "doWriteValData" );
-
+  
+  int num_words = 4;
   // Retrieve HLTResult
   DataHandle<HLT::HLTResult> hltResult; ///! HLTResult object
   if ( ! evtStore()->transientContains<HLT::HLTResult>(m_HltResultName.value()) ) {
@@ -80,13 +85,33 @@ StatusCode TrigL1TopoWriteValData::doWriteValData(){
     }
   }
 
+  // Retrieve L1Topo CTP simulated overflows if present
+  const DataHandle< LVL1::FrontPanelCTP > simTopoOverflowCTP; ///! simulated overflow output
+  if ( ! evtStore()->contains<LVL1::FrontPanelCTP>(m_simTopoOverflowCTPLocation.value()) ){
+    ATH_MSG_INFO("Could not find LVL1::FrontPanelCTP with key " << m_simTopoOverflowCTPLocation.value() << " in SG. No simulated overflow bits" );
+  } else {
+    CHECK_RECOVERABLE( evtStore()->retrieve(simTopoOverflowCTP,m_simTopoOverflowCTPLocation.value()) );
+    if (!simTopoOverflowCTP){
+      ATH_MSG_INFO( "Retrieve of LVL1::FrontPanelCTP sim overflows failed. No sim overflow data written to HLTResult" );
+    } else {
+      num_words = 8;
+    }
+  }
+
   // Write the L1Topo simulation data into the HLTResult
-  hltResult->getExtraData().anonymous.push_back( 4 );                         // number of words to be written
+  hltResult->getExtraData().anonymous.push_back( num_words );                         // number of words to be written
   hltResult->getExtraData().anonymous.push_back( simTopoCTP->cableWord1(0) ); // L1Topo simulation words
   hltResult->getExtraData().anonymous.push_back( simTopoCTP->cableWord1(1) );
   hltResult->getExtraData().anonymous.push_back( simTopoCTP->cableWord2(0) );
   hltResult->getExtraData().anonymous.push_back( simTopoCTP->cableWord2(1) );
 
+  if ( num_words == 8 ) {
+    hltResult->getExtraData().anonymous.push_back( simTopoOverflowCTP->cableWord1(0) );// L1Topo simulated overflow words
+    hltResult->getExtraData().anonymous.push_back( simTopoOverflowCTP->cableWord1(1) );
+    hltResult->getExtraData().anonymous.push_back( simTopoOverflowCTP->cableWord2(0) );
+    hltResult->getExtraData().anonymous.push_back( simTopoOverflowCTP->cableWord2(1) );
+  }
+
   return StatusCode::SUCCESS;
 }
 

HLT/Trigger/TrigMonitoring/TrigOnlineMonitor/src/TrigL1TopoWriteValData.h

@@ -29,6 +29,7 @@ class TrigL1TopoWriteValData:public AthAlgorithm {
  private:
   StatusCode doWriteValData();
   StringProperty m_simTopoCTPLocation;
+  StringProperty m_simTopoOverflowCTPLocation;
   StringProperty m_HltResultName;
 };
 

PhysicsAnalysis/HeavyIonPhys/HIEventUtils/Root/HITowerWeightTool.cxx

@@ -72,24 +72,15 @@ StatusCode HITowerWeightTool::configureEvent()
   {
     ATH_MSG_ERROR("Could not retrieve EventInfo");
     return StatusCode::FAILURE;
-  } 
+  }
   unsigned int run_number=ei->runNumber();
   if(m_run_number!=run_number)
   {
     auto itr=m_run_map.find(run_number);
     if(itr==m_run_map.end())
     {
-        //trying generic run number <=> no run dependence
-        run_number = 226000;
-        auto itrg=m_run_map.find(run_number);
-        if(itrg==m_run_map.end()){  
-            m_run_index=0;
-            ATH_MSG_WARNING("No generic calibration or calibration for " << run_number << " is avaliable. Doing no eta-phi correction.");
-        }
-        else {
-            m_run_index=itrg->second;
-            ATH_MSG_DEBUG("Using generic calibration for eta-phi correction.");
-        }
+      m_run_index=0;
+      ATH_MSG_WARNING("No calibration avaliable for " << run_number << ". Doing no eta-phi correction.");
     }
     else m_run_index=itr->second;
     m_run_number=run_number;
@@ -163,9 +154,7 @@ StatusCode HITowerWeightTool::initialize()
     ATH_MSG_FATAL("Cannot find TH3F h1_run_index in config file " << full_path ); 
     return StatusCode::FAILURE;
   }
-  for(int xbin=1; xbin<=h1_run_index->GetNbinsX(); xbin++) {
-    m_run_map.emplace_hint(m_run_map.end(),std::make_pair(h1_run_index->GetBinContent(xbin),xbin));
-  }
+  for(int xbin=1; xbin<h1_run_index->GetNbinsX(); xbin++) m_run_map.emplace_hint(m_run_map.end(),std::make_pair(h1_run_index->GetBinContent(xbin),xbin));
   f->Close();
   m_init=true;
   return StatusCode::SUCCESS;

PhysicsAnalysis/TauID/TauDQA/CMakeLists.txt

@@ -30,5 +30,5 @@ atlas_add_component( TauDQA
                      src/*.cxx
                      src/components/*.cxx
                      INCLUDE_DIRS ${HEPPDT_INCLUDE_DIRS} ${ROOT_INCLUDE_DIRS} ${HEPMC_INCLUDE_DIRS}
-                     LINK_LIBRARIES ${HEPPDT_LIBRARIES} ${ROOT_LIBRARIES} ${HEPMC_LIBRARIES} GaudiKernel AthenaBaseComps AthenaMonitoringLib xAODEgamma xAODJet xAODTau xAODTruth TauHistUtils McParticleEvent TrkValHistUtils )
+                     LINK_LIBRARIES ${HEPPDT_LIBRARIES} ${ROOT_LIBRARIES} ${HEPMC_LIBRARIES} GaudiKernel AthenaBaseComps AthenaMonitoringLib xAODEgamma xAODJet xAODTau xAODTruth TauHistUtils McParticleEvent TrkValHistUtils TauAnalysisToolsLib )
 

PhysicsAnalysis/TauID/TauDQA/share/PhysValTau.h

@@ -16,15 +16,12 @@
 // Local includes
 #include "AthenaMonitoring/ManagedMonitorToolBase.h"
 #include "TauValidationPlots.h"
-//#include "TauTools/TruthHandler.h"
-//#include "TauTools/MatchingTools_depreciated.h"
+#include "TauAnalysisTools/TauTruthMatchingTool.h"
+#include "TauAnalysisTools/TauSelectionTool.h"
 #include <TLorentzVector.h>
-//Additional includes
 
-#include "TruthHandler.h"
+//Additional includes
 #include "RecoTypes.h"
-//#include "TauTools/MatchingTools.h"
-
 
 // Forward declaration
 
@@ -78,44 +75,19 @@ class PhysValTau
   std::string m_TauDetailsContainerName; 
   std::string m_TruthParticleContainerName; 
 
-  bool            m_isMC;           //!< Are we running over MC data?
-    
-    //Variable Definitiona
-    /** provides tools to match tau candidates to truth taus (from TauTools). */
-    // MatchingTools matchtool;
-    /** is a cut applied to the Delta R variable. */
-    float m_DeltaRMatchCut;
-    
-    /** is a threshold (cut) applied the pT of the leading charged pion. */
-    float m_LeadingChPiPt_Threshold;
-    /** cuts used for truth matching to had taus*/
-    float m_visETcut;
-    float m_visEtacut;
-    
+  bool m_isMC;           //!< Are we running over MC data?
     
-    /** counts the number of truth taus. */
-    int m_truth_all;
+   //Variable Definitions
     
-    /** counts the number of truth taus geometrically matched. */
-    int m_truth_all_matched;
-    
-    /** counts the number of truth 1p taus. */
-    int m_truth_1p;
-
-    /** counts the number of truth taus geometrically matched and 1 track. */
-    int m_truth_1p_matched;
-
-    /** counts the number of truth 3p taus. */
-    int m_truth_3p;
-    
-    /** counts the number of truth taus geometrically matched and 3 track. */
-    int m_truth_3p_matched;
-
     /*keeps track of matched tau jets*/    
     std::vector<size_t> m_matched_itr;
 
-    /** Object to define Truth Handler Tool*/
-    TruthHandler truthHandler;
+   // Tool used for truth-matching
+   TauAnalysisTools::TauTruthMatchingTool m_truthTool;
+   // Tool used to select "primitive" and "nominal" taus
+   TauAnalysisTools::TauSelectionTool m_primTauSel;
+   TauAnalysisTools::TauSelectionTool m_nomiTauSel;
+
 
   //Histograms
   // general tau all prongs plots

PhysicsAnalysis/TauID/TauDQA/share/TauValidationPlots.h

@@ -91,6 +91,35 @@ class TauValidationPlots:public PlotBase {
       //Migration Matrix plots
       Tau::Migration m_oMigrationPlots;		
 
+      // Plots with the "nominal" tau selection
+      Tau::GeneralTauPlots m_oFakeGeneralNom;
+      Tau::Had1ProngPlots m_oFakeHad1ProngNom;
+      Tau::Had3ProngPlots m_oFakeHad3ProngNom;
+      Tau::EfficiencyPtPlots m_oFakeTauEffPlotsNom;
+      Tau::EfficiencyPtPlots m_oFakeTauEff1PPlotsNom;
+      Tau::EfficiencyPtPlots m_oFakeTauEff3PPlotsNom;
+      Tau::RecoTauPlots m_oFakeTauRecoTauPlotsNom;
+      Tau::NewCorePlots m_oNewCoreFakePlotsNom;
+      
+      Tau::GeneralTauPlots m_oRecoGeneralNom;
+      Tau::Had1ProngPlots m_oRecoHad1ProngNom;
+      Tau::Had3ProngPlots m_oRecoHad3ProngNom;
+      Tau::EfficiencyPtPlots m_oRecTauEffPlotsNom;
+      Tau::EfficiencyPtPlots m_oRecTauEff1PPlotsNom;
+      Tau::EfficiencyPtPlots m_oRecTauEff3PPlotsNom;
+      Tau::RecoTauPlots m_oRecTauRecoTauPlotsNom;
+      Tau::NewCorePlots m_oNewCoreRecTauPlotsNom;
+      
+      Tau::GeneralTauPlots m_oMatchedGeneralNom;
+      Tau::Had1ProngPlots m_oMatchedHad1ProngNom;
+      Tau::Had3ProngPlots m_oMatchedHad3ProngNom;
+      Tau::EfficiencyPtPlots m_oMatchedTauEffPlotsNom;
+      Tau::EfficiencyPtPlots m_oMatchedTauEff1PPlotsNom;
+      Tau::EfficiencyPtPlots m_oMatchedTauEff3PPlotsNom;
+      Tau::RecoTauPlots m_oMatchedTauRecoTauPlotsNom;
+      Tau::Migration m_oMigrationPlotsNom;
+      Tau::NewCorePlots m_oNewCoreMatchedPlotsNom;
+
 
 };
 

PhysicsAnalysis/TauID/TauDQA/share/TruthHandler.h

-#ifndef TAUTRUTH_H
-#define TAUTRUTH_H
-
-//////////////////////////////////////////////////////////////////////////////////////
-/// Name    : TruthHandler.h
-/// Package : offline/PhysicsAnalysis/TauID/TauTools
-/// Author  : Jyothsna Komaragiri, Dugan O'Neil, Aldo Saavedra
-/// Created : April 2008
-/// Modified: Feb 2009 by Aldo Saavedra, Added Atautau and SingleTau filters
-///
-/// modified: Jennifer Godfrey
-///
-/// modified by: Felix Friedrich, 2014
-///
-/// modified by: Guillermo Hamity, 2014
-///
-/// DESCRIPTION:
-///
-/// This class contains methods to access truth tau information. It has methods to find the MC
-/// truth tau, determine if it is hadronic, match to reco candidates, etc.
-///
-//////////////////////////////////////////////////////////////////////////////////////
-#include "McParticleEvent/TruthParticleContainer.h"
-#include "xAODTruth/TruthParticleContainer.h"
-#include "xAODTruth/TruthVertex.h"
-
-#include "HepPDT/ParticleData.hh"
-#include "HepMC/GenEvent.h"
-#include "HepMC/GenParticle.h"
-#include "HepMC/GenVertex.h"
-#include <vector>
-#include "TLorentzVector.h"
-#include <functional>
-#include <algorithm>
-#include <math.h>
-#include "Gtypes.h"
-
-// FF,2014:
-// this class is just a collection of free functions. Having them collected into a class is for backwards compatibility.
-// in principle all of the methods can be moved to a namespace
-
-class TruthHandler {
-public:
-	// let the compiler auto generate the constructor and destructor
-	//TruthHandler();
-	//~TruthHandler();
-
-		/** determines if a particle is only a G4 particle */
-		bool isGenerator(int barcode, int status);
-		bool isGenerator( const TruthParticle* part )       { return isGenerator(part->barcode(), part->status()); }
-		bool isGenerator( const HepMC::GenParticle* part )  { return isGenerator(part->barcode(), part->status()); }
-		bool isGenerator( const xAOD::TruthParticle* part)  { return isGenerator(part->barcode(), part->status()); }
-
-		/** determine if a particle is a final state stable particle  */
-		bool isGenStable( const HepMC::GenParticle* part );
-		bool isGenStable( const xAOD::TruthParticle* part );
-
-		/** returns false if particle is only a reference particle in the generator.  Also checks whether particle is intermediate (Status==2) or final state and stable (Status==1)*/
-		bool isGoodStatus(int Status);
-		bool isGoodStatus(const HepMC::GenParticle* part, int StatusToCheck);
-		bool isGoodStatus(const xAOD::TruthParticle* part, int StatusToCheck);
-
-		/** return true if xAODTruth particle as a child with pdgID==pdgIDtoCheck. Only direct children are checked. No iteration on children-of-children. */
-		bool hasChild(const xAOD::TruthParticle* part, int pdgIDtoCheck);
-    
-		/** determines if a particle is Tau or not */
-		bool isTauTruth( const TruthParticle* part );
-		bool isTauTruth( const xAOD::TruthParticle* part );
-
-		/**  determines if a particle is a true hadronic tau*/
-		bool isHadTau(const HepMC::GenParticle* part, int Mother = -1 );
-		bool isHadTau(const xAOD::TruthParticle* part, int Mother = -1 );
-		bool isHadTau(const TruthParticle* part, int Mother = -1 ) { return isHadTau( (const HepMC::GenParticle*) part->genParticle(), Mother); }
-
-		/** determine if a particle is charged pion, exclude those which come from kaon decays.  */
-		bool isGoodChrgPiDaughter(const HepMC::GenParticle* hadTau);
-		bool isGoodChrgPiDaughter(const xAOD::TruthParticle* hadTau);
-
-		/** determine whether tau decay includes given pdg_ID particle as an intermediate (Status==2) or final state (Status==1) daughter*/
-		bool isTauTypeDecay(const HepMC::GenParticle* part, int PDGID, int Status );
-		bool isTauTypeDecay(const TruthParticle* part, int PDGID, int Status  ) { return isTauTypeDecay( (const HepMC::GenParticle*) part->genParticle(), PDGID, Status); }
-
-		/** determine whether tau decay is an electron decay*/
-		bool isTauElecDecay(const HepMC::GenParticle* part ) { return isTauTypeDecay(part, 11, 1); }
-		bool isTauElecDecay(const TruthParticle* part )      { return isTauTypeDecay(part, 11, 1); }
-
-		/** determine whether tau decay is a muon decay*/
-		bool isTauMuonDecay(const HepMC::GenParticle* part ) { return isTauTypeDecay(part, 13, 1); }
-		bool isTauMuonDecay(const TruthParticle* part )      { return isTauTypeDecay(part, 13, 1); }
-
-		/** determine whether tau decays directly to a rho (does not include a1->rho)*/
-		bool isTauRhoDecay(const HepMC::GenParticle* part ) { return isTauTypeDecay(part, PDG::rho_plus, 2); }
-		bool isTauRhoDecay(const TruthParticle* part )      { return isTauTypeDecay(part, PDG::rho_plus, 2); }
-
-		/** determine whether tau decays directly to an a1 particle */
-		bool isTauA1Decay(const HepMC::GenParticle* part ) {  return isTauTypeDecay(part, PDG::a_1_plus,2); }
-		bool isTauA1Decay(const TruthParticle* part )      {  return isTauTypeDecay(part, PDG::a_1_plus,2); }
-
-		/** determine if a particle is charged pion.  */
-		bool   isPiChTruth( const TruthParticle* part ) { return ( abs((int)part->pdgId()) == PDG::pi_plus); }
-
-		/** Loops through the truth taus in the event to determine if they are hadronic decays or not.
-		It returns a container of hadronic taus. Option to enforce the pdgID of the parent particle to be of type Mother. */
-		TruthParticleContainer* getHadronicTruth(const TruthParticleContainer *mcpartTES, int Mother = -1 );
-		xAOD::TruthParticleContainer* getHadronicTruth(const xAOD::TruthParticleContainer *mcpartTES, int Mother = -1 );
-
-		/**Handle tau truth information. Return a container of all truth taus
-		Option to enforce the pdgID of the parent particle to be of type Mother.**/
-		TruthParticleContainer* getAllFinalTaus(const TruthParticleContainer *mcpartTES, int Mother=-1);
-
-		/** provides the number of charged daughters (pions) in tau decays, does not include pions that come from kaons.
-		Will include charged  kaons if UseKaon=true*/
-		int nProngTruth(const HepMC::GenParticle* hadTau, bool UseKaon=true );
-		int nProngTruth(const xAOD::TruthParticle* hadTau, bool UseKaon=true );
-		int nProngTruthTau(const xAOD::TruthParticle* hadTau, bool UseKaon=true );
-		int nProngTruth(const TruthParticle* hadTau, bool UseKaon=true ) { return nProngTruth( (const HepMC::GenParticle*)hadTau->genParticle(), UseKaon); }
-
-		/** method to count no. of neutral pions */
-		int numNeutPion(const HepMC::GenParticle* hadTau );
-		int numNeutPion(const xAOD::TruthParticle* hadTau);
-		int numNeutPion( const TruthParticle* hadTau) { return numNeutPion( (const HepMC::GenParticle*)hadTau->genParticle() ); }
-
-		/** method to count no. of neutral pions and get the pointer to pi+, rho+, a1+ */
-		const TruthParticle* nPi0Truth( const TruthParticle* hadTau, int &nPi0 );
-
-		/** method to get a pointer to the intermediate daughter (either the pion, rho, or a1) */
-		const TruthParticle* GetIntermDaughter(const TruthParticle* hadTau );
-
-		/** determines whether ``Daughter'' is a hadronic daughter of the decay of the ``TrueTau'',
-		(where status specifies intermediate daughter (Status==2) or final state daughter (Status==1))*/
-		bool isHadTauDaughter(const HepMC::GenParticle* TruthTau,const HepMC::GenParticle* Daughter, int Status);
-		bool isHadTauDaughter(const TruthParticle* TruthTau,const TruthParticle* TruthDaughter, int Status) { return isHadTauDaughter( (const HepMC::GenParticle*) TruthTau->genParticle(), (const HepMC::GenParticle*) TruthDaughter->genParticle(), Status); }
-		bool isHadTauDaughter(const HepMC::GenEvent* TrueTauCollection, const HepMC::GenParticle* Daughter, int Status);
-		bool isHadTauDaughter(const TruthParticleContainer *TrueTauCollection,const TruthParticle* TruthDaughter, int Status);
-
-		/** determines whether ``Daughter'' is a final stable daughter of the decay of the ``TrueTau'' */
-		bool isHadTauFinalDaughter(const HepMC::GenParticle* TruthTau,const HepMC::GenParticle* Daughter) { return isHadTauDaughter(TruthTau,Daughter,1); }
-		bool isHadTauFinalDaughter(const TruthParticle* TruthTau,const TruthParticle* Daughter)           { return isHadTauDaughter(TruthTau,Daughter,1); }
-		bool isHadTauFinalDaughter(const  HepMC::GenEvent* TrueTauCollection, const HepMC::GenParticle* Daughter)      {  return isHadTauDaughter(TrueTauCollection, Daughter, 1); }
-		bool isHadTauFinalDaughter(const TruthParticleContainer *TrueTauCollection,const TruthParticle* Daughter)      {  return isHadTauDaughter(TrueTauCollection, Daughter, 1); }
-
-		/** determines whether ``Daughter'' is an intermediate  daughter of the decay of the ``TrueTau'' */
-		bool isHadTauIntermDaughter(const HepMC::GenParticle* TruthTau,const HepMC::GenParticle* Daughter) { return isHadTauDaughter(TruthTau,Daughter,2); }
-		bool isHadTauIntermDaughter(const TruthParticle* TruthTau,const TruthParticle* Daughter)           { return isHadTauDaughter(TruthTau,Daughter,2); }
-		bool isHadTauIntermDaughter(const HepMC::GenEvent* TrueTauCollection,const HepMC::GenParticle* Daughter)         { return isHadTauDaughter(TrueTauCollection, Daughter, 2); }
-		bool isHadTauIntermDaughter(const TruthParticleContainer *TrueTauCollection, const TruthParticle* Daughter)      { return isHadTauDaughter(TrueTauCollection, Daughter, 2); }
-
-		/** returns a collection of the true intermediate daughters  (Status==2) or final daughters (Status==2)
-		of the true hadronic tau*/
-		TruthParticleContainer* getTrueHadDaughters(const TruthParticle *TrueTau, const TruthParticleContainer *mcpartTES, int Status);
-
-		/** returns a collection of the true  final daughters of the true hadronic tau*/
-		TruthParticleContainer* getFinalTrueHadDaughters(const TruthParticle *TrueTau, const TruthParticleContainer *mcpartTES)  { return getTrueHadDaughters(TrueTau, mcpartTES, 1); }
-
-		/** returns a collection of the true intermediate daughters of the true hadronic tau*/
-		TruthParticleContainer* getIntermTrueHadDaughters(const TruthParticle *TrueTau, const TruthParticleContainer *mcpartTES) { return getTrueHadDaughters(TrueTau, mcpartTES, 2); }
-
-		/** returns a collection of the true hadronics taus which decay to nProngs */
-		TruthParticleContainer* getHadronicnProngTruth(const TruthParticleContainer *mcpartTES, int nProngs);
-
-		/** returns a collection of the true hadronics taus which decay to 1 Prong */
-		TruthParticleContainer* getHadronic1ProngTruth(const TruthParticleContainer *mcpartTES) { return getHadronicnProngTruth(mcpartTES, 1); }
-
-		/** returns a collection of the true hadronics taus which decay to 3 Prongs */
-		TruthParticleContainer* getHadronic3ProngTruth(const TruthParticleContainer *mcpartTES) { return getHadronicnProngTruth(mcpartTES, 3); }
-
-		/** This method adds the momentum of the daughter neutrinos of the tau, it is called recursively */
-		CLHEP::HepLorentzVector sumDaughterNeutrinos( const TruthParticle *part );
-
-		/** Given a hadronic truth tau, calculate the visible Sum */
-		CLHEP::HepLorentzVector getTauVisibleSumTruth( const TruthParticle* hadTau );
-		TLorentzVector getTauVisibleSumTruth( const xAOD::TruthParticle* hadTau );
-
-		/** This method returns the HepLorentzVector of leading charged pion */
-		CLHEP::HepLorentzVector getPiChTruth( const TruthParticle* hadTau );
-		//CLHEP::HepLorentzVector getPiChTruth( const xAOD::TruthParticle* hadTau );
-};
-
-#endif

PhysicsAnalysis/TauID/TauDQA/src/PhysValTau.cxx

@@ -24,6 +24,7 @@
 #include "xAODTruth/TruthParticleContainer.h"
 #include "xAODTruth/TruthParticle.h"  
 #include "AthenaBaseComps/AthCheckMacros.h"
+#include "xAODRootAccess/TEvent.h"
 using CLHEP::GeV;
 //namespace PhysVal {
 
@@ -37,12 +38,15 @@ using CLHEP::GeV;
 PhysValTau::PhysValTau(const std::string& type, 
 		       const std::string& name, 
                        const IInterface* parent) : 
-    ManagedMonitorToolBase(type, name, parent)
+   ManagedMonitorToolBase(type, name, parent),
+   m_truthTool("TauTruthMatchingTool"),
+   m_primTauSel("PrimitiveTauSelectionTool"),
+   m_nomiTauSel("NominalTauSelectionTool")
 {
    declareProperty("TauContainerName", m_TauJetContainerName = "TauRecContainer");
    declareProperty("TruthParticleContainerName", m_TruthParticleContainerName = "TruthParticle");
    declareProperty("TauDetailsContainerName", m_TauDetailsContainerName = "TauRecDetailsContainer");
-   declareProperty("isMC", m_isMC= false);
+   declareProperty("isMC", m_isMC = false);
 }
 
 // Destructor
@@ -56,23 +60,32 @@ StatusCode PhysValTau::initialize()
 {
    ATH_MSG_INFO ("Initializing " << name() << "...");    
    ATH_CHECK(ManagedMonitorToolBase::initialize());
-   
-   // geometrical matching between Reco Tau and MC tau
-   m_DeltaRMatchCut          = 0.2;
-   m_LeadingChPiPt_Threshold = 0.0;
-   
-   //Truth Matching Cuts
-   m_visETcut                = 10.;
-   m_visEtacut               = 2.5;
-    
-   //Initialize Counters
-   m_truth_all = 0;
-   m_truth_1p = 0;
-   m_truth_3p = 0;
-   
-   m_truth_all_matched = 0;
-   m_truth_1p_matched = 0;
-   m_truth_3p_matched = 0;
+
+   if ( m_isMC ) {
+      CHECK(m_truthTool.setProperty("TruthElectronContainerName",
+      				    "TruthElectrons"));
+      CHECK(m_truthTool.setProperty("TruthMuonContainerName",
+      				    "MuonTruthParticles"));
+      CHECK(m_truthTool.setProperty("WriteTruthTaus", true));
+      CHECK(m_truthTool.sysInitialize());
+   }
+   // setup a "primitive" tau selection tool with basically no cuts
+   CHECK(m_primTauSel.setProperty("PtMin",0.0));
+   CHECK(m_primTauSel.setProperty("JetIDWP",int(TauAnalysisTools::JETIDNONE)));
+   CHECK(m_primTauSel.setProperty("EleOLR",false));
+   CHECK(m_primTauSel.setProperty("NTracks",std::vector<int>{0,1,2,3,4,5}));
+   CHECK(m_primTauSel.setProperty("AbsCharges",std::vector<int>{0,1,2,3}));
+   CHECK(m_primTauSel.setProperty("AbsEtaRegion",std::vector<double>{0.0,10.0}));
+   m_primTauSel.msg().setLevel(MSG::DEBUG);
+   CHECK(m_primTauSel.initialize());
+   // setup a "nominal" tau selection tool (just eta and pt cuts)
+   CHECK(m_nomiTauSel.setProperty("PtMin",20.0));
+   CHECK(m_nomiTauSel.setProperty("JetIDWP",int(TauAnalysisTools::JETIDNONE)));
+   CHECK(m_nomiTauSel.setProperty("EleOLR",false));
+   CHECK(m_nomiTauSel.setProperty("NTracks",std::vector<int>{0,1,2,3,4,5}));
+   CHECK(m_nomiTauSel.setProperty("AbsCharges",std::vector<int>{0,1,2,3}));
+   m_nomiTauSel.msg().setLevel(MSG::DEBUG);
+   CHECK(m_nomiTauSel.initialize());
    
    return StatusCode::SUCCESS;
 }
@@ -98,142 +111,164 @@ StatusCode PhysValTau::fillHistograms()
 {
     
    ATH_MSG_INFO ("Filling hists " << name() << "...");
-   ////////////////////////////////////////////////////////////////////////////////////////////////
-   // Retrieve tau container: 
-   const xAOD::TauJetContainer* taus = evtStore()->retrieve< const xAOD::TauJetContainer >( m_TauJetContainerName ); 
+
+   // Retrieve tau container:
+   const xAOD::TauJetContainer* taus = evtStore()
+      ->retrieve<const xAOD::TauJetContainer>(m_TauJetContainerName); 
    if ( !taus ) { 
-      ATH_MSG_ERROR ("Couldn't retrieve tau container with key: " << m_TauJetContainerName); 
+      ATH_MSG_ERROR("Couldn't retrieve tau container with key: "
+		    << m_TauJetContainerName); 
       return StatusCode::FAILURE; 
    }         
-   ATH_MSG_DEBUG("Number of taus: " << taus->size()); 
+   ATH_MSG_DEBUG("Number of taus: " << taus->size());
 
-   ////////////////////////////////////////////////////////////////////////////////////////////////
    // Retrieve truth container:     
-   const xAOD::TruthParticleContainer* truth = 0;
+   const xAOD::TruthParticleContainer* truthParticles = 0;
    if ( m_isMC ) {
-      truth = evtStore()->retrieve<const xAOD::TruthParticleContainer>(m_TruthParticleContainerName);
-      if ( !truth ) { 
-	 ATH_MSG_ERROR ("Couldn't retrieve tau container with key: " << m_TruthParticleContainerName); 
+      truthParticles = evtStore()->retrieve<const xAOD::TruthParticleContainer>(m_TruthParticleContainerName);
+      if ( !truthParticles ) {
+	 ATH_MSG_ERROR ("Couldn't retrieve tau container with key: "
+			<< m_TruthParticleContainerName);
 	 return StatusCode::FAILURE;
       }   
-      //  ATH_MSG_DEBUG( "Number of truth: " << truth->size() );      
-   }
-   //////////////////////////////////////////////////////////////////////////////////////////////////
-   // Retrieve true hadronic tau container from truth container
-   // getHaderonicTruth finds true taus (ID == 15) with correct status and no leptonic decay.
-   const xAOD::TruthParticleContainer* trueTauContainer = 0;
-   if ( m_isMC ) {
-      trueTauContainer = truthHandler.getHadronicTruth(truth);
-      ATH_MSG_DEBUG("Number of true had taus: " << trueTauContainer->size());
+      //  ATH_MSG_DEBUG( "Number of truth: " << truth->size() );
    }
-    
-   //////////////////////////////////////////
-   // Plotting TauRec Variables
-   
+
    // Loop through reco tau jet container
    for (auto tau : *taus) { 
-      if (m_detailLevel < 10) continue;
-      if (tau->pt()/GeV < 20) continue;
-      // fill Substructure/PFO histograms
+      if ( m_detailLevel < 10 ) continue;
+      if ( !m_primTauSel.accept(*tau) ) continue;
+      bool nominal = m_nomiTauSel.accept(*tau);
+      
+      // fill histograms for reconstructed taus
       m_oTauValidationPlots->m_oRecoTauAllProngsPlots.fill(*tau);
       m_oTauValidationPlots->m_oNewCorePlots.fill(*tau);
       m_oTauValidationPlots->m_oRecTauEffPlots.fill(*tau);
-      //Reco Tau General Plots
       m_oTauValidationPlots->m_oRecoGeneralTauAllProngsPlots.fill(*tau);
-      if ( tau->nTracks()==1 ) {
+      if ( nominal ) {
+	 m_oTauValidationPlots->m_oRecoGeneralNom.fill(*tau);
+	 m_oTauValidationPlots->m_oRecTauEffPlotsNom.fill(*tau);
+	 m_oTauValidationPlots->m_oRecTauRecoTauPlotsNom.fill(*tau);
+	 m_oTauValidationPlots->m_oNewCoreRecTauPlotsNom.fill(*tau);
+      }
+      int recProng = tau->nTracks();
+      if ( recProng == 1 ) {
 	 m_oTauValidationPlots->m_oRecoHad1ProngPlots.fill(*tau);
 	 m_oTauValidationPlots->m_oRecTauEff1PPlots.fill(*tau);
-         
+	 if ( nominal ) {
+	    m_oTauValidationPlots->m_oRecoHad1ProngNom.fill(*tau);
+	    m_oTauValidationPlots->m_oRecTauEff1PPlotsNom.fill(*tau);
+	 }
       }
-      if ( tau->nTracks()==3 ) { 
+      else if ( recProng == 3 ) { 
 	 m_oTauValidationPlots->m_oRecoHad3ProngPlots.fill(*tau);
 	 m_oTauValidationPlots->m_oRecTauEff3PPlots.fill(*tau);
-      }
-   }
-   m_matched_itr.clear();
-   //////////////////////////////////////////
-   // Plotting TruthMatched Variables
-   // Loop through reco tau jet container
-   
-   // 
-   
-   if ( (trueTauContainer != 0) && (m_isMC == true) ) {
-      xAOD::TruthParticleContainer::const_iterator truth_itr = trueTauContainer->begin();
-      xAOD::TruthParticleContainer::const_iterator truth_end = trueTauContainer->end();
-      for ( ; truth_itr != truth_end; truth_itr++ ) {
-	 ATH_MSG_DEBUG( "Trying to match tau :");
-	 xAOD::TruthParticle* trueTau = const_cast<xAOD::TruthParticle*>(*truth_itr);
-	 const xAOD::TauJet *matchedRecTau = 0;
-	 ATH_MSG_DEBUG("Matching Tau");
-	 bool matched = matchTrueAndRecoTau(taus,trueTau,matchedRecTau);
-	 if ( matched ) {
-	    m_oTauValidationPlots->m_oGeneralTauAllProngsPlots.fill(*matchedRecTau);
-	    m_oTauValidationPlots->m_oNewCoreMatchedPlots.fill(*matchedRecTau);
-	    // Substructure/PFO histograms 
-	    m_oTauValidationPlots->m_oMatchedTauAllProngsPlots.fill(*matchedRecTau);
-	    m_oTauValidationPlots->m_oMatchedTauEffPlots.fill(*matchedRecTau);
-	    // 1-prong
-	    if ( matchedRecTau->nTracks() == 1 ) {
-	       m_oTauValidationPlots->m_oHad1ProngPlots.fill(*matchedRecTau);
-	       m_oTauValidationPlots->m_oMatchedTauEff1PPlots.fill(*matchedRecTau);  
-	    }
-	    // 3-prong
-	    else if( matchedRecTau->nTracks() == 3 ) {
-	       m_oTauValidationPlots->m_oHad3ProngPlots.fill(*matchedRecTau);
-	       m_oTauValidationPlots->m_oMatchedTauEff3PPlots.fill(*matchedRecTau);  
-	    }
+	 if ( nominal ) {
+	    m_oTauValidationPlots->m_oRecoHad3ProngNom.fill(*tau);
+	    m_oTauValidationPlots->m_oRecTauEff3PPlotsNom.fill(*tau);
 	 }
       }
-      if ( taus != 0 ) {
-	 xAOD::TauJetContainer::const_iterator tau_itr = taus->begin();
-	 xAOD::TauJetContainer::const_iterator tau_end = taus->end();
-	 for ( size_t iRecTau = 0 ; iRecTau < taus->size(); iRecTau++ ) {
-	    bool alreadymatched = false;
-	    if ( m_matched_itr.size() > 0 ) {
-	       for ( size_t i = 0; i < m_matched_itr.size(); i++ ) {
-		  if(m_matched_itr.at(i) == iRecTau) alreadymatched = true;
+      
+      // Don't fill truth and fake histograms if we are running on data.
+      if ( !m_isMC ) continue;
+      
+      ATH_MSG_DEBUG("Trying to truth-match tau");
+      auto trueTau = m_truthTool.getTruth(*tau);
+
+      // Fill truth and fake histograms
+      if ( (bool)tau->auxdata<char>("IsTruthMatched") ) {
+      	 ATH_MSG_DEBUG("Tau is truth-matched");
+	 // std::cout << "Truth pdgId = " << trueTau->pdgId() << std::endl; 
+	 if ( trueTau->isTau() ) {
+	    if ( (bool)trueTau->auxdata<char>("IsHadronicTau") ) {
+	       ATH_MSG_DEBUG("Tau is hadronic tau");
+	       m_oTauValidationPlots->m_oGeneralTauAllProngsPlots.fill(*tau);
+	       m_oTauValidationPlots->m_oNewCoreMatchedPlots.fill(*tau);
+	       // Substructure/PFO histograms 
+	       m_oTauValidationPlots->m_oMatchedTauAllProngsPlots.fill(*tau);
+	       m_oTauValidationPlots->m_oMatchedTauEffPlots.fill(*tau);
+	       if ( nominal ) {
+		  m_oTauValidationPlots->m_oMatchedGeneralNom.fill(*tau);
+		  m_oTauValidationPlots->m_oMatchedTauEffPlotsNom.fill(*tau);
+		  m_oTauValidationPlots->m_oMatchedTauRecoTauPlotsNom.fill(*tau);
+		  m_oTauValidationPlots->m_oNewCoreMatchedPlotsNom.fill(*tau);
 	       }
-	    }
-	    if ( alreadymatched ) continue;
-	    const xAOD::TauJet *recTau = taus->at(iRecTau);
-	    if ( m_detailLevel < 10 ) continue;
-	    if ( recTau->pt()/GeV < 20 ) continue;
-	    bool eleMatch = false;
-	    // Matching to electrons (Improvements needed)
-	    for ( auto mc_candidate : *truth ) {
-	       if ( abs(mc_candidate->pdgId())==11 && mc_candidate->pt()>10000. ) {
-		  float dr = sqrt( (mc_candidate->eta()-recTau->eta())*(mc_candidate->eta()-recTau->eta())
-				   + (mc_candidate->phi()-recTau->phi())*(mc_candidate->phi()-recTau->phi()));
-		  if( dr < 0.2 ) {
-		     eleMatch = true;
-		     continue;
+	       if ( recProng == 1 ) {
+		  m_oTauValidationPlots->m_oHad1ProngPlots.fill(*tau);
+		  m_oTauValidationPlots->m_oMatchedTauEff1PPlots.fill(*tau);  
+		  if ( nominal ) {
+		     m_oTauValidationPlots->m_oMatchedHad1ProngNom.fill(*tau);
+		     m_oTauValidationPlots->m_oMatchedTauEff1PPlotsNom.fill(*tau);
 		  }
 	       }
+	       else if ( recProng == 3 ) {
+		  m_oTauValidationPlots->m_oHad3ProngPlots.fill(*tau);
+		  m_oTauValidationPlots->m_oMatchedTauEff3PPlots.fill(*tau);  
+		  if ( nominal ) {
+		     m_oTauValidationPlots->m_oMatchedHad3ProngNom.fill(*tau);
+		     m_oTauValidationPlots->m_oMatchedTauEff3PPlotsNom.fill(*tau);
+		  }
+	       }
+
+	       xAOD::TauJetParameters::DecayMode trueMode
+		  = m_truthTool.getDecayMode(*trueTau);
+	       m_oTauValidationPlots->m_oMigrationPlots.fill(*tau, trueMode);
+	       if ( nominal ) {
+		  m_oTauValidationPlots->m_oMigrationPlotsNom.fill(*tau, trueMode);
+	       }
 	    }
-	    // electron matched taus
-	    if ( eleMatch ) {
-	       m_oTauValidationPlots->m_oElMatchedParamPlots.fill(*recTau);
-	       m_oTauValidationPlots->m_oElMatchedEVetoPlots.fill(*recTau);
+	 }
+      }
+      else {
+      	 ATH_MSG_DEBUG("Tau is fake");
+	 // try to match to truth electrons
+	 bool isElectron = false;
+	 for ( auto truth : *truthParticles ) {
+	    if ( abs(truth->pdgId()) != 11 ) continue;
+	    if ( truth->status() != 1 ) continue;
+	    if ( truth->pt() < 10000.0 ) continue;
+	    if ( tau->p4().DeltaR(truth->p4()) > 0.2 ) continue;
+	    std::cout << "Found electron!" << std::endl;
+	    // OK, now it probably is an electron
+	    isElectron = true;
+	    break;
+	 }
+	 if ( isElectron ) {
+	    m_oTauValidationPlots->m_oElMatchedParamPlots.fill(*tau);
+	    m_oTauValidationPlots->m_oElMatchedEVetoPlots.fill(*tau);
+	 }
+	 else { // other fakes
+	    m_oTauValidationPlots->m_oFakeGeneralTauAllProngsPlots.fill(*tau);
+	    // Substructure/PFO histograms
+	    m_oTauValidationPlots->m_oFakeTauAllProngsPlots.fill(*tau);
+	    m_oTauValidationPlots->m_oNewCoreFakePlots.fill(*tau);
+	    m_oTauValidationPlots->m_oFakeTauEffPlots.fill(*tau);
+	    if ( nominal ) {
+	       m_oTauValidationPlots->m_oFakeGeneralNom.fill(*tau);
+	       m_oTauValidationPlots->m_oFakeTauEffPlotsNom.fill(*tau);
+	       m_oTauValidationPlots->m_oFakeTauRecoTauPlotsNom.fill(*tau);
+	       m_oTauValidationPlots->m_oNewCoreFakePlotsNom.fill(*tau);
 	    }
-	    else {
-	       m_oTauValidationPlots->m_oFakeGeneralTauAllProngsPlots.fill(*recTau);
-	       // Substructure/PFO histograms
-	       m_oTauValidationPlots->m_oFakeTauAllProngsPlots.fill(*recTau);
-	       m_oTauValidationPlots->m_oNewCoreFakePlots.fill(*recTau);
-	       m_oTauValidationPlots->m_oFakeTauEffPlots.fill(*recTau);
-	       if ( recTau->nTracks()==1 ) {
-		  m_oTauValidationPlots->m_oFakeHad1ProngPlots.fill(*recTau);
-		  m_oTauValidationPlots->m_oFakeTauEff1PPlots.fill(*recTau);
+	    if ( recProng == 1 ) {
+	       m_oTauValidationPlots->m_oFakeHad1ProngPlots.fill(*tau);
+	       m_oTauValidationPlots->m_oFakeTauEff1PPlots.fill(*tau);
+	       if ( nominal ) {
+		  m_oTauValidationPlots->m_oFakeHad1ProngNom.fill(*tau);
+		  m_oTauValidationPlots->m_oFakeTauEff1PPlotsNom.fill(*tau);
 	       }
-	       if ( recTau->nTracks()==3 ) {
-		  m_oTauValidationPlots->m_oFakeTauEff3PPlots.fill(*recTau);
-		  m_oTauValidationPlots->m_oFakeHad3ProngPlots.fill(*recTau);    
+	    }
+	    if ( recProng == 3 ) {
+	       m_oTauValidationPlots->m_oFakeTauEff3PPlots.fill(*tau);
+	       m_oTauValidationPlots->m_oFakeHad3ProngPlots.fill(*tau);    
+	       if ( nominal ) {
+		  m_oTauValidationPlots->m_oFakeHad3ProngNom.fill(*tau);
+		  m_oTauValidationPlots->m_oFakeTauEff3PPlotsNom.fill(*tau);
 	       }
 	    }
 	 }
       }
-   }   /////////////////////////////////////////////////////////////////////////////////////////////////
-   
+   }
+
    return StatusCode::SUCCESS;
 }
 
@@ -243,64 +278,6 @@ StatusCode PhysValTau::procHistograms()
     return StatusCode::SUCCESS;
 }
 
-bool PhysValTau::matchTrueAndRecoTau(const xAOD::TauJetContainer *&taus, const xAOD::TruthParticle *trueTau, const xAOD::TauJet *&matchedRecTau)
-{
-    std::vector< const xAOD::TruthParticle * > decayParticles;
-    int nCharged = 0;
-    int nNeutral = 0;
-    //    RecoTypes::DecayMode trueDecayMode = getDecayMode(trueTau, decayParticles, nCharged, nNeutral);
-    nCharged = truthHandler.nProngTruthTau(trueTau,false);
-    nNeutral = truthHandler.numNeutPion(trueTau);
-
-    RecoTypes::DecayMode trueDecayMode = RecoTypes::GetDecayMode(nCharged, nNeutral);
-
-
-    ATH_MSG_DEBUG( "True decay mode is " << nCharged << "p" << nNeutral << "n" ); 
-    
-    if (!RecoTypes::IsValidMode(trueDecayMode)) {
-        ATH_MSG_DEBUG(" Decay mode is not valid, skipping..." ); 
-        return false;
-    }
-
-    TLorentzVector visSum = truthHandler.getTauVisibleSumTruth(trueTau);                    // Get visible TLV for true had tau         
-    if ((visSum.Et()/GeV < m_visETcut) || (fabs(visSum.Eta()) > m_visEtacut)) return false;    // Detector limitations
-    
-    xAOD::TauJetContainer::const_iterator tau_itr = taus->begin();
-    xAOD::TauJetContainer::const_iterator tau_end = taus->end();
-    double minDeltaR = m_DeltaRMatchCut;
-    bool matched = false;
-    size_t iMatchedRecTau = 0;
-    TLorentzVector hlv_matchedRecTau;
-    
-    for (size_t iRecTau = 0 ; iRecTau < taus->size(); iRecTau++) {
-        const xAOD::TauJet *recTau = taus->at(iRecTau);
-        double recPt  = recTau->ptIntermediateAxis();
-        double recEta = recTau->etaIntermediateAxis();
-        double recPhi = recTau->phiIntermediateAxis();
-        double recM   = recTau->mIntermediateAxis();
-        TLorentzVector hlv_recTau;
-        hlv_recTau.SetPtEtaPhiM(recPt, recEta, recPhi, recM);
-        
-        double curDeltaR = visSum.DeltaR(hlv_recTau);
-        if (curDeltaR < minDeltaR) {
-            minDeltaR = curDeltaR;
-            matchedRecTau = recTau;
-            hlv_matchedRecTau = hlv_recTau;
-            matched = true;
-            iMatchedRecTau = iRecTau;
-        }
-    }
-    
-    if(matched){
-        const xAOD::TauJet *recTau = taus->at(iMatchedRecTau);
-        m_oTauValidationPlots->m_oMigrationPlots.fill(*recTau,nCharged,nNeutral); //Migration      
-        m_matched_itr.push_back(iMatchedRecTau);
-        //    std::cout<<"Number of matched between: "<<m_matched_itr.size()<<std::endl;
-    }
-    
-    return matched;
-}
-
 
 /////////////////////////////////////////////////////////////////// 
 // Const methods: 

PhysicsAnalysis/TauID/TauDQA/src/TauValidationPlots.cxx

@@ -6,33 +6,63 @@
 
 TauValidationPlots::TauValidationPlots(PlotBase* pParent, std::string sDir, std::string sTauJetContainerName):
   PlotBase(pParent, sDir),
-  m_oGeneralTauAllProngsPlots(this, "Matched/", sTauJetContainerName),
-  m_oHad1ProngPlots(this, "Matched/Tau1P/", sTauJetContainerName),             // tau1P plots : variables for tau ID
-  m_oHad3ProngPlots(this, "Matched/Tau3P/", sTauJetContainerName),             // tau3P plots : variables for tau ID
+  // Plots with the "primitive" tau selection
+  m_oGeneralTauAllProngsPlots(this, "NoCuts/Matched/", sTauJetContainerName),
+  m_oHad1ProngPlots(this, "NoCuts/Matched/Tau1P/", sTauJetContainerName),             // tau1P plots : variables for tau ID
+  m_oHad3ProngPlots(this, "NoCuts/Matched/Tau3P/", sTauJetContainerName),             // tau3P plots : variables for tau ID
   m_oElMatchedParamPlots(this, "Electron/", sTauJetContainerName),     // electron veto variables for electrons matching tau candidates	  
   m_oElMatchedEVetoPlots(this, "Electron/", sTauJetContainerName),     // electron veto variables for electrons matching tau candidates
-  m_oFakeGeneralTauAllProngsPlots(this,"Fake/", sTauJetContainerName),  // general tau all fake prongs plots
-  m_oFakeHad1ProngPlots(this,"Fake/Jet1P/", sTauJetContainerName), 		     // tau1P fake plots : variables for tau ID
-  m_oFakeHad3ProngPlots(this,"Fake/Jet3P/", sTauJetContainerName),  	       // tau3P fake plots : variables for tau ID
-  m_oRecoGeneralTauAllProngsPlots(this,"RecTau/All/",sTauJetContainerName),// "recTau_General"),  // general tau all fake prongs plots
-  m_oRecoHad1ProngPlots(this,"RecTau/1P/", sTauJetContainerName),//"recTau_1P"), 		     // tau1P fake plots : variables for tau ID
-  m_oRecoHad3ProngPlots(this,"RecTau/3P/", sTauJetContainerName),// "recTau_3P"),  	       // tau3P fake plots : variables for tau ID
-  m_oRecoTauAllProngsPlots(this,"RecTau/PFOs/", sTauJetContainerName),             // all tau reco, no match to truth
-  m_oMatchedTauAllProngsPlots(this,"Matched/PFOs/", sTauJetContainerName),
-  m_oFakeTauAllProngsPlots(this,"Fake/PFOs/", sTauJetContainerName),             // all tau reco, no match to truth
-  m_oMatchedTauEffPlots  (this,"Matched/Eff/All/", sTauJetContainerName),
-  m_oMatchedTauEff1PPlots(this,"Matched/Eff/Tau1P/", sTauJetContainerName),
-  m_oMatchedTauEff3PPlots(this,"Matched/Eff/Tau3P/", sTauJetContainerName),
-  m_oRecTauEffPlots  (this,"RecTau/Eff/All/", sTauJetContainerName),
-  m_oRecTauEff1PPlots(this,"RecTau/Eff/Tau1P/", sTauJetContainerName),
-  m_oRecTauEff3PPlots(this,"RecTau/Eff/Tau3P/", sTauJetContainerName),
-  m_oFakeTauEffPlots  (this,"Fake/Eff/All/", sTauJetContainerName),
-  m_oFakeTauEff1PPlots(this,"Fake/Eff/Tau1P/", sTauJetContainerName),
-  m_oFakeTauEff3PPlots(this,"Fake/Eff/Tau3P/", sTauJetContainerName),
-  m_oNewCorePlots(this,"RecTau/All/", sTauJetContainerName),             // all tau reco, newCore variables
-  m_oNewCoreMatchedPlots(this,"Matched/All/", sTauJetContainerName),             // all tau reco, newCore variables
-  m_oNewCoreFakePlots(this,"Fake/All/", sTauJetContainerName),             // all tau reco, newCore variables
-  m_oMigrationPlots(this,"Matched/Migration/", sTauJetContainerName)             // Migration Matrix
+  m_oFakeGeneralTauAllProngsPlots(this,"NoCuts/Fake/", sTauJetContainerName),  // general tau all fake prongs plots
+  m_oFakeHad1ProngPlots(this,"NoCuts/Fake/Jet1P/", sTauJetContainerName), 		     // tau1P fake plots : variables for tau ID
+  m_oFakeHad3ProngPlots(this,"NoCuts/Fake/Jet3P/", sTauJetContainerName),  	       // tau3P fake plots : variables for tau ID
+  m_oRecoGeneralTauAllProngsPlots(this,"NoCuts/RecTau/",sTauJetContainerName),// "recTau_General"),  // general tau all fake prongs plots
+  m_oRecoHad1ProngPlots(this,"NoCuts/RecTau/1P/", sTauJetContainerName),//"recTau_1P"), 		     // tau1P fake plots : variables for tau ID
+  m_oRecoHad3ProngPlots(this,"NoCuts/RecTau/3P/", sTauJetContainerName),// "recTau_3P"),  	       // tau3P fake plots : variables for tau ID
+  m_oRecoTauAllProngsPlots(this,"NoCuts/RecTau/PFOs/", sTauJetContainerName),             // all tau reco, no match to truth
+  m_oMatchedTauAllProngsPlots(this,"NoCuts/Matched/PFOs/", sTauJetContainerName),
+  m_oFakeTauAllProngsPlots(this,"NoCuts/Fake/PFOs/", sTauJetContainerName),             // all tau reco, no match to truth
+  m_oMatchedTauEffPlots  (this,"NoCuts/Matched/Eff/All/", sTauJetContainerName),
+  m_oMatchedTauEff1PPlots(this,"NoCuts/Matched/Eff/Tau1P/", sTauJetContainerName),
+  m_oMatchedTauEff3PPlots(this,"NoCuts/Matched/Eff/Tau3P/", sTauJetContainerName),
+  m_oRecTauEffPlots  (this,"NoCuts/RecTau/Eff/All/", sTauJetContainerName),
+  m_oRecTauEff1PPlots(this,"NoCuts/RecTau/Eff/Tau1P/", sTauJetContainerName),
+  m_oRecTauEff3PPlots(this,"NoCuts/RecTau/Eff/Tau3P/", sTauJetContainerName),
+  m_oFakeTauEffPlots  (this,"NoCuts/Fake/Eff/All/", sTauJetContainerName),
+  m_oFakeTauEff1PPlots(this,"NoCuts/Fake/Eff/Tau1P/", sTauJetContainerName),
+  m_oFakeTauEff3PPlots(this,"NoCuts/Fake/Eff/Tau3P/", sTauJetContainerName),
+  m_oNewCorePlots(this,"NoCuts/RecTau/All/", sTauJetContainerName),             // all tau reco, newCore variables
+  m_oNewCoreMatchedPlots(this,"NoCuts/Matched/All/", sTauJetContainerName),             // all tau reco, newCore variables
+  m_oNewCoreFakePlots(this,"NoCuts/Fake/All/", sTauJetContainerName),             // all tau reco, newCore variables
+  m_oMigrationPlots(this,"NoCuts/Matched/Migration/", sTauJetContainerName),             // Migration Matrix
+  
+  // Plots with the "nominal" tau selection
+  m_oFakeGeneralNom(this,"Nominal/Fake/", sTauJetContainerName),
+  m_oFakeHad1ProngNom(this,"Nominal/Fake/Jet1P/", sTauJetContainerName),
+  m_oFakeHad3ProngNom(this,"Nominal/Fake/Jet3P/", sTauJetContainerName),
+  m_oFakeTauEffPlotsNom(this, "Nominal/Fake/Eff/All/", sTauJetContainerName),
+  m_oFakeTauEff1PPlotsNom(this, "Nominal/Fake/Eff/Jet1P/", sTauJetContainerName),
+  m_oFakeTauEff3PPlotsNom(this, "Nominal/Fake/Eff/Jet3P/", sTauJetContainerName),
+  m_oFakeTauRecoTauPlotsNom(this, "Nominal/Fake/PFOs/", sTauJetContainerName),
+  m_oNewCoreFakePlotsNom(this, "Nominal/Fake/All/", sTauJetContainerName),
+
+  m_oRecoGeneralNom(this,"Nominal/RecTau/", sTauJetContainerName),
+  m_oRecoHad1ProngNom(this,"Nominal/RecTau/1P/", sTauJetContainerName),
+  m_oRecoHad3ProngNom(this,"Nominal/RecTau/3P/", sTauJetContainerName),
+  m_oRecTauEffPlotsNom(this, "Nominal/RecTau/Eff/All/", sTauJetContainerName),
+  m_oRecTauEff1PPlotsNom(this, "Nominal/RecTau/Eff/1P/", sTauJetContainerName),
+  m_oRecTauEff3PPlotsNom(this, "Nominal/RecTau/Eff/3P/", sTauJetContainerName),
+  m_oRecTauRecoTauPlotsNom(this, "Nominal/RecTau/PFOs/", sTauJetContainerName),
+  m_oNewCoreRecTauPlotsNom(this, "Nominal/RecTau/All/", sTauJetContainerName),
+
+  m_oMatchedGeneralNom(this,"Nominal/Matched/", sTauJetContainerName),
+  m_oMatchedHad1ProngNom(this,"Nominal/Matched/Tau1P/", sTauJetContainerName),
+  m_oMatchedHad3ProngNom(this,"Nominal/Matched/Tau3P/", sTauJetContainerName),
+  m_oMatchedTauEffPlotsNom(this, "Nominal/Matched/Eff/All/", sTauJetContainerName),
+  m_oMatchedTauEff1PPlotsNom(this, "Nominal/Matched/Eff/1P/", sTauJetContainerName),
+  m_oMatchedTauEff3PPlotsNom(this, "Nominal/Matched/Eff/3P/", sTauJetContainerName),
+  m_oMatchedTauRecoTauPlotsNom(this, "Nominal/Matched/PFOs/", sTauJetContainerName),
+  m_oMigrationPlotsNom(this, "Nominal/Matched/Migration/", sTauJetContainerName),
+  m_oNewCoreMatchedPlotsNom(this, "Nominal/Matched/All/", sTauJetContainerName)
 {}	
 
 // no fill method implement in order to let filling logic stay in the ManagedMonitoringTool

PhysicsAnalysis/TauID/TauHistUtils/TauHistUtils/Migration.h

@@ -36,9 +36,10 @@ namespace Tau{
 	Migration(PlotBase *pParent, std::string sDir, std::string sTauJetContainerName);
 	virtual ~Migration();
 
-	void fill(const xAOD::TauJet& tau,int nProng, int nNeu);
-	
-	//Tau::ParamPlots m_oParamPlots;
+	/* void fill(const xAOD::TauJet& tau,int nProng, int nNeu); */
+	void fill(
+	   const xAOD::TauJet& tau,
+	   xAOD::TauJetParameters::DecayMode trueMode);
 	
 	const char *m_lable[DECAYSIZE] = {
 	    "t10r10",
@@ -64,8 +65,8 @@ namespace Tau{
     private:
 	void initializePlots();
 	std::string m_sTauJetContainerName;
-	void decayModeFill(int trueMode, int recP, int recN,TH1 *histo);
-	void decayModeFill(int trueP,int trueN,int recP, int recN,TH1 *histo);
+	void decayModeFill(int trueMode, int recMode, TH1 *histo);
+	void decayModeFill(int trueMode, int recP, int recN, TH1 *histo);
     };
     
 }