TTClusterAssociationMap.h

Go to the documentation of this file.

#ifndef L1_TRACK_TRIGGER_CLUSTER_ASSOCIATION_FORMAT_H
#define L1_TRACK_TRIGGER_CLUSTER_ASSOCIATION_FORMAT_H

#include "DataFormats/Common/interface/Ref.h"
#include "DataFormats/Common/interface/Ptr.h"
#include "DataFormats/Common/interface/DetSet.h"
#include "DataFormats/Common/interface/DetSetVector.h"
#include "DataFormats/Common/interface/DetSetVectorNew.h"
#include "DataFormats/DetId/interface/DetId.h"
#include "DataFormats/Phase2TrackerDigi/interface/Phase2TrackerDigi.h"
#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h" 
#include "DataFormats/L1TrackTrigger/interface/TTCluster.h"
#include "SimDataFormats/TrackerDigiSimLink/interface/PixelDigiSimLink.h"
#include "SimDataFormats/Track/interface/SimTrack.h"
#include "SimDataFormats/Track/interface/SimTrackContainer.h"
#include "SimDataFormats/EncodedEventId/interface/EncodedEventId.h"
#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h"

template< typename T >
class TTClusterAssociationMap
{
  public:
    TTClusterAssociationMap();

    ~TTClusterAssociationMap();


    std::map< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >, std::vector< edm::Ptr< TrackingParticle > > > getTTClusterToTrackingParticlesMap() const
      { return clusterToTrackingParticleVectorMap; }
    std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > > getTrackingParticleToTTClustersMap() const
      { return trackingParticleToClusterVectorMap; }

    void setTTClusterToTrackingParticlesMap( std::map< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >, std::vector< edm::Ptr< TrackingParticle > > > aMap )
      { clusterToTrackingParticleVectorMap = aMap; }
    void setTrackingParticleToTTClustersMap( std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > > aMap )
      { trackingParticleToClusterVectorMap = aMap; }

    std::vector< edm::Ptr< TrackingParticle > >                                       findTrackingParticlePtrs( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const;
    edm::Ptr< TrackingParticle >                                                      findTrackingParticlePtr( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const;
    std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > findTTClusterRefs( edm::Ptr< TrackingParticle > aTrackingParticle ) const;

    bool isGenuine( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const;
    bool isCombinatoric( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const;
    bool isUnknown( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const;

  private:
    std::map< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >, std::vector< edm::Ptr< TrackingParticle > > > clusterToTrackingParticleVectorMap;
    std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > > trackingParticleToClusterVectorMap;

    int nclus;

}; 

template< typename T >
TTClusterAssociationMap< T >::TTClusterAssociationMap()
{
  clusterToTrackingParticleVectorMap.clear();
  trackingParticleToClusterVectorMap.clear();
  nclus=0;
}

template< typename T >
TTClusterAssociationMap< T >::~TTClusterAssociationMap(){}

template< typename T >
std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > TTClusterAssociationMap< T >::findTTClusterRefs( edm::Ptr< TrackingParticle > aTrackingParticle ) const
{
  if ( trackingParticleToClusterVectorMap.find( aTrackingParticle ) != trackingParticleToClusterVectorMap.end() )
  {
    return trackingParticleToClusterVectorMap.find( aTrackingParticle )->second;
  }

  std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > tempVector;
  tempVector.clear();
  return tempVector;
}

template< typename T >
std::vector< edm::Ptr< TrackingParticle > > TTClusterAssociationMap< T >::findTrackingParticlePtrs( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const
{
  if ( clusterToTrackingParticleVectorMap.find( aCluster ) != clusterToTrackingParticleVectorMap.end() )
  {
    return clusterToTrackingParticleVectorMap.find( aCluster )->second;
  }

  std::vector< edm::Ptr< TrackingParticle > > tempVector;
  tempVector.clear();
  return tempVector;
}




template< typename T >
bool TTClusterAssociationMap< T >::isGenuine( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const
{


  std::vector< edm::Ptr< TrackingParticle > > theseTrackingParticles = this->findTrackingParticlePtrs( aCluster );



  if ( theseTrackingParticles.size() == 0 )
    return false;

  unsigned int nullTPs = 0;
  unsigned int goodDifferentTPs = 0;
  std::vector< const TrackingParticle* > tpAddressVector;

  std::vector<float> tp_mom;

  float tp_tot=0;

  for ( const auto& tp : theseTrackingParticles )
  {
    edm::Ptr< TrackingParticle > curTP = tp;

    if ( curTP.isNull() )
    {
      //      nullTPs++;
      tp_mom.push_back(0);
    }
    else
    {
      tp_mom.push_back(curTP.get()->p4().pt());
      tp_tot+=curTP.get()->p4().pt();
    }
  }

  if (tp_tot==0) return false;
  
  for ( unsigned int itp = 0; itp < theseTrackingParticles.size(); itp++ )
  {
    edm::Ptr< TrackingParticle > curTP = theseTrackingParticles.at(itp);

    if ( tp_mom.at(itp) <= 0.01*tp_tot)
    {
      nullTPs++;
    }
    else
    {
      tpAddressVector.push_back( curTP.get() );
    }
  }
  

  std::sort( tpAddressVector.begin(), tpAddressVector.end() );
  tpAddressVector.erase( std::unique( tpAddressVector.begin(), tpAddressVector.end() ), tpAddressVector.end() );
  goodDifferentTPs = tpAddressVector.size();

  return ( goodDifferentTPs == 1 );
}

template< typename T >
bool TTClusterAssociationMap< T >::isUnknown( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const
{
  std::vector< edm::Ptr< TrackingParticle > > theseTrackingParticles = this->findTrackingParticlePtrs( aCluster );

  if ( theseTrackingParticles.size() == 0 )
    return true;

  unsigned int goodDifferentTPs = 0;
  std::vector< const TrackingParticle* > tpAddressVector;

  for ( unsigned int itp = 0; itp < theseTrackingParticles.size(); itp++ )
  {
    edm::Ptr< TrackingParticle > curTP = theseTrackingParticles.at(itp);

    if ( !curTP.isNull() )
    {
      tpAddressVector.push_back( curTP.get() );
    }
  }

  std::sort( tpAddressVector.begin(), tpAddressVector.end() );
  tpAddressVector.erase( std::unique( tpAddressVector.begin(), tpAddressVector.end() ), tpAddressVector.end() );
  goodDifferentTPs = tpAddressVector.size();

  return ( goodDifferentTPs == 0 );
}

template< typename T >
bool TTClusterAssociationMap< T >::isCombinatoric( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const
{
  std::vector< edm::Ptr< TrackingParticle > > theseTrackingParticles = this->findTrackingParticlePtrs( aCluster );

  if ( theseTrackingParticles.empty())
    return false;


  bool genuineClu = this->isGenuine( aCluster );
  bool unknownClu = this->isUnknown( aCluster );

  if (genuineClu || unknownClu) return false;

  return true;

  unsigned int nullTPs = 0;
  unsigned int goodDifferentTPs = 0;
  std::vector< const TrackingParticle* > tpAddressVector;
  
  for ( unsigned int itp = 0; itp < theseTrackingParticles.size(); itp++ )
  {
    edm::Ptr< TrackingParticle > curTP = theseTrackingParticles.at(itp);

    if ( curTP.isNull() )
    {
      nullTPs++;
    }
    else
    {
      tpAddressVector.push_back( curTP.get() );
    }
  }

  std::sort( tpAddressVector.begin(), tpAddressVector.end() );
  tpAddressVector.erase( std::unique( tpAddressVector.begin(), tpAddressVector.end() ), tpAddressVector.end() );
  goodDifferentTPs = tpAddressVector.size();

  //return ( ( nullTPs == 0 && goodDifferentTPs > 1 ) || ( nullTPs > 0 && goodDifferentTPs > 0 ) );
  return (goodDifferentTPs > 1);
}

template< typename T >
edm::Ptr< TrackingParticle > TTClusterAssociationMap< T >::findTrackingParticlePtr( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const
{
  if ( this->isGenuine( aCluster ) )
  {
    return this->findTrackingParticlePtrs( aCluster ).at(0);
  }

  edm::Ptr< TrackingParticle >* temp = new edm::Ptr< TrackingParticle >();
  return *temp;
}

#endif