Associator_BestMatch.h

Go to the documentation of this file.

/* emacs: this is -*- c++ -*- */
 
 
#ifndef TIDAUTILS_ASSOCIATOR_BESTMATCH_H
#define TIDAUTILS_ASSOCIATOR_BESTMATCH_H
 
#include <set>
#include <map>
#include <cmath>
 
 
#include "TrigInDetAnalysis/TrackAssociator.h"
#include "TrigInDetAnalysis/Track.h"
 
#include "TrigInDetAnalysisUtils/BestMatcher.h"
 
 
 
typedef BestMatcher<TIDA::Track> Associator_BestMatcher;
 
 
 
 
class Associator_DeltaRMatcher : public Associator_BestMatcher { 
 
public:
 
  Associator_DeltaRMatcher(const std::string& name, double d) : 
    Associator_BestMatcher(name, d) 
  { } 
  
  virtual ~Associator_DeltaRMatcher() { } 
 
  virtual TrackAssociator* clone() override { return new Associator_DeltaRMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_DeltaRMatcher>(*this); }
 
  virtual double distance( const TIDA::Track* t0,  const TIDA::Track* t1 ) const override {
    double deta = t0->eta()-t1->eta();
    double dphi = t0->phi()-t1->phi();    
    if ( dphi> M_PI ) dphi-=2*M_PI; 
    if ( dphi<-M_PI ) dphi+=2*M_PI;
    return std::sqrt( deta*deta + dphi*dphi );
  }
  
};
 
 
 
 
class Associator_SecondBestpTMatcher : public Associator_BestMatcher {
 
public:
 
  Associator_SecondBestpTMatcher(const std::string& name, double d) :
    Associator_BestMatcher(name, d)
  { }
 
  virtual ~Associator_SecondBestpTMatcher() { }
 
  virtual TrackAssociator* clone() override { return new Associator_SecondBestpTMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_SecondBestpTMatcher>(*this); }
  
  virtual double distance( const TIDA::Track* t0, const TIDA::Track* t1 ) const override {
    double dpT = fabs( t0->pT()/1000 - t1->pT()/1000 );
    //std::cout << "pT dist = " << dpT << "    dpT / pT = " << dpT/fabs(t0->pT()/1000) << std::endl;
    return dpT/(fabs(t0->pT()/1000));
  }
 
};
 
 
 
class Associator_BestDeltaRMatcher : public Associator_BestMatcher { 
 
public:
 
  Associator_BestDeltaRMatcher(const std::string& name, double d) : 
    Associator_BestMatcher(name, d) 
  { } 
 
  virtual ~Associator_BestDeltaRMatcher() { } 
 
  virtual TrackAssociator* clone() override { return new Associator_BestDeltaRMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_BestDeltaRMatcher>(*this); }
 
  virtual double distance( const TIDA::Track* t0, const TIDA::Track* t1 ) const override {
    double deta = t0->eta()-t1->eta();
    double dphi = t0->phi()-t1->phi();    
    if ( dphi> M_PI ) dphi-=2*M_PI; 
    if ( dphi<-M_PI ) dphi+=2*M_PI;
    return std::sqrt( deta*deta + dphi*dphi );
  }
 
};
 
 
 
 
 
 
 
 
class Associator_BestDeltaRZMatcher : public Associator_BestMatcher { 
 
public:
 
  Associator_BestDeltaRZMatcher(const std::string& name, double deta=0.05, double dphi=0.05, double dzed=5) : 
    Associator_BestMatcher(name, 1), 
    m_deta2(deta*deta),
    m_dphi2(dphi*dphi),
    m_dzed2(dzed*dzed)
  {
    std::cout << "Associator: Best RZ Matcher" << std::endl;
  } 
 
  virtual ~Associator_BestDeltaRZMatcher() { } 
 
  virtual TrackAssociator* clone() override { return new Associator_BestDeltaRZMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_BestDeltaRZMatcher>(*this); }
 
  virtual double distance( const TIDA::Track* t0, const TIDA::Track* t1 ) const override {
    double deta = t0->eta()-t1->eta();
    double dphi = t0->phi()-t1->phi(); if ( dphi> M_PI ) dphi-=2*M_PI;  if ( dphi<-M_PI ) dphi+=2*M_PI;
    double dzed = t0->z0()-t1->z0();    
 
    double dr =  std::sqrt( deta*deta/m_deta2 + dphi*dphi/m_dphi2 + dzed*dzed/m_dzed2 );
 
    //    std::cout << "RZ matcher dr: " << dr 
    //        << "\t : \t" << deta*deta/m_deta2 << "\t" << dphi*dphi/m_dphi2 << "\t" << dzed*dzed/m_dzed2  << "\t" << *t1 
    //        << std::endl;
 
    return dr;
  }
 
protected: 
 
  double m_deta2;
  double m_dphi2;
  double m_dzed2;
 
};
 
 
 
 
 
class Associator_BestDeltaRZSinThetaMatcher : public Associator_BestMatcher { 
  // public Clonable<Associator_BestDeltaRZSinThetaMatcher, TrackAssociator>, 
 
public:
 
  Associator_BestDeltaRZSinThetaMatcher(const std::string& name, double deta=0.05, double dphi=0.05, double dzed=5) : 
    Associator_BestMatcher(name, 1), 
    m_deta2(deta*deta),
    m_dphi2(dphi*dphi),
    m_dzed2(dzed*dzed)
  {
    std::cout << "Associator: Best RZ Matcher" << std::endl;
  } 
 
  virtual ~Associator_BestDeltaRZSinThetaMatcher() { } 
 
  virtual TrackAssociator* clone() override { return new Associator_BestDeltaRZSinThetaMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_BestDeltaRZSinThetaMatcher>(*this); }
  
  virtual double distance( const TIDA::Track* t0, const TIDA::Track* t1 ) const override {
    double theta = 2*std::atan(std::exp(-t1->eta()));
 
    double deta = t0->eta()-t1->eta();
    double dphi = t0->phi()-t1->phi(); if ( dphi> M_PI ) dphi-=2*M_PI;  if ( dphi<-M_PI ) dphi+=2*M_PI;
 
    double dzed = (t0->z0()-t1->z0())*std::sin(theta);    
 
    double dr =  std::sqrt( deta*deta/m_deta2 + dphi*dphi/m_dphi2 + dzed*dzed/m_dzed2 );
 
    //    std::cout << "RZ matcher dr: " << dr 
    //        << "\t : \t" << deta*deta/m_deta2 << "\t" << dphi*dphi/m_dphi2 << "\t" << dzed*dzed/m_dzed2  << "\t" << *t1 
    //        << std::endl;
 
    return dr;
  }
 
protected: 
 
  double m_deta2;
  double m_dphi2;
  double m_dzed2;
 
};
 
 
 
 
class Associator_BestSigmaMatcher : public Associator_BestMatcher { 
  // public Clonable<Associator_BestSigmaMatcher, TrackAssociator>,
 
public:
 
  Associator_BestSigmaMatcher(const std::string& name, double dsigma=1) : 
    Associator_BestMatcher(name, dsigma) 
  { 
    std::cout << "Associator: Best Sigma Matcher" << std::endl;
  } 
 
  virtual ~Associator_BestSigmaMatcher() { } 
 
  virtual TrackAssociator* clone() override { return new Associator_BestSigmaMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_BestSigmaMatcher>(*this); }
  
  virtual double distance( const TIDA::Track* t0, const TIDA::Track* t1 ) const override {
    double deta = t1->eta()-t0->eta();
    double dphi = t1->phi()-t0->phi(); 
    if ( dphi> M_PI ) dphi-=2*M_PI;  
    if ( dphi<-M_PI ) dphi+=2*M_PI;
    double dzed = t1->z0()-t0->z0();    
 
    //     std::cout << *t0 << "\n" << *t1 << "\ndphi : " << dphi << std::endl;
 
    deta /= t1->deta();
    dphi /= t1->dphi();
    dzed /= t1->dz0();
 
    double dr =  std::sqrt( deta*deta + dphi*dphi + dzed*dzed );
 
    //    std::cout << "Sigma matcher dr: " << dr 
    //        << "\t : \t" << deta*deta << "\t" << dphi*dphi << "\t" << dzed*dzed << "\t" << *t1 
    //        << std::endl;
 
    return dr;
  }
 
protected: 
 
  double m_deta2;
  double m_dphi2;
  double m_dzed2;
 
};
 
 
 
 
class Associator_BestDeltaPhiMatcher : public Associator_BestMatcher { 
  // public Clonable<Associator_BestDetlaPhiMatcher, TrackAssociator>, 
 
public:
 
  Associator_BestDeltaPhiMatcher(const std::string& name, double p) : 
    Associator_BestMatcher(name, p) 
  { } 
 
  virtual ~Associator_BestDeltaPhiMatcher() { } 
 
  virtual TrackAssociator* clone() override { return new Associator_BestDeltaPhiMatcher(*this); }
 
  virtual std::unique_ptr<TrackAssociator> uclone() const override { return std::make_unique<Associator_BestDeltaPhiMatcher>(*this); }
  
  virtual double distance( const TIDA::Track* t0, const TIDA::Track* t1 ) const override {
    double dphi = t0->phi()-t1->phi();    
    if ( dphi> M_PI ) dphi-=2*M_PI; 
    if ( dphi<-M_PI ) dphi+=2*M_PI;
    return std::fabs( dphi );
  }
 
};
 
 
 
 
#endif //  TIDAUTILS_ASSOCIATOR_BESTMATCH_H