Merge pull request #18 from hahassan7/btagFramework

hanseopark · web-flow · commit 16e4b254251b · 2024-12-20T00:25:01.000+09:00
small fix flavour-defintion and adding ML column on jetTaggerHF.cxx
diff --git a/PWGJE/DataModel/JetTagging.h b/PWGJE/DataModel/JetTagging.h
@@ -124,21 +124,21 @@ JETSV_TABLES_DEF(Charged, SecondaryVertex2Prong, "2PRONG");
 #define JETFLAVOURDEF_TABLE_DEF(_jet_type_, _name_, _description_) \
   namespace _name_##flavourdef                                     \
   {                                                                \
-    DECLARE_SOA_COLUMN(Origin, origin, int);                       \
+    DECLARE_SOA_COLUMN(Origin, origin, int8_t);                    \
   }                                                                \
   DECLARE_SOA_TABLE(_jet_type_##FlavourDef, "AOD", _description_ "FlavourDef", _name_##flavourdef::Origin);
 
 #define JETTAGGING_TABLE_DEF(_jet_type_, _name_, _description_)       \
   namespace _name_##tagging                                           \
   {                                                                   \
-    DECLARE_SOA_COLUMN(Origin, origin, int);                          \
-    DECLARE_SOA_COLUMN(JetProb, jetProb, std::vector<float>);         \
     DECLARE_SOA_COLUMN(FlagtaggedjetIP, flagtaggedjetIP, bool);       \
     DECLARE_SOA_COLUMN(FlagtaggedjetIPxyz, flagtaggedjetIPxyz, bool); \
     DECLARE_SOA_COLUMN(FlagtaggedjetSV, flagtaggedjetSV, bool);       \
     DECLARE_SOA_COLUMN(FlagtaggedjetSVxyz, flagtaggedjetSVxyz, bool); \
+    DECLARE_SOA_COLUMN(ScoreJetML, scoreML, float);                   \
+    DECLARE_SOA_COLUMN(JetProb, jetProb, float);                      \
   }                                                                   \
-  DECLARE_SOA_TABLE(_jet_type_##Tags, "AOD", _description_ "Tags", _name_##tagging::Origin, _name_##tagging::JetProb, _name_##tagging::FlagtaggedjetIP, _name_##tagging::FlagtaggedjetIPxyz, _name_##tagging::FlagtaggedjetSV, _name_##tagging::FlagtaggedjetSVxyz);
+  DECLARE_SOA_TABLE(_jet_type_##Tags, "AOD", _description_ "Tags", _name_##tagging::FlagtaggedjetIP, _name_##tagging::FlagtaggedjetIPxyz, _name_##tagging::FlagtaggedjetSV, _name_##tagging::FlagtaggedjetSVxyz, _name_##tagging::ScoreJetML, _name_##tagging::JetProb);
 
 #define JETTAGGING_TABLES_DEF(_jet_type_, _description_)                                                       \
   JETTAGGING_TABLE_DEF(_jet_type_##Jet, _jet_type_##jet, _description_)                                        \
diff --git a/PWGJE/TableProducer/heavyFlavourDefinition.cxx b/PWGJE/TableProducer/heavyFlavourDefinition.cxx
@@ -47,7 +47,6 @@ struct HeavyFlavourDefinitionTask {
   using JetTracksMCD = soa::Join<aod::JetTracksMCD, aod::JTrackExtras, aod::JTrackPIs>;
   Preslice<aod::JetParticles> particlesPerCollision = aod::jmcparticle::mcCollisionId;
 
-  HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject};
   void init(InitContext const&)
   {
   }
@@ -60,7 +59,7 @@ struct HeavyFlavourDefinitionTask {
   void processMCD(aod::JetCollision const& /*collision*/, JetTableMCD const& mcdjets, JetTracksMCD const& jtracks, aod::JetParticles const& particles)
   {
     for (auto const& mcdjet : mcdjets) {
-      int origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, jtracks, particles, maxDeltaR, searchUpToQuark);
+      int8_t origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, jtracks, particles, maxDeltaR, searchUpToQuark);
       flavourTableMCD(origin);
     }
   }
@@ -70,7 +69,7 @@ struct HeavyFlavourDefinitionTask {
   {
     for (auto const& mcdjet : mcdjets) {
       auto const particlesPerColl = particles.sliceBy(particlesPerCollision, collision.mcCollisionId());
-      int origin = -1;
+      int8_t origin = -1;
       for (auto const& mcpjet : mcdjet.template matchedJetGeo_as<soa::Join<JetTableMCP, aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>>()) {
         if (searchUpToQuark) {
           origin = jettaggingutilities::getJetFlavor(mcpjet, particlesPerColl);
@@ -86,21 +85,20 @@ struct HeavyFlavourDefinitionTask {
   void processMCP(JetTableMCP const& mcpjets, aod::JetParticles const& particles)
   {
     for (auto const& mcpjet : mcpjets) {
-      int origin = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, searchUpToQuark);
+      int8_t origin = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, searchUpToQuark);
       flavourTableMCP(origin);
     }
   }
   PROCESS_SWITCH(HeavyFlavourDefinitionTask, processMCP, "Fill definition of flavour for mcp jets", true);
 
-  void processMCPRun2(JetTableMCP const& mcpjets, aod::JetParticles const& particles)
+  void processMCPRun2(aod::JMcCollisions::iterator const& /*collision*/, JetTableMCP const& mcpjets, aod::JetParticles const& particles)
   {
     for (auto const& mcpjet : mcpjets) {
-      auto const particlesPerColl = particles.sliceBy(particlesPerCollision, mcpjet.mcCollisionId());
-      int origin = -1;
+      int8_t origin = -1;
       if (searchUpToQuark) {
-        origin = jettaggingutilities::getJetFlavor(mcpjet, particlesPerColl);
+        origin = jettaggingutilities::getJetFlavor(mcpjet, particles);
       } else {
-        origin = jettaggingutilities::getJetFlavorHadron(mcpjet, particlesPerColl);
+        origin = jettaggingutilities::getJetFlavorHadron(mcpjet, particles);
       }
       flavourTableMCP(origin);
     }
@@ -110,22 +108,14 @@ struct HeavyFlavourDefinitionTask {
 
 using JetFlavourDefCharged = HeavyFlavourDefinitionTask<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents>, soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents>, aod::ChargedMCDetectorLevelJetFlavourDef, aod::ChargedMCParticleLevelJetFlavourDef>;
 using JetFlavourDefFull = HeavyFlavourDefinitionTask<soa::Join<aod::FullMCDetectorLevelJets, aod::FullMCDetectorLevelJetConstituents>, soa::Join<aod::FullMCParticleLevelJets, aod::FullMCParticleLevelJetConstituents>, aod::FullMCDetectorLevelJetFlavourDef, aod::FullMCParticleLevelJetFlavourDef>;
-// using JetTaggerhfNeutral = HeavyFlavourDefinitionTask<soa::Join<aod::NeutralMCDetectorLevelJets, aod::NeutralMCDetectorLevelJetConstituents>, aod::NeutralMCDetectorLevelJetTags, aod::NeutralMCParticleLevelJetFlavourDef>;
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
 
   std::vector<o2::framework::DataProcessorSpec> tasks;
 
-  tasks.emplace_back(
-    adaptAnalysisTask<JetFlavourDefCharged>(cfgc));
+  tasks.emplace_back(adaptAnalysisTask<JetFlavourDefCharged>(cfgc, SetDefaultProcesses{}, TaskName{"jet-hfdefinition-charged"}));
+  tasks.emplace_back(adaptAnalysisTask<JetFlavourDefFull>(cfgc, SetDefaultProcesses{}, TaskName{"jet-hfdefinition-full"}));
 
-  tasks.emplace_back(
-    adaptAnalysisTask<JetFlavourDefFull>(cfgc));
-  /*
-    tasks.emplace_back(
-      adaptAnalysisTask<JetFlavourDefNeutral>(cfgc,
-                                                  SetDefaultProcesses{}));
-  */
   return WorkflowSpec{tasks};
 }
diff --git a/PWGJE/TableProducer/jetTaggerHF.cxx b/PWGJE/TableProducer/jetTaggerHF.cxx
@@ -33,12 +33,11 @@ using namespace o2;
 using namespace o2::framework;
 using namespace o2::framework::expressions;
 
-template <typename JetTableData, typename JetTableMCD, typename JetTableMCP, typename JetTaggingTableData, typename JetTaggingTableMCD, typename JetTaggingTableMCP>
+template <typename JetTableData, typename JetTableMCD, typename JetTaggingTableData, typename JetTaggingTableMCD>
 struct JetTaggerHFTask {
 
   Produces<JetTaggingTableData> taggingTableData;
   Produces<JetTaggingTableMCD> taggingTableMCD;
-  Produces<JetTaggingTableMCP> taggingTableMCP;
 
   // configuration topological cut for track and sv
   Configurable<float> trackDcaXYMax{"trackDcaXYMax", 1, "minimum DCA xy acceptance for tracks [cm]"};
@@ -51,11 +50,6 @@ struct JetTaggerHFTask {
   Configurable<float> prongChi2PCAMax{"prongChi2PCAMax", 100, "maximum Chi2 PCA of decay length of prongs"};
   Configurable<float> svDispersionMax{"svDispersionMax", 1, "maximum dispersion of sv"};
 
-  // jet flavour definition
-  Configurable<float> maxDeltaR{"maxDeltaR", 0.25, "maximum distance of jet axis from flavour initiating parton"};
-  Configurable<bool> removeGluonShower{"removeGluonShower", true, "find jet origin removed gluon spliting"}; // true:: remove gluon spliting
-  Configurable<bool> searchUpToQuark{"searchUpToQuark", true, "Finding first mother in particles to quark"};
-
   // configuration about IP method
   Configurable<bool> useJetProb{"useJetProb", false, "fill table for track counting algorithm"};
   Configurable<bool> trackProbQA{"trackProbQA", false, "fill track probability histograms separately for geometric positive and negative tracks for QA"};
@@ -76,17 +70,10 @@ struct JetTaggerHFTask {
 
   // axis spec
   ConfigurableAxis binTrackProbability{"binTrackProbability", {100, 0.f, 1.f}, ""};
-  ConfigurableAxis binJetFlavour{"binJetFlavour", {6, -0.5, 5.5}, ""};
 
   using JetTagTracksData = soa::Join<aod::JetTracks, aod::JTrackExtras, aod::JTrackPIs>;
   using JetTagTracksMCD = soa::Join<aod::JetTracksMCD, aod::JTrackExtras, aod::JTrackPIs>;
 
-  std::vector<float> vecParamsData;
-  std::vector<float> vecParamsIncJetMC;
-  std::vector<float> vecParamsCharmJetMC;
-  std::vector<float> vecParamsBeautyJetMC;
-  std::vector<float> vecParamsLfJetMC;
-  std::vector<float> jetProb;
   bool useResoFuncFromIncJet = false;
   int maxOrder = -1;
   int resoFuncMatch = 0;
@@ -96,6 +83,13 @@ struct JetTaggerHFTask {
   std::unique_ptr<TF1> fSignImpXYSigBeautyJetMC = nullptr;
   std::unique_ptr<TF1> fSignImpXYSigLfJetMC = nullptr;
 
+  std::vector<int8_t> decisionIPs;
+  std::vector<int8_t> decisionIPs3D;
+  std::vector<int8_t> decisionSV;
+  std::vector<int8_t> decisionSV3D;
+  std::vector<float> scoreML;
+  std::vector<float> jetProb;
+
   template <typename T, typename U>
   void calculateJetProbability(int origin, T const& jet, U const& jtracks, std::vector<float>& jetProb, bool const& isMC = true)
   {
@@ -164,6 +158,12 @@ struct JetTaggerHFTask {
   HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject};
   void init(InitContext const&)
   {
+    std::vector<float> vecParamsData;
+    std::vector<float> vecParamsIncJetMC;
+    std::vector<float> vecParamsCharmJetMC;
+    std::vector<float> vecParamsBeautyJetMC;
+    std::vector<float> vecParamsLfJetMC;
+
     maxOrder = numCount + 1; // 0: untagged, >1 : N ordering
 
     // Set up the resolution function
@@ -257,7 +257,7 @@ struct JetTaggerHFTask {
       if (jettaggingutilities::isGreaterThanTaggingPoint(jet, jtracks, trackDcaXYMax, trackDcaZMax, tagPointForIP, minIPCount, true))
         flagtaggedjetIPxyz = true;
 
-      taggingTableData(0, jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
+      taggingTableData(jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
     }
   }
   PROCESS_SWITCH(JetTaggerHFTask, processData, "Fill tagging decision for data jets", false);
@@ -281,24 +281,19 @@ struct JetTaggerHFTask {
         flagtaggedjetIPxyz = true;
       flagtaggedjetSV = jettaggingutilities::isTaggedJetSV(jet, prongs, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyMax, svDispersionMax, false, tagPointForSV);
       flagtaggedjetSVxyz = jettaggingutilities::isTaggedJetSV(jet, prongs, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyzMax, svDispersionMax, true, tagPointForSV);
-      taggingTableData(0, jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
+      taggingTableData(jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
     }
   }
   PROCESS_SWITCH(JetTaggerHFTask, processDataWithSV, "Fill tagging decision for data jets", false);
 
-  void processMCD(aod::JetCollision const& /*collision*/, JetTableMCD const& mcdjets, JetTagTracksMCD const& jtracks, aod::JetParticles const& particles)
+  void processMCD(aod::JetCollision const& /*collision*/, soa::Join<JetTableMCD, aod::ChargedMCDetectorLevelJetFlavourDef> const& mcdjets, JetTagTracksMCD const& jtracks, aod::JetParticles const& particles)
   {
     for (auto& mcdjet : mcdjets) {
       bool flagtaggedjetIP = false;
       bool flagtaggedjetIPxyz = false;
       bool flagtaggedjetSV = false;
       bool flagtaggedjetSVxyz = false;
-      typename JetTagTracksMCD::iterator hftrack;
-      int origin = 0;
-      if (removeGluonShower)
-        origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, jtracks, particles, maxDeltaR, searchUpToQuark);
-      else
-        origin = jettaggingutilities::jetTrackFromHFShower(mcdjet, jtracks, particles, hftrack, searchUpToQuark);
+      int origin = mcdjet.origin();
       if (useJetProb) {
         calculateJetProbability(origin, mcdjet, jtracks, jetProb);
         if (trackProbQA) {
@@ -309,24 +304,19 @@ struct JetTaggerHFTask {
         flagtaggedjetIP = true;
       if (jettaggingutilities::isGreaterThanTaggingPoint(mcdjet, jtracks, trackDcaXYMax, trackDcaZMax, tagPointForIP, minIPCount, true))
         flagtaggedjetIPxyz = true;
-      taggingTableMCD(origin, jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
+      taggingTableMCD(jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
     }
   }
   PROCESS_SWITCH(JetTaggerHFTask, processMCD, "Fill tagging decision for mcd jets", false);
 
-  void processMCDWithSV(aod::JetCollision const& /*collision*/, soa::Join<JetTableMCD, aod::MCDSecondaryVertex3ProngIndices> const& mcdjets, JetTagTracksMCD const& jtracks, aod::MCDSecondaryVertex3Prongs const& prongs, aod::JetParticles const& particles)
+  void processMCDWithSV(aod::JetCollision const& /*collision*/, soa::Join<JetTableMCD, aod::ChargedMCDetectorLevelJetFlavourDef, aod::MCDSecondaryVertex3ProngIndices> const& mcdjets, JetTagTracksMCD const& jtracks, aod::MCDSecondaryVertex3Prongs const& prongs)
   {
     for (auto& mcdjet : mcdjets) {
       bool flagtaggedjetIP = false;
       bool flagtaggedjetIPxyz = false;
       bool flagtaggedjetSV = false;
       bool flagtaggedjetSVxyz = false;
-      typename JetTagTracksMCD::iterator hftrack;
-      int origin = 0;
-      if (removeGluonShower)
-        origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, jtracks, particles, maxDeltaR, searchUpToQuark);
-      else
-        origin = jettaggingutilities::jetTrackFromHFShower(mcdjet, jtracks, particles, hftrack, searchUpToQuark);
+      int origin = mcdjet.origin();
       if (useJetProb) {
         calculateJetProbability(origin, mcdjet, jtracks, jetProb);
         if (trackProbQA) {
@@ -339,67 +329,34 @@ struct JetTaggerHFTask {
         flagtaggedjetIPxyz = true;
       flagtaggedjetSV = jettaggingutilities::isTaggedJetSV(mcdjet, prongs, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyMax, prongIPxyMin, prongIPxyMax, svDispersionMax, false, tagPointForSV);
       flagtaggedjetSVxyz = jettaggingutilities::isTaggedJetSV(mcdjet, prongs, prongChi2PCAMin, prongChi2PCAMax, prongsigmaLxyzMax, prongIPxyMin, prongIPxyMax, svDispersionMax, true, tagPointForSV);
-      taggingTableMCD(origin, jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
+      taggingTableMCD(jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
     }
   }
   PROCESS_SWITCH(JetTaggerHFTask, processMCDWithSV, "Fill tagging decision for mcd jets with sv", false);
 
-  void processMCP(aod::JetMcCollision const& /*collision*/, JetTableMCP const& mcpjets, aod::JetParticles const& particles)
+  void processDataAlgorithmML(aod::JetCollision const& /*collision*/, soa::Join<JetTableData, aod::DataSecondaryVertex3ProngIndices> const& /*allJets*/, JetTagTracksData const& /*allTracks*/, aod::DataSecondaryVertex3Prongs const& allSVs)
   {
-    for (auto& mcpjet : mcpjets) {
-      bool flagtaggedjetIP = false;
-      bool flagtaggedjetIPxyz = false;
-      bool flagtaggedjetSV = false;
-      bool flagtaggedjetSVxyz = false;
-      typename aod::JetParticles::iterator hfparticle;
-      int origin = 0;
-      // TODO
-      if (removeGluonShower) {
-        if (jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, searchUpToQuark))
-          origin = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, searchUpToQuark);
-        else
-          origin = 0;
-      } else {
-        if (jettaggingutilities::jetParticleFromHFShower(mcpjet, particles, hfparticle, searchUpToQuark))
-          origin = jettaggingutilities::jetParticleFromHFShower(mcpjet, particles, hfparticle, searchUpToQuark);
-        else
-          origin = 0;
-      }
-      jetProb.clear();
-      jetProb.reserve(maxOrder);
-      jetProb.push_back(-1);
-      taggingTableMCP(origin, jetProb, flagtaggedjetIP, flagtaggedjetIPxyz, flagtaggedjetSV, flagtaggedjetSVxyz);
-    }
+    // To create table for ML
   }
-  PROCESS_SWITCH(JetTaggerHFTask, processMCP, "Fill tagging decision for mcp jets with sv", false);
+  PROCESS_SWITCH(JetTaggerHFTask, processDataAlgorithmML, "Fill ML evaluation score for data jets", false);
 
-  void processTraining(aod::JetCollision const& /*collision*/, JetTableMCD const& /*mcdjets*/, JetTagTracksMCD const& /*tracks*/)
+  void processMCDAlgorithmML(aod::JetCollision const& /*collision*/, soa::Join<JetTableMCD, aod::ChargedMCDetectorLevelJetFlavourDef, aod::MCDSecondaryVertex3ProngIndices> const& /*allJets*/, JetTagTracksMCD const& /*allTracks*/, aod::MCDSecondaryVertex3Prongs const& allSVs)
   {
     // To create table for ML
   }
-  PROCESS_SWITCH(JetTaggerHFTask, processTraining, "Fill tagging decision for mcd jets", false);
+  PROCESS_SWITCH(JetTaggerHFTask, processMCDAlgorithmML, "Fill ML evaluation score for MCD jets", false);
 };
 
-using JetTaggerChargedJets = JetTaggerHFTask<soa::Join<aod::ChargedJets, aod::ChargedJetConstituents>, soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents>, soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents>, aod::ChargedJetTags, aod::ChargedMCDetectorLevelJetTags, aod::ChargedMCParticleLevelJetTags>;
-using JetTaggerFullJets = JetTaggerHFTask<soa::Join<aod::FullJets, aod::FullJetConstituents>, soa::Join<aod::FullMCDetectorLevelJets, aod::FullMCDetectorLevelJetConstituents>, soa::Join<aod::FullMCParticleLevelJets, aod::FullMCParticleLevelJetConstituents>, aod::FullJetTags, aod::FullMCDetectorLevelJetTags, aod::FullMCParticleLevelJetTags>;
-// using JetTaggerNeutralJets = JetTaggerHFTask<soa::Join<aod::NeutralJets, aod::NeutralJetConstituents>,soa::Join<aod::NeutralMCDetectorLevelJets, aod::NeutralMCDetectorLevelJetConstituents>, aod::NeutralJetTags, aod::NeutralMCDetectorLevelJetTags>;
+using JetTaggerChargedJets = JetTaggerHFTask<soa::Join<aod::ChargedJets, aod::ChargedJetConstituents>, soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents>, aod::ChargedJetTags, aod::ChargedMCDetectorLevelJetTags>;
+using JetTaggerFullJets = JetTaggerHFTask<soa::Join<aod::FullJets, aod::FullJetConstituents>, soa::Join<aod::FullMCDetectorLevelJets, aod::FullMCDetectorLevelJetConstituents>, aod::FullJetTags, aod::FullMCDetectorLevelJetTags>;
 
 WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
 {
 
   std::vector<o2::framework::DataProcessorSpec> tasks;
 
-  tasks.emplace_back(
-    adaptAnalysisTask<JetTaggerChargedJets>(cfgc,
-                                            SetDefaultProcesses{}, TaskName{"jet-taggerhf-charged"}));
-
-  tasks.emplace_back(
-    adaptAnalysisTask<JetTaggerFullJets>(cfgc,
-                                         SetDefaultProcesses{}, TaskName{"jet-taggerhf-full"}));
-  /*
-    tasks.emplace_back(
-      adaptAnalysisTask<JetTaggerNeutralJets>(cfgc,
-                                                  SetDefaultProcesses{}, TaskName{"jet-taggerhf-neutral"}));
-  */
+  tasks.emplace_back(adaptAnalysisTask<JetTaggerChargedJets>(cfgc, SetDefaultProcesses{}, TaskName{"jet-taggerhf-charged"}));
+  tasks.emplace_back(adaptAnalysisTask<JetTaggerFullJets>(cfgc, SetDefaultProcesses{}, TaskName{"jet-taggerhf-full"}));
+
   return WorkflowSpec{tasks};
 }

Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,6 @@ struct HeavyFlavourDefinitionTask {`
`47`	`47`	`using JetTracksMCD = soa::Join<aod::JetTracksMCD, aod::JTrackExtras, aod::JTrackPIs>;`
`48`	`48`	`Preslice<aod::JetParticles> particlesPerCollision = aod::jmcparticle::mcCollisionId;`
`49`	`49`
`50`		`- HistogramRegistry registry{"registry", {}, OutputObjHandlingPolicy::AnalysisObject};`
`51`	`50`	`void init(InitContext const&)`
`52`	`51`	`{`
`53`	`52`	`}`
`@@ -60,7 +59,7 @@ struct HeavyFlavourDefinitionTask {`
`60`	`59`	`void processMCD(aod::JetCollision const& /collision/, JetTableMCD const& mcdjets, JetTracksMCD const& jtracks, aod::JetParticles const& particles)`
`61`	`60`	`{`
`62`	`61`	`for (auto const& mcdjet : mcdjets) {`
`63`		`- int origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, jtracks, particles, maxDeltaR, searchUpToQuark);`
	`62`	`+ int8_t origin = jettaggingutilities::mcdJetFromHFShower(mcdjet, jtracks, particles, maxDeltaR, searchUpToQuark);`
`64`	`63`	`flavourTableMCD(origin);`
`65`	`64`	`}`
`66`	`65`	`}`
`@@ -70,7 +69,7 @@ struct HeavyFlavourDefinitionTask {`
`70`	`69`	`{`
`71`	`70`	`for (auto const& mcdjet : mcdjets) {`
`72`	`71`	`auto const particlesPerColl = particles.sliceBy(particlesPerCollision, collision.mcCollisionId());`
`73`		`- int origin = -1;`
	`72`	`+ int8_t origin = -1;`
`74`	`73`	`for (auto const& mcpjet : mcdjet.template matchedJetGeo_as<soa::Join<JetTableMCP, aod::ChargedMCParticleLevelJetsMatchedToChargedMCDetectorLevelJets>>()) {`
`75`	`74`	`if (searchUpToQuark) {`
`76`	`75`	`origin = jettaggingutilities::getJetFlavor(mcpjet, particlesPerColl);`
`@@ -86,21 +85,20 @@ struct HeavyFlavourDefinitionTask {`
`86`	`85`	`void processMCP(JetTableMCP const& mcpjets, aod::JetParticles const& particles)`
`87`	`86`	`{`
`88`	`87`	`for (auto const& mcpjet : mcpjets) {`
`89`		`- int origin = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, searchUpToQuark);`
	`88`	`+ int8_t origin = jettaggingutilities::mcpJetFromHFShower(mcpjet, particles, maxDeltaR, searchUpToQuark);`
`90`	`89`	`flavourTableMCP(origin);`
`91`	`90`	`}`
`92`	`91`	`}`
`93`	`92`	`PROCESS_SWITCH(HeavyFlavourDefinitionTask, processMCP, "Fill definition of flavour for mcp jets", true);`
`94`	`93`
`95`		`- void processMCPRun2(JetTableMCP const& mcpjets, aod::JetParticles const& particles)`
	`94`	`+ void processMCPRun2(aod::JMcCollisions::iterator const& /collision/, JetTableMCP const& mcpjets, aod::JetParticles const& particles)`
`96`	`95`	`{`
`97`	`96`	`for (auto const& mcpjet : mcpjets) {`
`98`		`- auto const particlesPerColl = particles.sliceBy(particlesPerCollision, mcpjet.mcCollisionId());`
`99`		`- int origin = -1;`
	`97`	`+ int8_t origin = -1;`
`100`	`98`	`if (searchUpToQuark) {`
`101`		`- origin = jettaggingutilities::getJetFlavor(mcpjet, particlesPerColl);`
	`99`	`+ origin = jettaggingutilities::getJetFlavor(mcpjet, particles);`
`102`	`100`	`} else {`
`103`		`- origin = jettaggingutilities::getJetFlavorHadron(mcpjet, particlesPerColl);`
	`101`	`+ origin = jettaggingutilities::getJetFlavorHadron(mcpjet, particles);`
`104`	`102`	`}`
`105`	`103`	`flavourTableMCP(origin);`
`106`	`104`	`}`
`@@ -110,22 +108,14 @@ struct HeavyFlavourDefinitionTask {`
`110`	`108`
`111`	`109`	`using JetFlavourDefCharged = HeavyFlavourDefinitionTask<soa::Join<aod::ChargedMCDetectorLevelJets, aod::ChargedMCDetectorLevelJetConstituents>, soa::Join<aod::ChargedMCParticleLevelJets, aod::ChargedMCParticleLevelJetConstituents>, aod::ChargedMCDetectorLevelJetFlavourDef, aod::ChargedMCParticleLevelJetFlavourDef>;`
`112`	`110`	`using JetFlavourDefFull = HeavyFlavourDefinitionTask<soa::Join<aod::FullMCDetectorLevelJets, aod::FullMCDetectorLevelJetConstituents>, soa::Join<aod::FullMCParticleLevelJets, aod::FullMCParticleLevelJetConstituents>, aod::FullMCDetectorLevelJetFlavourDef, aod::FullMCParticleLevelJetFlavourDef>;`
`113`		`-// using JetTaggerhfNeutral = HeavyFlavourDefinitionTask<soa::Join<aod::NeutralMCDetectorLevelJets, aod::NeutralMCDetectorLevelJetConstituents>, aod::NeutralMCDetectorLevelJetTags, aod::NeutralMCParticleLevelJetFlavourDef>;`
`114`	`111`
`115`	`112`	`WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)`
`116`	`113`	`{`
`117`	`114`
`118`	`115`	`std::vector<o2::framework::DataProcessorSpec> tasks;`
`119`	`116`
`120`		`- tasks.emplace_back(`
`121`		`- adaptAnalysisTask<JetFlavourDefCharged>(cfgc));`
	`117`	`+ tasks.emplace_back(adaptAnalysisTask<JetFlavourDefCharged>(cfgc, SetDefaultProcesses{}, TaskName{"jet-hfdefinition-charged"}));`
	`118`	`+ tasks.emplace_back(adaptAnalysisTask<JetFlavourDefFull>(cfgc, SetDefaultProcesses{}, TaskName{"jet-hfdefinition-full"}));`
`122`	`119`
`123`		`- tasks.emplace_back(`
`124`		`- adaptAnalysisTask<JetFlavourDefFull>(cfgc));`
`125`		`- /*`
`126`		`- tasks.emplace_back(`
`127`		`- adaptAnalysisTask<JetFlavourDefNeutral>(cfgc,`
`128`		`- SetDefaultProcesses{}));`
`129`		`- */`
`130`	`120`	`return WorkflowSpec{tasks};`
`131`	`121`	`}`