derivedDataSelector.cxx

// Copyright 2019-2020 CERN and copyright holders of ALICE O2.
// See https://alice-o2.web.cern.ch/copyright for details of the copyright holders.
// All rights not expressly granted are reserved.
//
// This software is distributed under the terms of the GNU General Public
// License v3 (GPL Version 3), copied verbatim in the file "COPYING".
//
// In applying this license CERN does not waive the privileges and immunities
// granted to it by virtue of its status as an Intergovernmental Organization
// or submit itself to any jurisdiction.

/// \file jetderiveddataselector.cxx
/// \brief Task to store decision of which events to skim for producing jet framework tables (aod::JetCollisions, aod::JetTracks, aod::JetClusters, ...)
/// while adjusting indices accordingly
///
/// \author Nima Zardoshti <nima.zardoshti@cern.ch>
/// \author Jochen Klein <jochen.klein@cern.ch>

#include "JetDerivedDataUtilities.h"

#include "PWGJE/DataModel/Jet.h"
#include "PWGJE/DataModel/JetReducedData.h"
#include "PWGJE/DataModel/JetReducedDataSelector.h"

#include <Framework/ASoA.h>
#include <Framework/AnalysisHelpers.h>
#include <Framework/AnalysisTask.h>
#include <Framework/Configurable.h>
#include <Framework/DataProcessorSpec.h>
#include <Framework/InitContext.h>
#include <Framework/runDataProcessing.h>

#include <TRandom3.h>

#include <cstdlib>
#include <string>
#include <type_traits>
#include <vector>

using namespace o2;
using namespace o2::framework;
using namespace o2::framework::expressions;

struct JetDerivedDataSelector {

  Produces<aod::JCollisionSelections> collisionSelectionsTable;
  Produces<aod::JMcCollisionSelections> mcCollisionSelectionsTable;

  struct : ConfigurableGroup {
    Configurable<float> thresholdChargedJetPtMin{"thresholdChargedJetPtMin", 0.0, "Minimum charged jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedJetPtMin{"thresholdChargedEventWiseSubtractedJetPtMin", 0.0, "Minimum charged event-wise subtracted jet pt to accept event"};
    Configurable<float> thresholdChargedMCPJetPtMin{"thresholdChargedMCPJetPtMin", 0.0, "Minimum charged mcp jet pt to accept event"};
    Configurable<float> thresholdFullJetPtMin{"thresholdFullJetPtMin", 0.0, "Minimum full jet pt to accept event"};
    Configurable<float> thresholdFullMCPJetPtMin{"thresholdFullMCPJetPtMin", 0.0, "Minimum full mcp jet pt to accept event"};
    Configurable<float> thresholdD0PtMin{"thresholdD0PtMin", 0.0, "Minimum D0 pt to accept event"};
    Configurable<float> thresholdD0MCPPtMin{"thresholdD0MCPPtMin", 0.0, "Minimum mcp D0 pt to accept event"};
    Configurable<float> thresholdChargedD0JetPtMin{"thresholdChargedD0JetPtMin", 0.0, "Minimum charged D0 jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedD0JetPtMin{"thresholdChargedEventWiseSubtractedD0JetPtMin", 0.0, "Minimum charged event-wise subtracted D0 jet pt to accept event"};
    Configurable<float> thresholdChargedD0MCPJetPtMin{"thresholdChargedD0MCPJetPtMin", 0.0, "Minimum charged D0 mcp jet pt to accept event"};
    Configurable<float> thresholdDplusPtMin{"thresholdDplusPtMin", 0.0, "Minimum Dplus pt to accept event"};
    Configurable<float> thresholdDplusMCPPtMin{"thresholdDplusMCPPtMin", 0.0, "Minimum mcp Dplus pt to accept event"};
    Configurable<float> thresholdChargedDplusJetPtMin{"thresholdChargedDplusJetPtMin", 0.0, "Minimum charged Dplus jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedDplusJetPtMin{"thresholdChargedEventWiseSubtractedDplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Dplus jet pt to accept event"};
    Configurable<float> thresholdChargedDplusMCPJetPtMin{"thresholdChargedDplusMCPJetPtMin", 0.0, "Minimum charged Dplus mcp jet pt to accept event"};
    Configurable<float> thresholdDsPtMin{"thresholdDsPtMin", 0.0, "Minimum Ds pt to accept event"};
    Configurable<float> thresholdDsMCPPtMin{"thresholdDsMCPPtMin", 0.0, "Minimum mcp Ds pt to accept event"};
    Configurable<float> thresholdChargedDsJetPtMin{"thresholdChargedDsJetPtMin", 0.0, "Minimum charged Ds jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedDsJetPtMin{"thresholdChargedEventWiseSubtractedDsJetPtMin", 0.0, "Minimum charged event-wise subtracted Ds jet pt to accept event"};
    Configurable<float> thresholdChargedDsMCPJetPtMin{"thresholdChargedDsMCPJetPtMin", 0.0, "Minimum charged Ds mcp jet pt to accept event"};
    Configurable<float> thresholdDstarPtMin{"thresholdDstarPtMin", 0.0, "Minimum Dstar pt to accept event"};
    Configurable<float> thresholdDstarMCPPtMin{"thresholdDstarMCPPtMin", 0.0, "Minimum mcp Dstar pt to accept event"};
    Configurable<float> thresholdChargedDstarJetPtMin{"thresholdChargedDstarJetPtMin", 0.0, "Minimum charged Dstar jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedDstarJetPtMin{"thresholdChargedEventWiseSubtractedDstarJetPtMin", 0.0, "Minimum charged event-wise subtracted Dstar jet pt to accept event"};
    Configurable<float> thresholdChargedDstarMCPJetPtMin{"thresholdChargedDstarMCPJetPtMin", 0.0, "Minimum charged Dstar mcp jet pt to accept event"};
    Configurable<float> thresholdLcPtMin{"thresholdLcPtMin", 0.0, "Minimum Lc pt to accept event"};
    Configurable<float> thresholdLcMCPPtMin{"thresholdLcMCPPtMin", 0.0, "Minimum mcp Lc pt to accept event"};
    Configurable<float> thresholdChargedLcJetPtMin{"thresholdChargedLcJetPtMin", 0.0, "Minimum charged Lc jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedLcJetPtMin{"thresholdChargedEventWiseSubtractedLcJetPtMin", 0.0, "Minimum charged event-wise subtracted Lc jet pt to accept event"};
    Configurable<float> thresholdChargedLcMCPJetPtMin{"thresholdChargedLcMCPJetPtMin", 0.0, "Minimum charged Lc mcp jet pt to accept event"};
    Configurable<float> thresholdB0PtMin{"thresholdB0PtMin", 0.0, "Minimum B0 pt to accept event"};
    Configurable<float> thresholdB0MCPPtMin{"thresholdB0MCPPtMin", 0.0, "Minimum mcp B0 pt to accept event"};
    Configurable<float> thresholdChargedB0JetPtMin{"thresholdChargedB0JetPtMin", 0.0, "Minimum charged B0 jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedB0JetPtMin{"thresholdChargedEventWiseSubtractedB0JetPtMin", 0.0, "Minimum charged event-wise subtracted B0 jet pt to accept event"};
    Configurable<float> thresholdChargedB0MCPJetPtMin{"thresholdChargedB0MCPJetPtMin", 0.0, "Minimum charged B0 mcp jet pt to accept event"};
    Configurable<float> thresholdBplusPtMin{"thresholdBplusPtMin", 0.0, "Minimum Bplus pt to accept event"};
    Configurable<float> thresholdBplusMCPPtMin{"thresholdBplusMCPPtMin", 0.0, "Minimum mcp Bplus pt to accept event"};
    Configurable<float> thresholdChargedBplusJetPtMin{"thresholdChargedBplusJetPtMin", 0.0, "Minimum charged Bplus jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedBplusJetPtMin{"thresholdChargedEventWiseSubtractedBplusJetPtMin", 0.0, "Minimum charged event-wise subtracted Bplus jet pt to accept event"};
    Configurable<float> thresholdChargedBplusMCPJetPtMin{"thresholdChargedBplusMCPJetPtMin", 0.0, "Minimum charged Bplus mcp jet pt to accept event"};
    Configurable<float> thresholdXicToXiPiPiPtMin{"thresholdXicToXiPiPiPtMin", 0.0, "Minimum XicToXiPiPi pt to accept event"};
    Configurable<float> thresholdXicToXiPiPiMCPPtMin{"thresholdXicToXiPiPiMCPPtMin", 0.0, "Minimum mcp XicToXiPiPi pt to accept event"};
    Configurable<float> thresholdChargedXicToXiPiPiJetPtMin{"thresholdChargedXicToXiPiPiJetPtMin", 0.0, "Minimum charged XicToXiPiPi jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedXicToXiPiPiJetPtMin{"thresholdChargedEventWiseSubtractedXicToXiPiPiJetPtMin", 0.0, "Minimum charged event-wise subtracted XicToXiPiPi jet pt to accept event"};
    Configurable<float> thresholdChargedXicToXiPiPiMCPJetPtMin{"thresholdChargedXicToXiPiPiMCPJetPtMin", 0.0, "Minimum charged XicToXiPiPi mcp jet pt to accept event"};
    Configurable<float> thresholdDielectronPtMin{"thresholdDielectronPtMin", 0.0, "Minimum Dielectron pt to accept event"};
    Configurable<float> thresholdDielectronMCPPtMin{"thresholdDielectronMCPPtMin", 0.0, "Minimum mcp Dielectron pt to accept event"};
    Configurable<float> thresholdChargedDielectronJetPtMin{"thresholdChargedDielectronJetPtMin", 0.0, "Minimum charged Dielectron jet pt to accept event"};
    Configurable<float> thresholdChargedEventWiseSubtractedDielectronJetPtMin{"thresholdChargedEventWiseSubtractedDielectronJetPtMin", 0.0, "Minimum charged event-wise subtracted Dielectron jet pt to accept event"};
    Configurable<float> thresholdChargedDielectronMCPJetPtMin{"thresholdChargedDielectronMCPJetPtMin", 0.0, "Minimum charged Dielectron mcp jet pt to accept event"};
    Configurable<float> thresholdTriggerTrackPtMin{"thresholdTriggerTrackPtMin", 0.0, "Minimum trigger track pt to accept event"};
    Configurable<float> thresholdTriggerTrackReferencePtMin{"thresholdTriggerTrackReferencePtMin", 0.0, "Minimum trigger track reference pt to accept event"};
    Configurable<float> thresholdTriggerParticlePtMin{"thresholdTriggerParticlePtMin", 0.0, "Minimum trigger particle pt to accept event"};
    Configurable<float> thresholdTriggerParticleReferencePtMin{"thresholdTriggerParticleReferencePtMin", 0.0, "Minimum trigger particle reference pt to accept event"};
    Configurable<float> thresholdClusterEnergyMin{"thresholdClusterEnergyMin", 0.0, "Minimum cluster energy to accept event"};
    Configurable<int> downscaleFactor{"downscaleFactor", 1, "random downscale of selected events"};

    Configurable<float> vertexZCut{"vertexZCut", 10.0, "z-vertex cut on event"};
    Configurable<float> centralityMin{"centralityMin", -999.0, "minimum centrality"};
    Configurable<float> centralityMax{"centralityMax", 999.0, "maximum centrality"};
    Configurable<int> trackOccupancyInTimeRangeMax{"trackOccupancyInTimeRangeMax", 999999, "maximum occupancy of tracks in neighbouring collisions in a given time range"};
    Configurable<std::string> eventSelectionsCharged{"eventSelectionsCharged", "", "choose charged event selection"};
    Configurable<std::string> eventSelectionsFull{"eventSelectionsFull", "", "choose full event selection"};
    Configurable<bool> skipMBGapEvents{"skipMBGapEvents", true, "decide to run over MB gap events or not"};
    Configurable<bool> applyRCTSelectionsCharged{"applyRCTSelectionsCharged", true, "decide to apply RCT selections"};
    Configurable<bool> applyRCTSelectionsFull{"applyRCTSelectionsFull", true, "decide to apply RCT selections to full analyses"};
    Configurable<bool> performTrackSelection{"performTrackSelection", true, "only save tracks that pass one of the track selections"};
    Configurable<float> trackPtSelectionMin{"trackPtSelectionMin", 0.15, "only save tracks that have a pT larger than this pT"};
    Configurable<float> trackEtaSelectionMax{"trackEtaSelectionMax", 0.9, "only save tracks that have an eta smaller than this eta"};
    Configurable<float> triggerTrackSignalFraction{"triggerTrackSignalFraction", 0.95, "fraction of events to scan for signal trigger track class"};

    Configurable<std::string> triggerMasks{"triggerMasks", "", "possible JE Trigger masks: fJetChLowPt,fJetChHighPt,fTrackLowPt,fTrackHighPt,fJetD0ChLowPt,fJetD0ChHighPt,fJetLcChLowPt,fJetLcChHighPt,fEMCALReadout,fJetFullHighPt,fJetFullLowPt,fJetNeutralHighPt,fJetNeutralLowPt,fGammaVeryHighPtEMCAL,fGammaVeryHighPtDCAL,fGammaHighPtEMCAL,fGammaHighPtDCAL,fGammaLowPtEMCAL,fGammaLowPtDCAL,fGammaVeryLowPtEMCAL,fGammaVeryLowPtDCAL"};
  } config;

  std::vector<bool> collisionFlag;
  std::vector<bool> mcCollisionFlag;
  std::vector<bool> collisionSplitFlag;
  std::vector<bool> mcCollisionSplitFlag;

  TRandom3 randomNumber;

  std::vector<int> eventSelectionBitsCharged;
  std::vector<int> eventSelectionBitsFull;
  std::vector<int> triggerMaskBits;
  void init(InitContext&)
  {
    eventSelectionBitsCharged = jetderiveddatautilities::initialiseEventSelectionBits(static_cast<std::string>(config.eventSelectionsCharged));
    eventSelectionBitsFull = jetderiveddatautilities::initialiseEventSelectionBits(static_cast<std::string>(config.eventSelectionsFull));
    randomNumber.SetSeed(0);
    triggerMaskBits = jetderiveddatautilities::initialiseTriggerMaskBits(config.triggerMasks);
  }

  PresliceUnsorted<soa::Join<aod::JCollisions, aod::JMcCollisionLbs>> CollisionsPerMcCollision = aod::jmccollisionlb::mcCollisionId;

  void processSetupCollisions(aod::JCollisions const& collisions)
  {
    collisionFlag.clear();
    collisionFlag.resize(collisions.size(), false);
  }

  void processSetupMcCollisions(aod::JMcCollisions const& mcCollisions)
  {
    mcCollisionFlag.clear();
    mcCollisionFlag.resize(mcCollisions.size(), false);
  }

  void processSelectMcCollisionsPerCollision(aod::JMcCollisions const& mcCollisions, soa::Join<aod::JCollisions, aod::JMcCollisionLbs> const& collisions)
  {
    for (auto mcCollision : mcCollisions) {
      const auto collisionsPerMcCollision = collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex());
      for (auto collision : collisionsPerMcCollision) {
        if (collisionFlag[collision.globalIndex()]) {
          mcCollisionFlag[mcCollision.globalIndex()] = true;
        }
      }
    }
  }

  void processSelectCollisionsPerMcCollision(soa::Join<aod::JCollisions, aod::JMcCollisionLbs>::iterator const& collision)
  {
    if (collision.has_mcCollision()) {
      if (mcCollisionFlag[collision.mcCollisionId()]) {
        collisionFlag[collision.globalIndex()] = true;
      }
    }
  }

  void processSetupAllCollisionsWithDownscaling(aod::JCollisions const& collisions)
  {
    collisionFlag.clear();
    collisionFlag.resize(collisions.size(), false);
    for (const auto& collision : collisions) {
      if (randomNumber.Integer(config.downscaleFactor) == 0) {
        collisionFlag[collision.globalIndex()] = true;
      }
    }
  }

  void processSetupAllMcCollisionsWithDownscaling(aod::JMcCollisions const& mcCollisions)
  {
    mcCollisionFlag.clear();
    mcCollisionFlag.resize(mcCollisions.size(), false);
    for (const auto& mcCollision : mcCollisions) {
      if (randomNumber.Integer(config.downscaleFactor) == 0) {
        mcCollisionFlag[mcCollision.globalIndex()] = true;
      }
    }
  }

  template <typename T>
  void processDoDownscaling(T const& collisions)
  {
    for (const auto& collision : collisions) {
      if constexpr (std::is_same_v<std::decay_t<T>, aod::JCollisions>) {
        if (collisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) {
          collisionFlag[collision.globalIndex()] = false;
        }
      }
      if constexpr (std::is_same_v<std::decay_t<T>, aod::JMcCollisions>) {
        if (mcCollisionFlag[collision.globalIndex()] && randomNumber.Integer(config.downscaleFactor) != 0) {
          mcCollisionFlag[collision.globalIndex()] = false;
        }
      }
    }
  }

  void processSetupEventTriggering(aod::JCollision const& collision)
  {
    if (jetderiveddatautilities::selectTrigger(collision, triggerMaskBits)) {
      collisionFlag[collision.globalIndex()] = true;
    }
  }

  void processDoCollisionSelections(aod::JetCollision const& collision)
  { // can also add event selection like sel8 but goes a little against the derived data idea
    if (collision.centFT0M() < config.centralityMin || collision.centFT0M() >= config.centralityMax || collision.trackOccupancyInTimeRange() > config.trackOccupancyInTimeRangeMax || std::abs(collision.posZ()) > config.vertexZCut) {
      collisionFlag[collision.globalIndex()] = false;
    }
    bool barrelRCTFlagSelection = false;
    bool emcalRCTFlagSelection = false;
    if (jetderiveddatautilities::selectCollision(collision, eventSelectionBitsCharged, config.skipMBGapEvents, config.applyRCTSelectionsCharged)) {
      barrelRCTFlagSelection = true;
    }
    if (doprocessSelectingFullJets || doprocessSelectingFullMCDJets || doprocessSelectingFullMCPJets || doprocessSelectingClusters) {
      if (jetderiveddatautilities::selectCollision(collision, eventSelectionBitsFull, config.skipMBGapEvents, config.applyRCTSelectionsFull, "CBT_calo")) {
        emcalRCTFlagSelection = true;
      }
    }
    if (!barrelRCTFlagSelection && !emcalRCTFlagSelection) {
      collisionFlag[collision.globalIndex()] = false;
    }
  }

  void processCollisionSplitting(aod::JCollisions const& collisions)
  {
    collisionSplitFlag.clear();
    collisionSplitFlag.resize(collisions.size(), true);
    for (auto const& collision : collisions) {
      if (randomNumber.Rndm() > config.triggerTrackSignalFraction) {
        collisionSplitFlag[collision.globalIndex()] = false;
      }
    }
  }

  void processCollisionSplittingMC(aod::JMcCollisions const& mcCollisions, soa::Join<aod::JCollisions, aod::JMcCollisionLbs> const& collisions)
  {
    mcCollisionSplitFlag.clear();
    mcCollisionSplitFlag.resize(mcCollisions.size(), true);
    collisionSplitFlag.clear();
    collisionSplitFlag.resize(collisions.size(), true);
    for (auto const& mcCollision : mcCollisions) {
      if (randomNumber.Rndm() > config.triggerTrackSignalFraction) {
        mcCollisionSplitFlag[mcCollision.globalIndex()] = false;
        for (auto const& collision : collisions.sliceBy(CollisionsPerMcCollision, mcCollision.globalIndex())) {
          collisionSplitFlag[collision.globalIndex()] = false;
        }
      }
    }
  }

  template <typename T>
  void processSelectionObjects(T const& selectionObjects)
  {
    float selectionObjectPtMin = 0.0;
    if constexpr (std::is_same_v<std::decay_t<T>, aod::ChargedJets> || std::is_same_v<std::decay_t<T>, aod::ChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::ChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::ChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::ChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::FullJets> || std::is_same_v<std::decay_t<T>, aod::FullMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdFullJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::FullMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdFullMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesD0Data>) {
      selectionObjectPtMin = config.thresholdD0PtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesD0MCP>) {
      selectionObjectPtMin = config.thresholdD0MCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::D0ChargedJets> || std::is_same_v<std::decay_t<T>, aod::D0ChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedD0JetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::D0ChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedD0JetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::D0ChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedD0MCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDplusData>) {
      selectionObjectPtMin = config.thresholdDplusPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDplusMCP>) {
      selectionObjectPtMin = config.thresholdDplusMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DplusChargedJets> || std::is_same_v<std::decay_t<T>, aod::DplusChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDplusJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DplusChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::DplusChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDplusJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DplusChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDplusMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDsData>) {
      selectionObjectPtMin = config.thresholdDsPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDsMCP>) {
      selectionObjectPtMin = config.thresholdDsMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DsChargedJets> || std::is_same_v<std::decay_t<T>, aod::DsChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDsJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DsChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::DsChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDsJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DsChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDsMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDstarData>) {
      selectionObjectPtMin = config.thresholdDstarPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDstarMCP>) {
      selectionObjectPtMin = config.thresholdDstarMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DstarChargedJets> || std::is_same_v<std::decay_t<T>, aod::DstarChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDstarJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DstarChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::DstarChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDstarJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DstarChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDstarMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesLcData>) {
      selectionObjectPtMin = config.thresholdLcPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesLcMCP>) {
      selectionObjectPtMin = config.thresholdLcMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::LcChargedJets> || std::is_same_v<std::decay_t<T>, aod::LcChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedLcJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::LcChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedLcJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::LcChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedLcMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesB0Data>) {
      selectionObjectPtMin = config.thresholdB0PtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesB0MCP>) {
      selectionObjectPtMin = config.thresholdB0MCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::B0ChargedJets> || std::is_same_v<std::decay_t<T>, aod::B0ChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedB0JetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::B0ChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::B0ChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedB0JetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::B0ChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedB0MCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesBplusData>) {
      selectionObjectPtMin = config.thresholdBplusPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesBplusMCP>) {
      selectionObjectPtMin = config.thresholdBplusMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::BplusChargedJets> || std::is_same_v<std::decay_t<T>, aod::BplusChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedBplusJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::BplusChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedBplusJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::BplusChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedBplusMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesXicToXiPiPiData>) {
      selectionObjectPtMin = config.thresholdXicToXiPiPiPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesXicToXiPiPiMCP>) {
      selectionObjectPtMin = config.thresholdXicToXiPiPiMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::XicToXiPiPiChargedJets> || std::is_same_v<std::decay_t<T>, aod::XicToXiPiPiChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedXicToXiPiPiJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::XicToXiPiPiChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::XicToXiPiPiChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedXicToXiPiPiJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::XicToXiPiPiChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedXicToXiPiPiMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDielectronData>) {
      selectionObjectPtMin = config.thresholdDielectronPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::CandidatesDielectronMCP>) {
      selectionObjectPtMin = config.thresholdDielectronMCPPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DielectronChargedJets> || std::is_same_v<std::decay_t<T>, aod::DielectronChargedMCDetectorLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDielectronJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DielectronChargedEventWiseSubtractedJets> || std::is_same_v<std::decay_t<T>, aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>) {
      selectionObjectPtMin = config.thresholdChargedEventWiseSubtractedDielectronJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::DielectronChargedMCParticleLevelJets>) {
      selectionObjectPtMin = config.thresholdChargedDielectronMCPJetPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::JTracks>) {
      selectionObjectPtMin = config.thresholdTriggerTrackPtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::JMcParticles>) {
      selectionObjectPtMin = config.thresholdTriggerParticlePtMin;
    } else if constexpr (std::is_same_v<std::decay_t<T>, aod::JClusters>) {
      selectionObjectPtMin = config.thresholdClusterEnergyMin;
    } else {
      selectionObjectPtMin = 0.0;
    }
    for (const auto& selectionObject : selectionObjects) {
      bool isTriggerObject = false;
      if constexpr (std::is_same_v<std::decay_t<T>, aod::JClusters>) {
        if (selectionObject.energy() >= selectionObjectPtMin) {
          isTriggerObject = true;
        }
      } else {
        if constexpr (std::is_same_v<std::decay_t<T>, aod::JTracks>) {
          if (config.performTrackSelection && !(selectionObject.trackSel() & ~((1ULL << jetderiveddatautilities::JTrackSel::trackSign) | (1ULL << jetderiveddatautilities::JTrackSel::notBadMcTrack)))) {
            continue;
          }
          if (selectionObject.pt() < config.trackPtSelectionMin || std::abs(selectionObject.eta()) > config.trackEtaSelectionMax) {
            continue;
          }
          if (doprocessCollisionSplitting || doprocessCollisionSplittingMC) {
            if (collisionSplitFlag[selectionObject.collisionId()]) {
              selectionObjectPtMin = config.thresholdTriggerTrackPtMin;
            } else {
              selectionObjectPtMin = config.thresholdTriggerTrackReferencePtMin;
            }
          }
        }
        if constexpr (std::is_same_v<std::decay_t<T>, aod::JMcParticles>) {
          if (!selectionObject.isPhysicalPrimary()) {
            continue;
          }
          if (selectionObject.pt() < config.trackPtSelectionMin || std::abs(selectionObject.eta()) > config.trackEtaSelectionMax) {
            continue;
          }
          if (doprocessCollisionSplittingMC) {
            if (mcCollisionSplitFlag[selectionObject.mcCollisionId()]) {
              selectionObjectPtMin = config.thresholdTriggerParticlePtMin;
            } else {
              selectionObjectPtMin = config.thresholdTriggerParticleReferencePtMin;
            }
          }
        }
        if (selectionObject.pt() >= selectionObjectPtMin) {
          isTriggerObject = true;
        }
      }
      if (isTriggerObject) {
        if constexpr (std::is_same_v<std::decay_t<T>, aod::ChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::FullMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesD0MCP> || std::is_same_v<std::decay_t<T>, aod::D0ChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesDplusMCP> || std::is_same_v<std::decay_t<T>, aod::DplusChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesDsMCP> || std::is_same_v<std::decay_t<T>, aod::DsChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesDstarMCP> || std::is_same_v<std::decay_t<T>, aod::DstarChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesLcMCP> || std::is_same_v<std::decay_t<T>, aod::LcChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesB0MCP> || std::is_same_v<std::decay_t<T>, aod::B0ChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesBplusMCP> || std::is_same_v<std::decay_t<T>, aod::BplusChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesXicToXiPiPiMCP> || std::is_same_v<std::decay_t<T>, aod::XicToXiPiPiChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::CandidatesDielectronMCP> || std::is_same_v<std::decay_t<T>, aod::DielectronChargedMCParticleLevelJets> || std::is_same_v<std::decay_t<T>, aod::JMcParticles>) {
          if (selectionObject.mcCollisionId() >= 0) {
            mcCollisionFlag[selectionObject.mcCollisionId()] = true;
          }
        } else {
          if (selectionObject.collisionId() >= 0) {
            collisionFlag[selectionObject.collisionId()] = true;
          }
        }
      }
    }
  }
  // Todo : Check memory consumption of having so many Process Switches
  PROCESS_SWITCH(JetDerivedDataSelector, processSetupCollisions, "setup the writing for data and MCD based on collisions", true);
  PROCESS_SWITCH(JetDerivedDataSelector, processSetupMcCollisions, "setup the writing for MCP based on mcCollisions", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processSetupAllCollisionsWithDownscaling, "setup the writing of untriggered collisions with downscaling", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processSetupAllMcCollisionsWithDownscaling, "setup the writing of untriggered mccollisions with downscaling", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processSetupEventTriggering, "process software triggers", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processCollisionSplitting, "process collision splitting for trigger tracks", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processCollisionSplittingMC, "process mcCollision and collision splitting for trigger tracks", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::ChargedJets>, processSelectingChargedJets, "process charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::ChargedEventWiseSubtractedJets>, processSelectingChargedEventWiseSubtractedJets, "process charged event-wise subtracted jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::ChargedMCDetectorLevelJets>, processSelectingChargedMCDJets, "process charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::ChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingChargedMCDetectorLevelEventWiseSubtractedJets, "process charged event-wise subtracted mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::ChargedMCParticleLevelJets>, processSelectingChargedMCPJets, "process charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::FullJets>, processSelectingFullJets, "process full jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::FullMCDetectorLevelJets>, processSelectingFullMCDJets, "process full mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::FullMCParticleLevelJets>, processSelectingFullMCPJets, "process full mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesD0Data>, processSelectingD0Candidates, "process D0 candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesD0MCP>, processSelectingD0CandidatesMCP, "process D0 particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::D0ChargedJets>, processSelectingD0ChargedJets, "process D0 charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::D0ChargedEventWiseSubtractedJets>, processSelectingD0ChargedEventWiseSubtractedJets, "process D0 event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::D0ChargedMCDetectorLevelJets>, processSelectingD0ChargedMCDJets, "process D0 charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::D0ChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingD0ChargedMCDetectorLevelEventWiseSubtractedJets, "process D0 event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::D0ChargedMCParticleLevelJets>, processSelectingD0ChargedMCPJets, "process D0 charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDplusData>, processSelectingDplusCandidates, "process Dplus candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDplusMCP>, processSelectingDplusCandidatesMCP, "process Dplus particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DplusChargedJets>, processSelectingDplusChargedJets, "process Dplus charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DplusChargedEventWiseSubtractedJets>, processSelectingDplusChargedEventWiseSubtractedJets, "process Dplus event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DplusChargedMCDetectorLevelJets>, processSelectingDplusChargedMCDJets, "process Dplus charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DplusChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingDplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Dplus event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DplusChargedMCParticleLevelJets>, processSelectingDplusChargedMCPJets, "process Dplus charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDsData>, processSelectingDsCandidates, "process Ds candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDsMCP>, processSelectingDsCandidatesMCP, "process Ds particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DsChargedJets>, processSelectingDsChargedJets, "process Ds charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DsChargedEventWiseSubtractedJets>, processSelectingDsChargedEventWiseSubtractedJets, "process Ds event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DsChargedMCDetectorLevelJets>, processSelectingDsChargedMCDJets, "process Ds charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DsChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingDsChargedMCDetectorLevelEventWiseSubtractedJets, "process Ds event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DsChargedMCParticleLevelJets>, processSelectingDsChargedMCPJets, "process Ds charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDstarData>, processSelectingDstarCandidates, "process Dstar candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDstarMCP>, processSelectingDstarCandidatesMCP, "process Dstar particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DstarChargedJets>, processSelectingDstarChargedJets, "process Dstar charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DstarChargedEventWiseSubtractedJets>, processSelectingDstarChargedEventWiseSubtractedJets, "process Dstar event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DstarChargedMCDetectorLevelJets>, processSelectingDstarChargedMCDJets, "process Dstar charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DstarChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingDstarChargedMCDetectorLevelEventWiseSubtractedJets, "process Dstar event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DstarChargedMCParticleLevelJets>, processSelectingDstarChargedMCPJets, "process Dstar charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesLcData>, processSelectingLcCandidates, "process Lc candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesLcMCP>, processSelectingLcCandidatesMCP, "process Lc particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::LcChargedJets>, processSelectingLcChargedJets, "process Lc charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::LcChargedEventWiseSubtractedJets>, processSelectingLcChargedEventWiseSubtractedJets, "process Lc event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::LcChargedMCDetectorLevelJets>, processSelectingLcChargedMCDJets, "process Lc charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::LcChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingLcChargedMCDetectorLevelEventWiseSubtractedJets, "process Lc event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::LcChargedMCParticleLevelJets>, processSelectingLcChargedMCPJets, "process Lc charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesB0Data>, processSelectingB0Candidates, "process B0 candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesB0MCP>, processSelectingB0CandidatesMCP, "process B0 particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::B0ChargedJets>, processSelectingB0ChargedJets, "process B0 charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::B0ChargedEventWiseSubtractedJets>, processSelectingB0ChargedEventWiseSubtractedJets, "process B0 event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::B0ChargedMCDetectorLevelJets>, processSelectingB0ChargedMCDJets, "process B0 charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::B0ChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingB0ChargedMCDetectorLevelEventWiseSubtractedJets, "process B0 event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::B0ChargedMCParticleLevelJets>, processSelectingB0ChargedMCPJets, "process B0 charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesBplusData>, processSelectingBplusCandidates, "process Bplus candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesBplusMCP>, processSelectingBplusCandidatesMCP, "process Bplus particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::BplusChargedJets>, processSelectingBplusChargedJets, "process Bplus charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::BplusChargedEventWiseSubtractedJets>, processSelectingBplusChargedEventWiseSubtractedJets, "process Bplus event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::BplusChargedMCDetectorLevelJets>, processSelectingBplusChargedMCDJets, "process Bplus charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::BplusChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingBplusChargedMCDetectorLevelEventWiseSubtractedJets, "process Bplus event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::BplusChargedMCParticleLevelJets>, processSelectingBplusChargedMCPJets, "process Bplus charged mcp jets", false);
  // PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesXicToXiPiPiData>, processSelectingXicToXiPiPiCandidates, "process XicToXiPiPi candidates", false);
  // PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesXicToXiPiPiMCP>, processSelectingXicToXiPiPiCandidatesMCP, "process XicToXiPiPi particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::XicToXiPiPiChargedJets>, processSelectingXicToXiPiPiChargedJets, "process XicToXiPiPi charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::XicToXiPiPiChargedEventWiseSubtractedJets>, processSelectingXicToXiPiPiChargedEventWiseSubtractedJets, "process XicToXiPiPi event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::XicToXiPiPiChargedMCDetectorLevelJets>, processSelectingXicToXiPiPiChargedMCDJets, "process XicToXiPiPi charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::XicToXiPiPiChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingXicToXiPiPiChargedMCDetectorLevelEventWiseSubtractedJets, "process XicToXiPiPi event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::XicToXiPiPiChargedMCParticleLevelJets>, processSelectingXicToXiPiPiChargedMCPJets, "process XicToXiPiPi charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDielectronData>, processSelectingDielectronCandidates, "process Dielectron candidates", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::CandidatesDielectronMCP>, processSelectingDielectronCandidatesMCP, "process Dielectron particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DielectronChargedJets>, processSelectingDielectronChargedJets, "process Dielectron charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DielectronChargedEventWiseSubtractedJets>, processSelectingDielectronChargedEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DielectronChargedMCDetectorLevelJets>, processSelectingDielectronChargedMCDJets, "process Dielectron charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DielectronChargedMCDetectorLevelEventWiseSubtractedJets>, processSelectingDielectronChargedMCDetectorLevelEventWiseSubtractedJets, "process Dielectron event-wise subtracted charged mcd jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::DielectronChargedMCParticleLevelJets>, processSelectingDielectronChargedMCPJets, "process Dielectron charged mcp jets", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::JClusters>, processSelectingClusters, "process EMCal clusters", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::JTracks>, processSelectingTracks, "process high pt tracks", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processSelectionObjects<aod::JMcParticles>, processSelectingParticles, "process high pt particles", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processDoDownscaling<aod::JCollisions>, processCollisionDownscaling, "process downsaling of triggered collisions", false);
  PROCESS_SWITCH_FULL(JetDerivedDataSelector, processDoDownscaling<aod::JMcCollisions>, processMcCollisionDownscaling, "process downsaling of triggered mccollisions", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processDoCollisionSelections, "process event selections for saved events", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processSelectMcCollisionsPerCollision, "select McCollisions due to a triggered reconstructed collision", false);
  PROCESS_SWITCH(JetDerivedDataSelector, processSelectCollisionsPerMcCollision, "select collisions due to a triggered McCollision", false);

  void processStoreCollisionDecision(aod::JCollision const& collision)
  {
    if (collisionFlag[collision.globalIndex()]) {
      collisionSelectionsTable(true);
    } else {
      collisionSelectionsTable(false);
    }
  }
  PROCESS_SWITCH(JetDerivedDataSelector, processStoreCollisionDecision, "write out decision of storing collision", true);

  void processStoreMcCollisionDecision(aod::JMcCollision const& mcCollision)
  {
    if (mcCollisionFlag[mcCollision.globalIndex()]) {
      mcCollisionSelectionsTable(true);
    } else {
      mcCollisionSelectionsTable(false);
    }
  }
  PROCESS_SWITCH(JetDerivedDataSelector, processStoreMcCollisionDecision, "write out decision of storing mcCollision", false);
};

WorkflowSpec defineDataProcessing(ConfigContext const& cfgc)
{
  std::vector<DataProcessorSpec> tasks;

  tasks.emplace_back(adaptAnalysisTask<JetDerivedDataSelector>(cfgc, TaskName{"jet-deriveddata-selector"}));

  return WorkflowSpec{tasks};
}