diff --git a/Trigger/TrigTools/IDScanHitFilter/ATLAS_CHECK_THREAD_SAFETY b/Trigger/TrigTools/IDScanHitFilter/ATLAS_CHECK_THREAD_SAFETY
deleted file mode 100644
index 61d96e367e6069905544cb36c5d86e1fdbbb4a16..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/ATLAS_CHECK_THREAD_SAFETY
+++ /dev/null
@@ -1 +0,0 @@
-Trigger/TrigTools/IDScanHitFilter
diff --git a/Trigger/TrigTools/IDScanHitFilter/CMakeLists.txt b/Trigger/TrigTools/IDScanHitFilter/CMakeLists.txt
deleted file mode 100644
index 215a0e7e35fa869d5f089d2b47ac830f72104d74..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/CMakeLists.txt
+++ /dev/null
@@ -1,9 +0,0 @@
-# Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-
-# Declare the package name:
-atlas_subdir( IDScanHitFilter )
-
-# Component(s) in the package:
-atlas_add_component( IDScanHitFilter
- src/*.cxx src/components/*.cxx
- LINK_LIBRARIES AthenaBaseComps CxxUtils GaudiKernel IRegionSelector TrigInDetEvent TrigInDetToolInterfacesLib )
diff --git a/Trigger/TrigTools/IDScanHitFilter/doc/packagedoc.h b/Trigger/TrigTools/IDScanHitFilter/doc/packagedoc.h
deleted file mode 100644
index d4bcebb285441a06d5f9055407b436fa24511540..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/doc/packagedoc.h
+++ /dev/null
@@ -1,49 +0,0 @@
-/*
- Copyright (C) 2002-2018 CERN for the benefit of the ATLAS collaboration
-*/
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-/**
-
-@page IDScanHitFilter_page IDScanHitFilter Package
-@author Nikos.Konstantinidis@cern.ch Dmitry.Emeliyanov@cern.ch
-@section IDScanHitFilter_IntroIDScanHitFilter Introduction
-
-This package contains the AlgTool that does the main part of pattern recognition of IDScan. For a full discription of all the
-pattern recognition steps of IDScan, please look at
-
-https://twiki.cern.ch/twiki/bin/view/Atlas/IDScanHowTo
-
-@section IDScanHitFilter_IDScanHitFilterProps IDScanHitFilter Properties:
-
- - PrintDiagnosticMessages : extra diagnostic printing to std::cout ( default false )
- - phiHalfWidth : RoI size in phi ( default 0.1 rads )
- - etaHalfWidth : RoI size in eta ( default 0.1 rads )
- - PhiBinSize : Size of the phi bins in the (phi,eta) histogram used at the main step of pattern recognition. The phi bin size is linked to how low-pT tracks can be reconstructed ( default 2.4 degrees )
- - EtaBinSize : Size of the eta bins in the (phi,eta) histogram used at the main step of pattern recognition ( default 0.005 )
- - LayerThreshold : Min. number of SPs in different Si layers in order to accept a group of SPs as a possible track candidate ( default 3.5 )
- - EnhanceLayer0 : By setting this parameter to TRUE you have a better chance of finding the Pixel Layer0 spacepoint of a track ( default true )
- - RemoveDuplicates : Apply a basic removal of duplicate tracks ( default true )
- - CloneRemovalCut : Between tracks sharing 3 (default) spacepoints or more, only the longest one is kept ( default 3 )
- - UsePtSign : Used to find clone tracks more efficiently ( default true )
-
- - LooseTightBoundary : Number of SPs in a group below which we use the loose set of cuts for the groupCleaner ( default 20.5 )
- - deltadzdrCut_loose : The difference in d_z/d_rho between hits 12 and 23 in a triplet, used to decide if the triplet comes from a track ( default 0.04 )
- - deltadzdrCut_tight : As above, but tighter, for when origianl group of hits is large, i.e. containing hits from several tracks ( default 0.01 )
- - etaCutInner_loose : The difference in eta between two hits (1-2), used to decide if they come from the same track ( default 0.008 )
- - etaCutInner_tight : As above, but tighter, for when origianl group of hits is large ( default 0.004 )
- - etaCutOuter_loose : The difference in eta between two hits (2-3), used to decide if they come from the same track ( default 0.02 )
- - etaCutOuter_tight : As above, but tighter, for when origianl group of hits is large ( default 0.01 )
- - d0Cut_loose : The track d0 calculated from a triplet of hits, used to decide if a triplet could come from a reasonable track ( default 4.0 )
- - d0Cut_tight : As above, but tighter, for when origianl group of hits is large ( default 1.0 )
- - dPhidRBins_loose : Number of 1/pT bins in the (1/pT,phi0) histogram used in the final step of pattern recognition ( default 200 )
- - dPhidRBins_tight : As above, but tighter, for when origianl group of hits is large ( default 250 )
- - phi0Bins_loose : Number of phi0 bins in the (1/pT,phi0) histogram used in the final step of pattern recognition ( default 16000 )
- - phi0Bins_tight : As above, but tighter, for when origianl group of hits is large ( default 20000 )
-
-
-
-
-*/
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/FilterBin.cxx b/Trigger/TrigTools/IDScanHitFilter/src/FilterBin.cxx
deleted file mode 100644
index 59b6feb0d1d740b26eb3c0200a2069eb4c7ca992..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/FilterBin.cxx
+++ /dev/null
@@ -1,14 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-//
-// @file FilterBin.cxx
-// set static variables for the FilterBin class
-//
-// @author M.Sutton
-//
-//
-// $Id: FilyterBin.cxx, v0.0 Sun 17 Mar 2013 10:06:51 GMT sutt $
-
-
-#include "FilterBin.h"
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/FilterBin.h b/Trigger/TrigTools/IDScanHitFilter/src/FilterBin.h
deleted file mode 100644
index c93b01262fdce05f830d9f4abc13d7d473e0cb20..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/FilterBin.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: FilterBin.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-//
-// Description: - The (eta,phi) bins for the HitFilter
-//
-// date: 29/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-#if ! defined( IDSCAN_FILTERBIN_H )
-#define IDSCAN_FILTERBIN_H
-
-#include "FixedBitSet.h"
-#include "IdScanSpPoint.h"
-
-#include "CxxUtils/checker_macros.h"
-
-#include <iostream>
-#include <list>
-#include <map>
-
-class FilterBin
-{
- public:
-
- long NumberOfHits() const;
- long NumberOfLayers() const;
-
- void AddLdirect( long layer_id );
- void AddLindirect( FixedBitSet& bits );
-
- void AddHit( IdScanSpPoint* spptr, long maxLayers, long maxBarrelLayer);
- void AddTriplet( IdScanSpPoint* iPtr,
- IdScanSpPoint* jPtr,
- IdScanSpPoint* kPtr );
-
- void exchangeBits( FilterBin& otherBin );
- std::list<IdScanSpPoint* >& hitList();
- const std::list<IdScanSpPoint* >& hitList() const;
-
-private:
- void neighborKeys( long key, long* np ) const;
-
-private:
- std::list<IdScanSpPoint* > m_HitList; // "list" of ptrs to SpPs falling in bin
-
- FixedBitSet m_Ldirect; // keeps direct layers
- FixedBitSet m_Ltotal; // keeps direct+indirect layers
-};
-
-
-inline std::ostream& operator<<(std::ostream& s, const FilterBin& f) {
- s << "[ Nhits=" << f.NumberOfHits()
- << "\t Nlayers=" << f.NumberOfLayers() << "\taddr=" << (void*)&f << "\t]";
-
- for (const IdScanSpPoint* hit : f.hitList()) {
- s << "\n\t" << *hit;
- }
- return s;
-}
-
-
-typedef std::map<int, FilterBin> FilterMap;
-
-
-inline long FilterBin::NumberOfHits() const {
- return m_HitList.size();
-}
-
-
-inline long FilterBin::NumberOfLayers() const {
- return m_Ltotal.count();
-}
-
-
-inline void FilterBin::AddLdirect( long layer_id ) {
- m_Ldirect.set( layer_id );
- m_Ltotal.set( layer_id );
-}
-
-
-inline void FilterBin::AddLindirect( FixedBitSet& bits ) {
- m_Ltotal.Or( bits );
-}
-
-
-inline void FilterBin::AddHit(IdScanSpPoint* spptr, long maxLayers, long maxBarrelLayer)
-{
-
- m_HitList.push_back( spptr );
- long lr = spptr->layer();
- this->AddLdirect( lr );
- if ( lr==0 || lr==maxBarrelLayer ){
- this->AddLdirect( maxLayers+lr );
- }
-
-}
-
-
-inline void FilterBin::AddTriplet( IdScanSpPoint* ip,
- IdScanSpPoint* jp,
- IdScanSpPoint* kp )
-{
-
- m_HitList.push_back( ip ); this->AddLdirect( ip->layer() );
- m_HitList.push_back( jp ); this->AddLdirect( jp->layer() );
- m_HitList.push_back( kp ); this->AddLdirect( kp->layer() );
-
-}
-
-
-inline void FilterBin::exchangeBits( FilterBin& otherBin )
-{
- m_Ltotal.Or( otherBin.m_Ldirect );
- otherBin.AddLindirect(m_Ldirect);
-}
-
-
-inline std::list<IdScanSpPoint* >& FilterBin::hitList()
-{
- return m_HitList;
-}
-
-inline const std::list<IdScanSpPoint* >& FilterBin::hitList() const
-{
- return m_HitList;
-}
-
-#endif
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/FixedBitSet.h b/Trigger/TrigTools/IDScanHitFilter/src/FixedBitSet.h
deleted file mode 100755
index da4311ccd464bb58e15478a9f27e6795cb583223..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/FixedBitSet.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: FixedBitSet.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-// athena migration: Malte Muller
-// mm@hep.ucl.ac.uk
-//
-// Description: defines the FixedBitSet class, used to store layer-information
-//
-// date: 29/10/2002
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if ! defined( IDSCAN_FIXEDBITSET_H )
-#define IDSCAN_FIXEDBITSET_H
-
-
- // Create the masks for each bit.
- static const unsigned int setMask[] = {
- (1u<< 0), (1u<< 1), (1u<< 2), (1u<< 3),
- (1u<< 4), (1u<< 5), (1u<< 6), (1u<< 7),
- (1u<< 8), (1u<< 9), (1u<<10), (1u<<11),
- (1u<<12), (1u<<13), (1u<<14), (1u<<15),
- (1u<<16), (1u<<17), (1u<<18), (1u<<19),
- (1u<<20), (1u<<21), (1u<<22), (1u<<23),
- (1u<<24), (1u<<25), (1u<<26), (1u<<27),
- (1u<<28), (1u<<29), (1u<<30), (1u<<31)};
-
- static const unsigned int clearMask[] = {
- ~(1u<< 0),~(1u<< 1),~(1u<< 2),~(1u<< 3),
- ~(1u<< 4),~(1u<< 5),~(1u<< 6),~(1u<< 7),
- ~(1u<< 8),~(1u<< 9),~(1u<<10),~(1u<<11),
- ~(1u<<12),~(1u<<13),~(1u<<14),~(1u<<15),
- ~(1u<<16),~(1u<<17),~(1u<<18),~(1u<<19),
- ~(1u<<20),~(1u<<21),~(1u<<22),~(1u<<23),
- ~(1u<<24),~(1u<<25),~(1u<<26),~(1u<<27),
- ~(1u<<28),~(1u<<29),~(1u<<30),~(1u<<31)};
-
- static const int countLUT0[] =
- {0,2,1,3,1,3,2,4,1,3,2,4,2,4,3,5,1,3,2,4,2,4,3,5,2,4,3,5,3,5,4,6,
- 1,3,2,4,2,4,3,5,2,4,3,5,3,5,4,6,2,4,3,5,3,5,4,6,3,5,4,6,4,6,5,7,
- 2,4,3,5,3,5,4,6,3,5,4,6,4,6,5,7,3,5,4,6,4,6,5,7,4,6,5,7,5,7,6,8,
- 3,5,4,6,4,6,5,7,4,6,5,7,5,7,6,8,4,6,5,7,5,7,6,8,5,7,6,8,6,8,7,9,
- 1,3,2,4,2,4,3,5,2,4,3,5,3,5,4,6,2,4,3,5,3,5,4,6,3,5,4,6,4,6,5,7,
- 2,4,3,5,3,5,4,6,3,5,4,6,4,6,5,7,3,5,4,6,4,6,5,7,4,6,5,7,5,7,6,8,
- 3,5,4,6,4,6,5,7,4,6,5,7,5,7,6,8,4,6,5,7,5,7,6,8,5,7,6,8,6,8,7,9,
- 4,6,5,7,5,7,6,8,5,7,6,8,6,8,7,9,5,7,6,8,6,8,7,9,6,8,7,9,7,9,8,10};
-
- static const int countLUT1[] =
- {0,1,1,2,1,2,2,3,1,2,2,3,2,3,3,4,1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,
- 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
- 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
- 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
- 1,2,2,3,2,3,3,4,2,3,3,4,3,4,4,5,2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,
- 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
- 2,3,3,4,3,4,4,5,3,4,4,5,4,5,5,6,3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,
- 3,4,4,5,4,5,5,6,4,5,5,6,5,6,6,7,4,5,5,6,5,6,6,7,5,6,6,7,6,7,7,8};
-
-
-class FixedBitSet {
-
- public:
-
- FixedBitSet() { m_bits = s_clearAllMask; };
- FixedBitSet(const FixedBitSet& set) { m_bits = set.m_bits; };
-
- bool get(const int bitIndex) const { return ((m_bits&setMask[bitIndex]) != 0); };
- int length() const { return 32; };
- int size() const { return 32; };
- int count() const
- {
- return ( countLUT1[m_bits & s_maskByte]+
- countLUT1[(m_bits>>8) & s_maskByte]+
- countLUT1[(m_bits>>16) & s_maskByte]+
- countLUT1[(m_bits>>24) & s_maskByte] );
- };
-
- void set(const int bitIndex) { m_bits |= setMask[bitIndex]; };
- void setAll() { m_bits = s_setAllMask; };
- void clear(const int bitIndex) { m_bits &= clearMask[bitIndex]; };
- void clearAll() { m_bits = s_clearAllMask; };
-
- void And (FixedBitSet& set) { m_bits &= set.m_bits; };
- void NAnd (FixedBitSet& set) { m_bits &= ~set.m_bits; };
- void Or (FixedBitSet& set) { m_bits |= set.m_bits; };
- void XOr (FixedBitSet& set) { m_bits ^= set.m_bits; };
-
- bool operator==(const FixedBitSet& set) const { return (m_bits == set.m_bits); };
-
- private:
-
- static const int s_clearAllMask = 0;
- static const int s_setAllMask = ~((int) 0);
- static const int s_maskByte = 255;
-
- // The m_bits used to store this FixedBitSet.
- int m_bits;
-
-};
-
-
-#endif
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/GC_Constants.h b/Trigger/TrigTools/IDScanHitFilter/src/GC_Constants.h
deleted file mode 100755
index 3abc58a073c1539577758daf4e169d3ecb12c15d..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/GC_Constants.h
+++ /dev/null
@@ -1,94 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: GC_Constants.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-// Description: parameters for group cleaner
-//
-// date: 29/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if ! defined( IDSCAN_GCCONSTANTS_H )
-#define IDSCAN_GCCONSTANTS_H
-
-// to convert GeV to MeV and cm to mm
-//#include "CLHEP/Units/PhysicalConstants.h"
-#include <cmath>
-
-struct groupCleanerParams
-{
- const double dPhidRCut, deltadZdRCut;
- const double etaCutInner, etaCutOuter;
- const double d0Cut;
- const double phi0Offset;
- const double invdPhidRBinSize, invPhi0BinSize;
-
- groupCleanerParams( const double ddZdR, const double etaI,
- const double etaO, const double d0,
- const double dPhidRBinSize, const long phi0Bins, const double delPhidelRCut=0.0003 ) :
-
- // dPhidRCut ( 0.0003 ), /* was 0.003 in cm */
- dPhidRCut ( delPhidelRCut ), /* was 0.003 in cm */
- deltadZdRCut ( ddZdR ),
- etaCutInner ( etaI ),
- etaCutOuter ( etaO ),
- d0Cut ( d0 ),
- phi0Offset ( 0.155/0.0003 ),
- // invdPhidRBinSize ( dPhidRBins/(2*dPhidRCut) ),
- invdPhidRBinSize ( 1.0/dPhidRBinSize ),
- invPhi0BinSize ( phi0Bins/(2.0*M_PI) )
- {};
-};
-
-struct GCP_loose : public groupCleanerParams
-{
- GCP_loose(double deltadzdrCut,
- double etaCutInner,
- double etaCutOuter,
- double d0Cut,
- double dPhidRBinSize,
- long phi0Bins,
- double delPhidelRCut ) :
- groupCleanerParams(
- deltadzdrCut,
- etaCutInner,
- etaCutOuter,
- d0Cut,
- dPhidRBinSize,
- phi0Bins,
- delPhidelRCut
- ) {};
-};
-
-struct GCP_tight : public groupCleanerParams
-{
- GCP_tight(double deltadzdrCut,
- double etaCutInner,
- double etaCutOuter,
- double d0Cut,
- double dPhidRBinSize,
- long phi0Bins,
- double delPhidelRCut ) :
- groupCleanerParams(
- deltadzdrCut,
- etaCutInner,
- etaCutOuter,
- d0Cut,
- dPhidRBinSize,
- phi0Bins,
- delPhidelRCut
- ) {};
-};
-
-
-#endif
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/Group.h b/Trigger/TrigTools/IDScanHitFilter/src/Group.h
deleted file mode 100644
index b7467307baf99e47eb586f433a808a1cce95ebfa..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/Group.h
+++ /dev/null
@@ -1,154 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: Group.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-//
-// Description: - The Groups of IdScanSpPoints after pattern recognition
-//
-// date: 29/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-#if ! defined( IDSCAN_GROUP_H )
-#define IDSCAN_GROUP_H
-
-
-#include <list>
-#include <iostream>
-#include <iomanip>
-
-
-#include "IdScanSpPoint.h"
-
-typedef std::vector<IdScanSpPoint*> hitVec;
-
-class Group
-{
- public:
-
- Group() : m_bin1(0), m_bin2(0), m_nEntries(0),
- m_eta(0), m_phi0(0), m_d0(0), m_z0(0) { };
-
- void AddHits( std::list<IdScanSpPoint* >& binhits, long bin1, long bin2 );
- long NumberOfHits() const;
- std::list< IdScanSpPoint* >& groupHits();
- const std::list< IdScanSpPoint* >& groupHits() const;
- double bin1() const;
- double bin2() const;
-
- double getEta() const { return m_eta; };
- double getPhi0() const { return m_phi0; };
- double getPtInv() const { return m_ptInv; };
- double getd0() const { return m_d0; };
- double getz0() const { return m_z0; };
- double getChi2() const { return m_chi2; };
-
- void setEta( double eta) { m_eta = eta; };
- void setPhi0( double phi0) { m_phi0 = phi0; };
- void setPtInv( double ptinv) { m_ptInv = ptinv; };
- void setd0( double d0) { m_d0 = d0; };
- void setz0( double z0) { m_z0 = z0; };
- void setChi2( double chi2) { m_chi2 = chi2;};
-
- void removeDuplicates();
-
- bool operator < (const Group& rhs)
- { return fabs(m_ptInv) > fabs(rhs.m_ptInv); };
-
- private:
- std::list< IdScanSpPoint* > m_HitList; // "list" of ptrs to SpPs making the group
- long m_bin1;
- long m_bin2;
- long m_nEntries;
-
- double m_eta;
- double m_phi0;
- double m_ptInv;
- double m_d0;
- double m_z0;
- double m_chi2;
-
-};
-
-
-typedef std::list< Group > GroupList;
-
-
-
-inline std::ostream& operator<<(std::ostream& s, const Group& g)
-{
- const std::list<IdScanSpPoint*>& hits = g.groupHits();
- s << "[ eta=" << g.getEta()
- << "\tphi=" << g.getPhi0()
- << "\tzed=" << g.getz0()
- << "\tnhits=" << hits.size()
- << "\taddr=" << std::hex << (void*)&g << std::dec << "\t]";
- std::list<IdScanSpPoint*>::const_iterator hitr(hits.begin());
- std::list<IdScanSpPoint*>::const_iterator hend(hits.end());
- while ( hitr!=hend ) s << "\n\t" << *(*hitr++);
- return s;
-}
-
-
-
-
-inline double Group::bin1() const
-{
- return double(m_bin1)/double(m_nEntries);
-}
-
-
-inline double Group::bin2() const
-{
- return double(m_bin2)/double(m_nEntries);
-}
-
-inline void Group::AddHits( std::list< IdScanSpPoint* >& binhits, long bin1, long bin2 )
-{
- long entries = binhits.size();
- m_nEntries += entries;
- m_bin1 += entries*bin1;
- m_bin2 += entries*bin2;
-
- m_HitList.splice(m_HitList.end(), binhits);
-}
-
-
-inline long Group::NumberOfHits() const
-{
- return m_HitList.size();
-}
-
-
-inline const std::list< IdScanSpPoint* >& Group::groupHits() const
-{
- return m_HitList;
-}
-
-
-inline std::list< IdScanSpPoint* >& Group::groupHits()
-{
- return m_HitList;
-}
-
-
-inline void Group::removeDuplicates()
-{
- // m_HitList.sort( );
- // m_HitList.unique();
- m_HitList.sort(orderInIndex());
- m_HitList.unique(equalIds());
- m_HitList.sort(orderInLayer());
-}
-
-#endif
-
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/HF_Constants.h b/Trigger/TrigTools/IDScanHitFilter/src/HF_Constants.h
deleted file mode 100755
index 6ef1ce70f187d759f2fb9eccc0c067525fe23afb..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/HF_Constants.h
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: HF_Constants.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-// Description: contains HitFilter constants
-//
-// date: 24/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if ! defined( IDSCAN_HFCONSTANTS_H )
-#define IDSCAN_HFCONSTANTS_H
-
-const long HashKeyCoeff = 1000;
-
-#endif
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/IDScanHitFilter.cxx b/Trigger/TrigTools/IDScanHitFilter/src/IDScanHitFilter.cxx
deleted file mode 100755
index 57304efd3e9aa4eb8c4e6b76b26dc4176eee8238..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/IDScanHitFilter.cxx
+++ /dev/null
@@ -1,219 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-// IDScanHitFilter
-// ( see header-file for details )
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-#include <iostream>
-
-#include "GaudiKernel/MsgStream.h"
-#include "CxxUtils/checker_macros.h"
-
-#include "TrigInDetEvent/TrigVertex.h"
-#include "TrigInDetEvent/TrigSiSpacePoint.h"
-#include "TrigInDetEvent/TrigInDetTrack.h"
-#include "TrigInDetEvent/TrigInDetTrackCollection.h"
-#include "IRegionSelector/IRoiDescriptor.h"
-
-#include "IDScanHitFilter.h"
-#include "IdScanSpPoint.h"
-#include "Group.h"
-
-
-IDScanHitFilter::IDScanHitFilter(const std::string& t,
- const std::string& n,
- const IInterface* p ):
- AthAlgTool(t,n,p),
- m_numberingTool("TrigL2LayerNumberTool")
-{
- declareInterface< ITrigHitFilter >( this );
-
- declareProperty( "PrintDiagnosticMessages", m_printDiagnosticMessages = false );
- declareProperty( "phiHalfWidth", m_ROIphiHalfWidth = 0.1 );
- declareProperty( "etaHalfWidth", m_ROIetaHalfWidth = 0.1 );
-
- declareProperty( "PhiBinSize", m_phiBinSize = 2.4 );
- declareProperty( "EtaBinSize", m_etaBinSize = 0.005 );
- declareProperty( "LayerThreshold", m_layerThreshold = 3.5 );
- declareProperty( "EnhanceLayer0", m_enhanceLayer0 = true );
- declareProperty( "RemoveDuplicates", m_cloneRemoval = true );
- declareProperty( "CloneRemovalCut", m_cloneRemovalCut = 3 );
- declareProperty( "UsePtSign", m_usePtSign = true );
-
- declareProperty( "LooseTightBoundary", m_looseTight = 20.5 );
-
- declareProperty( "deltadzdrCut_loose", m_loose_deltadzdrCut = 0.04 );
- declareProperty( "deltadzdrCut_tight", m_tight_deltadzdrCut = 0.01 );
- declareProperty( "etaCutInner_loose", m_loose_etaCutInner = 0.008 );
- declareProperty( "etaCutInner_tight", m_tight_etaCutInner = 0.004 );
- declareProperty( "etaCutOuter_loose", m_loose_etaCutOuter = 0.02 );
- declareProperty( "etaCutOuter_tight", m_tight_etaCutOuter = 0.01 );
- declareProperty( "d0Cut_loose", m_loose_d0Cut = 4.0 );
- declareProperty( "d0Cut_tight", m_tight_d0Cut = 1.0 );
- declareProperty( "dPhidRBinSize_loose", m_loose_dPhidRBinSize = 0.0000030 );
- declareProperty( "dPhidRBinSize_tight", m_tight_dPhidRBinSize = 0.0000024 );
- declareProperty( "pTcutInMeV", m_pTcutInMeV = 1000.0 );
- declareProperty( "phi0Bins_loose", m_loose_phi0Bins = 16000 );
- declareProperty( "phi0Bins_tight", m_tight_phi0Bins = 20000 );
-
- declareProperty( "maxBeamSpotShift", m_maxBeamSpotShift = 4.0 );
- declareProperty( "fullScan", m_fullScan = false );
-
-}
-
-StatusCode IDScanHitFilter::initialize()
-{
- m_dPhidRCut = 0.3/m_pTcutInMeV;
-
- ATH_MSG_INFO( "IDScanHitFilter constructed " );
- ATH_MSG_INFO( "phiBinSize set to " << m_phiBinSize );
- ATH_MSG_INFO( "etaBinSize set to " << m_etaBinSize );
- ATH_MSG_INFO( "layerThreshold set to " << m_layerThreshold );
- ATH_MSG_INFO( "enhanceZeroLayer set to " << m_enhanceLayer0 );
- ATH_MSG_INFO( "Clone removal set to " << m_cloneRemoval );
- ATH_MSG_INFO( "dphidrcut set to " << m_dPhidRCut );
-
- ATH_CHECK( m_numberingTool.retrieve() );
-
- /// get first endcap layer, so we know how
- /// barrel layers there are
- int offsetEndcapPixels = m_numberingTool->offsetEndcapPixels();
- int maxSiliconLayerNum = m_numberingTool->maxSiliconLayerNum();
- // int offsetBarrelSCT = m_numberingTool->offsetBarrelSCT();
-
- /// Set the layer variables for the FilterBin class
- /// NB: decrement the endcap pixels, as we want the layer number
- /// of the last barrel layer, not the number of the first
- /// endcap pixel layer
- /// initialise the HitFilter with the correct number of layers
- /// NB: DO NOT pass in the max eta here, but remember that it can be set here!!
- /// the parameter initialisation is very messy for this stuff
- iHitFilter::initialise( maxSiliconLayerNum, offsetEndcapPixels-1 ); /// , 3.0 );
-
- // NB: Now set the other way - ie, set m_fullScan=true,
- // then this will enforce m_ROIphiHalfWidth=M_PI, but in
- // iHitFilterinitialise() where it should have been in any
- // case
- //
- // m_fullScan = (2*m_ROIphiHalfWidth > 6.28);
-
- return StatusCode::SUCCESS;
-}
-
-
- //Luke: edit this to take recoTracks as an input pointer, passed by reference
-void IDScanHitFilter::findTracks( std::vector<const TrigSiSpacePoint* > spVec, TrigInDetTrackCollection& recoTracks,
- const IRoiDescriptor* RoI, double zVertex,
- double shiftx=0, double shifty=0,
- const int missing_layers=0 )
-{
- setLayerThresholdTmp(getLayerThreshold()-double(missing_layers));
- ATH_MSG_DEBUG( "m_layerThreshold=" << m_layerThreshold
- << "\tm_layerThresholdTmp=" << m_layerThresholdTmp );
-
- // 0. check if RoI is in [0,2pi] boundary (boundary for the space point definition!)
- // and calculate phi offset <- now done in spacepoints themselves!!!
-
- // 1. make internal IDScan SPs
- if (RoI!=nullptr) {
- makeIDScanSPs( spVec, RoI->eta(), 0.5*fabs(RoI->etaPlus()-RoI->etaMinus()),
- RoI->phi(), 0.5*fabs(RoI->phiPlus()-RoI->phiMinus()),
- zVertex );
- }
- else {
- makeIDScanSPs( spVec, 0, 3,
- 0, M_PI,
- zVertex );
- }
-
- ATH_MSG_DEBUG( "REGTEST / Made " << m_internalSPs->size()
- << " IdScanSpPoints. Proceeding to HitFilter." );
- if (m_printDiagnosticMessages) std::cout << "IdScanMain DIAGNOSTIC " << " Made " << m_internalSPs->size()
- << " IdScanSpPoints. Proceeding to HitFilter." << std::endl;
-
- // 2. run HitFilter & GroupCleaner
-
- GroupList cleanGroups = execute();
-
- // 3. turn groups into TrigInDetTracks
-
- //Luke: delete this line
- //TrigInDetTrackCollection* recoTracks=NULL;
- if ( !cleanGroups.empty() ) {
- makeTracks( cleanGroups, recoTracks, zVertex, shiftx, shifty);
- }
-
- cleanInternalSPs();
-
- //return recoTracks;
-}
-
-
-//Luke: need to pass recoTracks by reference to this or have it as a member variable or something?
-void IDScanHitFilter::makeTracks( GroupList& idScanGroups, TrigInDetTrackCollection& recoTracks, double zPosition,
- double shiftx=0, double shifty=0)
-{
- // recoTracks->reserve( idScanGroups.size() );
-
- // Since the FilterMap is a hashmap and hash tables are not guaranteed
- // to be sorted, running the code twice sometimes ends up producing
- // differently ordered REGTEST output files. So sort them is debugging:
-
- if ( msgLvl(MSG::DEBUG) ) idScanGroups.sort();
-
- for ( GroupList::iterator gItr( idScanGroups.begin() ) ; gItr != idScanGroups.end(); ++gItr ) {
- if(gItr->groupHits().size()==0) continue;
- gItr->groupHits().sort(orderInRho());
- double phi0 = gItr->getPhi0();
- if(phi0<-M_PI)
- {
- phi0+=2.0*M_PI;
- }
- else if(phi0>M_PI)
- {
- phi0-=2.0*M_PI;
- }
- ATH_MSG_DEBUG( "REGTEST / group phi0/ptInv/eta: "
- << phi0 << " / "
- << gItr->getPtInv() << " / "
- << gItr->getEta() );
-
- if (m_printDiagnosticMessages) std::cout << "IdScanMain DIAGNOSTIC " << " group phi0/ptInv/eta: "
- << phi0 << " / "
- << gItr->getPtInv() << " / "
- << gItr->getEta() << std::endl;
-
- double ptInv=gItr->getPtInv();
- if(fabs(ptInv)<1e-9) ptInv=1e-9;
-
- double input_d0 = 0;
- if (shiftx || shifty){
- input_d0 = -shiftx*sin(phi0)+shifty*cos(phi0);
- }
-
- TrigInDetTrackFitPar* perigee = new TrigInDetTrackFitPar( input_d0,
- phi0,
- zPosition,
- gItr->getEta(),
- 1.0/ptInv );
-
- std::vector<const TrigSiSpacePoint*> spacePointsOnTrack;
- for (IdScanSpPoint* sp : gItr->groupHits())
- {
- spacePointsOnTrack.push_back( sp->commonSP() );
- }
- std::vector<const TrigSiSpacePoint*>* spv = new std::vector<const TrigSiSpacePoint*>;
- spv->assign(spacePointsOnTrack.begin(),spacePointsOnTrack.end());
- TrigInDetTrack* newTrack = new TrigInDetTrack(spv, perigee, NULL, gItr->getChi2());
- newTrack->algorithmId(TrigInDetTrack::IDSCANID);
- recoTracks.push_back( newTrack );
- }
-
- //return recoTracks;
-
-}
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/IDScanHitFilter.h b/Trigger/TrigTools/IDScanHitFilter/src/IDScanHitFilter.h
deleted file mode 100644
index 0042993d2c815eccf93f76e836d7b96b9ba9beee..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/IDScanHitFilter.h
+++ /dev/null
@@ -1,76 +0,0 @@
-// emacs: this is -*- c++ -*-
-
-/*
- Copyright (C) 2002-2019 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: IDScanHitFilter.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-//
-// Description: - main pattern recognition algorithm of IdScan
-//
-// date: 28/07/2003
-//
-// migrated to an AlgTool 28/01/2007
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#ifndef IDSCANHITFILTER_IDSCANHITFILTER_H
-#define IDSCANHITFILTER_IDSCANHITFILTER_H
-
-#include <vector>
-#include <list>
-#include <string>
-
-#include "AthenaBaseComps/AthAlgTool.h"
-
-#include "iHitFilter.h"
-#include "TrigInDetEvent/TrigInDetTrackCollection.h"
-#include "TrigInDetToolInterfaces/ITrigHitFilter.h"
-
-#include "GaudiKernel/ToolHandle.h"
-#include "TrigInDetToolInterfaces/ITrigL2LayerNumberTool.h"
-
-class TrigSiSpacePoint;
-class IRoiDescriptor;
-class Group;
-class IdScanSpacePoint;
-
-////////////////////////////////////////////////////////////////////////////////
-//// IDScanHitFilter
-////////////////////////////////////////////////////////////////////////////////
-
-class IDScanHitFilter: public iHitFilter, public AthAlgTool, virtual public ITrigHitFilter
-{
- public:
-
- IDScanHitFilter( const std::string&, const std::string&, const IInterface* );
- virtual ~IDScanHitFilter(){ };
-
- virtual StatusCode initialize() override;
-
- virtual
- void findTracks( std::vector<const TrigSiSpacePoint* >,
- TrigInDetTrackCollection&,
- const IRoiDescriptor*, double zvertex,
- double shiftx, double shifty,
- const int missing_layers) override;
-
- private:
-
- void makeTracks( std::list<Group>&, TrigInDetTrackCollection&, double zvertex, double shiftx, double shifty);
-
- /// actually, need the TrigL2LayerNumberTool so we can configure with the
- /// correct number of layers when including the IBL etc
- ToolHandle<ITrigL2LayerNumberTool> m_numberingTool;
-
-};
-
-#endif
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/IdScanSpPoint.h b/Trigger/TrigTools/IDScanHitFilter/src/IdScanSpPoint.h
deleted file mode 100644
index d9912c2b17d5e32f0b5b963cc7eafd6dd51d1047..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/IdScanSpPoint.h
+++ /dev/null
@@ -1,45 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: IdScanSpPoint.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-//
-// Description: - Internal IdScan space point
-//
-// date: 24/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if ! defined( IDSCAN_IDSCANSPPOINT_H )
-#define IDSCAN_IDSCANSPPOINT_H
-
-#include <vector>
-#include <iostream>
-
-#include "tIdScanSpPoint.h"
-#include "TrigInDetEvent/TrigSiSpacePoint.h"
-
-
-typedef TrigSiSpacePoint ExternalSpacePoint;
-
-typedef tIdScanSpPoint<ExternalSpacePoint> IdScanSpPoint;
-
-
-typedef std::vector< IdScanSpPoint* > hitVec;
-typedef torderInRho<IdScanSpPoint> orderInRho;
-typedef torderInLayer<IdScanSpPoint> orderInLayer;
-typedef torderInIndex<IdScanSpPoint> orderInIndex;
-typedef tequalIds<IdScanSpPoint> equalIds;
-
-
-#endif
-
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/components/IDScanHitFilter_entries.cxx b/Trigger/TrigTools/IDScanHitFilter/src/components/IDScanHitFilter_entries.cxx
deleted file mode 100644
index 170355fa38f0bc80a8f6e8fe30844a72a4c94078..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/components/IDScanHitFilter_entries.cxx
+++ /dev/null
@@ -1,10 +0,0 @@
-////////////////////////////////////////////////////////////////////////////////
-// IDScanHitFilter
-// -------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-#include "../IDScanHitFilter.h"
-
-DECLARE_COMPONENT( IDScanHitFilter )
-
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/iHitFilter.cxx b/Trigger/TrigTools/IDScanHitFilter/src/iHitFilter.cxx
deleted file mode 100755
index 8812d32fc30732ea6106a8c72cefff4be574e4e3..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/iHitFilter.cxx
+++ /dev/null
@@ -1,1469 +0,0 @@
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-// iHitFilter
-// ( see header-file for details )
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-// IdScan stuff
-#include "GC_Constants.h"
-#include "IdScanSpPoint.h"
-#include "Group.h"
-#include "FilterBin.h"
-#include "iHitFilter.h"
-
-#include <iostream>
-#include <algorithm>
-
-#include <cmath>
-#include <cstring>
-
-//#define IDSCAN_DEBUG 1
-
-using std::log;
-using std::exp;
-using std::atan;
-using std::fabs;
-using std::cerr;
-using std::endl;
-using std::memset;
-
-int iHitFilter::initialise(long maxlayers, long maxBarrelLayer, double maxeta)
-{
-
- m_IdScan_MaxNumLayers = maxlayers;
- m_maxBarrelLayer = maxBarrelLayer;
- m_IdScan_MaxEta = maxeta;
-
- if ( m_fullScan ) m_useROIphiHalfWidth = M_PI;
- else m_useROIphiHalfWidth = m_ROIphiHalfWidth;
-
- //in some cases I got 360/3.6 = 99, so divide with something a bit less than m_phiBinSize
- m_maxPhiBins = long(360./(m_phiBinSize-1e-6));
-
- // avoid obliging the user to use phi bin size that is an integer multiple of 360.
- double tmp_phiBinSize = 360./double(m_maxPhiBins);
-
- m_invPhiBinSize = 180./(M_PI*tmp_phiBinSize);
- m_invEtaBinSize = 1./m_etaBinSize;
-
- m_binMap = new FilterMap;
-
- m_tight = new GCP_tight(m_tight_deltadzdrCut,
- m_tight_etaCutInner,
- m_tight_etaCutOuter,
- m_tight_d0Cut,
- m_tight_dPhidRBinSize,
- m_tight_phi0Bins,
- m_dPhidRCut
- );
-
-#ifdef IDSCAN_DEBUG
- std::cout << "tight params: ddzdr,etainner,etaouter,d0,dphidrbinsize,dpdrcut: " << m_tight_deltadzdrCut
- << " / " << m_tight_etaCutInner
- << " / " << m_tight_etaCutOuter
- << " / " << m_tight_d0Cut
- << " / " << m_tight_dPhidRBinSize
- << " / " << m_tight_phi0Bins
- << " / " << m_dPhidRCut << std::endl;
-#endif
-
-
- m_loose = new GCP_loose(m_loose_deltadzdrCut,
- m_loose_etaCutInner,
- m_loose_etaCutOuter,
- m_loose_d0Cut,
- m_loose_dPhidRBinSize,
- m_loose_phi0Bins,
- m_dPhidRCut
- );
-
-#ifdef IDSCAN_DEBUG
- std::cout << "loose params: ddzdr,etainner,etaouter,d0,dphidrbinsize,dpdrcut: " << m_loose_deltadzdrCut
- << " / " << m_loose_etaCutInner
- << " / " << m_loose_etaCutOuter
- << " / " << m_loose_d0Cut
- << " / " << m_loose_dPhidRBinSize
- << " / " << m_loose_phi0Bins
- << " / " << m_dPhidRCut << std::endl;
-#endif
-
- return 0;
-}
-
-iHitFilter::~iHitFilter()
- {
- if (m_binMap) delete m_binMap;
- if (m_loose) delete m_loose;
- if (m_tight) delete m_tight;
- }
-
-
-void iHitFilter::makeIDScanSPs( std::vector<const ExternalSpacePoint* > spVec,
- double meanEta, double deltaEta,
- double meanPhi, double deltaPhi,
- double zVertex)
-{
-
- int Counter=1;
-
- m_zVertex = zVertex;
-
- double roiPhiMin, roiPhiMax;
-
- if ( m_fullScan ) {
- meanPhi=0;
- meanEta=0;
- roiPhiMin=-M_PI;
- roiPhiMax= M_PI;
- }
- else {
-
- // If we trust that all the SPs are properly input, we determine the RoI phi width
- // using the SPs themselves.
- // If the RoI phi range is wider than pi, ie. if the RoI is large enough, we keep everything as usual.
- // if ( 2 * m_useROIphiHalfWidth < M_PI )
- if ( 2 * deltaPhi < M_PI )
- {
- double roiPhiPosMin( 9.9), roiPhiPosMax(0);
- double roiPhiNegMin(-9.9), roiPhiNegMax(0); // least negative and most negative
-
- std::vector<const ExternalSpacePoint* >::const_iterator SpItr( spVec.begin() );
- for(unsigned int i=0; i<spVec.size(); ++i, ++SpItr)
- {
- double spphi = (*SpItr)->phi();
- if ( spphi>0 && spphi>roiPhiPosMax ) roiPhiPosMax = spphi;
- if ( spphi>0 && spphi<roiPhiPosMin ) roiPhiPosMin = spphi;
-
- if ( spphi<0 && spphi<roiPhiNegMax ) roiPhiNegMax = spphi;
- if ( spphi<0 && spphi>roiPhiNegMin ) roiPhiNegMin = spphi;
- }
-
- // if all SPs are in (0, pi):
- if ( roiPhiNegMax > roiPhiNegMin ) { roiPhiMin = roiPhiPosMin; roiPhiMax = roiPhiPosMax; }
- // if all SPs are in (-pi, 0):
- else if ( roiPhiPosMax < roiPhiPosMin ) { roiPhiMin = roiPhiNegMax; roiPhiMax = roiPhiNegMin; }
- // if we have an RoI that covers phi=0 axis
- else if ( roiPhiPosMin - roiPhiNegMin < M_PI ) { roiPhiMin = roiPhiNegMax; roiPhiMax = roiPhiPosMax; }
- // if we have an RoI that covers phi=pi axis
- else { roiPhiMin = roiPhiPosMin; roiPhiMax = roiPhiNegMin; }
-
- roiPhiMin -= 1e-10;
- roiPhiMax += 1e-10;
- //double ROIphiWidth = roiPhiMax - roiPhiMin;
- //if ( ROIphiWidth < 0 ) ROIphiWidth += 2*M_PI;
- //m_useROIphiHalfWidth = ROIphiWidth / 2.;
- }
- else
- {
- // roiPhiMin = meanPhi - m_useROIphiHalfWidth;
- // roiPhiMax = meanPhi + m_useROIphiHalfWidth;
- roiPhiMin = meanPhi - deltaPhi;
- roiPhiMax = meanPhi + deltaPhi;
- }
-
- if ( roiPhiMin < -M_PI ) roiPhiMin += 2.0*M_PI;
- if ( roiPhiMax > M_PI ) roiPhiMax -= 2.0*M_PI;
-
- // std::cout << "TrigIDSCAN IDScanHitFilter roiPhiMin " << roiPhiMin << std::endl;
- // std::cout << "TrigIDSCAN IDScanHitFilter roiPhiMax " << roiPhiMax << std::endl;
-
- }
-
- bool boundary = (roiPhiMin>roiPhiMax);
-
- if ( m_internalSPs!=NULL ) cleanInternalSPs();
- m_internalSPs = new hitVec;
- m_internalSPs->reserve( spVec.size() );
-
- // Now that we know the z of the pp vertex, we can move from a trapezium shape RoI
- // to a triangle shape and get rid of some extra hits that are of no interest
- //
-
-
- // std::cout << "TrigIDSCAN IDScanHitFilter m_ROIetaHalfWidth " << m_ROIetaHalfWidth << std::endl;
- // std::cout << "TrigIDSCAN IDScanHitFilter roi->etaHalfWidth " << deltaEta << std::endl;
-
- // NB: should set a default full scan range when m_fullScan==true but it is
- // etaHalfWidth=3 for the fullscan slice and etaHalfWidth=5 for the cosmic,
- // so which to chose? left as it is for the moment
- // double dEta = m_ROIetaHalfWidth;
- double dEta = deltaEta;
-
- // The 'core' resolution from muFast is ~0.015
- dEta += 0.045;
-
- // SP etas can change significantly when shifted to account for an offset beamspot.
- // Offset BS affects most the hits on the B-layer ==> 50mm.
- dEta += ( std::fabs(meanEta) +
- log(tan(atan(50./((50-m_maxBeamSpotShift)/tan(2.*atan(exp(-std::fabs(meanEta))))))/2.)) );
-
- // An extra eta range to account for the fact that the RoI eta is computed with for z=0
- // Assume that the eta of the RoI is computed at the radius of the calorimeter and compute
- // the eta of an RoI which is said to be at eta=0.
- double extraEta(0);
- if ( zVertex!=0 ) extraEta -= log(tan(atan(2800./std::fabs(zVertex))/2));
-
- // std::cout << "TrigIDSCAN IDScanHitFilter dEta " << dEta << std::endl;
- // std::cout << "TrigIDSCAN IDScanHitFilter extraEta " << extraEta << std::endl;
-
- std::vector<const ExternalSpacePoint* >::const_iterator siSpItr( spVec.begin() );
- for ( ; siSpItr!=spVec.end(); ++siSpItr ) {
- double eta = (*siSpItr)->eta(zVertex);
-
- if ( std::fabs(eta)>m_IdScan_MaxEta ) continue;
- if ( zVertex<=0 && ( eta-meanEta>dEta+extraEta || meanEta-eta>dEta ) ) continue;
- if ( zVertex> 0 && ( meanEta-eta>dEta+extraEta || eta-meanEta>dEta ) ) continue;
-
- IdScanSpPoint* pSP=new IdScanSpPoint( *siSpItr, eta );
- pSP->index(Counter++);
- m_internalSPs->push_back( pSP );
- }
-
- long nSPs = m_internalSPs->size();
- std::vector<double> rotatedPhi(nSPs);
-
- hitVec::iterator SpItr = m_internalSPs->begin();
- for ( long i=0; i<nSPs; ++i, ++SpItr ) {
- rotatedPhi[i] = (*SpItr)->phi() - roiPhiMin;
- }
-
- if ( boundary ){
- for ( long i=0; i<nSPs; ++i ) {
- if(rotatedPhi[i]<0.0) rotatedPhi[i]+=2.0*M_PI;
- }
- }
-
- SpItr = m_internalSPs->begin();
- for ( long i=0; i<nSPs; ++i, ++SpItr ) {
- (*SpItr)->setRotatedPhi( rotatedPhi[i] );
- }
-
-}
-
-
-void iHitFilter::cleanInternalSPs() {
- for ( hitVec::iterator spItr( m_internalSPs->begin() ); spItr != m_internalSPs->end(); ++spItr ) {
- delete (*spItr);
- }
- m_internalSPs->clear();
- delete m_internalSPs;
- m_internalSPs = NULL;
-}
-
-
-GroupList iHitFilter::execute()
-{
-
- if ( m_internalSPs==NULL ) {
- cerr << "iHitFilter::execute() m_internalSPs=NULL" << endl;
- }
-
- m_HF = true; // we are in hitFilter; becomes false when we go to groupCleaner
-
-// 1. Loop over the hits to make bins and fill the binMap
-//
- long sp_key;
- hitVec::iterator hitItr( m_internalSPs->begin() );
- hitVec::iterator hitEnd( m_internalSPs->end() );
-
- for ( ; hitItr != hitEnd; ++hitItr ) {
- sp_key = makeHashKey( (*hitItr)->rotatedPhi(), (*hitItr)->eta() );
- (*m_binMap)[sp_key].AddHit( *hitItr, m_IdScan_MaxNumLayers, m_maxBarrelLayer );
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG hitfilter: layer/phi/z/eta/sp_key: "
- << (*hitItr)->layer() << " / " << (*hitItr)->phi() << " / " << (*hitItr)->z() << " / " << sp_key << std::endl;
-#endif
- }
-
-// Special treatment for hits at pixel layer 0. Optionally enter them two more times
-// in the binMap, at +/- 2 bins in eta, as their eta is affected most by mis-measurements
-// in the ZFinder. Important mostly for low p_T tracks (B physics, b-tagging).
-//
-
- if ( m_enhanceLayer0 ) {
- long offset = 2*HashKeyCoeff;
- for ( hitItr = m_internalSPs->begin(); hitItr != hitEnd; ++hitItr ) {
- if ( (*hitItr)->layer() == 0 ) {
- sp_key = this->makeHashKey( (*hitItr)->rotatedPhi(), (*hitItr)->eta() );
- (*m_binMap)[sp_key+offset].AddHit( *hitItr, m_IdScan_MaxNumLayers, m_maxBarrelLayer );
- (*m_binMap)[sp_key-offset].AddHit( *hitItr, m_IdScan_MaxNumLayers, m_maxBarrelLayer );
- }
- }
- }
-
-// 2. Loop over bins to form groups
-//
- GroupList gList, cleanGroups;
- this->clusterBins( gList );
- m_HF = false;
-
-// 3. Loop over groups to delete "small" groups and run second level filter (group cleaner)
-//
- GroupList::iterator gItr( gList.begin() ), gEnd( gList.end() );
- while( gItr != gEnd ) {
- if ( m_enhanceLayer0 ) { // if 0 layer hits entered 3 times, remove duplicates first
- gItr->removeDuplicates();
- }
- if ( gItr->NumberOfHits()>m_layerThresholdTmp ) {
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: " << std::endl;
- std::cout << "IDSCAN_DEBUG: Group entering the groupCleaner - number of sps: "
- << gItr->NumberOfHits() << std::endl;
- std::list<IdScanSpPoint *> hitList = gItr->groupHits();
- for ( std::list<IdScanSpPoint *>::const_iterator i = hitList.begin(); i != hitList.end(); ++i ) {
- std::cout << "IDSCAN_DEBUG: layer = " << (*i)->layer()
- << " phi= " << (*i)->phi()
- << " rho= " << (*i)->rho()
- << " zed= " << (*i)->z()
- << std::endl;
- }
-#endif
-
- this->groupCleaner( gItr, cleanGroups );
- gList.erase( gItr++ );
- }
- else {
- gList.erase( gItr++ );
- }
- }
-
-// 4. Loop over cleaned groups to delete "small" groups
-//
- GroupList::iterator gItr2( cleanGroups.begin() ), gEnd2( cleanGroups.end() );
- for ( ; gItr2 != gEnd2; ) {
- if(gItr2->NumberOfHits()!=0)
- {
- if ( gItr2->NumberOfHits() > m_layerThresholdTmp ) {
- ++gItr2;
- }
- else {
- cleanGroups.erase(gItr2++);
- }
- }
- else cleanGroups.erase(gItr2++);
- }
-
- return cleanGroups;
-}
-
-void iHitFilter::groupCleaner( GroupList::iterator& inputItr, GroupList& cleanGroups )
-{
-
- groupCleanerParams* params;
- if( inputItr->NumberOfHits() > m_looseTight ) {
- params = m_tight;
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: tight set of grouCleaner parameters" << std::endl;
-#endif
-
- }
- else {
- params = m_loose;
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: loose set of grouCleaner parameters" << std::endl;
-#endif
-
- }
-
-
- // deal with phi wrap-around when in full scan mode
- if ( m_fullScan) {
- double posPhi = 0;
- double negPhi = 0;
- std::list<IdScanSpPoint *> hitList = inputItr->groupHits();
- for ( std::list<IdScanSpPoint *>::const_iterator i = hitList.begin();
- i != hitList.end(); ++i ) {
- if ((*i)->phi()<-3.0) negPhi++;
- if ((*i)->phi()> 3.0) posPhi++;
- }
-
- if (negPhi>0 && posPhi>0) { // this group is in the phi wrap-around
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: had to deal with phi wrap-around: " << posPhi<< "/" << negPhi << std::endl;
-#endif
-
- for ( std::list<IdScanSpPoint *>::const_iterator i = hitList.begin();
- i != hitList.end(); ++i ) {
- if ((*i)->phi()<0) ((*i)->setRotatedPhi(((*i)->rotatedPhi()+2.0*M_PI)));
- }
- }
- }
-
- this->fillMapGC1( inputItr, params );
- // this->fillMapGC2(inputItr, params );
-
-// Same clustering algo as before: Loop over bins to form groups
-//
- unsigned long groupsBefore = cleanGroups.size();
- this->clusterBins( cleanGroups );
- unsigned long newGroups = cleanGroups.size()-groupsBefore;
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: grouCleaner found " << newGroups << " groups in the original group." << std::endl;
-#endif
-
- if (newGroups!=0)
- {
- double eta = (inputItr->bin1()+0.5)/m_invEtaBinSize-m_IdScan_MaxEta;
- GroupList::reverse_iterator gItr2=cleanGroups.rbegin();
- for ( unsigned long i=0; i<newGroups;++i,++gItr2)
- {
- double dfdrho = ((gItr2->bin2()+0.5)/params->invdPhidRBinSize)-params->dPhidRCut;
- double ptinv = -dfdrho/params->dPhidRCut/1000.;
- double phi0 = (gItr2->bin1()+0.5)/params->invPhi0BinSize - dfdrho*params->phi0Offset;
- gItr2->setPhi0( phi0 );
- gItr2->setPtInv( ptinv );
- gItr2->setEta( eta );
- gItr2->setz0( m_zVertex );
- gItr2->removeDuplicates();
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: New grouCleaner group with number of hits = " << gItr2->NumberOfHits()
- << " 1/pT= " << ptinv
- << " phi0= " << phi0
- << " eta= " << eta
- << " z0= " << m_zVertex
- << std::endl;
-#endif
-
- for (IdScanSpPoint* pSP : gItr2->groupHits()) {
- pSP->setUsed(1);
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: new group - layer = " << pSP->layer()
- << " phi= " << pSP->phi()
- << " rho= " << pSP->rho()
- << " zed= " << pSP->z()
- << std::endl;
-#endif
- }
-
- int badHit=0;
- //setting used=0 to spacepoints in the same layer
- for(std::list<IdScanSpPoint *>::iterator phIt1=(*gItr2).groupHits().begin();
- phIt1!=(*gItr2).groupHits().end();++phIt1)
- {
- //if((*phIt1)->used()==0) continue;
- int lay1=(*phIt1)->layer();
- int type1=((*phIt1)->dz()<(*phIt1)->dr())?1:0;
- std::list<IdScanSpPoint *>::iterator phIt2=phIt1;
- ++phIt2;
- for(;phIt2!=(*gItr2).groupHits().end();++phIt2)
- {
- //if((*phIt2)->used()==0) continue;
- int lay2=(*phIt2)->layer();
- int type2=((*phIt2)->dz()<(*phIt2)->dr())?1:0;
- if((lay2==lay1)&&(type2==type1))
- {
- if(((type1==0)&&(std::fabs((*phIt2)->rho()-(*phIt1)->rho())<5.0))
- ||((type1==1)&&(std::fabs((*phIt2)->z()-(*phIt1)->z())<2.0)))
- {
- if((*phIt2)->used()!=0)
- {
- badHit++;
- (*phIt2)->setUsed(0);
- }
- if((*phIt1)->used()!=0)
- {
- badHit++;
- (*phIt1)->setUsed(0);
- }
- }
- }
- }
- }
- //printf("%d duplicated hits detected...\n",badHit);
- fitGroup((*gItr2));
- //fitGroupWithoutHitRemoval((*gItr2));
-
- //deleting spacepoints that have used==0
- if(badHit!=0)
- {
- std::list<IdScanSpPoint *>::iterator hitItr=(*gItr2).groupHits().begin();
- while(hitItr!=(*gItr2).groupHits().end())
- {
- IdScanSpPoint* pSP=(*hitItr);
- if(pSP->used()==0)
- {
- (*gItr2).groupHits().erase(hitItr++);pSP->setUsed(1);
- }
- else
- {
- ++hitItr;pSP->setUsed(1);
- }
- }
- }
-
- if (badHit!=0)
- {
- gItr2->setChi2(1e9);
- }
- else
- {
- gItr2->setChi2(0);
- }
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: after ambig. resol. - number of hits = " << (*gItr2).NumberOfHits() << std::endl;
- for( hitItr=(*gItr2).groupHits().begin(); hitItr!=(*gItr2).groupHits().end(); hitItr++) {
- IdScanSpPoint* pSP=(*hitItr);
- std::cout << "IDSCAN_DEBUG: after ambig. resol. - layer = " << pSP->layer()
- << " phi= " << pSP->phi()
- << " rho= " << pSP->rho()
- << " zed= " << pSP->z()
- << std::endl;
- }
-#endif
- }
-
-
- if((newGroups>1)&&m_cloneRemoval)
- {
- TrackFilterClass* pTF = new TrackFilterClass(m_usePtSign);
- gItr2=cleanGroups.rbegin();
- for ( unsigned long i=0; i<newGroups;++i,++gItr2)
- {
- pTF->addNewTrackCandidate(&(*gItr2));
- }
- pTF->removeClones(m_cloneRemovalCut);
- delete pTF;
- }
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: after clone removal remaining groups = " << cleanGroups.size()-groupsBefore << std::endl;
-
- gItr2=cleanGroups.rbegin();
- for ( unsigned long i=0; i<cleanGroups.size()-groupsBefore; ++i,++gItr2) {
- std::cout << "IDSCAN_DEBUG: Final group after clone rem. with number of hits = " << gItr2->NumberOfHits()
- << " 1/pT= " << gItr2->getPtInv()
- << " phi0= " << gItr2->getPhi0()
- << " eta= " << gItr2->getEta()
- << " z0= " << gItr2->getz0()
- << std::endl;
- }
-
-#endif
-
- }
-}
-
-
-void iHitFilter::fillMapGC1( GroupList::iterator& inputItr, groupCleanerParams* params ) const
-{
-// Make hit triplets from different layer and if they satisfy certain cuts
-// fill the 2D histogram/map in (phi0,dPhidRho).
-// This is the fancy way of making triplets. It is faster than fillMapGC1 for nHits > ~20
-//
- std::vector<long> used(m_IdScan_MaxNumLayers,0);
- std::vector<std::list<IdScanSpPoint*> > ll(m_IdScan_MaxNumLayers);
- std::list<IdScanSpPoint*> hitList = inputItr->groupHits();
- for ( std::list<IdScanSpPoint*>::const_iterator i = hitList.begin();
- i != hitList.end(); ++i ) {
- long lr = (*i)->layer();
- ll[lr].push_back(*i);
- used[lr]=1;
- }
- std::vector<long> filled(m_IdScan_MaxNumLayers);
- long nf = 0;
- for ( long i = 0; i < m_IdScan_MaxNumLayers; ++i ) {
- if ( used[i] ) {
- filled[nf++] = i;
- }
- }
-
- double rr1,fr1, dzdr21, k21, ddzdr;
- long sp_key;
- double r[3],z[3],f[3],e[3];
- for ( long i = 0; i < nf-2; ++i ) {
- for ( std::list<IdScanSpPoint *>::const_iterator iit = ll[filled[i]].begin();
- iit != ll[filled[i]].end(); ++iit ) {
-
-#ifdef IDSCAN_DEBUG
- std::cout << "layer1: " << filled[i] << std::endl;
-#endif
-
- f[0] = (*iit)->rotatedPhi();
- r[0] = (*iit)->rho();
- z[0] = (*iit)->z();
- e[0] = (*iit)->eta();
- rr1 = r[0]*r[0];
- fr1 = r[0]*f[0];
- for ( long j = i+1; j < nf-1; ++j ) {
- for ( std::list<IdScanSpPoint *>::const_iterator jit = ll[filled[j]].begin();
- jit != ll[filled[j]].end(); ++jit ) {
-
-#ifdef IDSCAN_DEBUG
- std::cout << "layer1/2: " << filled[i] << "/" << filled[j] << std::endl;
-#endif
-
- e[1] = (*jit)->eta();
-
-#ifdef IDSCAN_DEBUG
- std::cout << " d_etacutInner/21: " << 1000*(params->etaCutInner) << " / " << 1000*(e[1]-e[0]) << std::endl;
-#endif
-
- if ( std::fabs(e[1]-e[0]) > params->etaCutInner ) continue;
- f[1] = (*jit)->rotatedPhi();
- r[1] = (*jit)->rho();
- z[1] = (*jit)->z();
- dzdr21 = dzdr( r, z );
- k21 = ktemp( r, f );
- for ( long k = j+1; k < nf; ++k ) {
- for ( std::list<IdScanSpPoint *>::const_iterator kit = ll[filled[k]].begin();
- kit != ll[filled[k]].end(); ++kit ) {
-
-#ifdef IDSCAN_DEBUG
- std::cout << "layer1/2/3: " << filled[i] << "/" << filled[j] << "/" << filled[k] << std::endl;
-#endif
-
- e[2] = (*kit)->eta();
-
-#ifdef IDSCAN_DEBUG
- std::cout << " d_etacutOuter/321: " << 1000*(params->etaCutOuter) << " / " << 1000*(e[2]-e[1]) << std::endl;
-#endif
-
- if ( std::fabs(e[2]-e[1]) > params->etaCutOuter ) continue;
- r[2] = (*kit)->rho();
- z[2] = (*kit)->z();
- ddzdr = dzdr21-dzdr( &r[1], &z[1] );
-
-#ifdef IDSCAN_DEBUG
- std::cout << " 1000ddzdr, 1000deltadZdRCut " << 1000*params->deltadZdRCut << 1000*ddzdr << " / " << std::endl;
-#endif
-
- if ( std::fabs(ddzdr) > params->deltadZdRCut ) continue;
- f[2] = (*kit)->rotatedPhi();
- sp_key = this->makeHashKey( r, f, k21, rr1, fr1, params );
- if ( sp_key ) {
- (*m_binMap)[sp_key].AddTriplet( *iit, *jit, *kit );
-
-#ifdef IDSCAN_DEBUG
- std::cout << " Made sp_key: " << sp_key << std::endl;
-#endif
-
- }
- }
- }
- }
- }
- }
- }
-
- for (long i = 0; i < nf; ++i ) {
- ll[filled[i]].clear();
- }
-
-}
-
-
-void iHitFilter::fillMapGC2(GroupList::iterator& inputItr, groupCleanerParams* params ) const
-{
-// Make hit triplets from different layer and if they satisfy certain cuts
-// fill the 2D histogram/map in (phi0,dPhidRho).
-// This is the brute force way of making triplets, which is the fastest for nHits < ~20
-//
- long nHits = inputItr->NumberOfHits();
- std::list<IdScanSpPoint *> hitList = inputItr->groupHits();
-
-
- std::list<IdScanSpPoint *>::const_iterator Itr0( hitList.begin() );
- std::list<IdScanSpPoint *>::const_iterator Itr1, Itr2;
-
- long sp_key, l[3];
- double rr1, fr1, dzdr21, k21, ddzdr;
- double r[3],z[3],f[3],e[3];
-
- for ( long i=0; i<nHits-2; ++i, ++Itr0 ) {
- f[0] = (*Itr0)->rotatedPhi();
- r[0] = (*Itr0)->rho();
- z[0] = (*Itr0)->z();
- e[0] = (*Itr0)->eta();
- l[0] = (*Itr0)->layer();
- rr1 = r[0]*r[0];
- fr1 = r[0]*f[0];
-
- Itr1 = Itr0; ++Itr1;
- for ( long j=i+1; j<nHits-1; ++j, ++Itr1 ) {
- l[1] = (*Itr1)->layer();
- if ( l[1]==l[0] ) continue;
-
- e[1] = (*Itr1)->eta();
- if ( std::fabs(e[1]-e[0])>params->etaCutInner ) continue;
-
- f[1] = (*Itr1)->rotatedPhi();
- r[1] = (*Itr1)->rho();
- z[1] = (*Itr1)->z();
- dzdr21 = dzdr( r, z );
- k21 = ktemp( r, f );
-
- Itr2 = Itr1; ++Itr2;
- for ( long k=j+1; k<nHits; ++k, ++Itr2 ) {
- l[2] = (*Itr2)->layer();
- if ( l[2]==l[1] ) continue;
-
- e[2] = (*Itr2)->eta();
- if ( std::fabs(e[2]-e[1]) > params->etaCutOuter ) continue;
-
- r[2] = (*Itr2)->rho();
- z[2] = (*Itr2)->z();
- ddzdr = dzdr21-dzdr( &r[1], &z[1] );
- if ( std::fabs(ddzdr) > params->deltadZdRCut ) continue;
-
- f[2] = (*Itr2)->rotatedPhi();
- sp_key = this->makeHashKey( r, f, k21, rr1, fr1, params );
-
- if (sp_key) {
- (*m_binMap)[sp_key].AddTriplet( *Itr0, *Itr1, *Itr2 );
- }
- }
- }
- }
-
-}
-
-
-void iHitFilter::clusterBins( GroupList& gList )
-{
-// Loop over all the bins in the map and cluster them into groups. As soon as
-// bins are processed they get deleted with the fancy m_binMap->erase( binItr++ )
-// so at the end of this loop m_binMap is empty and there is no need to .clear()!
-//
- FilterMap::iterator binItr( m_binMap->begin() ), mapEnd( m_binMap->end() );
- for ( ; binItr != mapEnd; m_binMap->erase( binItr++ ) ) {
- if ( (binItr->second).NumberOfHits() > 0 ) {
- m_binCounter = 0;
- this->joinGroup( binItr->first, binItr->second, gList.end(), gList );
- // int binCounter = 0;
- // this->joinGroup( binItr->first, binItr->second, gList.end(), gList, bincounter);
- }
- }
-}
-
-
-void iHitFilter::joinGroup( long key, FilterBin& bin,
- GroupList::iterator giter, GroupList& glist )
-{
-// 1. Find the 8 neighbouring bins and exchange layer numbers
-//
- long np[8], Nneigh( 0 );
- this->neighborKeys(key, np );
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: in join groups - bincounter/key = " << m_binCounter << " / " << key << std::endl;
-#endif
-
- FilterMap::iterator miter, mneigh[8], mEnd( m_binMap->end() );
- for( long i = 0; i < 8; ++i ) {
-
-#ifdef IDSCAN_DEBUG
- std::cout << "IDSCAN_DEBUG: neighbour = " << i << " / " << np[i] << std::endl;
-#endif
-
- if ( ( miter=m_binMap->find(np[i]) ) != mEnd ){
- mneigh[Nneigh++] = miter;
- bin.exchangeBits( miter->second );
- }
- }
-
-// 2. Knowing the total number of layers in this bin, decide whether to proceed in
-// forming/joining a group; if not, get out of here!
-//
- if ( bin.NumberOfLayers() > m_layerThresholdTmp ) {
-
-// if the GroupList iterator giter is in the end, it means that this bin should start
-// the formation of a new group; if not, it means that it should join the group pointed
-// to by giter
-//
- if (giter == glist.end()){
- glist.push_back( Group() );
- giter-- = glist.end();
- }
- long bin1 = key/HashKeyCoeff;
- long bin2 = key%HashKeyCoeff;
- giter->AddHits( bin.hitList(), bin1, bin2 ); // pass all hits from the bin to the group...
-
-// Now all the neighbours should follow the same procedure...
-//
- for(long i=0; i<Nneigh; ++i){
- if ( (mneigh[i]->second).NumberOfHits() > 0 && m_binCounter<25){
- m_binCounter++;
- this->joinGroup( mneigh[i]->first, mneigh[i]->second, giter, glist );
- }
- }
- }
-
-}
-
-
-long iHitFilter::makeHashKey( double* r, double* f,
- double k21, double rr1,
- double fr1, groupCleanerParams* params ) const
-{
-// Makes the hash key for the (phi0,dPhidRho) map of the group cleaner.
-// Unlike before, here we calculate d0 and dPhidRho and make cuts on them,
-// so hash key = 0 means "ignore this hit-triplet".
-//
- double k32 = ktemp(&r[1],&f[1]);
-
- double dfdr = (k32-k21)/(r[2]-r[0]);
-
-#ifdef IDSCAN_DEBUG
- std::cout << "makeHashKey 1: 1000*dfdrcut(<)dfdr " << 1000*(params->dPhidRCut) << " / " << 1000*dfdr << std::endl;
-#endif
-
- if ( std::fabs(dfdr)>params->dPhidRCut ) return 0;
-
- double f0 = k21 - dfdr*(r[0]+r[1]);
-
- double d0 = fr1-dfdr*rr1-f0*r[0];
-
-#ifdef IDSCAN_DEBUG
- std::cout << "makeHashKey 2: 1000*d0cut/d0 " << 1000*(params->d0Cut) << " / " << 1000*d0 << std::endl;
-#endif
-
- if ( std::fabs(d0)>params->d0Cut ) return 0;
-
- f0 += dfdr*params->phi0Offset;
-
- long dfdrbin = (long) ( ( dfdr + params->dPhidRCut ) * params->invdPhidRBinSize );
- long f0bin = (long) ( f0*params->invPhi0BinSize );
-
-#ifdef IDSCAN_DEBUG
- std::cout << "f0bin/dfdrbin: " << f0bin << " / " << dfdrbin << std::endl;
-#endif
-
- return HashKeyCoeff*f0bin + dfdrbin;
-}
-
-
-TrackCandidateClass::TrackCandidateClass(Group* grp)
-{
- m_pGroup=grp;
- m_nHitShift=0;
- m_nSharedHits=0;
- m_nSharedTotal=0;
- m_fom=1.0*grp->groupHits().size();
-}
-
-TrackFilterClass::TrackFilterClass(bool usePtSign)
-{
- m_vpTCC.clear();
- m_usePtSign=usePtSign;
-}
-
-TrackFilterClass::~TrackFilterClass()
-{
- for(std::vector<TrackCandidateClass*>::iterator pTCCIt=m_vpTCC.begin();
- pTCCIt!=m_vpTCC.end();++pTCCIt)
- {
- delete (*pTCCIt);
- }
- m_vpTCC.clear();
-}
-
-void TrackFilterClass::addNewTrackCandidate(Group* pGrp)
-{
- TrackCandidateClass* pTCC;
- pTCC=new TrackCandidateClass(pGrp);
- pTCC->m_pt=1.0/pGrp->getPtInv();
- m_vpTCC.push_back(pTCC);
-}
-
-bool compareTrackCandidates(const TrackCandidateClass* pTCC1, const TrackCandidateClass* pTCC2)
-{
- if ( pTCC1->m_fom == pTCC2->m_fom ) return (std::fabs(pTCC1->m_pt) > std::fabs(pTCC2->m_pt) );
- return (pTCC1->m_fom > pTCC2->m_fom );
-}
-
-void TrackFilterClass::removeClones(int cut)
-{
- int nTrackCounter=1;
- int nSign,nBinNum;
- char nContribHisto[1000];
-
- std::sort(m_vpTCC.begin(),m_vpTCC.end(),compareTrackCandidates);
- for(std::vector<TrackCandidateClass*>::iterator pTCCIt=m_vpTCC.begin();
- pTCCIt!=m_vpTCC.end();++pTCCIt)
- {
- nTrackCounter++;
- nSign=((*pTCCIt)->m_pt<0)?-1:1;
- (*pTCCIt)->m_nHitShift=nTrackCounter*nSign;
- memset(nContribHisto,0,sizeof(nContribHisto));
-
- for (IdScanSpPoint* pSP : (*pTCCIt)->m_pGroup->groupHits())
- {
- if(pSP->used()==0) continue;
- if(pSP->used()==1)
- pSP->setUsed((*pTCCIt)->m_nHitShift);
- else
- {
- if((((pSP->used()*nSign)>0)&&(m_usePtSign))||(!m_usePtSign))
- {
- nBinNum=abs(pSP->used())-1;
- if(nBinNum<1000)
- {
- nContribHisto[nBinNum]++;
- if(nContribHisto[nBinNum]>(*pTCCIt)->m_nSharedHits)
- (*pTCCIt)->m_nSharedHits++;
- }
- }
- (*pTCCIt)->m_nSharedTotal++;
- }
- }
- }
- for(std::vector<TrackCandidateClass*>::iterator pTCCIt=m_vpTCC.begin();
- pTCCIt!=m_vpTCC.end();++pTCCIt)
- {
- if( (*pTCCIt)->m_nSharedHits>=cut || (*pTCCIt)->m_nSharedTotal > 0.45*(*pTCCIt)->m_pGroup->NumberOfHits() )
- (*pTCCIt)->m_pGroup->groupHits().clear();
- }
-}
-
-typedef std::vector<IdScanSpPoint*> HIT_VECTOR;
-
-bool CompareSpByLayer(const IdScanSpPoint* point1, const IdScanSpPoint* point2)
-{
- return (point1->layer() < point2->layer());
-}
-
-void iHitFilter::fitGroup(Group& G)
-{
- const double C=0.029997;
- const double maxChi2=500.0;
- const double maxChi2inGroup=6000.0;
- const double minPt=600.0;
-
- double Rk[5],Gk[5][5],Hk[2][5],Kk[5][2],resid[2],
- Bk[5][2],Vk[2][2],sigma[2][2],Dk[2][2];
- double chi2,dchi2,Bz,fConst,x,y,detr,bestChi2,averagePhi0=0.0,theta;
- int i,j,m,nAmbiLayers=0,nHits=0;
-
- HIT_VECTOR arrAmbiLayers[20];
- HIT_VECTOR spVec;
- int arrAmbiIdx[20];
-
- IdScanSpPoint* pBestSP;
- spVec.clear();
-
- theta=2.0*atan(exp(-G.getEta()));
-
- Rk[0]=0.0;
- // Rk[1]=0.0;
- Rk[1]=G.getz0();
- Rk[2]=0.0;
- Rk[3]=cos(theta)/sin(theta);
- Rk[4]=G.getPtInv();
-
- memset(&Gk[0][0],0,sizeof(Gk));
- Gk[0][0]=100.0;
- Gk[1][1]=100.0;
- Gk[2][2]=100.0;
- Gk[3][3]=100.0;
- Gk[4][4]=0.01;
- memset(&arrAmbiIdx[0],0,sizeof(arrAmbiIdx));
-
- chi2=0.0;Bz=20.84;fConst=C*Bz;
-
- double minPhi=(*G.groupHits().begin())->phi();
-
- for (IdScanSpPoint* pSP : G.groupHits())
- {
- if(minPhi>pSP->phi()) minPhi=pSP->phi();
- spVec.push_back(pSP);
- }
- std::sort(spVec.begin(),spVec.end(),CompareSpByLayer);
-
- for (IdScanSpPoint* pSP : spVec)
- {
- nHits++;
- double delta=pSP->phi()-minPhi;
- if(std::fabs(delta)>M_PI) delta-=2.0*M_PI;
- averagePhi0+=delta;
- }
- averagePhi0/=nHits;averagePhi0+=minPhi;
-
-#ifdef IDSCAN_DEBUG
- printf("Average PHI0=%f Initial Pt=%f\n",averagePhi0,1.0/G.getPtInv());
-#endif
-
- for(std::vector<IdScanSpPoint *>::reverse_iterator hitItr=spVec.rbegin();hitItr!=spVec.rend();++hitItr)
- {
- IdScanSpPoint* pSP=(*hitItr);
- if(pSP->used()!=0)
- {
- x=pSP->rho()*cos(pSP->phi()-averagePhi0);
- y=pSP->rho()*sin(pSP->phi()-averagePhi0);
-#ifdef IDSCAN_DEBUG
- printf("x=%f y=%f z=%f\n",x,y,pSP->z());
-#endif
- Hk[0][0]=1.0;Hk[0][1]=0.0;Hk[0][2]=x;
- Hk[0][3]=0.0;Hk[0][4]=-0.5*x*x*fConst;
- Hk[1][0]=0.0;Hk[1][1]=1.0;
- Hk[1][2]=0.0;Hk[1][3]=x;Hk[1][4]=0.0;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Bk[i][j]=0.0;for(m=0;m<5;m++) Bk[i][j]+=Gk[i][m]*Hk[j][m];
- }
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- {
- Vk[i][j]=0.0;for(m=0;m<5;m++) Vk[i][j]+=Hk[i][m]*Bk[m][j];
- }
-
- if(pSP->layer()<7)
- {
- sigma[0][0]=x*pSP->dphi();
- sigma[1][1]=pSP->dz();
- for(i=0;i<2;i++)
- Vk[i][i]+=sigma[i][i]*sigma[i][i];
- }
- else
- {
- sigma[1][1]=pSP->dr()*Rk[3]/cos(Rk[2]);
- sigma[1][1]=sigma[1][1]*sigma[1][1];
- double a=Rk[2]-x*fConst*Rk[4]-sin(pSP->phi()-averagePhi0);
- sigma[0][0]=x*x*pSP->dphi()*pSP->dphi()+
- a*a*pSP->dr()*pSP->dr();
- sigma[0][1]=sigma[1][0]=a*Rk[3]*pSP->dr()*pSP->dr();
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- Vk[i][j]+=sigma[i][j];
- }
-
- detr=Vk[0][0]*Vk[1][1]-Vk[0][1]*Vk[1][0];detr=1.0/detr;
- Dk[0][0]=Vk[1][1]*detr;Dk[0][1]=Dk[1][0]=-Vk[0][1]*detr;
- Dk[1][1]=Vk[0][0]*detr;
-
- for(i=0;i<2;i++)
- {
- resid[i]=0.0;for(j=0;j<5;j++) resid[i]+=Hk[i][j]*Rk[j];
- }
- resid[0]=y-resid[0];
- resid[1]=pSP->z()-resid[1];
- dchi2=resid[0]*resid[0]*Dk[0][0]+2.0*Dk[0][1]*resid[0]*resid[1]+
- resid[1]*resid[1]*Dk[1][1];
- // printf("r1=%f r2=%f dchi2=%f\n",resid[0],resid[1],dchi2);
- //printf("dchi2phi=%f dchi2z=%f\n",
- // resid[0]*resid[0]*Dk[0][0],resid[1]*resid[1]*Dk[1][1]);
- if(dchi2<maxChi2)
- {
- chi2+=dchi2;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Kk[i][j]=0.0;for(m=0;m<2;m++) Kk[i][j]+=Bk[i][m]*Dk[m][j];
- }
- for(i=0;i<5;i++)
- Rk[i]+=Kk[i][0]*resid[0]+Kk[i][1]*resid[1];
- for(i=0;i<5;i++)
- for(j=i;j<5;j++)
- {
- Gk[i][j]-=Kk[i][0]*Bk[j][0]+Kk[i][1]*Bk[j][1];
- Gk[j][i]=Gk[i][j];
- }
- }
- }
- else
- {
- int LayId=pSP->layer();
- arrAmbiIdx[LayId]++;
- arrAmbiLayers[LayId].push_back(pSP);
- }
- }
-#ifdef IDSCAN_DEBUG
- printf("Estimates before amb.resolving : d0=%f z0=%f phi0=%f theta=%f pT=%f\n",
- Rk[0],Rk[1],Rk[2],theta,1.0/Rk[4]);
- printf("Chi2 = %f Total %d ambiguities\n",
- chi2,nAmbiLayers);
-#endif
-
- for(i=0;i<20;i++) nAmbiLayers+=arrAmbiIdx[i];
- if(nAmbiLayers!=0)
- {
- for(int layId=19;layId>=0;layId--)
- {
- if(arrAmbiIdx[layId]==0) continue;
- pBestSP=NULL;
- bestChi2=maxChi2;
-#ifdef IDSCAN_DEBUG
- printf("Analyzing layer %d ...\n",layId);
-#endif
- for(std::vector<IdScanSpPoint *>::iterator hitItr=arrAmbiLayers[layId].begin();
- hitItr!=arrAmbiLayers[layId].end();++hitItr)
- {
- IdScanSpPoint* pSP=(*hitItr);
- x=pSP->rho()*cos(pSP->phi()-averagePhi0);
- y=pSP->rho()*sin(pSP->phi()-averagePhi0);
- Hk[0][0]=1.0;Hk[0][1]=0.0;Hk[0][2]=x;
- Hk[0][3]=0.0;Hk[0][4]=-0.5*x*x*fConst;
- Hk[1][0]=0.0;Hk[1][1]=1.0;
- Hk[1][2]=0.0;Hk[1][3]=x;Hk[1][4]=0.0;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Bk[i][j]=0.0;for(m=0;m<5;m++) Bk[i][j]+=Gk[i][m]*Hk[j][m];
- }
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- {
- Vk[i][j]=0.0;for(m=0;m<5;m++) Vk[i][j]+=Hk[i][m]*Bk[m][j];
- }
- if(pSP->layer()<7)
- {
- sigma[0][0]=pSP->rho()*pSP->dphi();
- sigma[1][1]=pSP->dz();
- for(i=0;i<2;i++)
- Vk[i][i]+=sigma[i][i]*sigma[i][i];
- }
- else
- {
- sigma[1][1]=pSP->dr()*Rk[3]/cos(Rk[2]);
- sigma[1][1]=sigma[1][1]*sigma[1][1];
- double a=Rk[2]-x*fConst*Rk[4]-sin(pSP->phi()-averagePhi0);
- sigma[0][0]=x*x*pSP->dphi()*pSP->dphi()+
- a*a*pSP->dr()*pSP->dr();
- sigma[0][1]=sigma[1][0]=a*Rk[3]*pSP->dr()*pSP->dr();
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- Vk[i][j]+=sigma[i][j];
- }
-
- detr=Vk[0][0]*Vk[1][1]-Vk[0][1]*Vk[1][0];detr=1.0/detr;
- Dk[0][0]=Vk[1][1]*detr;Dk[0][1]=Dk[1][0]=-Vk[0][1]*detr;
- Dk[1][1]=Vk[0][0]*detr;
- for(i=0;i<2;i++)
- {
- resid[i]=0.0;for(j=0;j<5;j++) resid[i]+=Hk[i][j]*Rk[j];
- }
- resid[0]=y-resid[0];
- resid[1]=pSP->z()-resid[1];
- dchi2=resid[0]*resid[0]*Dk[0][0]+2.0*Dk[0][1]*resid[0]*resid[1]+
- resid[1]*resid[1]*Dk[1][1];
-#ifdef IDSCAN_DEBUG
- printf(" dchi2=%f\n",dchi2);
-#endif
- if(dchi2<bestChi2)
- {
- bestChi2=dchi2;
- pBestSP=pSP;
- }
- }
- if(pBestSP!=NULL)
- {
-#ifdef IDSCAN_DEBUG
- printf("Best spacepoint with dchi2=%f\n",bestChi2);
-#endif
- IdScanSpPoint* pSP=pBestSP;
- pSP->setUsed(1);
- x=pSP->rho()*cos(pSP->phi()-averagePhi0);
- y=pSP->rho()*sin(pSP->phi()-averagePhi0);
- Hk[0][0]=1.0;Hk[0][1]=0.0;Hk[0][2]=x;
- Hk[0][3]=0.0;Hk[0][4]=-0.5*x*x*fConst;
- Hk[1][0]=0.0;Hk[1][1]=1.0;
- Hk[1][2]=0.0;Hk[1][3]=x;Hk[1][4]=0.0;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Bk[i][j]=0.0;for(m=0;m<5;m++) Bk[i][j]+=Gk[i][m]*Hk[j][m];
- }
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- {
- Vk[i][j]=0.0;for(m=0;m<5;m++) Vk[i][j]+=Hk[i][m]*Bk[m][j];
- }
- if(pSP->layer()<7)
- {
- sigma[0][0]=x*pSP->dphi();
- sigma[1][1]=pSP->dz();
- for(i=0;i<2;i++)
- Vk[i][i]+=sigma[i][i]*sigma[i][i];
- }
- else
- {
- sigma[1][1]=pSP->dr()*Rk[3]/cos(Rk[2]);
- sigma[1][1]=sigma[1][1]*sigma[1][1];
- double a=Rk[2]-x*fConst*Rk[4]-sin(pSP->phi()-averagePhi0);
- sigma[0][0]=x*x*pSP->dphi()*pSP->dphi()+
- a*a*pSP->dr()*pSP->dr();
- sigma[0][1]=sigma[1][0]=a*Rk[3]*pSP->dr()*pSP->dr();
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- Vk[i][j]+=sigma[i][j];
- }
-
- detr=Vk[0][0]*Vk[1][1]-Vk[0][1]*Vk[1][0];detr=1.0/detr;
- Dk[0][0]=Vk[1][1]*detr;Dk[0][1]=Dk[1][0]=-Vk[0][1]*detr;
- Dk[1][1]=Vk[0][0]*detr;
-
- for(i=0;i<2;i++)
- {
- resid[i]=0.0;for(j=0;j<5;j++) resid[i]+=Hk[i][j]*Rk[j];
- }
- resid[0]=y-resid[0];
- resid[1]=pSP->z()-resid[1];
- dchi2=resid[0]*resid[0]*Dk[0][0]+2.0*Dk[0][1]*resid[0]*resid[1]+
- resid[1]*resid[1]*Dk[1][1];
- // printf("r1=%f r2=%f dchi2=%f\n",resid[0],resid[1],dchi2);
- chi2+=dchi2;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Kk[i][j]=0.0;for(m=0;m<2;m++) Kk[i][j]+=Bk[i][m]*Dk[m][j];
- }
- for(i=0;i<5;i++)
- Rk[i]+=Kk[i][0]*resid[0]+Kk[i][1]*resid[1];
- for(i=0;i<5;i++)
- for(j=i;j<5;j++)
- {
- Gk[i][j]-=Kk[i][0]*Bk[j][0]+Kk[i][1]*Bk[j][1];
- Gk[j][i]=Gk[i][j];
- }
- }
-#ifdef IDSCAN_DEBUG
- else
- printf("All SPs are rejected\n");
-#endif
- }
- }
- theta=atan(1.0/Rk[3]);
- if(theta<0.0) theta+=M_PI;
- Rk[2]+=averagePhi0;
-#ifdef IDSCAN_DEBUG
- printf("Final estimates: d0=%f z0=%f phi0=%f theta=%f pT=%f\n",
- Rk[0],Rk[1],Rk[2],theta,1.0/Rk[4]);
- printf("Chi2 = %f Total %d ambiguities\n",
- chi2,nAmbiLayers);
-#endif
- if((chi2>maxChi2inGroup)||(std::fabs(1.0/Rk[4])<minPt))
- {
- G.groupHits().clear();
-#ifdef IDSCAN_DEBUG
- printf("Large Chi2 or very low pT - the group is rejected\n");
-#endif
- }
- G.setPtInv(Rk[4]);
- G.setChi2(chi2);
- G.setPhi0(Rk[2]);
- G.setz0(Rk[1]);
- G.setEta(-log(sin(0.5*theta)/cos(0.5*theta)));
-
- for(i=0;i<20;i++)
- {
- if(arrAmbiIdx[i]!=0)
- {
- arrAmbiLayers[i].clear();
- }
- }
-}
-void iHitFilter::fitGroupWithoutHitRemoval(Group& G)
-{
- const double C=0.029997;
- const double maxChi2=500.0;
- const double maxChi2inGroup=6000.0;
- const double minPt=600.0;
-
- double Rk[5],Gk[5][5],Hk[2][5],Kk[5][2],resid[2],
- Bk[5][2],Vk[2][2],sigma[2][2],Dk[2][2];
- double chi2,dchi2,Bz,fConst,x,y,z,detr,averagePhi0=0.0,theta,
- phiErr,rhoErr,zErr;
- int i,j,m,nAmbiLayers=0,nHits=0;
-
- HIT_VECTOR arrAmbiLayers[20];
- HIT_VECTOR spVec;
- int arrAmbiIdx[20];
-
- spVec.clear();
-
- theta=2.0*atan(exp(-G.getEta()));
-
- Rk[0]=0.0;
- // Rk[1]=0.0;
- Rk[1]=G.getz0();
- Rk[2]=0.0;
- Rk[3]=cos(theta)/sin(theta);
- Rk[4]=G.getPtInv();
-
- memset(&Gk[0][0],0,sizeof(Gk));
- Gk[0][0]=100.0;
- Gk[1][1]=100.0;
- Gk[2][2]=100.0;
- Gk[3][3]=100.0;
- Gk[4][4]=0.01;
- memset(&arrAmbiIdx[0],0,sizeof(arrAmbiIdx));
-
- chi2=0.0;Bz=20.84;fConst=C*Bz;
-
- double minPhi=(*G.groupHits().begin())->phi();
-
- for (IdScanSpPoint* pSP : G.groupHits())
- {
- if(minPhi>pSP->phi()) minPhi=pSP->phi();
- spVec.push_back(pSP);
- }
- std::sort(spVec.begin(),spVec.end(),CompareSpByLayer);
-
- for (IdScanSpPoint* pSP : spVec)
- {
- if(pSP->used()==0)
- pSP->setUsed(1);
- nHits++;
- double delta=pSP->phi()-minPhi;
- if(std::fabs(delta)>M_PI) delta-=2.0*M_PI;
- averagePhi0+=delta;
- }
- averagePhi0/=nHits;averagePhi0+=minPhi;
-
-#ifdef IDSCAN_DEBUG
- printf("Average PHI0=%f Initial Pt=%f\n",averagePhi0,1.0/G.getPtInv());
-#endif
-
- for(std::vector<IdScanSpPoint *>::reverse_iterator hitItr=spVec.rbegin();hitItr!=spVec.rend();++hitItr)
- {
- IdScanSpPoint* pSP=(*hitItr);
- int LayId=pSP->layer();
- arrAmbiIdx[LayId]++;
- arrAmbiLayers[LayId].push_back(pSP);
- }
- for(int LayId=0;LayId<20;LayId++)
- {
- if(arrAmbiIdx[LayId]==0) continue;
-
- if(arrAmbiIdx[LayId]==1)
- {
- IdScanSpPoint* pSP=(*arrAmbiLayers[LayId].begin());
- x=pSP->rho()*cos(pSP->phi()-averagePhi0);
- y=pSP->rho()*sin(pSP->phi()-averagePhi0);
- z=pSP->z();
- phiErr=pSP->dphi();
- rhoErr=pSP->dr();
- zErr=pSP->dz();
-#ifdef IDSCAN_DEBUG
- printf("x=%f y=%f z=%f of a spacepoint\n",x,y,z);
-#endif
- }
- else
- {
- x=0.0;y=0.0;z=0.0;
- int nHitLayer=0;
- for(HIT_VECTOR::iterator hitItr=arrAmbiLayers[LayId].begin();hitItr!=arrAmbiLayers[LayId].end();++hitItr)
- {
- IdScanSpPoint* pSP=(*hitItr);
- nHitLayer++;
- x+=pSP->rho()*cos(pSP->phi()-averagePhi0);
- y+=pSP->rho()*sin(pSP->phi()-averagePhi0);
- z+=pSP->z();nAmbiLayers++;
- }
- x=x/nHitLayer;y=y/nHitLayer;z=z/nHitLayer;
-#ifdef IDSCAN_DEBUG
- printf("x=%f y=%f z=%f of spacepoint combination\n",x,y,z);
-#endif
- IdScanSpPoint* pSP=(*arrAmbiLayers[LayId].begin());
- phiErr=10.0*pSP->dphi();
- rhoErr=10.0*pSP->dr();
- zErr=10.0*pSP->dz();
- }
- Hk[0][0]=1.0;Hk[0][1]=0.0;Hk[0][2]=x;
- Hk[0][3]=0.0;Hk[0][4]=-0.5*x*x*fConst;
- Hk[1][0]=0.0;Hk[1][1]=1.0;
- Hk[1][2]=0.0;Hk[1][3]=x;Hk[1][4]=0.0;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Bk[i][j]=0.0;for(m=0;m<5;m++) Bk[i][j]+=Gk[i][m]*Hk[j][m];
- }
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- {
- Vk[i][j]=0.0;for(m=0;m<5;m++) Vk[i][j]+=Hk[i][m]*Bk[m][j];
- }
- if(LayId<7)
- {
- sigma[0][0]=x*phiErr;
- sigma[1][1]=zErr;
- for(i=0;i<2;i++)
- Vk[i][i]+=sigma[i][i]*sigma[i][i];
- }
- else
- {
- sigma[1][1]=rhoErr*Rk[3]/cos(Rk[2]);
- sigma[1][1]=sigma[1][1]*sigma[1][1];
- double phii = atan2(y,x);
- double a=Rk[2]-x*fConst*Rk[4]-sin(phii);
- sigma[0][0]=x*x*phiErr*phiErr+a*a*rhoErr*rhoErr;
- sigma[0][1]=sigma[1][0]=a*Rk[3]*rhoErr*rhoErr;
- for(i=0;i<2;i++)
- for(j=0;j<2;j++)
- Vk[i][j]+=sigma[i][j];
- }
-
- detr=Vk[0][0]*Vk[1][1]-Vk[0][1]*Vk[1][0];detr=1.0/detr;
- Dk[0][0]=Vk[1][1]*detr;Dk[0][1]=Dk[1][0]=-Vk[0][1]*detr;
- Dk[1][1]=Vk[0][0]*detr;
-
- for(i=0;i<2;i++)
- {
- resid[i]=0.0;for(j=0;j<5;j++) resid[i]+=Hk[i][j]*Rk[j];
- }
- resid[0]=y-resid[0];
- resid[1]=z-resid[1];
- dchi2=resid[0]*resid[0]*Dk[0][0]+2.0*Dk[0][1]*resid[0]*resid[1]+
- resid[1]*resid[1]*Dk[1][1];
- // printf("r1=%f r2=%f dchi2=%f\n",resid[0],resid[1],dchi2);
- //printf("dchi2phi=%f dchi2z=%f\n",
- // resid[0]*resid[0]*Dk[0][0],resid[1]*resid[1]*Dk[1][1]);
- if(dchi2<maxChi2)
- {
- chi2+=dchi2;
- for(i=0;i<5;i++)
- for(j=0;j<2;j++)
- {
- Kk[i][j]=0.0;for(m=0;m<2;m++) Kk[i][j]+=Bk[i][m]*Dk[m][j];
- }
- for(i=0;i<5;i++)
- Rk[i]+=Kk[i][0]*resid[0]+Kk[i][1]*resid[1];
- for(i=0;i<5;i++)
- for(j=i;j<5;j++)
- {
- Gk[i][j]-=Kk[i][0]*Bk[j][0]+Kk[i][1]*Bk[j][1];
- Gk[j][i]=Gk[i][j];
- }
- }
- }
- theta=atan(1.0/Rk[3]);
- if(theta<0.0) theta+=M_PI;
- Rk[2]+=averagePhi0;
-#ifdef IDSCAN_DEBUG
- printf("Final estimates: d0=%f z0=%f phi0=%f theta=%f pT=%f\n",
- Rk[0],Rk[1],Rk[2],theta,1.0/Rk[4]);
- printf("Chi2 = %f Total %d ambiguities\n",
- chi2,nAmbiLayers);
-#endif
- if((chi2>maxChi2inGroup)||(std::fabs(1.0/Rk[4])<minPt))
- {
- G.groupHits().clear();
-#ifdef IDSCAN_DEBUG
- printf("Large Chi2 or very low pT - the group is rejected\n");
-#endif
- }
- G.setPtInv(Rk[4]);
- G.setChi2(chi2);
- G.setPhi0(Rk[2]);
- G.setz0(Rk[1]);
- G.setEta(-log(sin(0.5*theta)/cos(0.5*theta)));
-
- for(i=0;i<20;i++)
- {
- if(arrAmbiIdx[i]!=0)
- {
- arrAmbiLayers[i].clear();
- }
- }
-}
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/iHitFilter.h b/Trigger/TrigTools/IDScanHitFilter/src/iHitFilter.h
deleted file mode 100644
index 99b92cf2816b3fbc71001480844406b186be26d8..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/iHitFilter.h
+++ /dev/null
@@ -1,244 +0,0 @@
-// emacs: this is -*- c++ -*-
-
-/*
- Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: HitFilter.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-//
-// Description: - main pattern recognition algorithm of IdScan
-//
-// date: 28/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if ! defined( IDSCAN_IHITFILTER_H )
-#define IDSCAN_IHITFILTER_H
-
-#include <vector>
-
-#include "HF_Constants.h"
-
-#include "FilterBin.h"
-#include "Group.h"
-#include "IdScanSpPoint.h"
-
-struct groupCleanerParams;
-struct GCP_loose;
-struct GCP_tight;
-
-
-////////////////////////////////////////////////////////////////////////////////
-//// HitFilter
-////////////////////////////////////////////////////////////////////////////////
-
-class iHitFilter
-{
-public:
-
- iHitFilter()
- : m_fullScan(false), m_binMap(NULL), m_loose(NULL), m_tight(NULL), m_internalSPs(NULL), m_zVertex(0),
- m_IdScan_MaxNumLayers(19), m_IdScan_MaxEta(3.0) { }
-
- ~iHitFilter();
-
- int initialise(long maxlayers, long maxBarrelLayer, double maxeta=3.0);
-
- double getLayerThreshold() const { return m_layerThreshold; }
-
- void setLayerThresholdTmp(double d) { m_layerThresholdTmp = d; }
-
-protected: // member functions
-
- // GroupList execute( hitVec& );
- GroupList execute();
-
- long makeHashKey( double phi, double eta ) const;
- long makeHashKey( double* r, double* f,
- double k21, double rr1,
- double fr1, groupCleanerParams* params) const;
- void neighborKeys( long key, long* np ) const;
-
- void clusterBins( GroupList& gList );
- void joinGroup( long key, FilterBin& bin, GroupList::iterator giter, GroupList& glist );
-
- void groupCleaner( GroupList::iterator& gItr, GroupList& cleangroups ) ;
- void fillMapGC1( GroupList::iterator& inputItr, groupCleanerParams* params ) const;
- void fillMapGC2( GroupList::iterator& inputItr, groupCleanerParams* params ) const;
-
- double dzdr(double* r, double* z) const;
- double ktemp(double* r, double* f) const;
- void fitGroup(Group&);
- void fitGroupWithoutHitRemoval(Group&);
-
- void cleanInternalSPs();
-
- void makeIDScanSPs( std::vector<const ExternalSpacePoint* >, double, double, double, double, double );
-
-protected: // data members
-
- // to be read in from jobOptions
-
- double m_ROIphiHalfWidth;
- double m_ROIetaHalfWidth;
-
- double m_useROIphiHalfWidth;
-
- bool m_fullScan;
- long m_maxPhiBins;
- bool m_HF;
-
- double m_phiBinSize;
- double m_etaBinSize;
- double m_layerThreshold; // This is the value that you set once.
- double m_layerThresholdTmp; // This value is set for each RoI, depending on number of missing layers
- bool m_enhanceLayer0;
- bool m_cloneRemoval;
- bool m_usePtSign;
- long m_cloneRemovalCut;
- double m_invPhiBinSize;
- double m_invEtaBinSize;
-
- double m_looseTight;
- double m_pTcutInMeV;
- double m_dPhidRCut;
-
- double m_loose_deltadzdrCut;
- double m_loose_etaCutInner;
- double m_loose_etaCutOuter;
- double m_loose_d0Cut;
- double m_loose_dPhidRBinSize;
- long m_loose_phi0Bins;
-
- double m_tight_deltadzdrCut;
- double m_tight_etaCutInner;
- double m_tight_etaCutOuter;
- double m_tight_d0Cut;
- double m_tight_dPhidRBinSize;
- long m_tight_phi0Bins;
-
- FilterMap* m_binMap;
-
- GCP_loose* m_loose; // loose set of parameters for group cleaner (look at GC_Constants.h)
- GCP_tight* m_tight; // tight set of parameters for group cleaner
-
- bool m_printDiagnosticMessages;
-
- hitVec* m_internalSPs;
-
- double m_zVertex; // roi z vertex
-
- long m_binCounter;
-
- double m_maxBeamSpotShift;
-
-
- /// locally set parameters for number of layers (and max eta ??)
- long m_IdScan_MaxNumLayers;
- double m_IdScan_MaxEta;
-
- long m_maxBarrelLayer = 6;
-};
-
-
-class TrackCandidateClass
-{
- public:
- TrackCandidateClass(class Group*);
- ~TrackCandidateClass(){};
- Group* m_pGroup;
- int m_nHitShift;
- int m_nSharedHits;
- int m_nSharedTotal;
- double m_fom;
- double m_pt;
-};
-
-class TrackFilterClass
-{
- public:
- void addNewTrackCandidate(class Group*);
- void removeClones(int);
- TrackFilterClass(bool);
- ~TrackFilterClass();
- private:
- std::vector<TrackCandidateClass*> m_vpTCC;
- bool m_usePtSign;
-};
-
-
-inline long iHitFilter::makeHashKey( double phi, double eta ) const
-{
-// makes the hash key for the (eta,phi) mapping in the hit filter...
-//
- long etabin = (long) ( (eta+m_IdScan_MaxEta)*m_invEtaBinSize );
- long phibin = (long) ( phi*m_invPhiBinSize);
-
- return (HashKeyCoeff*etabin + phibin);
-
-}
-
-
-inline void iHitFilter::neighborKeys( long key, long* np ) const
-{
-// Finds the hash keys for the 8 neighbouring bins. Look at HitFilter::makeHashKey
-// to understand the decoding...
-//
- long bin1 = key/HashKeyCoeff; // eta bin for hitFilter, phi0 bin for groupCleaner
- long bin2 = key%HashKeyCoeff; // phi bin for hitFilter, dphi/drho bin for groupCleaner
-
- long bin1m1 = bin1 - 1;
- long bin1p1 = bin1 + 1;
-
- long bin2m1 = bin2 - 1;
- long bin2p1 = bin2 + 1;
-
- if ( m_fullScan && m_HF ) {
- if ( bin2m1 < 0 ) bin2m1 += m_maxPhiBins;
- if ( bin2p1 > m_maxPhiBins-1) bin2p1 -= m_maxPhiBins;
- }
-
- np[0] = HashKeyCoeff*bin1m1 + bin2m1;
- np[1] = HashKeyCoeff*bin1m1 + bin2;
- np[2] = HashKeyCoeff*bin1m1 + bin2p1;
- np[3] = HashKeyCoeff*bin1 + bin2m1;
- np[4] = HashKeyCoeff*bin1 + bin2p1;
- np[5] = HashKeyCoeff*bin1p1 + bin2m1;
- np[6] = HashKeyCoeff*bin1p1 + bin2;
- np[7] = HashKeyCoeff*bin1p1 + bin2p1;
-
- /*
- for (long i=-1; i<2; ++i) {
- for (long j=-1; j<2; ++j) {
- if ( i||j ) {
- *np++ = HashKeyCoeff*(bin1+i) + (bin2+j);
- }
- }
- }
- */
-
-}
-
-
-inline double iHitFilter::dzdr(double* r, double* z) const
-{
- return (z[1]-z[0])/(r[1]-r[0]);
-}
-
-
-inline double iHitFilter::ktemp(double* r, double* f) const
-{
- return (f[1]*r[1]-f[0]*r[0])/(r[1]-r[0]);
-}
-
-
-#endif
diff --git a/Trigger/TrigTools/IDScanHitFilter/src/tIdScanSpPoint.h b/Trigger/TrigTools/IDScanHitFilter/src/tIdScanSpPoint.h
deleted file mode 100755
index be0a76c0735e2898a8e62820a4422697120a3eb0..0000000000000000000000000000000000000000
--- a/Trigger/TrigTools/IDScanHitFilter/src/tIdScanSpPoint.h
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- Copyright (C) 2002-2017 CERN for the benefit of the ATLAS collaboration
-*/
-
-////////////////////////////////////////////////////////////////////////////////
-//
-// filename: IdScanSpPoint.h
-//
-// author: Nikos Konstantinidis
-// nk@hep.ucl.ac.uk
-//
-//
-// Description: - Internal IdScan space point
-//
-// date: 24/07/2003
-//
-// -------------------------------
-// ATLAS Collaboration
-////////////////////////////////////////////////////////////////////////////////
-
-
-#if ! defined( IDSCAN_TIDSCANSPPOINT_H )
-#define IDSCAN_TIDSCANSPPOINT_H
-
-#include <iostream>
-
-
-template<class SpacePointClass> class tIdScanSpPoint
-{
- public:
-
- tIdScanSpPoint( const SpacePointClass* spPtr, double eta ) :
- m_commonSP(spPtr),
- m_eta(eta)
- { };
-
- int index() const { return m_index; }
- int index(int i) { return m_index=i; }
-
- const SpacePointClass* commonSP() const { return m_commonSP; };
-
- double phi() const { return m_commonSP->phi(); };
- double rho() const { return m_commonSP->r(); };
- double z() const { return m_commonSP->z(); };
-
- double eta() const { return m_eta; };
- double rotatedPhi() const { return m_rotatedPhi; };
-
- long layer() const { return m_commonSP->layer(); };
-
- double dphi() const { return m_commonSP->dphi(); };
- double dr() const { return m_commonSP->dr(); };
- double dz() const { return m_commonSP->dz(); };
-
- int used() const { return m_used; };
- void setUsed(int u) { m_used=u; };
-
- void setRotatedPhi(double phi) { m_rotatedPhi = phi; }
-
- private:
-
- const SpacePointClass* m_commonSP;
-
- double m_eta;
- double m_rotatedPhi;
-
- int m_used;
- int m_index;
-};
-
-
-template<class SpacePointClass>
-inline std::ostream& operator<<(std::ostream& s,
- const tIdScanSpPoint<SpacePointClass>& sp)
-{
- return s << "[ i=" << sp.index()
- << "\tlyr=" << sp.layer()
- << "\trho=" << sp.rho()
- << "\tphi=" << sp.phi()
- << "\tzed=" << sp.z()
- << "\t( eta=" << sp.eta() << " )\t]";
-}
-
-
-
-template<class SpacePointClass>
-struct torderInRho
-{
-// this is a comparison function needed by std::sort to sort the hits of a list in increasing rho
-//
- bool operator()(const SpacePointClass* sp1, const SpacePointClass* sp2) const
- {
- return ( sp1->rho() < sp2->rho() );
- }
-};
-
-template<class SpacePointClass>
-struct torderInLayer
-{
- bool operator()(SpacePointClass* sp1, SpacePointClass* sp2) const
- {
- return ( sp1->layer() < sp2->layer() );
- }
-};
-
-template<class SpacePointClass>
-struct torderInIndex
-{
- bool operator()(SpacePointClass* sp1, SpacePointClass* sp2) const
- {
- return ( sp1->index() < sp2->index() );
- }
-};
-
-template<class SpacePointClass>
-struct tequalIds
-{
- bool operator()(SpacePointClass* sp1, SpacePointClass* sp2) const
- {
- return ( sp1->index() == sp2->index() );
- }
-};
-
-
-#endif
-