AnalizerTCInfo.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
// tracking:
#include <tracking/spacePointCreation/SpacePointTrackCand.h>
#include <tracking/spacePointCreation/MCVXDPurityInfo.h>
#include <tracking/trackFindingVXD/analyzingTools/TCType.h>
 
// root:
#include <TVector3.h>
 
// stl:
#include <vector>
#include <utility> // std::pair
 
namespace Belle2 {
  class AnalizerTCInfo {
  public:
 
 
    TVector3 posSeed;
 
    TVector3 momSeed;
 
    const SpacePointTrackCand* tC;
 
    AnalizerTCInfo* assignedTC;
 
    MCVXDPurityInfo assignedID;
 
    TCType::Type tcType;
 
 
    AnalizerTCInfo() : tC(nullptr), assignedTC(nullptr), tcType(TCType::Unclassified) {}
 
 
    static AnalizerTCInfo createTC(bool isReference, const MCVXDPurityInfo& iD, SpacePointTrackCand& aTC)
    {
      AnalizerTCInfo newTC;
 
      newTC.posSeed = aTC.getPosSeed();
      newTC.momSeed = aTC.getMomSeed();
      newTC.tC = &aTC;
      newTC.assignedID = iD;
      newTC.tcType = isReference ? TCType::Reference : TCType::Unclassified;
      return newTC;
    }
 
 
    static void markUnused(std::vector<AnalizerTCInfo>& tcs, TCType::Type newType)
    {
      for (AnalizerTCInfo& aTC : tcs) {
        if (aTC.assignedTC == nullptr) {
          aTC.tcType = newType;
        }
      }
    }
 
 
    static TCType::Type classifyTC(AnalizerTCInfo& referenceTC, AnalizerTCInfo& testTC, double purityThreshold,
                                   unsigned int ndfThreshold)
    {
      std::pair<int, float> testPurity = testTC.assignedID.getPurity();
      std::pair<int, float> refPurity = referenceTC.assignedID.getPurity();
      // catch ill case
      if (testPurity.first != refPurity.first) { return TCType::Unclassified; }
 
      if (testPurity.second < purityThreshold) { return TCType::Ghost; }
 
      if (testTC.assignedID.getNDFTotal() < ndfThreshold) { return TCType::SmallStump; }
 
      if (testPurity.second < 1.f) { return TCType::Contaminated; }
 
      if (testTC.assignedID.getNClustersTotal() < referenceTC.assignedID.getNClustersTotal()) { return TCType::Clean; }
 
      return TCType::Perfect;
    }
 
 
    void discardTC()
    {
      assignedTC->tcType = TCType::Clone;
      assignedTC = nullptr;
    }
 
 
    void assignTCs(AnalizerTCInfo* otherTC)
    {
      assignedTC = otherTC;
      otherTC->assignedTC = this;
    }
 
 
    void pairUp(AnalizerTCInfo* otherTC)
    {
      // case: this TC was not assigned before
      if (assignedTC == nullptr) {
        assignTCs(otherTC);
        return;
      }
 
      // case: was already assigned, but old one was not as good as the new one
      if (assignedTC->tcType < otherTC->tcType) {
        discardTC();
        assignTCs(otherTC);
        return;
      }
 
      // case: was already assigned, but old one was better.
      otherTC->assignedTC = this;
      otherTC->tcType = TCType::Clone;
    }
 
 
    TCType::Type getType() const { return tcType; }
  };
}