Merge branch 'AliceO2Group:master' into master

Author: blacwovie

Common/Core/MetadataHelper.cxx

@@ -124,3 +124,19 @@ bool MetadataHelper::isInitialized() const
   }
   return mIsInitialized;
 }
+
+std::string MetadataHelper::makeMetadataLabel() const
+{
+  if (!mIsInitialized) {
+    LOG(fatal) << "Metadata not initialized";
+  }
+  std::string label = get("DataType");
+  label += "_" + get("LPMProductionTag");
+  if (isMC()) {
+    label += "_" + get("AnchorPassName");
+    label += "_" + get("AnchorProduction");
+  } else {
+    label += "_" + get("RecoPassName");
+  }
+  return label;
+}

Common/Core/MetadataHelper.h

@@ -8,10 +8,10 @@
 // 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   TableHelper.h
+
+/// \file MetadataHelper.h
+/// \brief Utility to handle the metadata from the AOD
 /// \author Nicolò Jacazio nicolo.jacazio@cern.ch
-/// \brief  Utility to handle the metadata from the AOD
-///
 
 #ifndef COMMON_CORE_METADATAHELPER_H_
 #define COMMON_CORE_METADATAHELPER_H_
@@ -61,6 +61,9 @@ struct MetadataHelper {
   /// @return true if the key is defined, false otherwise. Throws an exception if the key is not found
   bool isKeyDefined(const std::string& key) const;
 
+  /// @brief Function to create a label with the metadata information, useful e.g. for histogram naming
+  std::string makeMetadataLabel() const;
+
  private:
   std::map<std::string, std::string> mMetadata; /// < The metadata map
   bool mIsInitialized = false;                  /// < Flag to check if the metadata has been initialized

Common/Core/macros/testMetadataHelper.C

@@ -0,0 +1,84 @@
+// 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   testMetadataHelper.C
+/// \author Nicolò Jacazio nicolo.jacazio@cern.ch
+/// \brief  Test the MetadataHelper functionality
+
+#include "Common/Core/MetadataHelper.h"
+
+#include <Framework/ConfigContext.h>
+#include <Framework/ConfigParamRegistry.h>
+#include <Framework/ConfigParamStore.h>
+#include <Framework/ServiceRegistry.h>
+#include <Framework/ServiceRegistryRef.h>
+
+#include <TFile.h>
+#include <TMap.h>
+#include <TObjString.h>
+
+#include <memory>
+#include <string>
+#include <utility>
+#include <vector>
+
+// Taken from O2/Framework/AnalysisSupport/src/Plugin.cxx
+auto readMetadata(std::unique_ptr<TFile>& currentFile) -> std::vector<o2::framework::ConfigParamSpec>
+{
+  // Get the metadata, if any
+  auto m = (TMap*)currentFile->Get("metaData");
+  if (!m) {
+    return {};
+  }
+  std::vector<o2::framework::ConfigParamSpec> results;
+  auto it = m->MakeIterator();
+
+  // Serialise metadata into a ; separated string with : separating key and value
+  bool first = true;
+  while (auto obj = it->Next()) {
+    if (first) {
+      LOGP(info, "Metadata for file \"{}\":", currentFile->GetName());
+      first = false;
+    }
+    auto objString = (TObjString*)m->GetValue(obj);
+    std::string key = "aod-metadata-" + std::string(obj->GetName());
+    LOGP(info, "- {}: {} goes into key {}", obj->GetName(), objString->String().Data(), key);
+    char const* value = strdup(objString->String());
+    results.push_back(o2::framework::ConfigParamSpec{key, o2::framework::VariantType::String, value, {"Metadata in AOD"}});
+  }
+  return results;
+}
+
+void testMetadataHelper(std::string aod = "/tmp/AO2D.root")
+{
+
+  TFile* file = TFile::Open(aod.c_str());
+  if (!file || file->IsZombie()) {
+    LOG(fatal) << "Could not open file " << aod;
+  }
+  std::unique_ptr<TFile> currentFile{file};
+  std::vector<o2::framework::ConfigParamSpec> specs = readMetadata(currentFile);
+
+  std::vector<std::unique_ptr<o2::framework::ParamRetriever>> retrievers;
+  auto paramStore = std::make_unique<o2::framework::ConfigParamStore>(specs, std::move(retrievers));
+  paramStore->preload();
+  paramStore->activate();
+  o2::framework::ConfigParamRegistry paramRegistry(std::move(paramStore));
+  o2::framework::ServiceRegistry serviceRegistry;
+  o2::framework::ServiceRegistryRef services(serviceRegistry);
+  o2::framework::ConfigContext aodCfg(paramRegistry, services, 0, nullptr);
+  LOG(info) << "Loaded " << aodCfg.options().specs().size() << " configuration entries from file " << aod;
+  aodCfg.options().get<std::string>("aod-metadata-DataType");
+  o2::common::core::MetadataHelper metadataInfo;
+  metadataInfo.initMetadata(aodCfg);
+  metadataInfo.print();
+  LOG(info) << "Metadata label: " << metadataInfo.makeMetadataLabel();
+}

PWGCF/Femto/Core/baseSelection.h

@@ -110,17 +110,48 @@ class BaseSelection
     mSelectionContainers.at(observableIndex) = SelectionContainer<T, BitmaskType>(baseName, lowerLimit, upperLimit, selectionValues, limitType, skipMostPermissiveBit, isMinimalCut);
   }
 
+  /// \brief Add a boolean based selection for a specific observable.
+  /// \param mode Whether the selection is not applied, minimal or optional cut
+  /// \param observableIndex Index of the observable.
+  void addSelection(int mode, int observableIndex)
+  {
+    if (static_cast<size_t>(observableIndex) >= NumObservables) {
+      LOG(fatal) << "Observable is not valid. Observable (index) has to be smaller than " << NumObservables;
+    }
+    switch (mode) {
+      case -1: // cut is optional and we store bit for the cut
+        mNSelections += 1;
+        mHasOptionalSelection = true;
+        mSelectionContainers.at(observableIndex) = SelectionContainer<T, BitmaskType>(std::vector<T>{1}, limits::LimitType::kEqual, false, false);
+        break;
+      case 0: // cut is not applied, initalize with empty vector, so we bail out later
+        mSelectionContainers.at(observableIndex) = SelectionContainer<T, BitmaskType>(std::vector<T>{}, limits::LimitType::kEqual, false, false);
+        break;
+      case 1: // cut is added as mininal selection (since it is only one value, not extra bit is stored)
+        mSelectionContainers.at(observableIndex) = SelectionContainer<T, BitmaskType>(std::vector<T>{1}, limits::LimitType::kEqual, true, true);
+        break;
+      default:
+        LOG(fatal) << "Invalid switch for boolean selection";
+    }
+    if (mNSelections >= sizeof(BitmaskType) * CHAR_BIT) {
+      LOG(fatal) << "Too many selections. At most " << sizeof(BitmaskType) * CHAR_BIT << " are supported";
+    }
+  }
+
   /// \brief Update the limits of a function-based selection for a specific observable.
   /// \param observable Index of the observable.
   /// \param value Value at which to evaluate the selection functions.
-  void updateLimits(int observable, T value) { mSelectionContainers.at(observable).updateLimits(value); }
+  void updateLimits(int observable, T value)
+  {
+    mSelectionContainers.at(observable).updateLimits(value);
+  }
 
   /// \brief Reset the internal bitmask and evaluation flags before evaluating a new event.
   void reset()
   {
     mFinalBitmask.reset();
     mPassesMinimalSelections = true;
-    // will be true if no optional cut as been defined and
+    // will be true if no optional cut has been defined and
     // will be set to false if we have optional cuts (but will be set to true in the case at least one optional cut succeeds)
     mPassesOptionalSelections = !mHasOptionalSelection;
   }

PWGCF/Femto/Core/cascadeBuilder.h

@@ -337,23 +337,23 @@ class CascadeBuilder
   template <typename T1, typename T2, typename T3, typename T4>
   void init(T1& config, T2& filter, T3& table, T4& initContext)
   {
-    cascadeSelection.configure(config, filter);
+    mCascadeSelection.configure(config, filter);
     if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) {
       LOG(info) << "Initialize femto Xi builder...";
-      produceXis = utils::enableTable("FXis_001", table.produceXis.value, initContext);
-      produceXiMasks = utils::enableTable("FXiMasks_001", table.produceXiMasks.value, initContext);
-      produceXiExtras = utils::enableTable("FXiExtras_001", table.produceXiExtras.value, initContext);
+      mProduceXis = utils::enableTable("FXis_001", table.produceXis.value, initContext);
+      mProduceXiMasks = utils::enableTable("FXiMasks_001", table.produceXiMasks.value, initContext);
+      mProduceXiExtras = utils::enableTable("FXiExtras_001", table.produceXiExtras.value, initContext);
     }
     if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) {
       LOG(info) << "Initialize femto Omega builder...";
-      produceOmegas = utils::enableTable("FOmegas_001", table.produceOmegas.value, initContext);
-      produceOmegaMasks = utils::enableTable("FOmegaMasks_001", table.produceOmegaMasks.value, initContext);
-      produceOmegaExtras = utils::enableTable("FOmegaExtras_001", table.produceOmegaExtras.value, initContext);
+      mProduceOmegas = utils::enableTable("FOmegas_001", table.produceOmegas.value, initContext);
+      mProduceOmegaMasks = utils::enableTable("FOmegaMasks_001", table.produceOmegaMasks.value, initContext);
+      mProduceOmegaExtras = utils::enableTable("FOmegaExtras_001", table.produceOmegaExtras.value, initContext);
     }
 
-    if (produceXis || produceXiExtras || produceXiMasks || produceOmegas || produceOmegaMasks || produceOmegaExtras) {
+    if (mProduceXis || mProduceXiExtras || mProduceXiMasks || mProduceOmegas || mProduceOmegaMasks || mProduceOmegaExtras) {
       mFillAnyTable = true;
-      cascadeSelection.printSelections(cascadeSelsName, cascadeSelsToString);
+      mCascadeSelection.printSelections(cascadeSelsName, cascadeSelsToString);
     } else {
       LOG(info) << "No tables configured";
     }
@@ -371,11 +371,11 @@ class CascadeBuilder
     int64_t posDaughterIndex = 0;
     int64_t negDaughterIndex = 0;
     for (const auto& cascade : fullCascades) {
-      if (!cascadeSelection.checkFilters(cascade)) {
+      if (!mCascadeSelection.checkFilters(cascade)) {
         continue;
       }
-      cascadeSelection.applySelections(cascade, fullTracks, col);
-      if (cascadeSelection.passesAllRequiredSelections() && cascadeSelection.checkHypothesis(cascade)) {
+      mCascadeSelection.applySelections(cascade, fullTracks, col);
+      if (mCascadeSelection.passesAllRequiredSelections() && mCascadeSelection.checkHypothesis(cascade)) {
 
         auto bachelor = cascade.template bachelor_as<T5>();
         auto posDaughter = cascade.template posTrack_as<T5>();
@@ -394,7 +394,7 @@ class CascadeBuilder
   void fillCascade(T1& collisionProducts, T2& cascadeProducts, T3 const& cascade, T4 const& col, int bachelorIndex, int posDaughterIndex, int negDaughterIndex)
   {
     if constexpr (modes::isEqual(cascadeType, modes::Cascade::kXi)) {
-      if (produceXis) {
+      if (mProduceXis) {
         cascadeProducts.producedXis(collisionProducts.producedCollision.lastIndex(),
                                     cascade.sign() * cascade.pt(),
                                     cascade.eta(),
@@ -404,10 +404,10 @@ class CascadeBuilder
                                     posDaughterIndex,
                                     negDaughterIndex);
       }
-      if (produceXiMasks) {
-        cascadeProducts.producedXiMasks(cascadeSelection.getBitmask());
+      if (mProduceXiMasks) {
+        cascadeProducts.producedXiMasks(mCascadeSelection.getBitmask());
       }
-      if (produceXiExtras) {
+      if (mProduceXiExtras) {
         cascadeProducts.producedXiExtras(
           cascade.mOmega(),
           cascade.casccosPA(col.posX(), col.posY(), col.posZ()),
@@ -420,7 +420,7 @@ class CascadeBuilder
       }
     }
     if constexpr (modes::isEqual(cascadeType, modes::Cascade::kOmega)) {
-      if (produceOmegas) {
+      if (mProduceOmegas) {
         cascadeProducts.producedOmegas(collisionProducts.producedCollision.lastIndex(),
                                        cascade.sign() * cascade.pt(),
                                        cascade.eta(),
@@ -430,10 +430,10 @@ class CascadeBuilder
                                        posDaughterIndex,
                                        negDaughterIndex);
       }
-      if (produceOmegaMasks) {
-        cascadeProducts.producedOmegaMasks(cascadeSelection.getBitmask());
+      if (mProduceOmegaMasks) {
+        cascadeProducts.producedOmegaMasks(mCascadeSelection.getBitmask());
       }
-      if (produceOmegaExtras) {
+      if (mProduceOmegaExtras) {
         cascadeProducts.producedOmegaExtras(
           cascade.mXi(),
           cascade.casccosPA(col.posX(), col.posY(), col.posZ()),
@@ -450,14 +450,14 @@ class CascadeBuilder
   bool fillAnyTable() { return mFillAnyTable; }
 
  private:
-  CascadeSelection<cascadeType> cascadeSelection;
+  CascadeSelection<cascadeType> mCascadeSelection;
   bool mFillAnyTable = false;
-  bool produceXis = false;
-  bool produceXiMasks = false;
-  bool produceXiExtras = false;
-  bool produceOmegas = false;
-  bool produceOmegaMasks = false;
-  bool produceOmegaExtras = false;
+  bool mProduceXis = false;
+  bool mProduceXiMasks = false;
+  bool mProduceXiExtras = false;
+  bool mProduceOmegas = false;
+  bool mProduceOmegaMasks = false;
+  bool mProduceOmegaExtras = false;
 };
 
 } // namespace cascadebuilder