AnalyzingAlgorithmClusterBased.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2015 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Jakob Lettenbichler                                      *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
// svd:
#include <svd/dataobjects/SVDCluster.h>
 
 
// tracking:
#include <tracking/spacePointCreation/SpacePoint.h>
#include <tracking/trackFindingVXD/analyzingTools/algorithms/AnalyzingAlgorithmBase.h>
 
namespace Belle2 {
  namespace AnalyzingAlgorithmHelper {
 
//  /** non-memberfunction Comparison for equality two clusters */
//  template <class ClusterType>
//  inline bool operator == (const ClusterType& a, const ClusterType& b)
//  { return (a.getSensorID() == b.getSensorID()
//    and a.isUCluster() == b.isUCluster()
//    and a.getPosition() == b.getSensorID()); }
//
 
 
    template <class TrackCandType>
    std::vector<const Belle2::SVDCluster*> getSVDClusters(const TrackCandType* aTC, bool wantUCluster)
    {
      std::vector<const Belle2::SVDCluster*> clusters;
      for (const Belle2::SpacePoint* aHit : aTC->getHits()) {
        auto relatedClusters = aHit->getRelationsTo<SVDCluster>("ALL");
        for (const Belle2::SVDCluster& aCluster : relatedClusters) {
          if (aCluster.isUCluster() == wantUCluster) { clusters.push_back(&aCluster); }
        }
      }
      return clusters;
    }
 
 
    template <class ClusterType>
    std::vector<const ClusterType*> getUniqueClusters(std::vector<const ClusterType*>& firstTC,
                                                      std::vector<const ClusterType*>& secondTC)
    {
      auto compareClusters = [](const ClusterType * a, const ClusterType * b) -> bool {
        return (a->getSensorID() == b->getSensorID()
        and a->isUCluster() == b->isUCluster()
        and a->getPosition() == b->getPosition()); };
 
      std::vector<const ClusterType*> uniqueClusters;
      for (const auto* firstCluster : firstTC) {
        for (const auto* secondCluster : secondTC) {
          if (compareClusters(firstCluster, secondCluster)) { uniqueClusters.push_back(firstCluster); break; }
        }
      }
      return uniqueClusters;
    }
  }
 
 
 
// residual type algorithms: (uses difference between test- and refTC):
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmLostUClusters : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmLostUClusters() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmLostUClusters) {}
 
    DataType calcData(const TCInfoType& aTC) override 
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      std::vector<const SVDCluster*> uClustersRef = AnalyzingAlgorithmHelper::getSVDClusters(tcs.refTC->tC, true);
      std::vector<const SVDCluster*> uClustersTest = AnalyzingAlgorithmHelper::getSVDClusters(tcs.testTC->tC, true);
 
      return AnalyzingAlgorithmHelper::getUniqueClusters(uClustersRef, uClustersTest).size();
    }
  };
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmLostVClusters : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmLostVClusters() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmLostVClusters) {}
 
    DataType calcData(const TCInfoType& aTC) override 
    {
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      std::vector<const SVDCluster*> vClustersRef = AnalyzingAlgorithmHelper::getSVDClusters(tcs.refTC->tC, false);
      std::vector<const SVDCluster*> vClustersTest = AnalyzingAlgorithmHelper::getSVDClusters(tcs.testTC->tC, false);
 
      return AnalyzingAlgorithmHelper::getUniqueClusters(vClustersRef, vClustersTest).size();
    }
  };
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmLostUEDep : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmLostUEDep() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmLostUEDep) {}
 
    virtual DataType calcData(const TCInfoType& aTC) 
    {
      DataType lostEdep;
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      std::vector<const SVDCluster*> uClustersRef = AnalyzingAlgorithmHelper::getSVDClusters(tcs.refTC->tC, true);
      std::vector<const SVDCluster*> uClustersTest = AnalyzingAlgorithmHelper::getSVDClusters(tcs.testTC->tC, true);
 
      std::vector<const SVDCluster*> lostuClusters = AnalyzingAlgorithmHelper::getUniqueClusters(uClustersRef, uClustersTest);
 
      for (const SVDCluster* aCluster : lostuClusters) {
        lostEdep.push_back(double(aCluster->getCharge()));
      }
      return lostEdep;
    }
  };
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmLostVEDep : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmLostVEDep() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmLostVEDep) {}
 
    virtual DataType calcData(const TCInfoType& aTC) 
    {
      DataType lostEdep;
      const auto tcs = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectPairOfTCs(aTC);
      std::vector<const SVDCluster*> vClustersRef = AnalyzingAlgorithmHelper::getSVDClusters(tcs.refTC->tC, false);
      std::vector<const SVDCluster*> vClustersTest = AnalyzingAlgorithmHelper::getSVDClusters(tcs.testTC->tC, false);
 
      std::vector<const SVDCluster*> lostvClusters = AnalyzingAlgorithmHelper::getUniqueClusters(vClustersRef, vClustersTest);
 
      for (const SVDCluster* aCluster : lostvClusters) {
        lostEdep.push_back(double(aCluster->getCharge()));
      }
      return lostEdep;
    }
  };
 
 
 
// value type algorithms: (uses info of a single TC):
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmTotalUClusters : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmTotalUClusters() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmTotalUClusters) {}
 
    DataType calcData(const TCInfoType& aTC) override 
    {
      const TCInfoType& thisTC = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectTC(aTC);
      std::vector<const SVDCluster*> uClusters = AnalyzingAlgorithmHelper::getSVDClusters(thisTC.tC, true);
 
      return uClusters.size();
    }
  };
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmTotalVClusters : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmTotalVClusters() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmTotalVClusters) {}
 
    DataType calcData(const TCInfoType& aTC) override 
    {
      const TCInfoType& thisTC = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectTC(aTC);
      std::vector<const SVDCluster*> vClusters = AnalyzingAlgorithmHelper::getSVDClusters(thisTC.tC, false);
 
      return vClusters.size();
    }
  };
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmTotalUEDep : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmTotalUEDep() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmTotalUEDep) {}
 
    virtual DataType calcData(const TCInfoType& aTC) 
    {
      DataType totalEDep;
      const TCInfoType& thisTC = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectTC(aTC);
      std::vector<const SVDCluster*> uClusters = AnalyzingAlgorithmHelper::getSVDClusters(thisTC.tC, true);
 
      for (const SVDCluster* aCluster : uClusters) {
        totalEDep.push_back(double(aCluster->getCharge()));
      }
      return totalEDep;
    }
  };
 
 
 
  template <class DataType, class TCInfoType, class VectorType>
  class AnalyzingAlgorithmTotalVEDep : public AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType> {
  public:
    AnalyzingAlgorithmTotalVEDep() : AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>
      (AlgoritmType::AnalyzingAlgorithmTotalVEDep) {}
 
    virtual DataType calcData(const TCInfoType& aTC) 
    {
      DataType totalEDep;
      const TCInfoType& thisTC = AnalyzingAlgorithmBase<DataType, TCInfoType, VectorType>::chooseCorrectTC(aTC);
      std::vector<const SVDCluster*> vClusters = AnalyzingAlgorithmHelper::getSVDClusters(thisTC.tC, false);
 
      for (const SVDCluster* aCluster : vClusters) {
        totalEDep.push_back(double(aCluster->getCharge()));
      }
      return totalEDep;
    }
  };
}