AliEmcalContainerIndexMap.h

Go to the documentation of this file.

#if !(defined(__CINT__) || defined(__MAKECINT__))
#ifndef ALIEMCALCONTAINERINDEXMAP_H
#define ALIEMCALCONTAINERINDEXMAP_H

#include <map>
#include <typeinfo>

#include <TObject.h>
#include <TClonesArray.h>
#include <TObjArray.h>
#include <TClass.h>
#include <AliLog.h>

#include "AliEmcalContainer.h"

template <class U, class V>
class AliEmcalContainerIndexMap {
 public:
  AliEmcalContainerIndexMap();
  // Implemented using copy-and-swap mechanism
  AliEmcalContainerIndexMap(const AliEmcalContainerIndexMap & map);
  AliEmcalContainerIndexMap &operator=(AliEmcalContainerIndexMap map);
  // Change the template variables to avoid shadowing U and V.
  // See: https://stackoverflow.com/a/4039892
  template<class X, class Y>
  friend void swap(AliEmcalContainerIndexMap<X, Y> & first, AliEmcalContainerIndexMap<X, Y> & second);
  AliEmcalContainerIndexMap(AliEmcalContainerIndexMap<U, V> && other);

  // Don't delete fClass, as it was returned by TClass and deleting it will cause segfaults in ROOT
  virtual ~AliEmcalContainerIndexMap() {}

  // Setup index map for AliEmcalContainer or TClonesArray
  int RegisterArray(U * inputObject);

  // Copy the mapping from the source "map"; the mapping is between the global index found in "map" for object "cont" and the object "cont" itself
  template<class U2>
  void CopyMappingFrom(const AliEmcalContainerIndexMap<U2, V>& map, U* cont);

  // Copy the mapping from the source "map"; the mapping is between the global index found in "map" for each object in "containers" and the objects in "containers"
  template<class U2>
  void CopyMappingFrom(const AliEmcalContainerIndexMap<U2, V>& map, TCollection & containers);

  // Index operations
  // Returns the offset of an input object 
  template<class U2>
  int GetOffset(const U2 * inputObject) const;
  // Returns the global index of an input object and the local index of the object of interest
  int GlobalIndexFromLocalIndex(const U * inputObject, const int localIndex) const;
  // Returns a pair with the local index and the array for a given global index
  std::pair<int, U *> LocalIndexFromGlobalIndex(const int globalIndex) const;
  // Get object directly
  V * GetObjectFromGlobalIndex(const int globalIndex) const;

 protected:
  //template<class Z = U>
  const TClonesArray * GetObject(const AliEmcalContainer * inputObject) const;
  const TClonesArray * GetObject(const TClonesArray * inputObject) const;
  bool IsUnderlyingInputObjectTypeCompatible(const U * inputObject) const;

  std::map <int, U *> fGlobalIndexMap; 

  int fOffset;                         
  TClass* fClass;                      
};

template<class U, class V>
AliEmcalContainerIndexMap<U, V>::AliEmcalContainerIndexMap():
  fOffset(100000),
  fGlobalIndexMap(),
  fClass(TClass::GetClass(typeid(V)))
{
}

template<class U, class V>
AliEmcalContainerIndexMap<U, V>::AliEmcalContainerIndexMap(const AliEmcalContainerIndexMap<U, V> & map):
  fOffset(map.fOffset),
  fGlobalIndexMap(map.fGlobalIndexMap),
  fClass(map.fClass) // Should be okay to be the same pointer, as it just points to the class type
{
}

template<class U, class V>
AliEmcalContainerIndexMap<U, V>::AliEmcalContainerIndexMap(AliEmcalContainerIndexMap<U, V> && other):
  AliEmcalContainerIndexMap()
{
  swap(*this, other);
}

template<class U, class V>
AliEmcalContainerIndexMap<U, V> & AliEmcalContainerIndexMap<U, V>::operator=(AliEmcalContainerIndexMap<U, V> map)
{
  swap(*this, map);

  return *this;
}

template<class X, class Y>
void swap(AliEmcalContainerIndexMap<X, Y> & first, AliEmcalContainerIndexMap<X, Y> & second)
{
  using std::swap;

  swap(first.offset, second.offset);
  swap(first.fGlobalIndexMap, second.fGlobalIndexMap);
  swap(first.fClass, second.fClass);
}

template<class U, class V>
inline const TClonesArray * AliEmcalContainerIndexMap<U, V>::GetObject(const AliEmcalContainer * inputObject) const
{
  return inputObject->GetArray();
}

template<class U, class V>
inline const TClonesArray * AliEmcalContainerIndexMap<U, V>::GetObject(const TClonesArray * inputObject) const
{
  return inputObject;
}

template<class U, class V>
inline bool AliEmcalContainerIndexMap<U, V>::IsUnderlyingInputObjectTypeCompatible(const U * inputObject) const
{
  if (!(inputObject->GetClass()->InheritsFrom(fClass))) {
    AliErrorGeneral("AliEmcalContainerIndexMap", Form("Cannot register array %s. This map can only accept arrays of type %s.", inputObject->GetName(), fClass->GetName()));
    return false;
  }

  return true;
}

template<class U, class V>
int AliEmcalContainerIndexMap<U, V>::RegisterArray(U * inputObject)
{
  if (IsUnderlyingInputObjectTypeCompatible(inputObject) == false) {
    return -1;
  }

  int index = 0;
  bool addToMap = true;
  for (auto val : fGlobalIndexMap)
  {
    // Check if the array is already added
    // We want to compare the address of the TClonesArrays to simplify the comparison
    if (GetObject(val.second) == GetObject(inputObject)) {
      addToMap = false;
      index = val.first;
      break;
    }

    // Find the max index so that we can add at the proper place
    if (val.first >= index) {
      index = val.first + fOffset;
    }
  }

  // Add to map
  if (addToMap) {
    // We want to compare the address of the TClonesArrays to simplify the comparison
    fGlobalIndexMap[index] = inputObject;
  }

  return index;
}

template<class U, class V>
int AliEmcalContainerIndexMap<U, V>::GlobalIndexFromLocalIndex(const U * inputObject, const int localIndex) const
{
  int globalIndex = GetOffset(inputObject);

  // Only add the local index if we found a match!
  if (globalIndex >= 0) {
    globalIndex += localIndex;
  }
  else {
    AliWarningGeneral("AliEmcalContainerIndexMap", TString::Format("Unable to retrieve global index for input object %s. Was the input object registered?", inputObject->GetName()));
  }

  return globalIndex;
}

template<class U, class V>
template<class U2>
int AliEmcalContainerIndexMap<U, V>::GetOffset(const U2 * inputObject) const
{
  int globalIndex = -1;
  for (auto val : fGlobalIndexMap)
  {
    // We want to compare the address of the TClonesArrays to simplify the comparison
    if (GetObject(val.second) == GetObject(inputObject)) {
      globalIndex = val.first;
      break;
    }
  }

  return globalIndex;
}

template<class U, class V>
std::pair<int, U *> AliEmcalContainerIndexMap<U, V>::LocalIndexFromGlobalIndex(const int globalIndex) const
{
  // Round to nearest offset
  int index = (globalIndex + fOffset/2)/fOffset * fOffset;

  // Used at() to allow the function to be const (operator[] is not const for std::map)
  U * array = fGlobalIndexMap.at(index);

  return std::pair<int, U*> (globalIndex - index, array);
}

template<class U, class V>
V * AliEmcalContainerIndexMap<U, V>::GetObjectFromGlobalIndex(const int globalIndex) const
{
  auto res = LocalIndexFromGlobalIndex(globalIndex);

  // We don't need to call GetObject() if we access using operator[]!
  return static_cast<V *>((*res.second)[res.first]);
}

template<class U, class V>
template<class U2>
void AliEmcalContainerIndexMap<U, V>::CopyMappingFrom(const AliEmcalContainerIndexMap<U2, V>& map, TCollection & containers)
{
  TIter next(&containers);
  TObject* obj = 0;
  while((obj = next())) {
    U* cont = dynamic_cast<U*>(obj);
    if (!cont) continue;
    if (IsUnderlyingInputObjectTypeCompatible(cont) == false) {
      continue;
    }

    int gindex = map.GetOffset(cont);
    if (gindex >= 0) fGlobalIndexMap[gindex] = cont;
  }
}

template<class U, class V>
template<class U2>
void AliEmcalContainerIndexMap<U, V>::CopyMappingFrom(const AliEmcalContainerIndexMap<U2, V>& map, U* cont)
{
  if (IsUnderlyingInputObjectTypeCompatible(cont) == false) {
    return;
  }

  int gindex = map.GetOffset(cont);
  if (gindex >= 0) fGlobalIndexMap[gindex] = cont;
}

#endif /* AliEmcalContainerIndexMap.h */
#endif /* Hiding from CINT */