diff --git a/Configuration/Geometry/python/GeometryExtended2023SHCal_cff.py b/Configuration/Geometry/python/GeometryExtended2023SHCal_cff.py new file mode 100644 index 0000000000000..777f6bb276535 --- /dev/null +++ b/Configuration/Geometry/python/GeometryExtended2023SHCal_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +from Geometry.CMSCommonData.cmsExtendedGeometry2023SHCalXML_cfi import * +from Geometry.TrackerNumberingBuilder.trackerNumberingSLHCGeometry_cfi import * diff --git a/Configuration/PyReleaseValidation/python/relval_steps.py b/Configuration/PyReleaseValidation/python/relval_steps.py index 76a5e9b5f0020..aa4bb8b8dca4c 100644 --- a/Configuration/PyReleaseValidation/python/relval_steps.py +++ b/Configuration/PyReleaseValidation/python/relval_steps.py @@ -2543,7 +2543,7 @@ def genvalid(fragment,d,suffix='all',fi=''): '--conditions':'auto:upgradePLS3', '--mc':'', '--magField' : '38T_PostLS1', - '--customise' : 'SLHCUpgradeSimulations/Configuration/phase1TkCustoms.customise', + '--customise' : 'SLHCUpgradeSimulations/Configuration/phase2TkCustomsBE5D.customise', '--geometry' : 'ExtendedPhase2TkBE5D' } diff --git a/DataFormats/L1TrackTrigger/interface/TTCluster.h b/DataFormats/L1TrackTrigger/interface/TTCluster.h index 0c705bb7b0c22..2a5ce2eca32a9 100644 --- a/DataFormats/L1TrackTrigger/interface/TTCluster.h +++ b/DataFormats/L1TrackTrigger/interface/TTCluster.h @@ -31,7 +31,8 @@ class TTCluster TTCluster(); TTCluster( std::vector< T > aHits, DetId aDetId, - unsigned int aStackMember ); + unsigned int aStackMember, + bool storeLocal ); /// Destructor ~TTCluster(); @@ -49,6 +50,13 @@ class TTCluster unsigned int getStackMember() const { return theStackMember; } void setStackMember( unsigned int aStackMember ) { theStackMember = aStackMember; } + /// Rows and columns to get rid of Digi collection + std::vector< int > findRows() const; + std::vector< int > findCols() const; + void setCoordinates( std::vector< int > a, std::vector< int > b ) { theRows = a; theCols = b; } + std::vector< int > getRows() const { return theRows; } + std::vector< int > getCols() const { return theCols; } + /// Cluster width unsigned int findWidth() const; @@ -66,6 +74,9 @@ class TTCluster DetId theDetId; unsigned int theStackMember; + std::vector< int > theRows; + std::vector< int > theCols; + }; /// Close class /*! \brief Implementation of methods @@ -84,18 +95,29 @@ TTCluster< T >::TTCluster() theHits.clear(); theDetId = 0; theStackMember = 0; + + theRows.clear(); + theCols.clear(); } /// Another Constructor template< typename T > TTCluster< T >::TTCluster( std::vector< T > aHits, DetId aDetId, - unsigned int aStackMember ) + unsigned int aStackMember, + bool storeLocal ) { /// Set data members this->setHits( aHits ); this->setDetId( aDetId ); this->setStackMember( aStackMember ); + + theRows.clear(); + theCols.clear(); + if ( storeLocal ) + { + this->setCoordinates( this->findRows(), this->findCols() ); + } } /// Destructor @@ -104,15 +126,36 @@ TTCluster< T >::~TTCluster(){} /// Cluster width template< > -unsigned int TTCluster< edm::Ref< edm::DetSetVector , PixelDigi > >::findWidth() const; +unsigned int TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findWidth() const; /// Single hit coordinates /// Average cluster coordinates template< > -MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector , PixelDigi > >::findHitLocalCoordinates( unsigned int hitIdx ) const; +MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findHitLocalCoordinates( unsigned int hitIdx ) const; + +template< > +MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findAverageLocalCoordinates() const; + +/// Operations with coordinates stored locally +template< typename T > +std::vector< int > TTCluster< T >::findRows() const +{ + std::vector< int > temp; + return temp; +} + +template< typename T > +std::vector< int > TTCluster< T >::findCols() const +{ + std::vector< int > temp; + return temp; +} + +template< > +std::vector< int > TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findRows() const; template< > -MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector , PixelDigi > >::findAverageLocalCoordinates() const; +std::vector< int > TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findCols() const; /// Information template< typename T > diff --git a/DataFormats/L1TrackTrigger/interface/TTStub.h b/DataFormats/L1TrackTrigger/interface/TTStub.h index 9d32bcb37d96c..f85e0c0c603d4 100644 --- a/DataFormats/L1TrackTrigger/interface/TTStub.h +++ b/DataFormats/L1TrackTrigger/interface/TTStub.h @@ -16,6 +16,7 @@ #include "DataFormats/GeometryVector/interface/GlobalVector.h" #include "DataFormats/L1TrackTrigger/interface/TTCluster.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" template< typename T > class TTStub @@ -32,9 +33,9 @@ class TTStub /// Helper methods: findABC( ... ) /// Clusters composing the Stub - std::vector< edm::Ptr< TTCluster< T > > > getClusterPtrs() const { return theClusters; } - const edm::Ptr< TTCluster< T > >& getClusterPtr( unsigned int hitIdentifier ) const; - void addClusterPtr( edm::Ptr< TTCluster< T > > aTTCluster ) { theClusters.push_back( aTTCluster ); } + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > getClusterRefs() const { return theClusterRefs; } + const edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >& getClusterRef( unsigned int hitIdentifier ) const; + void addClusterRef( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aTTCluster ) { theClusterRefs.push_back( aTTCluster ); } /// Detector element DetId getDetId() const { return theDetId; } @@ -57,10 +58,11 @@ class TTStub private: /// Data members - DetId theDetId; - std::vector< edm::Ptr< TTCluster< T > > > theClusters; - int theDisplacement; - int theOffset; + DetId theDetId; + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > + theClusterRefs; + int theDisplacement; + int theOffset; }; /// Close class @@ -77,7 +79,7 @@ TTStub< T >::TTStub() { /// Set default data members theDetId = 0; - theClusters.clear(); + theClusterRefs.clear(); theDisplacement = 999999; theOffset = 0; } @@ -90,7 +92,7 @@ TTStub< T >::TTStub( DetId aDetId ) this->setDetId( aDetId ); /// Set default data members - theClusters.clear(); + theClusterRefs.clear(); theDisplacement = 999999; theOffset = 0; } @@ -99,14 +101,14 @@ TTStub< T >::TTStub( DetId aDetId ) template< typename T > TTStub< T >::~TTStub(){} -/// Get the Pointer to a Cluster +/// Get the Reference to a Cluster template< typename T > -const edm::Ptr< TTCluster< T > >& TTStub< T >::getClusterPtr( unsigned int hitIdentifier ) const +const edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >& TTStub< T >::getClusterRef( unsigned int hitIdentifier ) const { /// Look for the TTCluster with the stack member corresponding to the argument - typename std::vector< edm::Ptr< TTCluster< T > > >::const_iterator clusIter; - for ( clusIter = theClusters.begin(); - clusIter != theClusters.end(); + typename std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > >::const_iterator clusIter; + for ( clusIter = theClusterRefs.begin(); + clusIter != theClusterRefs.end(); ++clusIter ) { if ( (*clusIter)->getStackMember() == hitIdentifier ) @@ -115,10 +117,10 @@ const edm::Ptr< TTCluster< T > >& TTStub< T >::getClusterPtr( unsigned int hitId } } - /// In case no TTCluster is found, return a NULL edm::Ptr + /// In case no TTCluster is found, return a NULL edm::Ref /// (hopefully code doesn't reach this point) - edm::Ptr< TTCluster< T > >* tmpCluPtr = new edm::Ptr< TTCluster< T > >(); - return *tmpCluPtr; + edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >* tmpCluRef = new edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > >(); + return *tmpCluRef; } /// Trigger info @@ -138,11 +140,17 @@ void TTStub< T >::setTriggerOffset( int anOffset ) { theOffset = anOffset; } template< typename T > double TTStub< T >::getTriggerPosition() const { - return this->getClusterPtr(0)->findAverageLocalCoordinates().x(); + return this->getClusterRef(0)->findAverageLocalCoordinates().x(); } template< typename T > -double TTStub< T >::getTriggerBend() const { return 0.5*( theDisplacement - theOffset ); } +double TTStub< T >::getTriggerBend() const +{ + if ( theDisplacement == 999999 ) + return theDisplacement; + + return 0.5*( theDisplacement - theOffset ); +} /// Information template< typename T > @@ -157,14 +165,15 @@ std::string TTStub< T >::print( unsigned int i ) const std::stringstream output; output<getTriggerPosition(); + output << ", bend: " << this->getTriggerBend() << '\n'; unsigned int iClu = 0; - typename std::vector< edm::Ptr< TTCluster< T > > >::const_iterator clusIter; - for ( clusIter = theClusters.begin(); - clusIter!= theClusters.end(); + typename std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > >::const_iterator clusIter; + for ( clusIter = theClusterRefs.begin(); + clusIter!= theClusterRefs.end(); ++clusIter ) { - output << padding << "cluster: " << iClu++ << ", member: " << (*clusIter)->getStackMember(); + output << padding << "cluster: " << iClu++ << ", member: " << (*clusIter)->getStackMember() << ", address: " << (*clusIter).get(); output << ", cluster size: " << (*clusIter)->getHits().size() << '\n'; } diff --git a/DataFormats/L1TrackTrigger/interface/TTTrack.h b/DataFormats/L1TrackTrigger/interface/TTTrack.h index 9a3b3426bf9b2..5cd4cc7f6e02d 100644 --- a/DataFormats/L1TrackTrigger/interface/TTTrack.h +++ b/DataFormats/L1TrackTrigger/interface/TTTrack.h @@ -21,59 +21,59 @@ class TTTrack { private: /// Data members - std::vector< edm::Ptr< TTStub< T > > > theStubPtrs; - GlobalVector theMomentum; - GlobalPoint theVertex; - double theRInv; - unsigned int theSector; - unsigned int theWedge; - double theChi2; - int theLargestResIdx; + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > + theStubRefs; + GlobalVector theMomentum; + GlobalPoint thePOCA; + double theRInv; + unsigned int theSector; + unsigned int theWedge; + double theChi2; + unsigned int theFitParNo; public: /// Constructors TTTrack(); - TTTrack( std::vector< edm::Ptr< TTStub< T > > > aStubs ); + TTTrack( std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > aStubs ); /// Destructor ~TTTrack(); /// Track components - std::vector< edm::Ptr< TTStub< T > > > getStubPtrs() const { return theStubPtrs; } - void addStubPtr( edm::Ptr< TTStub< T > > aStub ) { theStubPtrs.push_back( aStub ); } - void setStubPtrs( std::vector< edm::Ptr< TTStub< T > > > aStubs ) { theStubPtrs = aStubs; } + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > getStubRefs() const { return theStubRefs; } + void addStubRef( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) { theStubRefs.push_back( aStub ); } + void setStubRefs( std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > aStubs ) { theStubRefs = aStubs; } /// Track momentum GlobalVector getMomentum() const { return theMomentum; } void setMomentum( GlobalVector aMomentum ) { theMomentum = aMomentum; } - /// Track parameters + /// Track curvature double getRInv() const { return theRInv; } void setRInv( double aRInv ) { theRInv = aRInv; } - /// Vertex - GlobalPoint getVertex() const { return theVertex; } - void setVertex( GlobalPoint aVertex ) { theVertex = aVertex; } + /// POCA + GlobalPoint getPOCA() const { return thePOCA; } + void setPOCA( GlobalPoint aPOCA ) { thePOCA = aPOCA; } /// Sector unsigned int getSector() const { return theSector; } void setSector( unsigned int aSector ) { theSector = aSector; } - unsigned int getWedge() const { return theWedge; } - void setWedge( unsigned int aWedge ) { theWedge = aWedge; } + unsigned int getWedge() const { return theWedge; } + void setWedge( unsigned int aWedge ) { theWedge = aWedge; } /// Chi2 - double getChi2() const { return theChi2; } - double getChi2Red() const; - void setChi2( double aChi2 ) { theChi2 = aChi2; } - - /// Largest Residual Idx - int getLargestResIdx() const { return theLargestResIdx; } - void setLargestResIdx( int aIdx ) { theLargestResIdx = aIdx; } + double getChi2() const { return theChi2; } + double getChi2Red() const; + void setChi2( double aChi2 ) { theChi2 = aChi2; } + unsigned int getFitParNo() const { return theFitParNo; } + void setFitParNo( unsigned int aFitParNo ) { theFitParNo = aFitParNo; } +/* /// Superstrip /// Here to prepare inclusion of AM L1 Track finding uint32_t getSuperStrip() const { return 0; } - +*/ /// Duplicate identification bool isTheSameAs( TTTrack< T > aTrack ) const; @@ -96,28 +96,29 @@ class TTTrack template< typename T > TTTrack< T >::TTTrack() { - theStubPtrs.clear(); + theStubRefs.clear(); theMomentum = GlobalVector(0.0,0.0,0.0); theRInv = 0; - theVertex = GlobalPoint(0.0,0.0,0.0); + thePOCA = GlobalPoint(0.0,0.0,0.0); theSector = 0; theWedge = 0; theChi2 = 0; - theLargestResIdx = -1; + theFitParNo = 0; } /// Another Constructor template< typename T > -TTTrack< T >::TTTrack( std::vector< edm::Ptr< TTStub< T > > > aStubs ) +//TTTrack< T >::TTTrack( std::vector< edm::Ptr< TTStub< T > > > aStubs ) +TTTrack< T >::TTTrack( std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > aStubs ) { - theStubPtrs = aStubs; + theStubRefs = aStubs; theMomentum = GlobalVector(0.0,0.0,0.0); - theVertex = GlobalPoint(0.0,0.0,0.0); + thePOCA = GlobalPoint(0.0,0.0,0.0); theRInv = 0; theSector = 0; theWedge = 0; theChi2 = 0; - theLargestResIdx = -1; + theFitParNo = 0; } /// Destructor @@ -128,7 +129,7 @@ TTTrack< T >::~TTTrack(){} template< typename T > double TTTrack< T >::getChi2Red() const { - return theChi2/( 2*theStubPtrs.size() - 4 ); + return theChi2/( 2*theStubRefs.size() - this->getFitParNo() ); } /// Duplicate identification @@ -136,15 +137,16 @@ template< typename T> bool TTTrack< T >::isTheSameAs( TTTrack< T > aTrack ) const { /// Take the other stubs - std::vector< edm::Ptr< TTStub< T > > > otherStubPtrs = aTrack.getStubPtrs(); +// std::vector< edm::Ptr< TTStub< T > > > otherStubPtrs = aTrack.getStubPtrs(); + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > otherStubRefs = aTrack.getStubRefs(); /// Count shared stubs unsigned int nShared = 0; - for ( unsigned int i = 0; i < theStubPtrs.size() && nShared < 2; i++) + for ( unsigned int i = 0; i < theStubRefs.size() && nShared < 2; i++) { - for ( unsigned int j = 0; j < otherStubPtrs.size() && nShared < 2; j++) + for ( unsigned int j = 0; j < otherStubRefs.size() && nShared < 2; j++) { - if ( theStubPtrs.at(i) == otherStubPtrs.at(j) ) + if ( theStubRefs.at(i) == otherStubRefs.at(j) ) { nShared++; } @@ -159,9 +161,9 @@ bool TTTrack< T >::isTheSameAs( TTTrack< T > aTrack ) const template< typename T > bool TTTrack< T >::hasStubInBarrel( unsigned int aLayer ) const { - for ( unsigned int i = 0; i < theStubPtrs.size(); i++) + for ( unsigned int i = 0; i < theStubRefs.size(); i++) { - StackedTrackerDetId thisDetId( theStubPtrs.at(i)->getDetId() ); + StackedTrackerDetId thisDetId( theStubRefs.at(i)->getDetId() ); if ( thisDetId.isBarrel() && thisDetId.iLayer() == aLayer ) { return true; @@ -186,15 +188,16 @@ std::string TTTrack< T >::print( unsigned int i ) const padding+='\t'; output << '\n'; unsigned int iStub = 0; - typename std::vector< edm::Ptr< TTStub< T > > >::const_iterator stubIter; - for ( stubIter = theStubPtrs.begin(); - stubIter!= theStubPtrs.end(); + + typename std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > >::const_iterator stubIter; + for ( stubIter = theStubRefs.begin(); + stubIter!= theStubRefs.end(); ++stubIter ) { output << padding << "stub: " << iStub++ << ", DetId: " << ((*stubIter)->getDetId()).rawId() << '\n'; } - //output << ", z-vertex: " << theVertex.z() << " (cm), transverse momentum " << theMomentum.perp() << " (GeV/c)"; + //output << ", z-vertex: " << thePOCA.z() << " (cm), transverse momentum " << theMomentum.perp() << " (GeV/c)"; //output << ", red. chi2 " << this->getChi2Red() << '\n'; return output.str(); diff --git a/DataFormats/L1TrackTrigger/src/TTCluster.cc b/DataFormats/L1TrackTrigger/src/TTCluster.cc index df3dbfa74108e..02bbc69fbd903 100644 --- a/DataFormats/L1TrackTrigger/src/TTCluster.cc +++ b/DataFormats/L1TrackTrigger/src/TTCluster.cc @@ -12,7 +12,7 @@ /// Cluster width template< > -unsigned int TTCluster , PixelDigi > >::findWidth() const +unsigned int TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findWidth() const { int rowMin = 99999999; int rowMax = 0; @@ -20,27 +20,47 @@ unsigned int TTCluster , PixelDigi > >::f /// but for 2d or neighbor Clusters this is only the actual size in RPhi for ( unsigned int i = 0; i < theHits.size(); i++ ) { - if ( theHits.at(i)->row() < rowMin ) - rowMin = theHits.at(i)->row(); - if ( theHits.at(i)->row() > rowMax ) - rowMax = theHits.at(i)->row(); + int row = 0; + if ( this->getRows().size() == 0 ) + { + row = theHits.at(i)->row(); + } + else + { + row = this->getRows().at(i); + } + + if ( row < rowMin ) + rowMin = row; + if ( row > rowMax ) + rowMax = row; } return abs( rowMax - rowMin + 1 ); /// This takes care of 1-Pixel clusters } /// Get hit local coordinates template< > -MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector , PixelDigi > >::findHitLocalCoordinates( unsigned int hitIdx ) const +MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findHitLocalCoordinates( unsigned int hitIdx ) const { /// NOTE in this case, DO NOT add 0.5 /// to get the center of the pixel - MeasurementPoint mp( theHits.at(hitIdx)->row(), theHits.at(hitIdx)->column() ); - return mp; + if ( this->getRows().size() == 0 || this->getCols().size() == 0 ) + { + MeasurementPoint mp( theHits.at(hitIdx)->row(), theHits.at(hitIdx)->column() ); + return mp; + } + else + { + int row = this->getRows().at(hitIdx); + int col = this->getCols().at(hitIdx); + MeasurementPoint mp( row, col ); + return mp; + } } /// Unweighted average local cluster coordinates template< > -MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector , PixelDigi > >::findAverageLocalCoordinates() const +MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findAverageLocalCoordinates() const { double averageCol = 0.0; double averageRow = 0.0; @@ -48,18 +68,53 @@ MeasurementPoint TTCluster< edm::Ref< edm::DetSetVector , PixelDigi > /// Loop over the hits and calculate the average coordinates if ( theHits.size() != 0 ) { - typename std::vector< edm::Ref< edm::DetSetVector , PixelDigi > >::const_iterator hitIter; - for ( hitIter = theHits.begin(); - hitIter != theHits.end(); - hitIter++ ) + if ( this->getRows().size() == 0 || this->getCols().size() == 0 ) + { + typename std::vector< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::const_iterator hitIter; + for ( hitIter = theHits.begin(); + hitIter != theHits.end(); + hitIter++ ) + { + averageCol += (*hitIter)->column(); + averageRow += (*hitIter)->row(); + } + averageCol /= theHits.size(); + averageRow /= theHits.size(); + } + else { - averageCol += (*hitIter)->column(); - averageRow += (*hitIter)->row(); + for ( unsigned int j = 0; j < theHits.size(); j++ ) + { + averageCol += theCols.at(j); + averageRow += theRows.at(j); + } + averageCol /= theHits.size(); + averageRow /= theHits.size(); } - averageCol /= theHits.size(); - averageRow /= theHits.size(); } - return MeasurementPoint( averageRow, averageCol ); } +/// Coordinates stored locally +template< > +std::vector< int > TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findRows() const +{ + std::vector< int > temp; + for ( unsigned int i = 0; i < theHits.size(); i++ ) + { + temp.push_back( theHits.at(i)->row() ); + } + return temp; +} + +template< > +std::vector< int > TTCluster< edm::Ref< edm::DetSetVector< PixelDigi >, PixelDigi > >::findCols() const +{ + std::vector< int > temp; + for ( unsigned int i = 0; i < theHits.size(); i++ ) + { + temp.push_back( theHits.at(i)->column() ); + } + return temp; +} + diff --git a/DataFormats/L1TrackTrigger/src/classes.h b/DataFormats/L1TrackTrigger/src/classes.h index 5a6854ddad402..738327454a654 100644 --- a/DataFormats/L1TrackTrigger/src/classes.h +++ b/DataFormats/L1TrackTrigger/src/classes.h @@ -8,37 +8,53 @@ */ #include "DataFormats/Common/interface/Wrapper.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" #include "DataFormats/L1TrackTrigger/interface/TTTypes.h" namespace { namespace { + /// Main template type Ref_PixelDigi_ PD; - TTCluster< Ref_PixelDigi_ > C_PD; - std::vector< TTCluster< Ref_PixelDigi_ > > V_C_PD; - edm::Wrapper< std::vector< TTCluster< Ref_PixelDigi_ > > > W_V_C_PD; - edm::Ptr< TTCluster< Ref_PixelDigi_ > > P_C_PD; - edm::Wrapper< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > W_P_C_PD; - std::vector< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > V_P_C_PD; - edm::Wrapper< std::vector< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > > W_V_P_C_PD; - - TTStub< Ref_PixelDigi_ > S_PD; - std::vector< TTStub< Ref_PixelDigi_ > > V_S_PD; - edm::Wrapper< std::vector< TTStub< Ref_PixelDigi_ > > > W_V_S_PD; - edm::Ptr< TTStub< Ref_PixelDigi_ > > P_S_PD; - edm::Wrapper< edm::Ptr< TTStub< Ref_PixelDigi_ > > > W_P_S_PD; - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > V_P_S_PD; - edm::Wrapper< std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > W_V_P_S_PD; - - TTTrack< Ref_PixelDigi_ > T_PD; - std::vector< TTTrack< Ref_PixelDigi_ > > V_T_PD; - edm::Wrapper< std::vector< TTTrack< Ref_PixelDigi_ > > > W_V_T_PD; + /// TTCluster and containers + TTCluster< Ref_PixelDigi_ > C_PD; + std::vector< TTCluster< Ref_PixelDigi_ > > V_C_PD; + edm::Wrapper< std::vector< TTCluster< Ref_PixelDigi_ > > > W_V_C_PD; + edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > SDV_C_PD; + edm::Wrapper< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > > W_SDV_C_PD; + + /// edm::Ref to TTCluster in edmNew::DetSetVector and containers + edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > R_C_PD; + edm::Wrapper< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > W_R_C_PD; + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > V_R_C_PD; + edm::Wrapper< std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > > W_V_R_C_PD; + + /// TTStub and containers + TTStub< Ref_PixelDigi_ > S_PD; + std::vector< TTStub< Ref_PixelDigi_ > > V_S_PD; + edm::Wrapper< std::vector< TTStub< Ref_PixelDigi_ > > > W_V_S_PD; + edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > > SDV_S_PD; + edm::Wrapper< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > > > W_SDV_S_PD; + + /// edm::Ref to TTStub in edmNew::DetSetVector and containers + edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > R_S_PD; + edm::Wrapper< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > > W_R_S_PD; + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > > V_R_S_PD; + edm::Wrapper< std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > > > W_V_R_S_PD; + + /// TTTrack and containers + TTTrack< Ref_PixelDigi_ > T_PD; + std::vector< TTTrack< Ref_PixelDigi_ > > V_T_PD; + edm::Wrapper< std::vector< TTTrack< Ref_PixelDigi_ > > > W_V_T_PD; + + /// edm::Ptr to TTTrack and containers edm::Ptr< TTTrack< Ref_PixelDigi_ > > P_T_PD; edm::Wrapper< edm::Ptr< TTTrack< Ref_PixelDigi_ > > > W_P_T_PD; std::vector< edm::Ptr< TTTrack< Ref_PixelDigi_ > > > V_P_T_PD; edm::Wrapper< std::vector< edm::Ptr< TTTrack< Ref_PixelDigi_ > > > > W_V_P_T_PD; + } } diff --git a/DataFormats/L1TrackTrigger/src/classes_def.xml b/DataFormats/L1TrackTrigger/src/classes_def.xml index 3f6a8ef75901f..588363c252297 100644 --- a/DataFormats/L1TrackTrigger/src/classes_def.xml +++ b/DataFormats/L1TrackTrigger/src/classes_def.xml @@ -1,30 +1,44 @@ + - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Fireworks/Core/src/FW3DViewGeometry.cc b/Fireworks/Core/src/FW3DViewGeometry.cc index bcb8e284dd148..54124cbe3bf3b 100644 --- a/Fireworks/Core/src/FW3DViewGeometry.cc +++ b/Fireworks/Core/src/FW3DViewGeometry.cc @@ -373,3 +373,5 @@ FW3DViewGeometry::showTrackerEndcap( bool showTrackerEndcap ) gEve->Redraw3D(); } } + + diff --git a/Geometry/CMSCommonData/python/cmsExtendedGeometry2023HGCalXML_cfi.py b/Geometry/CMSCommonData/python/cmsExtendedGeometry2023HGCalXML_cfi.py index d5f72d29b0708..6a69e6524cefb 100644 --- a/Geometry/CMSCommonData/python/cmsExtendedGeometry2023HGCalXML_cfi.py +++ b/Geometry/CMSCommonData/python/cmsExtendedGeometry2023HGCalXML_cfi.py @@ -61,7 +61,9 @@ 'Geometry/HcalCommonData/data/hcalforwardalgo.xml', 'Geometry/HcalCommonData/data/average/hcalforwardmaterial.xml', 'Geometry/HGCalCommonData/data/hgcal.xml', - 'Geometry/PFCalGeometry/data/pfcal.xml', + 'Geometry/HGCalCommonData/data/hgcalEE.xml', + 'Geometry/HGCalCommonData/data/hgcalHE.xml', +## 'Geometry/PFCalGeometry/data/pfcal.xml', 'Geometry/MuonCommonData/data/v1/mbCommon.xml', 'Geometry/MuonCommonData/data/v1/mb1.xml', 'Geometry/MuonCommonData/data/v1/mb2.xml', diff --git a/Geometry/CMSCommonData/python/cmsExtendedGeometry2023SHCalXML_cfi.py b/Geometry/CMSCommonData/python/cmsExtendedGeometry2023SHCalXML_cfi.py new file mode 100644 index 0000000000000..00924560ae14b --- /dev/null +++ b/Geometry/CMSCommonData/python/cmsExtendedGeometry2023SHCalXML_cfi.py @@ -0,0 +1,124 @@ +import FWCore.ParameterSet.Config as cms + +## 2015 + new phase 1 pixel detector + Tracker BarrelEndcap5Dv(described as a pixel detector before the detid migration) + +XMLIdealGeometryESSource = cms.ESSource("XMLIdealGeometryESSource", + geomXMLFiles = cms.vstring('Geometry/CMSCommonData/data/materials.xml', + 'Geometry/CMSCommonData/data/rotations.xml', + 'Geometry/CMSCommonData/data/extend/cmsextent.xml', + 'Geometry/CMSCommonData/data/PhaseI/cms.xml', + 'Geometry/CMSCommonData/data/cmsMother.xml', + 'Geometry/CMSCommonData/data/cmsTracker.xml', + 'Geometry/CMSCommonData/data/caloBase.xml', + 'Geometry/CMSCommonData/data/cmsCalo.xml', + 'Geometry/CMSCommonData/data/muonBase.xml', + 'Geometry/CMSCommonData/data/cmsMuon.xml', + 'Geometry/CMSCommonData/data/mgnt.xml', + 'Geometry/CMSCommonData/data/PhaseI/beampipe.xml', + 'Geometry/CMSCommonData/data/cmsBeam.xml', + 'Geometry/CMSCommonData/data/muonMB.xml', + 'Geometry/CMSCommonData/data/muonMagnet.xml', + 'Geometry/CMSCommonData/data/cavern.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdMaterials.xml', + 'Geometry/TrackerCommonData/data/pixfwdCommon.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdCylinder.xml', + 'Geometry/TrackerCommonData/data/PhaseII/BarrelEndcap5D/pixfwd.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdDisks.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdInnerDisk1.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdInnerDisk2.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdInnerDisk3.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdOuterDisk1.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdOuterDisk2.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdOuterDisk3.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdblade1.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdblade2.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixfwdblade3.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarmaterial.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarladder.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarladderfull0.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarladderfull1.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarladderfull2.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarladderfull3.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarlayer.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarlayer0.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarlayer1.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarlayer2.xml', + 'Geometry/TrackerCommonData/data/PhaseI/pixbarlayer3.xml', + 'Geometry/TrackerCommonData/data/PhaseII/BarrelEndcap5D/pixbar.xml', + 'Geometry/TrackerCommonData/data/trackermaterial.xml', + 'Geometry/TrackerCommonData/data/PhaseII/BarrelEndcap5D/tracker.xml', + 'Geometry/TrackerCommonData/data/trackerpixbar.xml', + 'Geometry/TrackerCommonData/data/PhaseI/trackerpixfwd.xml', + 'Geometry/EcalCommonData/data/PhaseII/eregalgo.xml', + 'Geometry/EcalCommonData/data/ebalgo.xml', + 'Geometry/EcalCommonData/data/ebcon.xml', + 'Geometry/EcalCommonData/data/ebrot.xml', + 'Geometry/EcalCommonData/data/eecon.xml', + 'Geometry/HcalCommonData/data/hcalrotations.xml', + 'Geometry/HcalCommonData/data/PhaseII/hcalalgo.xml', + 'Geometry/HcalCommonData/data/hcalbarrelalgo.xml', + 'Geometry/HcalCommonData/data/hcalouteralgo.xml', + 'Geometry/HcalCommonData/data/hcalforwardalgo.xml', + 'Geometry/HcalCommonData/data/average/hcalforwardmaterial.xml', + 'Geometry/HGCalCommonData/data/shashlik.xml', + 'Geometry/MuonCommonData/data/v1/mbCommon.xml', + 'Geometry/MuonCommonData/data/v1/mb1.xml', + 'Geometry/MuonCommonData/data/v1/mb2.xml', + 'Geometry/MuonCommonData/data/v1/mb3.xml', + 'Geometry/MuonCommonData/data/v1/mb4.xml', + 'Geometry/MuonCommonData/data/design/muonYoke.xml', + 'Geometry/MuonCommonData/data/v2/mf.xml', + 'Geometry/MuonCommonData/data/v2/rpcf.xml', + 'Geometry/MuonCommonData/data/v4/gemf.xml', + 'Geometry/MuonCommonData/data/v2/csc.xml', + 'Geometry/MuonCommonData/data/v2/mfshield.xml', + 'Geometry/ForwardCommonData/data/forward.xml', + 'Geometry/ForwardCommonData/data/v2/forwardshield.xml', + 'Geometry/ForwardCommonData/data/brmrotations.xml', + 'Geometry/ForwardCommonData/data/brm.xml', + 'Geometry/ForwardCommonData/data/totemMaterials.xml', + 'Geometry/ForwardCommonData/data/totemRotations.xml', + 'Geometry/ForwardCommonData/data/totemt1.xml', + 'Geometry/ForwardCommonData/data/totemt2.xml', + 'Geometry/ForwardCommonData/data/ionpump.xml', + 'Geometry/ForwardCommonData/data/castor.xml', + 'Geometry/ForwardCommonData/data/zdcmaterials.xml', + 'Geometry/ForwardCommonData/data/lumimaterials.xml', + 'Geometry/ForwardCommonData/data/zdcrotations.xml', + 'Geometry/ForwardCommonData/data/lumirotations.xml', + 'Geometry/ForwardCommonData/data/zdc.xml', + 'Geometry/ForwardCommonData/data/zdclumi.xml', + 'Geometry/ForwardCommonData/data/cmszdc.xml')+cms.vstring( + 'Geometry/MuonCommonData/data/v2/muonNumbering.xml', + 'Geometry/MuonCommonData/data/v2/muonGemNumbering.xml', + 'Geometry/TrackerCommonData/data/PhaseII/BarrelEndcap5D/trackerStructureTopology.xml', + 'Geometry/TrackerSimData/data/PhaseII/BarrelEndcap5D/trackersens.xml', + 'Geometry/TrackerRecoData/data/PhaseII/BarrelEndcap5D/trackerRecoMaterial.xml', + 'Geometry/EcalSimData/data/PhaseII/ecalsens.xml', + 'Geometry/HcalCommonData/data/PhaseII/hcalsenspmf.xml', + 'Geometry/HcalSimData/data/hf.xml', + 'Geometry/HcalSimData/data/hfpmt.xml', + 'Geometry/HcalSimData/data/hffibrebundle.xml', + 'Geometry/HcalSimData/data/CaloUtil.xml', + 'Geometry/MuonSimData/data/v2/muonSens.xml', + 'Geometry/DTGeometryBuilder/data/dtSpecsFilter.xml', + 'Geometry/CSCGeometryBuilder/data/cscSpecsFilter.xml', + 'Geometry/CSCGeometryBuilder/data/cscSpecs.xml', + 'Geometry/RPCGeometryBuilder/data/RPCSpecs.xml', + 'Geometry/GEMGeometryBuilder/data/v4/GEMSpecs.xml', + 'Geometry/ForwardCommonData/data/brmsens.xml', + 'Geometry/ForwardSimData/data/castorsens.xml', + 'Geometry/ForwardSimData/data/zdcsens.xml', + 'Geometry/HcalSimData/data/HcalProdCuts.xml', + 'Geometry/EcalSimData/data/EcalProdCuts.xml', + 'Geometry/TrackerSimData/data/PhaseII/BarrelEndcap5D/trackerProdCuts.xml', + 'Geometry/TrackerSimData/data/trackerProdCutsBEAM.xml', + 'Geometry/MuonSimData/data/muonProdCuts.xml', + 'Geometry/ForwardSimData/data/CastorProdCuts.xml', + 'Geometry/ForwardSimData/data/zdcProdCuts.xml', + 'Geometry/ForwardSimData/data/ForwardShieldProdCuts.xml', + 'Geometry/CMSCommonData/data/FieldParameters.xml'), + rootNodeName = cms.string('cms:OCMS') +) + + diff --git a/Geometry/HGCalCommonData/data/hgcalEE.xml b/Geometry/HGCalCommonData/data/hgcalEE.xml new file mode 100644 index 0000000000000..1aefbf9a8626f --- /dev/null +++ b/Geometry/HGCalCommonData/data/hgcalEE.xml @@ -0,0 +1,2553 @@ + + + + + + + + + + + + + + + 1, 30 + 31, 60 + 61, 90 + 91, 120 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0, 0, 3.331*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.3255*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.3145*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.309*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.3035*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.298*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2925*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.287*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2815*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.276*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2705*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.265*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2595*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.254*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.243*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2375*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.232*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2265*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.221*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2155*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.2045*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.199*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.1935*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.188*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.1825*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.177*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.1715*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.33282*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32733*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32183*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.31632*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.31083*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.30532*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.29983*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.29432*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.28883*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.28333*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.27782*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.27232*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.26682*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.26133*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.25582*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.25033*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.24483*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.23933*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.23382*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.22832*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.22283*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21732*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21183*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.20632*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.20083*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.19532*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.18982*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.18433*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.17882*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.17333*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.33332*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32782*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32233*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.31683*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.31133*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.30583*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.30032*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.29482*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.28932*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.28383*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.27833*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.27283*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.26733*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.26182*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.25632*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.25082*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.24533*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.23983*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.23433*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.22883*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.22332*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21782*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21232*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.20682*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.20132*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.19583*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.19033*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.18483*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.17932*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.17382*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.33425*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32875*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.32325*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.31775*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.31225*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.30675*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.30125*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.29575*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.29025*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.28475*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.27925*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.27375*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.26825*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.26275*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.25725*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.25175*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.24625*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.24075*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.23525*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.22975*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.22425*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21875*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.21325*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.20775*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.20225*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.19675*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.19125*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.18575*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.18025*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.17475*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/HGCalCommonData/data/hgcalHE.xml b/Geometry/HGCalCommonData/data/hgcalHE.xml new file mode 100644 index 0000000000000..5c405d13cf5a0 --- /dev/null +++ b/Geometry/HGCalCommonData/data/hgcalHE.xml @@ -0,0 +1,4449 @@ + + + + + + + + + + + + + + + + + + 1, 30 + 31, 60 + 61, 90 + 91, 120 + 121, 150 + 151, 180 + 181, 210 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0, 0, 5.179*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.119*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.059*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.999*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.939*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.879*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.819*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.759*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.699*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.639*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.579*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.519*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.459*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.399*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.339*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.279*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.219*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.159*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.099*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.039*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.979*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.919*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.859*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.799*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.739*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.679*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.619*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.559*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.499*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.439*m + 90*deg,90*deg,180*deg,0*deg,0*deg,90*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.209*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.149*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.089*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.029*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.969*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.909*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.849*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.789*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.729*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.669*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.609*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.549*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.489*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.429*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.369*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.309*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.249*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.189*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.129*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.069*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.009*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.949*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.889*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.829*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.769*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.709*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.649*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.589*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.529*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.469*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.206*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.146*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.086*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.026*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.966*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.906*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.846*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.786*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.726*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.666*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.606*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.546*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.486*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.426*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.366*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.306*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.246*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.186*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.126*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.066*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.006*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.946*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.886*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.826*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.766*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.706*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.646*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.586*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.526*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.466*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.2085*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.1485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.0885*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.0285*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.9685*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.9085*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.8485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.7885*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.7285*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.6685*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.6085*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.5485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.4885*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.4285*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.3685*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.3085*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.2485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.1885*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.1285*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.0685*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.0085*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.9485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.8885*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.8285*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.7685*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.7085*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.6485*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.5885*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.5285*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.4685*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.21003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.15003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.09003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.03003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.97003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.91003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.85003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.79003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.73003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.67003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.61003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.55003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.49003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.43003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.37003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.31003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.25003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.19003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.13003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.07003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.01003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.95003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.89003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.83003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.77003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.71003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.65003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.59003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.53003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.47003*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.21056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.15056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.09056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.03056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.97056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.91056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.85056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.79056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.73056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.67056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.61056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.55056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.49056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.43056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.37056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.31056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.25056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.19056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.13056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.07056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.01056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.95056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.89056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.83056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.77056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.71056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.65056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.59056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.53056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.47056*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.21203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.15203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.09203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 5.03203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.97203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.91203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.85203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.79203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.73203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.67203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.61203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.55203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.49203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.43203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.37203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.31203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.25203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.19203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.13203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.07203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 4.01203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.95203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.89203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.83203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.77203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.71203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.65203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.59203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.53203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,-264.962*deg,0*deg,0*deg,180*deg + + + + + + + + + + + 0, 0, 3.47203*m + 90*deg,90*deg,180*deg,0*deg,0*deg,84.9616*deg,0*deg,0*deg,180*deg + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/HGCalCommonData/data/shashlik.xml b/Geometry/HGCalCommonData/data/shashlik.xml new file mode 100644 index 0000000000000..1deecc8bdef21 --- /dev/null +++ b/Geometry/HGCalCommonData/data/shashlik.xml @@ -0,0 +1,73 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/MuonCommonData/data/v5/gemf.xml b/Geometry/MuonCommonData/data/v5/gemf.xml new file mode 100644 index 0000000000000..a64853d9437f4 --- /dev/null +++ b/Geometry/MuonCommonData/data/v5/gemf.xml @@ -0,0 +1,1151 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/MuonCommonData/data/v5/muonGemNumbering.xml b/Geometry/MuonCommonData/data/v5/muonGemNumbering.xml new file mode 100644 index 0000000000000..0a55dd35ce8c3 --- /dev/null +++ b/Geometry/MuonCommonData/data/v5/muonGemNumbering.xml @@ -0,0 +1,433 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h b/Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h index c4d98dfd97823..8a5d71ebf64cb 100644 --- a/Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h +++ b/Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h @@ -30,97 +30,91 @@ class StackedTrackerDetUnit; class GeomDet; class TrackerGeometry; -class StackedTrackerGeometry { -public: - typedef std::vector StackContainer; - typedef std::vector::const_iterator StackContainerIterator; - typedef std::vector StackIdContainer; - typedef std::vector::const_iterator StackIdContainerIterator; - typedef __gnu_cxx::hash_map< unsigned int, StackedTrackerDetUnit*> mapIdToStack; - - /// Constructors - StackedTrackerGeometry( const TrackerGeometry *i ); - StackedTrackerGeometry( const TrackerGeometry *i, const int partitionsPerRoc, const unsigned CBC3_Stubs ); - virtual ~StackedTrackerGeometry(); - - /// Methods for data members - const StackContainer& stacks() const { return theStacks; } - const StackIdContainer& stackIds() const { return theStackIds; } - void addStack( StackedTrackerDetUnit *aStack ); - const StackedTrackerDetUnit* idToStack( StackedTrackerDetId anId ) const; - - /// Analogous to the methods in TrackerGeomety except that you pass it a stack id and an identifier to a stack member - const GeomDetUnit* idToDetUnit( StackedTrackerDetId anId, unsigned int stackMemberIdentifier ) const; - const GeomDet* idToDet( StackedTrackerDetId anId, unsigned int stackMemberIdentifier ) const; - - /// Specific module properties - const bool isPSModule( StackedTrackerDetId anId ) const; - - /// Dedicated to CBC3 emulation - /// Everything is in half-strip units - const int getDetUnitWindow( StackedTrackerDetId anId ) const; - const int getASICOffset( StackedTrackerDetId anId, int asicNumber, int partitionNumber ) const; - int getPartitionsPerRoc() const { return theNumPartitions; } - unsigned getCBC3MaxStubs() const { return theMaxStubs; } - - /// Helper functions - Plane::PlanePointer meanPlane( StackedTrackerDetId anId ) const; - - /// Stub functions - /// OLD STYLE - template< typename T > - double findRoughPt( double aMagneticFieldStrength, const L1TkStub *stub) const; - template< typename T > - GlobalPoint findGlobalPosition( const L1TkStub *stub ) const; - template< typename T > - GlobalVector findGlobalDirection( const L1TkStub *stub ) const; - - /// Stub functions - /// NEW style - template< typename T > - double findRoughPt( double aMagneticFieldStrength, const TTStub *stub) const; - template< typename T > - GlobalPoint findGlobalPosition( const TTStub *stub ) const; - template< typename T > - GlobalVector findGlobalDirection( const TTStub *stub ) const; +class StackedTrackerGeometry +{ + public: + typedef std::vector< StackedTrackerDetUnit* > StackContainer; + typedef std::vector< StackedTrackerDetUnit* >::const_iterator StackContainerIterator; + typedef std::vector< StackedTrackerDetId > StackIdContainer; + typedef std::vector< StackedTrackerDetId >::const_iterator StackIdContainerIterator; + typedef __gnu_cxx::hash_map< unsigned int, StackedTrackerDetUnit* > mapIdToStack; + + /// Constructors + StackedTrackerGeometry( const TrackerGeometry *i ); + StackedTrackerGeometry( const TrackerGeometry *i, const int partitionsPerRoc, const unsigned CBC3_Stubs ); + virtual ~StackedTrackerGeometry(); + + /// Methods for data members + const StackContainer& stacks() const { return theStacks; } + const StackIdContainer& stackIds() const { return theStackIds; } + void addStack( StackedTrackerDetUnit *aStack ); + const StackedTrackerDetUnit* idToStack( StackedTrackerDetId anId ) const; + + /// Analogous to the methods in TrackerGeomety except that you pass it a stack id and an identifier to a stack member + const GeomDetUnit* idToDetUnit( StackedTrackerDetId anId, unsigned int stackMemberIdentifier ) const; + const GeomDet* idToDet( StackedTrackerDetId anId, unsigned int stackMemberIdentifier ) const; + + /// Association Detector/Module/Stack + DetId findPairedDetector( DetId anId ) const; + DetId findStackFromDetector( DetId anId ) const; + + /// Specific module properties + const bool isPSModule( StackedTrackerDetId anId ) const; + + /// Dedicated to CBC3 emulation + /// Everything is in half-strip units + const int getDetUnitWindow( StackedTrackerDetId anId ) const; + const int getASICOffset( StackedTrackerDetId anId, int asicNumber, int partitionNumber ) const; + int getPartitionsPerRoc() const { return theNumPartitions; } + unsigned getCBC3MaxStubs() const { return theMaxStubs; } + + /// Helper functions + Plane::PlanePointer meanPlane( StackedTrackerDetId anId ) const; + + /// Stub functions + /// OLD STYLE + template< typename T > double findRoughPt( double aMagneticFieldStrength, const L1TkStub *stub) const; + template< typename T > GlobalPoint findGlobalPosition( const L1TkStub *stub ) const; + template< typename T > GlobalVector findGlobalDirection( const L1TkStub *stub ) const; + + /// Stub functions + /// NEW style + template< typename T > double findRoughPt( double aMagneticFieldStrength, const TTStub *stub) const; + template< typename T > GlobalPoint findGlobalPosition( const TTStub *stub ) const; + template< typename T > GlobalVector findGlobalDirection( const TTStub *stub ) const; - /// Cluster functions - /// OLD STYLE - template< typename T > - LocalPoint findHitLocalPosition( const L1TkCluster *cluster , unsigned int hitIdx ) const; - template< typename T > - GlobalPoint findHitGlobalPosition( const L1TkCluster *cluster, unsigned int hitIdx ) const; - template< typename T > - LocalPoint findAverageLocalPosition( const L1TkCluster *cluster ) const; - template< typename T > - GlobalPoint findAverageGlobalPosition( const L1TkCluster *cluster ) const; - template< typename T > - void checkSimTrack( L1TkCluster *cluster, - edm::Handle > thePixelDigiSimLinkHandle, - edm::Handle simTrackHandle ) const; - - /// Cluster functions - /// NEW STYLE - template< typename T > - LocalPoint findHitLocalPosition( const TTCluster *cluster , unsigned int hitIdx ) const; - template< typename T > - GlobalPoint findHitGlobalPosition( const TTCluster *cluster, unsigned int hitIdx ) const; - template< typename T > - LocalPoint findAverageLocalPosition( const TTCluster *cluster ) const; - template< typename T > - GlobalPoint findAverageGlobalPosition( const TTCluster *cluster ) const; - -private: - - /// Data members - const TrackerGeometry* theTracker; - StackContainer theStacks; - StackIdContainer theStackIds; - mapIdToStack theMap; - - /// CBC3 dedicated stuff - int theNumPartitions; // Partitions per ROC for offset calculations as per CBC3 chip - unsigned theMaxStubs; // Maximum number of stubs per CBC3 chip; will need rethink when PS chip designed + /// Cluster functions + /// OLD STYLE + template< typename T > LocalPoint findHitLocalPosition( const L1TkCluster *cluster , unsigned int hitIdx ) const; + template< typename T > GlobalPoint findHitGlobalPosition( const L1TkCluster *cluster, unsigned int hitIdx ) const; + template< typename T > LocalPoint findAverageLocalPosition( const L1TkCluster *cluster ) const; + template< typename T > GlobalPoint findAverageGlobalPosition( const L1TkCluster *cluster ) const; + template< typename T > void checkSimTrack( L1TkCluster *cluster, + edm::Handle > thePixelDigiSimLinkHandle, + edm::Handle simTrackHandle ) const; + + /// Cluster functions + /// NEW STYLE + template< typename T > LocalPoint findHitLocalPosition( const TTCluster *cluster , unsigned int hitIdx ) const; + template< typename T > GlobalPoint findHitGlobalPosition( const TTCluster *cluster, unsigned int hitIdx ) const; + template< typename T > LocalPoint findAverageLocalPosition( const TTCluster *cluster ) const; + template< typename T > GlobalPoint findAverageGlobalPosition( const TTCluster *cluster ) const; + + private: + + /// Data members + const TrackerGeometry* theTracker; + StackContainer theStacks; + StackIdContainer theStackIds; + mapIdToStack theMap; + + /// Associative containers + std::map< DetId, DetId > mapDetectorsToPartner; + std::map< DetId, DetId > mapDetectorsToStack; + + /// CBC3 dedicated stuff + int theNumPartitions; // Partitions per ROC for offset calculations as per CBC3 chip + unsigned theMaxStubs; // Maximum number of stubs per CBC3 chip; will need rethink when PS chip designed }; @@ -129,15 +123,15 @@ class StackedTrackerGeometry { /// Cluster stuff /// OLD STYLE template<> - LocalPoint StackedTrackerGeometry::findHitLocalPosition( const L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, unsigned int hitIdx ) const; +LocalPoint StackedTrackerGeometry::findHitLocalPosition( const L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, unsigned int hitIdx ) const; template<> - GlobalPoint StackedTrackerGeometry::findHitGlobalPosition( const L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, unsigned int hitIdx ) const; +GlobalPoint StackedTrackerGeometry::findHitGlobalPosition( const L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, unsigned int hitIdx ) const; template<> - LocalPoint StackedTrackerGeometry::findHitLocalPosition( const L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, unsigned int hitIdx ) const; +LocalPoint StackedTrackerGeometry::findHitLocalPosition( const L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, unsigned int hitIdx ) const; template<> - void StackedTrackerGeometry::checkSimTrack( L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, - edm::Handle > thePixelDigiSimLinkHandle, - edm::Handle simTrackHandle ) const; +void StackedTrackerGeometry::checkSimTrack( L1TkCluster< edm::Ref< edm::PSimHitContainer > > *cluster, + edm::Handle > thePixelDigiSimLinkHandle, + edm::Handle simTrackHandle ) const; /// Fit Stub as in Builder /// To be used for out-of-Builder Stubs @@ -229,7 +223,7 @@ GlobalVector StackedTrackerGeometry::findGlobalDirection( const L1TkStub< T > *s { /// Add 0.5 to get the center of the pixel const GeomDetUnit* geomDetUnit = idToDetUnit( cluster->getDetId(), cluster->getStackMember() ); - T hit=cluster->getHits().at(hitIdx); + T hit = cluster->getHits().at(hitIdx); MeasurementPoint mp( hit->row() + 0.5, hit->column() + 0.5 ); return geomDetUnit->topology().localPosition( mp ); } @@ -241,7 +235,7 @@ GlobalVector StackedTrackerGeometry::findGlobalDirection( const L1TkStub< T > *s { /// Add 0.5 to get the center of the pixel const GeomDetUnit* geomDetUnit = idToDetUnit( cluster->getDetId(), cluster->getStackMember() ); - T hit=cluster->getHits().at(hitIdx); + T hit = cluster->getHits().at(hitIdx); MeasurementPoint mp( hit->row() + 0.5, hit->column() + 0.5 ); return geomDetUnit->surface().toGlobal( geomDetUnit->topology().localPosition( mp ) ); } @@ -368,8 +362,8 @@ double StackedTrackerGeometry::findRoughPt( double aMagneticFieldStrength, const double mPtFactor = (floor(aMagneticFieldStrength*10.0 + 0.5))/10.0*0.0015; /// Get average position of Clusters composing the Stub - GlobalPoint innerHitPosition = findAverageGlobalPosition( stub->getClusterPtr(0).get() ); - GlobalPoint outerHitPosition = findAverageGlobalPosition( stub->getClusterPtr(1).get() ); + GlobalPoint innerHitPosition = findAverageGlobalPosition( stub->getClusterRef(0).get() ); + GlobalPoint outerHitPosition = findAverageGlobalPosition( stub->getClusterRef(1).get() ); /// Get useful quantities double outerPointRadius = outerHitPosition.perp(); @@ -397,8 +391,8 @@ double StackedTrackerGeometry::findRoughPt( double aMagneticFieldStrength, const { /// Test approximated formula for Endcap stubs /// Check always to be consistent with HitMatchingAlgorithm_window2012.h - double roughPt = innerPointRadius * innerPointRadius * mPtFactor / fabs(findAverageLocalPosition( stub->getClusterPtr(0).get() ).x()) ; - roughPt += outerPointRadius * outerPointRadius * mPtFactor / fabs(findAverageLocalPosition( stub->getClusterPtr(1).get() ).x()) ; + double roughPt = innerPointRadius * innerPointRadius * mPtFactor / fabs(findAverageLocalPosition( stub->getClusterRef(0).get() ).x()) ; + roughPt += outerPointRadius * outerPointRadius * mPtFactor / fabs(findAverageLocalPosition( stub->getClusterRef(1).get() ).x()) ; roughPt = roughPt / 2.; /// Return the rough Pt @@ -415,15 +409,15 @@ template< typename T > GlobalPoint StackedTrackerGeometry::findGlobalPosition( const TTStub< T > *stub ) const { /// Fast version: only inner cluster matters - return findAverageGlobalPosition( stub->getClusterPtr(0).get() ); + return findAverageGlobalPosition( stub->getClusterRef(0).get() ); } template< typename T > GlobalVector StackedTrackerGeometry::findGlobalDirection( const TTStub< T > *stub ) const { /// Get average position of Clusters composing the Stub - GlobalPoint innerHitPosition = findAverageGlobalPosition( stub->getClusterPtr(0).get() ); - GlobalPoint outerHitPosition = findAverageGlobalPosition( stub->getClusterPtr(1).get() ); + GlobalPoint innerHitPosition = findAverageGlobalPosition( stub->getClusterRef(0).get() ); + GlobalPoint outerHitPosition = findAverageGlobalPosition( stub->getClusterRef(1).get() ); /// Calculate the direction GlobalVector directionVector( outerHitPosition.x()-innerHitPosition.x(), @@ -440,9 +434,21 @@ LocalPoint StackedTrackerGeometry::findHitLocalPosition( const TTCluster< T > *c { /// Add 0.5 to get the center of the pixel const GeomDetUnit* geomDetUnit = idToDetUnit( cluster->getDetId(), cluster->getStackMember() ); - T hit=cluster->getHits().at(hitIdx); + int row = 0; + int col = 0; - MeasurementPoint mp( hit->row() + 0.5, hit->column() + 0.5 ); + if ( cluster->getRows().size() == 0 || cluster->getCols().size() == 0 ) + { + T hit = cluster->getHits().at(hitIdx); + row = hit->row(); + col = hit->column(); + } + else + { + row = cluster->getRows().at(hitIdx); + col = cluster->getCols().at(hitIdx); + } + MeasurementPoint mp( row + 0.5, col + 0.5 ); return geomDetUnit->topology().localPosition( mp ); } @@ -453,9 +459,21 @@ GlobalPoint StackedTrackerGeometry::findHitGlobalPosition( const TTCluster< T > { /// Add 0.5 to get the center of the pixel const GeomDetUnit* geomDetUnit = idToDetUnit( cluster->getDetId(), cluster->getStackMember() ); - T hit=cluster->getHits().at(hitIdx); + int row = 0; + int col = 0; - MeasurementPoint mp( hit->row() + 0.5, hit->column() + 0.5 ); + if ( cluster->getRows().size() == 0 || cluster->getCols().size() == 0 ) + { + T hit = cluster->getHits().at(hitIdx); + row = hit->row(); + col = hit->column(); + } + else + { + row = cluster->getRows().at(hitIdx); + col = cluster->getCols().at(hitIdx); + } + MeasurementPoint mp( row + 0.5, col + 0.5 ); return geomDetUnit->surface().toGlobal( geomDetUnit->topology().localPosition( mp ) ); } diff --git a/Geometry/TrackerGeometryBuilder/src/StackedTrackerGeometry.cc b/Geometry/TrackerGeometryBuilder/src/StackedTrackerGeometry.cc index dcd6537b17ffc..cf32ee7dca167 100644 --- a/Geometry/TrackerGeometryBuilder/src/StackedTrackerGeometry.cc +++ b/Geometry/TrackerGeometryBuilder/src/StackedTrackerGeometry.cc @@ -27,11 +27,16 @@ StackedTrackerGeometry::StackedTrackerGeometry( const TrackerGeometry *i, StackedTrackerGeometry::~StackedTrackerGeometry() {} /// Methods for data members -void StackedTrackerGeometry::addStack(StackedTrackerDetUnit* aStack) +void StackedTrackerGeometry::addStack( StackedTrackerDetUnit* aStack ) { theStacks.push_back( aStack ); theStackIds.push_back( aStack->Id() ); - theMap.insert( std::make_pair(aStack->Id(),aStack) ); + theMap.insert( std::make_pair( aStack->Id(), aStack ) ); + + mapDetectorsToPartner.insert( std::make_pair( aStack->stackMember(0), aStack->stackMember(1) ) ); + mapDetectorsToPartner.insert( std::make_pair( aStack->stackMember(1), aStack->stackMember(0) ) ); + mapDetectorsToStack.insert( std::make_pair( aStack->stackMember(0), aStack->Id() ) ); + mapDetectorsToStack.insert( std::make_pair( aStack->stackMember(1), aStack->Id() ) ); } const StackedTrackerDetUnit* StackedTrackerGeometry::idToStack( StackedTrackerDetId anId ) const @@ -43,6 +48,25 @@ const StackedTrackerDetUnit* StackedTrackerGeometry::idToStack( StackedTrackerDe return NULL; } +/// Association Detector/Module/Stack +DetId StackedTrackerGeometry::findPairedDetector( DetId anId ) const +{ + if ( mapDetectorsToPartner.find( anId ) != mapDetectorsToPartner.end() ) + { + return mapDetectorsToPartner.find( anId )->second; + } + return DetId( 0x00000000 ); +} + +DetId StackedTrackerGeometry::findStackFromDetector( DetId anId ) const +{ + if ( mapDetectorsToStack.find( anId ) != mapDetectorsToStack.end() ) + { + return mapDetectorsToStack.find( anId )->second; + } + return DetId( 0x00000000 ); +} + /// CBC3 stuff const int StackedTrackerGeometry::getDetUnitWindow( StackedTrackerDetId anId ) const { diff --git a/Geometry/XMLTutorial/data/main.xml b/Geometry/XMLTutorial/data/main.xml new file mode 100644 index 0000000000000..5b7f8e8195bb6 --- /dev/null +++ b/Geometry/XMLTutorial/data/main.xml @@ -0,0 +1,36 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 0, 0, 0 + 0.*deg, 0.*deg, 180*deg, 90.*deg, 0.*deg, 90.*deg, 0.*deg, 0.*deg, 45.*deg + + + diff --git a/Geometry/XMLTutorial/python/dumpTutorialGeom_cfg.py b/Geometry/XMLTutorial/python/dumpTutorialGeom_cfg.py new file mode 100644 index 0000000000000..9e0e621d9ef5b --- /dev/null +++ b/Geometry/XMLTutorial/python/dumpTutorialGeom_cfg.py @@ -0,0 +1,32 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("DUMP") +process.load("Geometry.XMLTutorial.tutorial_cfi") +process.load("FWCore.MessageService.MessageLogger_cfi") + +process.MessageLogger = cms.Service("MessageLogger", + debugModules = cms.untracked.vstring('*'), + destinations = cms.untracked.vstring('cout'), + cout = cms.untracked.PSet + ( + threshold = cms.untracked.string('DEBUG'), + noLineBreaks = cms.untracked.bool(True) + ) + ) + +process.source = cms.Source("EmptySource") + +process.maxEvents = cms.untracked.PSet( + input = cms.untracked.int32(1) +) + +process.add_(cms.ESProducer("TGeoMgrFromDdd", + verbose = cms.untracked.bool(False), + level = cms.untracked.int32(14) +)) + +process.dump = cms.EDAnalyzer("DumpSimGeometry") + +process.p = cms.Path(process.dump) + + diff --git a/Geometry/XMLTutorial/python/tutorial_cfi.py b/Geometry/XMLTutorial/python/tutorial_cfi.py new file mode 100644 index 0000000000000..096bc662f2d21 --- /dev/null +++ b/Geometry/XMLTutorial/python/tutorial_cfi.py @@ -0,0 +1,12 @@ +import FWCore.ParameterSet.Config as cms + +XMLIdealGeometryESSource = cms.ESSource("XMLIdealGeometryESSource", + geomXMLFiles = cms.vstring('Geometry/CMSCommonData/data/materials.xml', + 'Geometry/CMSCommonData/data/rotations.xml', + 'Geometry/CMSCommonData/data/extend/cmsextent.xml', + 'Geometry/CMSCommonData/data/cms.xml', + 'Geometry/CMSCommonData/data/cmsMother.xml', + 'Geometry/XMLTutorial/data/main.xml' + ), + rootNodeName = cms.string('cms:OCMS') +) diff --git a/Geometry/XMLTutorial/tutorial.fwc b/Geometry/XMLTutorial/tutorial.fwc new file mode 100644 index 0000000000000..fab9077cf8d43 --- /dev/null +++ b/Geometry/XMLTutorial/tutorial.fwc @@ -0,0 +1,1171 @@ + + + + 2 + + + 0 + + + 1 + + + 0 + + + 50 + + + 90 + + + 1032 + + + 1033 + + + 1026 + + + 1017 + + + 1025 + + + 1022 + + + 1 + + + 50 + + + 3 + + + 1 + + + + + + edm::SortedCollection<CaloTower,edm::StrictWeakOrdering<CaloTower> > + + + towerMaker + + + + + + + + + $.emEt()>0.2 + + + 1008 + + + t + + + 2 + + + ECal + + + 0 + + + + + + + edm::SortedCollection<CaloTower,edm::StrictWeakOrdering<CaloTower> > + + + towerMaker + + + + + + + + + $.hadEt()+$.outerEt()>0.2 + + + 1005 + + + t + + + 2 + + + HCal + + + 0 + + + + + + + std::vector<reco::PFJet> + + + ak5PFJets + + + + + + + + + $.pt()>20 + + + 1000 + + + t + + + 3 + + + Jets + + + 0 + + + + + 0 + + + 0 + + + 2.1 + + + + + + + std::vector<reco::Track> + + + generalTracks + + + + + + + + + $.pt()>1 + + + 1009 + + + t + + + 1 + + + Tracks + + + 0 + + + + + + + std::vector<reco::Muon> + + + muons + + + + + + + + + $.isStandAloneMuon() + + + 1008 + + + t + + + 5 + + + Muons + + + 0 + + + + + + + std::vector<reco::GsfElectron> + + + gsfElectrons + + + + + + + + + $.hadronicOverEm()<0.05 + + + 1007 + + + t + + + 3 + + + Electrons + + + 0 + + + + + + + std::vector<reco::Vertex> + + + offlinePrimaryVertices + + + + + + + + + + + + 1000 + + + t + + + 10 + + + Vertices + + + 0 + + + + + 0 + + + 0 + + + 3 + + + + + + + reco::BeamSpot + + + offlineBeamSpot + + + + + + + + + + + + 1002 + + + t + + + 12 + + + Beam Spot + + + 0 + + + + + + + edm::RangeMap<DTChamberId,edm::OwnVector<DTRecSegment4D,edm::ClonePolicy<DTRecSegment4D> >,edm::ClonePolicy<DTRecSegment4D> > + + + dt4DSegments + + + + + + + + + + + + 1005 + + + t + + + 1 + + + DT-segments + + + 0 + + + + + + + edm::RangeMap<CSCDetId,edm::OwnVector<CSCSegment,edm::ClonePolicy<CSCSegment> >,edm::ClonePolicy<CSCSegment> > + + + cscSegments + + + + + + + + + + + + 1005 + + + t + + + 1 + + + CSC-segments + + + 0 + + + + + + + std::vector<reco::Photon> + + + photons + + + + + + + + + hadronicOverEm < 0.2 + + + 1009 + + + t + + + 1 + + + Photons + + + 0 + + + + + + + std::vector<reco::MET> + + + tcMet + + + + + + + + + et()>20 + + + 1008 + + + t + + + 11 + + + recoMET + + + 0 + + + + + + + std::vector<reco::Conversion> + + + conversions + + + + + + + + + + + + 1016 + + + t + + + 13 + + + Conversions + + + 0 + + + + + + + + + + $Tracks.pt()>1 + + + 1 + + + + + + + + $Jets.pt()>100 + + + 0 + + + + + + + + $Muons@.size()>3 + + + 0 + + + + + + + + HLT_Mu9 + + + 0 + + + + + + HLT + + + + + 1 + + + 0 + + + + + + 32 + + + 47 + + + 1081 + + + 805 + + + 0.0911815 + + + 0.983784 + + + 1.01622 + + + + + + 1 + + + 0 + + + 0 + + + 0 + + + 1 + + + 0 + + + 1 + + + 1 + + + 1 + + + 0 + + + 1 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0.03 + + + 0.05 + + + 0.95 + + + 0.2 + + + 0.02 + + + 0.98 + + + 1 + + + 50 + + + 3 + + + 1 + + + 0.434711 + + + -0.775731 + + + 0.457456 + + + 0 + + + 0.872362 + + + 0.488862 + + + 0 + + + 0 + + + -0.223633 + + + 0.399068 + + + 0.889232 + + + 0 + + + 87937.2 + + + -156922 + + + 92538.3 + + + 1 + + + -1 + + + 0 + + + 0 + + + 0 + + + 0 + + + -0 + + + 1 + + + 0 + + + 0 + + + 1 + + + 0 + + + 0 + + + 0 + + + 0 + + + 0 + + + 1 + + + 0.149144 + + + + + -1 + + + 1 + + + 1 + + + 0 + + + + + + 1 + + + 3 + + + 1 + + + + + + + + + -1 + + + 1 + + + 1 + + + /cms:World_1/cms:CMSE_1 + + + 0.08 + + + 1 + + + 1 + + + 1 + + + 1 + + + + + + + + + + + 0.983784 + + + 0 + + + + + 1 + + + 0 + + + + + 1 + + + 0 + + + + + + + + + + + id + detid.rawId + 0 + energy + energy + 3 + time + time + 3 + flags + flags + 0 + + + emEt + emEt + 1 + hadEt + hadEt + 1 + et + et + 1 + eta + eta + 3 + phi + phi + 3 + + + number of segments + size + 0 + + + number of segments + size + 0 + + + Pt + pt + 1 + eta + eta + 3 + phi + phi + 3 + ECAL + p4().E() * emEnergyFraction() + 1 + HCAL + p4().E() * energyFractionHadronic() + 1 + emf + emEnergyFraction() + 3 + size_eta + sqrt(etaetaMoment) + 3 + size_phi + sqrt(phiphiMoment) + 3 + + + pT + pt + 1 + eta + eta + 3 + phi + phi + 3 + status + status + 0 + pdgId + pdgId + 0 + + + pT + pt + 1 + eta + eta + 3 + phi + phi + 3 + E/p + eSuperClusterOverP + 3 + H/E + hadronicOverEm + 3 + fbrem + (trackMomentumAtVtx().R() - trackMomentumOut().R()) / trackMomentumAtVtx().R() + 3 + dei + deltaEtaSuperClusterTrackAtVtx() + 3 + dpi + deltaPhiSuperClusterTrackAtVtx() + 3 + charge + charge + 0 + + + pT + pt + 1 + eta + eta + 3 + phi + phi + 3 + + + MET + et + 1 + phi + phi + 3 + sumEt + sumEt + 1 + mEtSig + mEtSig + 3 + + + pT + pt + 1 + global + isGlobalMuon + -2 + tracker + isTrackerMuon + -2 + SA + isStandAloneMuon + -2 + calo + isCaloMuon + -2 + tr pt + track().pt() + 1 + eta + eta + 3 + phi + phi + 3 + matches + numberOfMatches('SegmentArbitration') + 0 + d0 + track().d0() + 3 + d0 / d0Err + track().d0() / track().d0Error() + 3 + charge + charge + 0 + + + pT + pt + 1 + eta + eta + 3 + phi + phi + 3 + H/E + hadronicOverEm + 3 + + + pT + pt + 1 + eta + eta + 3 + phi + phi + 3 + d0 + d0 + 5 + d0Err + d0Error + 5 + dz + dz + 5 + dzErr + dzError + 5 + vx + vx + 5 + vy + vy + 5 + vz + vz + 5 + pixel hits + hitPattern().numberOfValidPixelHits() + 0 + strip hits + hitPattern().numberOfValidStripHits() + 0 + chi2 + chi2 + 3 + ndof + ndof + 0 + charge + charge + 0 + + + x + x + 5 + xError + xError + 5 + y + y + 5 + yError + yError + 5 + z + z + 5 + zError + zError + 5 + tracks + tracksSize + 0 + chi2 + chi2 + 3 + ndof + ndof + 3 + + + CaloRecHit + CaloTower + edm::RangeMap<CSCDetId,edm::OwnVector<CSCSegment,edm::ClonePolicy<CSCSegment> >,edm::ClonePolicy<CSCSegment> > + edm::RangeMap<DTChamberId,edm::OwnVector<DTRecSegment4D,edm::ClonePolicy<DTRecSegment4D> >,edm::ClonePolicy<DTRecSegment4D> > + reco::CaloJet + reco::GenParticle + reco::GsfElectron + reco::Jet + reco::MET + reco::Muon + reco::Photon + reco::Track + reco::Vertex + + + + + diff --git a/L1Trigger/TrackFindingAM/BuildFile.xml b/L1Trigger/TrackFindingAM/BuildFile.xml new file mode 100644 index 0000000000000..4bbcfa11fc285 --- /dev/null +++ b/L1Trigger/TrackFindingAM/BuildFile.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/L1Trigger/TrackFindingAM/interface/CMSPatternLayer.h b/L1Trigger/TrackFindingAM/interface/CMSPatternLayer.h new file mode 100644 index 0000000000000..c4fd06b285ad0 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/CMSPatternLayer.h @@ -0,0 +1,148 @@ +#ifndef _CMSPATTERNLAYER_H_ +#define _CMSPATTERNLAYER_H_ + +#include +#include +#include +#include "PatternLayer.h" + +#include +#include + +using namespace std; + + +/** + \brief First version of a CMS pattern structure +**/ + +class CMSPatternLayer : public PatternLayer{ + private: + static const short MOD_START_BIT = 11; + static const short PHI_START_BIT = 7; + static const short STRIP_START_BIT = 1; + static const short SEG_START_BIT = 0; + + static const short MOD_MASK = 0x1F; + static const short PHI_MASK = 0xF; + static const short STRIP_MASK = 0x3F; + static const short SEG_MASK = 0x1; + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const//const boost::serialization::version_type& version) const + { + ar << boost::serialization::base_object(*this); + } + + template void load(Archive & ar, const unsigned int version) + { + ar >> boost::serialization::base_object(*this); + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + CMSPatternLayer(); + CMSPatternLayer* clone(); + vector getSuperStrip(int l, const vector& ladd, const map >& modules, Detector& d); + + /** + \brief Set the values in the patternLayer + \param m The module Z position (0 to 13 for modules 23 to 47) + \param phi The phi position of the module in the sector (0 to 7) + \param strip The super strip number + \param seg The segment in the module (0 or 1) + **/ + void setValues(short m, short phi, short strip, short seg); + /** + \brief Returns a string representation of the PatternLayer + \return A string describing the PatternLayer + **/ + string toString(); + /** + \brief Returns the module's Z position + \return The module's Z position + **/ + short getModule(); + /** + \brief Returns the ladder phi position + \return The ladder's phi position + **/ + short getPhi(); + /** + \brief Returns the Super strip position + \return The position of the super strip in the segment + **/ + short getStrip(); + /** + \brief Returns the position of the segment in the module + \return The segment's position in the module (0 or 1) + **/ + short getSegment(); + + /** + \brief Returns the list of layers IDs in the detector + \return a vector containing the layer IDs + **/ + static vector getLayerIDs(); + + /** + \brief Returns the number of strips in a segment + \return an int value + **/ + static int getNbStripsInSegment(); + + /** + \brief Get the ID of the ladder from the ladder ID in the muon file. Used to change the IDs between the root file and the simulation program (if needed). + \brief After a call to this method, ladders numbering must start at 0 + \param layerID The layer ID (TIB : 5,6,7 - TOB : 8,9,10 - TEC : 11,12,13,14,15,16,17 and 18,19,20,21,22,23,24) + \param ladderID The ladder ID in the muon file + \return The ID to use in the program + **/ + static int getLadderCode(int layerID, int ladderID); + + /** + \brief Get the ID of the module from the module ID in the muon file. Used to change the IDs between the root file and the simulation program (if needed). + \brief This method allows to change the module resolution (you can divide the ID by 2) or the numbering. + \brief After a call to this method, modules numbering must start at 0 + \param layerID The layer ID (TIB : 5,6,7 - TOB : 8,9,10 - TEC : 11,12,13,14,15,16,17 and 18,19,20,21,22,23,24) + \param moduleID The module ID in the muon file + \return The ID to use in the program + **/ + static int getModuleCode(int layerID, int moduleID); + + /** + \brief Get the code of the segment in the patternLayer from the segment ID in the muon file + \brief Segment ID must be 0 or 1 + \param layerID The layer ID (TIB : 5,6,7 - TOB : 8,9,10 - TEC : 11,12,13,14,15,16,17 and 18,19,20,21,22,23,24) + \param ladderID The ladder ID in the muon file + \param segmentID The segment ID in the muon file + \return The number to use in the simulation program + **/ + static int getSegmentCode(int layerID, int ladderID, int segmentID); + + /** + \brief Gives the number of ladders in the detector for a given layer + \param layerID The layer ID + \return The number of ladders on the layer layerID + **/ + static int getNbLadders(int layerID); + + /** + \brief Gives the number of modules in the detector for a given layer/ladder + \param layerID The layer ID + \param ladderID The ladder ID + \return The number of modules on the layer layerID / ladder ladderID + **/ + static int getNbModules(int layerID, int ladderID); + + /** + \brief Returns a map containing the valid ETA range for each layer + \return For each layerID, gives the minimum and maximum ETA values + **/ + static map > getLayerDefInEta(); + +}; + +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Detector.h b/L1Trigger/TrackFindingAM/interface/Detector.h new file mode 100644 index 0000000000000..ebb978d8954f3 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Detector.h @@ -0,0 +1,73 @@ +#ifndef _DETECTOR_H_ +#define _DETECTOR_H_ + +#include "Layer.h" +#include + + +/** + \brief Representation of a detector. + A detector is made of layers->ladders->modules->segments->superStrips +**/ +class Detector{ + + private: + vector layers; + vector layerNumber; + SuperStrip* dump;//used for fake superstrips in the patterns + + int getLayerPosition(int pos); + + public: + /** + \brief Constructor. + Creates an empty detector (no layer). + **/ + Detector(); + /** + \brief Add a new layer to the detector + \param lNum The id of the layer (ie 10 for the outermost layer) + \param nbLad Number of ladders in the layer + \param nbMod Number of modules for each ladder + \param segmentSize Number of strips in each segment + \param sstripSize Size of a superStrip (number of strips) + **/ + void addLayer(int lNum, int nbLad, int nbMod, int segmentSize, int sstripSize); + /** + \brief Destructor + Delete all layers. + **/ + ~Detector(); + /** + \brief Get one of the detector's layers + \param pos The id of the layer (ie 10 for the outermost layer) + \return A pointer on the Layer object (not a copy), NULL if nothing found. + **/ + Layer* getLayer(int pos); + /** + \brief Get one of the detector's layers + \param pos The position of the layer in the detector(layer num 0, layer num 1, ...) + \return A pointer on the Layer object (not a copy), NULL if nothing found. + **/ + Layer* getLayerFromAbsolutePosition(int pos); + /** + \brief Actives the super strip corresponding tho the given hit in the detector + \param h A hit + **/ + void receiveHit(const Hit& h); + /** + \brief Desactivates all superstrips in the detector + **/ + void clear(); + /** + Get the current number of layes in the detector + \return The number of layers + **/ + int getNbLayers(); + /** + Get the dump superstrip (used for fake superstrips in patterns) + **/ + SuperStrip* getDump(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/FitParams.h b/L1Trigger/TrackFindingAM/interface/FitParams.h new file mode 100644 index 0000000000000..4185be656f8cd --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/FitParams.h @@ -0,0 +1,142 @@ +#ifndef _FITPARAMS_H_ +#define _FITPARAMS_H_ + +#include +#include +#include "TPrincipal.h" +#include "TMultiDimFit.h" +#include "MultiDimFitData.h" +#include "Track.h" + +#include +#include +//#include +//#include + +using namespace std; + +/** + \brief Parameters needed for Principal Components Analysis fit in a sub-sector (PCA+MultiDimFit params) +**/ + +class FitParams{ + + private: + + int nb_layers; + int threshold; + int nb_principal; + int nb_multidimfit; + + TPrincipal* principal; + vector eigen; + vector mean; + vector sig; + double** transform; + + TMultiDimFit* pt_fit; + MultiDimFitData* pt_fit_data; + TMultiDimFit* phi0_fit; + MultiDimFitData* phi0_fit_data; + TMultiDimFit* d0_fit; + MultiDimFitData* d0_fit_data; + TMultiDimFit* eta0_fit; + MultiDimFitData* eta0_fit_data; + TMultiDimFit* z0_fit; + MultiDimFitData* z0_fit_data; + + void computePrincipalParams(); + void computeMultiDimFitParams(); + void initializeMultiDimFit(TMultiDimFit* f); + void init(); + double getPTFitValue(double* val); + double getPhi0FitValue(double* val); + double getD0FitValue(double* val); + double getEta0FitValue(double* val); + double getZ0FitValue(double* val); + + public: + FitParams(); + FitParams(const FitParams& ref); + FitParams(int n_layers, int thresh); + ~FitParams(); + void addDataForPrincipal(double* d); + bool hasPrincipalParams(); + void forcePrincipalParamsComputing(); + void addDataForMultiDimFit(double* d, double* val); + bool hasMultiDimFitParams(); + void forceMultiDimFitParamsComputing(); + void x2p(double *x, double *p); + double get_chi_square(double *x, double p); + Track* getTrack(double* val); + int getNbPrincipalTracks(); + int getNbMultiDimFitTracks(); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << nb_layers; + ar << threshold; + if(nb_principal>threshold) + ar << nb_principal; + else{ // if the parametrization is not done we will have to start again from scratch + int tmp = 0; + ar << tmp; + } + ar << eigen; + ar << sig; + ar << mean; + for(int i=0;ithreshold){ + ar << nb_multidimfit; + ar << pt_fit_data; + ar << phi0_fit_data; + ar << d0_fit_data; + ar << eta0_fit_data; + ar << z0_fit_data; + } + else{ // if the fit parameters computing is not done we will have to start again from scratch + int tmp = 0; + ar << tmp; + } + } + + template void load(Archive & ar, const unsigned int version){ + ar >> nb_layers; + //init(); + ar >> threshold; + ar >> nb_principal; + ar >> eigen; + ar >> sig; + ar >> mean; + for(int i=0;i> transform[i][j]; + } + } + principal = NULL; + ar >> nb_multidimfit; + if(nb_multidimfit>threshold){ // restauration des parametres de FIT + ar >> pt_fit_data; + ar >> phi0_fit_data; + ar >> d0_fit_data; + ar >> eta0_fit_data; + ar >> z0_fit_data; + } + else{ + pt_fit_data=NULL; + phi0_fit_data=NULL; + d0_fit_data=NULL; + eta0_fit_data=NULL; + z0_fit_data=NULL; + } + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/GradedPattern.h b/L1Trigger/TrackFindingAM/interface/GradedPattern.h new file mode 100644 index 0000000000000..062ea11c3cd7b --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/GradedPattern.h @@ -0,0 +1,72 @@ +#ifndef _GRADEDPATTERN_H_ +#define _GRADEDPATTERN_H_ + +#include "Pattern.h" + +#include + +using namespace std; + +/** + \brief A Pattern wih a grade (the number of tracks corresponding to this pattern). + Can also contain (optionnaly) the average Pt of the tracks +**/ + +class GradedPattern : public Pattern{ + public: + /** + \brief Constructor + **/ + GradedPattern(); + /** + \brief Copy Constructor + **/ + GradedPattern(const Pattern& p); + /** + \brief Get the grade of the Pattern + \return The number of tracks having generated the pattern + **/ + int getGrade() const; + /** + \brief Get the average Pt of the tracks having generated the pattern (if used) + \return The average Pt + **/ + float getAveragePt() const; + /** + Increment the grade (tracks occurences + 1) + **/ + void increment(); + /** + Increment the grade (tracks occurences + 1) and add a Pt value to the average Pt + @param pt The Pt value of the last track + **/ + void increment(float pt); + /** + \brief Allows to compare 2 patterns on their grade + \param gp The second pattern + \return -1 if the pattern has a lower grade + **/ + int operator<(const GradedPattern& gp); + + private: + int grade; + float averagePt; + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << boost::serialization::base_object(*this); + ar << grade; + ar << averagePt; + } + + template void load(Archive & ar, const unsigned int version){ + ar >> boost::serialization::base_object(*this); + ar >> grade; + ar >> averagePt; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Hit.h b/L1Trigger/TrackFindingAM/interface/Hit.h new file mode 100644 index 0000000000000..2784c2a8826d7 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Hit.h @@ -0,0 +1,152 @@ +#ifndef _HIT_H_ +#define _HIT_H_ +#include +#include +using namespace std; + +/** + \brief A hit in the detector +**/ +class Hit{ + + private : + char layer; + char ladder; + char zPos; + char segment; + short stripNumber; + short stub_idx; + int part_id; + float part_pt; + float part_ip; + float part_eta; + float part_phi0; + float x; + float y; + float z; + float X0; + float Y0; + float Z0; + + + + public : + /** + \brief Constructor + \param l The layer of the hit + \param lad The ladder of the hit + \param zp The Z position of the module + \param seg The segment of the hit in the module + \param strip The strip touched + \param idx The index of the stub creating this hit + \param tp The belonging particule's ID (used to check efficiency) + \param pt The belonging particule's PT (used to check efficiency) + \param ip Distance between particule's origine and interaction point + \param eta The belonging particule's ETA + \param phi0 The belonging particule's PHI0 + \param p_x The X coordinate of the hit in the tracker + \param p_y The Y coordinate of the hit in the tracker + \param p_z The Z coordinate of the hit in the tracker + \param p_x0 The X0 coordinate of the hit in the tracker + \param p_y0 The Y0 coordinate of the hit in the tracker + \param p_z0 The Z0 coordinate of the hit in the tracker + **/ + Hit(char l, char lad, char zp, char seg, short strip, short idx, int tp, float pt, float ip, float eta, float phi0, float p_x, float p_y, float p_z, float p_x0, float p_y0, float p_z0); + /** + \brief The copy Constructor + **/ + Hit(const Hit& h); + /** + \brief Get the layer of the hit + \return The layer of the Hit + **/ + char getLayer() const; + /** + \brief Get the ladder of the hit + \return The ladder of the Hit + **/ + char getLadder() const; + /** + \brief Get the Z position of the module of the hit + \return The position of the module + **/ + char getModule() const; + /** + \brief Get the segment of the hit + \return The segment of the Hit + **/ + char getSegment() const; + /** + \brief Get the strip position of the hit + \return The strip of the Hit + **/ + short getStripNumber() const; + /** + \brief Get the ID of the hit in the event + \return The ID of the Hit + **/ + short getID() const; + /** + \brief Get the original particule ID of the hit + \return The particule ID of the Hit + **/ + int getParticuleID() const; + /** + \brief Get the original particule PT of the hit + \return The particule's PT of the Hit + **/ + float getParticulePT() const; + /** + \brief Get the distance between particule's origine and IP + \return The distance in 0,1 mm + **/ + float getParticuleIP() const; + /** + \brief Get the eta value of the original particule + \return The Eta value + **/ + float getParticuleETA() const; + /** + \brief Get the PHI0 value of the original particule + \return The PHI0 value + **/ + float getParticulePHI0() const; + /** + \brief Get the X coordinate of the hit + \return The distance in cm + **/ + float getX() const; + /** + \brief Get the Y coordinate of the hit + \return The distance in cm + **/ + float getY() const; + /** + \brief Get the Z coordinate of the hit + \return The distance in cm + **/ + float getZ() const; + /** + \brief Get the X0 of the hit + \return The value as a float + **/ + float getX0() const; + /** + \brief Get the Y0 of the hit + \return The value as a float + **/ + float getY0() const; + /** + \brief Get the Z0 of the hit + \return The value as a float + **/ + float getZ0() const; + + + /** + \brief Allows to display a Hit as a string + **/ + friend ostream& operator<<(ostream& out, const Hit& h); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/HoughFitter.h b/L1Trigger/TrackFindingAM/interface/HoughFitter.h new file mode 100644 index 0000000000000..eebe6b53191d0 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/HoughFitter.h @@ -0,0 +1,55 @@ +#ifndef _HOUGHFITTER_H_ +#define _HOUGHFITTER_H_ + +#include "TrackFitter.h" +#include "HoughLocal.h" +#include +#include + +#include +#include + +/** + \brief Implementation of a Hough fitter +**/ +class HoughFitter:public TrackFitter{ + + private: + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const + { + cout<<"sauvegarde du HoughFitter"<(*this); + ar << sec_phi; + } + + template void load(Archive & ar, const unsigned int version) + { + cout<<"chargement de HoughFitter"<> boost::serialization::base_object(*this); + ar >> sec_phi; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + /** + \brief Default constructor + **/ + HoughFitter(); + /** + \brief Constructor + \param nb Layers number + **/ + HoughFitter(int nb); + ~HoughFitter(); + + void initialize(); + void mergePatterns(); + void mergeTracks(); + void fit(); + TrackFitter* clone(); +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/HoughLocal.h b/L1Trigger/TrackFindingAM/interface/HoughLocal.h new file mode 100644 index 0000000000000..68f67db038124 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/HoughLocal.h @@ -0,0 +1,55 @@ +#ifndef _HOUGHLOCAL_H + +#define _HOUGHLOCAL_H +#include +#include +#include +//#include +#define PI 3.141592653589793 +class RecoPoint; +class HoughLocal +{ +public: + + HoughLocal(double thmin,double thmax,double rmin,double rmax,uint32_t nbintheta=8,uint32_t nbinr=8); + ~HoughLocal(); + void fill(double x,double y); + void clear(); + double getTheta(int32_t i); + double getR(int32_t i); + uint16_t getValue(uint32_t i,uint32_t j); + void findMaxima(std::vector< std::pair >& maxval,uint32_t cut=3); + void findMaxima(std::vector< std::pair >& maxval,uint32_t cut=3); + void findMaximumBins(std::vector< std::pair >& maxval,uint32_t cut); + void findThresholdBins(std::vector< std::pair >& maxval,uint32_t cut); + + // void draw(DCHistogramHandler* h,std::vector< std::pair > *maxval=NULL); + // void draw(DCHistogramHandler* h,std::vector< std::pair > *maxval); + uint32_t getVoteMax(); + double getThetaBin(){return theThetaBin_;} + double getRBin(){return theRBin_;} + double getThetaMin(){return theThetaMin_;} + double getRMin(){return theRMin_;} + double getThetaMax(){return theThetaMax_;} + double getRMax(){return theRMax_;} + uint32_t getNbinTheta(){ return theNbinTheta_;} + uint32_t getNbinR(){ return theNbinR_;} + static void PrintConvert(double theta,double r); +private: + double theSin_[1024]; + double theCos_[1024]; + std::vector theX_; + std::vector theY_; + uint16_t theHoughImage_[1024][1024]; + double theThetaMin_; + double theThetaMax_; + double theRMin_,theRMax_; + double theThetaBin_,theRBin_; + uint32_t theNbinTheta_; + uint32_t theNbinR_; + uint16_t theVoteMax_; +}; + + + +#endif diff --git a/L1Trigger/TrackFindingAM/interface/KarimakiTrackFitter.h b/L1Trigger/TrackFindingAM/interface/KarimakiTrackFitter.h new file mode 100644 index 0000000000000..4c69be57b42f9 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/KarimakiTrackFitter.h @@ -0,0 +1,55 @@ +#ifndef _KARIMAKITRACKFITTER_H_ +#define _KARIMAKITRACKFITTER_H_ + +#include "TrackFitter.h" +#include + +#include +#include + +/** + \brief Implementation of a Karimaki fitter +**/ +class KarimakiTrackFitter:public TrackFitter{ + + private: + + void fitPattern(Pattern* p); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const//const boost::serialization::version_type& version) const + { + cout<<"sauvegarde du KarimakiTrackFitter"<(*this); + ar << sec_phi; + } + + template void load(Archive & ar, const unsigned int version) + { + cout<<"chargement de KarimakiTrackFitter"<> boost::serialization::base_object(*this); + ar >> sec_phi; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + /** + \brief Default constructor + **/ + KarimakiTrackFitter(); + /** + \brief Constructor + \param nb Layers number + **/ + KarimakiTrackFitter(int nb); + ~KarimakiTrackFitter(); + + void initialize(); + void mergePatterns(); + void mergeTracks(); + void fit(); + TrackFitter* clone(); +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Ladder.h b/L1Trigger/TrackFindingAM/interface/Ladder.h new file mode 100644 index 0000000000000..58f3258fa73a6 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Ladder.h @@ -0,0 +1,39 @@ +#ifndef _LADDER_H_ +#define _LADDER_H_ + +#include "Module.h" +#include + +/** + \brief Representation of a Ladder (vector of modules) +**/ +class Ladder{ + + private: + vector modules; + + public: + /** + \brief Constructor + \param nbMod Number of modules in the ladder + \param segmentSize Number of strips in a segment + \param sstripSize Number of strips in a super strip + **/ + Ladder(int nbMod, int segmentSize, int sstripSize); + /** + \brief Destructor + **/ + ~Ladder(); + /** + \brief Retrieves a module from the ladder + \param zPos Position of the module in the ladder (0 to N) + \return Returns a pointer on the module (not a copy), NULL if not found. + **/ + Module* getModule(int zPos); + /** + Desactivates all the superstrips of the module + **/ + void clear(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Layer.h b/L1Trigger/TrackFindingAM/interface/Layer.h new file mode 100644 index 0000000000000..a52d60535f8a3 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Layer.h @@ -0,0 +1,40 @@ +#ifndef _LAYER_H_ +#define _LAYER_H_ + +#include "Ladder.h" +#include + +/** + \brief Represents a Layer (vector of Ladders) +**/ +class Layer{ + + private: + vector ladders; + + public: + /** + \brief Constructor + \param nbLad Number of ladders on this layer + \param nbMod Number of modules on each ladder + \param segmentSize Number of strips in a segment + \param sstripSize Number of strips in a super strip + **/ + Layer(int nbLad, int nbMod, int segmentSize, int sstripSize); + /** + \brief Destructor + **/ + ~Layer(); + /** + \brief Get one of the ladders + \param pos The ladder ID starting from 0. + \return A pointer on the Ladder object (not a copy), NULL if not found. + **/ + Ladder* getLadder(int pos); + /** + \brief Desactivates all the superstrips in the layer. + **/ + void clear(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Module.h b/L1Trigger/TrackFindingAM/interface/Module.h new file mode 100644 index 0000000000000..6c8b15308aaea --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Module.h @@ -0,0 +1,38 @@ +#ifndef _MODULE_H_ +#define _MODULE_H_ + +#include "Segment.h" +#include + +/** +\brief Representation of a Module (2 segments) +**/ +class Module{ + + private: + Segment* segments[2]; + + public: + /** + \brief Constructor + \param segmentSize Number of strips in a segment + \param sstripSize Number of strips in a super strip + **/ + Module(int segmentSize, int sstripSize); + /** + \brief Destructor + **/ + ~Module(); + /** + \brief Retrieves on of the segment in the module + \param n The position of the segment (0 or 1). + \return A pointer on the Segment (not a copy), NULL if not found. + **/ + Segment* getSegment(int n); + /** + \brief Desactivates all the super strips in the module + **/ + void clear(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/MultiDimFitData.h b/L1Trigger/TrackFindingAM/interface/MultiDimFitData.h new file mode 100644 index 0000000000000..efd1929293b5c --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/MultiDimFitData.h @@ -0,0 +1,122 @@ +#ifndef _MULTIDIMFITDATA_H_ +#define _MULTIDIMFITDATA_H_ + +#include +#include "TMultiDimFit.h" + +#include + +using namespace std; + +/** + \brief Parameters needed for the MultiDimFit in a sub-sector +**/ + +class MultiDimFitData{ + private: + int gNVariables; + int gNCoefficients; + int gNMaxTerms; + int gNMaxFunctions; + double gDMean; + + int nb_layers; + + double *gXMin; + double *gXMax; + double *gCoefficient; + int *gPowerIndex; + int *gPower; + double *m_final_coeffs; + + public: + MultiDimFitData(TMultiDimFit* m, int nb); + MultiDimFitData(); + MultiDimFitData(const MultiDimFitData&); + ~MultiDimFitData(); + + double getVal(double *x); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + + ar << gNVariables; + ar << gNCoefficients; + ar << gDMean; + ar << gNMaxTerms; + ar << gNMaxFunctions; + ar << nb_layers; + + for(int i=0;i void load(Archive & ar, const unsigned int version){ + ar >> gNVariables; + ar >> gNCoefficients; + ar >> gDMean; + ar >> gNMaxTerms; + ar >> gNMaxFunctions; + ar >> nb_layers; + + gXMin = new double[gNVariables]; + for(int i=0;i> gXMin[i]; + } + + gXMax = new double[gNVariables]; + for(int i=0;i> gXMax[i]; + } + + gCoefficient = new double[gNCoefficients]; + for(int i=0;i> gCoefficient[i]; + } + + gPowerIndex = new int[gNMaxTerms]; + for(int i=0;i> gPowerIndex[i]; + } + + gPower = new int[gNVariables*gNMaxFunctions]; + for(int i=0;i> gPower[i]; + } + + int size = ((nb_layers-1)*3)+1; + m_final_coeffs = new double[size]; + for(int i=0;i> m_final_coeffs[i]; + } + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + +}; + +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Pattern.h b/L1Trigger/TrackFindingAM/interface/Pattern.h new file mode 100644 index 0000000000000..419321d9a6bb2 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Pattern.h @@ -0,0 +1,124 @@ +#ifndef _PATTERN_H_ +#define _PATTERN_H_ + +#include +#include +#include +#include "SuperStrip.h" +#include "PatternLayer.h" +#include "Detector.h" + +#include +#include + +using namespace std; + +/** + \brief A Pattern contains one PatternLayer per layer +**/ + +class Pattern{ + + public: + + /** + \brief Constructor + \param nb The number of layers + **/ + Pattern(int nb); + /** + \brief Default Constructor + **/ + Pattern(); + /** + \brief Copy constructor. The patternLayers are copied, the superstrips are copies of pointers (not real copies). + \param p The pattern to copy + **/ + Pattern(const Pattern& p); + ~Pattern(); + /** + \brief Set one of the PatternLayer + \param layer The layer of the new PatternLayer (will be copied) + \param strip The PatternLayer + **/ + void setLayerStrip(int layer, PatternLayer* strip); + /** + \brief Retrieves the PatternLayer of the given layer + \param layer The layer of the PatternLayer you want + \return A pointer on the PatternLayer (this is not a copy) + **/ + PatternLayer* getLayerStrip(int layer); + /** + \brief Retrieves the PatternLayer of the given layer + \param layer The layer of the PatternLayer you want + \return A pointer on the PatternLayer (this is not a copy) + **/ + PatternLayer* operator[](int layer); + /** + \brief Create links (pointers) between the PaternLayers and the Detector structure + \param d The detector structure on which we link the pattern + \param sec The ladders in the sector + \param modules The modules in the sector (one vector per ladder) + **/ + void link(Detector& d, const vector< vector >& sec, const vector > >& modules); + /** + \brief Reset the links between the pattern layers and the super strips + **/ + void unlink(); + /** + \brief Check if the pattern is active + \param active_threshold Minimum number of hit super strips + \return True if the pattern is active, false otherwise. + **/ + bool isActive(int active_threshold); + /** + \brief Created a unique key for this pattern + **/ + string getKey(); + /** + \brief Copy constructor + \return The number of layers for this Pattern + **/ + int getNbLayers() const; + /** + \brief Get a vectors of pointers on the Hits contained in this pattern (those are no copies) + \return A vector of Hits (must be used before the superstrips are cleared) + **/ + vector getHits(); + /** + \brief Get a vectors of pointers on the Hits contained in this pattern layer (those are no copies) + \param layerPosition The index of the layer + \return A vector of Hits (must be used before the superstrips are cleared) + **/ + vector getHits(int layerPosition); + + /** + \brief Allows to display a Pattern as a string + **/ + friend ostream& operator<<(ostream& out, const Pattern& s); + + + private: + int nb_layer; + SuperStrip*** strips; + char* nb_strips; + vector layer_strips; + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << nb_layer; + ar << layer_strips; + } + + template void load(Archive & ar, const unsigned int version){ + ar >> nb_layer; + ar >> layer_strips; + strips=NULL; + nb_strips=NULL; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PatternFinder.h b/L1Trigger/TrackFindingAM/interface/PatternFinder.h new file mode 100644 index 0000000000000..dc8e0fc5c410c --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PatternFinder.h @@ -0,0 +1,62 @@ +#ifndef _PATTERNFINDER_H_ +#define _PATTERNFINDER_H_ + +#include +#include +#include +#include +#include "SectorTree.h" + +using namespace std; + +/** + \brief Used to find active patterns in events +**/ +class PatternFinder{ + private: + int superStripSize; + int active_threshold; + SectorTree* sectors; + string eventsFilename; + string outputFileName; + Detector tracker; + + public: + /** + \brief Constructor + \param sp Size of a super strip + \param at The minimum number of hit super strip to activate a pattern + \param st The SectorTree containing the sectors with their associated patterns + \param f The name of the file to analyse + \param of The name of the output file + **/ + PatternFinder(int sp, int at, SectorTree* st, string f, string of); + /** + \brief Set the SectorTree (contains sectors with their patterns) + \param s The SectorTree containing the sectors with their associated patterns + **/ + void setSectorTree(SectorTree* s); + + /** + \brief Set the name of the root file containing events + \param f The name of the file + **/ + void setEventsFile(string f); + /** + \brief Look for active patterns in events + \param start The search will start from this event number + \param stop The search will end at this event number + **/ + void find(int start, int& stop); + + /** + \brief Get active patterns from list of hits (public for CMSSW). + **/ + vector find(vector hits); + + /** + \brief Merge 2 files into 1 single file + **/ + static void mergeFiles(string outputFile, string inputFile1, string inputFile2); +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PatternGenerator.h b/L1Trigger/TrackFindingAM/interface/PatternGenerator.h new file mode 100644 index 0000000000000..a016c9593444d --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PatternGenerator.h @@ -0,0 +1,123 @@ +#ifndef _PATTERNGENERATOR_H_ +#define _PATTERNGENERATOR_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include "SectorTree.h" + +using namespace std; + +/** + \brief Creates a pattern bank from root muons simulation files. +**/ +class PatternGenerator{ + private: + int superStripSize; + int variableRes; // number of DC bits used + float ptMin; + float ptMax; + float etaMin; + float etaMax; + int nbMaxFakeSuperstrips; + vector tracker_layers; + string particuleDirName; + + // Containers to load the TTree branches + int m_stub; + vector m_stub_tp; // tp of the particule + vector m_stub_layer; // Layer du stub (5 a 10 pour les 6 layers qui nous interessent) + vector m_stub_module; // Position en Z du module contenant le stub + vector m_stub_ladder; // Position en PHI du module contenant le stub + vector m_stub_seg; // Segment du module contenant le stub + vector m_stub_strip; // Strip du cluster interne du stub + vector m_stub_pxGEN; // Px de la particule initiale (en GeV/c) + vector m_stub_pyGEN; // Py de la particule initiale (en GeV/c) + vector m_stub_etaGEN; // Eta de la particule initiale + + vector *p_m_stub_tp; + vector *p_m_stub_layer; + vector *p_m_stub_module; + vector *p_m_stub_ladder; + vector *p_m_stub_seg; + vector *p_m_stub_strip; + vector *p_m_stub_pxGEN; + vector *p_m_stub_pyGEN; + vector *p_m_stub_etaGEN; + + TChain* createTChain(string directoryName, string tchainName); + int generate(TChain* TT, int* evtIndex, int evtNumber, int* nbTrack, SectorTree* sectors, map > eta_limits); + + public: + /** + \brief Constructor + \param sp Size of a super strip + **/ + PatternGenerator(int sp); + + /** + \brief Change the super strip size + \param sp Size of a super strip + **/ + void setSuperStripSize(int sp); + /** + \brief Change the minimum PT accepted to create a pattern (default is 2) + \param minp The minimum PT in GeV/c + **/ + void setMinPT(float minp); + /** + \brief Change the maximum PT accepted to create a pattern (default is 100) + \param maxp The maximum PT in GeV/c + **/ + void setMaxPT(float maxp); + /** + \brief Change the minimum Eta accepted to create a pattern + \param mine The minimum Eta + **/ + void setMinEta(float mine); + /** + \brief Change the maximum Eta accepted to create a pattern + \param maxe The maximum Eta + **/ + void setMaxEta(float maxe); + /** + \brief Change the maximum number of fake superstrips that can be used in a pattern + \param maxe The maximum number of fakse superstrips in a pattern + **/ + void setMaxFakeSuperstrips(int mf); + /** + \brief Sets the layers used + \param l A vector of int, each integer is a layer number (ex : 8 9 10 for the last 3 layers) + **/ + void setLayers(vector l); + /** + \brief Set the name of the directory containing the root files with muons informations + \param f The name of the directory + **/ + void setParticuleDirName(string f); + /** + \brief Set the number of DC bits used (0 to 3). If 0, adaptative patterns are not used + \param nb The number of DC bits to use + **/ + void setVariableResolution(int nb); + /** + \brief Is the variable resolutions pattern system activated + \return True if activated + **/ + int getVariableResolutionState(); + /** + \brief Generates the patterns + \param sectors This structure contains the interesting sectors, patterns will be added to this structure + \param step Number of events used at each step + \param threshold The process will stop when the size of the bank does not grow above this threshold (%) beteen 2 steps (or when we don't have any event). + \param eta_limits For each sector the minimum eta and the maximum eta on which the sector does exist. If a sector is missing in the list, no limits are taken into account. + **/ + void generate(SectorTree* sectors, int step, float threshold, map > eta_limits); +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PatternLayer.h b/L1Trigger/TrackFindingAM/interface/PatternLayer.h new file mode 100644 index 0000000000000..6a2456150c662 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PatternLayer.h @@ -0,0 +1,158 @@ +#ifndef _PATTERNLAYER_H_ +#define _PATTERNLAYER_H_ + +#include +#include +#include +#include +#include + +#include "Detector.h" + +#include + +using namespace std; + +/** + \brief Layer part of a pattern + This class contains the bits for one layer +**/ + +class PatternLayer{ + + public: + /** + \brief Number of bits per patternLayer + **/ + static const int LAYER_BITS=16; + /** + \brief Number of maximum DC bits + **/ + static const int DC_BITS=3; + /** + \brief Map between GRAY code and decimal values + **/ + static map GRAY_POSITIONS; + + /** + \brief Constructor + **/ + PatternLayer(); + /** + \brief Destructor + **/ + virtual ~PatternLayer(){}; + /** + \brief Returns a copy of the PatternLayer + \return A pointer on the copy + **/ + virtual PatternLayer* clone()=0; + + /** + \brief Returns the ladder's position in phi + \return The ladder's phi position + **/ + virtual short getPhi()=0; + + /** + \brief Set the values of the Don't Care bits + \param index The index of the bit + \param val The value of the bit (between 0 and 3) + **/ + void setDC(int index, char val); + /** + \brief Get a DC bit + \param index The index of the bit + \return The value of the DC bit in position index + **/ + char getDC(int index); + /** + \brief Returns the int value of the bitset as a string of 5 characters + \return A string (ie : "28653" or "00142") + **/ + string getCode(); + /** + \brief Get the bitset value as an integer + \return The value of the bitset (ie 28653 or 142) + **/ + int getIntValue() const; + /** + \brief Change the value contained in the bitset + \param v The new value as an integer + **/ + void setIntValue(int v); + /** + \brief Retrieve the SuperStrip objects corresponding to the PatternLayer from the Detector structure + \param l The layer of the PatternLayer (starting from 0) + \param ladd The ladders of this layer for the current sector + \param modules The modules in the current sector + \param d The detector structure + \return A list of SuperStrip*. If no DC bits are used we have only one value. + **/ + virtual vector getSuperStrip(int l, const vector& ladd, const map >& modules, Detector& d)=0; + + /** + \brief Allows to display a PatternLayer as a string + **/ + virtual string toString()=0; + + /** + \brief Returns the Super strip position + \return The position of the super strip + **/ + virtual short getStrip()=0; + /** + \brief Get the list of positions from the DC bits + **/ + void getPositionsFromDC(vector& positions); + + /** + \brief Get the number of DC bits used + \return The number of active DC bits for this PatternLayer + **/ + int getDCBitsNumber(); + + private: + /** + Get the list of positions from the DC bits + **/ + void getPositionsFromDC(vector dc, vector& positions); + static map CreateMap(); + + + protected: + bitset bits; + /* + 4 possible values for a DC bit: + 0 : 0 + 1 : 1 + 2 : X (Don't Care) + 3 : UNUSED + */ + char dc_bits[DC_BITS]; + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const//const boost::serialization::version_type& version) const + { + unsigned long i(this->getIntValue()); + ar << i; + for(int j=0;j void load(Archive & ar, const unsigned int version) + { + int i; + ar >> i; + setIntValue(i); + for(int j=0;j> dc_bits[j]; + } + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PatternTree.h b/L1Trigger/TrackFindingAM/interface/PatternTree.h new file mode 100644 index 0000000000000..f53c56ed201b5 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PatternTree.h @@ -0,0 +1,103 @@ +#ifndef _PATTERNTREE_H_ +#define _PATTERNTREE_H_ + +#include +#include +#include "PatternTrunk.h" + +using namespace std; +/** + \brief A map of PatternTrunks +**/ +class PatternTree{ + public: + /** + \brief Constructor + **/ + PatternTree(); + ~PatternTree(); + /** + \brief Add a copy of the pattern to the structure or increment the grade of the already stored pattern + \param ldp The low definition pattern (will be copied) + \param fdp The corresponding full definition pattern (will be copied, can be NULL if only one definition level is used) + **/ + void addPattern(Pattern* ldp, Pattern* fdp); + /** + \brief Add a pattern to the structure or increment the grade of the already stored pattern. Update the average Pt of the pattern. + \param ldp The low definition pattern + \param fdp The corresponding full definition pattern (can be NULL if only one definition level is used) + \param new_pt The Pt of the track generating the pattern + **/ + void addPattern(Pattern* ldp, Pattern* fdp, float new_pt); + + /** + \brief Get a copy of the full definition patterns + \return A vector of copies + **/ + vector getFDPatterns(); + /** + \brief Get a copy of the low definition patterns + \return A vector of copies + **/ + vector getLDPatterns(); + /** + \brief Get the distribution of PT among the LDPatterns + \return A vector containing the occurences of each PT (bin is 1). + **/ + vector getPTHisto(); + /** + \brief Get the number of LD patterns + \return The number of LD patterns in the structure + **/ + int getLDPatternNumber(); + /** + \brief Get the number of FD patterns + \return The number of FD patterns in the structure + **/ + int getFDPatternNumber(); + /** + \brief Link all patterns to the detector structure + \param d The detector + \param sec The ladders in the sector (one vector per layer) + \param modules The modules in the sector (one vector per ladder) + **/ + void link(Detector& d, const vector< vector >& sec, const vector > >& modules); + /** + \brief Returns a vector of copies of the active patterns + \brief active_threshold The minimum number of hit super strips to activate the pattern + \return A vector containing copies of active patterns + **/ + void getActivePatterns(int active_threshold, vector& active_patterns); + /** + \brief Replace all LD patterns with adapatative patterns. All FD patterns are removed. + \param r The number of DC bits used between FD and LD + **/ + void computeAdaptativePatterns(short r); + /** + \brief Add all LD patterns coming from an other PatternTree + \param p The PatternTree containing the patterns to add + **/ + void addPatternsFromTree(PatternTree* p); + + private: + map patterns; + + /** + \brief Add a pattern and update de DC bits if necessary + \param ldp The pattern to add + **/ + void addPatternForMerging(GradedPattern* ldp); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << patterns; + } + + template void load(Archive & ar, const unsigned int version){ + ar >> patterns; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PatternTrunk.h b/L1Trigger/TrackFindingAM/interface/PatternTrunk.h new file mode 100644 index 0000000000000..c82a3d093871d --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PatternTrunk.h @@ -0,0 +1,138 @@ +#ifndef _PATTERNTRUNK_H_ +#define _PATTERNTRUNK_H_ + +#include +#include +#include +#include +#ifdef __APPLE__ +#include // needed for boost v1.35 +#endif +#include +#include +#include "GradedPattern.h" + +using namespace std; + +/** + \brief A PatternTrunk can contain one low definition pattern and all the associated full definitions patterns +**/ + +class PatternTrunk{ + public: + /** + \brief Constructor + \param p The low definition pattern (will be copied) + **/ + PatternTrunk(Pattern* p); + + /** + \brief Default constructor + **/ + PatternTrunk(); + ~PatternTrunk(); + /** + \brief Add a new full definition pattern to the structure + Increment the low definition pattern grade. If the FD pattern is already contained, increments the grade. + **/ + void addFDPattern(Pattern* p); + + /** + \brief Add a new full definition pattern to the structure and update the average pt of this pattern + Increment the low definition pattern grade. If the FD pattern is already contained, increments the grade. + **/ + void addFDPattern(Pattern* p, float pt); + + + /** + \brief Get the list of all the full definition patterns + \return A vector of pointers on the Patterns (each Pattern is a copy) + **/ + vector getFDPatterns(); + /** + \brief Get the low definition pattern + \return A pointer on a copy of the Pattern + **/ + GradedPattern* getLDPattern(); + /** + \brief Get the average PT of the tracks that have created the low definition pattern + \return The PT in GeV/c + **/ + float getLDPatternPT(); + /** + \brief Get the number of FD patterns + \return The number of FD patterns stored in the PatternTrunk + **/ + int getFDPatternNumber(); + + /** + \brief Set the DC bits of the LD patterns. All FD patterns are removed. + \param r The number of DC bits used between FD and LD + **/ + void computeAdaptativePattern(short r); + + /** + \brief Link the low definition patterns to the detector structure + \param d The detector + \param sec The ladders in the sector + \param modules The modules in the sector (one vector per ladder) + **/ + void link(Detector& d, const vector< vector >& sec, const vector > >& modules); + + /** + \brief Change the DC bits of the LDP to take the parameter's DC bits into account (used while merging banks) + \param p A new pattern + **/ + void updateDCBits(GradedPattern* p); + + /** + \brief Returns a copy of the active pattern + \param active_threshold The minimum number of active super strips to activate the pattern + \return A pointer on the copy + **/ + GradedPattern* getActivePattern(int active_threshold); + + private: + GradedPattern* lowDefPattern; + map fullDefPatterns; + + /** + \brief Compute the DC bits. We use Gray Code to encode the positions : + 0 : 000 + 1 : 001 + 2 : 011 + 3 : 010 + 4 : 110 + 5 : 111 + 6 : 101 + 7 : 100 + The values used for the Don't Care bits are : + 0 : 0 + 1 : 1 + 2 : X (don't care) + 3 : Unused + For example if the DC bits are 1X0 it means positions 4 and 7. + \param v List of DC bits, used for recursivity + \param values List of used strips at full resolution (00110000 if the third and fourth strips are used at full def) + \param size The number of strips in the previous array. Depends on the number of DC bits used (2 for 1 DC bit, 4 for 2 DC bits, 8 for 3 DC bits, ...) + \param reverse Used for recursivity. Usefull to know if we are on the first or the second half of the array + **/ + void computeDCBits(vector &v, bool* values, int size, int reverse); + void deleteFDPatterns(); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << lowDefPattern;; + ar << fullDefPatterns; + } + + template void load(Archive & ar, const unsigned int version){ + ar >> lowDefPattern;; + ar >> fullDefPatterns; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PrincipalFitGenerator.h b/L1Trigger/TrackFindingAM/interface/PrincipalFitGenerator.h new file mode 100644 index 0000000000000..472b9051b5c6c --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PrincipalFitGenerator.h @@ -0,0 +1,69 @@ +#ifndef _PRINCIPALFITGENERATOR_H_ +#define _PRINCIPALFITGENERATOR_H_ + +#include +#include +#include +#include "SectorTree.h" +#include "PrincipalTrackFitter.h" + + +/** + \brief Class used to generate the parameters of a Principal Components Analysis Fitter +**/ +class PrincipalFitGenerator{ + + private: + string inputDirectory; + SectorTree* st; + + // Containers to load the TTree branches + int m_stub; + vector m_stub_tp; // tp of the particule + vector m_stub_layer; // Layer du stub (5 a 10 pour les 6 layers qui nous interessent) + vector m_stub_module; // Position en Z du module contenant le stub + vector m_stub_ladder; // Position en PHI du module contenant le stub + vector m_stub_pxGEN; // Px de la particule initiale (en GeV/c) + vector m_stub_pyGEN; // Py de la particule initiale (en GeV/c) + vector m_stub_etaGEN; // Eta de la particule initiale + vector m_stub_x; // x coordinate of the hit + vector m_stub_y; // y coordinate of the hit + vector m_stub_z; // z coordinate of the hit + vector m_clus_zmc; + vector m_stub_clust1; + vector m_stub_pdg; + vector m_stub_x0; + vector m_stub_y0; + vector m_stub_z0; + + + + vector *p_m_stub_tp; + vector *p_m_stub_layer; + vector *p_m_stub_module; + vector *p_m_stub_ladder; + vector *p_m_stub_pxGEN; + vector *p_m_stub_pyGEN; + vector *p_m_stub_etaGEN; + vector *p_m_stub_x; + vector *p_m_stub_y; + vector *p_m_stub_z; + vector *p_m_clus_zmc; + vector *p_m_stub_clust1; + vector *p_m_stub_pdg; + vector *p_m_stub_x0; + vector *p_m_stub_y0; + vector *p_m_stub_z0; + + TChain* createTChain(); + void generatePrincipal(map > eta_limits, float min_pt, float max_pt, float min_eta, float max_eta); + void generateMultiDim(map > eta_limits, float min_pt, float max_pt, float min_eta, float max_eta); + bool selectTrack(vector &tracker_layers, int* layers, vector &ladder_per_layer, vector &module_per_layer, + map > &eta_limits, float min_pt, float max_pt, float min_eta, float max_eta); + + public: + PrincipalFitGenerator(string f, SectorTree *s); + void generate(map > eta_limits, float min_pt, float max_pt, float min_eta, float max_eta); +}; + +#endif diff --git a/L1Trigger/TrackFindingAM/interface/PrincipalTrackFitter.h b/L1Trigger/TrackFindingAM/interface/PrincipalTrackFitter.h new file mode 100644 index 0000000000000..adbba884b30d0 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/PrincipalTrackFitter.h @@ -0,0 +1,58 @@ +#ifndef _PRINCIPALTRACKFITTER_H_ +#define _PRINCIPALTRACKFITTER_H_ + +#include "TrackFitter.h" +#include "FitParams.h" +#include + +#include +#include + +/** + \brief Implementation of a Principal Components Analysis fitter +**/ +class PrincipalTrackFitter:public TrackFitter{ + + private: + map params; + int threshold; + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const + { + ar << boost::serialization::base_object(*this); + ar << threshold; + ar << params; + } + + template void load(Archive & ar, const unsigned int version) + { + ar >> boost::serialization::base_object(*this); + ar >> threshold; + ar >> params; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + PrincipalTrackFitter(); + PrincipalTrackFitter(int nb, int t); + ~PrincipalTrackFitter(); + + void initialize(); + void mergePatterns(); + void mergeTracks(); + void fit(); + TrackFitter* clone(); + + void addTrackForPrincipal(int* tracker, double* coord); + bool hasPrincipalParams(); + void forcePrincipalParamsComputing(); + + void addTrackForMultiDimFit(int* tracker, double* coord, double* pt); + bool hasMultiDimFitParams(); + void forceMultiDimFitParamsComputing(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Sector.h b/L1Trigger/TrackFindingAM/interface/Sector.h new file mode 100644 index 0000000000000..a85302122e1f2 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Sector.h @@ -0,0 +1,279 @@ +#ifndef _SECTOR_H_ +#define _SECTOR_H_ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "PatternTree.h" +#include "TrackFitter.h" +#include "CMSPatternLayer.h" + +using namespace std; + +/** + \brief A part of the detector (1 to N ladders per layer) + A Sector is a part of the detector (1 to N ladders per layer) + The sector object can also contain the list of associated Patterns +**/ + +class Sector{ + + private: + + map > > m_modules; // map>> + map > m_ladders; // map> : needed to keep the order of the ladders (order not kept in maps) + PatternTree* patterns; + TrackFitter* fitter; + int officialID; + void getRecKeys(vector< vector > &v, int level, string temp, vector &res); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << m_modules; + ar << m_ladders; + ar << patterns; + ar << officialID; + int exists; + if(fitter==NULL){ + exists = 0; + ar << exists; + } + else{ + exists = 1; + ar << exists; + ar << fitter; + } + } + + template void load(Archive & ar, const unsigned int version){ + ar >> m_modules; + ar >> m_ladders; + ar >> patterns; + if(version>0)// Add support of the Sector ID coming from the TKLayout + ar >> officialID; + else + officialID=-1; + int exists; + ar >> exists; + if(exists==1){ + ar >> fitter; + } + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + /** + \brief Default constructor (3 layers) + **/ + Sector(); + /** + \brief Copy constructor. Be carreful : the list of patterns is not copied! + \param s The sector to be copied. + **/ + Sector(const Sector& s); + + /** + \brief Constructor. + \param layersID The list of layers in the sector (the layers tracker IDs : from 1 to 10) + **/ + Sector(vector layersID); + + /** + \brief Destructor : destroy the list of patterns + **/ + ~Sector(); + + /** + \brief Be carreful : the list of patterns is not copied! + **/ + Sector& operator=(Sector& s); + + /** + Check if the 2 sectors have the same layers and ladders + **/ + bool operator==(Sector& s); + + /** + \brief Add a layer to the sector + \param layer The layer number + **/ + void addLayer(int layer); + + /** + \brief Add ladders to the sector + \param layer The layer ID + \param firstLadder The starting ladder ID + \param nbLadders The number of consecutive ladders on this layer + **/ + void addLadders(int layer, int firstLadder, int nbLadders); + + /** + \brief Add modules to the ladder + \param layer The layer ID + \param ladder The ladder ID + \param firstModule The starting module ID + \param nbModules The number of consecutive modules on this ladder + **/ + void addModules(int layer, int ladder, int firstModule, int nbModules); + + /** + \brief Get the ladder code in the sector (to be used in the patternLayer). This is the position of the ladder in the layer + \param layer The layer ID + \param ladder The ladder ID + \return The position of the ladder in the layer which is the code to use in the pattern + **/ + int getLadderCode(int layer, int ladder); + + /** + \brief Get the module code in the sector (to be used in the patternLayer). This is the position of the module in the ladder + \param layer The layer ID + \param ladder The ladder ID + \param module The module ID + \return The position of the module in the ladder, which is the code to use in the pattern + **/ + int getModuleCode(int layer, int ladder, int module); + + /** + \brief Get the number of layers in the sector + \return The number of layers + **/ + int getNbLayers(); + + /** + \brief Get all the possible paths in this sector (1 ladder per layer) + \return A list of strings. Each string uses 2 digits per ladder (01 02 03 ...). The format is 020406 for ladders 2,4 and 6 respectively on layers 0,1 and 2 + **/ + vector getKeys(); + + /** + \brief Get a string representation of the sector + \return A string representating the sector (ex : "1 7-8 8-9") + **/ + string getIDString(); + + /** + \brief Get a unique key to identify the sector + \return The int key of the sector + **/ + int getKey(); + + /** + \brief Get the TKLayout ID of the sector + \return The TKLayout ID of the sector, -1 if not known + **/ + int getOfficialID(); + + /** + \brief Set the Sector official ID (id must be > -1) + **/ + void setOfficialID(int id); + + /** + \brief Does the sector contains the hit? + \return True if the hit is in the sector, false otherwise + **/ + bool contains(const Hit& h); + + + /** + \brief Get the ladders on the given layer + \param l The layer index (not the ID!) + \return A vector containing the ordered ladders id. + **/ + vector getLadders(int l) const; + + /** + \brief Get the modules on the given layer and ladder + \param lay The layer index (not the ID!) + \param l The ladder ID + \return A vector containing the ordered module IDs. + **/ + vector getModules(int lay, int l) const; + + + /** + \brief Get the layer ID + \param i The order of the layer in the sector + \return The layer ID + **/ + int getLayerID(int i) const; + + /** + \brief Get the layer index + \param i The ID of the layer + \return The index of the layer + **/ + int getLayerIndex(int i) const; + + /** + \brief Get list of patterns + \return A pointer on the PatternTree structure + **/ + PatternTree* getPatternTree(); + + /** + \brief Allows to display a sector as a string + **/ + friend ostream& operator<<(ostream& out, const Sector& s); + + /** + \brief Returns the number of Low Definition Patterns + \return The number of LD patterns contained in the sector + **/ + int getLDPatternNumber(); + + /** + \brief Returns the number of Full Definition Patterns + \return The number of FD patterns contained in the sector + **/ + int getFDPatternNumber(); + /** + \brief Replace all LD patterns with adapatative patterns. All FD patterns are removed. + \param r The number of DC bits used between FD and LD + **/ + void computeAdaptativePatterns(short r); + /** + Link all the patterns contained in the sector to the super strips contained in the Detector object + \param d The Detector object + **/ + void link(Detector& d); + /** + \brief Get the active patterns of the sector + \param active_threshold The minimum number of hit super strips to activate the pattern + \return A vector containing pointers on copies of the patterns + **/ + vector getActivePatterns(int active_threshold); + + /** + \brief Associates a fitter to the Sector + \param f The TrackFitter object which will be used for this sector + **/ + void setFitter(TrackFitter* f); + + /** + \brief Get the fitter for this Sector + \return f The TrackFitter object which will be used for this sector. Do NOT delete this object! + **/ + TrackFitter* getFitter(); + + /** + \brief Update the Phi Rotation value of the current fitter + **/ + void updateFitterPhiRotation(); + + static map< int, vector > readConfig(string name); +}; +BOOST_CLASS_VERSION(Sector, 1) +#endif diff --git a/L1Trigger/TrackFindingAM/interface/SectorTree.h b/L1Trigger/TrackFindingAM/interface/SectorTree.h new file mode 100644 index 0000000000000..904bab2b30168 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/SectorTree.h @@ -0,0 +1,132 @@ +#ifndef _SECTORTREE_H_ +#define _SECTORTREE_H_ + +#include +#include +#include +#include +#include +#include +#include "Sector.h" +#include "CMSPatternLayer.h" +#include "PrincipalTrackFitter.h" +#include "KarimakiTrackFitter.h" +#include "HoughFitter.h" + +#ifndef __APPLE__ +BOOST_CLASS_EXPORT_KEY(CMSPatternLayer) +BOOST_CLASS_EXPORT_KEY(PrincipalTrackFitter) +#endif + +using namespace std; + +/** + \brief Contains a list of sector + + This class allows to search a sector by giving one ladder per layer. +**/ + +class SectorTree{ + + private: + multimap sectors; + vector sector_list; + /** + \brief used to know the superstrip size used for the patterns contained in this sectorTree. + This value is not used inside the class. + **/ + int superStripSize; + + void updateSectorMap(); + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << sector_list; + ar << superStripSize; + } + + template void load(Archive & ar, const unsigned int version){ + ar >> sector_list; + ar >> superStripSize; + updateSectorMap(); + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + /** + \brief Constructor + **/ + SectorTree(); + /** + \brief Destructor + **/ + ~SectorTree(); + /** + \brief Search for one sector + \param ladders One ladder per layer : ie [5,6,6] if the particule went through ladders 5,6,6 on layers 0,1,2. + \param modules One module per ladder : ie [1,2,3] if the particule went through modules 1,2,3 on layers 0,1,2. + \return NULL if no sector was found or a pointer on the Sector (do NOT delete this pointer, it is not a copy). If several sectors match, the first one is returned (smaller ladders) + **/ + Sector* getSector(vector ladders, vector modules); + /** + \brief Search for one sector + \param h A hit + \return NULL if the hit is not in any sector or a pointer on the Sector (do NOT delete this pointer, it is not a copy). If several sectors match, the first one is returned (smaller ladders) + **/ + Sector* getSector(const Hit& h); + /** + \brief Add a sector to the SectorTree + \param s The sector to add + **/ + void addSector(Sector s); + /** + \brief Get all the sectors + \return A vector containing all the Sectors. Do NOT delete those pointers. + **/ + vector getAllSectors(); + /** + \brief Gets the number of Low Def patterns in the tree + **/ + int getLDPatternNumber(); + /** + \brief Gets the number of Full Def patterns in the tree + **/ + int getFDPatternNumber(); + /** + \brief Replace all LD patterns with adapatative patterns. All FD patterns are removed. + \param r The number of DC bits used between FD and LD + **/ + void computeAdaptativePatterns(short r); + /** + Link all the patterns contained in each sector to the super strips contained in the Detector object + \param d The Detector object + **/ + void link(Detector& d); + /** + \brief Get the active patterns in each sector + \param active_threshold The minimum number of hit super strips to activate the pattern + \return A vector containing pointers on copies of the sectors, each sectors containing its active patterns + **/ + vector getActivePatternsPerSector(int active_threshold); + + /** + \brief Retrieve the superstrip size used for the patterns inside the SectorTree + \return -1 if not specified, the superStrip size otherwise. + **/ + int getSuperStripSize(); + + /** + \brief Set the size of the superStrip used in the patterns stored in the SectorTree + \param s The superStrip size (should be greater than 0) + **/ + void setSuperStripSize(int s); + + /** + \brief Get the number of sectors in the SectorTree + **/ + int getNbSectors(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Segment.h b/L1Trigger/TrackFindingAM/interface/Segment.h new file mode 100644 index 0000000000000..59d7e50f0f2f1 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Segment.h @@ -0,0 +1,44 @@ +#ifndef _SEGMENT_H_ +#define _SEGMENT_H_ + +#include "SuperStrip.h" +#include + +/** + \brief Representation of a segment (vector of superstrips) +**/ +class Segment{ + + private: + vector strips; + short sStripSize; + + public: + /** + \brief Constructor + \param stripNumber Total number of strips in a segment (should be 1024 for CMS external layers) + \param sstripSize Size of a super strip (16,32,64,128,256,1024) + **/ + Segment(int stripNumber, int sstripSize); + /** + \brief Destructor + **/ + ~Segment(); + /** + \brief Get a super strip pointer from a strip number + \param stripNumber The number of a strip + \return A pointer (not a copy) of the superStrip object containing the given strip + **/ + SuperStrip* getSuperStrip(int stripNumber); + /** + \brief Get a super strip pointer from a super strip position + \param sstripNumber The position of the superstrip + \return A pointer (not a copy) of the superStrip object containing the given strip + **/ + SuperStrip* getSuperStripFromIndex(int sstripNumber); + /** + \brief Clear all the superstrips + **/ + void clear(); +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/SuperStrip.h b/L1Trigger/TrackFindingAM/interface/SuperStrip.h new file mode 100644 index 0000000000000..8236edf497c4e --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/SuperStrip.h @@ -0,0 +1,57 @@ +#ifndef _SUPERSTRIP_H_ +#define _SUPERSTRIP_H_ + +#include +#include +#include "Hit.h" + +using namespace std; + +/** +\brief Representation of a detector super strip (group of strips). +It contains the list of Hits that have touched the super strip. +**/ + +class SuperStrip{ + + private : + bool hit;//touched or not + short size;//number of strips in the SuperStrip + vector hits;//list of full resolution hits + + public: + /** + \brief Constructor + \param s The number of strips in the super strip + **/ + SuperStrip(int s); + /** + \brief Destructor + **/ + ~SuperStrip(); + /** + \brief Get the number of strips in the super strip + \return The size of the super strip + **/ + short getSize(); + /** + \brief Check if the super strip has been hit + \return True if a Hit occured + **/ + bool isHit(); + /** + \brief getHits + \return A vector containing pointers on the Hit objects (the Hits are not copied) + **/ + vector& getHits(); + /** + \brief Reset the super strip + **/ + void clear(); + /** + \brief Add a new hit to the super strip + \param h A pointer on the Hit object : this object will be copied. + **/ + void touch(const Hit* h); +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/Track.h b/L1Trigger/TrackFindingAM/interface/Track.h new file mode 100644 index 0000000000000..efa188a931e00 --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/Track.h @@ -0,0 +1,90 @@ +#ifndef _TRACK_H_ +#define _TRACK_H_ + +using namespace std; + +/** + \brief A track is defined with its curve (PT), D0, Phi0, Eta0 and Z0 parameters +**/ +class Track{ + + private: + double curve; + double d0; + double phi0; + double eta0; + double z0; + + public: + /** + \brief Default Constructor : all values set to 0 + **/ + Track(); + /** + \brief Constructor + \param c The PT of the track + \param d The D0 of the track + \param p The PHI0 of the track + \param p_a The Eta0 of the track + \param p_b The Z0 of the track + **/ + Track(double c, double d, double p, double p_a, double p_b); + /** + \brief Copy Constructor + **/ + Track(const Track&); + + /** + \brief Set the PT of the track + \param p The PT of the track + **/ + void setCurve(double p); + /** + \brief Set the D0 of the track + \param d The D0 of the track + **/ + void setD0(double d); + /** + \brief Set the Phi of the track + \param p The Phi of the track + **/ + void setPhi0(double p); + /** + \brief Set the Eta of the track + \param e The Eta of the track + **/ + void setEta0(double e); + /** + \brief Set the Z0 of the track + \param z The Z0 of the track + **/ + void setZ0(double z); + + /** + \brief Get the PT of the track + \return The PT of the track + **/ + double getCurve(); + /** + \brief Get the D0 of the track + \return The D0 of the track + **/ + double getD0(); + /** + \brief Get the Phi of the track + \return The Phi of the track + **/ + double getPhi0(); + /** + \brief Get the Eta of the track + \return The Eta of the track + **/ + double getEta0(); + /** + \brief Get the Z0 of the track + \return The Z0 of the track + **/ + double getZ0(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/interface/TrackFitter.h b/L1Trigger/TrackFindingAM/interface/TrackFitter.h new file mode 100644 index 0000000000000..fd12cf02e972b --- /dev/null +++ b/L1Trigger/TrackFindingAM/interface/TrackFitter.h @@ -0,0 +1,94 @@ +#ifndef _TRACKFITTER_H_ +#define _TRACKFITTER_H_ + +#include +#include "Track.h" +#include "Pattern.h" + +#include + +using namespace std; + +/** + \brief Generic class for a fitter. A fitter is associated with a Sector and is able to delete redundancy among patterns or tracks and compute tracks from patterns. +**/ +class TrackFitter{ + + protected: + vector patterns; + vector tracks; + int nb_layers; + double sec_phi;//used for sector rotation + + friend class boost::serialization::access; + + template void save(Archive & ar, const unsigned int version) const{ + ar << nb_layers; + ar << sec_phi; + } + + template void load(Archive & ar, const unsigned int version){ + ar >> nb_layers; + ar >> sec_phi; + } + + BOOST_SERIALIZATION_SPLIT_MEMBER() + + public: + /** + \brief Default constructor + **/ + TrackFitter(); + /** + \brief Constructor + \param nb Layers number + **/ + TrackFitter(int nb); + virtual ~TrackFitter(); + /** + \brief Performs any initialization if needed. + **/ + virtual void initialize()=0; + /** + \brief Add a pattern to the existing list. + \param p The pattern to add + **/ + void addPattern(Pattern* p); + /** + \brief Delete redondant patterns among the existing list. + **/ + virtual void mergePatterns()=0; + /** + \brief Delete redondant tracks among the existing list. + **/ + virtual void mergeTracks()=0; + /** + \brief Create tracks from the list of existing patterns. The tracks are stored inside the TrackFitter object. + **/ + virtual void fit()=0; + /** + \brief Create a copy of the existing object. + \return A pointer on the copy : you will have to delete this object. + **/ + virtual TrackFitter* clone()=0; + /** + \brief Delete all patterns and tracks from the current object. + **/ + void clean(); + + /** + \brief Returns a copy of the patterns inside the TrackFitter object. + \return A vector containing a copy of the patterns. You have to delete these objects. + **/ + vector getFilteredPatterns(); + /** + \brief Returns a copy of the fitted tracks. + \return A vector containing a copy of the fitted tracks. You have to delete these objects. + **/ + vector getTracks(); + + void setPhiRotation(double rot); + double getPhiRotation(); + +}; +#endif diff --git a/L1Trigger/TrackFindingAM/plugins/BuildFile.xml b/L1Trigger/TrackFindingAM/plugins/BuildFile.xml new file mode 100644 index 0000000000000..ad0856e5908fb --- /dev/null +++ b/L1Trigger/TrackFindingAM/plugins/BuildFile.xml @@ -0,0 +1,20 @@ + + + + + + + + + + + + + + + + + + + + diff --git a/L1Trigger/TrackFindingAM/plugins/TrackFindingAMProducer.cc b/L1Trigger/TrackFindingAM/plugins/TrackFindingAMProducer.cc new file mode 100644 index 0000000000000..116e9a43d390f --- /dev/null +++ b/L1Trigger/TrackFindingAM/plugins/TrackFindingAMProducer.cc @@ -0,0 +1,303 @@ +/*! \class TrackFindingAMProducer + * + * \author Nicola Pozzobon + * \date 2013, Jul 18 + * + */ + +#ifndef TRACK_BUILDER_AM_H +#define TRACK_BUILDER_AM_H + +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDProducer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + +#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" +#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" +#include "DataFormats/BeamSpot/interface/BeamSpot.h" +#include "MagneticField/Engine/interface/MagneticField.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" +#include "Geometry/TrackerGeometryBuilder/interface/TrackerGeometry.h" +#include "Geometry/Records/interface/TrackerDigiGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h" +#include "Geometry/Records/interface/StackedTrackerGeometryRecord.h" +#include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h" + +#include "L1Trigger/TrackFindingAM/interface/CMSPatternLayer.h" +#include "L1Trigger/TrackFindingAM/interface/PatternFinder.h" +#include "L1Trigger/TrackFindingAM/interface/SectorTree.h" +#include "L1Trigger/TrackFindingAM/interface/Hit.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#ifndef __APPLE__ +BOOST_CLASS_EXPORT_IMPLEMENT(CMSPatternLayer) +#endif + +class TrackFindingAMProducer : public edm::EDProducer +{ + public: + /// Constructor + explicit TrackFindingAMProducer( const edm::ParameterSet& iConfig ); + + /// Destructor; + ~TrackFindingAMProducer(); + + private: + /// Data members + double mMagneticField; + unsigned int nSectors; + unsigned int nWedges; + std::string nBKName; + int nThresh; + SectorTree m_st; + PatternFinder *m_pf; + const StackedTrackerGeometry *theStackedTracker; + edm::InputTag TTStubsInputTag; + + /// Mandatory methods + virtual void beginRun( const edm::Run& run, const edm::EventSetup& iSetup ); + virtual void endRun( const edm::Run& run, const edm::EventSetup& iSetup ); + virtual void produce( edm::Event& iEvent, const edm::EventSetup& iSetup ); + +}; /// Close class + +/*! \brief Implementation of methods + */ + +/// Constructors +TrackFindingAMProducer::TrackFindingAMProducer( const edm::ParameterSet& iConfig ) +{ + TTStubsInputTag = iConfig.getParameter< edm::InputTag >( "TTStubsBricks" ); + nSectors = iConfig.getParameter< int >("NumSectors"); + nWedges = iConfig.getParameter< int >("NumWedges"); + nBKName = iConfig.getParameter< std::string >("inputBankFile"); + nThresh = iConfig.getParameter< int >("threshold"); + + std::cout << "Loading pattern bank file : " << std::endl; + std::cout << nBKName << std::endl; + + std::ifstream ifs(nBKName.c_str()); + boost::archive::text_iarchive ia(ifs); + + ia >> m_st; + m_pf = new PatternFinder( m_st.getSuperStripSize(), nThresh, &m_st, "", "" ); + + produces< std::vector< TTTrack< Ref_PixelDigi_ > > >( "AML1Tracks" ); +} + +/// Destructor +TrackFindingAMProducer::~TrackFindingAMProducer() {} + +/// Begin run +void TrackFindingAMProducer::beginRun( const edm::Run& run, const edm::EventSetup& iSetup ) +{ + /// Get the geometry references + edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle; + iSetup.get< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle ); + theStackedTracker = StackedTrackerGeomHandle.product(); + + /// Get magnetic field + edm::ESHandle magneticFieldHandle; + iSetup.get().get(magneticFieldHandle); + const MagneticField* theMagneticField = magneticFieldHandle.product(); + double mMagneticFieldStrength = theMagneticField->inTesla(GlobalPoint(0,0,0)).z(); + mMagneticField = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0; +} + +/// End run +void TrackFindingAMProducer::endRun( const edm::Run& run, const edm::EventSetup& iSetup ) {} + +/// Implement the producer +void TrackFindingAMProducer::produce( edm::Event& iEvent, const edm::EventSetup& iSetup ) +{ + /// Prepare output + /// The temporary collection is used to store tracks + /// before removal of duplicates + std::auto_ptr< std::vector< TTTrack< Ref_PixelDigi_ > > > TTTracksForOutput( new std::vector< TTTrack< Ref_PixelDigi_ > > ); + + /// Get the Stubs already stored away + edm::Handle< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > > > TTStubHandle; + iEvent.getByLabel( TTStubsInputTag, TTStubHandle ); + + /// STEP 0 + /// Prepare output + TTTracksForOutput->clear(); + + int layer = 0; + int ladder = 0; + int module = 0; + int disk = 0; + int lad_cor= 0; + + /// STEP 1 + /// Loop over input stubs + + // std::cout << "Start the loop on stubs to transform them into sstrips" << std::endl; + + std::vector< Hit* > m_hits; + + for(unsigned int i=0;i >, TTStub< Ref_PixelDigi_ > > > stubMap; + + unsigned int j = 0; + edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >::const_iterator inputIter; + edmNew::DetSet< TTStub< Ref_PixelDigi_ > >::const_iterator stubIter; + for ( inputIter = TTStubHandle->begin(); + inputIter != TTStubHandle->end(); + ++inputIter ) + { + for ( stubIter = inputIter->begin(); + stubIter != inputIter->end(); + ++stubIter ) + { + /// Increment the counter + j++; + + /// Make the Ref to be put in the Track + edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > tempStubRef = makeRefTo( TTStubHandle, stubIter ); + + stubMap.insert( std::make_pair( j, tempStubRef ) ); + + /// Calculate average coordinates col/row for inner/outer Cluster + /// These are already corrected for being at the center of each pixel + MeasurementPoint mp0 = tempStubRef->getClusterRef(0)->findAverageLocalCoordinates(); + GlobalPoint posStub = theStackedTracker->findGlobalPosition( &(*tempStubRef) ); + + StackedTrackerDetId detIdStub( tempStubRef->getDetId() ); + //bool isPS = theStackedTracker->isPSModule( detIdStub ); + + const GeomDetUnit* det0 = theStackedTracker->idToDetUnit( detIdStub, 0 ); + const GeomDetUnit* det1 = theStackedTracker->idToDetUnit( detIdStub, 1 ); + + /// Find pixel pitch and topology related information + const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 ); + const PixelGeomDetUnit* pix1 = dynamic_cast< const PixelGeomDetUnit* >( det1 ); + const PixelTopology* top0 = dynamic_cast< const PixelTopology* >( &(pix0->specificTopology()) ); + const PixelTopology* top1 = dynamic_cast< const PixelTopology* >( &(pix1->specificTopology()) ); + + /// Find the z-segment + int cols0 = top0->ncolumns(); + int cols1 = top1->ncolumns(); + int ratio = cols0/cols1; /// This assumes the ratio is integer! + int segment = floor( mp0.y() / ratio ); + + // Here we rearrange the number in order to be compatible with the AM emulator + if ( detIdStub.isBarrel() ) + { + layer = detIdStub.iLayer()+4; + ladder = detIdStub.iPhi()-1; + module = detIdStub.iZ()-1; + } + else if ( detIdStub.isEndcap() ) + { + layer = 10+detIdStub.iZ()+abs(detIdStub.iSide()-2)*7; + + if (layer>10 && layer<=17) disk=(layer-10)%8; + if (layer>17 && layer<=24) disk=(layer-17)%8; + if (disk>=5) lad_cor = (disk-4)%4; + + ladder = detIdStub.iRing()-1+lad_cor; + module = detIdStub.iPhi()-1; + } + + module = CMSPatternLayer::getModuleCode(layer,module); + if ( module < 0 ) // the stub is on the third Z position on the other side of the tracker -> out of range + continue; + + ladder = CMSPatternLayer::getLadderCode(layer, ladder); + + int strip = mp0.x(); + int tp = -1; + float eta = 0; + float phi0 = 0; + float spt = 0; + float x = posStub.x(); + float y = posStub.y(); + float z = posStub.z(); + float x0 = 0.; + float y0 = 0.; + float z0 = 0.; + float ip = sqrt(x0*x0+y0*y0); + + Hit* h = new Hit(layer,ladder, module, segment, strip, j, tp, spt, ip, eta, phi0, x, y, z, x0, y0, z0); + m_hits.push_back(h); + } /// End of loop over input stubs + } /// End of loop over DetSetVector + + /// STEP 2 + /// PAssing the superstrips into the AM chip + + // std::cout << "AM chip processing" << std::endl; + + std::vector< Sector* > patternsSectors = m_pf->find(m_hits); // AM PR is done here.... + + /// STEP 3 + /// Collect the info and store the track seed stuff + + // std::cout << "AM chip processing" << std::endl; + + std::vector< Hit* > hits; + for ( unsigned int i = 0; i < patternsSectors.size(); i++ ) + { + std::vector< GradedPattern* > pl = patternsSectors[i]->getPatternTree()->getLDPatterns(); + + if ( pl.size() == 0 ) continue; // No patterns + + int secID = patternsSectors[i]->getOfficialID(); + + // std::cout<<"Found "<getHits(); + + /// Create the Seed in the form of a Track and store it in the output + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > > tempVec; + + for(unsigned k = 0; k < hits.size(); k++ ) + { + tempVec.push_back( stubMap[ hits[k]->getID() ] ); + } + + TTTrack< Ref_PixelDigi_ > tempTrack( tempVec ); + tempTrack.setSector( secID ); + TTTracksForOutput->push_back( tempTrack ); + + delete pl[j]; + } + + //delete the Sectors + delete patternsSectors[i]; + } + + /// Put in the event content + iEvent.put( TTTracksForOutput, "AML1Tracks" ); +} + +// DEFINE THIS AS A PLUG-IN +DEFINE_FWK_MODULE(TrackFindingAMProducer); + +#endif + diff --git a/L1Trigger/TrackFindingAM/python/L1AMTrack_cfi.py b/L1Trigger/TrackFindingAM/python/L1AMTrack_cfi.py new file mode 100644 index 0000000000000..5af2d1c3e9685 --- /dev/null +++ b/L1Trigger/TrackFindingAM/python/L1AMTrack_cfi.py @@ -0,0 +1,14 @@ +import FWCore.ParameterSet.Config as cms + + +TTTracksFromPixelDigisAM = cms.EDProducer("TrackFindingAMProducer", + TTStubsBricks = cms.InputTag("TTStubsFromPixelDigis", "StubAccepted"), + NumSectors = cms.int32(6), + NumWedges = cms.int32(3), + inputBankFile = cms.string('/afs/cern.ch/work/s/sviret/testarea/PatternBanks/BE_5D/Eta7_Phi8/ss32_cov40/612_SLHC6_MUBANK_lowmidhig_sec37_ss32_cov40.pbk'), + threshold = cms.int32(5) +) + +#process.BeamSpotFromSim = cms.EDProducer("BeamSpotFromSimProducer") +#process.TrackFindingTracklet_step = cms.Path(process.BeamSpotFromSim*process.TTTracksFromPixelDigisTracklet) + diff --git a/L1Trigger/TrackFindingAM/src/CMSPatternLayer.cc b/L1Trigger/TrackFindingAM/src/CMSPatternLayer.cc new file mode 100644 index 0000000000000..b294ced55261c --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/CMSPatternLayer.cc @@ -0,0 +1,228 @@ +#include "../interface/CMSPatternLayer.h" + +CMSPatternLayer::CMSPatternLayer():PatternLayer(){ + +} + +CMSPatternLayer* CMSPatternLayer::clone(){ + CMSPatternLayer* p = new CMSPatternLayer(); + p->bits=this->bits; + memcpy(p->dc_bits,this->dc_bits, DC_BITS*sizeof(char)); + return p; +} + +vector CMSPatternLayer::getSuperStrip(int l, const vector& ladd, const map >& modules, Detector& d){ + int nb_dc = getDCBitsNumber(); + int factor = (int)pow(2.0,nb_dc); + vector v; + + if(getPhi()==15){ // this is a fake superstrip! We link it to the dump superstrip + vector positions; + getPositionsFromDC(positions); + for(unsigned int i=0;igetLadder(ladderID); + if(patternLadder!=NULL){ + map >::const_iterator iterator = modules.find(ladderID); // get the vector of module IDs for this ladder + int moduleID = iterator->second[getModule()];// getthe module ID from its position + Module* patternModule = patternLadder->getModule(moduleID); + if(patternModule!=NULL){ + Segment* patternSegment = patternModule->getSegment(getSegment()); + if(patternSegment!=NULL){ + int base_index = getStrip()*factor; + vector positions; + getPositionsFromDC(positions); + for(unsigned int i=0;igetSuperStripFromIndex(base_index+PatternLayer::GRAY_POSITIONS[positions[i]]); + v.push_back(patternStrip); + } + return v; + } + } + } + } + cout<<"Error : can not link layer "<>MOD_START_BIT)&MOD_MASK; + return r; +} + +short CMSPatternLayer::getPhi(){ + int val = bits.to_ulong(); + short r = (val>>PHI_START_BIT)&PHI_MASK; + return r; +} + +short CMSPatternLayer::getStrip(){ + int val = bits.to_ulong(); + short r = (val>>STRIP_START_BIT)&STRIP_MASK; + return r; +} + +short CMSPatternLayer::getSegment(){ + int val = bits.to_ulong(); + short r = (val>>SEG_START_BIT)&SEG_MASK; + return r; +} + +string CMSPatternLayer::toString(){ + ostringstream oss; + oss<<"Ladder "< CMSPatternLayer::getLayerIDs(){ + vector layers; + + //BARREL + layers.push_back(5); + layers.push_back(6); + layers.push_back(7); + layers.push_back(8); + layers.push_back(9); + layers.push_back(10); + + //ENDCAP 1 + layers.push_back(11); + layers.push_back(12); + layers.push_back(13); + layers.push_back(14); + layers.push_back(15); + + //ENDCAP 2 + layers.push_back(18); + layers.push_back(19); + layers.push_back(20); + layers.push_back(21); + layers.push_back(22); + + return layers; +} + +int CMSPatternLayer::getNbStripsInSegment(){ + return 1024; +} + +int CMSPatternLayer::getSegmentCode(int layerID, int ladderID, int segmentID){ + if(layerID>7 && layerID<11) + return segmentID; + if(layerID>=5 && layerID<=7) + return segmentID/16; + if(ladderID<=8) + return segmentID/16; + return segmentID; +} + + +int CMSPatternLayer::getModuleCode(int layerID, int moduleID){ + switch(layerID){ + case 5 : return (moduleID/2); + case 6 : return (moduleID/2); + case 7 : return (moduleID/2); + case 8 : return moduleID; + case 9 : return moduleID; + case 10 : return moduleID; + default : return moduleID; + } +} + +int CMSPatternLayer::getLadderCode(int layerID, int ladderID){ + return ladderID; +} + + int CMSPatternLayer::getNbLadders(int layerID){ + if(layerID<5 || layerID>24) + return -1; + switch(layerID){ + case 5 : return 16; + case 6 : return 24; + case 7 : return 34; + case 8 : return 48; + case 9 : return 62; + case 10 : return 76; + default : return 15; + } + } + +int CMSPatternLayer::getNbModules(int layerID, int ladderID){ + if(layerID==5) + return 64; + if(layerID==6) + return 56; + if(layerID==7) + return 54; + if(layerID>=8 && layerID<=10) + return 24; + if(layerID>=11 && layerID<=24){ + switch(ladderID){ + case 0:return 20; + case 1:return 24; + case 2:return 28; + case 3:return 28; + case 4:return 32; + case 5:return 36; + case 6:return 36; + case 7:return 40; + case 8:return 40; + case 9:return 48; + case 10:return 56; + case 11:return 64; + case 12:return 68; + case 13:return 72; + case 14:return 80; + default:return 80; + } + } + return -1; +} + +map > CMSPatternLayer::getLayerDefInEta(){ + map > eta; + eta[5]=pair(-2.2,2.2); + eta[6]=pair(-1.72,1.72); + eta[7]=pair(-1.4,1.4); + eta[8]=pair(-1.2,1.2); + eta[9]=pair(-1.1,1.1); + eta[10]=pair(-0.9,0.9); + eta[11]=pair(1.1,2.4); + eta[12]=pair(1.2,2.4); + eta[13]=pair(1.3,2.4); + eta[14]=pair(1.4,2.5); + eta[15]=pair(1.6,2.5); + eta[18]=pair(-2.4,-1.1); + eta[19]=pair(-2.4,-1.2); + eta[20]=pair(-2.4,-1.3); + eta[21]=pair(-2.5,-1.4); + eta[22]=pair(-2.5,-1.6); + return eta; +} diff --git a/L1Trigger/TrackFindingAM/src/Detector.cc b/L1Trigger/TrackFindingAM/src/Detector.cc new file mode 100644 index 0000000000000..1c14c65497b49 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/Detector.cc @@ -0,0 +1,77 @@ +#include "../interface/Detector.h" + +Detector::Detector(){ + dump=NULL; +} + +void Detector::addLayer(int lNum, int nbLad, int nbMod, int segmentSize, int sstripSize){ + if(dump==NULL) + dump = new SuperStrip(sstripSize); + Layer* l = new Layer(nbLad, nbMod, segmentSize, sstripSize); + layerNumber.push_back(lNum); + layers.push_back(l); +} + +Detector::~Detector(){ + if(dump!=NULL) + delete dump; + for(unsigned int i=0;i-1 && pos<(int)layers.size()) + return layers[pos]; + return NULL; +} + +Layer* Detector::getLayer(int pos){ + int localPosition = getLayerPosition(pos); + if(localPosition!=-1) + return layers[localPosition]; + return NULL; +} + +void Detector::clear(){ + for(unsigned int i=0;iclear(); + } +} + +void Detector::receiveHit(const Hit& h){ + // cout<getLadder(h.getLadder())->getModule(h.getModule())->getSegment(h.getSegment())->getSuperStrip(h.getStripNumber()); + if(s==NULL) + cout<<"ERROR : Cannot find superStrip corresponding to the following hit : "<touch(&h); + } + } + else{ + //int tmp_layer = (int)h.getLayer(); + //cout<<"no layer "<AddRow(d); + } + + if(nb_principal==threshold){ + computePrincipalParams(); + } +} + +bool FitParams::hasPrincipalParams(){ + return nb_principal>threshold; +} + +void FitParams::forcePrincipalParamsComputing(){ + if(nb_principal>1){ + computePrincipalParams(); + } +} + +bool FitParams::hasMultiDimFitParams(){ + return nb_multidimfit>threshold; +} + +void FitParams::forceMultiDimFitParamsComputing(){ + if(nb_multidimfit>1){ + computeMultiDimFitParams(); + } +} +void FitParams::computePrincipalParams(){ + principal->MakePrincipals(); + + const TVectorD* m_eigen = principal->GetEigenValues(); + // if((*m_eigen)[0]!=(*m_eigen)[0]) + // cout<<"NaN value in eigen vector ("<GetEigenVectors(); + const TVectorD* m_mean = principal->GetMeanValues(); + const TVectorD* m_sig = principal->GetSigmas(); + + for(int i=0;iGetEigenVectors()->Print(); + principal->Print("mse"); + delete principal; + principal=NULL; + nb_principal=threshold+1; +} + +void FitParams::initializeMultiDimFit(TMultiDimFit* f){ + Int_t mPowers1[] = { 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4}; + //Int_t mPowers1[] = { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5}; + f->SetMaxPowers(mPowers1); + f->SetMaxFunctions(100); + f->SetMaxStudy(100); + f->SetMaxTerms(10); + f->SetPowerLimit(0.3); + f->SetMinAngle(1); +} + +void FitParams::addDataForMultiDimFit(double* d, double* val){ + if(nb_multidimfit "<AddRow(new_system,val[0]); + phi0_fit->AddRow(new_system,val[1]); + d0_fit->AddRow(new_system,val[2]); + eta0_fit->AddRow(new_system,val[3]); + z0_fit->AddRow(new_system,val[4]); + } + + if(nb_multidimfit==threshold){ + computeMultiDimFitParams(); + } +} + +void FitParams::computeMultiDimFitParams(){ + if(pt_fit!=NULL && pt_fit_data==NULL){ + pt_fit->FindParameterization(); + pt_fit_data = new MultiDimFitData(pt_fit, nb_layers); + delete pt_fit; + pt_fit=NULL; + phi0_fit->FindParameterization(); + phi0_fit_data = new MultiDimFitData(phi0_fit, nb_layers); + delete phi0_fit; + phi0_fit=NULL; + d0_fit->FindParameterization(); + d0_fit_data = new MultiDimFitData(d0_fit, nb_layers); + delete d0_fit; + d0_fit=NULL; + eta0_fit->FindParameterization(); + eta0_fit_data = new MultiDimFitData(eta0_fit, nb_layers); + delete eta0_fit; + eta0_fit=NULL; + z0_fit->FindParameterization(); + z0_fit_data = new MultiDimFitData(z0_fit, nb_layers); + delete z0_fit; + z0_fit=NULL; + nb_multidimfit=threshold+1; + } +} + +void FitParams::x2p(double *x, double *p) +{ + // This small method is processing these lines using parameters + // retrieved from the TPrincipal objects + + for (int i=0; idim) return -1; + + for (int i=(int)(dim-3*p);igetVal(val); +} + +double FitParams::getPhi0FitValue(double* val){ + if(phi0_fit_data==NULL) + return -1000; + + return phi0_fit_data->getVal(val); +} + +double FitParams::getD0FitValue(double* val){ + if(d0_fit_data==NULL){ + cout<<"D0 params do not exist"<getVal(val); +} + +double FitParams::getEta0FitValue(double* val){ + if(eta0_fit_data==NULL) + return -1000; + + return eta0_fit_data->getVal(val); +} + +double FitParams::getZ0FitValue(double* val){ + if(z0_fit_data==NULL) + return -1000; + + return z0_fit_data->getVal(val); +} + +Track* FitParams::getTrack(double* val){ + double pt = getPTFitValue(val); + double phi0 = getPhi0FitValue(val); + double d0 = getD0FitValue(val); + double eta0 = getEta0FitValue(val); + double z0 = getZ0FitValue(val); + + phi0 = atan(phi0); + pt = (0.3*3.833)/(2*pt*pow(cos(phi0),3)); + d0 = d0*cos(phi0); + eta0 = asinh(eta0*cos(phi0)); + + Track* t = new Track(pt,d0,phi0,eta0,z0); + return t; +} + +int FitParams::getNbPrincipalTracks(){ + return nb_principal; +} + +int FitParams:: getNbMultiDimFitTracks(){ + return nb_multidimfit; +} diff --git a/L1Trigger/TrackFindingAM/src/GradedPattern.cc b/L1Trigger/TrackFindingAM/src/GradedPattern.cc new file mode 100644 index 0000000000000..dd5f8d31783ba --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/GradedPattern.cc @@ -0,0 +1,32 @@ +#include "../interface/GradedPattern.h" + +GradedPattern::GradedPattern():Pattern(){ + grade=0; + averagePt=0; +} + +GradedPattern::GradedPattern(const Pattern& p):Pattern(p){ + grade=0; + averagePt=0; +} + +int GradedPattern::getGrade() const{ + return grade; +} + +float GradedPattern::getAveragePt() const{ + return averagePt; +} + +void GradedPattern::increment(){ + grade++; +} + +void GradedPattern::increment(float pt){ + averagePt=(averagePt*grade+pt)/(grade+1); + grade++; +} + +int GradedPattern::operator<(const GradedPattern& gp){ + return grade activatedHits; + + //////// Get the list of unique stubs from all the patterns /////////// + set ids; + int total=0; + for(unsigned int i=0;i allHits = patterns[i]->getHits(); + total+=allHits.size(); + for(unsigned int j=0;j::iterator,bool> result = ids.insert(allHits[j]->getID()); + if(result.second==true) + activatedHits.push_back(allHits[j]); + } + } + /////////////////////////////////////////////////////////////////////// + + //low resolution hough + HoughLocal* htl = new HoughLocal(0.5-PI/2,0,-0.01,0.01,32,32); + + //Add stubs to hough space + //cout<fill(activatedHits[j]->getX(), activatedHits[j]->getY()); + } + //cout<getValue(i,j); + } + cout< > hbins; + htl->findMaximumBins(hbins,min_nb_stubs-1);//we are more permissive the first time + if (htl->getVoteMax()>=(unsigned int)min_nb_stubs-1){ + //cout<<"etape 1 OK (vote max = "<getVoteMax()<<" bins : "< >::iterator ihb=hbins.begin();ihb \n",ith-2*htl->getThetaBin(),ith+2*htl->getThetaBin(),ir-2*htl->getRBin(),ir+2*htl->getRBin()); + //HoughLocal::PrintConvert(ith,ir); + double R=1./2./TMath::Abs(ir); + double pth=0.3*3.8*R/100.; + uint32_t nbinf=64; + if (pth<5) nbinf=128; + if (pth>=5 && pth<10) nbinf=192; + if (pth>=10 && pth<30) nbinf=256; + if (pth>=30) nbinf=320; + + //for each candidate at low res, creates a new houh at high res + HoughLocal *htp = new HoughLocal(ith-2*htl->getThetaBin(),ith+2*htl->getThetaBin(),ir-2*htl->getRBin(),ir+2*htl->getRBin(),nbinf,nbinf); + + htp->clear(); + + //add the stubs + for(unsigned int j=0;jfill(activatedHits[j]->getX(), activatedHits[j]->getY()); + } + /* + for(unsigned int i=0;igetValue(i,j); + } + cout< > hfbins;hfbins.clear(); + + //cout<<"etape 2 (vote max = "<getVoteMax()<<")"<getVoteMax()<(unsigned int)min_nb_stubs){ + delete htp; + continue; + } + + //we will keep only one candidate at high res : let's keep only the best ones + htp->findMaximumBins(hfbins,htp->getVoteMax());//we know getVoteMax is at least min_nb_stubs + + //cout<<"Bins : "<0){ + for (std::vector < std::pair >::iterator ihbp=hfbins.begin();ihbp delete track"<1000){ + //cout<<"PT over 1TeV -> delete track"<setPhiRotation(sec_phi); + return fit; +} diff --git a/L1Trigger/TrackFindingAM/src/HoughLocal.cc b/L1Trigger/TrackFindingAM/src/HoughLocal.cc new file mode 100644 index 0000000000000..d44019a9558f2 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/HoughLocal.cc @@ -0,0 +1,296 @@ +#include "../interface/HoughLocal.h" +#include +#include + +#include + +#include +HoughLocal::HoughLocal(double thmin,double thmax,double rmin,double rmax,uint32_t nbintheta,uint32_t nbinr) : theThetaMin_(thmin),theThetaMax_(thmax),theRMin_(rmin),theRMax_(rmax),theNbinTheta_(nbintheta),theNbinR_(nbinr) +{ + this->clear(); + theThetaBin_=(theThetaMax_-theThetaMin_)*1./theNbinTheta_; + theRBin_=(theRMax_-theRMin_)*1./theNbinR_; + + for (uint32_t i=0;itheRMax_ || rtheVoteMax_) theVoteMax_=theHoughImage_[i][ir]; + } + +} +void HoughLocal::clear() +{ + memset(theHoughImage_,0,1024*1024*sizeof(uint16_t)); + theX_.clear(); + theY_.clear(); + theVoteMax_=0; +} +double HoughLocal::getTheta(int32_t i) {return theThetaMin_+i*theThetaBin_;} +double HoughLocal::getR(int32_t i) {return theRMin_+i*theRBin_;} +uint16_t HoughLocal::getValue(uint32_t i,uint32_t j){return theHoughImage_[i][j];} +void HoughLocal::findMaxima(std::vector< std::pair >& maxval,uint32_t cut) +{ + printf("The Vote maximum is %d \n",theVoteMax_); +#ifdef VOTEBIN + if (theVoteMax_ < 3) return; + double theVoteBin_=theVoteMax_*1./(100); + printf("the Vote bin %f \n",theVoteBin_); + uint16_t theVotes_[100]; + memset(theVotes_,0,100*sizeof(uint16_t)); + for (uint32_t ith=0;ithiv*theVoteBin_) theVotes_[iv]++; + + uint32_t ivmin=0; + for (uint32_t iv=100-1;iv>=0;iv--) if (theVotes_[iv]>cut) {ivmin=iv+1;break;} + if (ivmin == 100) ivmin--; + double vcut=ivmin*theVoteBin_; +#else + double vcut=theVoteMax_-1; + if (vcut>12) vcut=12; +#endif + printf("The vote cut is %d \n",cut); + for (uint32_t ith=0;iththeNbinTheta_) continue; + if ((int)(ir+irb)<0 || (ir+irb)>theNbinR_) continue; + notmax= notmax || (count >::iterator it=maxval.begin();it!=maxval.end();it++) + if (TMath::Abs((int)(ith-it->first))<2 &&TMath::Abs((int)(ir-it->second))<2) + { notmax=true;break;} + if (notmax) continue; + std::pair p(ith,ir); + maxval.push_back(p); + } + +} +void HoughLocal::findMaximumBins(std::vector< std::pair >& maxval,uint32_t cut) +{ + + + + int32_t** matrix= new int*[theNbinTheta_]; + for(uint32_t i = 0; i < theNbinTheta_; ++i) { + matrix[i] = new int[theNbinR_]; + } + + int32_t** matlap= new int*[theNbinTheta_]; + for(uint32_t i = 0; i < theNbinTheta_; ++i) { + matlap[i] = new int[theNbinR_]; + } + + + + for (uint32_t ith=0;iththeNbinTheta_) continue; + if ((int)(ir+irb)<0 || (ir+irb)>theNbinR_) continue; + notmax= notmax || (count pf((ith+0.5)*theThetaBin_+theThetaMin_,(ir+0.5)*theRBin_+theRMin_); + maxval.push_back(pf); + } + } + /* + std::cout<<"Matlap : "< pf(theta*theThetaBin_+theThetaMin_,r*theRBin_+theRMin_); + maxval.push_back(pf); + } + + for(uint32_t i = 0; i < theNbinTheta_; ++i) + { + delete [] matrix[i]; + } + delete [] matrix; + for(uint32_t i = 0; i < theNbinTheta_; ++i) { + delete [] matlap[i]; + } + delete [] matlap; +} + +void HoughLocal::findThresholdBins(std::vector< std::pair >& maxval,uint32_t cut) +{ + + + + maxval.clear(); + for (uint32_t ith=0;ith=cut) + { + std::pair pf((ith+0.5)*theThetaBin_+theThetaMin_,(ir+0.5)*theRBin_+theRMin_); + maxval.push_back(pf); + } + + } +} + + +void HoughLocal::findMaxima(std::vector< std::pair >& maxval,uint32_t cut) +{ + + for (uint32_t ith=0;ith=cut) + { + bool notmax=false; + for (int ithb=-1;ithb<=1;ithb++) + for (int irb=-1;irb<=1;irb++) + { + if (ithb==0 && irb==0) continue; + if ((int)(ith+ithb)<0 || (ith+ithb)>theNbinTheta_) continue; + if ((int)(ir+irb)<0 || (ir+irb)>theNbinR_) continue; + notmax= notmax || (theHoughImage_[ith][ir]theNbinTheta_) continue; + if ((int)(ir+irb)<0 || (ir+irb)>theNbinR_) continue; + double thetab = (this->getTheta(ith+ithb)+this->getTheta(ith+ithb+1))/2; + double rb = (this->getR(ir+irb)+this->getR(ir+irb+1))/2; + double wb=theHoughImage_[ith+ithb][ir+irb]*1.; + if (ithb!=0 || irb!=0) wb=wb/2.; + //printf("%d %d %f \n",ithb,irb,wb); + w+=wb; + theta+=thetab*wb; + r+=rb*wb; + nb+=1; + } + printf("\t Candidat %f %f %f \n",w,theta/w,r/w); + std::pair p(theta/w,r/w/1.); + //std::pair p((ith+0.5)*theThetaBin_+theThetaMin_,(ir+0.5)*theRBin_+theRMin_); + maxval.push_back(p); + } + +} + +void HoughLocal::PrintConvert(double theta,double r) +{ + double a=-1./tan(theta); + double b=r/sin(theta); + + + // + double R=1./2./TMath::Abs(r); + //double xi=-a/2./b; + //double yi=1./2./b; + printf(" From r=%f theta=%f a=%f b=%f R= %f => Pt=%f GeV/c Phi0=%f \n",r,theta,a,b,R,0.3*3.8*R/100.,atan(a)); + +} + + diff --git a/L1Trigger/TrackFindingAM/src/KarimakiTrackFitter.cc b/L1Trigger/TrackFindingAM/src/KarimakiTrackFitter.cc new file mode 100644 index 0000000000000..598a25515d966 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/KarimakiTrackFitter.cc @@ -0,0 +1,176 @@ +#include "../interface/KarimakiTrackFitter.h" + +KarimakiTrackFitter::KarimakiTrackFitter():TrackFitter(){ +} + +KarimakiTrackFitter::KarimakiTrackFitter(int nb):TrackFitter(nb){ +} + +KarimakiTrackFitter::~KarimakiTrackFitter(){ +} + +void KarimakiTrackFitter::initialize(){ + +} + +void KarimakiTrackFitter::mergePatterns(){ + //cout<<"Merging of patterns not implemented"< active_hits = p->getHits(i);//list of hits in the pattern for this layer + + ng = active_hits.size(); + + if (ng==0) + n_miss++; + if (ng>1) + n_mult++; + + if (ng!=1) + continue; + + ngc++; + + (active_hits[0]->getLayer()<8)? wght = 1. : wght = 5000.; + + //cout<<*active_hits[0]<getX()*cos(sec_phi)+active_hits[0]->getY()*sin(sec_phi); + y = -active_hits[0]->getX()*sin(sec_phi)+active_hits[0]->getY()*cos(sec_phi); + z = active_hits[0]->getZ(); + + rr = (x*x+y*y); + + parZX[0][0] += rr/wght; + parZX[1][1] += 1/wght; + parZX[1][0] += sqrt(rr)/wght; + + resZX[0] += sqrt(rr)*z/wght; + resZX[1] += z/wght; + + s_x += x; + s_y += y; + s_xy += x*y; + s_xx += x*x; + s_yy += y*y; + s_rr += rr; + s_xrr += x*rr; + s_yrr += y*rr; + s_rrrr += rr*rr; + s_0 += 1; + } + + s_x /= s_0; + s_y /= s_0; + s_xy /= s_0; + s_xx /= s_0; + s_yy /= s_0; + s_rr /= s_0; + s_xrr /= s_0; + s_yrr /= s_0; + s_rrrr /= s_0; + + c_xx = s_xx - s_x*s_x; + c_xy = s_xy - s_x*s_y; + c_yy = s_yy - s_y*s_y; + c_xr = s_xrr - s_x*s_rr; + c_yr = s_yrr - s_y*s_rr; + c_rr = s_rrrr - s_rr*s_rr; + + double q_1 = c_rr*c_xy - c_xr*c_yr; + double q_2 = c_rr*(c_xx-c_yy) - c_xr*c_xr + c_yr*c_yr; + + phi = 0.5*atan(2*q_1/q_2); + kappa = (sin(phi)*c_xr-cos(phi)*c_yr)/c_rr; + delta = -kappa*s_rr+sin(phi)*s_x-cos(phi)*s_y; + + detZX = parZX[0][0]*parZX[1][1]-parZX[1][0]*parZX[1][0]; + + invZX[0][0] = parZX[1][1]/detZX; + invZX[1][0] = -parZX[1][0]/detZX; + invZX[1][1] = parZX[0][0]/detZX; + + if (n_miss<=1 && n_mult==0){ + pr[0] = 0.01/(2*kappa/sqrt(1-4*delta*kappa))*(0.3*3.833); + pr[1] = phi; + pr[2] = -2*delta/(1+sqrt(1-4*delta*kappa));// TODO : pourquoi signe oppose? + pr[3] = asinh((invZX[0][0]*resZX[0] + invZX[1][0]*resZX[1])); + pr[4] = invZX[1][0]*resZX[0] + invZX[1][1]*resZX[1]; + + Track* fit_track = new Track(pr[0], pr[2], pr[1], pr[3], pr[4]); + fit_track->setPhi0(fit_track->getPhi0()+sec_phi);//correction de la rotation en PHI + //cout<<"PT estime de la trace : "<getCurve()<getPhi0()<getD0()<getEta0()<getZ0()<setPhiRotation(sec_phi); + return fit; +} diff --git a/L1Trigger/TrackFindingAM/src/Ladder.cc b/L1Trigger/TrackFindingAM/src/Ladder.cc new file mode 100644 index 0000000000000..98a3289d23588 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/Ladder.cc @@ -0,0 +1,27 @@ +#include "../interface/Ladder.h" + +Ladder::Ladder(int nbMod, int segmentSize, int sstripSize){ + for(int i=0;i-1 && zPos<(int)modules.size()) + return modules[zPos]; + return NULL; +} + +void Ladder::clear(){ + for(unsigned int i=0;iclear(); + } +} diff --git a/L1Trigger/TrackFindingAM/src/Layer.cc b/L1Trigger/TrackFindingAM/src/Layer.cc new file mode 100644 index 0000000000000..352511adb682c --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/Layer.cc @@ -0,0 +1,28 @@ +#include "../interface/Layer.h" + +Layer::Layer(int nbLad, int nbMod, int segmentSize, int sstripSize){ + for(int i=0;i=0 && pos<(int)ladders.size()) + return ladders[pos];//ladders numbered from 0 to n-1 + cout<<"ladder "<clear(); + } +} diff --git a/L1Trigger/TrackFindingAM/src/Module.cc b/L1Trigger/TrackFindingAM/src/Module.cc new file mode 100644 index 0000000000000..1ab3f3ec196e3 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/Module.cc @@ -0,0 +1,22 @@ +#include "../interface/Module.h" + +Module::Module(int segmentSize, int sstripSize){ + segments[0]=new Segment(segmentSize, sstripSize); + segments[1]=new Segment(segmentSize, sstripSize); +} + +Module::~Module(){ + delete segments[0]; + delete segments[1]; +} + +Segment* Module::getSegment(int n){ + if(n>-1 && n<2) + return segments[n]; + return NULL; +} + +void Module::clear(){ + segments[0]->clear(); + segments[1]->clear(); +} diff --git a/L1Trigger/TrackFindingAM/src/MultiDimFitData.cc b/L1Trigger/TrackFindingAM/src/MultiDimFitData.cc new file mode 100644 index 0000000000000..1f7510a5a34b5 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/MultiDimFitData.cc @@ -0,0 +1,149 @@ +#include "../interface/MultiDimFitData.h" + +MultiDimFitData::~MultiDimFitData(){ + //cout<<"destruction MultiDimFitData"<GetNVariables(); + gNCoefficients=m->GetNCoefficients(); + gNMaxTerms = m->GetMaxTerms(); + gNMaxFunctions = m->GetMaxFunctions(); + gDMean = m->GetMeanQuantity(); + + nb_layers = nb; + + gXMin = new double[gNVariables]; + for(int i=0;iGetMinVariables())[i]; + } + + gXMax = new double[gNVariables]; + for(int i=0;iGetMaxVariables())[i]; + } + + gCoefficient = new double[gNCoefficients]; + for(int i=0;iGetCoefficients())[i]; + } + + gPowerIndex = new int[gNMaxTerms]; + for(int i=0;iGetPowerIndex()[i]; + } + + gPower = new int[gNVariables*gNMaxFunctions]; + for(int i=0;iGetPowers()[i]; + } + + int size = ((nb_layers-1)*3)+1; + m_final_coeffs = new double[size]; + double returnValue = gDMean; + for (int i=0; iclone()); + if(p.strips!=NULL){ + nb_strips[i] = p.nb_strips[i]; + for(int j=0;j=0){ + layer_strips[layer]=strip->clone(); + } +} + +PatternLayer* Pattern::getLayerStrip(int layer){ + if(layer=0) + return layer_strips[layer]; + return NULL; +} + +PatternLayer* Pattern::operator[](int layer){ + if(layer=0) + return layer_strips[layer]; + return NULL; +} + +bool Pattern::isActive(int active_threshold){ + int score=0; + if(strips!=NULL){ + for(int i=0;iisHit()){ + score++; + break; + } + } + } + } + if(score>=active_threshold) + return true; + else + return false; +} + +string Pattern::getKey(){ + string key=""; + for(int i=0;igetCode()); + } + return key; +} + +int Pattern::getNbLayers() const { + return nb_layer; +} + +void Pattern::unlink(){ + if(nb_strips!=NULL) + delete [] nb_strips; + + if(strips!=NULL){ + for(int i=0;i >& sec, const vector > >& modules){ + if(strips!=NULL){// already linked + unlink(); + } + + nb_strips=new char[nb_layer]; + strips = new SuperStrip**[nb_layer]; + for(int i=0;i tmp_strips = layer_strips[i]->getSuperStrip(i, sec[i], modules[i], d); + nb_strips[i] = tmp_strips.size(); + strips[i] = new SuperStrip*[nb_strips[i]]; + for(unsigned int j=0;j Pattern::getHits(){ + vector hits; + for(int i=0;i l_hits = strips[i][j]->getHits(); + hits.insert(hits.end(), l_hits.begin(), l_hits.end()); + } + } + return hits; +} + +vector Pattern::getHits(int layerPosition){ + vector hits; + if(layerPosition>=0 && layerPosition l_hits = strips[layerPosition][j]->getHits(); + hits.insert(hits.end(), l_hits.begin(), l_hits.end()); + } + } + return hits; +} + +ostream& operator<<(ostream& out, const Pattern& s){ + for(int i=0;itoString()< > detector_config = Sector::readConfig("detector.cfg"); + + //We add the layers corresponding to the sectors structure + vector sectors = st->getAllSectors(); + if(sectors.size()>0){ + for(int i=0;igetNbLayers();i++){ + int layerID = sectors[0]->getLayerID(i); + if(detector_config.size()>0){ + if(detector_config.find(layerID)!=detector_config.end()) + tracker.addLayer(detector_config[layerID][0],detector_config[layerID][1],detector_config[layerID][2],detector_config[layerID][3], superStripSize); + else + cout<<"WARNING : Layer "<link(tracker); + cout<<"done."<Add(inputFile1.c_str()); + SEC1->Add(inputFile1.c_str()); + + int input1_nb_layers; + int input1_nb_patterns=0; + int input1_ori_nb_stubs=0; + int input1_sel_nb_stubs=0; + int input1_event_id; + int *input1_superStrip_layer_0 = new int[MAX_NB_PATTERNS]; + int *input1_superStrip_layer_1 = new int[MAX_NB_PATTERNS]; + int *input1_superStrip_layer_2 = new int[MAX_NB_PATTERNS]; + int *input1_superStrip_layer_3 = new int[MAX_NB_PATTERNS]; + int *input1_superStrip_layer_4 = new int[MAX_NB_PATTERNS]; + int *input1_superStrip_layer_5 = new int[MAX_NB_PATTERNS]; + int *input1_pattern_sector_id = new int[MAX_NB_PATTERNS]; + + //Array containing the strips arrays + int* input1_superStrips[MAX_NB_LAYERS]; + input1_superStrips[0]=input1_superStrip_layer_0; + input1_superStrips[1]=input1_superStrip_layer_1; + input1_superStrips[2]=input1_superStrip_layer_2; + input1_superStrips[3]=input1_superStrip_layer_3; + input1_superStrips[4]=input1_superStrip_layer_4; + input1_superStrips[5]=input1_superStrip_layer_5; + + int input1_sector_id=0; + int input1_sector_layers=0; + int input1_nb_ladders_layer[MAX_NB_LAYERS]; + int input1_sector_layer_list[MAX_NB_LAYERS]; + int input1_sector_layer_0[MAX_NB_LADDERS_PER_LAYER]; + int input1_sector_layer_1[MAX_NB_LADDERS_PER_LAYER]; + int input1_sector_layer_2[MAX_NB_LADDERS_PER_LAYER]; + int input1_sector_layer_3[MAX_NB_LADDERS_PER_LAYER]; + int input1_sector_layer_4[MAX_NB_LADDERS_PER_LAYER]; + int input1_sector_layer_5[MAX_NB_LADDERS_PER_LAYER]; + + int* input1_sector_layers_detail[MAX_NB_LAYERS]; + input1_sector_layers_detail[0]=input1_sector_layer_0; + input1_sector_layers_detail[1]=input1_sector_layer_1; + input1_sector_layers_detail[2]=input1_sector_layer_2; + input1_sector_layers_detail[3]=input1_sector_layer_3; + input1_sector_layers_detail[4]=input1_sector_layer_4; + input1_sector_layers_detail[5]=input1_sector_layer_5; + + int *input1_nbHitPerPattern = new int[MAX_NB_PATTERNS]; + int input1_totalNbHits=0; + int input1_nbTracks = 0; + float *input1_track_pt = new float[MAX_NB_PATTERNS]; + float *input1_track_phi = new float[MAX_NB_PATTERNS]; + float *input1_track_d0 = new float[MAX_NB_PATTERNS]; + float *input1_track_eta = new float[MAX_NB_PATTERNS]; + float *input1_track_z0 = new float[MAX_NB_PATTERNS]; + short *input1_hit_layer = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input1_hit_ladder = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input1_hit_zPos = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input1_hit_segment = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input1_hit_strip = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + int *input1_hit_tp = new int[MAX_NB_PATTERNS*MAX_NB_HITS]; + int *input1_hit_idx = new int[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_ptGEN = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_etaGEN = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_phi0GEN = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_ip = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_x = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_y = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_z = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_X0 = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_Y0 = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input1_hit_Z0 = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + + SEC1->SetBranchAddress("sectorID", &input1_sector_id);//ID du secteur + SEC1->SetBranchAddress("nbLayers", &input1_sector_layers);// nombre de layers dans le secteur + SEC1->SetBranchAddress("layer", input1_sector_layer_list);//layers ID + SEC1->SetBranchAddress("nb_ladders_layer", input1_nb_ladders_layer); // nombre de ladders pour chaque layer + SEC1->SetBranchAddress("sectorLadders_layer_0", input1_sector_layer_0);//liste des ladders pour layer 0 + SEC1->SetBranchAddress("sectorLadders_layer_1", input1_sector_layer_1); + SEC1->SetBranchAddress("sectorLadders_layer_2", input1_sector_layer_2); + SEC1->SetBranchAddress("sectorLadders_layer_3", input1_sector_layer_3); + SEC1->SetBranchAddress("sectorLadders_layer_4", input1_sector_layer_4); + SEC1->SetBranchAddress("sectorLadders_layer_5", input1_sector_layer_5); + + PATT1->SetBranchAddress("nbLayers", &input1_nb_layers);//nombre de layers pour les patterns + PATT1->SetBranchAddress("nbPatterns", &input1_nb_patterns); // nombre de patterns dans l'evenement + PATT1->SetBranchAddress("nbStubsInEvt", &input1_ori_nb_stubs); // nombre de stubs dans l'evenement initial + PATT1->SetBranchAddress("nbStubsInPat", &input1_sel_nb_stubs); // nombre de stubs uniques dans les patterns + PATT1->SetBranchAddress("eventID", &input1_event_id); // ID de l'evenement (le meme que dans le fichier de simulation) + PATT1->SetBranchAddress("sectorID", input1_pattern_sector_id);// ID du secteur du pattern (permet de retrouver le secteur dans le premier TTree) + PATT1->SetBranchAddress("superStrip0", input1_superStrip_layer_0);// tableau de superstrips pour le layer 0 + PATT1->SetBranchAddress("superStrip1", input1_superStrip_layer_1); + PATT1->SetBranchAddress("superStrip2", input1_superStrip_layer_2); + PATT1->SetBranchAddress("superStrip3", input1_superStrip_layer_3); + PATT1->SetBranchAddress("superStrip4", input1_superStrip_layer_4); + PATT1->SetBranchAddress("superStrip5", input1_superStrip_layer_5); + PATT1->SetBranchAddress("total_nb_stubs", &input1_totalNbHits); + PATT1->SetBranchAddress("nbTracks", &input1_nbTracks); + PATT1->SetBranchAddress("nbStubs", input1_nbHitPerPattern); // nombre de stubs contenus dans chaque pattern + + PATT1->SetBranchAddress("track_pt", input1_track_pt); // PT of fitted tracks + PATT1->SetBranchAddress("track_phi", input1_track_phi); // PHI0 of fitted tracks + PATT1->SetBranchAddress("track_d0", input1_track_d0); // D0 of fitted tracks + PATT1->SetBranchAddress("track_eta", input1_track_eta); // ETA of fitted tracks + PATT1->SetBranchAddress("track_z0", input1_track_z0); // Z0 of fitted tracks + + PATT1->SetBranchAddress("stub_layers", input1_hit_layer);//layer du stub + PATT1->SetBranchAddress("stub_ladders", input1_hit_ladder);//ladder du stub + PATT1->SetBranchAddress("stub_module", input1_hit_zPos);//position en Z du module du stub + PATT1->SetBranchAddress("stub_segment", input1_hit_segment);//segment du stub + PATT1->SetBranchAddress("stub_strip", input1_hit_strip);//numero de strip du stub + PATT1->SetBranchAddress("stub_tp", input1_hit_tp);//numero de la particule du stub + PATT1->SetBranchAddress("stub_idx", input1_hit_idx);//index du stub dans l'evenement + PATT1->SetBranchAddress("stub_ptGEN", input1_hit_ptGEN);//PT de la particule du stub + PATT1->SetBranchAddress("stub_etaGEN", input1_hit_etaGEN);//ETA de la particule du stub + PATT1->SetBranchAddress("stub_phi0GEN", input1_hit_phi0GEN);//PHI0 de la particule du stub + PATT1->SetBranchAddress("stub_IP", input1_hit_ip);//distance avec l'IP + PATT1->SetBranchAddress("stub_x", input1_hit_x); + PATT1->SetBranchAddress("stub_y", input1_hit_y); + PATT1->SetBranchAddress("stub_z", input1_hit_z); + PATT1->SetBranchAddress("stub_X0", input1_hit_X0); + PATT1->SetBranchAddress("stub_Y0", input1_hit_Y0); + PATT1->SetBranchAddress("stub_Z0", input1_hit_Z0); + + /*********************************************/ + + /*********************INPUT 2 FILE *************************************/ + + + TChain *PATT2 = new TChain("Patterns"); // infos about patterns + TChain *SEC2 = new TChain("Sectors"); //infos about sectors + PATT2->Add(inputFile2.c_str()); + SEC2->Add(inputFile2.c_str()); + + int input2_nb_layers; + int input2_nb_patterns=0; + int input2_ori_nb_stubs=0; + int input2_sel_nb_stubs=0; + int input2_event_id; + int *input2_superStrip_layer_0 = new int[MAX_NB_PATTERNS]; + int *input2_superStrip_layer_1 = new int[MAX_NB_PATTERNS]; + int *input2_superStrip_layer_2 = new int[MAX_NB_PATTERNS]; + int *input2_superStrip_layer_3 = new int[MAX_NB_PATTERNS]; + int *input2_superStrip_layer_4 = new int[MAX_NB_PATTERNS]; + int *input2_superStrip_layer_5 = new int[MAX_NB_PATTERNS]; + int *input2_pattern_sector_id = new int[MAX_NB_PATTERNS]; + + //Array containing the strips arrays + int* input2_superStrips[MAX_NB_LAYERS]; + input2_superStrips[0]=input2_superStrip_layer_0; + input2_superStrips[1]=input2_superStrip_layer_1; + input2_superStrips[2]=input2_superStrip_layer_2; + input2_superStrips[3]=input2_superStrip_layer_3; + input2_superStrips[4]=input2_superStrip_layer_4; + input2_superStrips[5]=input2_superStrip_layer_5; + + int input2_sector_id=0; + int input2_sector_layers=0; + int input2_nb_ladders_layer[MAX_NB_LAYERS]; + int input2_sector_layer_list[MAX_NB_LAYERS]; + int input2_sector_layer_0[MAX_NB_LADDERS_PER_LAYER]; + int input2_sector_layer_1[MAX_NB_LADDERS_PER_LAYER]; + int input2_sector_layer_2[MAX_NB_LADDERS_PER_LAYER]; + int input2_sector_layer_3[MAX_NB_LADDERS_PER_LAYER]; + int input2_sector_layer_4[MAX_NB_LADDERS_PER_LAYER]; + int input2_sector_layer_5[MAX_NB_LADDERS_PER_LAYER]; + + int* input2_sector_layers_detail[MAX_NB_LAYERS]; + input2_sector_layers_detail[0]=input2_sector_layer_0; + input2_sector_layers_detail[1]=input2_sector_layer_1; + input2_sector_layers_detail[2]=input2_sector_layer_2; + input2_sector_layers_detail[3]=input2_sector_layer_3; + input2_sector_layers_detail[4]=input2_sector_layer_4; + input2_sector_layers_detail[5]=input2_sector_layer_5; + + int *input2_nbHitPerPattern = new int[MAX_NB_PATTERNS]; + int input2_totalNbHits=0; + int input2_nbTracks = 0; + float *input2_track_pt = new float[MAX_NB_PATTERNS]; + float *input2_track_phi = new float[MAX_NB_PATTERNS]; + float *input2_track_d0 = new float[MAX_NB_PATTERNS]; + float *input2_track_eta = new float[MAX_NB_PATTERNS]; + float *input2_track_z0 = new float[MAX_NB_PATTERNS]; + short *input2_hit_layer = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input2_hit_ladder = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input2_hit_zPos = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input2_hit_segment = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + short *input2_hit_strip = new short[MAX_NB_PATTERNS*MAX_NB_HITS]; + int *input2_hit_tp = new int[MAX_NB_PATTERNS*MAX_NB_HITS]; + int *input2_hit_idx = new int[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_ptGEN = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_etaGEN = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_phi0GEN = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_ip = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_x = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_y = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_z = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_X0 = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_Y0 = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + float *input2_hit_Z0 = new float[MAX_NB_PATTERNS*MAX_NB_HITS]; + + SEC2->SetBranchAddress("sectorID", &input2_sector_id);//ID du secteur + SEC2->SetBranchAddress("nbLayers", &input2_sector_layers);// nombre de layers dans le secteur + SEC2->SetBranchAddress("layer", input2_sector_layer_list);//layers ID + SEC2->SetBranchAddress("nb_ladders_layer", input2_nb_ladders_layer); // nombre de ladders pour chaque layer + SEC2->SetBranchAddress("sectorLadders_layer_0", input2_sector_layer_0);//liste des ladders pour layer 0 + SEC2->SetBranchAddress("sectorLadders_layer_1", input2_sector_layer_1); + SEC2->SetBranchAddress("sectorLadders_layer_2", input2_sector_layer_2); + SEC2->SetBranchAddress("sectorLadders_layer_3", input2_sector_layer_3); + SEC2->SetBranchAddress("sectorLadders_layer_4", input2_sector_layer_4); + SEC2->SetBranchAddress("sectorLadders_layer_5", input2_sector_layer_5); + + PATT2->SetBranchAddress("nbLayers", &input2_nb_layers);//nombre de layers pour les patterns + PATT2->SetBranchAddress("nbPatterns", &input2_nb_patterns); // nombre de patterns dans l'evenement + PATT1->SetBranchAddress("nbStubsInEvt", &input2_ori_nb_stubs); // nombre de stubs dans l'evenement initial + PATT1->SetBranchAddress("nbStubsInPat", &input2_sel_nb_stubs); // nombre de stubs uniques dans les patterns + PATT2->SetBranchAddress("eventID", &input2_event_id); // ID de l'evenement (le meme que dans le fichier de simulation) + PATT2->SetBranchAddress("sectorID", input2_pattern_sector_id);// ID du secteur du pattern (permet de retrouver le secteur dans le premier TTree) + PATT2->SetBranchAddress("superStrip0", input2_superStrip_layer_0);// tableau de superstrips pour le layer 0 + PATT2->SetBranchAddress("superStrip1", input2_superStrip_layer_1); + PATT2->SetBranchAddress("superStrip2", input2_superStrip_layer_2); + PATT2->SetBranchAddress("superStrip3", input2_superStrip_layer_3); + PATT2->SetBranchAddress("superStrip4", input2_superStrip_layer_4); + PATT2->SetBranchAddress("superStrip5", input2_superStrip_layer_5); + PATT2->SetBranchAddress("total_nb_stubs", &input2_totalNbHits); + PATT2->SetBranchAddress("nbTracks", &input2_nbTracks); + PATT2->SetBranchAddress("nbStubs", input2_nbHitPerPattern); // nombre de stubs contenus dans chaque pattern + + PATT1->SetBranchAddress("track_pt", input2_track_pt); // PT of fitted tracks + PATT1->SetBranchAddress("track_phi", input2_track_phi); // PHI0 of fitted tracks + PATT1->SetBranchAddress("track_d0", input2_track_d0); // D0 of fitted tracks + PATT1->SetBranchAddress("track_eta", input2_track_eta); // ETA of fitted tracks + PATT1->SetBranchAddress("track_z0", input2_track_z0); // Z0 of fitted tracks + + PATT2->SetBranchAddress("stub_layers", input2_hit_layer);//layer du stub + PATT2->SetBranchAddress("stub_ladders", input2_hit_ladder);//ladder du stub + PATT2->SetBranchAddress("stub_module", input2_hit_zPos);//position en Z du module du stub + PATT2->SetBranchAddress("stub_segment", input2_hit_segment);//segment du stub + PATT2->SetBranchAddress("stub_strip", input2_hit_strip);//numero de strip du stub + PATT2->SetBranchAddress("stub_tp", input2_hit_tp);//numero de la particule du stub + PATT2->SetBranchAddress("stub_idx", input2_hit_idx);//index du stub dans l'evenement + PATT2->SetBranchAddress("stub_ptGEN", input2_hit_ptGEN);//PT de la particule du stub + PATT2->SetBranchAddress("stub_etaGEN", input2_hit_etaGEN);//PT de la particule du stub + PATT2->SetBranchAddress("stub_phi0GEN", input2_hit_phi0GEN);//PT de la particule du stub + PATT2->SetBranchAddress("stub_IP", input2_hit_ip);//distance avec l'IP + PATT2->SetBranchAddress("stub_x", input2_hit_x); + PATT2->SetBranchAddress("stub_y", input2_hit_y); + PATT2->SetBranchAddress("stub_z", input2_hit_z); + PATT2->SetBranchAddress("stub_X0", input2_hit_X0); + PATT2->SetBranchAddress("stub_Y0", input2_hit_Y0); + PATT2->SetBranchAddress("stub_Z0", input2_hit_Z0); + + /*********************OUTPUT FILE *************************************/ + TTree *PATTOUT = new TTree("Patterns", "Active patterns"); + TTree *SECOUT = new TTree("Sectors", "Used Sectors"); + TFile *t = new TFile(outputFile.c_str(),"recreate"); + + const int MAX_NB_OUTPUT_PATTERNS = 100000; + + int nb_layers; + int nb_patterns=0; + int ori_nb_stubs=0; + int sel_nb_stubs=0; + int event_id; + int *superStrip_layer_0 = new int[MAX_NB_OUTPUT_PATTERNS]; + int *superStrip_layer_1 = new int[MAX_NB_OUTPUT_PATTERNS]; + int *superStrip_layer_2 = new int[MAX_NB_OUTPUT_PATTERNS]; + int *superStrip_layer_3 = new int[MAX_NB_OUTPUT_PATTERNS]; + int *superStrip_layer_4 = new int[MAX_NB_OUTPUT_PATTERNS]; + int *superStrip_layer_5 = new int[MAX_NB_OUTPUT_PATTERNS]; + int *pattern_sector_id = new int[MAX_NB_OUTPUT_PATTERNS]; + + //Array containing the strips arrays + int* superStrips[MAX_NB_LAYERS]; + superStrips[0]=superStrip_layer_0; + superStrips[1]=superStrip_layer_1; + superStrips[2]=superStrip_layer_2; + superStrips[3]=superStrip_layer_3; + superStrips[4]=superStrip_layer_4; + superStrips[5]=superStrip_layer_5; + + int sector_id=0; + int sector_layers=0; + int nb_ladders_layer[MAX_NB_LAYERS]; + int sector_layer_list[MAX_NB_LAYERS]; + int sector_layer_0[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_1[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_2[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_3[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_4[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_5[MAX_NB_LADDERS_PER_LAYER]; + + int* sector_layers_detail[MAX_NB_LAYERS]; + sector_layers_detail[0]=sector_layer_0; + sector_layers_detail[1]=sector_layer_1; + sector_layers_detail[2]=sector_layer_2; + sector_layers_detail[3]=sector_layer_3; + sector_layers_detail[4]=sector_layer_4; + sector_layers_detail[5]=sector_layer_5; + + int *nbHitPerPattern = new int[MAX_NB_OUTPUT_PATTERNS]; + int totalNbHits=0; + int nbTracks = 0; + + float *track_pt = new float[MAX_NB_OUTPUT_PATTERNS]; + float *track_phi = new float[MAX_NB_OUTPUT_PATTERNS]; + float *track_d0 = new float[MAX_NB_OUTPUT_PATTERNS]; + float *track_eta = new float[MAX_NB_OUTPUT_PATTERNS]; + float *track_z0 = new float[MAX_NB_OUTPUT_PATTERNS]; + + short *hit_layer = new short[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + short *hit_ladder = new short[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + short *hit_zPos = new short[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + short *hit_segment = new short[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + short *hit_strip = new short[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + int *hit_tp = new int[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + int *hit_idx = new int[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_ptGEN = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_etaGEN = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_phi0GEN = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_ip = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_x = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_y = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_z = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_X0 = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_Y0 = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + float *hit_Z0 = new float[MAX_NB_OUTPUT_PATTERNS*MAX_NB_HITS]; + + SECOUT->Branch("sectorID", §or_id); + SECOUT->Branch("nbLayers", §or_layers); + SECOUT->Branch("layer", sector_layer_list, "layer[nbLayers]/I"); + SECOUT->Branch("nb_ladders_layer", nb_ladders_layer, "nb_ladders_layer[nbLayers]/I"); + SECOUT->Branch("sectorLadders_layer_0", sector_layer_0, "sectorLadders_layer_0[16]/I"); + SECOUT->Branch("sectorLadders_layer_1", sector_layer_1, "sectorLadders_layer_1[16]/I"); + SECOUT->Branch("sectorLadders_layer_2", sector_layer_2, "sectorLadders_layer_2[16]/I"); + SECOUT->Branch("sectorLadders_layer_3", sector_layer_3, "sectorLadders_layer_3[16]/I"); + SECOUT->Branch("sectorLadders_layer_4", sector_layer_4, "sectorLadders_layer_4[16]/I"); + SECOUT->Branch("sectorLadders_layer_5", sector_layer_5, "sectorLadders_layer_5[16]/I"); + + + PATTOUT->Branch("nbLayers", &nb_layers); + PATTOUT->Branch("nbPatterns", &nb_patterns); + PATTOUT->Branch("nbStubsInEvt", &ori_nb_stubs); + PATTOUT->Branch("nbStubsInPat", &sel_nb_stubs); + PATTOUT->Branch("eventID", &event_id); + PATTOUT->Branch("sectorID", pattern_sector_id, "sectorID[nbPatterns]/I"); + PATTOUT->Branch("superStrip0", superStrip_layer_0, "superStrip0[nbPatterns]/I"); + PATTOUT->Branch("superStrip1", superStrip_layer_1, "superStrip1[nbPatterns]/I"); + PATTOUT->Branch("superStrip2", superStrip_layer_2, "superStrip2[nbPatterns]/I"); + PATTOUT->Branch("superStrip3", superStrip_layer_3, "superStrip3[nbPatterns]/I"); + PATTOUT->Branch("superStrip4", superStrip_layer_4, "superStrip4[nbPatterns]/I"); + PATTOUT->Branch("superStrip5", superStrip_layer_5, "superStrip5[nbPatterns]/I"); + PATTOUT->Branch("nbStubs", nbHitPerPattern, "nbStubs[nbPatterns]/I"); + PATTOUT->Branch("total_nb_stubs", &totalNbHits, "total_nb_stubs/I"); + PATTOUT->Branch("nbTracks", &nbTracks, "nbTracks/I"); + PATTOUT->Branch("track_pt", track_pt, "track_pt[nbPatterns]/F"); + PATTOUT->Branch("track_phi", track_phi, "track_phi[nbPatterns]/F"); + PATTOUT->Branch("track_d0", track_d0, "track_d0[nbPatterns]/F"); + PATTOUT->Branch("track_eta", track_eta, "track_eta[nbPatterns]/F"); + PATTOUT->Branch("track_z0", track_z0, "track_z0[nbPatterns]/F"); + PATTOUT->Branch("stub_layers", hit_layer,"stub_layers[total_nb_stubs]/S"); + PATTOUT->Branch("stub_ladders", hit_ladder, "stub_ladders[total_nb_stubs]/S"); + PATTOUT->Branch("stub_module", hit_zPos, "stub_module[total_nb_stubs]/S"); + PATTOUT->Branch("stub_segment", hit_segment, "stub_segment[total_nb_stubs]/S"); + PATTOUT->Branch("stub_strip", hit_strip, "stub_strip[total_nb_stubs]/S"); + PATTOUT->Branch("stub_tp", hit_tp, "stub_tp[total_nb_stubs]/I"); + PATTOUT->Branch("stub_idx", hit_idx, "stub_idx[total_nb_stubs]/I"); + PATTOUT->Branch("stub_ptGEN", hit_ptGEN, "stub_ptGEN[total_nb_stubs]/F"); + PATTOUT->Branch("stub_etaGEN", hit_etaGEN, "stub_etaGEN[total_nb_stubs]/F"); + PATTOUT->Branch("stub_phi0GEN", hit_phi0GEN, "stub_phi0GEN[total_nb_stubs]/F"); + PATTOUT->Branch("stub_IP", hit_ip, "stub_IP[total_nb_stubs]/F"); + PATTOUT->Branch("stub_x", hit_x, "stub_x[total_nb_stubs]/F"); + PATTOUT->Branch("stub_y", hit_y, "stub_y[total_nb_stubs]/F"); + PATTOUT->Branch("stub_z", hit_z, "stub_z[total_nb_stubs]/F"); + PATTOUT->Branch("stub_X0", hit_X0, "stub_X0[total_nb_stubs]/F"); + PATTOUT->Branch("stub_Y0", hit_Y0, "stub_Y0[total_nb_stubs]/F"); + PATTOUT->Branch("stub_Z0", hit_Z0, "stub_Z0[total_nb_stubs]/F"); + + + /*********************************************/ + + /******************** MERGING SECTOR DATA************************/ + vector sectors; + //copy all the content of the first file + int nb_entries1 = SEC1->GetEntries(); + for(int i=0;iGetEntry(i); + sector_id = input1_sector_id; + sectors.push_back(sector_id); + sector_layers=input1_sector_layers; + memcpy(sector_layer_list, input1_sector_layer_list, sector_layers*sizeof(int)); + memcpy(nb_ladders_layer, input1_nb_ladders_layer, sector_layers*sizeof(int)); + for(int j=0;jFill(); + } + + //copy the content of the second file (only the unknown sectors) + int nb_entries2 = SEC2->GetEntries(); + for(int i=0;iGetEntry(i); + if(std::find(sectors.begin(),sectors.end(), input2_sector_id)==sectors.end()){ // We do not know this sector + sector_id = input2_sector_id; + sectors.push_back(sector_id); + sector_layers=input2_sector_layers; + memcpy(sector_layer_list, input2_sector_layer_list, sector_layers*sizeof(int)); + memcpy(nb_ladders_layer, input2_nb_ladders_layer, sector_layers*sizeof(int)); + for(int j=0;jFill(); + } + } + SECOUT->Write(); + + /******************** MERGING PATTERN DATA************************/ + //Loop on the events of the first file + nb_entries1 = PATT1->GetEntries(); + nb_entries2 = PATT2->GetEntries(); + + if(nb_entries1!=nb_entries2){ + cout<<"The 2 files do not have the same number of events -> CANCELED"<GetEntry(i); + PATT2->GetEntry(i); + + event_id = input1_event_id; + nb_layers = input1_nb_layers; + + if(input2_event_id!=event_id){ + cout<<"Cannot find event "< DROP EVENT"<Fill(); + } + + PATTOUT->Write(); + + t->Close(); + + delete [] input1_superStrip_layer_0; + delete [] input1_superStrip_layer_1; + delete [] input1_superStrip_layer_2; + delete [] input1_superStrip_layer_3; + delete [] input1_superStrip_layer_4; + delete [] input1_superStrip_layer_5; + delete [] input1_pattern_sector_id; + + delete [] input1_nbHitPerPattern; + delete [] input1_track_pt; + delete [] input1_track_phi; + delete [] input1_track_d0; + delete [] input1_track_eta; + delete [] input1_track_z0; + delete [] input1_hit_layer; + delete [] input1_hit_ladder; + delete [] input1_hit_zPos; + delete [] input1_hit_segment; + delete [] input1_hit_strip; + delete [] input1_hit_tp; + delete [] input1_hit_idx; + delete [] input1_hit_ptGEN; + delete [] input1_hit_etaGEN; + delete [] input1_hit_phi0GEN; + delete [] input1_hit_ip; + delete [] input1_hit_x; + delete [] input1_hit_y; + delete [] input1_hit_z; + delete [] input1_hit_X0; + delete [] input1_hit_Y0; + delete [] input1_hit_Z0; + + delete [] input2_superStrip_layer_0; + delete [] input2_superStrip_layer_1; + delete [] input2_superStrip_layer_2; + delete [] input2_superStrip_layer_3; + delete [] input2_superStrip_layer_4; + delete [] input2_superStrip_layer_5; + delete [] input2_pattern_sector_id; + + delete [] input2_nbHitPerPattern; + delete [] input2_track_pt; + delete [] input2_track_phi; + delete [] input2_track_d0; + delete [] input2_track_eta; + delete [] input2_track_z0; + delete [] input2_hit_layer; + delete [] input2_hit_ladder; + delete [] input2_hit_zPos; + delete [] input2_hit_segment; + delete [] input2_hit_strip; + delete [] input2_hit_tp; + delete [] input2_hit_idx; + delete [] input2_hit_ptGEN; + delete [] input2_hit_etaGEN; + delete [] input2_hit_phi0GEN; + delete [] input2_hit_ip; + delete [] input2_hit_x; + delete [] input2_hit_y; + delete [] input2_hit_z; + delete [] input2_hit_X0; + delete [] input2_hit_Y0; + delete [] input2_hit_Z0; + + delete [] superStrip_layer_0; + delete [] superStrip_layer_1; + delete [] superStrip_layer_2; + delete [] superStrip_layer_3; + delete [] superStrip_layer_4; + delete [] superStrip_layer_5; + delete [] pattern_sector_id; + delete [] track_pt; + delete [] track_phi; + delete [] track_d0; + delete [] track_eta; + delete [] track_z0; + delete [] nbHitPerPattern; + delete [] hit_layer; + delete [] hit_ladder; + delete [] hit_zPos; + delete [] hit_segment; + delete [] hit_strip; + delete [] hit_tp; + delete [] hit_idx; + delete [] hit_ptGEN; + delete [] hit_etaGEN; + delete [] hit_phi0GEN; + delete [] hit_ip; + delete [] hit_x; + delete [] hit_y; + delete [] hit_z; + delete [] hit_X0; + delete [] hit_Y0; + delete [] hit_Z0; + + delete PATT1; + delete PATT2; + delete SEC1; + delete SEC2; + delete PATTOUT; + delete SECOUT; + +} + +void PatternFinder::find(int start, int& stop){ + /**************** OUTPUT FILE ****************/ + TTree* Out = new TTree("Patterns", "Active patterns"); + TTree* SectorOut = new TTree("Sectors", "Used Sectors"); + TFile *t = new TFile(outputFileName.c_str(),"recreate"); + + const int MAX_NB_PATTERNS = 1500; + const int MAX_NB_HITS = 100; + const int MAX_NB_LADDERS_PER_LAYER = 16; + const int MAX_NB_LAYERS = 6; + + int nb_layers; + int nb_patterns=0; + int ori_nb_stubs=0; + int sel_nb_stubs=0; + int nb_tracks=0; + int event_id; + int superStrip_layer_0[MAX_NB_PATTERNS]; + int superStrip_layer_1[MAX_NB_PATTERNS]; + int superStrip_layer_2[MAX_NB_PATTERNS]; + int superStrip_layer_3[MAX_NB_PATTERNS]; + int superStrip_layer_4[MAX_NB_PATTERNS]; + int superStrip_layer_5[MAX_NB_PATTERNS]; + int pattern_sector_id[MAX_NB_PATTERNS]; + + //Array containing the strips arrays + int* superStrips[MAX_NB_LAYERS]; + superStrips[0]=superStrip_layer_0; + superStrips[1]=superStrip_layer_1; + superStrips[2]=superStrip_layer_2; + superStrips[3]=superStrip_layer_3; + superStrips[4]=superStrip_layer_4; + superStrips[5]=superStrip_layer_5; + + int sector_id=0; + int sector_layers=0; + int nb_ladders_layer[MAX_NB_LAYERS]; + int sector_layer_list[MAX_NB_LAYERS]; + int sector_layer_0[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_1[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_2[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_3[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_4[MAX_NB_LADDERS_PER_LAYER]; + int sector_layer_5[MAX_NB_LADDERS_PER_LAYER]; + + int* sector_layers_detail[MAX_NB_LAYERS]; + sector_layers_detail[0]=sector_layer_0; + sector_layers_detail[1]=sector_layer_1; + sector_layers_detail[2]=sector_layer_2; + sector_layers_detail[3]=sector_layer_3; + sector_layers_detail[4]=sector_layer_4; + sector_layers_detail[5]=sector_layer_5; + + int nbHitPerPattern[MAX_NB_PATTERNS]; + + float track_pt[MAX_NB_PATTERNS]; + float track_phi[MAX_NB_PATTERNS]; + float track_d0[MAX_NB_PATTERNS]; + float track_eta[MAX_NB_PATTERNS]; + float track_z0[MAX_NB_PATTERNS]; + + int totalNbHits=0; + short hit_layer[MAX_NB_PATTERNS*MAX_NB_HITS]; + short hit_ladder[MAX_NB_PATTERNS*MAX_NB_HITS]; + short hit_zPos[MAX_NB_PATTERNS*MAX_NB_HITS]; + short hit_segment[MAX_NB_PATTERNS*MAX_NB_HITS]; + short hit_strip[MAX_NB_PATTERNS*MAX_NB_HITS]; + int hit_tp[MAX_NB_PATTERNS*MAX_NB_HITS]; + int hit_idx[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_ptGEN[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_etaGEN[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_phi0GEN[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_ip[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_x[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_y[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_z[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_x0[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_y0[MAX_NB_PATTERNS*MAX_NB_HITS]; + float hit_z0[MAX_NB_PATTERNS*MAX_NB_HITS]; + + SectorOut->Branch("sectorID", §or_id); + SectorOut->Branch("nbLayers", §or_layers); + SectorOut->Branch("layer", sector_layer_list, "layer[nbLayers]/I"); + SectorOut->Branch("nb_ladders_layer", nb_ladders_layer, "nb_ladders_layer[nbLayers]/I"); + SectorOut->Branch("sectorLadders_layer_0", sector_layer_0, "sectorLadders_layer_0[16]/I"); + SectorOut->Branch("sectorLadders_layer_1", sector_layer_1, "sectorLadders_layer_1[16]/I"); + SectorOut->Branch("sectorLadders_layer_2", sector_layer_2, "sectorLadders_layer_2[16]/I"); + SectorOut->Branch("sectorLadders_layer_3", sector_layer_3, "sectorLadders_layer_3[16]/I"); + SectorOut->Branch("sectorLadders_layer_4", sector_layer_4, "sectorLadders_layer_4[16]/I"); + SectorOut->Branch("sectorLadders_layer_5", sector_layer_5, "sectorLadders_layer_5[16]/I"); + + Out->Branch("nbLayers", &nb_layers); + Out->Branch("nbPatterns", &nb_patterns); + Out->Branch("nbStubsInEvt", &ori_nb_stubs); + Out->Branch("nbStubsInPat", &sel_nb_stubs); + + Out->Branch("nbTracks", &nb_tracks); + + Out->Branch("eventID", &event_id); + Out->Branch("sectorID", pattern_sector_id, "sectorID[nbPatterns]/I"); + Out->Branch("superStrip0", superStrip_layer_0, "superStrip0[nbPatterns]/I"); + Out->Branch("superStrip1", superStrip_layer_1, "superStrip1[nbPatterns]/I"); + Out->Branch("superStrip2", superStrip_layer_2, "superStrip2[nbPatterns]/I"); + Out->Branch("superStrip3", superStrip_layer_3, "superStrip3[nbPatterns]/I"); + Out->Branch("superStrip4", superStrip_layer_4, "superStrip4[nbPatterns]/I"); + Out->Branch("superStrip5", superStrip_layer_5, "superStrip5[nbPatterns]/I"); + Out->Branch("nbStubs", nbHitPerPattern, "nbStubs[nbPatterns]/I"); + + Out->Branch("track_pt", track_pt, "track_pt[nbTracks]/F"); + Out->Branch("track_phi", track_phi, "track_phi[nbTracks]/F"); + Out->Branch("track_d0", track_d0, "track_d0[nbTracks]/F"); + Out->Branch("track_eta", track_eta, "track_eta[nbTracks]/F"); + Out->Branch("track_z0", track_z0, "track_z0[nbTracks]/F"); + + Out->Branch("total_nb_stubs", &totalNbHits, "total_nb_stubs/I"); + Out->Branch("stub_layers", hit_layer,"stub_layers[total_nb_stubs]/S"); + Out->Branch("stub_ladders", hit_ladder, "stub_ladders[total_nb_stubs]/S"); + Out->Branch("stub_module", hit_zPos, "stub_module[total_nb_stubs]/S"); + Out->Branch("stub_segment", hit_segment, "stub_segment[total_nb_stubs]/S"); + Out->Branch("stub_strip", hit_strip, "stub_strip[total_nb_stubs]/S"); + Out->Branch("stub_tp", hit_tp, "stub_tp[total_nb_stubs]/I"); + Out->Branch("stub_idx", hit_idx, "stub_idx[total_nb_stubs]/I"); + Out->Branch("stub_ptGEN", hit_ptGEN, "stub_ptGEN[total_nb_stubs]/F"); + Out->Branch("stub_etaGEN", hit_etaGEN, "stub_etaGEN[total_nb_stubs]/F"); + Out->Branch("stub_phi0GEN", hit_phi0GEN, "stub_phi0GEN[total_nb_stubs]/F"); + Out->Branch("stub_IP", hit_ip, "stub_IP[total_nb_stubs]/F"); + Out->Branch("stub_x", hit_x, "stub_x[total_nb_stubs]/F"); + Out->Branch("stub_y", hit_y, "stub_y[total_nb_stubs]/F"); + Out->Branch("stub_z", hit_z, "stub_z[total_nb_stubs]/F"); + Out->Branch("stub_X0", hit_x0, "stub_X0[total_nb_stubs]/F"); + Out->Branch("stub_Y0", hit_y0, "stub_Y0[total_nb_stubs]/F"); + Out->Branch("stub_Z0", hit_z0, "stub_Z0[total_nb_stubs]/F"); + + + /*********************************************/ + + /******************* SAVING SECTORS **************/ + map sectors_ids; + map sectors_map; + vector all_sectors = sectors->getAllSectors(); + for(unsigned int i=0;igetOfficialID(); + if(sector_id==-1) + sector_id=tmpSec->getKey(); + sector_layers = tmpSec->getNbLayers(); + for(int j=0;j sec_l = tmpSec->getLadders(j); + sector_layer_list[j] = tmpSec->getLayerID(j); + nb_ladders_layer[j] = sec_l.size(); + for(unsigned int l=0;lgetIDString()<<" -> "<getIDString()]=sector_id; + sectors_map[tmpSec->getIDString()]=tmpSec; + SectorOut->Fill(); + } + SectorOut->Write(); + delete SectorOut; + + /*************************************************/ + + /***************** INPUT FILE ****************/ + TChain* TT = new TChain("L1TrackTrigger"); + TT->Add(eventsFilename.c_str()); + + int n_evt; + + int m_stub; + + vector m_stub_layer; // Layer du stub (5 a 10 pour les 6 layers qui nous interessent) + vector m_stub_module; // Position en Z du module contenant le stub + vector m_stub_ladder; // Position en PHI du module contenant le stub + vector m_stub_seg; // Segment du module contenant le stub + vector m_stub_strip; // Strip du cluster interne du stub + vector m_stub_tp; // particule du stub + vector m_stub_px_gen; // pt initial de la particule ayant genere le stub + vector m_stub_py_gen; // pt initial de la particule ayant genere le stub + vector m_stub_x0; // utilise pour calculer la distance au point d'interaction + vector m_stub_y0; // utilise pour calculer la distance au point d'interaction + vector m_stub_z0; + vector m_stub_phi0; + vector m_stub_eta_gen; + vector m_stub_x; // x coordinate of the hit + vector m_stub_y; // y coordinate of the hit + vector m_stub_z; // z coordinate of the hit + + vector *p_m_stub_layer = &m_stub_layer; + vector *p_m_stub_module = &m_stub_module; + vector *p_m_stub_ladder = &m_stub_ladder; + vector *p_m_stub_seg = &m_stub_seg; + vector *p_m_stub_strip = &m_stub_strip; + vector *p_m_stub_tp = &m_stub_tp; + vector *p_m_stub_pxGEN = &m_stub_px_gen; + vector *p_m_stub_pyGEN = &m_stub_py_gen; + vector *p_m_stub_x0 = &m_stub_x0; + vector *p_m_stub_y0 = &m_stub_y0; + vector *p_m_stub_z0 = &m_stub_z0; + vector *p_m_stub_phi0 = &m_stub_phi0; + vector *p_m_stub_etaGEN = &m_stub_eta_gen; + vector *p_m_stub_x = &m_stub_x; + vector *p_m_stub_y = &m_stub_y; + vector *p_m_stub_z = &m_stub_z; + + + TT->SetBranchAddress("evt", &n_evt); + TT->SetBranchAddress("STUB_n", &m_stub); + TT->SetBranchAddress("STUB_layer", &p_m_stub_layer); + TT->SetBranchAddress("STUB_module", &p_m_stub_module); + TT->SetBranchAddress("STUB_ladder", &p_m_stub_ladder); + TT->SetBranchAddress("STUB_seg", &p_m_stub_seg); + TT->SetBranchAddress("STUB_strip", &p_m_stub_strip); + TT->SetBranchAddress("STUB_tp", &p_m_stub_tp); + TT->SetBranchAddress("STUB_X0", &p_m_stub_x0); + TT->SetBranchAddress("STUB_Y0", &p_m_stub_y0); + TT->SetBranchAddress("STUB_Z0", &p_m_stub_z0); + TT->SetBranchAddress("STUB_PHI0", &p_m_stub_phi0); + TT->SetBranchAddress("STUB_etaGEN", &p_m_stub_etaGEN); + TT->SetBranchAddress("STUB_pxGEN", &p_m_stub_pxGEN); + TT->SetBranchAddress("STUB_pyGEN", &p_m_stub_pyGEN); + TT->SetBranchAddress("STUB_x", &p_m_stub_x); + TT->SetBranchAddress("STUB_y", &p_m_stub_y); + TT->SetBranchAddress("STUB_z", &p_m_stub_z); + + /*******************************************************/ + + int n_entries_TT = TT->GetEntries(); + int num_evt = start; + if(stop>n_entries_TT){ + stop=n_entries_TT-1; + cout<<"Last event index too high : reset to "<GetEntry(num_evt); + + cout<<"Event "< hits; + + for(int i=0;i out of range + continue; + int ladder = CMSPatternLayer::getLadderCode(layer, m_stub_ladder[i]); + int segment = CMSPatternLayer::getSegmentCode(layer, ladder, m_stub_seg[i]); + if(segment<0 || segment>1){ + cout<<"Invalid segment on event "<getSector(*h)!=NULL) + hits.push_back(h); + else + delete(h); + } + + vector pattern_list = find(hits); + + //Traitement des patterns actif : enregistrement, affichage... + nb_layers = tracker.getNbLayers(); + event_id=num_evt;//we use the index in the file as event_id (most of our input files do not have a valid event_id) + nb_patterns = 0; + ori_nb_stubs = (int)hits.size(); + + nb_tracks = 0; + for(int i=0;i pl = pattern_list[i]->getPatternTree()->getLDPatterns(); + vector tracks; + + /////////FITTER//// + TrackFitter* fitter = (sectors_map[pattern_list[i]->getIDString()])->getFitter(); + if(fitter!=NULL){ + for(unsigned int l=0;laddPattern(pl[l]); + } + fitter->mergePatterns(); + fitter->fit(); + fitter->mergeTracks(); + tracks = fitter->getTracks(); + fitter->clean(); + } + else{ + cout<<"No fitter found for this sector!"<getIDString()]; + nbHitPerPattern[patternIndex]=0; + //loop on the patterns + unsigned int max_patterns = pl.size(); + unsigned int max_tracks = tracks.size(); + if((int)max_patterns>MAX_NB_PATTERNS){ + max_patterns=MAX_NB_PATTERNS; + nb_patterns=MAX_NB_PATTERNS; + if(max_tracks>max_patterns) + max_tracks=max_patterns; + cout<<"WARNING : Too may patterns in event "< keep only the first "< stub_ids; + + for(unsigned int j=0;jgetLayerStrip(k)->getIntValue(); + superStrips[k][patternIndex]=sstripValue; + } + //sector of the pattern + pattern_sector_id[patternIndex]=sec_id; + + //stubs of the patterns + vector active_hits = pl[j]->getHits(); + int nbHits = active_hits.size(); + if(nbHits>MAX_NB_HITS) // if we have too many hits, we keep only the MAX_NB_HITS first + nbHits=MAX_NB_HITS; + nbHitPerPattern[patternIndex]=nbHits; + totalNbHits+=nbHits; + for(int k=0;kgetLayer(); + hit_ladder[stubIndex]=active_hits[k]->getLadder(); + hit_zPos[stubIndex]=active_hits[k]->getModule(); + hit_segment[stubIndex]=active_hits[k]->getSegment(); + hit_strip[stubIndex]=active_hits[k]->getStripNumber(); + hit_tp[stubIndex]=active_hits[k]->getParticuleID(); + hit_idx[stubIndex]=active_hits[k]->getID(); + hit_ptGEN[stubIndex]=active_hits[k]->getParticulePT(); + hit_etaGEN[stubIndex]=active_hits[k]->getParticuleETA(); + hit_phi0GEN[stubIndex]=active_hits[k]->getParticulePHI0(); + hit_ip[stubIndex]=active_hits[k]->getParticuleIP(); + hit_x[stubIndex]=active_hits[k]->getX(); + hit_y[stubIndex]=active_hits[k]->getY(); + hit_z[stubIndex]=active_hits[k]->getZ(); + hit_x0[stubIndex]=active_hits[k]->getX0(); + hit_y0[stubIndex]=active_hits[k]->getY0(); + hit_z0[stubIndex]=active_hits[k]->getZ0(); + + stub_ids.insert(active_hits[k]->getID()); + + stubIndex++; + } + + patternIndex++; + delete pl[j]; + } + + sel_nb_stubs = stub_ids.size(); + + for(unsigned int j=0;jgetCurve(); + track_phi[trackIndex]= tracks[j]->getPhi0(); + track_d0[trackIndex] = tracks[j]->getD0(); + track_eta[trackIndex]= tracks[j]->getEta0(); + track_z0[trackIndex] = tracks[j]->getZ0(); + delete tracks[j]; + trackIndex++; + } + } + Out->Fill(); + + ////////////////////////////////// + for(unsigned int i=0;iPrint(); + Out->Write(); + t->Close(); + delete Out; + delete t; + + delete TT; +} + +vector PatternFinder::find(vector hits){ + tracker.clear(); + for(unsigned int i=0;igetActivePatternsPerSector(active_threshold); +} + diff --git a/L1Trigger/TrackFindingAM/src/PatternGenerator.cc b/L1Trigger/TrackFindingAM/src/PatternGenerator.cc new file mode 100644 index 0000000000000..18cbe58d7a87b --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/PatternGenerator.cc @@ -0,0 +1,439 @@ +#include "../interface/PatternGenerator.h" + +PatternGenerator::PatternGenerator(int sp){ + superStripSize = sp; + variableRes = 0; + ptMin=2; + ptMax=100; + etaMin=0.0f; + etaMax=1.0f; +} + +void PatternGenerator::setSuperStripSize(int sp){ + superStripSize = sp; +} + +void PatternGenerator::setMinPT(float minp){ + if(minp>0) + ptMin = minp; +} + +void PatternGenerator::setMaxPT(float maxp){ + if(maxp>0) + ptMax = maxp; +} + +void PatternGenerator::setMinEta(float mine){ + etaMin = mine; +} + +void PatternGenerator::setMaxEta(float maxe){ + etaMax = maxe; +} + +void PatternGenerator::setMaxFakeSuperstrips(int mf){ + if(mf>-1) + nbMaxFakeSuperstrips = mf; + else + nbMaxFakeSuperstrips = 0; +} + +void PatternGenerator::setLayers(vector l){ + tracker_layers = l; + sort(tracker_layers.begin(),tracker_layers.end()); +} + +void PatternGenerator::setParticuleDirName(string f){ + particuleDirName = f; +} + +void PatternGenerator::setVariableResolution(int nb){ + if(nb<0 || nb>3) + nb = 0; + variableRes = nb; +} + +int PatternGenerator::getVariableResolutionState(){ + return variableRes; +} + +TChain* PatternGenerator::createTChain(string directoryName, string tchainName){ + + cout<<"Loading files from "<GetName(); + if (!file->IsDirectory() && fname.EndsWith(".root")) { + TT->Add((directoryName + fname.Data()).c_str()); + } + } + } + else{//TSystemDirectory not supported for xrootd + /* + If using xrootd, directoryName should be a file (not a directory) containing one input file name per line + */ + ifstream in(directoryName.c_str()); + string fname; + + while (std::getline(in,fname)){ + TT->Add(fname.c_str()); + } + + in.close(); + } + + // p_m_stub_tp = &m_stub_tp; + p_m_stub_layer = &m_stub_layer; + p_m_stub_module = &m_stub_module; + p_m_stub_ladder = &m_stub_ladder; + p_m_stub_seg = &m_stub_seg; + p_m_stub_strip = &m_stub_strip; + p_m_stub_pxGEN = &m_stub_pxGEN; + p_m_stub_pyGEN = &m_stub_pyGEN; + p_m_stub_etaGEN = &m_stub_etaGEN; + + TT->SetBranchAddress("STUB_n", &m_stub); + // TT->SetBranchAddress("STUB_tp", &p_m_stub_tp); + TT->SetBranchAddress("STUB_layer", &p_m_stub_layer); + TT->SetBranchAddress("STUB_module", &p_m_stub_module); + TT->SetBranchAddress("STUB_ladder", &p_m_stub_ladder); + TT->SetBranchAddress("STUB_seg", &p_m_stub_seg); + TT->SetBranchAddress("STUB_strip", &p_m_stub_strip); + TT->SetBranchAddress("STUB_pxGEN", &p_m_stub_pxGEN); + TT->SetBranchAddress("STUB_pyGEN", &p_m_stub_pyGEN); + TT->SetBranchAddress("STUB_etaGEN", &p_m_stub_etaGEN); + + int nb_entries = TT->GetEntries(); + cout< > eta_limits){ + + if(tracker_layers.size()==0){ + cout<<"No layer defined!"< patterns; + + sectors->setSuperStripSize(superStripSize); + + //--> Signification (et dimension) des variables + + int n_entries_TT = TT->GetEntries(); + + int nbInLayer=0; + int nbInSector = 0; + int nbModuleOk = 0; + + int ld_fd_factor = (int)pow(2.0,(double)variableRes); + + int layers[tracker_layers.size()]; + vector ladder_per_layer(tracker_layers.size()); + vector module_per_layer(tracker_layers.size()); + + while(nbModuleOkGetEntry((*evtIndex)); + (*evtIndex)++; + + //cout<<"index "<<*evtIndex< we do not use it for pattern generation + continue; + } + if(m_stub_etaGEN[j]>etaMax){// eta of the generating particule is above the threshold -> we do not use it for pattern generation + continue; + } + float pt_GEN = sqrt(m_stub_pxGEN[j]*m_stub_pxGEN[j]+m_stub_pyGEN[j]*m_stub_pyGEN[j]); + if(pt_GEN we do not use it for pattern generation + continue; + } + if(pt_GEN>ptMax){// The PT of the generating particule is above the maximum accepted -> we do not use it for pattern generation + continue; + } + int layer = m_stub_layer[j]; + + int layer_position=-1; + for(unsigned int cpt=0;cptgetNbSectors()==1 && current_eta!=-10){ // we can use fake superstrips if we know the sector in which to add the tracks and if we have at least one stub (current_eta!=10) + if(eta_limits.find(tracker_layers[j])!=eta_limits.end()){//we have eta boundaries for this layer + pair limits = eta_limits[tracker_layers[j]]; + if(current_etalimits.second){ // we are outside the eta limits for this layer -> we will add a fake superstrip for this layer + if(nbFakeSuperstrip drop the event + } + + nbInLayer++; + + // cout<<"trace ok"<getSector(ladder_per_layer, module_per_layer); + + /* + for(unsigned int j=0;jgetModuleCode(tracker_layers[j], CMSPatternLayer::getLadderCode(tracker_layers[j],m_stub_ladder[stub_number]), CMSPatternLayer::getModuleCode(tracker_layers[j],m_stub_module[stub_number])); + + ladder=sector->getLadderCode(tracker_layers[j],CMSPatternLayer::getLadderCode(tracker_layers[j],m_stub_ladder[stub_number])); + + // cout<<"Layer "<setLayerStrip(j, &pat); + + if(variableRes){ + lowDef_layer.setValues(module, ladder, stripLD, seg); + lowDef_p->setLayerStrip(j, &lowDef_layer); + } + + } + + if(p==NULL){ + continue; + } + nbModuleOk++; + + //cout<<"creation pattern : "<getPatternTree()->addPattern(lowDef_p,p, last_pt); + } + else{ + sector->getPatternTree()->addPattern(p,NULL, last_pt); + } + + delete p; + if(lowDef_p!=NULL) + delete lowDef_p; + + } + + *nbTrackUsed=nbModuleOk; + + cout<<"Event index : "<<*evtIndex<getFDPatternNumber(); + else + return sectors->getLDPatternNumber(); + +} + + + +void PatternGenerator::generate(SectorTree* sectors, int step, float threshold, map > eta_limits){ + int nbPatterns = 1; + int newCount = 0; + int indexPart = 0; + float dif=1; + + int loop=0; + + int nbTracks = 0; + int trackUsed = 0; + + float tracks[10000]; + float patterns[10000]; + int iterationNbTracks=1; + + //creates the TChain from the directory name + TChain* tc = createTChain(particuleDirName, particuleDirName); + + cout<<"Starting patterns generation using iterations of "<0){ + loop++; + iterationNbTracks=0; + newCount = generate(tc, &indexPart, step, &nbTracks, sectors, eta_limits); + trackUsed+=nbTracks; + iterationNbTracks+=nbTracks; + dif=(newCount-nbPatterns)/(float)iterationNbTracks;//% of coverage for this iteration + nbPatterns=newCount; + if(iterationNbTracks!=0){ + tracks[loop-1]=nbPatterns; + patterns[loop-1]=(1-dif)*100; + } + if(loop>1) + cout<<"Current patterns bank size : "<SetTitle("Pattern Bank Generation"); + nbPatt->GetXaxis()->SetTitle("Patterns bank size"); + nbPatt->GetYaxis()->SetTitle("Coverage (%)"); + cout<Write(); + delete nbPatt; + + if(variableRes){ + cout<<"Creating variable resolution bank..."<computeAdaptativePatterns(variableRes); + } + + vector v_sector = sectors->getAllSectors(); + for(unsigned int k=0;k PT = v_sector[k]->getPatternTree()->getPTHisto(); + TH1I* pt_histo = new TH1I("PT sector "+k,"PT of pattern generating tracks", 110, 0, 110); + for(int i=0;i<101;i++){ + for(int j=0;jFill(i); + } + } + pt_histo->SetFillColor(41); + pt_histo->Write(); + delete pt_histo; + } +} diff --git a/L1Trigger/TrackFindingAM/src/PatternLayer.cc b/L1Trigger/TrackFindingAM/src/PatternLayer.cc new file mode 100644 index 0000000000000..25dffdf4500ce --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/PatternLayer.cc @@ -0,0 +1,119 @@ +#include +#include +#include "../interface/PatternLayer.h" + +map PatternLayer::GRAY_POSITIONS = PatternLayer::CreateMap(); + +map PatternLayer::CreateMap(){ + map p; + p[""]=0; + p["0"]=0; + p["1"]=1; + p["00"]=0; + p["01"]=1; + p["10"]=3; + p["11"]=2; + p["000"]=0; + p["001"]=1; + p["011"]=2; + p["010"]=3; + p["110"]=4; + p["111"]=5; + p["101"]=6; + p["100"]=7; + return p; +} + +PatternLayer::PatternLayer(){ + bits=0; + memset(dc_bits,3,DC_BITS*sizeof(char)); +} + +char PatternLayer::getDC(int index){ + if(index<0 || index>=DC_BITS) + index=0; + return dc_bits[index]; +} + +void PatternLayer::setDC(int index, char val){ + if(val<0 || val>3) + val=3; + if(index<0 || index>=DC_BITS) + index=0; + dc_bits[index]=val; +} + +string PatternLayer::getCode(){ + int c=bits.to_ulong(); + ostringstream oss; + oss< dc, vector& positions){ + int index = -1; + bool containsX = false; + + for(int i=0;i v1; + vector v2; + vector newDC1 = dc; + vector newDC2 = dc; + + newDC1[index]=0; + newDC2[index]=1; + getPositionsFromDC(newDC1, v1); + getPositionsFromDC(newDC2, v2); + for(unsigned int i=0;i& positions){ + vector v; + for(int i=0;i::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + delete (itr->second); + } +} + +void PatternTree::addPattern(Pattern* ldp, Pattern* fdp){ + string key = ldp->getKey(); + map::iterator it = patterns.find(key); + if(it==patterns.end()){//not found + PatternTrunk* pt = new PatternTrunk(ldp); + pt->addFDPattern(fdp); + patterns[key]=pt; + } + else{ + (it->second)->addFDPattern(fdp); + } +} + +void PatternTree::addPattern(Pattern* ldp, Pattern* fdp, float new_pt){ + string key = ldp->getKey(); + map::iterator it = patterns.find(key); + if(it==patterns.end()){//not found + PatternTrunk* pt = new PatternTrunk(ldp); + pt->addFDPattern(fdp, new_pt); + patterns[key]=pt; + } + else{ + (it->second)->addFDPattern(fdp, new_pt); + } +} + +vector PatternTree::getFDPatterns(){ + vector res; + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + vector fdp = itr->second->getFDPatterns(); + res.insert(res.end(), fdp.begin(), fdp.end()); + } + return res; +} + +vector PatternTree::getLDPatterns(){ + vector res; + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + GradedPattern* ldp = itr->second->getLDPattern(); + res.push_back(ldp); + } + return res; +} + +vector PatternTree::getPTHisto(){ + vector h; + for(int i=0;i<150;i++){ + h.push_back(0); + } + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + float pt = itr->second->getLDPatternPT(); + if(pt>149) + pt=149; + if(pt<0) + pt=0; + h[(int)pt]=h[(int)pt]+1; + } + return h; +} + +int PatternTree::getFDPatternNumber(){ + vector res; + int num=0; + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + num += itr->second->getFDPatternNumber(); + } + return num; +} + +int PatternTree::getLDPatternNumber(){ + return patterns.size(); +} + +void PatternTree::computeAdaptativePatterns(short r){ + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + itr->second->computeAdaptativePattern(r); + } +} + +void PatternTree::link(Detector& d, const vector< vector >& sec, const vector > >& modules){ + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + itr->second->link(d,sec, modules); + } +} + +void PatternTree::getActivePatterns(int active_threshold, vector& active_patterns){ + for(map::iterator itr = patterns.begin(); itr != patterns.end(); ++itr){ + GradedPattern* p = itr->second->getActivePattern(active_threshold); + if(p!=NULL) + active_patterns.push_back(p); + } +} + +void PatternTree::addPatternsFromTree(PatternTree* p){ + vector ld = p->getLDPatterns(); + for(unsigned int i=0;igetKey(); + map::iterator it = patterns.find(key); + if(it==patterns.end()){//not found + PatternTrunk* pt = new PatternTrunk(ldp); + for(int i=0;igetGrade();i++){ + pt->addFDPattern(NULL, ldp->getAveragePt()); + } + patterns[key]=pt; + } + else{ + (it->second)->updateDCBits(ldp); + for(int i=0;igetGrade();i++){ + (it->second)->addFDPattern(NULL, ldp->getAveragePt()); + } + } +} diff --git a/L1Trigger/TrackFindingAM/src/PatternTrunk.cc b/L1Trigger/TrackFindingAM/src/PatternTrunk.cc new file mode 100644 index 0000000000000..3bb1710c35355 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/PatternTrunk.cc @@ -0,0 +1,237 @@ +#include "../interface/PatternTrunk.h" + +PatternTrunk::PatternTrunk(Pattern* p){ + lowDefPattern = new GradedPattern(*p); +} + +PatternTrunk::PatternTrunk(){ + lowDefPattern = new GradedPattern(); +} + +PatternTrunk::~PatternTrunk(){ + for(map::iterator itr = fullDefPatterns.begin(); itr != fullDefPatterns.end(); ++itr){ + delete itr->second; + } + delete lowDefPattern; +} + +void PatternTrunk::addFDPattern(Pattern* p){ + lowDefPattern->increment(); + if(p!=NULL){ + string key=p->getKey(); + map::iterator it = fullDefPatterns.find(key); + if(it==fullDefPatterns.end()){//not found + GradedPattern* gp = new GradedPattern(*p); + gp->increment(); + fullDefPatterns[key]=gp; + } + else{ + (it->second)->increment(); + } + } +} + +void PatternTrunk::addFDPattern(Pattern* p, float pt){ + lowDefPattern->increment(pt); + if(p!=NULL){ + string key=p->getKey(); + map::iterator it = fullDefPatterns.find(key); + if(it==fullDefPatterns.end()){//not found + GradedPattern* gp = new GradedPattern(*p); + gp->increment(pt); + fullDefPatterns[key]=gp; + } + else{ + (it->second)->increment(pt); + } + } +} + +vector PatternTrunk::getFDPatterns(){ + vector res; + for(map::iterator itr = fullDefPatterns.begin(); itr != fullDefPatterns.end(); ++itr){ + res.push_back(new GradedPattern(*(itr->second))); + } + return res; +} + +GradedPattern* PatternTrunk::getLDPattern(){ + return new GradedPattern(*lowDefPattern); +} + +float PatternTrunk::getLDPatternPT(){ + return lowDefPattern->getAveragePt(); +} + +int PatternTrunk::getFDPatternNumber(){ + return fullDefPatterns.size(); +} + +void PatternTrunk::link(Detector& d, const vector< vector >& sec, const vector > >& modules){ + lowDefPattern->link(d, sec, modules); +} + +GradedPattern* PatternTrunk::getActivePattern(int active_threshold){ + if(lowDefPattern->isActive(active_threshold)){ + return new GradedPattern(*lowDefPattern); + } + return NULL; +} + +void PatternTrunk::deleteFDPatterns(){ + for(map::iterator itr = fullDefPatterns.begin(); itr != fullDefPatterns.end(); ++itr){ + delete itr->second; + } + fullDefPatterns.clear(); +} + +/* + This method is recursive. We know what to do with arrays with only two elements. + If the size is above 2, we split the array in 2 smaller arrays and call the method on both parts. + As we are using gray code, it's a bit tricky to know if we need to put a 0 or a 1. If you are in + the first half array -> 0 left branch and 1 right branch. If you are in the second half it's the opposite. + The 'reverse' parameter is used to know in which half array we are. + */ +void PatternTrunk::computeDCBits(vector &v, bool* values, int size, int reverse){ + + + if(size==2){ + if(values[0] && values[1]){ + v.push_back(2); + return; + } + if(values[0]){ + v.push_back(reverse); + return; + } + else{ + v.push_back(1-reverse); + return; + } + } + + bool half1=0; + bool half2=0; + + for(int i=0;i v1; + vector v2; + computeDCBits(v1, values, size/2, 0); + computeDCBits(v2, values+size/2, size/2, 1); + v.push_back(2); + for(unsigned int i=0;i v1; + computeDCBits(v1, values, size/2, 0); + v.push_back(reverse); + for(unsigned int i=0;i v1; + computeDCBits(v1, values+size/2, size/2, 1); + v.push_back(1-reverse); + for(unsigned int i=0;igetNbLayers(); + for(int i=0;igetLayerStrip(i); + //cout<toString()<getStrip(); + + for(map::iterator itr = fullDefPatterns.begin(); itr != fullDefPatterns.end(); ++itr){ + PatternLayer* fd_pl = itr->second->getLayerStrip(i); + //cout<<" "<toString()<getStrip()-size*ld_position; + strips[index]=true; + } + /* + for(int j=0;j bits; + computeDCBits(bits,strips,size,0); + + for(unsigned int j=0;jsetDC(j,bits[j]); + } + } + deleteFDPatterns(); +} + +void PatternTrunk::updateDCBits(GradedPattern* p){ + if(lowDefPattern->getKey().compare(p->getKey())==0){//the pattern layers are similar -> we update the DC bits + int nb_layers = lowDefPattern->getNbLayers(); + int nb_dc1 = lowDefPattern->getLayerStrip(0)->getDCBitsNumber(); + int nb_dc2 = p->getLayerStrip(0)->getDCBitsNumber(); + int max_nb_dc; + if(nb_dc1>nb_dc2) + max_nb_dc = nb_dc1; + else + max_nb_dc = nb_dc2; + if(max_nb_dc==0) + return; + int size = (int)pow(2.0,max_nb_dc); + bool strips[size]; + + for(int i=0;igetLayerStrip(i); + + vector positions; + pl->getPositionsFromDC(positions); + for(unsigned int j=0;jgetLayerStrip(i); + pl2->getPositionsFromDC(positions); + for(unsigned int j=0;j bits; + computeDCBits(bits,strips,size,0); + + for(unsigned int j=0;jsetDC(j,bits[j]); + } + } + } +} diff --git a/L1Trigger/TrackFindingAM/src/PrincipalFitGenerator.cc b/L1Trigger/TrackFindingAM/src/PrincipalFitGenerator.cc new file mode 100644 index 0000000000000..a2c9c0dbab13c --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/PrincipalFitGenerator.cc @@ -0,0 +1,367 @@ +#include "../interface/PrincipalFitGenerator.h" +#include "../interface/PatternFinder.h" + +PrincipalFitGenerator::PrincipalFitGenerator(string f, SectorTree *s){ + inputDirectory = f; + st = s; +} + +TChain* PrincipalFitGenerator::createTChain(){ + + cout<<"Loading files from "<GetName(); + if (!file->IsDirectory() && fname.EndsWith(".root")) { + TT->Add((inputDirectory + fname.Data()).c_str()); + } + } + } + + p_m_stub_tp = &m_stub_tp; + p_m_stub_layer = &m_stub_layer; + p_m_stub_module = &m_stub_module; + p_m_stub_ladder = &m_stub_ladder; + p_m_stub_pxGEN = &m_stub_pxGEN; + p_m_stub_pyGEN = &m_stub_pyGEN; + p_m_stub_etaGEN = &m_stub_etaGEN; + p_m_stub_x = &m_stub_x; + p_m_stub_y = &m_stub_y; + p_m_stub_z = &m_stub_z; + p_m_clus_zmc = &m_clus_zmc; + p_m_stub_clust1 = &m_stub_clust1; + p_m_stub_pdg = &m_stub_pdg; + p_m_stub_x0 = &m_stub_x0; + p_m_stub_y0 = &m_stub_y0; + p_m_stub_z0 = &m_stub_z0; + + TT->SetBranchAddress("STUB_n", &m_stub); + TT->SetBranchAddress("STUB_tp", &p_m_stub_tp); + TT->SetBranchAddress("STUB_layer", &p_m_stub_layer); + TT->SetBranchAddress("STUB_module", &p_m_stub_module); + TT->SetBranchAddress("STUB_ladder", &p_m_stub_ladder); + TT->SetBranchAddress("STUB_pxGEN", &p_m_stub_pxGEN); + TT->SetBranchAddress("STUB_pyGEN", &p_m_stub_pyGEN); + TT->SetBranchAddress("STUB_etaGEN", &p_m_stub_etaGEN); + TT->SetBranchAddress("STUB_x", &p_m_stub_x); + TT->SetBranchAddress("STUB_y", &p_m_stub_y); + TT->SetBranchAddress("STUB_z", &p_m_stub_z); + TT->SetBranchAddress("STUB_pdgID", &p_m_stub_pdg); + TT->SetBranchAddress("STUB_clust1", &p_m_stub_clust1); + TT->SetBranchAddress("CLUS_zmc", &p_m_clus_zmc); + TT->SetBranchAddress("STUB_X0", &p_m_stub_x0); + TT->SetBranchAddress("STUB_Y0", &p_m_stub_y0); + TT->SetBranchAddress("STUB_Z0", &p_m_stub_z0); + + int nb_entries = TT->GetEntries(); + cout< > eta_limits, float min_pt, float max_pt, float min_eta, float max_eta){ + + if(st->getNbSectors()==0){ + cout<<"No sector found"< > detector_config = Sector::readConfig("detector.cfg"); + //Get the layers IDs + vector tracker_layers; + Sector* first_sector = st->getAllSectors()[0]; + for(int i=0;igetNbLayers();i++){ + tracker_layers.push_back(first_sector->getLayerID(i)); + } + int nb_ladders = -1; + if(detector_config.find(first_sector->getLayerID(0))!=detector_config.end()){ + nb_ladders = detector_config[first_sector->getLayerID(0)][1]; + } + else{ + cout<<"We do not know the number of ladders in layer "<getLayerID(0)<GetEntries(); + + int evtIndex=0; + + int layers[tracker_layers.size()]; + vector ladder_per_layer(tracker_layers.size()); + vector module_per_layer(tracker_layers.size()); + + int max_tracks_number = 10000000; + + while(evtIndexGetEntry(evtIndex++); + + if(evtIndex%100000==0) + cout<<"Event "<getSector(ladder_per_layer, module_per_layer); + if(sector==NULL){ + //cout<<"No sector found"<getLadderCode(tracker_layers[0],CMSPatternLayer::getLadderCode(tracker_layers[0],m_stub_ladder[layers[0]]))); + + PrincipalTrackFitter* fitter = (PrincipalTrackFitter*)sector->getFitter(); + if(fitter==NULL){ + cout<<"No fitter associated to the sector, creating a default one!"<getNbLayers(), 1000); + sector->setFitter(fitter); + } + fitter->setPhiRotation(sec_phi); + + double data_coord[3*tracker_layers.size()]; + int data_tracker[3*tracker_layers.size()]; + + for(unsigned int i=0;i7) + data_coord[i*3+2]=m_stub_z[j]; + else + data_coord[i*3+2]=m_clus_zmc[m_stub_clust1[j]]; + + data_tracker[i*3]=sector->getLayerIndex(m_stub_layer[j]); + data_tracker[i*3+1]=sector->getLadderCode(m_stub_layer[j],m_stub_ladder[j]); + data_tracker[i*3+2] = sector->getModuleCode(m_stub_layer[j], CMSPatternLayer::getLadderCode(m_stub_layer[j],m_stub_ladder[j]), CMSPatternLayer::getModuleCode(m_stub_layer[j],m_stub_module[j])); + } + + fitter->addTrackForPrincipal(data_tracker, data_coord); + if(fitter->hasPrincipalParams())//The params are computed->we stop the process + break; + + if(evtIndex>max_tracks_number){ + fitter->forcePrincipalParamsComputing(); + } + + } + + delete TT; +} + +void PrincipalFitGenerator::generateMultiDim(map > eta_limits, float min_pt, float max_pt, float min_eta, float max_eta){ + + if(st->getNbSectors()==0){ + cout<<"No sector found"< > detector_config = Sector::readConfig("detector.cfg"); + + //Get the layers IDs + vector tracker_layers; + Sector* first_sector = st->getAllSectors()[0]; + cout<<"on utilise les layers "; + for(int i=0;igetNbLayers();i++){ + tracker_layers.push_back(first_sector->getLayerID(i)); + cout<getLayerID(i)<<","; + } + cout<getLayerID(0))!=detector_config.end()){ + nb_ladders = detector_config[first_sector->getLayerID(0)][1]; + } + else{ + cout<<"We do not know the number of ladders in layer "<getLayerID(0)<GetEntries(); + + int evtIndex=0; + + int layers[tracker_layers.size()]; + vector ladder_per_layer(tracker_layers.size()); + vector module_per_layer(tracker_layers.size()); + + int max_tracks_number = 10000000; + + while(evtIndexGetEntry(evtIndex++); + + if(evtIndex%100000==0) + cout<<"Event "<getSector(ladder_per_layer, module_per_layer); + if(sector==NULL){ + //cout<<"No sector found"<getFitter(); + if(fitter==NULL){ + cout<<"No fitter associated to the sector!"<7) + data_coord[i*3+2]=m_stub_z[j]; + else + data_coord[i*3+2]=m_clus_zmc[m_stub_clust1[j]]; + + data_tracker[i*3]=sector->getLayerIndex(m_stub_layer[j]); + data_tracker[i*3+1]=sector->getLadderCode(m_stub_layer[j],CMSPatternLayer::getLadderCode(m_stub_layer[j],m_stub_ladder[j])); + data_tracker[i*3+2] = sector->getModuleCode(m_stub_layer[j], CMSPatternLayer::getLadderCode(m_stub_layer[j],m_stub_ladder[j]), CMSPatternLayer::getModuleCode(m_stub_layer[j],m_stub_module[j])); + } + + int charge = m_stub_pdg[layers[0]]/abs(m_stub_pdg[layers[0]]); + double pt_GEN = sqrt(m_stub_pxGEN[layers[0]]*m_stub_pxGEN[layers[0]]+m_stub_pyGEN[layers[0]]*m_stub_pyGEN[layers[0]]); + double phi0 = atan2(m_stub_pyGEN[layers[0]],m_stub_pxGEN[layers[0]]); + double d0 = (m_stub_y0[layers[0]]-tan(phi0)*m_stub_x0[layers[0]])*cos(phi0); + //double d0 = 10.0; + + double values[5]; + values[0] = charge*pt_GEN;//PT + values[1] = phi0; + values[2] = d0; + values[3] = m_stub_etaGEN[layers[0]]; + values[4] = m_stub_z0[layers[0]]; + + fitter->addTrackForMultiDimFit(data_tracker, data_coord, values); + if(fitter->hasMultiDimFitParams())//The params are computed->we stop the process + break; + + if(evtIndex>max_tracks_number){ + fitter->forceMultiDimFitParamsComputing(); + } + + } + + delete TT; +} + +bool PrincipalFitGenerator::selectTrack(vector &tracker_layers, int* layers, vector &ladder_per_layer, vector &module_per_layer, + map > &eta_limits, float min_pt, float max_pt, float min_eta, float max_eta){ + + //initialize arrays + for(unsigned int j=0;j we do not use it + return false; + } + if(m_stub_etaGEN[j]>max_eta){// eta of the generating particule is above the threshold -> we do not use it + return false; + } + float pt_GEN = sqrt(m_stub_pxGEN[j]*m_stub_pxGEN[j]+m_stub_pyGEN[j]*m_stub_pyGEN[j]); + if(pt_GEN we do not use it + return false; + } + if(pt_GEN>max_pt){// The PT of the generating particule is above the maximum accepted -> we do not use it + return false; + } + + int layer = m_stub_layer[j]; + + int layer_position=-1; + for(unsigned int cpt=0;cptgetNbSectors()==1){ + if(eta_limits.find(tracker_layers[j])!=eta_limits.end()){//we have eta boundaries for this layer + pair limits = eta_limits[tracker_layers[j]]; + if(current_etalimits.second){ // we are outside the eta limits for this layer + //cout<<"missing hit on layer "< drop the event + } + + return true; +} + +void PrincipalFitGenerator::generate(map > eta_limits, float min_pt, float max_pt, float min_eta, float max_eta){ + generatePrincipal(eta_limits, min_pt, max_pt, min_eta, max_eta); + generateMultiDim(eta_limits, min_pt, max_pt, min_eta, max_eta); +} diff --git a/L1Trigger/TrackFindingAM/src/PrincipalTrackFitter.cc b/L1Trigger/TrackFindingAM/src/PrincipalTrackFitter.cc new file mode 100644 index 0000000000000..b9575713172b7 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/PrincipalTrackFitter.cc @@ -0,0 +1,217 @@ +#include "../interface/PrincipalTrackFitter.h" + +PrincipalTrackFitter::PrincipalTrackFitter():TrackFitter(){ + threshold = 1000; +} + +PrincipalTrackFitter::PrincipalTrackFitter(int nb, int t):TrackFitter(nb){ + threshold = t; + sec_phi = 0; +} + +PrincipalTrackFitter::~PrincipalTrackFitter(){ + for(map::iterator itr = params.begin(); itr != params.end(); ++itr){ + delete itr->second; + } +} + +void PrincipalTrackFitter::initialize(){ + +} + +void PrincipalTrackFitter::mergePatterns(){ + //cout<<"Merging of patterns not implemented"<getLayerStrip(j)->getPhi(); + if(j!=nb_layers-1) + oss<<"-"; + } + cout<<"ladder : "<::iterator it = params.find(oss.str()); + if(it==params.end()){//not found + cout<<"parametres de fit non trouves"<second; + vector active_hits = p->getHits(); + double coords[active_hits.size()*3]; + double coords_PCA[active_hits.size()*3]; + //cout<getX()*cos(sec_phi)+active_hits[i]->getY()*sin(sec_phi); + coords[i*3+1]=-active_hits[i]->getX()*sin(sec_phi)+active_hits[i]->getY()*cos(sec_phi); + coords[i*3+2]=active_hits[i]->getZ(); + cout<<*active_hits[i]<get_chi_square(coords,4); + cout<<"Erreur : "<x2p(coords,coords_PCA); + Track* fit_track = fit->getTrack(coords_PCA); + fit_track->setPhi0(fit_track->getPhi0()+sec_phi);//correction de la rotation en PHI + cout<<"PT estime de la trace : "<getCurve()<getPhi0()<getD0()<getEta0()<getZ0()<getCurve()<-200) + fit_track->setCurve(1.0); + tracks.push_back(fit_track); + } + cout<::iterator it = params.find(oss.str()); + // if(it==params.end()){//not found +} + +TrackFitter* PrincipalTrackFitter::clone(){ + PrincipalTrackFitter* fit = new PrincipalTrackFitter(nb_layers,threshold); + fit->setPhiRotation(sec_phi); + for(map::iterator itr = params.begin(); itr != params.end(); ++itr){ + fit->params[itr->first]=new FitParams(*(itr->second)); + } + + return fit; +} + +void PrincipalTrackFitter::addTrackForPrincipal(int* tracker, double* coord){ + //build the map string + ostringstream oss; + oss<::iterator it = params.find(oss.str()); + if(it==params.end()){//not found + fp=new FitParams(nb_layers, threshold); + params[oss.str()]=fp; + } + else{ + fp=it->second; + } + + //rotation according to sec_phi + for(int i=0;iaddDataForPrincipal(coord); + +} + +void PrincipalTrackFitter::addTrackForMultiDimFit(int* tracker, double* coord, double* val){ + //build the map string + ostringstream oss; + oss<::iterator it = params.find(oss.str()); + if(it==params.end()){//not found + cout<<"No sub sector found for multi dim fit!"<second; + } + + //rotation according to sec_phi + for(int i=0;iaddDataForMultiDimFit(coord, val); + +} + +bool PrincipalTrackFitter::hasPrincipalParams(){ + //bool complete=true; + //int total=0; + //int ok = 0; + for(map::iterator itr = params.begin(); itr != params.end(); ++itr){ + //total++; + if(!itr->second->hasPrincipalParams()){ + //complete=false; + // cout<<"manque : "<first<::iterator itr = params.begin(); itr != params.end(); ++itr){ + if(itr->second->getNbPrincipalTracks()<2) + params.erase(itr); + else{ + if(!itr->second->hasPrincipalParams()){ + itr->second->forcePrincipalParamsComputing(); + } + } + } +} + +bool PrincipalTrackFitter::hasMultiDimFitParams(){ + //bool complete=true; + //int total=0; + //int ok = 0; + for(map::iterator itr = params.begin(); itr != params.end(); ++itr){ + //total++; + if(!itr->second->hasMultiDimFitParams()){ + //complete=false; + //cout<<"manque : "<first<::iterator itr = params.begin(); itr != params.end(); ++itr){ + if(!itr->second->hasMultiDimFitParams()){ + itr->second->forceMultiDimFitParamsComputing(); + } + } +} diff --git a/L1Trigger/TrackFindingAM/src/Sector.cc b/L1Trigger/TrackFindingAM/src/Sector.cc new file mode 100644 index 0000000000000..fd1236024cfce --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/Sector.cc @@ -0,0 +1,467 @@ +#include "../interface/Sector.h" + +map< int, vector > Sector::readConfig(string name){ + string line; + ifstream myfile (name.c_str()); + int lineNumber=0; + map< int, vector > detector_config; + if (myfile.is_open()){ + cout<<"Using configuration found in detector.cfg"< layer_config; + if(line.length()>0 && line.find("#")!=0){ + layer_config.clear(); + size_t pos = -1; + pos = line.find(","); + bool go = true; + while(go){ + if(pos==string::npos) + go=false; + string sub = line.substr(0,pos); + line=line.substr(pos+1); + + int number; + std::istringstream ss( sub ); + ss >> number; + if (ss.bad()){ + cout<<"Syntax error line "<0 && layer_config.size()<4) + cout<<"Syntax error line "<0) + detector_config[layer_config[0]]=layer_config; + } + error=false; + } + myfile.close(); + } + else{ + cout << "No detector.cfg file found : using default configuration."< layers = CMSPatternLayer::getLayerIDs(); + for(unsigned int i=0;i layer_config; + layer_config.push_back(layers[i]);//layer's ID + layer_config.push_back(CMSPatternLayer::getNbLadders(layers[i]));//ladder number + layer_config.push_back(CMSPatternLayer::getNbModules(layers[i],-1));//max module number + layer_config.push_back(CMSPatternLayer::getNbStripsInSegment());//strip number in segment + detector_config[layer_config[0]]=layer_config; + } + } + return detector_config; +} + +Sector::Sector(){ + patterns = new PatternTree(); + fitter = NULL; + officialID=-1; +} + +Sector::Sector(vector layersID){ + for(unsigned int i=0;i > l; + vector ladders; + m_modules[layersID[i]]=l; + m_ladders[layersID[i]]=ladders; + } + patterns = new PatternTree(); + fitter = NULL; + officialID=-1; +} + +Sector::Sector(const Sector& s){ + m_modules=s.m_modules; + m_ladders=s.m_ladders; + patterns = new PatternTree(); + // if(s.fitter!=NULL) + // fitter = s.fitter->clone(); + //else + fitter=NULL; + officialID=s.officialID; +} + +Sector::~Sector(){ + delete patterns; + if(fitter!=NULL) + delete fitter; +} + +Sector& Sector::operator=(Sector& s){ + m_modules = s.m_modules; + m_ladders = s.m_ladders; + fitter=NULL; + officialID=s.officialID; + return *this; +} + +bool Sector::operator==(Sector& s){ + return (m_modules==s.m_modules && m_ladders==s.m_ladders); +} + +void Sector::addLayer(int layer){ + map > l; + m_modules[layer]=l; +} + +void Sector::addLadders(int layer, int firstLadder, int nbLadders){ + map > >::iterator it; + it=m_modules.find(layer); + + if(it!=m_modules.end()){//the layer does exist + if(it->second.size()==0){//we have no ladders yet->we add the ladders + int maxLadderNumber = CMSPatternLayer::getNbLadders(layer); + vector ladderList; + for(int i=0;i v; + int ladderID = (firstLadder+i)%maxLadderNumber; + it->second[ladderID]=v; + ladderList.push_back(ladderID); + } + m_ladders[layer]=ladderList; + } + } +} + +void Sector::addModules(int layer, int ladder, int firstModule, int nbModules){ + map > >::iterator it; + it=m_modules.find(layer); + + if(it!=m_modules.end()){//the layer does exist + map >::iterator it_ladder; + it_ladder=it->second.find(ladder); + if(it_ladder!=it->second.end()){ // the ladder does exist + if(it_ladder->second.size()==0){//we have no module yet->we add the modules + int maxModuleNumber = CMSPatternLayer::getNbModules(layer, ladder); + for(int i=0;isecond.push_back(moduleID); + } + } + } + } +} + +int Sector::getLadderCode(int layer, int ladder){ + map >::const_iterator it = m_ladders.find(layer); + + if(it==m_ladders.end()) + return -1;//the layer does not exist + + for(unsigned int i=0;isecond.size();i++){ + if(it->second[i]==ladder) + return i; + } + + return -1; + +} + +int Sector::getModuleCode(int layer, int ladder, int module){ + map > >::const_iterator it = m_modules.find(layer); + + if(it==m_modules.end()){ + cout<<"layer non trouve"< >::const_iterator it_ladder = it->second.find(ladder); + + if(it_ladder==it->second.end()) + return -1;//the module does not exist + + for(unsigned int i=0;isecond.size();i++){ + if(it_ladder->second[i]==module) + return i; + } + + return -1; + +} + +int Sector::getNbLayers(){ + return m_modules.size(); +} + +bool Sector::contains(const Hit& h){ + map > >::iterator it = m_modules.find(h.getLayer()); + if(it==m_modules.end()) + return false; + map >::iterator it2 = it->second.find(h.getLadder()); + if(it2==it->second.end()) + return false; + for(unsigned int i=0;isecond.size();i++){ + if(it2->second[i]==h.getModule()) + return true; + } + return false; +} + +vector Sector::getLadders(int l) const{ + vector v; + if(l<0 && l>=(int)m_modules.size())//no such layer + return v; + + map >::const_iterator it=m_ladders.begin(); + int cpt=0; + while(cptsecond.size();i++){ + v.push_back(it->second[i]); + } + return v; +} + +vector Sector::getModules(int lay, int l) const{ + vector mods; + if(lay<0 && lay>=(int)m_modules.size())//no such layer + return mods; + + map > >::const_iterator it=m_modules.begin(); + int cpt=0; + while(cpt >::const_iterator it_ladder = it->second.find(l); + if(it_ladder==it->second.end())//no such ladder + return mods; + return it_ladder->second; +} + +int Sector::getLayerID(int i) const{ + vector l; + for(map > >::const_iterator it=m_modules.begin();it!=m_modules.end();it++){ + l.push_back(it->first); + } + sort(l.begin(),l.end()); + if(i>-1 && i<(int)l.size()) + return l[i]; + else + return -1; +} + +int Sector::getLayerIndex(int i) const{ + vector l; + for(map > >::const_iterator it=m_modules.begin();it!=m_modules.end();it++){ + l.push_back(it->first); + } + sort(l.begin(),l.end()); + for(unsigned int j=0;j layer_list; + for(map > >::const_iterator it_layer=m_modules.begin();it_layer!=m_modules.end();it_layer++){ + layer_list.push_back(it_layer->first); + } + sort(layer_list.begin(), layer_list.end()); + for(unsigned int i=0;i lad = m_ladders[layer_list[i]]; + for(unsigned int j=0;j-1) + officialID=id; + else + officialID=-1; +} + +int Sector::getOfficialID(){ + return officialID; +} + +int Sector::getKey(){ + int k = 0; + stringstream oss; + int min_layer = 1000; + if(m_modules.size()>0){ + for(map > >::const_iterator it=m_modules.begin();it!=m_modules.end();it++){ + if(it->firstfirst; + } + map > lad = m_modules[min_layer]; + vector list; + for(map >::const_iterator it_ladder=lad.begin();it_ladder!=lad.end();it_ladder++){ + list.push_back(it_ladder->first); + } + if(list.size()!=0){ + sort(list.begin(), list.end()); + for(unsigned int j=0;j>k; + } + } + return k; +} + +vector Sector::getKeys(){ + vector res; + vector< vector > copy; + + for(map > >::const_iterator it=m_modules.begin();it!=m_modules.end();it++){ + vector v; + for(map >::const_iterator it_ladder=it->second.begin();it_ladder!=it->second.end();it_ladder++){ + v.push_back(it_ladder->first); + } + copy.push_back(v); + } + + getRecKeys(copy, 1, "", res); + return res; +} + +void Sector::getRecKeys(vector< vector > &v, int level, string temp, vector &res){ + if((int)v.size()==level){ + vector list = v[level-1]; + for(unsigned int i=0;i >::const_iterator it=s.m_ladders.begin();it!=s.m_ladders.end();it++){ + out<<"Layer : "<first< ladders = it->second; + map > ladders_modules = (s.m_modules.find(it->first))->second; + for(unsigned int j=0;j modules = ladders_modules[ladders[j]]; + for(unsigned int i=0;igetLDPatternNumber(); +} + +int Sector::getFDPatternNumber(){ + return patterns->getFDPatternNumber(); +} + +void Sector::computeAdaptativePatterns(short r){ + patterns->computeAdaptativePatterns(r); +} + +void Sector::link(Detector& d){ + + vector > ladders; + vector > > modules; + vector layer_list; + for(map > >::const_iterator it_layer=m_modules.begin();it_layer!=m_modules.end();it_layer++){ + layer_list.push_back(it_layer->first); + } + sort(layer_list.begin(), layer_list.end()); + + for(unsigned int i=0;i lad = m_ladders[layer_list[i]]; + vector ladder_list; + for(unsigned int j=0;jlink(d, ladders, modules); +} + +vector Sector::getActivePatterns(int active_threshold){ + vector active_patterns; + patterns->getActivePatterns(active_threshold, active_patterns); + return active_patterns; +} + +void Sector::setFitter(TrackFitter* f){ + if(fitter!=NULL) + delete fitter; + if(f!=NULL) + fitter = f; + else + fitter = NULL; +} + +TrackFitter* Sector::getFitter(){ + return fitter; +} + +void Sector::updateFitterPhiRotation(){ + map< int, vector > detector_config = readConfig("detector.cfg"); + //Get the layers IDs + vector tracker_layers; + for(int i=0;igetLayerID(i)); + } + int nb_ladders = -1; + if(detector_config.find(getLayerID(0))!=detector_config.end()){ + nb_ladders = detector_config[getLayerID(0)][1]; + } + else{ + cout<<"We do not know the number of ladders in layer "<setPhiRotation(sec_phi); + } +} diff --git a/L1Trigger/TrackFindingAM/src/SectorTree.cc b/L1Trigger/TrackFindingAM/src/SectorTree.cc new file mode 100644 index 0000000000000..d447b78623b25 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/SectorTree.cc @@ -0,0 +1,141 @@ +#include "../interface/SectorTree.h" + +SectorTree::SectorTree(){ + srand ( time(NULL) ); + superStripSize=-1; +} + +SectorTree::~SectorTree(){ + for(unsigned int i=0;i ladders, vector modules){ + pair::iterator,multimap::iterator> ret; + multimap::iterator first; + + ostringstream oss; + oss<second; + + bool found=false; + for(unsigned int i=0;i mods = test->getModules(i,ladders[i]); + found = false; + for(unsigned int j=0;j we take it + return test; + first++; + } + //none of the selected sectors where ok for modules... + return NULL; +} + +Sector* SectorTree::getSector(const Hit& h){ + for(unsigned int i=0;icontains(h)) + return sector_list[i]; + } + return NULL; +} + +void SectorTree::addSector(Sector s){ + Sector* ns = new Sector(s); + sector_list.push_back(ns); + vector keys = ns->getKeys(); + for(unsigned int i=0;i(keys[i],ns)); + } +} + +void SectorTree::updateSectorMap(){ + sectors.clear(); + for(unsigned int j=0;j keys = ns->getKeys(); + for(unsigned int i=0;i(keys[i],ns)); + } + } +} + +vector SectorTree::getAllSectors(){ + return sector_list; +} + +int SectorTree::getLDPatternNumber(){ + int nb = 0; + for(unsigned int i=0;igetLDPatternNumber(); + } + return nb; +} + +int SectorTree::getFDPatternNumber(){ + int nb = 0; + for(unsigned int i=0;igetFDPatternNumber(); + } + return nb; +} + +void SectorTree::computeAdaptativePatterns(short r){ + for(unsigned int i=0;icomputeAdaptativePatterns(r); + } +} + +void SectorTree::link(Detector& d){ + for(unsigned int i=0;ilink(d); + } +} + +vector SectorTree::getActivePatternsPerSector(int active_threshold){ + vector list; + for(unsigned int i=0;i active_patterns = sector_list[i]->getActivePatterns(active_threshold); + for(unsigned int j=0;jgetPatternTree()->addPattern(active_patterns[j], NULL); + delete active_patterns[j]; + } + list.push_back(copy); + } + return list; +} + +int SectorTree::getSuperStripSize(){ + return superStripSize; +} + +void SectorTree::setSuperStripSize(int s){ + if(s>0) + superStripSize=s; +} + +int SectorTree::getNbSectors(){ + return sector_list.size(); +} diff --git a/L1Trigger/TrackFindingAM/src/Segment.cc b/L1Trigger/TrackFindingAM/src/Segment.cc new file mode 100644 index 0000000000000..3169b6f711078 --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/Segment.cc @@ -0,0 +1,36 @@ +#include "../interface/Segment.h" + +Segment::Segment(int stripNumber, int sstripSize){ + int nbSStrips=stripNumber/sstripSize; + sStripSize=sstripSize; + for(int i=0;iclear(); + } +} diff --git a/L1Trigger/TrackFindingAM/src/SuperStrip.cc b/L1Trigger/TrackFindingAM/src/SuperStrip.cc new file mode 100644 index 0000000000000..da2f48f73d04b --- /dev/null +++ b/L1Trigger/TrackFindingAM/src/SuperStrip.cc @@ -0,0 +1,36 @@ +#include "../interface/SuperStrip.h" + +SuperStrip::SuperStrip(int s){ + hit=false; + size=s; +} + +SuperStrip::~SuperStrip(){ + clear(); +} + +short SuperStrip::getSize(){ + return size; +} + +bool SuperStrip::isHit(){ + return hit; +} + +vector& SuperStrip::getHits(){ + return hits; +} + +void SuperStrip::clear(){ + hit=false; + for(unsigned int i=0;i TrackFitter::getFilteredPatterns(){ + vector copy; + for(unsigned int i=0;i TrackFitter::getTracks(){ + vector copy; + for(unsigned int i=0;i +#include +#include +#include +#include +using namespace std; + +#include "L1TStub.hh" +#include "L1TTracklet.hh" +#include "L1TTrack.hh" +#include "L1TTracks.hh" +#include "L1TGeomBase.hh" +#include "L1TDisk.hh" + +class L1TBarrel:public L1TGeomBase { + +private: + L1TBarrel(){ + } + + +public: + + L1TBarrel(double rmin,double rmax,double zmax, int NSector){ + rmin_=rmin; + rmax_=rmax; + zmax_=zmax; + NSector_=NSector; + stubs_.resize(NSector); + tracklets_.resize(NSector); + tracks_.resize(NSector); + } + + bool addStub(const L1TStub& aStub){ + if (aStub.r()rmax_||fabs(aStub.z())>zmax_) return false; + double phi=aStub.phi(); + if (phi<0) phi+=two_pi; + int nSector=NSector_*phi/two_pi; + assert(nSector>=0); + assert(nSector=NSector_) jSector-=NSector_; + for (unsigned int i=0;istubs_[jSector].size();j++) { + if (hermetic&&(stubs_[iSector][i].ladder()!=L->stubs_[jSector][j].ladder())) continue; + //cout << "ladders"<< stubs_[iSector][i].ladder()<<" " + // << L->stubs_[jSector][j].ladder()<stubs_[jSector][j].r()<<" " + // <stubs_[jSector][j].phi()<stubs_[jSector][j].r(); + double z2=L->stubs_[jSector][j].z(); + double phi2=L->stubs_[jSector][j].phi(); + + double deltaphi=phi1-phi2; + + if (deltaphi>0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.5*two_pi); + + + double dist=sqrt(r2*r2+r1*r1-2*r1*r2*cos(deltaphi)); + + double rinv=2*sin(deltaphi)/dist; + + double phi0=phi1+asin(0.5*r1*rinv); + + if (phi0>0.5*two_pi) phi0-=two_pi; + if (phi0<-0.5*two_pi) phi0+=two_pi; + assert(fabs(phi0)<0.5*two_pi); + + double rhopsi1=2*asin(0.5*r1*rinv)/rinv; + + double rhopsi2=2*asin(0.5*r2*rinv)/rinv; + + double t=(z1-z2)/(rhopsi1-rhopsi2); + + double z0=z1-t*rhopsi1; + + if (stubs_[iSector][i].sigmaz()>1.0) { + if (fabs(z1-z2)<10.0){ + z0=0.0; + t=z1/rhopsi1; + } + } + + if (fabs(z0)>30.0) continue; + if (fabs(rinv)>0.0057) continue; + + double pt1=stubs_[iSector][i].pt(); + double pt2=L->stubs_[jSector][j].pt(); + double pttracklet=0.3*3.8/(rinv*100); + bool pass1=fabs(1.0/pt1-1.0/pttracklet)<0.25; + bool pass2=fabs(1.0/pt2-1.0/pttracklet)<0.25; + bool pass=pass1&&pass2; + + if (0) { + static ofstream out("ptmatch.txt"); + out << pt1<<" " + << pt2<<" " + << pttracklet<<" " + << pass + << endl; + } + + if (!pass) continue; + + L1TTracklet tracklet(rinv,phi0,t,z0); + tracklet.addStub(stubs_[iSector][i]); + tracklet.addStub(L->stubs_[jSector][j]); + + tracklets_[iSector].push_back(tracklet); + + if (0) { + static ofstream out("barreltracklets.txt"); + out << iSector<<" "<=NSector_) jSector-=NSector_; + for (unsigned int i=0;istubs_[jSector].size();j++) { + + double r1=stubs_[iSector][i].r(); + double z1=stubs_[iSector][i].z(); + double phi1=stubs_[iSector][i].phi(); + + double r2=D->stubs_[jSector][j].r(); + double z2=D->stubs_[jSector][j].z(); + double phi2=D->stubs_[jSector][j].phi(); + + if (r2>80.0) continue; + + double deltaphi=phi1-phi2; + + if (deltaphi>0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.5*two_pi); + + + double dist=sqrt(r2*r2+r1*r1-2*r1*r2*cos(deltaphi)); + + double rinv=2*sin(deltaphi)/dist; + + double phi0=phi1+asin(0.5*r1*rinv); + + if (phi0>0.5*two_pi) phi0-=two_pi; + if (phi0<-0.5*two_pi) phi0+=two_pi; + if (!(fabs(phi0)<0.5*two_pi)) { + cout << "phi0 phi1 r1 rinv : "<1.0) { + if (fabs(z1-z2)<10.0){ + z0=0.0; + t=z1/rhopsi1; + } + } + + if (fabs(z0)>30.0) continue; + if (fabs(rinv)>0.0057) continue; + + L1TTracklet tracklet(rinv,phi0,t,z0); + tracklet.addStub(stubs_[iSector][i]); + tracklet.addStub(D->stubs_[jSector][j]); + + tracklets_[iSector].push_back(tracklet); + + //cout << "rinv phi0 t z0:"<< + // rinv<<" "<=NSector_) jSector-=NSector_; + if (L->stubs_[jSector].size()==0) continue; + + + double rapprox=L->stubs_[jSector][0].r(); + + double phiprojapprox=phi0-asin(0.5*rapprox*rinv); + double zprojapprox=z0+2*t*asin(0.5*rapprox*rinv)/rinv; + if (phiprojapprox-L->stubs_[jSector][0].phi()<-0.5*two_pi) phiprojapprox+=two_pi; + if (phiprojapprox-L->stubs_[jSector][0].phi()>0.5*two_pi) phiprojapprox-=two_pi; + + for (unsigned int j=0;jstubs_[jSector].size();j++) { + double z=L->stubs_[jSector][j].z(); + if (fabs(z-zprojapprox)>10.0) continue; + double phi=L->stubs_[jSector][j].phi(); + double deltaphiapprox=fabs(phi-phiprojapprox); + assert(deltaphiapprox<12.0); + if (deltaphiapprox*rapprox>5.0) continue; + double r=L->stubs_[jSector][j].r(); + //cout << "r1 phi1 r2 phi2:" + // <stubs_[jSector][j].r()<<" " + // <stubs_[jSector][j].phi()<0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.5*two_pi); + + double rdeltaphi=r*deltaphi; + double deltaz=z-zproj; + + if (0) { + static ofstream out("barrelmatch.txt"); + out << aTracklet.r()<<" "<cutrphi) continue; + if (fabs(deltaz)>cutrz) continue; + + double dist=hypot(rdeltaphi/cutrphi,deltaz/cutrz); + + if (diststubs_[jSector][j]; + distbest=dist; + } + + //cout << "rdeltaphi deltaz:"<=NSector_) jSector-=NSector_; + for (unsigned int j=0;jstubs_[jSector].size();j++) { + double r=D->stubs_[jSector][j].r(); + double z=D->stubs_[jSector][j].z(); + //skip stub if on disk + if (fabs(z-aTracklet.getStubs()[1].z())<5.0) continue; + double phi=D->stubs_[jSector][j].phi(); + //cout << "r1 phi1 r2 phi2:" + // <stubs_[jSector][j].r()<<" " + // <stubs_[jSector][j].phi()<stubs_[jSector][j].iphi(); + double width=4.608; + double nstrip=508.0; + if (r<60.0) { + width=4.8; + nstrip=480; + } + double Deltai=width*(iphi-nstrip)/nstrip; //A bit of a hack... + if (z>0.0) Deltai=-Deltai; + + + double theta0=asin(Deltai/r); + + double Delta=Deltai-r_track*sin(theta0-(phi_track-phi)); + + + + //double phiturn=0.5*(z-z0)*rinv/t; + //if (fabs(phiturn)>0.25*two_pi) continue; + + //double phiproj=phi0-phiturn; + double rproj=2.0*sin(0.5*(z-z0)*rinv/t)/rinv; + + //double deltaphi=phi-phiproj; + //cout << "deltaphi phi phiproj:"<0.5*two_pi) deltaphi-=two_pi; + //if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + //if (!(fabs(deltaphi)<0.5*two_pi)) { + // cout << "deltaphi: "<0.2) continue; + if (fabs(deltar)>3.0) continue; + + double dist=hypot(rdeltaphi/0.2,deltar/3.0); + + if (diststubs_[jSector][j]; + distbest=dist; + } + + } + } + if (distbest<1e30) { + tracklets_[iSector][i].addStub(tmp); + } + } + } + } + + + +private: + + double rmin_; + double rmax_; + double zmax_; + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TConstants.hh b/L1Trigger/TrackFindingTracklet/interface/L1TConstants.hh new file mode 100644 index 0000000000000..5e3726598134b --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TConstants.hh @@ -0,0 +1,41 @@ +#ifndef L1TCONSTANTS_H +#define L1TCONSTANTS_H + +//static double DZ=0.0125; +//static double DX=0.00125; + +//static int MAXZ=32768*2; +//static int MAXX=8192; + +//static int BASE=32768*4; +//static int BASE2=BASE*64; +//static int BASE3=1024*8; +//static int BASE4=8192; +//static int BASE5=32768; +//static int BASE6=32768; +//static int BASE7=32768*4; +//static int BASE8=1024*16; + +//static int BASE9=32768*4; + +//static int BASE10=32768*16; +//static int BASE11=8192*4; +//static int BASE12=65536; +//static int BASE13=4096; + +//static int BASE14=4; +//static int BASE15=8; +//static int BASE16=16; +//static int BASE17=1024; + +//static int BASE18=4096; +//static int BASE19=1024; + +//static int BASE20=512; + +//static long long int MAXINT=65535*32768; + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TDisk.hh b/L1Trigger/TrackFindingTracklet/interface/L1TDisk.hh new file mode 100644 index 0000000000000..ef785cf702f6e --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TDisk.hh @@ -0,0 +1,316 @@ +#ifndef L1TDISK_H +#define L1TDISK_H + +#include +#include +#include +#include +#include +using namespace std; + +#include "L1TStub.hh" +#include "L1TTracklet.hh" +#include "L1TGeomBase.hh" + +class L1TDisk: public L1TGeomBase{ + +private: + L1TDisk(){ + } + + +public: + + L1TDisk(double zmin,double zmax, int NSector){ + zmin_=zmin; + zmax_=zmax; + if (zmin<0.0) { + zmin_=zmax; + zmax_=zmin; + } + NSector_=NSector; + stubs_.resize(NSector); + tracklets_.resize(NSector); + tracks_.resize(NSector); + } + + bool addStub(const L1TStub& aStub){ + //cout << "z zmin zmax:"<zmax_) return false; + double phi=aStub.phi(); + if (phi<0) phi+=two_pi; + int nSector=NSector_*phi/two_pi; + assert(nSector>=0); + assert(nSector=NSector_) jSector-=NSector_; + for (unsigned int i=0;istubs_[jSector].size();j++) { + //cout << "r1 phi1 r2 phi2:" + // <stubs_[jSector][j].r()<<" " + // <stubs_[jSector][j].phi()<stubs_[jSector][j].r(); + double z2=D->stubs_[jSector][j].z(); + double phi2=D->stubs_[jSector][j].phi(); + + if (r1>60.0||r2>60.0) continue; + + double deltaphi=phi1-phi2; + + if (deltaphi>0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.5*two_pi); + + if (fabs(r1-r2)/fabs(z1-z2)<0.1) continue; + + double dist=sqrt(r2*r2+r1*r1-2*r1*r2*cos(deltaphi)); + + double rinv=2*sin(deltaphi)/dist; + + double phi0=phi1+asin(0.5*r1*rinv); + + if (phi0>0.5*two_pi) phi0-=two_pi; + if (phi0<-0.5*two_pi) phi0+=two_pi; + if (!(fabs(phi0)<0.5*two_pi)) { + cout << "phi0 "<30.0) continue; + if (fabs(rinv)>0.0057) continue; + + //cout << "L1TDisk found tracklet"<stubs_[jSector][j]); + + //cout << "L1TDisk tracklet z() "<=NSector_) jSector-=NSector_; + + for (unsigned int j=0;jstubs_[jSector].size();j++) { + double r=D->stubs_[jSector][j].r(); + double z=D->stubs_[jSector][j].z(); + double phi=D->stubs_[jSector][j].phi(); + //cout << "r1 phi1 r2 phi2:" + // <stubs_[jSector][j].r()<<" " + // <stubs_[jSector][j].phi()<stubs_[jSector][j].iphi(); + double width=4.608; + double nstrip=508.0; + if (r<60.0) { + width=4.8; + nstrip=480; + } + double Deltai=width*(iphi-nstrip)/nstrip; //A bit of a hack... + if (z>0.0) Deltai=-Deltai; + + + double theta0=asin(Deltai/r); + + double Delta=Deltai-r_track*sin(theta0-(phi_track-phi)); + + + + if (Delta!=Delta) { + cout << "Error: "<0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.5*two_pi); + + double rdeltaphi=Delta; + double deltar=r-rproj; + + if (0&&fabs(Delta)<10.0&&fabs(deltar)<15.0) { + static ofstream out("diskmatch.txt"); + out << aTracklet.r()<<" "<rphicut1) continue; + if (fabs(deltar)>rcut1) continue; + dist=hypot(rdeltaphi/rphicut1,deltar/rcut1); + } + else { + if (fabs(rdeltaphi)>rphicut2) continue; + if (fabs(deltar)>rcut2) continue; + dist=hypot(rdeltaphi/rphicut2,deltar/rcut2); + } + + if (diststubs_[jSector][j]; + } + + //cout << "rdeltaphi deltar:"<=NSector_) jSector-=NSector_; + + for (unsigned int j=0;jstubs_[jSector].size();j++) { + double r=L->stubs_[jSector][j].r(); + double z=L->stubs_[jSector][j].z(); + double phi=L->stubs_[jSector][j].phi(); + //cout << "r1 phi1 r2 phi2:" + // <stubs_[jSector][j].r()<<" " + // <stubs_[jSector][j].phi()<0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.5*two_pi); + + double rdeltaphi=r*deltaphi; + double deltaz=z-zproj; + + if (fabs(rdeltaphi)>0.1) continue; + if (fabs(deltaz)>5.0) continue; //LS modified from 0.5 to 5.0 + + double dist=hypot(rdeltaphi/0.1,deltaz/5.0); //LS modified from 0.5 to 5.0 + + if (diststubs_[jSector][j]; + } + + } + } + if (bestdist<1e30) { + tracklets_[iSector][i].addStub(tmp); + } + } + } + } + + + +private: + + double zmin_; + double zmax_; + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TGeomBase.hh b/L1Trigger/TrackFindingTracklet/interface/L1TGeomBase.hh new file mode 100644 index 0000000000000..7cfed036ba979 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TGeomBase.hh @@ -0,0 +1,76 @@ +#ifndef L1TGEOMBASE_H +#define L1TGEOMBASE_H + +#include +#include +#include +#include +#include +using namespace std; + +#include "L1TStub.hh" +#include "L1TTracklet.hh" + +class L1TGeomBase{ + + friend class L1TDisk; + friend class L1TBarrel; + +private: + L1TGeomBase(){ + } + + +public: + + void fitTracks() { + for(int iSector=0;iSector3){ + L1TTrack aTrack(tracklets_[iSector][i]); + tracks_[iSector].addTrack(aTrack); + } + } + } + } + + unsigned int nTracks(int iSector) const {return tracks_[iSector].size();} + L1TTrack& track(int iSector, unsigned int i) {return tracks_[iSector].get(i);} + + unsigned int nTracklets(int iSector) const {return tracklets_[iSector].size();} + L1TTracklet& tracklet(int iSector, unsigned int i) {return tracklets_[iSector][i];} + + L1TTracks allTracks(){ + L1TTracks tracks=tracks_[0]; + for (int i=1;i > stubs_; + + vector > tracklets_; + + vector tracks_; + + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TSector.hh b/L1Trigger/TrackFindingTracklet/interface/L1TSector.hh new file mode 100644 index 0000000000000..37aaac2410aa0 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TSector.hh @@ -0,0 +1,927 @@ +#ifndef L1TSECTOR_H +#define L1TSECTOR_H + +#include +#include +using namespace std; + +#include "L1TRod.hh" +#include "L1TTracklets.hh" +#include "L1TTracks.hh" + +//This is the number of strips in rphi and in z for a module. +//This should be in the header of the ASCII file, but for now +//just hardcoded here. + + + +class L1TSector{ + +private: + + L1TSector(): + L11I_(0,1,1), + L11O_(0,2,1), + L12I_(0,1,2), + L12O_(0,2,2), + L13I_(0,1,3), + L13O_(0,2,3), + + L31I_(0,3,1), + L31O_(0,4,1), + L32I_(0,3,2), + L32O_(0,4,2), + L33I_(0,3,3), + L33O_(0,4,3), + L34I_(0,3,4), + L34O_(0,4,4), + + L5a1I_(0,5,1), + L5a1O_(0,6,1), + L5a2I_(0,5,2), + L5a2O_(0,6,2), + L5a3I_(0,5,3), + L5a3O_(0,6,3), + L5a4I_(0,5,4), + L5a4O_(0,6,4), + + L5b1I_(0,7,1), + L5b1O_(0,8,1), + L5b2I_(0,7,2), + L5b2O_(0,8,2), + L5b3I_(0,7,3), + L5b3O_(0,8,3), + L5b4I_(0,7,4), + L5b4O_(0,8,4), + + + L51I_(0,9,1), + L51O_(0,10,1), + L52I_(0,9,2), + L52O_(0,10,2), + L53I_(0,9,3), + L53O_(0,10,3), + L54I_(0,9,4), + L54O_(0,10,4), + L55I_(0,9,5), + L55O_(0,10,5), + L56I_(0,9,6), + L56O_(0,10,6), + L57I_(0,9,7), + L57O_(0,10,7) + { + n_=0; + } + +public: + + L1TSector(int n): + L11I_(n,1,1), + L11O_(n,2,1), + L12I_(n,1,2), + L12O_(n,2,2), + L13I_(n,1,3), + L13O_(n,2,3), + + L31I_(n,3,1), + L31O_(n,4,1), + L32I_(n,3,2), + L32O_(n,4,2), + L33I_(n,3,3), + L33O_(n,4,3), + L34I_(n,3,4), + L34O_(n,4,4), + + L5a1I_(n,5,1), + L5a1O_(n,6,1), + L5a2I_(n,5,2), + L5a2O_(n,6,2), + L5a3I_(n,5,3), + L5a3O_(n,6,3), + L5a4I_(n,5,4), + L5a4O_(n,6,4), + + L5b1I_(n,7,1), + L5b1O_(n,8,1), + L5b2I_(n,7,2), + L5b2O_(n,8,2), + L5b3I_(n,7,3), + L5b3O_(n,8,3), + L5b4I_(n,7,4), + L5b4O_(n,8,4), + + + L51I_(n,9,1), + L51O_(n,10,1), + L52I_(n,9,2), + L52O_(n,10,2), + L53I_(n,9,3), + L53O_(n,10,3), + L54I_(n,9,4), + L54O_(n,10,4), + L55I_(n,9,5), + L55O_(n,10,5), + L56I_(n,9,6), + L56O_(n,10,6), + L57I_(n,9,7), + L57O_(n,10,7) + { + n_=n; + } + + + + //uggly helper function + void append(L1TTracklets& a,L1TTracklets b){ + for (unsigned int i=0;i1) { + L1TTrack aTrack(aTracklet); + L1Tracks_.addTrack(aTrack); + } + } + for (unsigned int i=0; i1) { + L1TTrack aTrack(aTracklet); + L1Tracks_.addTrack(aTrack); + } + } + for (unsigned int i=0; i1) { + L1TTrack aTrack(aTracklet); + L1Tracks_.addTrack(aTrack); + } + } + + } + + L1TTracks getTracks() { + return L1Tracks_; + } + + void print() { + + cout << "Sector:"<0) { + rinv_=rinvfit_; + phi0_=phi0fit_; + z0_=z0fit_; + t_=tfit_; + } + + calculateDerivatives(); + + linearTrackFit(); + + + } + + largestresid=-1.0; + ilargestresid=-1; + + residuals(largestresid,ilargestresid); + + //cout << "Chisq largestresid: "<3&&chisq()>100.0&&largestresid>5.0) { + //cout << "Refitting track"<0.0) Deltai=-Deltai; + double theta0=asin(Deltai/ri); + + double rmultiplier=-sin(theta0-(phi_track-phii)); + double phimultiplier=r_track*cos(theta0-(phi_track-phii)); + + + double drdrinv=-2.0*sin(0.5*rinv_*(zi-z0_)/t_)/(rinv_*rinv_) + +(zi-z0_)*cos(0.5*rinv_*(zi-z0_)/t_)/(rinv_*t_); + double drdphi0=0; + double drdt=-(zi-z0_)*cos(0.5*rinv_*(zi-z0_)/t_)/(t_*t_); + double drdz0=-cos(0.5*rinv_*(zi-z0_)/t_)/t_; + + double dphidrinv=-0.5*(zi-z0_)/t_; + double dphidphi0=1.0; + double dphidt=0.5*rinv_*(zi-z0_)/(t_*t_); + double dphidz0=0.5*rinv_/t_; + + D_[0][j]=drdrinv/sigmaz; + D_[1][j]=drdphi0/sigmaz; + D_[2][j]=drdt/sigmaz; + D_[3][j]=drdz0/sigmaz; + j++; + //second the rphi position + D_[0][j]=(phimultiplier*dphidrinv+rmultiplier*drdrinv)/sigmax; + D_[1][j]=(phimultiplier*dphidphi0+rmultiplier*drdphi0)/sigmax; + D_[2][j]=(phimultiplier*dphidt+rmultiplier*drdt)/sigmax; + D_[3][j]=(phimultiplier*dphidz0+rmultiplier*drdz0)/sigmax; + //old calculation + //D_[0][j]=-0.5*(zi-z0_)/(t_*(sigmax/ri)); + //D_[1][j]=1.0/(sigmax/ri); + //D_[2][j]=-0.5*rinv_*(zi-z0_)/(t_*t_*(sigmax/ri)); + //D_[3][j]=0.5*rinv_/((sigmax/ri)*t_); + j++; + } + + //cout << "Exact rinv derivative: "<0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.1*two_pi); + + delta[j++]=ri*deltaphi/sigmax; + delta[j++]=(z0fit_+(2.0/rinvfit_)*tfit_*asin(0.5*ri*rinvfit_)-zi)/sigmaz; + + } + else { + //we are dealing with a disk hit + + double r_track=2.0*sin(0.5*rinvfit_*(zi-z0fit_)/tfit_)/rinvfit_; + double phi_track=phi0fit_-0.5*rinvfit_*(zi-z0fit_)/tfit_; + + int iphi=stubs_[i].iphi(); + + double width=4.608; + double nstrip=508.0; + if (ri<60.0) { + width=4.8; + nstrip=480; + } + double Deltai=width*(iphi-nstrip)/nstrip; //A bit of a hack... + + if (stubs_[i].z()>0.0) Deltai=-Deltai; + + double theta0=asin(Deltai/ri); + + double Delta=Deltai-r_track*sin(theta0-(phi_track-phii)); + + delta[j++]=(r_track-ri)/sigmaz; + delta[j++]=Delta/sigmax; + } + + if (fabs(delta[j-2])>largestresid) { + largestresid=fabs(delta[j-2]); + ilargestresid=i; + } + + if (fabs(delta[j-1])>largestresid) { + largestresid=fabs(delta[j-1]); + ilargestresid=i; + } + + if (print) cout << delta[j-2]<<" "<0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.1*two_pi); + + delta[j++]=ri*deltaphi/sigmax; + delta[j++]=(z0_+(2.0/rinv_)*t_*asin(0.5*ri*rinv_)-zi)/sigmaz; + + + //numerical derivative check + + for (int iii=0;iii<0;iii++){ + + double drinv=0.0; + double dphi0=0.0; + double dt=0.0; + double dz0=0.0; + + if (iii==0) drinv=0.001*fabs(rinv_); + if (iii==1) dphi0=0.001; + if (iii==2) dt=0.001; + if (iii==3) dz0=0.01; + + double deltaphi=phi0_+dphi0-asin(0.5*ri*(rinv_+drinv))-phii; + if (deltaphi>0.5*two_pi) deltaphi-=two_pi; + if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + assert(fabs(deltaphi)<0.1*two_pi); + + double delphi=ri*deltaphi/sigmax; + double deltaz=(z0_+dz0+(2.0/(rinv_+drinv))*(t_+dt)*asin(0.5*ri*(rinv_+drinv))-zi)/sigmaz; + + + if (iii==0) cout << "Numerical rinv derivative: "<0.0) Deltai=-Deltai; + + double theta0=asin(Deltai/ri); + + double Delta=Deltai-r_track*sin(theta0-(phi_track-phii)); + + delta[j++]=(r_track-ri)/sigmaz; + //double deltaphi=phi_track-phii; + //if (deltaphi>0.5*two_pi) deltaphi-=two_pi; + //if (deltaphi<-0.5*two_pi) deltaphi+=two_pi; + //assert(fabs(deltaphi)<0.1*two_pi); + //delta[j++]=deltaphi/(sigmax/ri); + delta[j++]=Delta/sigmax; + + //numerical derivative check + + for (int iii=0;iii<0;iii++){ + + double drinv=0.0; + double dphi0=0.0; + double dt=0.0; + double dz0=0.0; + + if (iii==0) drinv=0.001*fabs(rinv_); + if (iii==1) dphi0=0.001; + if (iii==2) dt=0.001; + if (iii==3) dz0=0.01; + + r_track=2.0*sin(0.5*(rinv_+drinv)*(zi-(z0_+dz0))/(t_+dt))/(rinv_+drinv); + //cout <<"t_track 2: "<0.0) Deltai=-Deltai; + theta0=asin(Deltai/ri); + + Delta=Deltai-r_track*sin(theta0-(phi_track-phii)); + + if (iii==0) cout << "Numerical rinv derivative: "<=2); + + } + + + int simtrackid(double& fraction) const { + + //cout << "In L1TTrack::simtrackid"< simtrackids; + + for(unsigned int i=0;isecond<second>nsimtrack) { + nsimtrack=it->second; + simtrackid=it->first; + } + it++; + } + + //cout << "L1TTrack::simtrackid done"< getStubs() const { return stubs_; } + unsigned int nstub() const { return stubs_.size(); } + double rinv() const { return rinv_; } + double getPhi0() const { return phi0_; } + double getZ0() const { return z0_; } + double getT() const { return t_; } + bool isCombinatorics() const { return isCombinatorics_; } + double getSimTrackID() const { return SimTrackID_; } + + double pt(double bfield) const { return 0.00299792*bfield/rinvfit_; } + //double ipt(double bfield) const { return 0.00299792*bfield/irinvfit(); } + double ptseed(double bfield) const { return 0.00299792*bfield/rinv_; } + + double phi0() const { return phi0fit_;} + //double iphi0() const { return iphi0fit();} + double phi0seed() const { return phi0_;} + + double eta() const { static double two_pi=8*atan(1.0); + return -log(tan(0.5*(0.25*two_pi-atan(tfit_)))); } + //double ieta() const { static double two_pi=8*atan(1.0); + // return -log(tan(0.5*(0.25*two_pi-atan(itfit())))); } + double etaseed() const { static double two_pi=8*atan(1.0); + return -log(tan(0.5*(0.25*two_pi-atan(t_)))); } + + double z0() const { return z0fit_; } + //double iz0() const { return iz0fit(); } + double z0seed() const { return z0_; } + + double chisq1() const {return chisq1_;} + double chisq2() const {return chisq2_;} + + double chisq1dof() const {return chisq1_/(stubs_.size()-2);} + double chisq2dof() const {return chisq2_/(stubs_.size()-2);} + + double chisq() const {return chisq1_+chisq2_; } + double chisqdof() const {return (chisq1_+chisq2_)/(2*stubs_.size()-4); } + + +private: + + L1TTracklet seed_; + vector stubs_; + double rinv_; + double phi0_; + double z0_; + double t_; + bool isCombinatorics_; + int SimTrackID_; + double rinvfit_; + double phi0fit_; + double z0fit_; + double tfit_; + + int irinvfit_; + int iphi0fit_; + int iz0fit_; + int itfit_; + + double chisq1_; + double chisq2_; + + int ichisq1_; + int ichisq2_; + + double D_[4][40]; + + double M_[4][8]; + + double MinvDt_[4][40]; + + +}; + + +#endif diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TTracklet.hh b/L1Trigger/TrackFindingTracklet/interface/L1TTracklet.hh new file mode 100644 index 0000000000000..1fd74853bab6b --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TTracklet.hh @@ -0,0 +1,96 @@ +#ifndef L1TTRACKLET_H +#define L1TTRACKLET_H + +#include +#include +#include +#include + +using namespace std; + + + +class L1TTracklet{ + +public: + + L1TTracklet(double rinv, double phi0, double t, double z0){ + + rinv_=rinv; + phi0_=phi0; + t_=t; + z0_=z0; + + } + + L1TTracklet(){ + } + + void addStub(const L1TStub& j){ + stubs_.push_back(j); + } + + vector getStubs() const { + return stubs_; + } + + int simtrackid(double& fraction) const { + + + map simtrackids; + + for(unsigned int i=0;isecond<second>nsimtrack) { + nsimtrack=it->second; + simtrackid=it->first; + } + it++; + } + + fraction=(1.0*nsimtrack)/stubs_.size(); + + return simtrackid; + + } + + double pt(double bfield) const { return 0.00299792*bfield/rinv_; } + + int nStubs() const {return stubs_.size();} + + double rinv() const {return rinv_;} + double phi0() const {return phi0_;} + double t() const {return t_;} + double z0() const {return z0_;} + + double r() const {return stubs_[0].r();} + double z() const {return stubs_[0].z();} + + +private: + + double rinv_; + double phi0_; + double t_; + double z0_; + + vector stubs_; + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TTracklets.hh b/L1Trigger/TrackFindingTracklet/interface/L1TTracklets.hh new file mode 100644 index 0000000000000..64a0d6c6050f9 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TTracklets.hh @@ -0,0 +1,59 @@ +#ifndef L1TTRACKLETS_H +#define L1TTRACKLETS_H + +#include +#include + +#include "L1TTracklet.hh" + + +using namespace std; + +//This is the number of strips in rphi and in z for a module. +//This should be in the header of the ASCII file, but for now +//just hardcoded here. + + + +class L1TTracklets{ + +public: + + L1TTracklets(){ + + } + + void addTracklet(const L1TTracklet& aTracklet){ + tracklets_.push_back(aTracklet); + } + + + void print() { + + for (unsigned int i=0;i tracklets_; + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TTracks.hh b/L1Trigger/TrackFindingTracklet/interface/L1TTracks.hh new file mode 100644 index 0000000000000..eaf085b8e2c70 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TTracks.hh @@ -0,0 +1,139 @@ +#ifndef L1TTRACKS_H +#define L1TTRACKS_H + +#include +#include + +#include "L1TTrack.hh" + + +using namespace std; + + +class L1TTracks{ + +public: + + L1TTracks(){ + + } + + void addTrack(const L1TTrack& aTrack){ + tracks_.push_back(aTrack); + } + + void addTracks(const L1TTracks& tracks){ + for(unsigned int i=0;i NduplicatesPerTrack() { + + vector NdupPerTrack; + vector Ndups((int)tracks_.size()); + + for (unsigned int i=0; i deleted(tracks_.size()); + for(unsigned int i=0;ifabs(tracks_[j].rinv())) { + //if (fractioni=2)){ + deleted[i]=true; + continue; + } + if ((tracks_[j].npixelstrip()<2)&&(tracks_[i].npixelstrip()>=2)){ + deleted[j]=true; + continue; + } + if ((tracks_[i].npixelstrip()<3)&&(tracks_[j].npixelstrip()>=3)){ + deleted[i]=true; + continue; + } + if ((tracks_[j].npixelstrip()<3)&&(tracks_[i].npixelstrip()>=3)){ + deleted[j]=true; + continue; + } + if ((tracks_[i].npixelstrip()<4)&&(tracks_[j].npixelstrip()>=4)){ + deleted[i]=true; + continue; + } + if ((tracks_[j].npixelstrip()<4)&&(tracks_[i].npixelstrip()>=4)){ + deleted[j]=true; + continue; + } + + + + if (tracks_[i].chisqdof()>tracks_[j].chisqdof()) { + deleted[i]=true; + } else { + deleted[j]=true; + } + continue; + } + } + if (deleted[i]) continue; + } + + L1TTracks tmp; + + for(unsigned int i=0;i tracks_; + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/L1TWord.hh b/L1Trigger/TrackFindingTracklet/interface/L1TWord.hh new file mode 100644 index 0000000000000..56738e068a772 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/L1TWord.hh @@ -0,0 +1,228 @@ +#ifndef L1TWORD_H +#define L1TWORD_H + +#include +#include +using namespace std; + +//This is the number of strips in rphi and in z for a module. +//This should be in the header of the ASCII file, but for now +//just hardcoded here. + + + +class L1TWord{ + +public: + + explicit L1TWord(bool printstat=false){ + + //cout << "In constructor 1"<maxsize_){ + cout <<"operator= "<maxsize_){ + cout << "Adding "<tmp.maxsize_) { + cout << "operator*:"<tmp.maxsize_) { + cout << "operator*(int):"<<"("<maxvalue_) { + maxvalue_=value; + } + } + + + long long int value_; + long long int maxsize_; + + std::string name_; + + bool printstat_; + long long int maxvalue_; + +}; + + + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/interface/slhcevent.hh b/L1Trigger/TrackFindingTracklet/interface/slhcevent.hh new file mode 100644 index 0000000000000..31456bb329a62 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/interface/slhcevent.hh @@ -0,0 +1,1794 @@ +#ifndef SLHCEVENT_H +#define SLHCEVENT_H + +#include +#include +#include +#include +#include +#include +#include +#include + +#define NSECTORS 28 + +using namespace std; + +//This is the number of strips in rphi and in z for a module. +//This should be in the header of the ASCII file, but for now +//just hardcoded here. + +static int nrphi=1000; +static int nz=80; + +static double two_pi=8*atan(1.0); + +static double x_offset=0.199196*0.0; +static double y_offset=0.299922*0.0; + + + +class ModuleGeometry { + +public: + + ModuleGeometry() { + + x0_=0.0; + y0_=0.0; + z0_=0.0; + + x1_=0.0; + y1_=0.0; + z1_=0.0; + + x2_=0.0; + y2_=0.0; + z2_=0.0; + + } + + + ModuleGeometry(double x0, double y0, double z0, + double x1, double y1, double z1, + double x2, double y2, double z2) { + + x0_=x0; + y0_=y0; + z0_=z0; + + x1_=x1; + y1_=y1; + z1_=z1; + + x2_=x2; + y2_=y2; + z2_=z2; + + } + + double phi() const { + return atan2(y0_+y1_,x0_+x1_); + } + + double phi1() const { + return atan2(y0_,x0_); + } + + double phi2() const { + return atan2(y1_,x1_); + } + + double r1() const { + return sqrt(y0_*y0_+x0_*x0_); + } + + double r2() const { + return sqrt(y1_*y1_+x1_*x1_); + } + + + +private: + + double x0_; + double y0_; + double z0_; + double x1_; + double y1_; + double z1_; + double x2_; + double y2_; + double z2_; + +}; + +class GeometryMap{ + +public: + + + GeometryMap() { + + //empty contructor to be used with the filler function. + + } + + void addModule(int innerlayer, int innerladder, int innermodule, + int outerlayer, int outerladder, int, + double x0, double y0, double z0, + double x1, double y1, double z1, + double x2, double y2, double z2) { + + x0-=x_offset; + y0-=y_offset; + + x1-=x_offset; + y1-=y_offset; + + x2-=x_offset; + y2-=y_offset; + + ModuleGeometry mg(x0,y0,z0,x1,y1,z1,x2,y2,z2); + + outerladder_[innerlayer][innerladder]=outerladder; + innerladder_[outerlayer][outerladder]=innerladder; + + modulegeometry_[innerlayer][innerladder][innermodule]=mg; + + } + + + GeometryMap(ifstream& in) { + + do { + + string tmp; + + in >> tmp; + + if (tmp=="EndMap") return; + + if (tmp!="Map:") { + cout << "Expected to read 'Map:' or 'EndMap' but found:"<> innerlayer >> innerladder >> innermodule + >> outerlayer >> outerladder >> outermodule + >> x0 >> y0 >> z0 + >> x1 >> y1 >> z1 + >> x2 >> y2 >> z2; + + innerlayer--; //HACK 6_1 + outerlayer--; //HACK 6_1 + //innerladder--; //HACK 6_1 + //outerladder--; //HACK 6_1 + + + //innermodule--; //Hack!!! + //outermodule--; + + x0-=x_offset; + y0-=y_offset; + + x1-=x_offset; + y1-=y_offset; + + x2-=x_offset; + y2-=y_offset; + + + ModuleGeometry mg(x0,y0,z0,x1,y1,z1,x2,y2,z2); + + + //if (innermodule==1) { + // cout << "innerlayer="< >::const_iterator it1=innerladder_.find(outerlayer); + assert(it1!=innerladder_.end()); + map< int, int>::const_iterator it2=it1->second.find(outerladder); + assert(it2!=it1->second.end()); + return it2->second; + } + + bool inner(int layer, int ladder){ + + map >::const_iterator ita1=outerladder_.find(layer); + assert(ita1!=outerladder_.end()); + map< int, int>::const_iterator ita2=ita1->second.find(ladder); + bool foundA=(ita2!=ita1->second.end()); + + + + map >::const_iterator itb1=innerladder_.find(layer); + assert(itb1!=innerladder_.end()); + map< int, int>::const_iterator itb2=itb1->second.find(ladder); + bool foundB=(itb2!=itb1->second.end()); + + assert(foundA||foundB); + assert(!(foundA&&foundB)); + + //if (foundA) cout << "layer="< > >::const_iterator ita1=modulegeometry_.find(layer); + assert(ita1!=modulegeometry_.end()); + + + map< int, map >::const_iterator ita2=ita1->second.find(ladder); + assert(ita2!=ita1->second.end()); + + map::const_iterator ita3=ita2->second.find(module); + assert(ita3!=ita2->second.end()); + + return ita3->second; + + + } + + bool moduleGeometryExists(int layer,int ladder,int module) const { + + map > >::const_iterator ita1=modulegeometry_.find(layer); + assert(ita1!=modulegeometry_.end()); + + + map< int, map >::const_iterator ita2=ita1->second.find(ladder); + assert(ita2!=ita1->second.end()); + + map::const_iterator ita3=ita2->second.find(module); + return ita3!=ita2->second.end(); + + + } + + bool print(int layer){ + + map > >::const_iterator ita1=modulegeometry_.find(layer); + assert(ita1!=modulegeometry_.end()); + + map< int, map >::const_iterator ita2=ita1->second.begin(); + map< int, map >::const_iterator ita2end=ita1->second.end(); + while(ita2!=ita2end){ + cout << "ladder, phi:"<first<<" "<second.begin()->second.phi()< > outerladder_; + + //returns the inner ladder given outer ladder + // layer ladder + map > innerladder_; + + //returns the geometry given inner ladder + // layer ladder module + map > > modulegeometry_; + + +}; + +class L1SimTrack{ + +public: + + L1SimTrack() { + id_=-1; + } + + L1SimTrack(int id, int type, double pt, double eta, double phi, + double vx, double vy, double vz) { + id_=id; + type_=type; + pt_=pt; + eta_=eta; + phi_=phi; + vx_=vx; + vy_=vy; + vz_=vz; + } + + void write(ofstream& out){ + + out << "L1SimTrack: " + << id_ << "\t" + << type_ << "\t" + << pt_ << "\t" + << eta_ << "\t" + << phi_ << "\t" + << vx_ << "\t" + << vy_ << "\t" + << vz_ << "\t" << endl; + + } + + int id() const { return id_; } + int type() const { return type_; } + double pt() { return pt_; } + double eta() { return eta_; } + double phi() { return phi_; } + double vx() { return vx_; } + double vy() { return vy_; } + double vz() { return vz_; } + +private: + + int id_; + int type_; + double pt_; + double eta_; + double phi_; + double vx_; + double vy_; + double vz_; + +}; + + +class Digi{ + +public: + + + Digi(int layer,int irphi, int iz, int sensorlayer, + int ladder, int module, double x, double y, double z) { + layer_=layer; + irphi_=irphi; + iz_=iz; + sensorlayer_=sensorlayer; + ladder_=ladder; + module_=module; + x_=x; + y_=y; + z_=z; + } + + void AddSimtrack(int simtrackid){ + simtrackids_.push_back(simtrackid); + } + + void write(ofstream& out){ + + out << "Digi: " + << layer_ << "\t" + << irphi_ << "\t" + << iz_ << "\t" + << sensorlayer_ << "\t" + << ladder_ << "\t" + << module_ << "\t" + << x_ << "\t" + << y_ << "\t" + << z_ << "\t" << endl; + + for (unsigned int i=0;i simtrackids_; + +}; + +struct HashOp { + int operator()(const Digi &a) const { + return a.hash(); + } +}; + +struct HashEqual { + bool operator()(const Digi &a, const Digi &b) const { + return a == b; + } +}; + + + +class ChipDigi{ + +public: + + + ChipDigi(int layer,int irphichip, int izchip,int irphi, int iz, + int sensorlayer, + int ladder, int module,bool inner) { + layer_=layer; + irphi_=irphi; + iz_=iz; + irphichip_=irphichip; + izchip_=izchip; + sensorlayer_=sensorlayer; + ladder_=ladder; + module_=module; + inner_=inner; + } + + void AddSimtrack(int simtrackid){ + for(unsigned int i=0;i simtrackids_; + +}; + + +class Sector{ + +public: + + Sector() { + sector_=-1; + phi_=-999.999; + } + + void setSector(int n){ + sector_=n; + phi_=n*(two_pi/NSECTORS); + } + + //return true is the test phi is closer then ladder + bool closer(const GeometryMap& map,int layer, int ladder,double phi){ + + double phi_ladder=map.moduleGeometry(layer,ladder,1).phi(); + + double delta_phi_ladder=phi_ladder-phi_; + double delta_phi=phi-phi_; + + if (delta_phi_ladder>0.5*two_pi) delta_phi_ladder-=two_pi; + if (delta_phi_ladder<-0.5*two_pi) delta_phi_ladder+=two_pi; + + if (delta_phi>0.5*two_pi) delta_phi-=two_pi; + if (delta_phi<-0.5*two_pi) delta_phi+=two_pi; + + return (fabs(delta_phi)& theLadder, unsigned int maxLadder, + const GeometryMap& map, + int layer, int ladder){ + + double phi=map.moduleGeometry(layer,ladder,1).phi(); + + if (theLadder.size()& theLadder,int ladder){ + for (unsigned int i=0;i=1&&layer<=10); + + if (layer==1) { + return inLadder(ladder_1,ladder); + return 0; + } + + if (layer==2) { + return inLadder(ladder_2,ladder); + return 0; + } + + if (layer==3) { + return inLadder(ladder_3,ladder); + } + + if (layer==4) { + return inLadder(ladder_4,ladder); + } + + if (layer==5) { + return inLadder(ladder_5,ladder); + } + + if (layer==6) { + return inLadder(ladder_6,ladder); + } + + if (layer==7) { + return inLadder(ladder_7,ladder); + } + + if (layer==8) { + return inLadder(ladder_8,ladder); + } + + if (layer==9) { + //cout << "ladder_9.size()="< ladder_1; + vector ladder_2; + vector ladder_3; + vector ladder_4; + vector ladder_5; + vector ladder_6; + vector ladder_7; + vector ladder_8; + vector ladder_9; + vector ladder_10; + +}; + + +class Stub{ + +public: + + Stub() { + + } + + Stub(int layer,int ladder, int module, double pt, + double x, double y, double z) { + layer_=layer; + ladder_=ladder; + module_=module; + pt_=pt; + x_=x; + y_=y; + z_=z; + + } + + void AddInnerDigi(int ladder, int module, int irphi,int iz){ + + pair tmplm(ladder,module); + innerdigisladdermodule_.push_back(tmplm); + + pair tmp(irphi,iz); + innerdigis_.push_back(tmp); + } + + void AddOuterDigi(int ladder, int module, int irphi,int iz){ + + pair tmplm(ladder,module); + outerdigisladdermodule_.push_back(tmplm); + + pair tmp(irphi,iz); + outerdigis_.push_back(tmp); + } + + void write(ofstream& out){ + + out << "Stub: " + << layer_ << "\t" + << ladder_ << "\t" + << module_ << "\t" + << pt_ << "\t" + << x_ << "\t" + << y_ << "\t" + << z_ << "\t" << endl; + + for (unsigned int i=0;i0) { + cout << "innerdigis_.size()="<0) { + cout << "outerdigis_.size()="<0) { + cout << "innerdigis_.size()="< > innerdigis() const { return innerdigis_; } + vector > outerdigis() const { return outerdigis_; } + vector > innerdigisladdermodule() const { return innerdigisladdermodule_; } + vector > outerdigisladdermodule() const { return outerdigisladdermodule_; } + double x() const { return x_; } + double y() const { return y_; } + double z() const { return z_; } + double r() const { return sqrt(x_*x_+y_*y_); } + double pt() const { return pt_; } + +private: + + int layer_; + int ladder_; + int module_; + double pt_; + double x_; + double y_; + double z_; + + vector > innerdigis_; + vector > innerdigisladdermodule_; + vector > outerdigis_; + vector > outerdigisladdermodule_; + + +}; + + + +class SLHCEvent{ + +public: + + + SLHCEvent() { + + //empty constructor to be used with 'filler' functions + + nchiprphi_=-1; + nchipz_=-1; + nstripz_=-1; + Ntrack_=0; + + } + + void setIPx(double x) { x_offset=x;} + void setIPy(double y) { y_offset=y;} + + void addL1SimTrack(int id,int type,double pt,double eta,double phi, + double vx,double vy,double vz){ + + vx-=x_offset; + vy-=y_offset; + L1SimTrack simtrack(id,type,pt,eta,phi,vx,vy,vz); + simtracks_.push_back(simtrack); + + } + + + void addDigi(int layer,int irphi,int iz,int sensorlayer,int ladder,int module, + double x,double y,double z,vector simtrackids){ + + x-=x_offset; + y-=y_offset; + + Digi digi(layer,irphi,iz,sensorlayer,ladder, + module,x,y,z); + + for (unsigned int i=0;i innerStack, + vector irphi, + vector iz, + vector iladder, + vector imodule){ + + x-=x_offset; + y-=y_offset; + + Stub stub(layer, ladder, module, pt, x, y, z); + + for(unsigned int i=0;i> tmp; + if (tmp!="Event:") { + cout << "Expected to read 'Event:' but found:"<> eventnum_; + + cout << "Started to read event="<> tmp; + while (tmp!="SimTrackEnd"){ + if (!(tmp=="SimTrack:"||tmp=="SimTrackEnd")) { + cout << "Expected to read 'SimTrack:' or 'SimTrackEnd' but found:" + << tmp << endl; + abort(); + } + int id; + int type; + double pt; + double eta; + double phi; + double vx; + double vy; + double vz; + in >> id >> type >> pt >> eta >> phi >> vx >> vy >> vz; + //in >> id >> pt >> eta >> vx >> vy >> vz; + if (first) { + mc_rinv=0.00299792*3.8/pt; + mc_phi0=phi; + mc_z0=vz; + mc_t=tan(0.25*two_pi-2.0*atan(exp(-eta))); + event=eventnum_; + first=false; + } + vx-=x_offset; + vy-=y_offset; + L1SimTrack simtrack(id,type,pt,eta,phi,vx,vy,vz); + simtracks_.push_back(simtrack); + in >> tmp; + } + + + + //read te Digis + in >> tmp; + while (tmp!="DigiEnd"){ + //cout << "Here001:"<> layer + >> irphi + >> iz + >> sensorlayer + >> ladder + >> module + >> x + >> y + >> z; + + x-=x_offset; + y-=y_offset; + + + Digi digi(layer,irphi,iz,sensorlayer,ladder, + module,x,y,z); + in >> tmp; + while (tmp=="SimTrackId:"){ + int simtrackid; + in >> simtrackid; + digi.AddSimtrack(simtrackid); + in >> tmp; + } + digis_.push_back(digi); + digihash_.insert(digi); + } + + cout << "Read "<> tmp; + while (tmp!="StubEnd"){ + //cout << "Here002:"<> layer >> ladder >> module >> pt >> x >> y >> z; + + layer--; //HACK 6_1 + //ladder++; + + x-=x_offset; + y-=y_offset; + + if (layer < 10) nlayer[layer]++; + + Stub stub(layer, ladder, module, pt, x, y, z); + + in >> tmp; + //cout << "Here003:"<> irphi; + //cout << "irphi="<> iz; + //cout << "iz="<> iladder; + //cout << "iladder="<> imodule; + //cout << "imodule="<> tmp; + //cout << "Here004:"< > > > chipdigimap; + + cout << "number of chip digis="< > > >::const_iterator itlayer=chipdigimap.begin(); + map > > >::const_iterator itlayerend=chipdigimap.end(); + + for(;itlayer!=itlayerend;++itlayer) { + + map > >::const_iterator itladder=itlayer->second.begin(); + map > >::const_iterator itladderend=itlayer->second.end(); + + for(;itladder!=itladderend;++itladder) { + + map >::const_iterator itmodule=itladder->second.begin(); + map >::const_iterator itmoduleend=itladder->second.end(); + + for(;itmodule!=itmoduleend;++itmodule) { + + cout << "layer="<first + << " ladder="<first + << " module="<first + << " number of digis="<second.size()< digis=itmodule->second; + + int innermap[1000][1000]; + int outermap[1000][1000]; + + //outchip << "layer="<first + // << " ladder="<first + // << " module="<first << endl; + + int nStubs=0; + + //first we have to count the stubs... + for (unsigned int i=0;ifirst&& + innerladder==itladder->first&& + aStub.module()==itmodule->first) { + nStubs++; + } + + } + + bool firstStub=true; + + for (unsigned int i=0;ifirst&& + innerladder==itladder->first&& + aStub.module()==itmodule->first) { + + + char buf[500]; + + + if (firstStub) { + + sprintf(buf,"FE_%02d_%03d_%03d_NSTUB %03d", + itlayer->first, + itladder->first, + itmodule->first, + nStubs); + + outchip << buf << endl;; + + } + + firstStub=false; + + + sprintf(buf,"FE_%02d_%03d_%03d", + itlayer->first, + itladder->first, + itmodule->first); + + outchip << buf << "_STUB "; + + vector > innerdigis=aStub.innerdigis(); + for (unsigned int j=0;j > outerdigistmp=aStub.outerdigis(); + + vector > outerdigis; + for (unsigned int j=0;j(outerdigistmp[j].first, + outerdigistmp[j].second/4)); + } + } + + for (unsigned int j=0;jfirst, + itladder->first, + itmodule->first, + izchip, + irphichip, + iz/4); + outchip<first, + itladder->first, + itmodule->first, + izchip, + irphichip, + iz); + outchip< simtrackids; + + simtrackids=this->simtrackids(stub); + + if (simtrackids.size()==0) { + //cout << "Warning no simtrackids"< simtrackids(const Stub& stub){ + + //cout << "Entering simtrackids"< simtrackids; + + int layer=stub.layer()+1; + + + vector > innerdigis=stub.innerdigis(); + vector > outerdigis=stub.outerdigis(); + vector > innerdigisladdermodule=stub.innerdigisladdermodule(); + vector > outerdigisladdermodule=stub.outerdigisladdermodule(); + + vector > alldigis=stub.innerdigis(); + alldigis.insert(alldigis.end(),outerdigis.begin(),outerdigis.end()); + vector > alldigisladdermodule=stub.innerdigisladdermodule(); + alldigisladdermodule.insert(alldigisladdermodule.end(), + outerdigisladdermodule.begin(), + outerdigisladdermodule.end()); + + + + if (layer<1000) { + + for (unsigned int k=0;k::const_iterator it=digihash_.find(tmp); + if(it==digihash_.end()){ + static int count=0; + count++; + if (count<5) { + cout << "Warning did not find digi"<::const_iterator it=digihash_.find(tmp); + if(it==digihash_.end()){ + static int count=0; + count++; + if (count < 5) { + cout << "Warning did not find digi in disks"< simtracks_; + vector digis_; + __gnu_cxx::hash_set digihash_; + vector chipdigis_; + vector stubs_; + + int nchiprphi_; + int nchipz_; + int nstripz_; + +}; + +double SLHCEvent::mc_rinv=0.0; +double SLHCEvent::mc_phi0=0.0; +double SLHCEvent::mc_z0=0.0; +double SLHCEvent::mc_t=0.0; +int SLHCEvent::event=0; + +#endif + + + diff --git a/L1Trigger/TrackFindingTracklet/plugins/BuildFile.xml b/L1Trigger/TrackFindingTracklet/plugins/BuildFile.xml new file mode 100644 index 0000000000000..3f26ffc21496d --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/plugins/BuildFile.xml @@ -0,0 +1,15 @@ + + + + + + + + + + + + + + + diff --git a/L1Trigger/TrackFindingTracklet/plugins/L1Tracking.icc b/L1Trigger/TrackFindingTracklet/plugins/L1Tracking.icc new file mode 100644 index 0000000000000..ee344f60eed74 --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/plugins/L1Tracking.icc @@ -0,0 +1,1071 @@ + const int NSector=24; + + int NBarrel=0; + int NDisk=0; + + L1TBarrel* L[10]; + L1TDisk* F[7]; + L1TDisk* B[7]; + + if (mode==4) { + NBarrel=6; + NDisk=5; + L[0]=new L1TBarrel(20.0,30.0,125.0,NSector); + L[1]=new L1TBarrel(30.0,40.0,125.0,NSector); + L[2]=new L1TBarrel(40.0,60.0,125.0,NSector); + L[3]=new L1TBarrel(60.0,80.0,125.0,NSector); + L[4]=new L1TBarrel(80.0,100.0,125.0,NSector); + L[5]=new L1TBarrel(100.0,120.0,125.0,NSector); + + F[0]=new L1TDisk(125.0,150.0,NSector); + F[1]=new L1TDisk(150.0,175.0,NSector); + F[2]=new L1TDisk(175.0,210.0,NSector); + F[3]=new L1TDisk(210.0,250.0,NSector); + F[4]=new L1TDisk(250.0,275.0,NSector); + + B[0]=new L1TDisk(-125.0,-150.0,NSector); + B[1]=new L1TDisk(-150.0,-175.0,NSector); + B[2]=new L1TDisk(-175.0,-210.0,NSector); + B[3]=new L1TDisk(-210.0,-250.0,NSector); + B[4]=new L1TDisk(-250.0,-275.0,NSector); + + } + + + if (mode==3) { + NBarrel=6; + NDisk=7; + L[0]=new L1TBarrel(20.0,30.0,125.0,NSector); + L[1]=new L1TBarrel(30.0,40.0,125.0,NSector); + L[2]=new L1TBarrel(40.0,60.0,125.0,NSector); + L[3]=new L1TBarrel(60.0,80.0,125.0,NSector); + L[4]=new L1TBarrel(80.0,100.0,125.0,NSector); + L[5]=new L1TBarrel(100.0,120.0,125.0,NSector); + + F[0]=new L1TDisk(125.0,140.0,NSector); + F[1]=new L1TDisk(140.0,157.0,NSector); + F[2]=new L1TDisk(157.0,175.0,NSector); + F[3]=new L1TDisk(175.0,195.0,NSector); + F[4]=new L1TDisk(195.0,220.0,NSector); + F[5]=new L1TDisk(220.0,245.0,NSector); + F[6]=new L1TDisk(245.0,279.0,NSector); + + B[0]=new L1TDisk(-125.0,-140.0,NSector); + B[1]=new L1TDisk(-140.0,-157.0,NSector); + B[2]=new L1TDisk(-157.0,-175.0,NSector); + B[3]=new L1TDisk(-175.0,-195.0,NSector); + B[4]=new L1TDisk(-195.0,-220.0,NSector); + B[5]=new L1TDisk(-220.0,-245.0,NSector); + B[6]=new L1TDisk(-245.0,-279.0,NSector); + + } + + if (mode==2){ + NBarrel=10; + NDisk=0; + L[0]=new L1TBarrel(18.0,23.5,290.0,NSector); + L[1]=new L1TBarrel(23.5,35.0,290.0,NSector); + L[2]=new L1TBarrel(35.0,49.0,290.0,NSector); + L[3]=new L1TBarrel(49.0,55.0,290.0,NSector); + L[4]=new L1TBarrel(55.0,66.0,290.0,NSector); + L[5]=new L1TBarrel(66.0,75.0,290.0,NSector); + L[6]=new L1TBarrel(75.0,83.0,290.0,NSector); + L[7]=new L1TBarrel(83.0,90.0,290.0,NSector); + L[8]=new L1TBarrel(90.0,99.0,290.0,NSector); + L[9]=new L1TBarrel(99.0,110.0,290.0,NSector); + } + + + if (mode==1){ + NBarrel=10; + NDisk=0; + L[0]=new L1TBarrel(30.0,38.0,290.0,NSector); + L[1]=new L1TBarrel(38.0,47.0,290.0,NSector); + L[2]=new L1TBarrel(47.0,56.0,290.0,NSector); + L[3]=new L1TBarrel(56.0,65.0,290.0,NSector); + L[4]=new L1TBarrel(65.0,73.0,290.0,NSector); + L[5]=new L1TBarrel(73.0,78.0,290.0,NSector); + L[6]=new L1TBarrel(78.0,85.0,290.0,NSector); + L[7]=new L1TBarrel(85.0,92.0,290.0,NSector); + L[8]=new L1TBarrel(92.0,98.0,290.0,NSector); + L[9]=new L1TBarrel(98.0,110.0,290.0,NSector); + } + + + + cout << "looping over stubs: "<60) sigmaz=1.44; //HACK!!! + } + + L1TStub aStub(simtrackid,stub.iphi(),stub.iz(),layer,ladder,module,stub.x(),stub.y(),stub.z(),sigmax,sigmaz,stub.pt()*stub.ptsign()); + + //cout << "layer ladder module:"<addStub(aStub)) count_match++; + } + for (int idisk=0;idiskaddStub(aStub)) count_match++; + if (B[idisk]->addStub(aStub)) count_match++; + } + + if (count_match!=1) { + cout << "layer ladder module:"<findTracklets(L[1],true); + //cout << "start finding matches..."<findMatches(L[2],0.075,0.6); + L[0]->findMatches(L[3],0.075,0.6); + L[0]->findMatches(L[4],0.5,2.0); + L[0]->findMatches(L[5],0.5,2.0); + L[0]->findMatches(L[6],0.5,2.0); + L[0]->findMatches(L[7],0.5,2.0); + L[0]->findMatches(L[8],0.5,2.0); + L[0]->findMatches(L[9],0.5,2.0); + //cout << "..done finding matches"<fitTracks(); + + allTracks.addTracks(L[0]->allTracks()); + + L[2]->findTracklets(L[3],true); + //cout << "start finding matches..."<findMatches(L[0],0.075,0.6); + L[2]->findMatches(L[1],0.075,0.6); + L[2]->findMatches(L[4],0.3,2.0); + L[2]->findMatches(L[5],0.3,2.0); + L[2]->findMatches(L[6],0.3,2.0); + L[2]->findMatches(L[7],0.3,2.0); + L[2]->findMatches(L[8],0.3,2.0); + L[2]->findMatches(L[9],0.3,2.0); + //cout << "..done finding matches"<fitTracks(); + + allTracks.addTracks(L[2]->allTracks()); + + L[4]->findTracklets(L[5],true); + //cout << "start finding matches..."<findMatches(L[0],0.15,2.0); + L[4]->findMatches(L[1],0.15,2.0); + L[4]->findMatches(L[2],0.15,1.5); + L[4]->findMatches(L[3],0.15,1.5); + L[4]->findMatches(L[6],0.15,1.5); + L[4]->findMatches(L[7],0.15,1.5); + L[4]->findMatches(L[8],0.15,1.5); + L[4]->findMatches(L[9],0.15,1.5); + //cout << "..done finding matches"<fitTracks(); + + allTracks.addTracks(L[4]->allTracks()); + + L[6]->findTracklets(L[7],true); + //cout << "start finding matches..."<findMatches(L[0],0.15,2.0); + L[6]->findMatches(L[1],0.15,2.0); + L[6]->findMatches(L[2],0.15,1.5); + L[6]->findMatches(L[3],0.15,1.5); + L[6]->findMatches(L[4],0.15,1.5); + L[6]->findMatches(L[5],0.15,1.5); + L[6]->findMatches(L[8],0.15,1.5); + L[6]->findMatches(L[9],0.15,1.5); + //cout << "..done finding matches"<fitTracks(); + + allTracks.addTracks(L[6]->allTracks()); + + + L[8]->findTracklets(L[9],true); + //cout << "start finding matches..."<findMatches(L[0],0.15,2.0); + L[8]->findMatches(L[1],0.15,2.0); + L[8]->findMatches(L[2],0.15,1.5); + L[8]->findMatches(L[3],0.15,1.5); + L[8]->findMatches(L[4],0.15,1.5); + L[8]->findMatches(L[5],0.15,1.5); + L[8]->findMatches(L[6],0.15,1.5); + L[8]->findMatches(L[7],0.15,1.5); + //cout << "..done finding matches"<fitTracks(); + + allTracks.addTracks(L[8]->allTracks()); + + } + + if (mode==2) { + + L[0]->findTracklets(L[1]); + L[0]->findMatches(L[2],0.2,2.0); + L[0]->findMatches(L[3],0.2,2.0); + L[0]->findMatches(L[4],1.0,3.0); + L[0]->findMatches(L[5],1.0,3.0); + L[0]->findMatches(L[6],1.0,3.0); + L[0]->findMatches(L[7],1.0,3.0); + L[0]->findMatches(L[8],1.0,3.0); + L[0]->findMatches(L[9],1.0,3.0); + L[0]->fitTracks(); + + allTracks.addTracks(L[0]->allTracks()); + + L[2]->findTracklets(L[3]); + L[2]->findMatches(L[0],0.075,2.0); + L[2]->findMatches(L[1],0.075,2.0); + L[2]->findMatches(L[4],0.3,3.0); + L[2]->findMatches(L[5],0.3,3.0); + L[2]->findMatches(L[6],0.3,3.0); + L[2]->findMatches(L[7],0.3,3.0); + L[2]->findMatches(L[8],0.3,3.0); + L[2]->findMatches(L[9],0.3,3.0); + L[2]->fitTracks(); + + allTracks.addTracks(L[2]->allTracks()); + + L[4]->findTracklets(L[5]); + L[4]->findMatches(L[0],0.075,10.0); + L[4]->findMatches(L[1],0.075,10.0); + L[4]->findMatches(L[2],0.075,10.0); + L[4]->findMatches(L[3],0.075,10.0); + L[4]->findMatches(L[6],0.075,10.0); + L[4]->findMatches(L[7],0.075,10.0); + L[4]->findMatches(L[8],0.075,10.0); + L[4]->findMatches(L[9],0.075,10.0); + L[4]->fitTracks(); + + allTracks.addTracks(L[4]->allTracks()); + + L[6]->findTracklets(L[7]); + L[6]->findMatches(L[0],0.075,10.0); + L[6]->findMatches(L[1],0.075,10.0); + L[6]->findMatches(L[2],0.075,10.0); + L[6]->findMatches(L[3],0.075,10.0); + L[6]->findMatches(L[4],0.075,10.0); + L[6]->findMatches(L[5],0.075,10.0); + L[6]->findMatches(L[8],0.075,10.0); + L[6]->findMatches(L[9],0.075,10.0); + L[6]->fitTracks(); + + allTracks.addTracks(L[6]->allTracks()); + + + L[8]->findTracklets(L[9]); + L[8]->findMatches(L[0],0.075,10.0); + L[8]->findMatches(L[1],0.075,10.0); + L[8]->findMatches(L[2],0.075,10.0); + L[8]->findMatches(L[3],0.075,10.0); + L[8]->findMatches(L[4],0.075,10.0); + L[8]->findMatches(L[5],0.075,10.0); + L[8]->findMatches(L[6],0.075,10.0); + L[8]->findMatches(L[7],0.075,10.0); + L[8]->fitTracks(); + + allTracks.addTracks(L[8]->allTracks()); + + } + + if (mode==3) { + + if (1){ + L[0]->findTracklets(L[1]); + L[0]->findTracklets(B[0]); + L[0]->findTracklets(F[0]); + L[0]->findMatches(L[2],0.075,0.5); + L[0]->findMatches(L[3],0.12,3.0); + L[0]->findMatches(L[4],0.15,3.0); + L[0]->findMatches(L[5],0.2,3.0); + L[0]->findMatches(F[0]); + L[0]->findMatches(F[1]); + L[0]->findMatches(F[2]); + L[0]->findMatches(F[3]); + L[0]->findMatches(F[4]); + L[0]->findMatches(F[5]); + L[0]->findMatches(F[6]); + L[0]->findMatches(B[0]); + L[0]->findMatches(B[1]); + L[0]->findMatches(B[2]); + L[0]->findMatches(B[3]); + L[0]->findMatches(B[4]); + L[0]->findMatches(B[5]); + L[0]->findMatches(B[6]); + L[0]->fitTracks(); + + allTracks.addTracks(L[0]->allTracks()); + } + + if(1){ + L[1]->findTracklets(L[2]); + L[1]->findTracklets(B[0]); + L[1]->findTracklets(F[0]); + L[1]->findMatches(L[0],0.04,0.5); + L[1]->findMatches(L[3],0.075,3.0); + L[1]->findMatches(L[4],0.1,3.0); + L[1]->findMatches(L[5],0.15,3.0); + L[1]->findMatches(F[0]); + L[1]->findMatches(F[1]); + L[1]->findMatches(F[2]); + L[1]->findMatches(F[3]); + L[1]->findMatches(F[4]); + L[1]->findMatches(F[5]); + L[1]->findMatches(F[6]); + L[1]->findMatches(B[0]); + L[1]->findMatches(B[1]); + L[1]->findMatches(B[2]); + L[1]->findMatches(B[3]); + L[1]->findMatches(B[4]); + L[1]->findMatches(B[5]); + L[1]->findMatches(B[6]); + L[1]->fitTracks(); + + allTracks.addTracks(L[1]->allTracks()); + } + + if(1){ + L[2]->findTracklets(L[3]); + L[2]->findTracklets(B[0]); + L[2]->findTracklets(F[0]); + L[2]->findMatches(L[0],0.025,5.0); + L[2]->findMatches(L[1],0.025,3.0); + L[2]->findMatches(L[4],0.03,8.0); + L[2]->findMatches(L[5],0.05,10.0); + L[2]->findMatches(F[0]); + L[2]->findMatches(F[1]); + L[2]->findMatches(F[2]); + L[2]->findMatches(F[3]); + L[2]->findMatches(F[4]); + L[2]->findMatches(F[5]); + L[2]->findMatches(F[6]); + L[2]->findMatches(B[0]); + L[2]->findMatches(B[1]); + L[2]->findMatches(B[2]); + L[2]->findMatches(B[3]); + L[2]->findMatches(B[4]); + L[2]->findMatches(B[5]); + L[2]->findMatches(B[6]); + L[2]->fitTracks(); + + allTracks.addTracks(L[2]->allTracks()); + } + + if(1){ + L[3]->findTracklets(L[4]); + L[3]->findTracklets(B[0]); + L[3]->findTracklets(F[0]); + L[3]->findMatches(L[0],0.025,5.0); + L[3]->findMatches(L[1],0.025,3.0); + L[3]->findMatches(L[2],0.03,8.0); + L[3]->findMatches(L[5],0.05,10.0); + L[3]->findMatches(F[0]); + L[3]->findMatches(F[1]); + L[3]->findMatches(F[2]); + L[3]->findMatches(F[3]); + L[3]->findMatches(F[4]); + L[3]->findMatches(F[5]); + L[3]->findMatches(F[6]); + L[3]->findMatches(B[0]); + L[3]->findMatches(B[1]); + L[3]->findMatches(B[2]); + L[3]->findMatches(B[3]); + L[3]->findMatches(B[4]); + L[3]->findMatches(B[5]); + L[3]->findMatches(B[6]); + L[3]->fitTracks(); + + allTracks.addTracks(L[3]->allTracks()); + } + + if(1){ + F[0]->findTracklets(F[1]); + F[0]->findMatches(F[2],0.05,0.5,0.05); + F[0]->findMatches(F[3],0.09,0.6,0.09); + F[0]->findMatches(F[4],0.1,1.0,0.1); + F[0]->findMatches(F[5],0.15,1.0,0.15); + F[0]->findMatches(F[6],0.15,1.0,0.15); + F[0]->findBarrelMatches(L[0]); + F[0]->findBarrelMatches(L[1]); + F[0]->findBarrelMatches(L[2]); + F[0]->findBarrelMatches(L[3]); + F[0]->findBarrelMatches(L[4]); + F[0]->findBarrelMatches(L[5]); + F[0]->fitTracks(); + + allTracks.addTracks(F[0]->allTracks()); + } + + if(1){ + F[1]->findTracklets(F[2]); + F[1]->findMatches(F[0],0.04,0.4,0.04); + F[1]->findMatches(F[3],0.05,0.5,0.05); + F[1]->findMatches(F[4],0.075,0.5,0.075); + F[1]->findMatches(F[5],0.1,1.0,0.1); + F[1]->findMatches(F[6],0.1,1.0,0.1); + F[1]->findBarrelMatches(L[0]); + F[1]->findBarrelMatches(L[1]); + F[1]->findBarrelMatches(L[2]); + F[1]->findBarrelMatches(L[3]); + F[1]->findBarrelMatches(L[4]); + F[1]->findBarrelMatches(L[5]); + F[1]->fitTracks(); + + allTracks.addTracks(F[1]->allTracks()); + } + + if(1){ + F[2]->findTracklets(F[3]); + F[2]->findMatches(F[0],0.05,0.5,0.05); + F[2]->findMatches(F[1],0.04,0.5,0.04); + F[2]->findMatches(F[4],0.05,0.5,0.05); + F[2]->findMatches(F[5],0.05,0.8,0.05); + F[2]->findMatches(F[6],0.08,1.0,0.08); + F[2]->findBarrelMatches(L[0]); + F[2]->findBarrelMatches(L[1]); + F[2]->findBarrelMatches(L[2]); + F[2]->findBarrelMatches(L[3]); + F[2]->findBarrelMatches(L[4]); + F[2]->findBarrelMatches(L[5]); + F[2]->fitTracks(); + + allTracks.addTracks(F[2]->allTracks()); + } + + if(1){ + F[3]->findTracklets(F[4]); + F[3]->findMatches(F[0],0.05,0.5,0.05); + F[3]->findMatches(F[1],0.05,0.5,0.05); + F[3]->findMatches(F[2],0.05,0.5,0.05); + F[3]->findMatches(F[5],0.05,0.8,0.05); + F[3]->findMatches(F[6],0.05,0.8,0.05); + F[3]->findBarrelMatches(L[0]); + F[3]->findBarrelMatches(L[1]); + F[3]->findBarrelMatches(L[2]); + F[3]->findBarrelMatches(L[3]); + F[3]->findBarrelMatches(L[4]); + F[3]->findBarrelMatches(L[5]); + F[3]->fitTracks(); + + allTracks.addTracks(F[3]->allTracks()); + } + + if(1){ + F[4]->findTracklets(F[5]); + F[4]->findMatches(F[0],0.05,0.5,0.05); + F[4]->findMatches(F[1],0.05,0.5,0.05); + F[4]->findMatches(F[2],0.05,0.5,0.05); + F[4]->findMatches(F[3],0.05,0.5,0.05); + F[4]->findMatches(F[6],0.05,0.5,0.05); + F[4]->findBarrelMatches(L[0]); + F[4]->findBarrelMatches(L[1]); + F[4]->findBarrelMatches(L[2]); + F[4]->findBarrelMatches(L[3]); + F[4]->findBarrelMatches(L[4]); + F[4]->findBarrelMatches(L[5]); + F[4]->fitTracks(); + + allTracks.addTracks(F[4]->allTracks()); + } + + if(1){ + F[5]->findTracklets(F[6]); + F[5]->findMatches(F[0],0.05,0.5,0.05); + F[5]->findMatches(F[1],0.05,0.5,0.05); + F[5]->findMatches(F[2],0.05,0.5,0.05); + F[5]->findMatches(F[3],0.05,0.5,0.05); + F[5]->findMatches(F[4],0.05,0.5,0.05); + F[5]->findBarrelMatches(L[0]); + F[5]->findBarrelMatches(L[1]); + F[5]->findBarrelMatches(L[2]); + F[5]->findBarrelMatches(L[3]); + F[5]->findBarrelMatches(L[4]); + F[5]->findBarrelMatches(L[5]); + F[5]->fitTracks(); + + allTracks.addTracks(F[5]->allTracks()); + } + + if(1){ + B[0]->findTracklets(B[1]); + B[0]->findMatches(B[2],0.05,0.5,0.05); + B[0]->findMatches(B[3],0.08,0.6,0.08); + B[0]->findMatches(B[4],0.1,1.0,0.1); + B[0]->findMatches(B[5],0.15,1.0,0.15); + B[0]->findMatches(B[6],0.15,1.0,0.15); + B[0]->findBarrelMatches(L[0]); + B[0]->findBarrelMatches(L[1]); + B[0]->findBarrelMatches(L[2]); + B[0]->findBarrelMatches(L[3]); + B[0]->findBarrelMatches(L[4]); + B[0]->findBarrelMatches(L[5]); + B[0]->fitTracks(); + + allTracks.addTracks(B[0]->allTracks()); + } + + if(1){ + B[1]->findTracklets(B[2]); + B[1]->findMatches(B[0],0.04,0.4,0.04); + B[1]->findMatches(B[3],0.05,0.5,0.05); + B[1]->findMatches(B[4],0.075,0.5,0.075); + B[1]->findMatches(B[5],0.1,1.0,0.1); + B[1]->findMatches(B[6],0.1,1.0,0.1); + B[1]->findBarrelMatches(L[0]); + B[1]->findBarrelMatches(L[1]); + B[1]->findBarrelMatches(L[2]); + B[1]->findBarrelMatches(L[3]); + B[1]->findBarrelMatches(L[4]); + B[1]->findBarrelMatches(L[5]); + B[1]->fitTracks(); + + allTracks.addTracks(B[1]->allTracks()); + } + + if(1){ + B[2]->findTracklets(B[3]); + B[2]->findMatches(B[0],0.05,0.5,0.05); + B[2]->findMatches(B[1],0.04,0.5,0.04); + B[2]->findMatches(B[4],0.05,0.5,0.05); + B[2]->findMatches(B[5],0.05,0.8,0.05); + B[2]->findMatches(B[6],0.08,1.0,0.08); + B[2]->findBarrelMatches(L[0]); + B[2]->findBarrelMatches(L[1]); + B[2]->findBarrelMatches(L[2]); + B[2]->findBarrelMatches(L[3]); + B[2]->findBarrelMatches(L[4]); + B[2]->findBarrelMatches(L[5]); + B[2]->fitTracks(); + + allTracks.addTracks(B[2]->allTracks()); + } + + if(1){ + B[3]->findTracklets(B[4]); + B[3]->findMatches(B[0],0.05,0.5,0.05); + B[3]->findMatches(B[1],0.05,0.5,0.05); + B[3]->findMatches(B[2],0.05,0.5,0.05); + B[3]->findMatches(B[5],0.05,0.8,0.05); + B[3]->findMatches(B[6],0.05,0.8,0.05); + B[3]->findBarrelMatches(L[0]); + B[3]->findBarrelMatches(L[1]); + B[3]->findBarrelMatches(L[2]); + B[3]->findBarrelMatches(L[3]); + B[3]->findBarrelMatches(L[4]); + B[3]->findBarrelMatches(L[5]); + B[3]->fitTracks(); + + allTracks.addTracks(B[3]->allTracks()); + } + + if(1){ + B[4]->findTracklets(B[5]); + B[4]->findMatches(B[0],0.05,0.5,0.05); + B[4]->findMatches(B[1],0.05,0.5,0.05); + B[4]->findMatches(B[2],0.05,0.5,0.05); + B[4]->findMatches(B[3],0.05,0.5,0.05); + B[4]->findMatches(B[6],0.05,0.5,0.05); + B[4]->findBarrelMatches(L[0]); + B[4]->findBarrelMatches(L[1]); + B[4]->findBarrelMatches(L[2]); + B[4]->findBarrelMatches(L[3]); + B[4]->findBarrelMatches(L[4]); + B[4]->findBarrelMatches(L[5]); + B[4]->fitTracks(); + + allTracks.addTracks(B[4]->allTracks()); + } + + if(1){ + B[5]->findTracklets(B[6]); + B[5]->findMatches(B[0],0.05,0.5,0.05); + B[5]->findMatches(B[1],0.05,0.5,0.05); + B[5]->findMatches(B[2],0.05,0.5,0.05); + B[5]->findMatches(B[3],0.05,0.5,0.05); + B[5]->findMatches(B[4],0.05,0.5,0.05); + B[5]->findBarrelMatches(L[0]); + B[5]->findBarrelMatches(L[1]); + B[5]->findBarrelMatches(L[2]); + B[5]->findBarrelMatches(L[3]); + B[5]->findBarrelMatches(L[4]); + B[5]->findBarrelMatches(L[5]); + B[5]->fitTracks(); + + allTracks.addTracks(B[5]->allTracks()); + } + + } + if (mode==4) { + + if (1){ + L[0]->findTracklets(L[1]); + L[0]->findTracklets(B[0]); + L[0]->findTracklets(F[0]); + L[0]->findMatches(L[2],0.075,0.5); + L[0]->findMatches(L[3],0.12,3.0); + L[0]->findMatches(L[4],0.15,3.0); + L[0]->findMatches(L[5],0.2,3.0); + L[0]->findMatches(F[0]); + L[0]->findMatches(F[1]); + L[0]->findMatches(F[2]); + L[0]->findMatches(F[3]); + L[0]->findMatches(F[4]); + L[0]->findMatches(B[0]); + L[0]->findMatches(B[1]); + L[0]->findMatches(B[2]); + L[0]->findMatches(B[3]); + L[0]->findMatches(B[4]); + L[0]->fitTracks(); + + allTracks.addTracks(L[0]->allTracks()); + } + + if(1){ + L[1]->findTracklets(L[2]); + L[1]->findTracklets(B[0]); + L[1]->findTracklets(F[0]); + L[1]->findMatches(L[0],0.04,0.5); + L[1]->findMatches(L[3],0.075,3.0); + L[1]->findMatches(L[4],0.1,3.0); + L[1]->findMatches(L[5],0.15,3.0); + L[1]->findMatches(F[0]); + L[1]->findMatches(F[1]); + L[1]->findMatches(F[2]); + L[1]->findMatches(F[3]); + L[1]->findMatches(F[4]); + L[1]->findMatches(B[0]); + L[1]->findMatches(B[1]); + L[1]->findMatches(B[2]); + L[1]->findMatches(B[3]); + L[1]->findMatches(B[4]); + L[1]->fitTracks(); + + allTracks.addTracks(L[1]->allTracks()); + } + + if(1){ + L[2]->findTracklets(L[3]); + L[2]->findTracklets(B[0]); + L[2]->findTracklets(F[0]); + L[2]->findMatches(L[0],0.025,5.0); + L[2]->findMatches(L[1],0.025,3.0); + L[2]->findMatches(L[4],0.03,8.0); + L[2]->findMatches(L[5],0.05,10.0); + L[2]->findMatches(F[0]); + L[2]->findMatches(F[1]); + L[2]->findMatches(F[2]); + L[2]->findMatches(F[3]); + L[2]->findMatches(F[4]); + L[2]->findMatches(B[0]); + L[2]->findMatches(B[1]); + L[2]->findMatches(B[2]); + L[2]->findMatches(B[3]); + L[2]->findMatches(B[4]); + L[2]->fitTracks(); + + allTracks.addTracks(L[2]->allTracks()); + } + + if(1){ + L[3]->findTracklets(L[4]); + L[3]->findTracklets(B[0]); + L[3]->findTracklets(F[0]); + L[3]->findMatches(L[0],0.025,5.0); + L[3]->findMatches(L[1],0.025,3.0); + L[3]->findMatches(L[2],0.03,8.0); + L[3]->findMatches(L[5],0.05,10.0); + L[3]->findMatches(F[0]); + L[3]->findMatches(F[1]); + L[3]->findMatches(F[2]); + L[3]->findMatches(F[3]); + L[3]->findMatches(F[4]); + L[3]->findMatches(B[0]); + L[3]->findMatches(B[1]); + L[3]->findMatches(B[2]); + L[3]->findMatches(B[3]); + L[3]->findMatches(B[4]); + L[3]->fitTracks(); + + allTracks.addTracks(L[3]->allTracks()); + } + + if(1){ + F[0]->findTracklets(F[1]); + F[0]->findMatches(F[2],0.05,0.5,0.05); + F[0]->findMatches(F[3],0.09,0.6,0.09); + F[0]->findMatches(F[4],0.1,1.0,0.1); + F[0]->findBarrelMatches(L[0]); + F[0]->findBarrelMatches(L[1]); + F[0]->findBarrelMatches(L[2]); + F[0]->findBarrelMatches(L[3]); + F[0]->findBarrelMatches(L[4]); + F[0]->findBarrelMatches(L[5]); + F[0]->fitTracks(); + + allTracks.addTracks(F[0]->allTracks()); + } + + if(1){ + F[1]->findTracklets(F[2]); + F[1]->findMatches(F[0],0.04,0.4,0.04); + F[1]->findMatches(F[3],0.05,0.5,0.05); + F[1]->findMatches(F[4],0.075,0.5,0.075); + F[1]->findBarrelMatches(L[0]); + F[1]->findBarrelMatches(L[1]); + F[1]->findBarrelMatches(L[2]); + F[1]->findBarrelMatches(L[3]); + F[1]->findBarrelMatches(L[4]); + F[1]->findBarrelMatches(L[5]); + F[1]->fitTracks(); + + allTracks.addTracks(F[1]->allTracks()); + } + + if(1){ + F[2]->findTracklets(F[3]); + F[2]->findMatches(F[0],0.05,0.5,0.05); + F[2]->findMatches(F[1],0.04,0.5,0.04); + F[2]->findMatches(F[4],0.05,0.5,0.05); + F[2]->findBarrelMatches(L[0]); + F[2]->findBarrelMatches(L[1]); + F[2]->findBarrelMatches(L[2]); + F[2]->findBarrelMatches(L[3]); + F[2]->findBarrelMatches(L[4]); + F[2]->findBarrelMatches(L[5]); + F[2]->fitTracks(); + + allTracks.addTracks(F[2]->allTracks()); + } + + if(1){ + F[3]->findTracklets(F[4]); + F[3]->findMatches(F[0],0.05,0.5,0.05); + F[3]->findMatches(F[1],0.05,0.5,0.05); + F[3]->findMatches(F[2],0.05,0.5,0.05); + F[3]->findBarrelMatches(L[0]); + F[3]->findBarrelMatches(L[1]); + F[3]->findBarrelMatches(L[2]); + F[3]->findBarrelMatches(L[3]); + F[3]->findBarrelMatches(L[4]); + F[3]->findBarrelMatches(L[5]); + F[3]->fitTracks(); + + allTracks.addTracks(F[3]->allTracks()); + } + + if(1){ + B[0]->findTracklets(B[1]); + B[0]->findMatches(B[2],0.05,0.5,0.05); + B[0]->findMatches(B[3],0.08,0.6,0.08); + B[0]->findMatches(B[4],0.1,1.0,0.1); + B[0]->findBarrelMatches(L[0]); + B[0]->findBarrelMatches(L[1]); + B[0]->findBarrelMatches(L[2]); + B[0]->findBarrelMatches(L[3]); + B[0]->findBarrelMatches(L[4]); + B[0]->findBarrelMatches(L[5]); + B[0]->fitTracks(); + + allTracks.addTracks(B[0]->allTracks()); + } + + if(1){ + B[1]->findTracklets(B[2]); + B[1]->findMatches(B[0],0.04,0.4,0.04); + B[1]->findMatches(B[3],0.05,0.5,0.05); + B[1]->findMatches(B[4],0.075,0.5,0.075); + B[1]->findBarrelMatches(L[0]); + B[1]->findBarrelMatches(L[1]); + B[1]->findBarrelMatches(L[2]); + B[1]->findBarrelMatches(L[3]); + B[1]->findBarrelMatches(L[4]); + B[1]->findBarrelMatches(L[5]); + B[1]->fitTracks(); + + allTracks.addTracks(B[1]->allTracks()); + } + + if(1){ + B[2]->findTracklets(B[3]); + B[2]->findMatches(B[0],0.05,0.5,0.05); + B[2]->findMatches(B[1],0.04,0.5,0.04); + B[2]->findMatches(B[4],0.05,0.5,0.05); + B[2]->findBarrelMatches(L[0]); + B[2]->findBarrelMatches(L[1]); + B[2]->findBarrelMatches(L[2]); + B[2]->findBarrelMatches(L[3]); + B[2]->findBarrelMatches(L[4]); + B[2]->findBarrelMatches(L[5]); + B[2]->fitTracks(); + + allTracks.addTracks(B[2]->allTracks()); + } + + if(1){ + B[3]->findTracklets(B[4]); + B[3]->findMatches(B[0],0.05,0.5,0.05); + B[3]->findMatches(B[1],0.05,0.5,0.05); + B[3]->findMatches(B[2],0.05,0.5,0.05); + B[3]->findBarrelMatches(L[0]); + B[3]->findBarrelMatches(L[1]); + B[3]->findBarrelMatches(L[2]); + B[3]->findBarrelMatches(L[3]); + B[3]->findBarrelMatches(L[4]); + B[3]->findBarrelMatches(L[5]); + B[3]->fitTracks(); + + allTracks.addTracks(B[3]->allTracks()); + } + + } + + //cout << "Done with track finding"<0) { + out1 << "Event "<0.3) { + //cout << "Found Track"<2) nsim=2; + + //cout << "Number of sim tracks="<10000) continue; //hack + + //cout << "SimTrackID="<nTracklets(iSector);itracklet++) { + L1TTracklet tracklet=L[0]->tracklet(iSector,itracklet); + + //double frac; + //int simtrackidmatch=tracklet.simtrackid(frac); + + if (fabs(1.0/tracklet.pt(mMagneticFieldStrength)-1.0/simtrackpt) +#include +#include +#include + +// this class is needed to make a map +// between different types of stubs +class L1TStubCompare +{ +public: + bool operator()(const L1TStub& x, const L1TStub& y) { + if (x.layer() != y.layer()) return (y.layer()-x.layer())>0; + else { + if (x.ladder() != y.ladder()) return (y.ladder()-x.ladder())>0; + else { + if (x.module() != y.module()) return (y.module()-x.module())>0; + else { + if (x.iz() != y.iz()) return (y.iz()-x.iz())>0; + else return (x.iphi()-y.iphi())>0; + } + } + } + } +}; + + +class TrackFindingTrackletProducer : public edm::EDProducer +{ +public: + /// Constructor/destructor + explicit TrackFindingTrackletProducer(const edm::ParameterSet& iConfig); + virtual ~TrackFindingTrackletProducer(); + +protected: + +private: + GeometryMap geom; + int eventnum; + edm::ParameterSet config; + string geometry_; + + virtual void beginRun( edm::Run& run, const edm::EventSetup& iSetup ); + virtual void endRun( edm::Run& run, const edm::EventSetup& iSetup ); + virtual void produce( edm::Event& iEvent, const edm::EventSetup& iSetup ); +}; + + +// CONSTRUCTOR +TrackFindingTrackletProducer::TrackFindingTrackletProducer(edm::ParameterSet const& iConfig) // : config(iConfig) +{ + produces< std::vector< TTTrack< Ref_PixelDigi_ > > >( "TrackletBasedL1Tracks" ).setBranchAlias("TrackletBasedL1Tracks"); + geometry_ = iConfig.getUntrackedParameter("geometry",""); +} + +// DESTRUCTOR +TrackFindingTrackletProducer::~TrackFindingTrackletProducer() +{ + /// Insert here what you need to delete + /// when you close the class instance +} + +// END JOB +void TrackFindingTrackletProducer::endRun(edm::Run& run, const edm::EventSetup& iSetup) +{ + /// Things to be done at the exit of the event Loop +} + +// BEGIN JOB +void TrackFindingTrackletProducer::beginRun(edm::Run& run, const edm::EventSetup& iSetup ) +{ + eventnum=0; + //std::cout << "TrackFindingTrackletProducer" << std::endl; +} + +////////// +// PRODUCE +void TrackFindingTrackletProducer::produce(edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + + typedef std::map< L1TStub, edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > >, L1TStubCompare > stubMapType; + + /// Prepare output + std::auto_ptr< std::vector< TTTrack< Ref_PixelDigi_ > > > TTTracksForOutput( new std::vector< TTTrack< Ref_PixelDigi_ > > ); + + /// Geometry handles etc + edm::ESHandle geometryHandle; + const TrackerGeometry* theGeometry; + edm::ESHandle stackedGeometryHandle; + const StackedTrackerGeometry* theStackedGeometry; + StackedTrackerGeometry::StackContainerIterator StackedTrackerIterator; + + /// Geometry setup + /// Set pointers to Geometry + iSetup.get().get(geometryHandle); + theGeometry = &(*geometryHandle); + /// Set pointers to Stacked Modules + iSetup.get().get(stackedGeometryHandle); + theStackedGeometry = stackedGeometryHandle.product(); /// Note this is different + /// from the "global" geometry + + // Magnetic field + edm::ESHandle magneticFieldHandle; + iSetup.get().get(magneticFieldHandle); + const MagneticField* theMagneticField = magneticFieldHandle.product(); + double mMagneticFieldStrength = theMagneticField->inTesla(GlobalPoint(0,0,0)).z(); + + /// Beamspot + edm::Handle recoBeamSpotHandle; + iEvent.getByLabel("BeamSpotFromSim","BeamSpot",recoBeamSpotHandle); + math::XYZPoint bsPosition=recoBeamSpotHandle->position(); + + //cout << "TrackFindingTrackletProducer: B="< simTrackHandle; + edm::Handle simVtxHandle; + //iEvent.getByLabel( "famosSimHits", simTrackHandle ); + //iEvent.getByLabel( "famosSimHits", simVtxHandle ); + iEvent.getByLabel( "g4SimHits", simTrackHandle ); + iEvent.getByLabel( "g4SimHits", simVtxHandle ); + + ////////////////////// + // GET MC PARTICLES // + edm::Handle genpHandle; + iEvent.getByLabel( "genParticles", genpHandle ); +*/ + + //cout << "Get pixel digis"< > pixelDigiHandle; + edm::Handle > pixelDigiSimLinkHandle; + iEvent.getByLabel("simSiPixelDigis", pixelDigiHandle); + iEvent.getByLabel("simSiPixelDigis", pixelDigiSimLinkHandle); + + //cout << "Get stubs and clusters"< > > pixelDigiTTClusterHandle; + edm::Handle< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > > > pixelDigiTTStubHandle; +// iEvent.getByLabel("TTClustersFromPixelDigis", pixelDigiTTClusterHandle); + iEvent.getByLabel("TTStubsFromPixelDigis", "StubAccepted", pixelDigiTTStubHandle); + + //cout << "Will loop over simtracks" <begin(); + iterSimTracks != simTrackHandle->end(); + ++iterSimTracks ) { + + /// Get the corresponding vertex + int vertexIndex = iterSimTracks->vertIndex(); + const SimVertex& theSimVertex = (*simVtxHandle)[vertexIndex]; + math::XYZTLorentzVectorD trkVtxPos = theSimVertex.position(); + GlobalPoint trkVtxCorr = GlobalPoint( trkVtxPos.x() - bsPosition.x(), + trkVtxPos.y() - bsPosition.y(), + trkVtxPos.z() - bsPosition.z() ); + + double pt=iterSimTracks->momentum().pt(); + if (pt!=pt) pt=9999.999; + ev.addL1SimTrack(iterSimTracks->trackId(),iterSimTracks->type(),pt, + iterSimTracks->momentum().eta(), + iterSimTracks->momentum().phi(), + trkVtxCorr.x(), + trkVtxCorr.y(), + trkVtxCorr.z()); + + + } /// End of Loop over SimTracks +*/ + + /// TrackingParticles + edm::Handle< std::vector< TrackingParticle > > TrackingParticleHandle; + iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingParticleHandle ); + edm::Handle< std::vector< TrackingVertex > > TrackingVertexHandle; + iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingVertexHandle ); + + /// Loop over TrackingParticles + if ( TrackingParticleHandle->size() > 0 ) + { + unsigned int tpCnt = 0; + std::vector< TrackingParticle >::const_iterator iterTP; + for ( iterTP = TrackingParticleHandle->begin(); + iterTP != TrackingParticleHandle->end(); + ++iterTP ) + { + + /// Make the pointer + edm::Ptr< TrackingParticle > tempTPPtr( TrackingParticleHandle, tpCnt++ ); + + std::vector::const_iterator iterSimTracks; + + for ( iterSimTracks = iterTP->g4Tracks().begin(); + iterSimTracks != iterTP->g4Tracks().end(); + ++iterSimTracks ) + { + + /// Get the corresponding vertex + GlobalPoint trkVtxCorr = GlobalPoint( tempTPPtr->vertex().x() - bsPosition.x(), + tempTPPtr->vertex().y() - bsPosition.y(), + tempTPPtr->vertex().z() - bsPosition.z() ); + + double pt=iterSimTracks->momentum().pt(); + if (pt!=pt) pt=9999.999; + + ev.addL1SimTrack(iterSimTracks->trackId(),iterSimTracks->type(),pt, + iterSimTracks->momentum().eta(), + iterSimTracks->momentum().phi(), + trkVtxCorr.x(), + trkVtxCorr.y(), + trkVtxCorr.z()); + } + } /// End of Loop over SimTracks + } + + //std::cout << "Will loop over digis:"<::const_iterator iterDet; + for ( iterDet = pixelDigiHandle->begin(); + iterDet != pixelDigiHandle->end(); + iterDet++ ) { + + /// Build Detector Id + DetId tkId( iterDet->id ); + StackedTrackerDetId stdetid(tkId); + /// Check if it is Pixel + if ( tkId.subdetId() == 2 ) { + + PXFDetId pxfId(tkId); + edm::DetSetVector::const_iterator itDigiSimLink1=pixelDigiSimLinkHandle->find(pxfId.rawId()); + if (itDigiSimLink1!=pixelDigiSimLinkHandle->end()){ + edm::DetSet digiSimLink = *itDigiSimLink1; + //DetSet digiSimLink = (*pixelDigiSimLinkHandle)[ pxfId.rawId() ]; + edm::DetSet::const_iterator iterSimLink; + /// Renormalize layer number from 5-14 to 0-9 and skip if inner pixels + + int disk = pxfId.disk(); + + if (disk<4) { + continue; + } + + disk-=3; + + // Layer 0-20 + //DetId digiDetId = iterDet->id; + //int sensorLayer = 0.5*(2*PXFDetId(digiDetId).layer() + (PXFDetId(digiDetId).ladder() + 1)%2 - 8); + + /// Loop over PixelDigis within Module and select those above threshold + edm::DetSet::const_iterator iterDigi; + for ( iterDigi = iterDet->data.begin(); + iterDigi != iterDet->data.end(); + iterDigi++ ) { + + /// Threshold (here it is NOT redundant) + if ( iterDigi->adc() <= 30 ) continue; + + /// Try to learn something from PixelDigi position + const GeomDetUnit* gDetUnit = theGeometry->idToDetUnit( tkId ); + MeasurementPoint mp( iterDigi->row() + 0.5, iterDigi->column() + 0.5 ); + GlobalPoint pdPos = gDetUnit->surface().toGlobal( gDetUnit->topology().localPosition( mp ) ) ; + + int offset=1000; + + if (pxfId.side()==1) { + offset=2000; + } + + assert(pxfId.panel()==1); + + vector simtrackids; + /// Loop over PixelDigiSimLink to find the + /// correct link to the SimTrack collection + for ( iterSimLink = digiSimLink.data.begin(); + iterSimLink != digiSimLink.data.end(); + iterSimLink++) { + + /// When the channel is the same, the link is found + if ( (int)iterSimLink->channel() == iterDigi->channel() && + iterSimLink->eventId().event()==0 && + iterSimLink->eventId().bunchCrossing()==0 + ) { + + /// Map wrt SimTrack Id + unsigned int simTrackId = iterSimLink->SimTrackId(); + simtrackids.push_back(simTrackId); + } + } + ev.addDigi(offset+disk,iterDigi->row(),iterDigi->column(), + 9999999,pxfId.panel(),pxfId.module(), + pdPos.x(),pdPos.y(),pdPos.z(),simtrackids); + } + } + } + + if ( tkId.subdetId() == 1 ) { + /// Get the PixelDigiSimLink corresponding to this one + PXBDetId pxbId(tkId); + edm::DetSetVector::const_iterator itDigiSimLink=pixelDigiSimLinkHandle->find(pxbId.rawId()); + if (itDigiSimLink==pixelDigiSimLinkHandle->end()){ + continue; + } + edm::DetSet digiSimLink = *itDigiSimLink; + //DetSet digiSimLink = (*pixelDigiSimLinkHandle)[ pxbId.rawId() ]; + edm::DetSet::const_iterator iterSimLink; + /// Renormalize layer number from 5-14 to 0-9 and skip if inner pixels + if ( pxbId.layer() < 5 ) { + continue; + } + + // Layer 0-20 + DetId digiDetId = iterDet->id; + int sensorLayer = 0.5*(2*PXBDetId(digiDetId).layer() + (PXBDetId(digiDetId).ladder() + 1)%2 - 8); + + /// Loop over PixelDigis within Module and select those above threshold + edm::DetSet::const_iterator iterDigi; + for ( iterDigi = iterDet->data.begin(); + iterDigi != iterDet->data.end(); + iterDigi++ ) { + + /// Threshold (here it is NOT redundant) + if ( iterDigi->adc() <= 30 ) continue; + + /// Try to learn something from PixelDigi position + const GeomDetUnit* gDetUnit = theGeometry->idToDetUnit( tkId ); + MeasurementPoint mp( iterDigi->row() + 0.5, iterDigi->column() + 0.5 ); + GlobalPoint pdPos = gDetUnit->surface().toGlobal( gDetUnit->topology().localPosition( mp ) ) ; + + /// Loop over PixelDigiSimLink to find the + /// correct link to the SimTrack collection + vector simtrackids; + for ( iterSimLink = digiSimLink.data.begin(); + iterSimLink != digiSimLink.data.end(); + iterSimLink++) { + + /// When the channel is the same, the link is found + if ( (int)iterSimLink->channel() == iterDigi->channel() && + iterSimLink->eventId().event()==0 && + iterSimLink->eventId().bunchCrossing()==0 + ) { + + /// Map wrt SimTrack Id + unsigned int simTrackId = iterSimLink->SimTrackId(); + simtrackids.push_back(simTrackId); + } + } + ev.addDigi(sensorLayer,iterDigi->row(),iterDigi->column(), + pxbId.layer(),pxbId.ladder(),pxbId.module(), + pdPos.x(),pdPos.y(),pdPos.z(),simtrackids); + } + } + } + + //cout << "Will loop over stubs" << endl; + + stubMapType stubMap; + int iter=0; + + int stubcounter=0; + + /// Loop over L1TkStubs + edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >::const_iterator iterDSV; + edmNew::DetSet< TTStub< Ref_PixelDigi_ > >::const_iterator iterTTStub; + for ( iterDSV = pixelDigiTTStubHandle->begin(); + iterDSV != pixelDigiTTStubHandle->end(); + ++iterDSV ) + { + DetId thisStackedDetId = iterDSV->id(); + + edmNew::DetSet< TTStub< Ref_PixelDigi_ > > theStubs = (*pixelDigiTTStubHandle)[ thisStackedDetId ]; + + for ( iterTTStub = theStubs.begin(); + iterTTStub != theStubs.end(); + ++iterTTStub ) + { + stubcounter++; + + double stubPt = theStackedGeometry->findRoughPt(mMagneticFieldStrength,&(*iterTTStub)); + + if (stubPt>10000.0) stubPt=9999.99; + GlobalPoint stubPosition = theStackedGeometry->findGlobalPosition(&(*iterTTStub)); + + StackedTrackerDetId stubDetId = iterTTStub->getDetId(); + unsigned int iStack = stubDetId.iLayer(); + unsigned int iRing = stubDetId.iRing(); + unsigned int iPhi = stubDetId.iPhi(); + unsigned int iZ = stubDetId.iZ(); + + std::vector innerStack; + std::vector irphi; + std::vector iz; + std::vector iladder; + std::vector imodule; + + if (iStack==999999) { + iStack=1000+iRing; + } + + /// Get the Inner and Outer TTCluster + edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > innerCluster = iterTTStub->getClusterRef(0); + + const DetId innerDetId = theStackedGeometry->idToDet( innerCluster->getDetId(), 0 )->geographicalId(); + + for (unsigned int ihit=0;ihitgetHits().size();ihit++){ + + std::pair rowcol= + std::make_pair( innerCluster->getRows().at( ihit), innerCluster->getCols().at(ihit) ); + + if (iStack<1000) { + innerStack.push_back(true); + irphi.push_back(rowcol.first); + iz.push_back(rowcol.second); + iladder.push_back(PXBDetId(innerDetId).ladder()); + imodule.push_back(PXBDetId(innerDetId).module()); + } + else { + innerStack.push_back(true); + irphi.push_back(rowcol.first); + iz.push_back(rowcol.second); + iladder.push_back(PXFDetId(innerDetId).disk()); + imodule.push_back(PXFDetId(innerDetId).module()); + } + } + + edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > outerCluster = iterTTStub->getClusterRef(1); + + const DetId outerDetId = theStackedGeometry->idToDet( outerCluster->getDetId(), 1 )->geographicalId(); + + for (unsigned int ihit=0;ihitgetHits().size();ihit++){ + + std::pair rowcol= + std::make_pair( outerCluster->getRows().at( ihit), outerCluster->getCols().at(ihit) ); + + if (iStack<1000) { + innerStack.push_back(false); + irphi.push_back(rowcol.first); + iz.push_back(rowcol.second); + iladder.push_back(PXBDetId(outerDetId).ladder()); + imodule.push_back(PXBDetId(outerDetId).module()); + } + else { + innerStack.push_back(false); + irphi.push_back(rowcol.first); + iz.push_back(rowcol.second); + iladder.push_back(PXFDetId(outerDetId).disk()); + imodule.push_back(PXFDetId(outerDetId).module()); + } + } + + if (ev.addStub(iStack-1,iPhi,iZ,stubPt, + stubPosition.x(),stubPosition.y(),stubPosition.z(), + innerStack,irphi,iz,iladder,imodule)) { + Stub *aStub = new Stub; + *aStub = ev.stub(iter); + iter++; + + //int theSimtrackId=ev.simtrackid(*aStub); + int theSimtrackId=-1; + + L1TStub L1Stub(theSimtrackId, aStub->iphi(), aStub->iz(), + aStub->layer()+1, aStub->ladder()+1, aStub->module(), + aStub->x(), aStub->y(), aStub->z(),0.0,0.0,aStub->pt()); + delete aStub; + + stubMap.insert( make_pair(L1Stub, edmNew::makeRefTo( pixelDigiTTStubHandle, iterTTStub ) ) ); + } + } + } + + cout << "TrackFindingTrackletProducer: "< >, TTStub< Ref_PixelDigi_ > > > TkStubs; + std::vector< L1TStub > stubs = track.getStubs(); + + stubMapType::iterator it; + //cout << "stubmap size="<first == stubs[j]) { + //cout << "Found stub match"<second); + } + } + } + + TTTrack< Ref_PixelDigi_ > TkTrack(TkStubs); + //double frac; + //TkTrack.setSimTrackId(track.simtrackid(frac)); + GlobalPoint bsPosition(0.0,0.0,track.z0()); //store the L1 track vertex position + TkTrack.setPOCA(bsPosition); + TkTrack.setChi2(track.chisq()); + TkTrack.setFitParNo(4); + //short int charge=1; + //if (track.pt(mMagneticFieldStrength)<0.0) charge=-1; + //TkTrack.setCharge(charge); + TkTrack.setRInv(track.rinv()); + + // set simtrack ID (??) **this doesn't work, re-introduced get/set simtrack ID methods** + //if (iEvent.isRealData() == false) TkTrack.checkSimTrack(); + + TkTrack.setMomentum( GlobalVector ( GlobalVector::Cylindrical( fabs(track.pt(mMagneticFieldStrength)), + track.phi0(), + fabs(track.pt(mMagneticFieldStrength))*sinh(track.eta())) ) ); + + TTTracksForOutput->push_back(TkTrack); + } + + iEvent.put( TTTracksForOutput, "TrackletBasedL1Tracks"); + +} /// End of produce() + +// /////////////////////////// +// // DEFINE THIS AS A PLUG-IN +DEFINE_FWK_MODULE(TrackFindingTrackletProducer); + +#endif + diff --git a/L1Trigger/TrackFindingTracklet/python/L1TTrack_cfi.py b/L1Trigger/TrackFindingTracklet/python/L1TTrack_cfi.py new file mode 100644 index 0000000000000..efad744d76cfa --- /dev/null +++ b/L1Trigger/TrackFindingTracklet/python/L1TTrack_cfi.py @@ -0,0 +1,9 @@ +import FWCore.ParameterSet.Config as cms + +TTTracksFromPixelDigisTracklet = cms.EDProducer("TrackFindingTrackletProducer", + geometry = cms.untracked.string('BE5D'), +) + +#process.BeamSpotFromSim = cms.EDProducer("BeamSpotFromSimProducer") +#process.TrackFindingTracklet_step = cms.Path(process.BeamSpotFromSim*process.TTTracksFromPixelDigisTracklet) + diff --git a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h b/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h deleted file mode 100644 index ae2309eaf735e..0000000000000 --- a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h +++ /dev/null @@ -1,138 +0,0 @@ -/*! \class TTTrackAlgorithm - * \brief Base class for any algorithm to be used - * in TTTrackBuilder - * \details After moving from SimDataFormats to DataFormats, - * the template structure of the class was maintained - * in order to accomodate any types other than PixelDigis - * in case there is such a need in the future. - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#ifndef L1_TRACK_TRIGGER_TRACK_ALGO_BASE_H -#define L1_TRACK_TRIGGER_TRACK_ALGO_BASE_H - -#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" -#include "DataFormats/L1TrackTrigger/interface/TTTrack.h" -#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" -#include "FWCore/MessageLogger/interface/MessageLogger.h" -#include "Geometry/CommonDetUnit/interface/GeomDetUnit.h" -#include "Geometry/CommonTopologies/interface/Topology.h" -#include "Geometry/CommonTopologies/interface/PixelTopology.h" -#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" -#include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h" -#include "MagneticField/Engine/interface/MagneticField.h" - -#include -#include -#include -#include "classNameFinder.h" - -template< typename T > -class TTTrackAlgorithm -{ - protected: - /// Data members - const StackedTrackerGeometry *theStackedTracker; - std::string className_; - - public: - /// Constructors - TTTrackAlgorithm( const StackedTrackerGeometry *aStackedGeom, std::string fName ) - : theStackedTracker( aStackedGeom ) - { - className_ = classNameFinder< T >(fName); - } - - /// Destructor - virtual ~TTTrackAlgorithm(){} - - /// Seed creation - virtual void CreateSeeds( std::vector< TTTrack< T > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< T > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< T > > > &input ) const - { - output.clear(); - } - - /// Match a Stub to a Seed/Track - virtual void AttachStubToSeed( TTTrack< T > &seed, - edm::Ptr< TTStub< T > > &candidate ) const - { - seed.addStubPtr( candidate ); - } - - /// AM Pattern Finding - virtual void PatternFinding() const - {} - - /// AM Pattern Recognition - virtual void PatternRecognition() const - {} - - virtual unsigned int ReturnNumberOfSectors() const { return 1; } - virtual unsigned int ReturnNumberOfWedges() const { return 1; } - virtual double ReturnMagneticField() const { return 1.0; } - - /// Fit the Track - virtual void FitTrack( TTTrack< T > &seed ) const; - - /// Algorithm name - virtual std::string AlgorithmName() const { return className_; } - - /// Helper methods - double DeltaPhi( double phi1, double phi2 ) const; - double CosineTheorem( double a, double b, double phi ) const; - double FindRInvOver2( double rho1, double rho2, double phi1, double phi2 ) const; - -}; /// Close class - -/*! \brief Implementation of methods - * \details Here, in the header file, the methods which do not depend - * on the specific type that can fit the template. - * Other methods, with type-specific features, are implemented - * in the source file. - */ - -/// Fit the track -template< > -void TTTrackAlgorithm< Ref_PixelDigi_ >::FitTrack( TTTrack< Ref_PixelDigi_ > &seed ) const; - -/// Helper methods -template< typename T > -double TTTrackAlgorithm< T >::DeltaPhi( double phi1, double phi2 ) const -{ - double deltaPhi = phi1 - phi2; - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - return deltaPhi; -} - -template< typename T > -double TTTrackAlgorithm< T >::CosineTheorem( double a, double b, double phi ) const -{ - return sqrt( a*a + b*b - 2*a*b*cos(phi) ); -} - -template< typename T > -double TTTrackAlgorithm< T >::FindRInvOver2( double rho1, double rho2, double phi1, double phi2 ) const -{ - /// Calculate angle between the vectors - double deltaPhi = this->DeltaPhi( phi1, phi2 ); - - /// Apply cosine theorem to find the distance between the vectors - double distance = this->CosineTheorem( rho1, rho2, deltaPhi ); - - /// Apply sine theorem to find 1/(2R) - return sin(deltaPhi)/distance; /// Sign is maintained to keep track of the charge -} - -#endif - diff --git a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h b/L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h deleted file mode 100644 index a4d8ce323b853..0000000000000 --- a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h +++ /dev/null @@ -1,24 +0,0 @@ -/*! \class TTTrackAlgorithmRecord - * \brief Class to store the TTTrackAlgorithm used - * in TTTrackBuilder - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#ifndef L1_TRACK_TRIGGER_TRACK_ALGO_RECORD_H -#define L1_TRACK_TRIGGER_TRACK_ALGO_RECORD_H - -#include "FWCore/Framework/interface/EventSetupRecordImplementation.h" -#include "FWCore/Framework/interface/DependentRecordImplementation.h" -#include "Geometry/Records/interface/StackedTrackerGeometryRecord.h" -#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" - -#include "boost/mpl/vector.hpp" - -class TTTrackAlgorithmRecord - : public edm::eventsetup::DependentRecordImplementation< TTTrackAlgorithmRecord, boost::mpl::vector< StackedTrackerGeometryRecord, IdealMagneticFieldRecord> > {}; - -#endif - diff --git a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_AMBE.h b/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_AMBE.h deleted file mode 100644 index a29130fd91e73..0000000000000 --- a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_AMBE.h +++ /dev/null @@ -1,164 +0,0 @@ -/*! \class TTTrackAlgorithm_AMBE - * \brief Skeleton for AM-based track finder simulation. - * \details After moving from SimDataFormats to DataFormats, - * the template structure of the class was maintained - * in order to accomodate any types other than PixelDigis - * in case there is such a need in the future. - * - * \author Nicola Pozzobon - * \author Sebastien Viret - * \date 2013, Jul 18 - * - */ - -#ifndef L1_TRACK_TRIGGER_TRACK_ALGO_ASSOBE_H -#define L1_TRACK_TRIGGER_TRACK_ALGO_ASSOBE_H - -#include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/Framework/interface/ModuleFactory.h" -#include "FWCore/Framework/interface/ESProducer.h" - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h" -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h" - -#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" -#include "Geometry/CommonTopologies/interface/Topology.h" -#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" -#include "Geometry/CommonTopologies/interface/PixelTopology.h" - -#include -#include -#include -#include - -template< typename T > -class TTTrackAlgorithm_AMBE : public TTTrackAlgorithm< T > -{ - private : - /// Data members - double mMagneticField; - unsigned int nSectors; - unsigned int nWedges; - - public: - /// Constructors - TTTrackAlgorithm_AMBE( const StackedTrackerGeometry *aStackedGeom, - double aMagneticField, - unsigned int aSectors, - unsigned int aWedges ) - : TTTrackAlgorithm< T > ( aStackedGeom, __func__ ) - { - mMagneticField = aMagneticField; - nSectors = aSectors; - nWedges = aWedges; - } - - /// Destructor - ~TTTrackAlgorithm_AMBE(){} - - /// Pattern Finding - void PatternFinding() const; - - /// Pattern Recognition - void PatternRecognition() const; - - /// Return the number of Sectors - unsigned int ReturnNumberOfSectors() const { return nSectors; } /// Phi - unsigned int ReturnNumberOfWedges() const { return nWedges; } /// Eta - - /// Return the value of the magnetic field - double ReturnMagneticField() const { return mMagneticField; } - - /// Fit the Track - void FitTrack( TTTrack< T > &track ) const; - -}; /// Close class - -/*! \brief Implementation of methods - * \details Here, in the header file, the methods which do not depend - * on the specific type that can fit the template. - * Other methods, with type-specific features, are implemented - * in the source file. - */ - -template< typename T > -void TTTrackAlgorithm_AMBE< T >::PatternFinding() const -{ - std::cerr << "Pattern Finding" << std::endl; -} - -template< typename T > -void TTTrackAlgorithm_AMBE< T >::PatternRecognition() const -{ - std::cerr << "Pattern Recognition" << std::endl; -} - -/// Fit the track -template< typename T > -void TTTrackAlgorithm_AMBE< T >::FitTrack( TTTrack< T > &track ) const -{ - std::cerr << "HOUGH!!!" << std::endl; -} - - - - - -/*! \class ES_TTTrackAlgorithm_AMBE - * \brief Class to declare the algorithm to the framework - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -template< typename T > -class ES_TTTrackAlgorithm_AMBE : public edm::ESProducer -{ - private: - /// Data members - boost::shared_ptr< TTTrackAlgorithm< T > > _theAlgo; - - /// Number of Sectors - unsigned int mSectors; - unsigned int mWedges; - - public: - /// Constructor - ES_TTTrackAlgorithm_AMBE( const edm::ParameterSet & p ) - : mSectors( p.getParameter< int >("NumSectors") ), - mWedges( p.getParameter< int >("NumWedges") ) - { - setWhatProduced( this ); - } - - /// Destructor - virtual ~ES_TTTrackAlgorithm_AMBE() {} - - /// Implement the producer - boost::shared_ptr< TTTrackAlgorithm< T > > produce( const TTTrackAlgorithmRecord & record ) - { - /// Get magnetic field - edm::ESHandle< MagneticField > magnet; - record.getRecord< IdealMagneticFieldRecord >().get(magnet); - double mMagneticFieldStrength = magnet->inTesla( GlobalPoint(0,0,0) ).z(); - double mMagneticFieldRounded = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0; - - edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle; - record.getRecord< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle ); - - TTTrackAlgorithm< T >* TTTrackAlgo = - new TTTrackAlgorithm_AMBE< T >( &(*StackedTrackerGeomHandle), - mMagneticFieldRounded, - mSectors, - mWedges ); - - _theAlgo = boost::shared_ptr< TTTrackAlgorithm< T > >( TTTrackAlgo ); - return _theAlgo; - } - -}; - -#endif - diff --git a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletBE.h b/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletBE.h deleted file mode 100644 index 146b3240abed6..0000000000000 --- a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletBE.h +++ /dev/null @@ -1,276 +0,0 @@ -/*! \class TTTrackAlgorithm_trackletBE - * \brief Tracklet-based algorithm for the BE layout. - * \details After moving from SimDataFormats to DataFormats, - * the template structure of the class was maintained - * in order to accomodate any types other than PixelDigis - * in case there is such a need in the future. - * - * \author Anders Ryd - * \author Emmanuele Salvati - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#ifndef L1_TRACK_TRIGGER_TRACK_ALGO_TRACKLETBE_H -#define L1_TRACK_TRIGGER_TRACK_ALGO_TRACKLETBE_H - -#include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/Framework/interface/ModuleFactory.h" -#include "FWCore/Framework/interface/ESProducer.h" - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h" -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h" - -#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" -#include "Geometry/CommonTopologies/interface/Topology.h" -#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" -#include "Geometry/CommonTopologies/interface/PixelTopology.h" - -#include -#include -#include -#include - -template< typename T > -class TTTrackAlgorithm_trackletBE : public TTTrackAlgorithm< T > -{ - private : - /// Data members - double mMagneticField; - unsigned int nSectors; - unsigned int nWedges; - - std::vector< std::vector< double > > tableRPhiBB; - std::vector< std::vector< double > > tableZBB; - std::vector< std::vector< double > > tableRPhiBE; - std::vector< std::vector< double > > tableZBE; - std::vector< std::vector< double > > tableRPhiEB; - std::vector< std::vector< double > > tableZEB; - std::vector< std::vector< double > > tableRPhiEE; - std::vector< std::vector< double > > tableZEE; - - std::vector< std::vector< double > > tableRPhiBE_PS; - std::vector< std::vector< double > > tableZBE_PS; - std::vector< std::vector< double > > tableRPhiEB_PS; - std::vector< std::vector< double > > tableZEB_PS; - std::vector< std::vector< double > > tableRPhiEE_PS; - std::vector< std::vector< double > > tableZEE_PS; - - public: - /// Constructors - TTTrackAlgorithm_trackletBE( const StackedTrackerGeometry *aStackedGeom, - double aMagneticField, - unsigned int aSectors, - unsigned int aWedges, - std::vector< std::vector< double > > aTableRPhiBB, - std::vector< std::vector< double > > aTableZBB, - std::vector< std::vector< double > > aTableRPhiBE, - std::vector< std::vector< double > > aTableZBE, - std::vector< std::vector< double > > aTableRPhiBE_PS, - std::vector< std::vector< double > > aTableZBE_PS, - std::vector< std::vector< double > > aTableRPhiEB, - std::vector< std::vector< double > > aTableZEB, - std::vector< std::vector< double > > aTableRPhiEB_PS, - std::vector< std::vector< double > > aTableZEB_PS, - std::vector< std::vector< double > > aTableRPhiEE, - std::vector< std::vector< double > > aTableZEE, - std::vector< std::vector< double > > aTableRPhiEE_PS, - std::vector< std::vector< double > > aTableZEE_PS ) - : TTTrackAlgorithm< T > ( aStackedGeom, __func__ ) - { - mMagneticField = aMagneticField; - nSectors = aSectors; - nWedges = aWedges; - - tableRPhiBB = aTableRPhiBB; - tableZBB = aTableZBB; - tableRPhiBE = aTableRPhiBE; - tableZBE = aTableZBE; - tableRPhiEB = aTableRPhiEB; - tableZEB = aTableZEB; - tableRPhiEE = aTableRPhiEE; - tableZEE = aTableZEE; - - tableRPhiBE_PS = aTableRPhiBE_PS; - tableZBE_PS = aTableZBE_PS; - tableRPhiEB_PS = aTableRPhiEB_PS; - tableZEB_PS = aTableZEB_PS; - tableRPhiEE_PS = aTableRPhiEE_PS; - tableZEE_PS = aTableZEE_PS; - } - - /// Destructor - ~TTTrackAlgorithm_trackletBE(){} - - /// Seed creation - void CreateSeeds( std::vector< TTTrack< T > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< T > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< T > > > &input ) const; - - /// Match a Stub to a Seed/Track - void AttachStubToSeed( TTTrack< T > &seed, - edm::Ptr< TTStub< T > > &candidate ) const; - - /// Return the number of Sectors - unsigned int ReturnNumberOfSectors() const { return nSectors; } /// Phi - unsigned int ReturnNumberOfWedges() const { return nWedges; } /// Eta - - /// Return the value of the magnetic field - double ReturnMagneticField() const { return mMagneticField; } - - /// Fit the Track - /// Take it from the parent class - -}; /// Close class - -/*! \brief Implementation of methods - * \details Here, in the header file, the methods which do not depend - * on the specific type that can fit the template. - * Other methods, with type-specific features, are implemented - * in the source file. - */ - -/// Create Seeds -template< > -void TTTrackAlgorithm_trackletBE< Ref_PixelDigi_ >::CreateSeeds( std::vector< TTTrack< Ref_PixelDigi_ > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > &input ) const; - -/// Match a Stub to a Seed/Track -template< > -void TTTrackAlgorithm_trackletBE< Ref_PixelDigi_ >::AttachStubToSeed( TTTrack< Ref_PixelDigi_ > &seed, - edm::Ptr< TTStub< Ref_PixelDigi_ > > &candidate ) const; - - - - - -/*! \class ES_TTTrackAlgorithm_trackletBE - * \brief Class to declare the algorithm to the framework - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -template< typename T > -class ES_TTTrackAlgorithm_trackletBE : public edm::ESProducer -{ - private: - /// Data members - boost::shared_ptr< TTTrackAlgorithm< T > > _theAlgo; - - /// Number of Sectors - unsigned int mSectors; - unsigned int mWedges; - - /// Projection windows - std::vector< std::vector< double > > setRhoPhiWinBB; - std::vector< std::vector< double > > setZWinBB; - std::vector< std::vector< double > > setRhoPhiWinBE; - std::vector< std::vector< double > > setZWinBE; - std::vector< std::vector< double > > setRhoPhiWinEB; - std::vector< std::vector< double > > setZWinEB; - std::vector< std::vector< double > > setRhoPhiWinEE; - std::vector< std::vector< double > > setZWinEE; - - /// PS Modules variants - /// NOTE these are not needed for the Barrel-Barrel case - std::vector< std::vector< double > > setRhoPhiWinBE_PS; - std::vector< std::vector< double > > setZWinBE_PS; - std::vector< std::vector< double > > setRhoPhiWinEB_PS; - std::vector< std::vector< double > > setZWinEB_PS; - std::vector< std::vector< double > > setRhoPhiWinEE_PS; - std::vector< std::vector< double > > setZWinEE_PS; - - public: - /// Constructor - ES_TTTrackAlgorithm_trackletBE( const edm::ParameterSet & p ) - : mSectors( p.getParameter< int >("NumSectors") ), - mWedges( p.getParameter< int >("NumWedges") ) - { - std::vector< edm::ParameterSet > vPSet; - std::vector< edm::ParameterSet >::const_iterator iPSet; - - vPSet = p.getParameter< std::vector< edm::ParameterSet > >("ProjectionWindowsBarrelBarrel"); - for ( iPSet = vPSet.begin(); iPSet != vPSet.end(); iPSet++ ) - { - setRhoPhiWinBB.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWin") ); - setZWinBB.push_back( iPSet->getParameter< std::vector< double > >("ZWin") ); - } - - vPSet = p.getParameter< std::vector< edm::ParameterSet > >("ProjectionWindowsBarrelEndcap"); - for ( iPSet = vPSet.begin(); iPSet != vPSet.end(); iPSet++ ) - { - setRhoPhiWinBE.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWin") ); - setZWinBE.push_back( iPSet->getParameter< std::vector< double > >("ZWin") ); - setRhoPhiWinBE_PS.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWinPS") ); - setZWinBE_PS.push_back( iPSet->getParameter< std::vector< double > >("ZWinPS") ); - } - - vPSet = p.getParameter< std::vector< edm::ParameterSet > >("ProjectionWindowsEndcapBarrel"); - for ( iPSet = vPSet.begin(); iPSet != vPSet.end(); iPSet++ ) - { - setRhoPhiWinEB.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWin") ); - setZWinEB.push_back( iPSet->getParameter< std::vector< double > >("ZWin") ); - setRhoPhiWinEB_PS.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWinPS") ); - setZWinEB_PS.push_back( iPSet->getParameter< std::vector< double > >("ZWinPS") ); - } - - vPSet = p.getParameter< std::vector< edm::ParameterSet > >("ProjectionWindowsEndcapEndcap"); - for ( iPSet = vPSet.begin(); iPSet != vPSet.end(); iPSet++ ) - { - setRhoPhiWinEE.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWin") ); - setZWinEE.push_back( iPSet->getParameter< std::vector< double > >("ZWin") ); - setRhoPhiWinEE_PS.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWinPS") ); - setZWinEE_PS.push_back( iPSet->getParameter< std::vector< double > >("ZWinPS") ); - } - - setWhatProduced( this ); - } - - /// Destructor - virtual ~ES_TTTrackAlgorithm_trackletBE() {} - - /// Implement the producer - boost::shared_ptr< TTTrackAlgorithm< T > > produce( const TTTrackAlgorithmRecord & record ) - { - /// Get magnetic field - edm::ESHandle< MagneticField > magnet; - record.getRecord< IdealMagneticFieldRecord >().get(magnet); - double mMagneticFieldStrength = magnet->inTesla( GlobalPoint(0,0,0) ).z(); - double mMagneticFieldRounded = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0; - - edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle; - record.getRecord< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle ); - - TTTrackAlgorithm< T >* TTTrackAlgo = - new TTTrackAlgorithm_trackletBE< T >( &(*StackedTrackerGeomHandle), - mMagneticFieldRounded, - mSectors, - mWedges, - setRhoPhiWinBB, - setZWinBB, - setRhoPhiWinBE, - setZWinBE, - setRhoPhiWinBE_PS, - setZWinBE_PS, - setRhoPhiWinEB, - setZWinEB, - setRhoPhiWinEB_PS, - setZWinEB_PS, - setRhoPhiWinEE, - setZWinEE, - setRhoPhiWinEE_PS, - setZWinEE_PS ); - - _theAlgo = boost::shared_ptr< TTTrackAlgorithm< T > >( TTTrackAlgo ); - return _theAlgo; - } - -}; - -#endif - diff --git a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletLB.h b/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletLB.h deleted file mode 100644 index e6838b31d83e5..0000000000000 --- a/L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletLB.h +++ /dev/null @@ -1,181 +0,0 @@ -/*! \class TTTrackAlgorithm_trackletLB - * \brief Tracklet-based algorithm for the LB layout. - * \details After moving from SimDataFormats to DataFormats, - * the template structure of the class was maintained - * in order to accomodate any types other than PixelDigis - * in case there is such a need in the future. - * - * \author Anders Ryd - * \author Emmanuele Salvati - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#ifndef L1_TRACK_TRIGGER_TRACK_ALGO_EXACTLB_H -#define L1_TRACK_TRIGGER_TRACK_ALGO_EXACTLB_H - -#include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/Framework/interface/ModuleFactory.h" -#include "FWCore/Framework/interface/ESProducer.h" - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h" -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h" - -#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" -#include "Geometry/CommonTopologies/interface/Topology.h" -#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" -#include "Geometry/CommonTopologies/interface/PixelTopology.h" - -#include -#include -#include -#include - -template< typename T > -class TTTrackAlgorithm_trackletLB : public TTTrackAlgorithm< T > -{ - private : - /// Data members - double mMagneticField; - unsigned int nSectors; - unsigned int nWedges; - - std::vector< std::vector< double > > tableRPhi; - std::vector< std::vector< double > > tableZ; - - public: - /// Constructors - TTTrackAlgorithm_trackletLB( const StackedTrackerGeometry *aStackedGeom, - double aMagneticField, - unsigned int aSectors, - unsigned int aWedges, - std::vector< std::vector< double > > aTableRPhi, - std::vector< std::vector< double > > aTableZ ) - : TTTrackAlgorithm< T > ( aStackedGeom, __func__ ) - { - mMagneticField = aMagneticField; - nSectors = aSectors; - nWedges = aWedges; - - tableRPhi = aTableRPhi; - tableZ = aTableZ; - } - - /// Destructor - ~TTTrackAlgorithm_trackletLB(){} - - /// Seed creation - void CreateSeeds( std::vector< TTTrack< T > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< T > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< T > > > &input ) const; - - /// Match a Stub to a Seed/Track - void AttachStubToSeed( TTTrack< T > &seed, - edm::Ptr< TTStub< T > > &candidate ) const; - - /// Return the number of Sectors - unsigned int ReturnNumberOfSectors() const { return nSectors; } /// Phi - unsigned int ReturnNumberOfWedges() const { return nWedges; } /// Eta - - /// Return the value of the magnetic field - double ReturnMagneticField() const { return mMagneticField; } - - /// Fit the Track - /// Take it from the parent class - -}; /// Close class - -/*! \brief Implementation of methods - * \details Here, in the header file, the methods which do not depend - * on the specific type that can fit the template. - * Other methods, with type-specific features, are implemented - * in the source file. - */ - -/// Create Seeds -template< > -void TTTrackAlgorithm_trackletLB< Ref_PixelDigi_ >::CreateSeeds( std::vector< TTTrack< Ref_PixelDigi_ > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > &input ) const; - -/// Match a Stub to a Seed/Track -template< > -void TTTrackAlgorithm_trackletLB< Ref_PixelDigi_ >::AttachStubToSeed( TTTrack< Ref_PixelDigi_ > &seed, edm::Ptr< TTStub< Ref_PixelDigi_ > > &candidate ) const; - - - - - - -/*! \class ES_TTTrackAlgorithm_trackletLB - * \brief Class to declare the algorithm to the framework - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -template< typename T > -class ES_TTTrackAlgorithm_trackletLB : public edm::ESProducer -{ - private: - /// Data members - boost::shared_ptr< TTTrackAlgorithm< T > > _theAlgo; - - /// Number of Sectors - unsigned int mSectors; - unsigned int mWedges; - - /// projection windows - std::vector< std::vector< double > > setRhoPhiWin; - std::vector< std::vector< double > > setZWin; - - public: - /// Constructor - ES_TTTrackAlgorithm_trackletLB( const edm::ParameterSet & p ) - : mSectors( p.getParameter< int >("NumSectors") ), mWedges( p.getParameter< int >("NumWedges") ) - { - std::vector< edm::ParameterSet > vPSet = p.getParameter< std::vector< edm::ParameterSet > >("ProjectionWindows"); - std::vector< edm::ParameterSet >::const_iterator iPSet; - for ( iPSet = vPSet.begin(); iPSet != vPSet.end(); iPSet++ ) - { - setRhoPhiWin.push_back( iPSet->getParameter< std::vector< double > >("RhoPhiWin") ); - setZWin.push_back( iPSet->getParameter< std::vector< double > >("ZWin") ); - } - - setWhatProduced( this ); - } - - /// Destructor - virtual ~ES_TTTrackAlgorithm_trackletLB() {} - - /// Implement the producer - boost::shared_ptr< TTTrackAlgorithm< T > > produce( const TTTrackAlgorithmRecord & record ) - { - /// Get magnetic field - edm::ESHandle< MagneticField > magnet; - record.getRecord< IdealMagneticFieldRecord >().get(magnet); - double mMagneticFieldStrength = magnet->inTesla(GlobalPoint(0,0,0)).z(); - double mMagneticFieldRounded = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0; - - edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle; - record.getRecord< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle ); - - TTTrackAlgorithm< T >* TTTrackAlgo = - new TTTrackAlgorithm_trackletLB< T >( &(*StackedTrackerGeomHandle), - mMagneticFieldRounded, - mSectors, - mWedges, - setRhoPhiWin, - setZWin ); - - _theAlgo = boost::shared_ptr< TTTrackAlgorithm< T > >( TTTrackAlgo ); - return _theAlgo; - } - -}; - -#endif - diff --git a/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.cc b/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.cc index fee7ffc7be17d..78700d7cdc24a 100644 --- a/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.cc +++ b/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.cc @@ -14,7 +14,7 @@ template< > void TTClusterBuilder< Ref_PixelDigi_ >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup ) { /// Prepare output - std::auto_ptr< std::vector< TTCluster< Ref_PixelDigi_ > > > TTClustersForOutput( new std::vector< TTCluster< Ref_PixelDigi_ > > ); + std::auto_ptr< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > > TTClusterDSVForOutput( new edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > ); std::map< DetId, std::vector< Ref_PixelDigi_ > > rawHits; /// This is a map containing hits: /// a vector of type Ref_PixelDigi_ is mapped wrt @@ -64,21 +64,31 @@ void TTClusterBuilder< Ref_PixelDigi_ >::produce( edm::Event& iEvent, const edm: if ( outerHitFind != rawHits.end() ) theClusterFindingAlgoHandle->Cluster( outerHits, outerHitFind->second, false ); /// Create TTCluster objects and store them - for ( unsigned int i = 0; i < innerHits.size(); i++ ) + /// Use the FastFiller with edmNew::DetSetVector { - TTCluster< Ref_PixelDigi_ > temp( innerHits.at(i), Id, 0 ); - TTClustersForOutput->push_back( temp ); + edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >::FastFiller innerOutputFiller( *TTClusterDSVForOutput, Unit->stackMember(0) ); + for ( unsigned int i = 0; i < innerHits.size(); i++ ) + { + TTCluster< Ref_PixelDigi_ > temp( innerHits.at(i), Id, 0, storeLocalCoord ); + innerOutputFiller.push_back( temp ); + } + if ( innerOutputFiller.empty() ) + innerOutputFiller.abort(); } - for ( unsigned int i = 0; i < outerHits.size(); i++ ) { - TTCluster< Ref_PixelDigi_ > temp( outerHits.at(i), Id, 1 ); - TTClustersForOutput->push_back( temp ); + edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >::FastFiller outerOutputFiller( *TTClusterDSVForOutput, Unit->stackMember(1) ); + for ( unsigned int i = 0; i < outerHits.size(); i++ ) + { + TTCluster< Ref_PixelDigi_ > temp( outerHits.at(i), Id, 1, storeLocalCoord ); + outerOutputFiller.push_back( temp ); + } + if ( outerOutputFiller.empty() ) + outerOutputFiller.abort(); } - } /// End of loop over detector elements /// Put output in the event - iEvent.put( TTClustersForOutput ); + iEvent.put( TTClusterDSVForOutput, "ClusterInclusive" ); } /// Retrieve hits from the event @@ -121,7 +131,7 @@ void TTClusterBuilder< Ref_PixelDigi_ >::RetrieveRawHits( std::map< DetId, std:: { /// If the Digi is over threshold, /// accept it as a raw hit and put into map - mRawHits[id].push_back( makeRefTo( HitHandle, id , hitsIter ) ); + mRawHits[id].push_back( edm::makeRefTo( HitHandle, id , hitsIter ) ); } /// End of threshold selection } /// End of loop over digis } /// End of "is Pixel" diff --git a/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.h b/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.h index b4f720047605c..00b0e41f14f96 100644 --- a/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.h +++ b/L1Trigger/TrackTrigger/plugins/TTClusterBuilder.h @@ -29,6 +29,8 @@ #include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" #include "Geometry/CommonTopologies/interface/PixelTopology.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" + #include #include #include @@ -51,6 +53,7 @@ class TTClusterBuilder : public edm::EDProducer edm::ESHandle< TTClusterAlgorithm< T > > theClusterFindingAlgoHandle; // Handles are needed in ::produce() std::vector< edm::InputTag > rawHitInputTags; unsigned int ADCThreshold; + bool storeLocalCoord; /// Mandatory methods virtual void beginRun( const edm::Run& run, const edm::EventSetup& iSetup ); @@ -76,7 +79,8 @@ TTClusterBuilder< T >::TTClusterBuilder( const edm::ParameterSet& iConfig ) { rawHitInputTags = iConfig.getParameter< std::vector< edm::InputTag > >("rawHits"); ADCThreshold = iConfig.getParameter< unsigned int >("ADCThreshold"); - produces< std::vector< TTCluster< T > > >(); + storeLocalCoord = iConfig.getParameter< bool >("storeLocalCoord"); + produces< edmNew::DetSetVector< TTCluster< T > > >( "ClusterInclusive" ); } /// Destructor diff --git a/L1Trigger/TrackTrigger/plugins/TTStubBuilder.h b/L1Trigger/TrackTrigger/plugins/TTStubBuilder.h index 4f6afb858b0e9..dff2aff2efa11 100644 --- a/L1Trigger/TrackTrigger/plugins/TTStubBuilder.h +++ b/L1Trigger/TrackTrigger/plugins/TTStubBuilder.h @@ -29,7 +29,8 @@ #include "L1Trigger/TrackTrigger/interface/TTStubAlgorithm.h" #include "L1Trigger/TrackTrigger/interface/TTStubAlgorithmRecord.h" -//#include "classNameFinder.h" + +#include "DataFormats/Common/interface/DetSetVectorNew.h" #include #include @@ -39,9 +40,6 @@ template< typename T > class TTStubBuilder : public edm::EDProducer { public: - typedef std::pair< StackedTrackerDetId, unsigned int > ClusterKey; /// This is the key - typedef std::map< ClusterKey, std::vector< edm::Ptr< TTCluster< T > > > > TTClusterMap; /// This is the map - /// Constructor explicit TTStubBuilder( const edm::ParameterSet& iConfig ); @@ -63,7 +61,6 @@ class TTStubBuilder : public edm::EDProducer /// NOTE: this must be static! static bool SortStubBendPairs( const std::pair< unsigned int, double >& left, const std::pair< unsigned int, double >& right ); - }; /// Close class /*! \brief Implementation of methods @@ -77,9 +74,10 @@ class TTStubBuilder : public edm::EDProducer template< typename T > TTStubBuilder< T >::TTStubBuilder( const edm::ParameterSet& iConfig ) { - produces< std::vector< TTStub< T > > >( "StubsPass" ); - produces< std::vector< TTStub< T > > >( "StubsFail" ); TTClustersInputTag = iConfig.getParameter< edm::InputTag >( "TTClusters" ); + produces< edmNew::DetSetVector< TTCluster< T > > >( "ClusterAccepted" ); + produces< edmNew::DetSetVector< TTStub< T > > >( "StubAccepted" ); + produces< edmNew::DetSetVector< TTStub< T > > >( "StubRejected" ); } /// Destructor @@ -95,7 +93,7 @@ void TTStubBuilder< T >::beginRun( const edm::Run& run, const edm::EventSetup& i iSetup.get< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle ); theStackedTracker = StackedTrackerGeomHandle.product(); - /// Get the clustering algorithm + /// Get the stub finding algorithm iSetup.get< TTStubAlgorithmRecord >().get( theStubFindingAlgoHandle ); /// Print some information when loaded @@ -115,51 +113,19 @@ template< typename T > void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup ) { /// Prepare output - std::auto_ptr< std::vector< TTStub< T > > > TTStubsForOutputAccepted( new std::vector< TTStub< T > > ); - std::auto_ptr< std::vector< TTStub< T > > > TTStubsForOutputRejected( new std::vector< TTStub< T > > ); + std::auto_ptr< edmNew::DetSetVector< TTCluster< T > > > TTClusterDSVForOutput( new edmNew::DetSetVector< TTCluster< T > > ); + std::auto_ptr< edmNew::DetSetVector< TTStub< T > > > TTStubDSVForOutputTemp( new edmNew::DetSetVector< TTStub< T > > ); + std::auto_ptr< edmNew::DetSetVector< TTStub< T > > > TTStubDSVForOutputAccepted( new edmNew::DetSetVector< TTStub< T > > ); + std::auto_ptr< edmNew::DetSetVector< TTStub< T > > > TTStubDSVForOutputRejected( new edmNew::DetSetVector< TTStub< T > > ); /// Get the Clusters already stored away - edm::Handle< std::vector< TTCluster< T > > > TTClusterHandle; - iEvent.getByLabel( TTClustersInputTag, TTClusterHandle); + edm::Handle< edmNew::DetSetVector< TTCluster< T > > > TTClusterHandle; + iEvent.getByLabel( TTClustersInputTag, TTClusterHandle ); /// Get the maximum number of stubs per ROC /// (CBC3-style) unsigned maxStubs = theStackedTracker->getCBC3MaxStubs(); - /// Map the Clusters according to detector elements - TTClusterMap clusterMap; - clusterMap.clear(); - - unsigned int j = 0; /// Counter needed to build the edm::Ptr to the TTCluster - typename std::vector< TTCluster< T > >::const_iterator inputIter; - for ( inputIter = TTClusterHandle->begin(); - inputIter != TTClusterHandle->end(); - ++inputIter ) - { - /// Make the pointer to be put in the map and, later on, in the Stub - /// as reference to lower-class bricks composing the Stub itself - edm::Ptr< TTCluster< T > > tempCluPtr( TTClusterHandle, j++ ); - - /// Build the key to the map - ClusterKey mapkey = std::make_pair( StackedTrackerDetId( inputIter->getDetId() ), inputIter->getStackMember() ); - - /// If an entry already exists for this key, just add the cluster - /// to the vector, otherwise create the entry - if ( clusterMap.find( mapkey ) == clusterMap.end() ) - { - /// New entry - std::vector< edm::Ptr< TTCluster< T > > > tempCluVec; - tempCluVec.clear(); - tempCluVec.push_back( tempCluPtr ); - clusterMap.insert( std::pair< ClusterKey, std::vector< edm::Ptr< TTCluster< T > > > > ( mapkey, tempCluVec ) ); - } - else - { - /// Already existing entry - clusterMap[mapkey].push_back( tempCluPtr ); - } - } - /// Loop over the detector elements StackedTrackerGeometry::StackContainerIterator StackedTrackerIterator; for ( StackedTrackerIterator = theStackedTracker->stacks().begin(); @@ -170,28 +136,52 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe StackedTrackerDetId Id = Unit->Id(); assert(Unit == theStackedTracker->idToStack(Id)); - /// Build the keys to get the Clusters - ClusterKey inmapkey = std::make_pair(Id, 0); - ClusterKey outmapkey = std::make_pair(Id, 1); + /// Get the DetIds of each sensor + DetId id0 = Unit->stackMember(0); + DetId id1 = Unit->stackMember(1); + + /// Check that everything is ok in the maps + if ( theStackedTracker->findPairedDetector( id0 ) != id1 || + theStackedTracker->findPairedDetector( id1 ) != id0 ) + { + std::cerr << "A L E R T! error in detector association within Pt module (detector-to-detector)" << std::endl; + continue; + } - /// Get the vectors of Clusters for the current Pt module - /// Go on only if the entry in the map is found - typename TTClusterMap::const_iterator innerIter = clusterMap.find( inmapkey ); - typename TTClusterMap::const_iterator outerIter = clusterMap.find( outmapkey ); + if ( theStackedTracker->findStackFromDetector( id0 ) != Id || + theStackedTracker->findStackFromDetector( id1 ) != Id ) + { + std::cerr << "A L E R T! error in detector association within Pt module (detector-to-module)" << std::endl; + continue; + } - if ( innerIter == clusterMap.end() || outerIter == clusterMap.end() ) + /// Go on only if both detectors have Clusters + if ( TTClusterHandle->find( id0 ) == TTClusterHandle->end() || + TTClusterHandle->find( id1 ) == TTClusterHandle->end() ) continue; - std::vector< edm::Ptr< TTCluster< T > > > innerClusters = innerIter->second; - std::vector< edm::Ptr< TTCluster< T > > > outerClusters = outerIter->second; + /// Get the DetSets of the Clusters + edmNew::DetSet< TTCluster< T > > innerClusters = (*TTClusterHandle)[ id0 ]; + edmNew::DetSet< TTCluster< T > > outerClusters = (*TTClusterHandle)[ id1 ]; - typename std::vector< edm::Ptr< TTCluster< T > > >::iterator innerClusterIter, outerClusterIter; + typename edmNew::DetSet< TTCluster< T > >::iterator innerClusterIter, outerClusterIter; /// If there are Clusters in both sensors /// you can try and make a Stub + /// This is ~redundant if ( innerClusters.size() == 0 || outerClusters.size() == 0 ) continue; + /// Create the vectors of objects to be passed to the FastFillers + std::vector< TTCluster< T > > *tempInner = new std::vector< TTCluster< T > >(); + std::vector< TTCluster< T > > *tempOuter = new std::vector< TTCluster< T > >(); + std::vector< TTStub< T > > *tempOutput = new std::vector< TTStub< T > >(); + std::vector< TTStub< T > > *tempRejected = new std::vector< TTStub< T > >(); + tempInner->clear(); + tempOuter->clear(); + tempOutput->clear(); + tempRejected->clear(); + /// Get chip size information const GeomDetUnit* det0 = theStackedTracker->idToDetUnit( Id, 0 ); const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 ); @@ -210,8 +200,8 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe { /// Build a temporary Stub TTStub< T > tempTTStub( Id ); - tempTTStub.addClusterPtr( *innerClusterIter ); /// innerClusterIter is an iterator pointing to the edm::Ptr - tempTTStub.addClusterPtr( *outerClusterIter ); + tempTTStub.addClusterRef( edmNew::makeRefTo( TTClusterHandle, innerClusterIter ) ); + tempTTStub.addClusterRef( edmNew::makeRefTo( TTClusterHandle, outerClusterIter ) ); /// Check for compatibility bool thisConfirmation = false; @@ -230,7 +220,9 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe if ( maxStubs == 0 ) { /// This means that ALL stubs go into the output - TTStubsForOutputAccepted->push_back( tempTTStub ); + tempInner->push_back( *innerClusterIter ); + tempOuter->push_back( *outerClusterIter ); + tempOutput->push_back( tempTTStub ); } else { @@ -240,7 +232,7 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe if ( moduleStubs.find( chip ) == moduleStubs.end() ) /// Already a stub for this ASIC? { /// No, so new entry - std::vector< TTStub > tempStubs; + std::vector< TTStub< T > > tempStubs; tempStubs.clear(); tempStubs.push_back( tempTTStub ); moduleStubs.insert( std::pair< int, std::vector< TTStub< T > > >( chip, tempStubs ) ); @@ -253,7 +245,7 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe } } /// Stub accepted else - TTStubsForOutputRejected->push_back( tempTTStub ); + tempRejected->push_back( tempTTStub ); } /// End of nested loop } /// End of loop over pairs of Clusters @@ -272,7 +264,9 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe { for ( auto const & ts: is.second ) { - TTStubsForOutputAccepted->push_back( ts ); + tempInner->push_back( *(ts.getClusterRef(0)) ); + tempOuter->push_back( *(ts.getClusterRef(1)) ); + tempOutput->push_back( ts ); } } else @@ -288,21 +282,174 @@ void TTStubBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSe for ( unsigned int i = 0; i < maxStubs; ++i ) { /// Put the highest momenta (lowest bend) stubs into the event - TTStubsForOutputAccepted->push_back(is.second[bendMap[i].first]); + tempInner->push_back( *(is.second[bendMap[i].first].getClusterRef(0)) ); + tempOuter->push_back( *(is.second[bendMap[i].first].getClusterRef(1)) ); + tempOutput->push_back( is.second[bendMap[i].first] ); } for ( unsigned int i = maxStubs; i < is.second.size(); ++i ) { /// Reject the rest - TTStubsForOutputRejected->push_back( is.second[bendMap[i].first] ); + tempRejected->push_back( is.second[bendMap[i].first] ); } } } /// End of loop over temp output + /// Create the FastFillers + if ( tempInner->size() > 0 ) + { + typename edmNew::DetSetVector< TTCluster< T > >::FastFiller innerOutputFiller( *TTClusterDSVForOutput, id0 ); + for ( unsigned int m = 0; m < tempInner->size(); m++ ) + { + innerOutputFiller.push_back( tempInner->at(m) ); + } + if ( innerOutputFiller.empty() ) + innerOutputFiller.abort(); + } + + if ( tempOuter->size() > 0 ) + { + typename edmNew::DetSetVector< TTCluster< T > >::FastFiller outerOutputFiller( *TTClusterDSVForOutput, id1 ); + for ( unsigned int m = 0; m < tempOuter->size(); m++ ) + { + outerOutputFiller.push_back( tempOuter->at(m) ); + } + if ( outerOutputFiller.empty() ) + outerOutputFiller.abort(); + } + + if ( tempOutput->size() > 0 ) + { + typename edmNew::DetSetVector< TTStub< T > >::FastFiller tempOutputFiller( *TTStubDSVForOutputTemp, DetId(Id.rawId()) ); + for ( unsigned int m = 0; m < tempOutput->size(); m++ ) + { + tempOutputFiller.push_back( tempOutput->at(m) ); + } + if ( tempOutputFiller.empty() ) + tempOutputFiller.abort(); + } + + if ( tempRejected->size() > 0 ) + { + typename edmNew::DetSetVector< TTStub< T > >::FastFiller rejectedOutputFiller( *TTStubDSVForOutputRejected, DetId(Id.rawId()) ); + for ( unsigned int m = 0; m < tempRejected->size(); m++ ) + { + rejectedOutputFiller.push_back( tempRejected->at(m) ); + } + if ( rejectedOutputFiller.empty() ) + rejectedOutputFiller.abort(); + } + } /// End of loop over detector elements - /// Put output in the event - iEvent.put( TTStubsForOutputAccepted, "StubsPass" ); - iEvent.put( TTStubsForOutputRejected, "StubsFail" ); + /// Put output in the event (1) + /// Get also the OrphanHandle of the accepted clusters + edm::OrphanHandle< edmNew::DetSetVector< TTCluster< T > > > TTClusterAcceptedHandle = iEvent.put( TTClusterDSVForOutput, "ClusterAccepted" ); + + /// Now, correctly reset the output + typename edmNew::DetSetVector< TTStub< T > >::const_iterator stubIter; + + for ( stubIter = TTStubDSVForOutputTemp->begin(); + stubIter != TTStubDSVForOutputTemp->end(); + ++stubIter ) + { + /// Get the DetId and prepare the FastFiller + DetId thisStackedDetId = stubIter->id(); + typename edmNew::DetSetVector< TTStub< T > >::FastFiller acceptedOutputFiller( *TTStubDSVForOutputAccepted, thisStackedDetId ); + + /// Get its DetUnit + const StackedTrackerDetUnit* thisUnit = theStackedTracker->idToStack( thisStackedDetId ); + DetId id0 = thisUnit->stackMember(0); + DetId id1 = thisUnit->stackMember(1); + + /// Check that everything is ok in the maps + /// Redundant up to (*) + if ( theStackedTracker->findPairedDetector( id0 ) != id1 || + theStackedTracker->findPairedDetector( id1 ) != id0 ) + { + std::cerr << "A L E R T! error in detector association within Pt module (detector-to-detector)" << std::endl; + continue; + } + + if ( theStackedTracker->findStackFromDetector( id0 ) != thisStackedDetId || + theStackedTracker->findStackFromDetector( id1 ) != thisStackedDetId ) + { + std::cerr << "A L E R T! error in detector association within Pt module (detector-to-module)" << std::endl; + continue; + } + + /// Go on only if both detectors have clusters + if ( TTClusterAcceptedHandle->find( id0 ) == TTClusterAcceptedHandle->end() || + TTClusterAcceptedHandle->find( id1 ) == TTClusterAcceptedHandle->end() ) + continue; + + /// (*) + + /// Get the DetSets of the clusters + edmNew::DetSet< TTCluster< T > > innerClusters = (*TTClusterAcceptedHandle)[ id0 ]; + edmNew::DetSet< TTCluster< T > > outerClusters = (*TTClusterAcceptedHandle)[ id1 ]; + + /// Get the DetSet of the stubs + edmNew::DetSet< TTStub< T > > theseStubs = (*TTStubDSVForOutputTemp)[ thisStackedDetId ]; + + /// Prepare the new DetSet to replace the current one + /// Loop over the stubs + typename edmNew::DetSet< TTCluster< T > >::iterator clusterIter; + typename edmNew::DetSet< TTStub< T > >::iterator stubIter; + for ( stubIter = theseStubs.begin(); + stubIter != theseStubs.end(); + ++stubIter ) + { + /// Create a temporary stub + TTStub< T > tempTTStub( stubIter->getDetId() ); + + /// Compare the clusters stored in the stub with the ones of this module + edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > innerClusterToBeReplaced = stubIter->getClusterRef(0); + edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > outerClusterToBeReplaced = stubIter->getClusterRef(1); + + bool innerOK = false; + bool outerOK = false; + + for ( clusterIter = innerClusters.begin(); + clusterIter != innerClusters.end() && !innerOK; + ++clusterIter ) + { + if ( clusterIter->getHits() == innerClusterToBeReplaced->getHits() ) + { + tempTTStub.addClusterRef( edmNew::makeRefTo( TTClusterAcceptedHandle, clusterIter ) ); + innerOK = true; + } + } + + for ( clusterIter = outerClusters.begin(); + clusterIter != outerClusters.end() && !outerOK; + ++clusterIter ) + { + if ( clusterIter->getHits() == outerClusterToBeReplaced->getHits() ) + { + tempTTStub.addClusterRef( edmNew::makeRefTo( TTClusterAcceptedHandle, clusterIter ) ); + outerOK = true; + } + } + + /// If no compatible clusters were found, skip to the next one + if ( !innerOK || !outerOK ) + continue; + + tempTTStub.setTriggerDisplacement( stubIter->getTriggerDisplacement() ); + tempTTStub.setTriggerOffset( stubIter->getTriggerOffset() ); + + acceptedOutputFiller.push_back( tempTTStub ); + + } /// End of loop over stubs of this module + + if ( acceptedOutputFiller.empty() ) + acceptedOutputFiller.abort(); + + } /// End of loop over stub DetSetVector + + /// Put output in the event (2) + iEvent.put( TTStubDSVForOutputAccepted, "StubAccepted" ); + iEvent.put( TTStubDSVForOutputRejected, "StubRejected" ); } /// Sort routine for stub ordering @@ -312,6 +459,5 @@ bool TTStubBuilder< T >::SortStubBendPairs( const std::pair< unsigned int, doubl return left.second < right.second; } - #endif diff --git a/L1Trigger/TrackTrigger/plugins/TTTrackBuilder.h b/L1Trigger/TrackTrigger/plugins/TTTrackBuilder.h deleted file mode 100644 index 91f9c43fba5b0..0000000000000 --- a/L1Trigger/TrackTrigger/plugins/TTTrackBuilder.h +++ /dev/null @@ -1,335 +0,0 @@ -/*! \class TTTrackBuilder - * \brief Plugin to load the Track finding algorithm and produce the - * collection of Tracks that goes in the event content. - * \details After moving from SimDataFormats to DataFormats, - * the template structure of the class was maintained - * in order to accomodate any types other than PixelDigis - * in case there is such a need in the future. - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#ifndef L1TK_TRACK_BUILDER_H -#define L1TK_TRACK_BUILDER_H - -#include "FWCore/Framework/interface/Frameworkfwd.h" -#include "FWCore/Framework/interface/EDProducer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/EventSetup.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/ParameterSet/interface/ParameterSet.h" - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h" -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h" -//#include "classNameFinder.h" - -#include -#include -#include - -template< typename T > -class TTTrackBuilder : public edm::EDProducer -{ - public: - /// Constructor - explicit TTTrackBuilder( const edm::ParameterSet& iConfig ); - - /// Destructor; - ~TTTrackBuilder(); - - private: - /// Tracking algorithm - const StackedTrackerGeometry *theStackedTracker; - edm::ESHandle< TTTrackAlgorithm< T > > theTrackFindingAlgoHandle; - edm::InputTag TTStubsInputTag; - - /// Other stuff - bool enterAssociativeMemoriesWorkflow; - - /// Mandatory methods - virtual void beginRun( const edm::Run& run, const edm::EventSetup& iSetup ); - virtual void endRun( const edm::Run& run, const edm::EventSetup& iSetup ); - virtual void produce( edm::Event& iEvent, const edm::EventSetup& iSetup ); - -}; /// Close class - -/*! \brief Implementation of methods - * \details Here, in the header file, the methods which do not depend - * on the specific type that can fit the template. - * Other methods, with type-specific features, are implemented - * in the source file. - */ - -/// Constructors -template< typename T > -TTTrackBuilder< T >::TTTrackBuilder( const edm::ParameterSet& iConfig ) -{ - produces< std::vector< TTTrack< T > > >( "Seeds" ); - produces< std::vector< TTTrack< T > > >( "NoDup" ); - TTStubsInputTag = iConfig.getParameter< edm::InputTag >( "TTStubsBricks" ); - enterAssociativeMemoriesWorkflow = iConfig.getParameter< bool >( "AssociativeMemories" ); -} - -/// Destructor -template< typename T > -TTTrackBuilder< T >::~TTTrackBuilder() {} - -/// Begin run -template< typename T > -void TTTrackBuilder< T >::beginRun( const edm::Run& run, const edm::EventSetup& iSetup ) -{ - /// Get the geometry references - edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle; - iSetup.get< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle ); - theStackedTracker = StackedTrackerGeomHandle.product(); - - /// Get the tracking algorithm - iSetup.get< TTTrackAlgorithmRecord >().get( theTrackFindingAlgoHandle ); - /// Print some information when loaded - std::cout << std::endl; - std::cout << "TTTrackBuilder< " << templateNameFinder< T >() << " > loaded modules:" - << "\n\tTTTrackAlgorithm:\t" << theTrackFindingAlgoHandle->AlgorithmName() - << std::endl; - std::cout << std::endl; -} - -/// End run -template< typename T > -void TTTrackBuilder< T >::endRun( const edm::Run& run, const edm::EventSetup& iSetup ) {} - -/// Implement the producer -template< typename T > -void TTTrackBuilder< T >::produce( edm::Event& iEvent, const edm::EventSetup& iSetup ) -{ - /// Prepare output - /// The temporary collection is used to store tracks - /// before removal of duplicates - std::vector< TTTrack< T > > tempTrackCollection; - tempTrackCollection.clear(); - std::auto_ptr< std::vector< TTTrack< T > > > TTTracksSeedsForOutput( new std::vector< TTTrack< T > > ); - std::auto_ptr< std::vector< TTTrack< T > > > TTTracksForOutput( new std::vector< TTTrack< T > > ); - std::auto_ptr< std::vector< TTTrack< T > > > TTTracksForOutputPurged( new std::vector< TTTrack< T > > ); - - /// Get the Stubs already stored away - edm::Handle< std::vector< TTStub< T > > > TTStubHandle; - iEvent.getByLabel( TTStubsInputTag, TTStubHandle ); - - if ( enterAssociativeMemoriesWorkflow ) - { - /// Enter AM - std::cerr << "TEST: AM workflow" << std::endl; - theTrackFindingAlgoHandle->PatternFinding(); - theTrackFindingAlgoHandle->PatternRecognition(); - - } /// End AM workflow - else - { - /// Tracklet-based approach - - /// Create the Seeds and map the Stubs per Sector/Wedge - std::vector< TTTrack< T > > theseSeeds; - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< T > > > > *stubSectorWedgeMap; - stubSectorWedgeMap = new std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< T > > > >(); - theTrackFindingAlgoHandle->CreateSeeds( theseSeeds, stubSectorWedgeMap, TTStubHandle ); - - /// Get the number of sectors - unsigned int nSectors = theTrackFindingAlgoHandle->ReturnNumberOfSectors(); - unsigned int nWedges = theTrackFindingAlgoHandle->ReturnNumberOfWedges(); - - /// Here all the seeds are available and all the stubs are stored - /// in a sector-wise map: loop over seeds, find the sector, attach stubs - /// Store the seeds menawhile ... - for ( unsigned int it = 0; it < theseSeeds.size(); it++ ) - { - /// Get the seed and immediately store the seed as it is being modified later! - TTTrack< T > curSeed = theseSeeds.at(it); - TTTracksSeedsForOutput->push_back( curSeed ); - - /// Find the sector and the stubs to be attached - unsigned int curSector0 = curSeed.getSector() + nSectors; /// This is to use the %nSectors later - unsigned int curWedge0 = curSeed.getWedge(); - - /// Loop over the sector and its two neighbors - for ( unsigned int iSector = 0; iSector < 2; iSector++ ) - { - for ( unsigned int iWedge = 0; iWedge < 2; iWedge++) - { - /// Find the correct sector index - unsigned int curSector = ( curSector0 + iSector -1 )%nSectors; - int curWedge = curWedge0 + iWedge - 1; - if ( curWedge < 0 || curWedge >= (int)nWedges ) - continue; - - std::pair< unsigned int, unsigned int > sectorWedge = std::make_pair( curSector, (unsigned int)curWedge ); - - /// Skip sector if empty - if ( stubSectorWedgeMap->find( sectorWedge ) == stubSectorWedgeMap->end() ) - continue; - - std::vector< edm::Ptr< TTStub< T > > > stubsToAttach = stubSectorWedgeMap->find( sectorWedge )->second; - - /// Loop over the stubs in the Sector - for ( unsigned int iv = 0; iv < stubsToAttach.size(); iv++ ) - { - /// Here we have same-sector-different-SL seed and stubs - theTrackFindingAlgoHandle->AttachStubToSeed( curSeed, stubsToAttach.at(iv) ); - } /// End of nested loop over stubs in the Sector - } - } /// End of loop over the sector and its two neighbors - - /// Here the seed is completed with all its matched stubs - /// The seed is now a track and it is time to fit it - theTrackFindingAlgoHandle->FitTrack( curSeed ); - - /// Refit tracks if needed - if ( curSeed.getLargestResIdx() > -1 ) - { - if ( curSeed.getStubPtrs().size() > 3 && curSeed.getChi2() > 100.0 ) - { - std::vector< edm::Ptr< TTStub< T > > > theseStubs = curSeed.getStubPtrs(); - theseStubs.erase( theseStubs.begin()+curSeed.getLargestResIdx() ); - curSeed.setStubPtrs( theseStubs ); - curSeed.setLargestResIdx( -1 ); - theTrackFindingAlgoHandle->FitTrack( curSeed ); - } - } - - /// Store the fitted track in the output - TTTracksForOutput->push_back( curSeed ); - - } /// End of loop over seeds - - } /// End of non-AM - - /// Remove duplicates - std::vector< bool > toBeDeleted; - for ( unsigned int i = 0; i < TTTracksForOutput->size(); i++ ) - { - toBeDeleted.push_back( false ); - } - - for ( unsigned int i = 0; i < TTTracksForOutput->size(); i++ ) - { - /// This check is necessary as the bool may be reset in a previous iteration - if ( toBeDeleted.at(i) ) - continue; - - /// Check if the track has min 3 stubs - if ( TTTracksForOutput->at(i).getStubPtrs().size() < 3 ) - continue; - - /// Count the number of PS stubs - unsigned int nPSi = 0; - for ( unsigned int is = 0; is < TTTracksForOutput->at(i).getStubPtrs().size(); is++ ) - { - StackedTrackerDetId stDetId( TTTracksForOutput->at(i).getStubPtrs().at(is)->getDetId() ); - bool isPS = theStackedTracker->isPSModule( stDetId ); - if ( isPS ) - nPSi++; - } - - bool hasBL1i = TTTracksForOutput->at(i).hasStubInBarrel(1); - - /// Nested loop to compare tracks with each other - for ( unsigned int j = i+1 ; j < TTTracksForOutput->size(); j++ ) - { - /// This check is necessary as the bool may be reset in a previous iteration - if ( toBeDeleted.at(j) ) - continue; - - /// Check if they are the same track - if ( TTTracksForOutput->at(i).isTheSameAs( TTTracksForOutput->at(j) ) ) - { - /// Check if the track has min 3 stubs - if ( TTTracksForOutput->at(j).getStubPtrs().size() < 3 ) - continue; - - /// Count the number of PS stubs - unsigned int nPSj = 0; - for ( unsigned int js = 0; js < TTTracksForOutput->at(j).getStubPtrs().size(); js++ ) - { - StackedTrackerDetId stDetId( TTTracksForOutput->at(j).getStubPtrs().at(js)->getDetId() ); - bool isPS = theStackedTracker->isPSModule( stDetId ); - if ( isPS ) - nPSj++; - } - - /// Choose the one with the largest number of PS stubs - if ( nPSi > nPSj ) - { - toBeDeleted[j] = true; - continue; - } - else if ( nPSi < nPSj ) - { - toBeDeleted[i] = true; - continue; - } - /// Here we are if the two tracks have the same number of PS stubs - - /// Check which one has a stub in Barrel L1 - bool hasBL1j = TTTracksForOutput->at(j).hasStubInBarrel(1); - - if ( hasBL1i || hasBL1j ) - { - if ( !hasBL1i ) - { - toBeDeleted[i] = true; - continue; - } - if ( !hasBL1j ) - { - toBeDeleted[j] = true; - continue; - } - } - /// We get here only if both have BL1 or both have not - - /// Choose the one with the largest number of PS stubs - if ( nPSi > nPSj ) - { - toBeDeleted[j] = true; - continue; - } - else if ( nPSi < nPSj ) - { - toBeDeleted[i] = true; - continue; - } - /// Here we are if the two tracks have the same number of PS stubs - - /// Compare Chi2 - if ( TTTracksForOutput->at(i).getChi2Red() > TTTracksForOutput->at(j).getChi2Red() ) - { - toBeDeleted[i] = true; - } - else - { - toBeDeleted[j] = true; - } - continue; - } - } - - if ( toBeDeleted.at(i) ) continue; /// Is it really necessary? - } - - /// Store only the non-deleted tracks - for ( unsigned int i = 0; i < TTTracksForOutput->size(); i++ ) - { - if ( toBeDeleted.at(i) ) - continue; - - TTTracksForOutputPurged->push_back( TTTracksForOutput->at(i) ); - } - - /// Put in the event content - iEvent.put( TTTracksSeedsForOutput, "Seeds" ); - iEvent.put( TTTracksForOutputPurged, "NoDup" ); -} - -#endif - diff --git a/L1Trigger/TrackTrigger/plugins/module.cc b/L1Trigger/TrackTrigger/plugins/module.cc index 71eaf9a41cec8..2db5e9960c910 100644 --- a/L1Trigger/TrackTrigger/plugins/module.cc +++ b/L1Trigger/TrackTrigger/plugins/module.cc @@ -15,26 +15,6 @@ DEFINE_FWK_MODULE( TTClusterBuilder_PixelDigi_ ); typedef TTStubBuilder< Ref_PixelDigi_ > TTStubBuilder_PixelDigi_; DEFINE_FWK_MODULE( TTStubBuilder_PixelDigi_ ); -#include "L1Trigger/TrackTrigger/plugins/TTTrackBuilder.h" -typedef TTTrackBuilder< Ref_PixelDigi_ > TTTrackBuilder_PixelDigi_; -DEFINE_FWK_MODULE( TTTrackBuilder_PixelDigi_ ); - - -/// The Track Finding Algorithms - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletLB.h" -typedef ES_TTTrackAlgorithm_trackletLB< Ref_PixelDigi_ > TTTrackAlgorithm_trackletLB_PixelDigi_; -DEFINE_FWK_EVENTSETUP_MODULE( TTTrackAlgorithm_trackletLB_PixelDigi_ ); - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletBE.h" -typedef ES_TTTrackAlgorithm_trackletBE< Ref_PixelDigi_ > TTTrackAlgorithm_trackletBE_PixelDigi_; -DEFINE_FWK_EVENTSETUP_MODULE( TTTrackAlgorithm_trackletBE_PixelDigi_ ); - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_AMBE.h" -typedef ES_TTTrackAlgorithm_AMBE TTTrackAlgorithm_AMBE_PixelDigi_; -DEFINE_FWK_EVENTSETUP_MODULE( TTTrackAlgorithm_AMBE_PixelDigi_ ); - - /// The Stub Finding Algorithms #include "L1Trigger/TrackTrigger/interface/TTStubAlgorithm_a.h" diff --git a/L1Trigger/TrackTrigger/python/TTCluster_cfi.py b/L1Trigger/TrackTrigger/python/TTCluster_cfi.py index 8e0e212468f86..2bfec528bb757 100644 --- a/L1Trigger/TrackTrigger/python/TTCluster_cfi.py +++ b/L1Trigger/TrackTrigger/python/TTCluster_cfi.py @@ -4,5 +4,7 @@ rawHits = cms.VInputTag(cms.InputTag("simSiPixelDigis")), simTrackHits = cms.InputTag("g4SimHits"), ADCThreshold = cms.uint32(30), + storeLocalCoord = cms.bool(True), # if True, local coordinates (row and col) + # of each hit are stored in the cluster object ) diff --git a/L1Trigger/TrackTrigger/python/TTStub_cfi.py b/L1Trigger/TrackTrigger/python/TTStub_cfi.py index f5c85c6286798..a2999a6438a4b 100644 --- a/L1Trigger/TrackTrigger/python/TTStub_cfi.py +++ b/L1Trigger/TrackTrigger/python/TTStub_cfi.py @@ -1,7 +1,7 @@ import FWCore.ParameterSet.Config as cms TTStubsFromPixelDigis = cms.EDProducer("TTStubBuilder_PixelDigi_", - TTClusters = cms.InputTag("TTClustersFromPixelDigis"), + TTClusters = cms.InputTag("TTClustersFromPixelDigis", "ClusterInclusive"), ) diff --git a/L1Trigger/TrackTrigger/python/TTTrackAlgorithmRegister_cfi.py b/L1Trigger/TrackTrigger/python/TTTrackAlgorithmRegister_cfi.py deleted file mode 100644 index 1ce86c7506b8a..0000000000000 --- a/L1Trigger/TrackTrigger/python/TTTrackAlgorithmRegister_cfi.py +++ /dev/null @@ -1,117 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -# First register all the clustering algorithms, then specify preferred ones at end. - -TTTrackAlgorithm_trackletLB_PixelDigi_ = cms.ESProducer("TTTrackAlgorithm_trackletLB_PixelDigi_", - NumSectors = cms.int32(28), - NumWedges = cms.int32(10), - ProjectionWindows = cms.VPSet( - cms.PSet( RhoPhiWin = cms.vdouble( 0 ), - ZWin = cms.vdouble( 0 ), ), #Use 0 as dummy to have direct access to the SL without re-starting from 0 - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.00, 0.09, 0.38 ), # from SL 1 to SL ... - ZWin = cms.vdouble( 0, 0.00, 1.05, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.06, 0.00, 0.19 ), # from SL 2 to SL ... - ZWin = cms.vdouble( 0, 1.02, 0.00, 2.10 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.07, 0.07, 0.00 ), # from SL 3 to SL ... - ZWin = cms.vdouble( 0, 2.76, 1.99, 0.00 ), ), - ) -) - - -TTTrackAlgorithm_trackletBE_PixelDigi_ = cms.ESProducer("TTTrackAlgorithm_trackletBE_PixelDigi_", - NumSectors = cms.int32(6),#24), - NumWedges = cms.int32(3),#6), - - ProjectionWindowsBarrelBarrel = cms.VPSet( - cms.PSet( RhoPhiWin = cms.vdouble( 0 ), - ZWin = cms.vdouble( 0 ), ), #Use 0 as dummy to have direct access to the SL without re-starting from 0 - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.00, 0.00, 0.08, 0.12, 0.15, 0.20 ), # from L 1,2 to L ... - ZWin = cms.vdouble( 0, 0.00, 0.00, 0.50, 3.00, 3.00, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.04, 0.00, 0.00, 0.08, 0.10, 0.15 ), - ZWin = cms.vdouble( 0, 0.50, 0.00, 0.00, 3.00, 3.00, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.03, 0.03, 0.00, 0.00, 0.03, 0.05 ), - ZWin = cms.vdouble( 0, 5.00, 3.00, 0.00, 0.00, 8.00, 10.0 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.03, 0.03, 0.03, 0.00, 0.00, 0.05 ), - ZWin = cms.vdouble( 0, 5.00, 3.00, 8.00, 0.00, 0.00, 10.0 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 ), # from L 5,6 to L ... - ZWin = cms.vdouble( 0, 0.00, 0.00, 0.00, 0.00, 0.00, 0.00 ), ), - ), - ProjectionWindowsBarrelEndcap = cms.VPSet( - cms.PSet( RhoPhiWin = cms.vdouble( 0 ), - ZWin = cms.vdouble( 0 ), - RhoPhiWinPS = cms.vdouble( 0 ), - ZWinPS = cms.vdouble( 0 ), ), #Use 0 as dummy to have direct access to the SL without re-starting from 0 - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), # from L 1,2 to D ... - ZWin = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWinPS = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWin = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWinPS = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWin = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWinPS = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWin = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.20, 0.20, 0.20, 0.20, 0.20 ), - ZWinPS = cms.vdouble( 0, 3.00, 3.00, 3.00, 3.00, 3.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.00, 0.00, 0.00, 0.00, 0.00 ), # from L 5,6 to D ... - ZWin = cms.vdouble( 0, 0.00, 0.00, 0.00, 0.00, 0.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.00, 0.00, 0.00, 0.00, 0.00 ), - ZWinPS = cms.vdouble( 0, 0.00, 0.00, 0.00, 0.00, 0.00 ), ), - ), - ProjectionWindowsEndcapBarrel = cms.VPSet( - cms.PSet( RhoPhiWin = cms.vdouble( 0 ), - ZWin = cms.vdouble( 0 ), - RhoPhiWinPS = cms.vdouble( 0 ), - ZWinPS = cms.vdouble( 0 ), ), #Use 0 as dummy to have direct access to the SL without re-starting from 0 - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWin = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), - RhoPhiWinPS = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWinPS = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWin = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), - RhoPhiWinPS = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWinPS = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWin = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), - RhoPhiWinPS = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWinPS = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWin = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), - RhoPhiWinPS = cms.vdouble( 0, 0.10, 0.10, 0.10, 0.10, 0.10, 0.10 ), - ZWinPS = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.50, 0.50, 0.50 ), ), - ), - ProjectionWindowsEndcapEndcap = cms.VPSet( - cms.PSet( RhoPhiWin = cms.vdouble( 0 ), - ZWin = cms.vdouble( 0 ), - RhoPhiWinPS = cms.vdouble( 0 ), - ZWinPS = cms.vdouble( 0 ), ), #Use 0 as dummy to have direct access to the SL without re-starting from 0 - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.00, 0.00, 0.09, 0.10, 0.15 ), - ZWin = cms.vdouble( 0, 0.00, 0.00, 3.00, 3.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.00, 0.00, 0.09, 0.10, 0.15 ), - ZWinPS = cms.vdouble( 0, 0.00, 0.00, 0.60, 1.00, 1.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.05, 0.00, 0.00, 0.08, 0.10 ), - ZWin = cms.vdouble( 0, 3.00, 0.00, 0.00, 3.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.05, 0.00, 0.00, 0.08, 0.10 ), - ZWinPS = cms.vdouble( 0, 0.40, 0.00, 0.00, 0.50, 1.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.05, 0.05, 0.00, 0.00, 0.08 ), - ZWin = cms.vdouble( 0, 3.00, 3.00, 0.00, 0.00, 3.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.05, 0.05, 0.00, 0.00, 0.08 ), - ZWinPS = cms.vdouble( 0, 0.50, 0.50, 0.00, 0.00, 1.00 ), ), - cms.PSet( RhoPhiWin = cms.vdouble( 0, 0.05, 0.05, 0.05, 0.00, 0.00 ), - ZWin = cms.vdouble( 0, 3.00, 3.00, 3.00, 0.00, 0.00 ), - RhoPhiWinPS = cms.vdouble( 0, 0.05, 0.05, 0.05, 0.00, 0.00 ), - ZWinPS = cms.vdouble( 0, 0.50, 0.50, 0.50, 0.00, 0.00 ), ), - ) -) - - -# Set the preferred hit matching algorithms. -# We prefer the a algorithm for now in order not to break anything. -# Override with process.TTTrackAlgorithm_PSimHit_ = ..., etc. in your -# configuration. -TTTrackAlgorithm_PixelDigi_ = cms.ESPrefer("TTTrackAlgorithm_trackletBE_PixelDigi_") - diff --git a/L1Trigger/TrackTrigger/python/TTTrack_cfi.py b/L1Trigger/TrackTrigger/python/TTTrack_cfi.py deleted file mode 100644 index ae02de991b30a..0000000000000 --- a/L1Trigger/TrackTrigger/python/TTTrack_cfi.py +++ /dev/null @@ -1,9 +0,0 @@ -import FWCore.ParameterSet.Config as cms - -TTTracksFromPixelDigis = cms.EDProducer("TTTrackBuilder_PixelDigi_", - TTStubsBricks = cms.InputTag("TTStubsFromPixelDigis", "StubsPass"), - AssociativeMemories = cms.bool(False) -) - - - diff --git a/L1Trigger/TrackTrigger/python/TrackTrigger_cff.py b/L1Trigger/TrackTrigger/python/TrackTrigger_cff.py index 88dfec13d45aa..6c4336321f1dd 100644 --- a/L1Trigger/TrackTrigger/python/TrackTrigger_cff.py +++ b/L1Trigger/TrackTrigger/python/TrackTrigger_cff.py @@ -8,15 +8,9 @@ from L1Trigger.TrackTrigger.TTStubAlgorithmRegister_cfi import * from L1Trigger.TrackTrigger.TTStub_cfi import * -from L1Trigger.TrackTrigger.TTTrackAlgorithmRegister_cfi import * -from L1Trigger.TrackTrigger.TTTrack_cfi import * - TTClusterAlgorithm_PixelDigi_ = cms.ESPrefer('TTClusterAlgorithm_2d2013_PixelDigi_') TTStubAlgorithm_PixelDigi_ = cms.ESPrefer('TTStubAlgorithm_tab2013_PixelDigi_') -TTTrackAlgorithm_PixelDigi_ = cms.ESPrefer('TTTrackAlgorithm_trackletBE_PixelDigi_') #and the sequence to run TrackTriggerClustersStubs = cms.Sequence(TTClustersFromPixelDigis*TTStubsFromPixelDigis) -TrackTriggerTracks = cms.Sequence(TTTracksFromPixelDigis) -TrackTriggerComplete = cms.Sequence(TTClustersFromPixelDigis*TTStubsFromPixelDigis*TTTracksFromPixelDigis) diff --git a/L1Trigger/TrackTrigger/src/ES_TTTrackAlgorithm.cc b/L1Trigger/TrackTrigger/src/ES_TTTrackAlgorithm.cc deleted file mode 100644 index 28f533b72afa2..0000000000000 --- a/L1Trigger/TrackTrigger/src/ES_TTTrackAlgorithm.cc +++ /dev/null @@ -1,11 +0,0 @@ -/*! \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#include "FWCore/Utilities/interface/typelookup.h" -#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h" - -TYPELOOKUP_DATA_REG( TTTrackAlgorithm< Ref_PixelDigi_ > ); - diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_cbc3.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_cbc3.cc index 856bac38bb53e..ee53b8c07674e 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_cbc3.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_cbc3.cc @@ -18,8 +18,8 @@ void TTStubAlgorithm_cbc3< Ref_PixelDigi_ >::PatternHitCorrelation( bool &aConfi { /// Calculate average coordinates col/row for inner/outer Cluster /// These are already corrected for being at the center of each pixel - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); /// Get the module ID StackedTrackerDetId stDetId( aTTStub.getDetId() ); diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_globalgeometry.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_globalgeometry.cc index 7c215c6ced3cd..b9bdd66dd4835 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_globalgeometry.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_globalgeometry.cc @@ -28,8 +28,8 @@ void TTStubAlgorithm_globalgeometry< Ref_PixelDigi_ >::PatternHitCorrelation( bo } /// Get average position of Clusters composing the Stub - GlobalPoint innerHitPosition = (*TTStubAlgorithm< Ref_PixelDigi_ >::theStackedTracker).findAverageGlobalPosition( aTTStub.getClusterPtr(0).get() ); - GlobalPoint outerHitPosition = (*TTStubAlgorithm< Ref_PixelDigi_ >::theStackedTracker).findAverageGlobalPosition( aTTStub.getClusterPtr(1).get() ); + GlobalPoint innerHitPosition = (*TTStubAlgorithm< Ref_PixelDigi_ >::theStackedTracker).findAverageGlobalPosition( aTTStub.getClusterRef(0).get() ); + GlobalPoint outerHitPosition = (*TTStubAlgorithm< Ref_PixelDigi_ >::theStackedTracker).findAverageGlobalPosition( aTTStub.getClusterRef(1).get() ); /// Get useful quantities double outerPointRadius = outerHitPosition.perp(); @@ -65,8 +65,8 @@ void TTStubAlgorithm_globalgeometry< Ref_PixelDigi_ >::PatternHitCorrelation( bo /// Calculate output /// NOTE this assumes equal pitch in both sensors! - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); aDisplacement = 2*(mp1.x() - mp0.x()); /// In HALF-STRIP units! /// By default, assigned as ZERO diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_pixelray.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_pixelray.cc index e98295ffdfbf3..062a39f9d45f1 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_pixelray.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_pixelray.cc @@ -51,8 +51,8 @@ void TTStubAlgorithm_pixelray< Ref_PixelDigi_ >::PatternHitCorrelation( bool &aC /// Calculate output /// NOTE this assumes equal pitch in both sensors! - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); aDisplacement = 2*(mp1.x() - mp0.x()); /// In HALF-STRIP units! /// By default, assigned as ZERO @@ -77,13 +77,13 @@ std::pair< double, double >* TTStubAlgorithm_pixelray< Ref_PixelDigi_ >::GetPixe const GeomDetUnit* innerDet = stackedTracker->idToDetUnit( aTTStub.getDetId(), 0 ); const GeomDetUnit* outerDet = stackedTracker->idToDetUnit( aTTStub.getDetId(), 1 ); - MeasurementPoint innerAvg = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint outerAvg = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint innerAvg = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint outerAvg = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); - StackedTrackerDetId innerDetId( aTTStub.getClusterPtr(0)->getDetId() ); - StackedTrackerDetId outerDetId( aTTStub.getClusterPtr(1)->getDetId() ); - unsigned int innerStackMember = aTTStub.getClusterPtr(0)->getStackMember(); - unsigned int outerStackMember = aTTStub.getClusterPtr(1)->getStackMember(); + StackedTrackerDetId innerDetId( aTTStub.getClusterRef(0)->getDetId() ); + StackedTrackerDetId outerDetId( aTTStub.getClusterRef(1)->getDetId() ); + unsigned int innerStackMember = aTTStub.getClusterRef(0)->getStackMember(); + unsigned int outerStackMember = aTTStub.getClusterRef(1)->getStackMember(); unsigned int innerStack = innerDetId.iLayer(); unsigned int outerStack = outerDetId.iLayer(); unsigned int innerLadderPhi = innerDetId.iPhi(); diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_tab2013.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_tab2013.cc index a96518073d72c..71c055042a717 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_tab2013.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_tab2013.cc @@ -19,8 +19,8 @@ void TTStubAlgorithm_tab2013< Ref_PixelDigi_ >::PatternHitCorrelation( bool &aCo { /// Calculate average coordinates col/row for inner/outer Cluster /// These are already corrected for being at the center of each pixel - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); /// Get the module position in global coordinates StackedTrackerDetId stDetId( aTTStub.getDetId() ); diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window.cc index ad3eef6b5c217..4b0c51550eabe 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window.cc @@ -31,7 +31,7 @@ void TTStubAlgorithm_window< Ref_PixelDigi_ >::PatternHitCorrelation( bool &aCon /// Calculate average coordinates col/row for inner Cluster double averageRow = 0.0; double averageCol = 0.0; - const std::vector< Ref_PixelDigi_ > &lhits0 = aTTStub.getClusterPtr(0)->getHits(); + const std::vector< Ref_PixelDigi_ > &lhits0 = aTTStub.getClusterRef(0)->getHits(); if ( lhits0.size() != 0 ) { for ( hitIter = lhits0.begin(); @@ -51,7 +51,7 @@ void TTStubAlgorithm_window< Ref_PixelDigi_ >::PatternHitCorrelation( bool &aCon /// Calculate average coordinates col/row for outer Cluster averageRow = 0.0; averageCol = 0.0; - const std::vector< Ref_PixelDigi_ > &lhits1 = aTTStub.getClusterPtr(1)->getHits(); + const std::vector< Ref_PixelDigi_ > &lhits1 = aTTStub.getClusterRef(1)->getHits(); if ( lhits1.size() != 0 ) { for ( hitIter = lhits1.begin(); @@ -73,8 +73,8 @@ void TTStubAlgorithm_window< Ref_PixelDigi_ >::PatternHitCorrelation( bool &aCon /// Calculate output /// NOTE this assumes equal pitch in both sensors! - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); aDisplacement = 2*(mp1.x() - mp0.x()); /// In HALF-STRIP units! /// By default, assigned as ZERO diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2012.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2012.cc index fce0e42a0beed..dd06d663e429c 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2012.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2012.cc @@ -18,8 +18,8 @@ void TTStubAlgorithm_window2012< Ref_PixelDigi_ >::PatternHitCorrelation( bool & { /// Calculate average coordinates col/row for inner/outer Cluster /// These are already corrected for being at the center of each pixel - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); /// Get the module position in global coordinates StackedTrackerDetId stDetId( aTTStub.getDetId() ); diff --git a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2013.cc b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2013.cc index fb8e80ee4dc82..d62268c0ba07f 100644 --- a/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2013.cc +++ b/L1Trigger/TrackTrigger/src/TTStubAlgorithm_window2013.cc @@ -18,8 +18,8 @@ void TTStubAlgorithm_window2013< Ref_PixelDigi_ >::PatternHitCorrelation( bool & { /// Calculate average coordinates col/row for inner/outer Cluster /// These are already corrected for being at the center of each pixel - MeasurementPoint mp0 = aTTStub.getClusterPtr(0)->findAverageLocalCoordinates(); - MeasurementPoint mp1 = aTTStub.getClusterPtr(1)->findAverageLocalCoordinates(); + MeasurementPoint mp0 = aTTStub.getClusterRef(0)->findAverageLocalCoordinates(); + MeasurementPoint mp1 = aTTStub.getClusterRef(1)->findAverageLocalCoordinates(); /// Get the module position in global coordinates StackedTrackerDetId stDetId( aTTStub.getDetId() ); diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm.cc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm.cc deleted file mode 100644 index 4dcad61e3a033..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm.cc +++ /dev/null @@ -1,35 +0,0 @@ -/*! \brief Implementation of methods of TTTrackAlgorithm - * \details Here, in the source file, the methods which do depend - * on the specific type that can fit the template. - * - * \author Anders Ryd - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm.h" - -/// Fit the track -template< > -void TTTrackAlgorithm< Ref_PixelDigi_ >::FitTrack( TTTrack< Ref_PixelDigi_ > &seed ) const -{ - /// Get the Stubs and other information from the seed - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > curStubs = seed.getStubPtrs(); - GlobalVector seedMomentum = seed.getMomentum(); - GlobalPoint seedVertex = seed.getVertex(); - double seedRInv = seed.getRInv(); - double seedPhi0 = seedMomentum.phi(); - double seedZ0 = seedVertex.z(); - double seedCotTheta0 = tan( M_PI_2 - seedMomentum.theta() ); - -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_TrackFit.icc" - - seed.setMomentum( GlobalVector( newPt*cos(newPhi0), - newPt*sin(newPhi0), - newPt*newCotTheta0 ) ); - seed.setVertex( GlobalPoint( 0, 0, seedZ0 + dZ0 ) ); - seed.setRInv( newRInv ); - seed.setChi2( chiSquare ); -} - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithmRecord.cc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithmRecord.cc deleted file mode 100644 index 60fdb831c1bf6..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithmRecord.cc +++ /dev/null @@ -1,12 +0,0 @@ -/*! \brief Register the record. - * - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithmRecord.h" -#include "FWCore/Framework/interface/eventsetuprecord_registration_macro.h" - -EVENTSETUP_RECORD_REG(TTTrackAlgorithmRecord); - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_TrackFit.icc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_TrackFit.icc deleted file mode 100644 index 7c8568adce29d..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_TrackFit.icc +++ /dev/null @@ -1,388 +0,0 @@ -/*! \brief Implementation of methods of TTTrackAlgorithm - * \details Here, in the source file, the methods which do depend - * on the specific type that can fit the template. - * - * \author Anders Ryd - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - - /// First step is to calculate derivatives - /// First index is parameter, second index is stub - /// Even stub index is for transverse plane, odd for r-z - /// Fit parameters are phi0, rInv, cotTheta0, z0 - double D_[4][40] = {{0.}}; /// NOTE: in the note, Dij is derivative wrt. var j at point i - /// here in the code D_ is the transpose of ij - double M_[4][8] = {{0.}}; - double MinvDt_[4][40] = {{0.}}; - unsigned int js = 0; /// Use js as looping index over stubs in matrices - - /// Loop over the Stubs and calculate derivatives at each point - /// Limit the procedure to 20 stubs - if ( curStubs.size() > 20 ) - return; - - for ( unsigned int is = 0; is < curStubs.size(); is++ ) - { - /// Get the stub global position - GlobalPoint curPos = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( curStubs.at(is).get() ); - double stubRho = curPos.perp(); - - /// Resolution from Pixel Pitch - StackedTrackerDetId stDetId( curStubs.at(is)->getClusterPtr(0)->getDetId() ); - const GeomDetUnit* det0 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->idToDetUnit( stDetId, 0 ); - const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 ); - const PixelTopology* top0 = dynamic_cast< const PixelTopology* >( &(pix0->specificTopology()) ); - std::pair< float, float > pitch0 = top0->pitch(); - - /// Residuals in RhoPhi - /// Simplified approach: cluster position is unweighted average of binary hits - /// and hit true position as sum of uncorrelated random variables - /// with uniform distribution within each strip width - /// NOTE: this is not true! when CW > 1, the probability that charge is deposited - /// far away from the center of the cluster is smaller than in the centre! - /// For this reason, this assumpion will give upper limits to the residuals - /// but this is fine for the time being ... - /// Average position = 1st coordinate + CW/2 - /// Residual is pitch*(U(0, 1) + U(1, 2) + ... + U(N-1, N) )/N - Avg. pos. - /// RMS of residuals is pitch/sqrt(N*12) - double sigmaRhoPhi = pitch0.first / sqrt(12 * curStubs.at(is)->getClusterPtr(0)->findWidth() ); /// Take into account cluster width! - - /// Residuals in Z - /// Simplification: 1 pixel long - /// This will give upper limits only, but pitch is the main dominating element in the resolution - double sigmaZ = pitch0.second / sqrt(12); /// This is valid for both Barrel and Endcap Stubs, - /// it is the calculation of derivatives that changes - - if ( stDetId.isBarrel() ) - { - /// Transverse plane: [0] rInv, [1] phi0 - /// d(rho*phi)/d(rInv) - D_[0][js] = -0.5 * stubRho * stubRho / sqrt( 1 - 0.25*stubRho*stubRho*seedRInv*seedRInv ) / sigmaRhoPhi; - /// d(rho*phi)/d(phi0) - D_[1][js] = stubRho / sigmaRhoPhi; - /// d(rho*phi)/d(cotTheta0) = 0 - /// d(rho*phi)/d(z0) = 0 - js++; - - /// Longitudinal plane: [2] cotTheta0, [3] z0 - /// d(z)/d(rInv) = 0 - - //D_[0][js] = - stubRho / sigmaZ * ( -2 * seedCotTheta0 / ( seedRInv*seedRInv ) * asin( stubRho * seedRInv * 0.5 ) +2 * seedCotTheta0 * stubRho / seedRInv / sqrt( 4 - stubRho*stubRho*seedRInv*seedRInv ) ); - - /// d(z)/d(phi0) = 0 - /// d(z)/d(cotTheta0) - D_[2][js] = 2. / seedRInv * asin( 0.5*seedRInv*stubRho ) / sigmaZ; - /// d(z)/d(z0) - D_[3][js] = 1.0 / sigmaZ; - js++; - } - else if ( stDetId.isEndcap() ) - { - double stubZ = curPos.z(); - double stubPhi = curPos.phi(); - - double dRho_dRInv = - 2.0 * sin( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) / ( seedRInv * seedRInv ) - + cos( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) * ( stubZ - seedZ0 ) / ( seedRInv * seedCotTheta0 ); - double dRho_dPhi0 = 0; - double dRho_dCotTheta0 = - cos( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) * ( stubZ - seedZ0 ) / ( seedCotTheta0 * seedCotTheta0 ); - double dRho_dZ0 = - cos( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) / ( seedCotTheta0 ); - - /// Radial plane - /// d(rho)/d(rInv) - D_[0][js] = dRho_dRInv / sigmaZ; - /// d(rho)/d(phi0) - D_[1][js] = dRho_dPhi0 / sigmaZ; - /// d(rho)/d(cotTheta0) - D_[2][js] = dRho_dCotTheta0 / sigmaZ; - /// d(rho)/d(z0) - D_[3][js] = dRho_dZ0 / sigmaZ; - js++; - - double dPhi_dRInv = - 0.5 * ( stubZ - seedZ0 ) / ( seedCotTheta0 ); - double dPhi_dPhi0 = 1; - double dPhi_dCotTheta0 = 0.5 * seedRInv * ( stubZ - seedZ0 ) / ( seedCotTheta0 * seedCotTheta0 ); - double dPhi_dZ0 = 0.5 * seedRInv / seedCotTheta0; - - /// Transverse plane - /* - /// OLD VERSION - /// d(rho*phi)/d(rInv) - D_[0][js] = stubRho * dPhi_dRInv / sigmaRhoPhi; - /// d(rho*phi)/d(phi0) - D_[1][js] = stubRho * dPhi_dPhi0 / sigmaRhoPhi; - /// d(rho*phi)/d(cotTheta0) - D_[2][js] = stubRho * dPhi_dCotTheta0 / sigmaRhoPhi; - /// d(rho*phi)/d(z0) - D_[3][js] = stubRho * dPhi_dZ0 / sigmaRhoPhi; - */ - - /// NEW VERSION - non-pointing strips correction - double rhoTrack = 2.0 * sin( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) / seedRInv; - double phiTrack = seedPhi0 - 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0; - - /// Calculate a correction for non-pointing-strips in square modules - /// Relevant angle is the one between hit and module center, with - /// vertex at (0, 0). Take snippet from HitMatchingAlgorithm_window201* - /// POSITION IN TERMS OF PITCH MULTIPLES: - /// 0 1 2 3 4 5 6 7 8 9 ... - /// COORD: 0 1 2 3 4 5 6 7 8 9 ... - /// OUT | | | | | |x| | | | | | | | | | - /// - /// IN | | | |x|x| | | | | | | | | | | - /// THIS is 3.5 (COORD) and 4.0 (POS) - /// The center of the module is at NROWS/2 (position) and NROWS-0.5 (coordinates) - MeasurementPoint stubCoord = curStubs.at(is)->getClusterPtr(0)->findAverageLocalCoordinates(); - double stubTransvDispl = pitch0.first * ( stubCoord.x() - (top0->nrows()/2 - 0.5) ); /// Difference in coordinates is the same as difference in position - if ( stubZ > 0 ) - { - stubTransvDispl = - stubTransvDispl; - } - double stubPhiCorr = asin( stubTransvDispl / stubRho ); - double rhoMultiplier = - sin( stubPhiCorr - phiTrack + stubPhi ); - double phiMultiplier = rhoTrack * cos( stubPhiCorr - phiTrack + stubPhi ); - - /// d(rho*phi)/d(rInv) - D_[0][js] = ( phiMultiplier * dPhi_dRInv + rhoMultiplier * dRho_dRInv ) / sigmaRhoPhi; - /// d(rho*phi)/d(phi0) - D_[1][js] = ( phiMultiplier * dPhi_dPhi0 + rhoMultiplier * dRho_dPhi0 ) / sigmaRhoPhi; - /// d(rho*phi)/d(cotTheta0) - D_[2][js] = ( phiMultiplier * dPhi_dCotTheta0 + rhoMultiplier * dRho_dCotTheta0 ) / sigmaRhoPhi; - /// d(rho*phi)/d(z0) - D_[3][js] = ( phiMultiplier * dPhi_dZ0 + rhoMultiplier * dRho_dZ0 ) / sigmaRhoPhi; - js++; - } - } - - /// Calculate M-matrix - /// now, by construction, js = 2*curStubs.size() - for ( unsigned int i1 = 0; i1 < 4; i1++ ) - { - for ( unsigned int i2 = 0; i2 < 4; i2++ ) - { - for ( unsigned int i3 = 0; i3 < js; i3++ ) - { - M_[i1][i2] += D_[i1][i3]*D_[i2][i3]; - } - } - } - - /// Invert the M-matrix - double ratio, a; - - /// Step 1 - for ( unsigned int i = 0; i < 4; i++ ) - { - for ( unsigned int j = 4; j < 8; j++ ) - { - if ( i == (j - 4) ) - M_[i][j] = 1.0; - else - M_[i][j] = 0.0; - } - } - - /// Step 2 - for ( unsigned int i = 0; i < 4; i++ ) - { - for ( unsigned int j = 0; j < 4; j++ ) - { - if ( i != j ) - { - ratio = M_[j][i]/M_[i][i]; - - for ( unsigned int k = 0; k < 8; k++ ) - { - M_[j][k] -= ratio * M_[i][k]; - } - } - } - } - - /// Step 3 - for ( unsigned int i = 0; i < 4; i++ ) - { - a = M_[i][i]; - for ( unsigned int j = 0; j < 8; j++) - { - M_[i][j] /= a; - } - } - - /// Calculate MinvDt-matrix - /// now, by construction, js = 2*curStubs.size() - for ( unsigned int j = 0; j < js; j++ ) - { - for ( unsigned int i1 = 0; i1 < 4; i1++ ) - { - for ( unsigned int i2 = 0; i2 < 4; i2++ ) - { - MinvDt_[i1][j] += M_[i1][i2+4] * D_[i2][j]; - } - } - } - - /// Calculate the residuals - double delta[40] = {0}; - double chiSquare = 0; - js = 0; /// re-initialize js - - double largestRes = -1.0; - int iLargestRes = -1; - - for ( unsigned int is = 0; is < curStubs.size(); is++ ) - { - /// Get the stub global position - GlobalPoint curPos = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( curStubs.at(is).get() ); - double stubRho = curPos.perp(); - double stubPhi = curPos.phi(); - double stubZ = curPos.z(); - - /// Resolution from Pixel Pitch - StackedTrackerDetId stDetId( curStubs.at(is)->getClusterPtr(0)->getDetId() ); - const GeomDetUnit* det0 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->idToDetUnit( stDetId, 0 ); - const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 ); - const PixelTopology* top0 = dynamic_cast< const PixelTopology* >( &(pix0->specificTopology()) ); - std::pair< float, float > pitch0 = top0->pitch(); - - /// Residuals in RhoPhi - /// Simplified approach: cluster position is unweighted average of binary hits - /// and hit true position as sum of uncorrelated random variables - /// with uniform distribution within each strip width - /// NOTE: this is not true! when CW > 1, the probability that charge is deposited - /// far away from the center of the cluster is smaller than in the centre! - /// For this reason, this assumpion will give upper limits to the residuals - /// but this is fine for the time being ... - /// Average position = 1st coordinate + CW/2 - /// Residual is pitch*(U(0, 1) + U(1, 2) + ... + U(N-1, N) )/N - Avg. pos. - /// RMS of residuals is pitch/sqrt(N*12) - double sigmaRhoPhi = pitch0.first / sqrt(12 * curStubs.at(is)->getClusterPtr(0)->findWidth() ); /// Take into account cluster width! - - /// Residuals in Z - /// Simplification: 1 pixel long - /// This will give upper limits only, but pitch is the main dominating element in the resolution - double sigmaZ = pitch0.second / sqrt(12); /// This is valid for both Barrel and Endcap Stubs, - /// it is the calculation of derivatives that changes - - /// Residuals! - if ( stDetId.isBarrel() ) - { - double deltaPhi = seedPhi0 - asin( 0.5*stubRho*seedRInv ) - stubPhi; - if ( deltaPhi > M_PI ) - deltaPhi -= 2*M_PI; - if ( deltaPhi < -1*M_PI ) - deltaPhi += 2*M_PI; - - /// Transverse plane - delta[js++] = stubRho * deltaPhi / sigmaRhoPhi; - /// Longitudinal plane - delta[js++] = ( seedZ0 + (2./seedRInv)*seedCotTheta0*asin( 0.5*stubRho*seedRInv ) - stubZ ) / sigmaZ; - } - else if ( stDetId.isEndcap() ) - { - /* - double deltaPhi = seedPhi0 - 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 - stubPhi; - if ( deltaPhi > M_PI ) - deltaPhi -= 2*M_PI; - if ( deltaPhi < -1*M_PI ) - deltaPhi += 2*M_PI; - */ - /* - /// OLD VERSION - /// Radial plane - delta[js++] = ( 2.0 * sin ( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) / seedRInv - stubRho ) / sigmaZ; - /// Transverse plane - delta[js++] = deltaPhi / ( sigmaRhoPhi / stubRho ); - */ - - double rhoTrack = 2.0 * sin( 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0 ) / seedRInv; - double phiTrack = seedPhi0 - 0.5 * seedRInv * ( stubZ - seedZ0 ) / seedCotTheta0; - double stubPhi = curPos.phi(); - - /// Calculate a correction for non-pointing-strips in square modules - /// Relevant angle is the one between hit and module center, with - /// vertex at (0, 0). Take snippet from HitMatchingAlgorithm_window201* - /// POSITION IN TERMS OF PITCH MULTIPLES: - /// 0 1 2 3 4 5 6 7 8 9 ... - /// COORD: 0 1 2 3 4 5 6 7 8 9 ... - /// OUT | | | | | |x| | | | | | | | | | - /// - /// IN | | | |x|x| | | | | | | | | | | - /// THIS is 3.5 (COORD) and 4.0 (POS) - /// The center of the module is at NROWS/2 (position) and NROWS-0.5 (coordinates) - MeasurementPoint stubCoord = curStubs.at(is)->getClusterPtr(0)->findAverageLocalCoordinates(); - double stubTransvDispl = pitch0.first * ( stubCoord.x() - (top0->nrows()/2 - 0.5) ); /// Difference in coordinates is the same as difference in position - if ( stubZ > 0 ) - { - stubTransvDispl = - stubTransvDispl; - } - double stubPhiCorr = asin( stubTransvDispl / stubRho ); - //double rhoMultiplier = - sin( stubPhiCorr - phiTrack + stubPhi ); - //double phiMultiplier = rhoTrack * cos( stubPhiCorr - phiTrack + stubPhi ); - double deltaRhoPhiCorr = stubTransvDispl - rhoTrack*sin( stubPhiCorr - phiTrack + stubPhi ); - - /// NEW VERSION - /// Radial plane - delta[js++] = ( rhoTrack - stubRho ) / sigmaZ; - /// Transverse plane - delta[js++] = deltaRhoPhiCorr / sigmaRhoPhi; - } - - /// Update largest residual - if ( fabs( delta[js-2] ) > largestRes ) - { - largestRes = fabs( delta[js-2] ); - iLargestRes = is; - } - if ( fabs( delta[js-1] ) > largestRes ) - { - largestRes = fabs( delta[js-1] ); - iLargestRes = is; - } - - if ( largestRes > 5.0 ) - { - seed.setLargestResIdx( iLargestRes ); - } - - /// Update the chiSquare - chiSquare += ( delta[js-2]*delta[js-2] + delta[js-1]*delta[js-1] ); - } - - /// Calculate the steps in the linearized fit - double dRInv = 0.0; - double dPhi0 = 0.0; - double dCotTheta0 = 0.0; - double dZ0 = 0.0; - double dRInv_c = 0.0; - double dPhi0_c = 0.0; - double dCotTheta0_c = 0.0; - double dZ0_c = 0.0; - - /// Matrix glory in action - for ( unsigned int j = 0; j < js; j++ ) - { - dRInv -= MinvDt_[0][j]*delta[j]; - dPhi0 -= MinvDt_[1][j]*delta[j]; - dCotTheta0 -= MinvDt_[2][j]*delta[j]; - dZ0 -= MinvDt_[3][j]*delta[j]; - - dRInv_c += D_[0][j]*delta[j]; - dPhi0_c += D_[1][j]*delta[j]; - dCotTheta0_c += D_[2][j]*delta[j]; - dZ0_c += D_[3][j]*delta[j]; - } - - double deltaChiSquare = dRInv*dRInv_c + dPhi0*dPhi0_c + dCotTheta0*dCotTheta0_c + dZ0*dZ0_c; - chiSquare += deltaChiSquare; - - /// Update the Track - double newRInv = seedRInv + dRInv; - double newPhi0 = seedPhi0 + dPhi0; - double newCotTheta0 = seedCotTheta0 + dCotTheta0; - - double mMagneticField = this->ReturnMagneticField(); - - double newPt = fabs( mMagneticField*0.003 / newRInv ); - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE.cc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE.cc deleted file mode 100644 index 841b878d30e14..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE.cc +++ /dev/null @@ -1,655 +0,0 @@ -/*! \brief Implementation of methods of TTTrackAlgorithm_trackletBE - * \details Here, in the source file, the methods which do depend - * on the specific type that can fit the template. - * - * \author Anders Ryd - * \author Emmanuele Salvati - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletBE.h" - -/// Create Seeds -template< > -void TTTrackAlgorithm_trackletBE< Ref_PixelDigi_ >::CreateSeeds( std::vector< TTTrack< Ref_PixelDigi_ > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > &input ) const -{ - /// STEP 0 - /// Prepare output - output.clear(); - outputSectorMap->clear(); - - /// Map the Stubs per Sector/Wedge for seeding purposes - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > *stubBarrelMap; - stubBarrelMap = new std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > >(); - stubBarrelMap->clear(); - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > *stubEndcapMap; - stubEndcapMap = new std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > >(); - stubEndcapMap->clear(); - - /// STEP 1 - /// Create the maps - /// Loop over input stubs - typename std::vector< TTStub< Ref_PixelDigi_ > >::const_iterator inputIter; - unsigned int j = 0; /// Counter needed to build the edm::Ptr to the TTStub - for ( inputIter = input->begin(); - inputIter != input->end(); - ++inputIter ) - { - /// Make the pointer to be put in the map and, later on, in the Track - edm::Ptr< TTStub< Ref_PixelDigi_ > > tempStubPtr( input, j++ ); - - /// Calculate Sector - /// From 0 to nSectors-1 - /// Sector 0 centered on Phi = 0 and symmetric around it - double stubPhi = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( tempStubPtr.get() ).phi(); - stubPhi += M_PI/nSectors; - if ( stubPhi < 0 ) - { - stubPhi += 2*M_PI; - } - unsigned int thisSector = floor( 0.5*stubPhi*nSectors/M_PI ); - - /// Calculate Wedge - /// From 0 to nWedges-1 - double stubEta = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( tempStubPtr.get() ).eta(); - stubEta += 2.5; /// Bring eta = -2.5 to 0 - if ( stubEta < 0.0 || stubEta > 5.0 ) - { - /// Accept only stubs within -2.5, 2.5 range - continue; - } - unsigned int thisWedge = floor( stubEta*nWedges/5.0 ); - - /// Build the key to the map (by Sector / Wedge) - std::pair< unsigned int, unsigned int > mapKey = std::make_pair( thisSector, thisWedge ); - - /// Do the same but separating Barrel and Endcap Stubs - /// NOTE this is internal to build seeds - /// The previous one goes into the output - StackedTrackerDetId detIdStub( inputIter->getDetId() ); - if ( detIdStub.isBarrel() ) - { - /// If an entry already exists for this key, just add the stub - /// to the vector, otherwise create the entry - if ( stubBarrelMap->find( mapKey ) == stubBarrelMap->end() ) - { - /// New entry - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempStubVec; - tempStubVec.clear(); - tempStubVec.push_back( tempStubPtr ); - stubBarrelMap->insert( std::pair< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > ( mapKey, tempStubVec ) ); - } - else - { - /// Already existing entry - stubBarrelMap->find( mapKey )->second.push_back( tempStubPtr ); - } - } - else if ( detIdStub.isEndcap() ) - { - /// If an entry already exists for this key, just add the stub - /// to the vector, otherwise create the entry - if ( stubEndcapMap->find( mapKey ) == stubEndcapMap->end() ) - { - /// New entry - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempStubVec; - tempStubVec.clear(); - tempStubVec.push_back( tempStubPtr ); - stubEndcapMap->insert( std::pair< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > ( mapKey, tempStubVec ) ); - } - else - { - /// Already existing entry - stubEndcapMap->find( mapKey )->second.push_back( tempStubPtr ); - } - } /// End of Barrel-Endcap switch - } /// End of loop over input stubs - - /// STEP 2 - /// Create the seeds - - /// At this point, all the maps are available - /// there are stubBarrelMap and stubEndcapMap - /// Then, tracklets must be found - /// the idea is to loop over neigbor sectors - - /// BARREL-BARREL - /// BARREL-ENDCAP - /// Loop over map elements - typename std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > >::const_iterator mapIter; - typename std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > >::const_iterator anotherMapIter; - for ( mapIter = stubBarrelMap->begin(); - mapIter != stubBarrelMap->end(); - ++mapIter ) - { - /// Get the list of stubs in the present Sector/Wedge - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempBarrelStubVec0 = mapIter->second; - - /// Get the Sector/Wedge of the present list - unsigned int curSector0 = mapIter->first.first + this->ReturnNumberOfSectors(); /// This is to use the %nSectors later - unsigned int curWedge0 = mapIter->first.second; - - /// Loop over the sector and its two neighbors - for ( unsigned int iSector = 0; iSector < 2; iSector++ ) - { - for ( unsigned int iWedge = 0; iWedge < 2; iWedge++) - { - /// Find the correct sector index - unsigned int curSector = ( curSector0 + iSector -1 )%(this->ReturnNumberOfSectors()); - int curWedge = curWedge0 + iWedge - 1; - if ( curWedge < 0 || curWedge >= (int)(this->ReturnNumberOfWedges()) ) - continue; - - /// Now we are in the correct Sector/Wedge pair - /// Get also the stubs of this Sector/Wedge - anotherMapIter = stubBarrelMap->find( std::make_pair( curSector, curWedge ) ); - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempBarrelStubVec1; - if ( anotherMapIter != stubBarrelMap->end() ) - { - tempBarrelStubVec1 = anotherMapIter->second; - } - - /// Include also the Endcap stubs (mixed seeding) - anotherMapIter = stubEndcapMap->find( std::make_pair( curSector, curWedge ) ); - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempEndcapStubVec1; - if ( anotherMapIter != stubEndcapMap->end() ) - { - tempEndcapStubVec1 = anotherMapIter->second; - } - - /// Double loop over all pairs of stubs - for ( unsigned int i = 0; i < tempBarrelStubVec0.size(); i++ ) - { - StackedTrackerDetId detId1( tempBarrelStubVec0.at(i)->getDetId() ); - GlobalPoint pos1 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempBarrelStubVec0.at(i)->getClusterPtr(0).get() ); - double rho1 = pos1.perp(); - double phi1 = pos1.phi(); - double z1 = pos1.z(); - - /// Layer-Disk-Ring constraint - if ( detId1.iLayer() > 4 ) - continue; - - bool barrelSeed2S = !( TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->isPSModule( detId1 ) ); - - /// Find the index of the first element of the nested loop - unsigned int startIndex = 0; - if ( curSector == curSector0%(this->ReturnNumberOfSectors()) && - curWedge == (int)curWedge0 ) /// If they are in the same Sector/Wedge the loop can be simplified - { - /// This means tempBarrelStubVec1 == tempBarrelStubVec0 - startIndex = i+1; - } - - /// Loop over other barrel stubs - for ( unsigned int k = startIndex; k < tempBarrelStubVec1.size(); k++ ) - { - StackedTrackerDetId detId2( tempBarrelStubVec1.at(k)->getDetId() ); - GlobalPoint pos2 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempBarrelStubVec1.at(k)->getClusterPtr(0).get() ); - double rho2 = pos2.perp(); - double phi2 = pos2.phi(); - double z2 = pos2.z(); - - /// Skip same layer pairs - /// Skip pairs with distance larger than 1 layer - //if (( detId2.iLayer() != detId1.iLayer() + 1 ) && ( detId1.iLayer() != detId2.iLayer() + 1 )) - if ( detId2.iLayer() != detId1.iLayer() + 1 ) - continue; - - /// Safety cross-check - if ( rho1 > rho2 ) - { - //std::cerr << "TTTrackAlgorithm_exactBarrelEndcap::CreateSeeds()" << std::endl; - //std::cerr << " A L E R T ! pos1.perp() > pos2.perp() in Barrel-Barrel tracklet" << std::endl; - continue; - } - - /// Apply cosine theorem to find 1/(2R) = rInvOver2 -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedTrigonometry.icc" - - /// Perform cut on Pt - if ( fabs(rInvOver2) > mMagneticField*0.0015*0.5 ) - continue; - - /// Calculate tracklet parameters with helix model - /// roughPt, z0, cotTheta0, phi0 -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedParameters.icc" - - /// Correct for seeds in 2S Barrel layers - if ( barrelSeed2S ) - { - if ( fabs( z1 - z2 ) < 10 ) - { - z0 = 0; - cotTheta0 = z1 / rhoPsi1; - } - } - - /// Perform projected vertex cut - if ( fabs(z0) > 30.0 ) - continue; - - /// Create the Seed in the form of a Track and store it in the output - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempVec; - tempVec.push_back( tempBarrelStubVec0.at(i) ); - tempVec.push_back( tempBarrelStubVec1.at(k) ); - TTTrack< Ref_PixelDigi_ > tempTrack( tempVec ); - tempTrack.setRInv( 2*rInvOver2 ); - tempTrack.setMomentum( GlobalVector( roughPt*cos(phi0), - roughPt*sin(phi0), - roughPt*cotTheta0 ) ); - tempTrack.setVertex( GlobalPoint( 0, 0, z0 ) ); - tempTrack.setSector( mapIter->first.first ); - tempTrack.setWedge( mapIter->first.second ); - output.push_back( tempTrack ); - } /// End of loop over other barrel stubs - - /// Loop over endcap stubs in the same sector (mixed seeding) - for ( unsigned int k = 0; k < tempEndcapStubVec1.size(); k++ ) - { - StackedTrackerDetId detId2( tempEndcapStubVec1.at(k)->getDetId() ); - GlobalPoint pos2 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempEndcapStubVec1.at(k)->getClusterPtr(0).get() ); - double rho2 = pos2.perp(); - double phi2 = pos2.phi(); - double z2 = pos2.z(); - - bool endcapSeedPS = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->isPSModule( detId2 ); - - /// Skip non-PS in endcaps for the mixed seeding - if ( !endcapSeedPS ) - {}// continue; - - /// Layer-Disk-Ring constraint - if ( detId2.iDisk() > 1 ) - continue; - - if ( detId2.iRing() > 11 ) - continue; - - /// Safety cross-check - if ( rho1 > rho2 ) - { - //std::cerr << "TTTrackAlgorithm_trackletBE::CreateSeeds()" << std::endl; - //std::cerr << " A L E R T ! pos1.perp() > pos2.perp() in Barrel-Endcap tracklet" << std::endl; - continue; - } - - /// Apply cosine theorem to find 1/(2R) = rInvOver2 -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedTrigonometry.icc" - - /// Perform cut on Pt - if ( fabs(rInvOver2) > mMagneticField*0.0015*0.5 ) - continue; - - /// Calculate tracklet parameters with helix model - /// roughPt, z0, cotTheta0, phi0 -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedParameters.icc" - - /// Correct for Endcap 2S in the seed - if ( !endcapSeedPS ) - { - if ( fabs( z1 - z2 ) < 10 ) - { - z0 = 0; - cotTheta0 = z1 / rhoPsi1; - } - } - - /// Perform projected vertex cut - if ( fabs(z0) > 30.0 ) - continue; - - /// Create the Seed in the form of a Track and store it in the output - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempVec; - tempVec.push_back( tempBarrelStubVec0.at(i) ); - tempVec.push_back( tempEndcapStubVec1.at(k) ); - TTTrack< Ref_PixelDigi_ > tempTrack( tempVec ); - tempTrack.setRInv( 2*rInvOver2 ); - tempTrack.setMomentum( GlobalVector( roughPt*cos(phi0), - roughPt*sin(phi0), - roughPt*cotTheta0 ) ); - tempTrack.setVertex( GlobalPoint( 0, 0, z0 ) ); - tempTrack.setSector( mapIter->first.first ); - tempTrack.setWedge( mapIter->first.second ); - output.push_back( tempTrack ); - } /// End of loop over endcap stubs in the same sector (mixed seeding) - - } /// End of double loop over pairs of stubs - } - } /// End of loop over neighbor Sectors/Wedges - } /// End of loop over map elements - - /// ENDCAP-ENDCAP - /// Loop over the map - /// Create Seeds in Endcap - for ( mapIter = stubEndcapMap->begin(); - mapIter != stubEndcapMap->end(); - ++mapIter ) - { - /// Here we have ALL the stubs in one single Sector/Wedge in the Endcap - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempEndcapStubVec0 = mapIter->second; - - /// Get the Sector/Wedge of the present list - unsigned int curSector0 = mapIter->first.first + this->ReturnNumberOfSectors(); /// This is to use the %nSectors later - unsigned int curWedge0 = mapIter->first.second; - - /// Loop over the sector and its two neighbors - for ( unsigned int iSector = 0; iSector < 2; iSector++ ) - { - for ( unsigned int iWedge = 0; iWedge < 2; iWedge++) - { - /// Find the correct sector index - unsigned int curSector = ( curSector0 + iSector -1 )%(this->ReturnNumberOfSectors()); - int curWedge = curWedge0 + iWedge - 1; - if ( curWedge < 0 || curWedge >= (int)(this->ReturnNumberOfWedges()) ) - continue; - - /// Now we are in the correct Sector/Wedge pair - /// Get also the stubs of this Sector/Wedge - anotherMapIter = stubEndcapMap->find( std::make_pair( curSector, curWedge ) ); - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempEndcapStubVec1; - if ( anotherMapIter != stubEndcapMap->end() ) - { - tempEndcapStubVec1 = anotherMapIter->second; - } - - /// Double loop over all pairs of stubs - for ( unsigned int i = 0; i < tempEndcapStubVec0.size(); i++ ) - { - StackedTrackerDetId detId1( tempEndcapStubVec0.at(i)->getDetId() ); - GlobalPoint pos1 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempEndcapStubVec0.at(i)->getClusterPtr(0).get() ); - double rho1 = pos1.perp(); - double phi1 = pos1.phi(); - double z1 = pos1.z(); - - bool endcapSeedPS1 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->isPSModule( detId1 ); - if ( !endcapSeedPS1 ) - continue; - - /// Find the index of the first element of the nested loop - unsigned int startIndex = 0; - if ( curSector == curSector0%(this->ReturnNumberOfSectors()) && - curWedge == (int)curWedge0 ) /// If they are in the same Sector/Wedge the loop can be simplified - { - /// This means tempEndcapStubVec1 == tempEndcapStubVec0 - startIndex = i+1; - } - - /// Loop over other endcap stubs - for ( unsigned int k = startIndex; k < tempEndcapStubVec1.size(); k++ ) - { - StackedTrackerDetId detId2( tempEndcapStubVec1.at(k)->getDetId() ); - GlobalPoint pos2 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempEndcapStubVec1.at(k)->getClusterPtr(0).get() ); - double rho2 = pos2.perp(); - double phi2 = pos2.phi(); - double z2 = pos2.z(); - - bool endcapSeedPS2 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->isPSModule( detId2 ); - if ( !endcapSeedPS2 ) - continue; - - /// Skip same disk pairs - if ( detId2.iSide() != detId1.iSide() ) - continue; - - /// Skip pairs with distance larger than 1 disk - //if (( detId2.iDisk() != detId1.iDisk() + 1 ) && ( detId1.iDisk() != detId2.iDisk() + 1 )) - if ( detId2.iDisk() != detId1.iDisk() + 1 ) - continue; - - /// Safety cross check - if ( fabs(pos1.z()) > fabs(pos2.z()) ) - { - //std::cerr << "TTTrackAlgorithm_exactBarrelEndcap::CreateSeeds()" << std::endl; - //std::cerr << " A L E R T ! fabs(pos1.z()) > fabs(pos2.z()) in Endcap-Endcap tracklet" << std::endl; - continue; - } - - /// More robust additional cross check - if ( fabs(rho1 - rho2) / fabs(z1 - z2) < 0.1 ) - continue; - - /// Apply cosine theorem to find 1/(2R) = rInvOver2 -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedTrigonometry.icc" - - /// Perform cut on Pt - if ( fabs(rInvOver2) > mMagneticField*0.0015*0.5 ) - continue; - - /// Calculate tracklet parameters with helix model - /// roughPt, z0, cotTheta0, phi0 -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedParameters.icc" - - /// Perform projected vertex cut - if ( fabs(z0) > 30.0 ) - continue; - - /// Create the Seed in the form of a Track and store it in the output - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempVec; - tempVec.push_back( tempEndcapStubVec0.at(i) ); - tempVec.push_back( tempEndcapStubVec1.at(k) ); - TTTrack< Ref_PixelDigi_ > tempTrack( tempVec ); - tempTrack.setRInv( 2*rInvOver2 ); - tempTrack.setMomentum( GlobalVector( roughPt*cos(phi0), - roughPt*sin(phi0), - roughPt*cotTheta0 ) ); - tempTrack.setVertex( GlobalPoint( 0, 0, z0 ) ); - tempTrack.setSector( mapIter->first.first ); - tempTrack.setWedge( mapIter->first.second ); - output.push_back( tempTrack ); - } - } /// End of double loop over pairs of stubs - } - } /// End of loop over neighbor Sectors/Wedges - } /// End of loop over map elements - - /// Fill the output map at the very end of everything - /// This should be faster than doing it filling it - /// stub-by-stub, also because we already have everything - /// This way the number of searches with map::find will be lower - /// and also the memory usage is smaller than in the other case - - /// Just to keep it simple and to avoid any overload of the memory - /// the two maps are merged into one which is eventually - /// passed to the output - for ( mapIter = stubEndcapMap->begin(); - mapIter != stubEndcapMap->end(); - ++mapIter ) - { - /// Get the key - std::pair< unsigned int, unsigned int > mapKey = mapIter->first; - - /// If an entry already exists for this Sector/Wedge, just add the vector - /// to the existing vector, otherwise create the entry - if ( stubBarrelMap->find( mapKey ) == stubBarrelMap->end() ) - { - /// New entry - stubBarrelMap->insert( std::make_pair( mapKey, mapIter->second ) ); - } - else - { - /// Already existing entry - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > >::iterator itVec = stubBarrelMap->find( mapKey )->second.end(); - stubBarrelMap->find( mapKey )->second.insert( itVec, mapIter->second.begin(), mapIter->second.end() ); - } - } - - /// Now copy the merged map in the output - outputSectorMap->insert( stubBarrelMap->begin(), stubBarrelMap->end() ); - -} - -/// Match a Stub to a Seed/Track -template< > -void TTTrackAlgorithm_trackletBE< Ref_PixelDigi_ >::AttachStubToSeed( TTTrack< Ref_PixelDigi_ > &seed, - edm::Ptr< TTStub< Ref_PixelDigi_ > > &candidate ) const -{ - /// Get the track Stubs - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > theStubs = seed.getStubPtrs(); - - /// Check that the candidate is NOT the one under examination - for ( unsigned int i = 0; i < theStubs.size(); i++ ) - { - if ( theStubs.at(i) == candidate ) - return; - } - - /// Skip if the stub is in one of the seed layers/disks - StackedTrackerDetId stDetId0( theStubs.at(0)->getDetId() ); - StackedTrackerDetId stDetId1( theStubs.at(1)->getDetId() ); - StackedTrackerDetId stDetIdCand( candidate->getDetId() ); - - bool endcapCandPS = false; - bool endcapSeedPS = false; - if ( endcapCandPS || endcapSeedPS ) - {} /// This is needed when I comment lines down there in order to perform tests and not to get compilation warnings etc... - - if ( stDetId0.isBarrel() && stDetIdCand.isBarrel() ) - { - if ( stDetId0.iLayer() == stDetIdCand.iLayer() || stDetId1.iLayer() == stDetIdCand.iLayer() ) - return; - } - else - { - if ( stDetId0.isEndcap() && stDetIdCand.isEndcap() ) - { - if ( stDetId0.iSide() == stDetIdCand.iSide() ) - { - if ( stDetId0.iDisk() == stDetIdCand.iDisk() || stDetId1.iDisk() == stDetIdCand.iDisk() ) - return; - } - } - } - - endcapCandPS = stDetIdCand.isEndcap() && TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->isPSModule( stDetIdCand ); - endcapSeedPS = stDetId0.isEndcap() && TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->isPSModule( stDetId0 ); - - /// Here we have either Barrel-Barrel with different Layer, - /// either Endcap-Endcap with different Side/Disk, - /// either Barrel-Endcap or Endcap-Barrel - - /// Get the track momentum and propagate it - GlobalVector curMomentum = seed.getMomentum(); - GlobalPoint curVertex = seed.getVertex(); - double curRInv = seed.getRInv(); - double curPhi = curMomentum.phi(); - double curTheta = curMomentum.theta(); - double curZVtx = curVertex.z(); - - /// Get the candidate Stub position - GlobalPoint candPos = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( candidate.get() ); - double rhoCand = candPos.perp(); - double phiCand = candPos.phi(); - double zCand = candPos.z(); - - /// Propagate seed to Barrel candidate - if ( stDetIdCand.isBarrel() ) - { - /// Calculate deltaRPhi and deltaZ -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_BarrelSeedPropagation.icc" - - /// First get the vector corresponding to the seed SL - /// Then get in this vector the entry corresponding to the targer SL - if ( stDetId0.isBarrel() ) - { - if ( deltaRPhi < (tableRPhiBB.at(stDetId0.iLayer())).at(stDetIdCand.iLayer()) && - deltaZ < (tableZBB.at(stDetId0.iLayer())).at(stDetIdCand.iLayer()) ) - { - seed.addStubPtr( candidate ); - } - } - else if ( stDetId0.isEndcap() ) - { - if ( endcapSeedPS ) - { - if ( deltaRPhi < (tableRPhiEB_PS.at(stDetId0.iDisk())).at(stDetIdCand.iLayer()) && - deltaZ < (tableZEB_PS.at(stDetId0.iDisk())).at(stDetIdCand.iLayer()) ) - { - seed.addStubPtr( candidate ); - } - } - else - { - if ( deltaRPhi < (tableRPhiEB.at(stDetId0.iDisk())).at(stDetIdCand.iLayer()) && - deltaZ < (tableZEB.at(stDetId0.iDisk())).at(stDetIdCand.iLayer()) ) - { - seed.addStubPtr( candidate ); - } - } - } - } - /// Propagate to Endcap candidate - else if ( stDetIdCand.isEndcap() ) - { - /// Calculate a correction for non-pointing-strips in square modules - /// Relevant angle is the one between hit and module center, with - /// vertex at (0, 0). Take snippet from HitMatchingAlgorithm_window201* - /// POSITION IN TERMS OF PITCH MULTIPLES: - /// 0 1 2 3 4 5 5 6 8 9 ... - /// COORD: 0 1 2 3 4 5 6 7 8 9 ... - /// OUT | | | | | |x| | | | | | | | | | - /// - /// IN | | | |x|x| | | | | | | | | | | - /// THIS is 3.5 (COORD) and 4.0 (POS) - /// The center of the module is at NROWS/2 (position) and NROWS-0.5 (coordinates) - StackedTrackerDetId stDetId( candidate->getClusterPtr(0)->getDetId() ); - const GeomDetUnit* det0 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->idToDetUnit( stDetId, 0 ); - const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 ); - const PixelTopology* top0 = dynamic_cast< const PixelTopology* >( &(pix0->specificTopology()) ); - std::pair< float, float > pitch0 = top0->pitch(); - MeasurementPoint stubCoord = candidate->getClusterPtr(0)->findAverageLocalCoordinates(); - double stubTransvDispl = pitch0.first * ( stubCoord.x() - (top0->nrows()/2 - 0.5) ); /// Difference in coordinates is the same as difference in position - - if ( zCand > 0 ) - { - stubTransvDispl = - stubTransvDispl; - } - - /// Calculate deltaRPhi and deltaRho -#include "L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_EndcapSeedPropagation.icc" - - if ( stDetId0.isBarrel() ) - { - if ( endcapCandPS ) - { - if ( deltaRPhi < (tableRPhiBE_PS.at(stDetId0.iLayer())).at(stDetIdCand.iDisk()) && - deltaR < (tableZBE_PS.at(stDetId0.iLayer())).at(stDetIdCand.iDisk()) ) - { - seed.addStubPtr( candidate ); - } - } - else - { - if ( deltaRPhi < (tableRPhiBE.at(stDetId0.iLayer())).at(stDetIdCand.iDisk()) && - deltaR < (tableZBE.at(stDetId0.iLayer())).at(stDetIdCand.iDisk()) ) - { - seed.addStubPtr( candidate ); - } - } - } - else if ( stDetId0.isEndcap() ) - { - if ( endcapCandPS ) - { - if ( deltaRPhi < (tableRPhiEE_PS.at(stDetId0.iDisk())).at(stDetIdCand.iDisk()) && - deltaR < (tableZEE_PS.at(stDetId0.iDisk())).at(stDetIdCand.iDisk()) ) - { - seed.addStubPtr( candidate ); - } - } - else - { - if ( deltaRPhi < (tableRPhiEE.at(stDetId0.iDisk())).at(stDetIdCand.iDisk()) && - deltaR < (tableZEE.at(stDetId0.iDisk())).at(stDetIdCand.iDisk()) ) - { - seed.addStubPtr( candidate ); - } - } - } - } -} - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_BarrelSeedPropagation.icc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_BarrelSeedPropagation.icc deleted file mode 100644 index 7c4541b456446..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_BarrelSeedPropagation.icc +++ /dev/null @@ -1,20 +0,0 @@ - double propPsi = asin( rhoCand * 0.5 * curRInv ); - double propPhi = curPhi - propPsi; - double propRhoPsi = 2 * propPsi / curRInv; - double propZ = curZVtx + propRhoPsi * tan( M_PI_2 - curTheta ); - - /// Calculate displacement - /* - double deltaPhi = phiCand - propPhi; - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - */ - double deltaPhi = this->DeltaPhi( phiCand, propPhi ); - double deltaRPhi = fabs( deltaPhi * rhoCand ); - double deltaZ = fabs( propZ - zCand ); - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_EndcapSeedPropagation.icc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_EndcapSeedPropagation.icc deleted file mode 100644 index ca0890c49db1e..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_EndcapSeedPropagation.icc +++ /dev/null @@ -1,26 +0,0 @@ - double propPsi = 0.5*( zCand - curZVtx ) * curRInv / tan( M_PI_2 - curTheta ); - double propPhi = curPhi - propPsi; - double propRho = 2 * sin( propPsi ) / curRInv; - - /// Calculate displacement - /* - double deltaPhi = phiCand - propPhi; - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - */ - double deltaPhi = this->DeltaPhi( phiCand, propPhi ); - double deltaRPhi = fabs( deltaPhi * rhoCand ); /// OLD VERSION (updated few lines below) - double deltaR = fabs( rhoCand - propRho ); - - /// NEW VERSION - non-pointing strips correction - double rhoTrack = 2.0 * sin( 0.5 * curRInv * ( zCand - curZVtx ) / tan( M_PI_2 - curTheta ) ) / curRInv; - double phiTrack = curPhi - 0.5 * curRInv * ( zCand - curZVtx ) / tan( M_PI_2 - curTheta ); - - double stubPhiCorr = asin( stubTransvDispl / rhoCand ); - deltaRPhi = stubTransvDispl - rhoTrack * sin( stubPhiCorr - phiTrack + phiCand ); - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedParameters.icc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedParameters.icc deleted file mode 100644 index cea902e9c3768..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedParameters.icc +++ /dev/null @@ -1,13 +0,0 @@ - /// Calculate projected vertex - /// NOTE: cotTheta0 = Pz/Pt - double rhoPsi1 = asin( rho1*rInvOver2 )/rInvOver2; - double rhoPsi2 = asin( rho2*rInvOver2 )/rInvOver2; - double cotTheta0 = ( z1 - z2 ) / ( rhoPsi1 - rhoPsi2 ); - double z0 = z1 - rhoPsi1 * cotTheta0; - - /// Calculate direction at vertex - double phi0 = phi1 + asin( rho1 * rInvOver2 ); - - /// Calculate Pt - double roughPt = fabs( mMagneticField*0.0015 / rInvOver2 ); - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedTrigonometry.icc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedTrigonometry.icc deleted file mode 100644 index 43a82796385bd..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletBE_SeedTrigonometry.icc +++ /dev/null @@ -1,26 +0,0 @@ - /// In the Barrel: - /// 1/RCurv = 0.003 * B * 1/Pt - /// In the Endcap: - /// DPhi/Dz = 0.003 / 2 * B * 1/Pz - /// ANYWAY find seed as in the Barrel! - - /// Perform standard trigonometric operations - /* - double deltaPhi = phi1 - phi2; - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - double distance = sqrt( rho2*rho2 + rho1*rho1 - 2*rho2*rho1*cos(deltaPhi) ); - */ - /* - double deltaPhi = this->DeltaPhi( phi1, phi2 ); - double distance = this->CosineTheorem( rho1, rho2, deltaPhi ); - double rInvOver2 = sin(deltaPhi)/distance; /// Sign is maintained to keep track of the charge - */ - - double rInvOver2 = this->FindRInvOver2( rho1, rho2, phi1, phi2 ); - diff --git a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletLB.cc b/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletLB.cc deleted file mode 100644 index 34f692cbe82ee..0000000000000 --- a/L1Trigger/TrackTrigger/src/TTTrackAlgorithm_trackletLB.cc +++ /dev/null @@ -1,244 +0,0 @@ -/*! \brief Implementation of methods of TTTrackAlgorithm_trackletLB - * \details Here, in the source file, the methods which do depend - * on the specific type that can fit the template. - * - * \author Anders Ryd - * \author Emmanuele Salvati - * \author Nicola Pozzobon - * \date 2013, Jul 18 - * - */ - -#include "L1Trigger/TrackTrigger/interface/TTTrackAlgorithm_trackletLB.h" - -template< > -void TTTrackAlgorithm_trackletLB< Ref_PixelDigi_ >::CreateSeeds( std::vector< TTTrack< Ref_PixelDigi_ > > &output, - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > *outputSectorMap, - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > &input ) const -{ - /// Prepare output - output.clear(); - - /// Map the Barrel Stubs per layer/rod - std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > stubBarrelMap; - stubBarrelMap.clear(); - - /// Map the Barrel Stubs per sector - outputSectorMap->clear(); - - typename std::vector< TTStub< Ref_PixelDigi_ > >::const_iterator inputIter; - unsigned int j = 0; /// Counter needed to build the edm::Ptr to the TTStub - - for ( inputIter = input->begin(); - inputIter != input->end(); - ++inputIter ) - { - /// Make the pointer to be put in the map and, later on, in the Track - edm::Ptr< TTStub< Ref_PixelDigi_ > > tempStubPtr( input, j++ ); - - /// Calculate Sector - /// From 0 to nSectors-1 - /// Sector 0 centered on Phi = 0 and symmetric around it - double stubPhi = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( tempStubPtr.get() ).phi(); - stubPhi += M_PI/nSectors; - if ( stubPhi < 0 ) - { - stubPhi += 2*M_PI; - } - unsigned int thisSector = floor( 0.5*stubPhi*nSectors/M_PI ); - /// Calculate Wedge - /// From 0 to nWedges-1 - /// - double stubEta = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findGlobalPosition( tempStubPtr.get() ).eta(); - stubEta += 2.5; /// bring eta = -2.5 to 0 - //stubEta += 2.5/nWedges; - - /// Accept only stubs within -2.5, 2.5 range - if ( stubEta < 0.0 || stubEta > 5.0 ) - continue; - - unsigned int thisWedge = floor( stubEta*nWedges/5.0 ); - - /// Build the key to the map (by Sector / Wedge) - std::pair< unsigned int, unsigned int > mapkey = std::make_pair( thisSector, thisWedge ); - - StackedTrackerDetId detIdStub( inputIter->getDetId() ); - if ( detIdStub.isBarrel() ) - { - /// If an entry already exists for this key, just add the stub - /// to the vector, otherwise create the entry - if ( stubBarrelMap.find( mapkey ) == stubBarrelMap.end() ) - { - /// New entry - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempStubVec; - tempStubVec.clear(); - tempStubVec.push_back( tempStubPtr ); - stubBarrelMap.insert( std::pair< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > ( mapkey, tempStubVec ) ); - } - else - { - /// Already existing entry - stubBarrelMap[mapkey].push_back( tempStubPtr ); - } - - /// If an entry already exists for this Sector, just add the stub - /// to the vector, otherwise create the entry - if ( outputSectorMap->find( mapkey ) == outputSectorMap->end() ) - { - /// New entry - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempStubVec; - tempStubVec.clear(); - tempStubVec.push_back( tempStubPtr ); - outputSectorMap->insert( std::pair< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > ( mapkey, tempStubVec ) ); - } - else - { - /// Already existing entry - outputSectorMap->find( mapkey )->second.push_back( tempStubPtr ); - } - } - } - - /// Loop over the map - /// Create Seeds and map detectors - typename std::map< std::pair< unsigned int, unsigned int >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > >::const_iterator mapIter; - for ( mapIter = stubBarrelMap.begin(); - mapIter != stubBarrelMap.end(); - ++mapIter ) - { - /// Here we have ALL the stubs in one single Hermetic ROD (if applicable) - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempStubVec = mapIter->second; - - for ( unsigned int i = 0; i < tempStubVec.size(); i++ ) - { - StackedTrackerDetId detId1( tempStubVec.at(i)->getDetId() ); - GlobalPoint pos1 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempStubVec.at(i)->getClusterPtr(0).get() ); - - for ( unsigned int k = i+1; k < tempStubVec.size(); k++ ) - { - StackedTrackerDetId detId2( tempStubVec.at(k)->getDetId() ); - GlobalPoint pos2 = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( tempStubVec.at(k)->getClusterPtr(0).get() ); - /// Skip different rod pairs - if ( detId1.iPhi() != detId2.iPhi() ) continue; - /// Skip same layer pairs - if ( detId1.iLayer()+1 != detId2.iLayer() ) continue; - /// Skip off-hermetic-rod - if ( detId1.iLayer()%2 == 0 ) continue; - - /// Perform standard trigonometric operations - double deltaPhi = pos1.phi() - pos2.phi(); - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - - double distance = sqrt( pos2.perp2() + pos1.perp2() - 2*pos2.perp()*pos1.perp()*cos(deltaPhi) ); - double rInvOver2 = sin(deltaPhi)/distance; /// Sign is maintained to keep track of the charge - - /// Perform cut on Pt - if ( fabs(rInvOver2) > mMagneticField*0.0015*0.5 ) continue; - - /// Calculate projected vertex - /// NOTE: cotTheta0 = Pz/Pt - double rhoPsi1 = asin( pos1.perp()*rInvOver2 )/rInvOver2; - double rhoPsi2 = asin( pos2.perp()*rInvOver2 )/rInvOver2; - double cotTheta0 = ( pos1.z() - pos2.z() ) / ( rhoPsi1 - rhoPsi2 ); - double z0 = pos2.z() - rhoPsi2 * cotTheta0; - - /// Perform projected vertex cut - if ( fabs(z0) > 30.0 ) continue; - - /// Calculate direction at vertex - double phi0 = pos2.phi() + asin( pos2.perp() * rInvOver2 ); - - /// Calculate Pt - double roughPt = fabs( mMagneticField*0.0015 / rInvOver2 ); - - /// Create the Seed in the form of a Track and store it in the output - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > tempVec; - tempVec.push_back( tempStubVec.at(i) ); - tempVec.push_back( tempStubVec.at(k) ); - TTTrack< Ref_PixelDigi_ > tempTrack( tempVec ); - tempTrack.setRInv( 2*rInvOver2 ); - tempTrack.setMomentum( GlobalVector( roughPt*cos(phi0), - roughPt*sin(phi0), - roughPt*cotTheta0 ) ); - tempTrack.setVertex( GlobalPoint( 0, 0, z0 ) ); - tempTrack.setSector( mapIter->first.first ); - tempTrack.setWedge( mapIter->first.second ); - output.push_back( tempTrack ); - } - } /// End of double loop over pairs of stubs - - } /// End of loop over map elements -} - -/// Match a Stub to a Seed/Track -template< > -void TTTrackAlgorithm_trackletLB< Ref_PixelDigi_ >::AttachStubToSeed( TTTrack< Ref_PixelDigi_ > &seed, - edm::Ptr< TTStub< Ref_PixelDigi_ > > &candidate ) const -{ - /// Get the track Stubs - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > theStubs = seed.getStubPtrs(); - - /// Compare SuperLayers - unsigned int seedSuperLayer = (unsigned int)(( StackedTrackerDetId( theStubs.at(0)->getDetId() ).iLayer() + 1 )/2 ); - unsigned int targetSuperLayer = (unsigned int)(( StackedTrackerDetId( candidate->getDetId() ).iLayer() + 1 )/2 ); - - if ( seedSuperLayer == targetSuperLayer ) - return; - - /// Skip if the seed and the stub are in the same - /// SuperLayer in case of SL 3-4-5 - if ( seedSuperLayer > 2 && targetSuperLayer > 2 ) - return; - - unsigned int seedSL = ( seedSuperLayer > 2 ) ? 3 : seedSuperLayer; - unsigned int targSL = ( targetSuperLayer > 2 ) ? 3 : targetSuperLayer; - - /// Check that the candidate is NOT the one under examination - for ( unsigned int i = 0; i < theStubs.size(); i++ ) - { - if ( theStubs.at(i) == candidate ) - return; - } - - /// Get the track momentum and propagate it - GlobalVector curMomentum = seed.getMomentum(); - GlobalPoint curVertex = seed.getVertex(); - double curRInv = seed.getRInv(); - - /// Get the candidate Stub position - GlobalPoint candPos = TTTrackAlgorithm< Ref_PixelDigi_ >::theStackedTracker->findAverageGlobalPosition( candidate->getClusterPtr(0).get() ); - - /// Propagate - double propPsi = asin( candPos.perp() * 0.5 * curRInv ); - double propRhoPsi = 2 * propPsi / curRInv; - double propPhi = curMomentum.phi() - propPsi; - double propZ = curVertex.z() + propRhoPsi * tan( M_PI_2 - curMomentum.theta() ); - - /// Calculate displacement - /// Perform standard trigonometric operations - double deltaPhi = propPhi - candPos.phi(); - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - double deltaRPhi = fabs( deltaPhi * candPos.perp() ); - double deltaZ = fabs( propZ - candPos.z() ); - - /// First get the vector corresponding to the seed SL - /// Then get in this vector the entry corresponding to the targer SL - if ( deltaRPhi < (tableRPhi.at(seedSL)).at(targSL) && deltaZ < (tableZ.at(seedSL)).at(targSL) ) - //if ( deltaRPhi < 4 && deltaZ < 8 ) - { - seed.addStubPtr( candidate ); - } -} - diff --git a/L1Trigger/TrackTrigger/test/ValidateClusterStub.cc b/L1Trigger/TrackTrigger/test/AnalyzerClusterStub.cc similarity index 93% rename from L1Trigger/TrackTrigger/test/ValidateClusterStub.cc rename to L1Trigger/TrackTrigger/test/AnalyzerClusterStub.cc index e3896d50cc576..6d94e30d5afc0 100644 --- a/L1Trigger/TrackTrigger/test/ValidateClusterStub.cc +++ b/L1Trigger/TrackTrigger/test/AnalyzerClusterStub.cc @@ -31,13 +31,13 @@ #include #include -class ValidateClusterStub : public edm::EDAnalyzer +class AnalyzerClusterStub : public edm::EDAnalyzer { /// Public methods public: /// Constructor/destructor - explicit ValidateClusterStub(const edm::ParameterSet& iConfig); - virtual ~ValidateClusterStub(); + explicit AnalyzerClusterStub(const edm::ParameterSet& iConfig); + virtual ~AnalyzerClusterStub(); // Typical methods used on Loops over events virtual void beginJob(); virtual void endJob(); @@ -182,7 +182,7 @@ class ValidateClusterStub : public edm::EDAnalyzer ////////////// // CONSTRUCTOR -ValidateClusterStub::ValidateClusterStub(edm::ParameterSet const& iConfig) : +AnalyzerClusterStub::AnalyzerClusterStub(edm::ParameterSet const& iConfig) : config(iConfig) { /// Insert here what you need to initialize @@ -191,7 +191,7 @@ ValidateClusterStub::ValidateClusterStub(edm::ParameterSet const& iConfig) : ///////////// // DESTRUCTOR -ValidateClusterStub::~ValidateClusterStub() +AnalyzerClusterStub::~AnalyzerClusterStub() { /// Insert here what you need to delete /// when you close the class instance @@ -199,16 +199,16 @@ ValidateClusterStub::~ValidateClusterStub() ////////// // END JOB -void ValidateClusterStub::endJob()//edm::Run& run, const edm::EventSetup& iSetup +void AnalyzerClusterStub::endJob()//edm::Run& run, const edm::EventSetup& iSetup { /// Things to be done at the exit of the event Loop - std::cerr << " ValidateClusterStub::endJob" << std::endl; + std::cerr << " AnalyzerClusterStub::endJob" << std::endl; /// End of things to be done at the exit from the event Loop } //////////// // BEGIN JOB -void ValidateClusterStub::beginJob() +void AnalyzerClusterStub::beginJob() { /// Initialize all slave variables /// mainly histogram ranges and resolution @@ -218,7 +218,7 @@ void ValidateClusterStub::beginJob() std::ostringstream histoTitle; /// Things to be done before entering the event Loop - std::cerr << " ValidateClusterStub::beginJob" << std::endl; + std::cerr << " AnalyzerClusterStub::beginJob" << std::endl; /// Book histograms etc edm::Service fs; @@ -609,7 +609,7 @@ void ValidateClusterStub::beginJob() ////////// // ANALYZE -void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +void AnalyzerClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { /// Geometry handles etc edm::ESHandle< TrackerGeometry > GeometryHandle; @@ -638,18 +638,19 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingVertexHandle ); /// Track Trigger - edm::Handle< std::vector< TTCluster< Ref_PixelDigi_ > > > PixelDigiTTClusterHandle; - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > PixelDigiTTStubHandle; - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > PixelDigiTTFailedStubHandle; - iEvent.getByLabel( "TTClustersFromPixelDigis", PixelDigiTTClusterHandle ); - iEvent.getByLabel( "TTStubsFromPixelDigis", "StubsPass", PixelDigiTTStubHandle ); - iEvent.getByLabel( "TTStubsFromPixelDigis", "StubsFail", PixelDigiTTFailedStubHandle ); + edm::Handle< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > > PixelDigiTTClusterHandle; + edm::Handle< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > > PixelDigiTTClusterInclusiveHandle; + edm::Handle< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > > > PixelDigiTTStubHandle; + /// NOTE: the InputTag for the "Accepted" clusters is different from the "Inclusive" one + iEvent.getByLabel( "TTStubsFromPixelDigis", "ClusterAccepted", PixelDigiTTClusterHandle ); + iEvent.getByLabel( "TTClustersFromPixelDigis", "ClusterInclusive", PixelDigiTTClusterInclusiveHandle ); + iEvent.getByLabel( "TTStubsFromPixelDigis", "StubAccepted", PixelDigiTTStubHandle ); /// Track Trigger MC Truth edm::Handle< TTClusterAssociationMap< Ref_PixelDigi_ > > MCTruthTTClusterHandle; edm::Handle< TTStubAssociationMap< Ref_PixelDigi_ > > MCTruthTTStubHandle; - iEvent.getByLabel( "TTClusterAssociatorFromPixelDigis", MCTruthTTClusterHandle ); - iEvent.getByLabel( "TTStubAssociatorFromPixelDigis", MCTruthTTStubHandle ); + iEvent.getByLabel( "TTClusterAssociatorFromPixelDigis", "ClusterAccepted", MCTruthTTClusterHandle ); + iEvent.getByLabel( "TTStubAssociatorFromPixelDigis", "StubAccepted", MCTruthTTStubHandle ); //////////////////////////////// /// COLLECT STUB INFORMATION /// @@ -670,7 +671,7 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu edm::Ptr< TrackingParticle > tempTPPtr( TrackingParticleHandle, tpCnt++ ); /// Search the cluster MC map - std::vector< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > theseClusters = MCTruthTTClusterHandle->findTTClusterPtrs( tempTPPtr ); + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > theseClusters = MCTruthTTClusterHandle->findTTClusterRefs( tempTPPtr ); if ( theseClusters.size() > 0 ) { @@ -734,7 +735,7 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu } /// Search the stub MC truth map - std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > theseStubs = MCTruthTTStubHandle->findTTStubPtrs( tempTPPtr ); + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > > theseStubs = MCTruthTTStubHandle->findTTStubRefs( tempTPPtr ); if ( tempTPPtr->p4().pt() <= 10 ) continue; @@ -788,32 +789,33 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu std::map< unsigned int, std::vector< edm::Ptr< TrackingParticle > > > tpPerLayer; std::map< unsigned int, std::vector< edm::Ptr< TrackingParticle > > > tpPerDisk; - /// Go on only if there are TTCluster from PixelDigis - if ( PixelDigiTTClusterHandle->size() > 0 ) + /// Loop over the input Clusters + typename edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >::const_iterator inputIter; + typename edmNew::DetSet< TTCluster< Ref_PixelDigi_ > >::const_iterator contentIter; + for ( inputIter = PixelDigiTTClusterHandle->begin(); + inputIter != PixelDigiTTClusterHandle->end(); + ++inputIter ) { - /// Loop over TTClusters - unsigned int cluCnt = 0; - std::vector< TTCluster< Ref_PixelDigi_ > >::const_iterator iterTTCluster; - for ( iterTTCluster = PixelDigiTTClusterHandle->begin(); - iterTTCluster != PixelDigiTTClusterHandle->end(); - ++iterTTCluster ) + for ( contentIter = inputIter->begin(); + contentIter != inputIter->end(); + ++contentIter ) { - /// Make the pointer - edm::Ptr< TTCluster< Ref_PixelDigi_ > > tempCluPtr( PixelDigiTTClusterHandle, cluCnt++ ); - - StackedTrackerDetId detIdClu( tempCluPtr->getDetId() ); - unsigned int memberClu = tempCluPtr->getStackMember(); - bool genuineClu = MCTruthTTClusterHandle->isGenuine( tempCluPtr ); - bool combinClu = MCTruthTTClusterHandle->isCombinatoric( tempCluPtr ); - //bool unknownClu = MCTruthTTClusterHandle->isUnknown( tempCluPtr ); + /// Make the reference to be put in the map + edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > tempCluRef = edmNew::makeRefTo( PixelDigiTTClusterHandle, contentIter ); + + StackedTrackerDetId detIdClu( tempCluRef->getDetId() ); + unsigned int memberClu = tempCluRef->getStackMember(); + bool genuineClu = MCTruthTTClusterHandle->isGenuine( tempCluRef ); + bool combinClu = MCTruthTTClusterHandle->isCombinatoric( tempCluRef ); + //bool unknownClu = MCTruthTTClusterHandle->isUnknown( tempCluRef ); int partClu = 999999999; if ( genuineClu ) { - edm::Ptr< TrackingParticle > thisTP = MCTruthTTClusterHandle->findTrackingParticlePtr( tempCluPtr ); + edm::Ptr< TrackingParticle > thisTP = MCTruthTTClusterHandle->findTrackingParticlePtr( tempCluRef ); partClu = thisTP->pdgId(); } - unsigned int widClu = tempCluPtr->findWidth(); - GlobalPoint posClu = theStackedGeometry->findAverageGlobalPosition( &(*tempCluPtr) ); + unsigned int widClu = tempCluRef->findWidth(); + GlobalPoint posClu = theStackedGeometry->findAverageGlobalPosition( &(*tempCluRef) ); hCluster_RZ->Fill( posClu.z(), posClu.perp() ); @@ -900,7 +902,7 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu /// Store Track information in maps, skip if the Cluster is not good if ( !genuineClu && !combinClu ) continue; - std::vector< edm::Ptr< TrackingParticle > > theseTPs = MCTruthTTClusterHandle->findTrackingParticlePtrs( tempCluPtr ); + std::vector< edm::Ptr< TrackingParticle > > theseTPs = MCTruthTTClusterHandle->findTrackingParticlePtrs( tempCluRef ); for ( unsigned int i = 0; i < theseTPs.size(); i++ ) { @@ -933,8 +935,8 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu tpPerDisk[detIdClu.iDisk()].push_back( tpPtr ); } } - } /// End of Loop over TTClusters - } /// End of if ( PixelDigiTTClusterHandle->size() > 0 ) + } + } /// End of Loop over TTClusters /// Clean the maps for TrackingParticles and fill histograms std::map< unsigned int, std::vector< edm::Ptr< TrackingParticle > > >::iterator iterTPPerLayer; @@ -998,33 +1000,34 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu std::map< unsigned int, std::vector< edm::Ptr< TrackingParticle > > > tpPerStubLayer; std::map< unsigned int, std::vector< edm::Ptr< TrackingParticle > > > tpPerStubDisk; - /// Go on only if there are TTStub from PixelDigis - if ( PixelDigiTTStubHandle->size() > 0 ) + /// Loop over the input Stubs + typename edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >::const_iterator otherInputIter; + typename edmNew::DetSet< TTStub< Ref_PixelDigi_ > >::const_iterator otherContentIter; + for ( otherInputIter = PixelDigiTTStubHandle->begin(); + otherInputIter != PixelDigiTTStubHandle->end(); + ++otherInputIter ) { - /// Loop over TTStubs - unsigned int cntStub = 0; - std::vector< TTStub< Ref_PixelDigi_ > >::const_iterator iterTTStub; - for ( iterTTStub = PixelDigiTTStubHandle->begin(); - iterTTStub != PixelDigiTTStubHandle->end(); - ++iterTTStub ) + for ( otherContentIter = otherInputIter->begin(); + otherContentIter != otherInputIter->end(); + ++otherContentIter ) { - /// Make the pointer - edm::Ptr< TTStub< Ref_PixelDigi_ > > tempStubPtr( PixelDigiTTStubHandle, cntStub++ ); + /// Make the reference to be put in the map + edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > tempStubRef = edmNew::makeRefTo( PixelDigiTTStubHandle, otherContentIter ); - StackedTrackerDetId detIdStub( tempStubPtr->getDetId() ); + StackedTrackerDetId detIdStub( tempStubRef->getDetId() ); - bool genuineStub = MCTruthTTStubHandle->isGenuine( tempStubPtr ); - bool combinStub = MCTruthTTStubHandle->isCombinatoric( tempStubPtr ); - //bool unknownStub = MCTruthTTStubHandle->isUnknown( tempStubPtr ); + bool genuineStub = MCTruthTTStubHandle->isGenuine( tempStubRef ); + bool combinStub = MCTruthTTStubHandle->isCombinatoric( tempStubRef ); + //bool unknownStub = MCTruthTTStubHandle->isUnknown( tempStubRef ); int partStub = 999999999; if ( genuineStub ) { - edm::Ptr< TrackingParticle > thisTP = MCTruthTTStubHandle->findTrackingParticlePtr( tempStubPtr ); + edm::Ptr< TrackingParticle > thisTP = MCTruthTTStubHandle->findTrackingParticlePtr( tempStubRef ); partStub = thisTP->pdgId(); } - double displStub = tempStubPtr->getTriggerDisplacement(); - double offsetStub = tempStubPtr->getTriggerOffset(); - GlobalPoint posStub = theStackedGeometry->findGlobalPosition( &(*tempStubPtr) ); + double displStub = tempStubRef->getTriggerDisplacement(); + double offsetStub = tempStubRef->getTriggerOffset(); + GlobalPoint posStub = theStackedGeometry->findGlobalPosition( &(*tempStubRef) ); hStub_RZ->Fill( posStub.z(), posStub.perp() ); @@ -1096,7 +1099,7 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu /// Store Track information in maps, skip if the Cluster is not good if ( !genuineStub ) continue; - edm::Ptr< TrackingParticle > tpPtr = MCTruthTTStubHandle->findTrackingParticlePtr( tempStubPtr ); + edm::Ptr< TrackingParticle > tpPtr = MCTruthTTStubHandle->findTrackingParticlePtr( tempStubRef ); /// Get the corresponding vertex and reject the track /// if its vertex is outside the beampipe @@ -1136,9 +1139,9 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu double simPt = thisTP.p4().pt(); double simEta = thisTP.momentum().eta(); double simPhi = thisTP.momentum().phi(); - double recPt = theStackedGeometry->findRoughPt( mMagneticFieldStrength, &(*tempStubPtr) ); - double recEta = theStackedGeometry->findGlobalDirection( &(*tempStubPtr) ).eta(); - double recPhi = theStackedGeometry->findGlobalDirection( &(*tempStubPtr) ).phi(); + double recPt = theStackedGeometry->findRoughPt( mMagneticFieldStrength, &(*tempStubRef) ); + double recEta = theStackedGeometry->findGlobalDirection( &(*tempStubRef) ).eta(); + double recPhi = theStackedGeometry->findGlobalDirection( &(*tempStubRef) ).phi(); if ( simPhi > M_PI ) { @@ -1179,8 +1182,8 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu mapStubDisk_hStub_W_TPart_Pt[ detIdStub.iDisk() ]->Fill( simPt, displStub - offsetStub ); mapStubDisk_hStub_W_TPart_InvPt[ detIdStub.iDisk() ]->Fill( 1./simPt, displStub - offsetStub ); } - } /// End of loop over TTStubs - } /// End of if ( PixelDigiTTStubHandle->size() > 0 ) + } + } /// End of loop over TTStubs /// Clean the maps for TrackingParticles and fill histograms std::map< unsigned int, std::vector< edm::Ptr< TrackingParticle > > >::iterator iterTPPerStubLayer; @@ -1278,5 +1281,5 @@ void ValidateClusterStub::analyze(const edm::Event& iEvent, const edm::EventSetu /////////////////////////// // DEFINE THIS AS A PLUG-IN -DEFINE_FWK_MODULE(ValidateClusterStub); +DEFINE_FWK_MODULE(AnalyzerClusterStub); diff --git a/L1Trigger/TrackTrigger/test/ValidateClusterStub_ExtendedPhase2TkBE5D_cfg.py b/L1Trigger/TrackTrigger/test/AnalyzerClusterStub_ExtendedPhase2TkBE5D_cfg.py similarity index 88% rename from L1Trigger/TrackTrigger/test/ValidateClusterStub_ExtendedPhase2TkBE5D_cfg.py rename to L1Trigger/TrackTrigger/test/AnalyzerClusterStub_ExtendedPhase2TkBE5D_cfg.py index 9b685881076cf..ee32cefcd2061 100644 --- a/L1Trigger/TrackTrigger/test/ValidateClusterStub_ExtendedPhase2TkBE5D_cfg.py +++ b/L1Trigger/TrackTrigger/test/AnalyzerClusterStub_ExtendedPhase2TkBE5D_cfg.py @@ -14,7 +14,7 @@ ################################################################################################# import FWCore.ParameterSet.Config as cms #--------------import os -process = cms.Process('ValidateClusterStub') +process = cms.Process('AnalyzerClusterStub') ################################################################################################# # global tag @@ -42,7 +42,7 @@ ################################################################################################# process.source = cms.Source("PoolSource", secondaryFileNames = cms.untracked.vstring(), - fileNames = cms.untracked.vstring('file:TenElePt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') + fileNames = cms.untracked.vstring('file:TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') # fileNames = cms.untracked.vstring('file:TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO_140PU.root') # fileNames = cms.untracked.vstring('file:test.root') @@ -64,7 +64,7 @@ ################################################################################################# # load the analyzer ################################################################################################# -process.ValidateClusterStub = cms.EDAnalyzer("ValidateClusterStub", +process.AnalyzerClusterStub = cms.EDAnalyzer("AnalyzerClusterStub", DebugMode = cms.bool(True) ) @@ -72,16 +72,16 @@ # define output file and message logger ################################################################################################# process.TFileService = cms.Service("TFileService", -# fileName = cms.string('file:ValidateClusterStub_ExtendedPhase2TkBE5D_MuonPU140.root') -# fileName = cms.string('file:ValidateClusterStub_ExtendedPhase2TkBE5D_Pion.root') - fileName = cms.string('file:ValidateClusterStub_ExtendedPhase2TkBE5D_Ele.root') -# fileName = cms.string('file:ValidateClusterStub_ExtendedPhase2TkBE5D_DYTauTau.root') +# fileName = cms.string('file:AnalyzerClusterStub_ExtendedPhase2TkBE5D_MuonPU140.root') +# fileName = cms.string('file:AnalyzerClusterStub_ExtendedPhase2TkBE5D_Pion.root') + fileName = cms.string('file:AnalyzerClusterStub_ExtendedPhase2TkBE5D_Muon.root') +# fileName = cms.string('file:AnalyzerClusterStub_ExtendedPhase2TkBE5D_DYTauTau.root') ) ################################################################################################# # define the final path to be fed to cmsRun ################################################################################################# -process.p = cms.Path( process.ValidateClusterStub ) +process.p = cms.Path( process.AnalyzerClusterStub ) diff --git a/L1Trigger/TrackTrigger/test/AnalyzerL1Track.cc b/L1Trigger/TrackTrigger/test/AnalyzerL1Track.cc new file mode 100644 index 0000000000000..5cd72757dd8d5 --- /dev/null +++ b/L1Trigger/TrackTrigger/test/AnalyzerL1Track.cc @@ -0,0 +1,729 @@ +/*! \brief Checklist + * \details TTTracks + * + * \author Nicola Pozzobon + * \author Anders Ryd + * \author Louise Skinnari + * \author David Sweigart + * \date 2013, Jul 22 + * + */ + +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/PluginManager/interface/ModuleDef.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" +#include "MagneticField/Engine/interface/MagneticField.h" +#include "Geometry/Records/interface/StackedTrackerGeometryRecord.h" +#include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h" +#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" +#include "Geometry/CommonTopologies/interface/Topology.h" +#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" +#include "Geometry/CommonTopologies/interface/PixelTopology.h" +#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" +#include "DataFormats/L1TrackTrigger/interface/TTCluster.h" +#include "DataFormats/L1TrackTrigger/interface/TTStub.h" +#include "DataFormats/L1TrackTrigger/interface/TTTrack.h" +#include "SimDataFormats/Vertex/interface/SimVertexContainer.h" +#include "SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h" +#include "SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h" +#include "SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" +#include "SimDataFormats/TrackingAnalysis/interface/TrackingVertex.h" +#include "CommonTools/UtilAlgos/interface/TFileService.h" +#include +#include + +class AnalyzerL1Track : public edm::EDAnalyzer +{ + /// Public methods + public: + /// Constructor/destructor + explicit AnalyzerL1Track(const edm::ParameterSet& iConfig); + virtual ~AnalyzerL1Track(); + // Typical methods used on Loops over events + virtual void beginJob(); + virtual void endJob(); + virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); + + /// Private methods and variables + private: + TH2D* hTrack_NStubs_Sector; + TH2D* hTrack_NStubs_Wedge; + TH2D* hTrack_Sector_Phi; + TH2D* hTrack_Wedge_Eta; + + TH1D* hTrack_3Stubs_Pt; + TH1D* hTrack_3Stubs_Phi; + TH1D* hTrack_3Stubs_Eta; + + TH1D* hTrack_2Stubs_Pt; + TH1D* hTrack_2Stubs_Phi; + TH1D* hTrack_2Stubs_Eta; + + TH1D* hTPart_Track_3Stubs_Pt; + TH1D* hTPart_Track_3Stubs_Phi_Pt5; + TH1D* hTPart_Track_3Stubs_Eta_Pt5; + + TH1D* hTPart_Track_2Stubs_Pt; + TH1D* hTPart_Track_2Stubs_Phi_Pt5; + TH1D* hTPart_Track_2Stubs_Eta_Pt5; + + TH1D* hTPart_Cluster_Pt; + TH1D* hTPart_Cluster_Phi_Pt5; + TH1D* hTPart_Cluster_Eta_Pt5; + + TH1D* hTPart_Stub_Pt; + TH1D* hTPart_Stub_Phi_Pt5; + TH1D* hTPart_Stub_Eta_Pt5; + + TH1D* hTrack_3Stubs_N; + TH2D* hTrack_3Stubs_Pt_TPart_Pt; + TH2D* hTrack_3Stubs_PtRes_TPart_Eta; + TH2D* hTrack_3Stubs_InvPt_TPart_InvPt; + TH2D* hTrack_3Stubs_InvPtRes_TPart_Eta; + TH2D* hTrack_3Stubs_Phi_TPart_Phi; + TH2D* hTrack_3Stubs_PhiRes_TPart_Eta; + TH2D* hTrack_3Stubs_Eta_TPart_Eta; + TH2D* hTrack_3Stubs_EtaRes_TPart_Eta; + TH2D* hTrack_3Stubs_VtxZ0_TPart_VtxZ0; + TH2D* hTrack_3Stubs_VtxZ0Res_TPart_Eta; + TH2D* hTrack_3Stubs_Chi2_NStubs; + TH2D* hTrack_3Stubs_Chi2_TPart_Eta; + TH2D* hTrack_3Stubs_Chi2Red_NStubs; + TH2D* hTrack_3Stubs_Chi2Red_TPart_Eta; + + TH1D* hTPart_Eta_Normalization; + TH1D* hTPart_Eta_NStubs; + + unsigned int maxPtBin; + unsigned int maxEtaBin; + std::vector< double > vLimitsPt; + std::vector< std::string > vStringPt; + std::vector< double > vLimitsEta; + std::vector< std::string > vStringEta; + + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_Chi2_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_Chi2Red_PtEta; + + unsigned int maxPtBinRes; + unsigned int maxEtaBinRes; + double ptBinSize; + double etaBinSize; + + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_PtRes_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_InvPtRes_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_RelPtRes_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_PhiRes_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_EtaRes_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_CotThetaRes_PtEta; + std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_VtxZ0Res_PtEta; + + TH1D* hTrack_2Stubs_N; + TH2D* hTrack_2Stubs_Pt_TPart_Pt; + TH2D* hTrack_2Stubs_PtRes_TPart_Eta; + TH2D* hTrack_2Stubs_InvPt_TPart_InvPt; + TH2D* hTrack_2Stubs_InvPtRes_TPart_Eta; + TH2D* hTrack_2Stubs_Phi_TPart_Phi; + TH2D* hTrack_2Stubs_PhiRes_TPart_Eta; + TH2D* hTrack_2Stubs_Eta_TPart_Eta; + TH2D* hTrack_2Stubs_EtaRes_TPart_Eta; + TH2D* hTrack_2Stubs_VtxZ0_TPart_VtxZ0; + TH2D* hTrack_2Stubs_VtxZ0Res_TPart_Eta; + TH2D* hTrack_2Stubs_Chi2_NStubs; + TH2D* hTrack_2Stubs_Chi2_TPart_Eta; + TH2D* hTrack_2Stubs_Chi2Red_NStubs; + TH2D* hTrack_2Stubs_Chi2Red_TPart_Eta; + + edm::InputTag tagTTClusters; + edm::InputTag tagTTClusterMCTruth; + edm::InputTag tagTTStubs; + edm::InputTag tagTTStubMCTruth; + edm::InputTag tagTTTracks; + edm::InputTag tagTTTrackMCTruth; +}; + +////////////////////////////////// +// // +// CLASS IMPLEMENTATION // +// // +////////////////////////////////// + +////////////// +// CONSTRUCTOR +AnalyzerL1Track::AnalyzerL1Track(edm::ParameterSet const& iConfig) +{ + /// Insert here what you need to initialize + vLimitsPt = iConfig.getParameter< std::vector< double > >("vLimitsPt"); + vLimitsEta = iConfig.getParameter< std::vector< double > >("vLimitsEta"); + vStringPt = iConfig.getParameter< std::vector< std::string > >("vStringPt"); + vStringEta = iConfig.getParameter< std::vector< std::string > >("vStringEta"); + + if ( vLimitsPt.size() != vStringPt.size() ) + { + exit(0); + } + else + { + maxPtBin = vLimitsPt.size(); + } + + if ( vLimitsEta.size() != vStringEta.size() ) + { + exit(0); + } + else + { + maxEtaBin = vLimitsEta.size(); + } + + maxPtBinRes = iConfig.getParameter< unsigned int >("maxPtBinRes"); + maxEtaBinRes = iConfig.getParameter< unsigned int >("maxEtaBinRes"); + ptBinSize = iConfig.getParameter< double >("ptBinSize"); + etaBinSize = iConfig.getParameter< double >("etaBinSize"); + + if ( maxPtBinRes == 0 || maxEtaBinRes == 0 ) + exit(0); + + tagTTClusters = iConfig.getParameter< edm::InputTag >("TTClusters"); + tagTTClusterMCTruth = iConfig.getParameter< edm::InputTag >("TTClusterMCTruth"); + tagTTStubs = iConfig.getParameter< edm::InputTag >("TTStubs"); + tagTTStubMCTruth = iConfig.getParameter< edm::InputTag >("TTStubMCTruth"); + tagTTTracks = iConfig.getParameter< edm::InputTag >("TTTracks"); + tagTTTrackMCTruth = iConfig.getParameter< edm::InputTag >("TTTrackMCTruth"); +} + +///////////// +// DESTRUCTOR +AnalyzerL1Track::~AnalyzerL1Track() +{ + /// Insert here what you need to delete + /// when you close the class instance +} + +////////// +// END JOB +void AnalyzerL1Track::endJob() +{ + /// Things to be done at the exit of the event Loop + std::cerr << " AnalyzerL1Track::endJob" << std::endl; + /// End of things to be done at the exit from the event Loop +} + +//////////// +// BEGIN JOB +void AnalyzerL1Track::beginJob() +{ + /// Initialize all slave variables + /// mainly histogram ranges and resolution + std::ostringstream histoName; + std::ostringstream histoTitle; + + /// Things to be done before entering the event Loop + std::cerr << " AnalyzerL1Track::beginJob" << std::endl; + + /// Book histograms etc + edm::Service fs; + + /// Prepare for LogXY Plots + int NumBins = 200; + double MinPt = 0.0; + double MaxPt = 100.0; + + double* BinVec = new double[NumBins+1]; + for ( int iBin = 0; iBin < NumBins + 1; iBin++ ) + { + double temp = pow( 10, (- NumBins + iBin)/(MaxPt - MinPt) ); + BinVec[ iBin ] = temp; + } + + hTrack_NStubs_Sector = fs->make( "hTrack_NStubs_Sector", "TTTrack number of Stubs vs. #phi sector", 35, -0.5, 34.5, 20, -0.5, 19.5 ); + hTrack_NStubs_Wedge = fs->make( "hTrack_NStubs_Wedge", "TTTrack number of Stubs vs. #eta wedge", 35, -0.5, 34.5, 20, -0.5, 19.5 ); + hTrack_Sector_Phi = fs->make( "hTrack_Sector_Phi", "#phi sector vs. TTTrack #phi", 180, -M_PI, M_PI, 35, -0.5, 34.5 ); + hTrack_Wedge_Eta = fs->make( "hTrack_Wedge_Eta", "#eta wedge vs. TTTrack #eta", 180, -M_PI, M_PI, 35, -0.5, 34.5 ); + + hTrack_NStubs_Sector->Sumw2(); + hTrack_NStubs_Wedge->Sumw2(); + hTrack_Sector_Phi->Sumw2(); + hTrack_Wedge_Eta->Sumw2(); + + hTrack_3Stubs_Pt = fs->make( "hTrack_3Stubs_Pt", "TTTrack 3Stubs p_{T}", 100, 0, 50 ); + hTrack_3Stubs_Phi = fs->make( "hTrack_3Stubs_Phi", "TTTrack 3Stubs #phi", 180, -M_PI, M_PI ); + hTrack_3Stubs_Eta = fs->make( "hTrack_3Stubs_Eta", "TTTrack 3Stubs #eta", 180, -M_PI, M_PI ); + hTrack_3Stubs_Pt->Sumw2(); + hTrack_3Stubs_Phi->Sumw2(); + hTrack_3Stubs_Eta->Sumw2(); + + hTrack_2Stubs_Pt = fs->make( "hTrack_2Stubs_Pt", "TTTrack 2Stubs p_{T}", 100, 0, 50 ); + hTrack_2Stubs_Phi = fs->make( "hTrack_2Stubs_Phi", "TTTrack 2Stubs #phi", 180, -M_PI, M_PI ); + hTrack_2Stubs_Eta = fs->make( "hTrack_2Stubs_Eta", "TTTrack 2Stubs #eta", 180, -M_PI, M_PI ); + hTrack_2Stubs_Pt->Sumw2(); + hTrack_2Stubs_Phi->Sumw2(); + hTrack_2Stubs_Eta->Sumw2(); + + hTPart_Track_3Stubs_Pt = fs->make( "hTPart_Track_3Stubs_Pt", "TTTrack 3Stubs TPart p_{T}", 100, 0, 50 ); + hTPart_Track_3Stubs_Phi_Pt5 = fs->make( "hTPart_Track_3Stubs_Phi_Pt5", "TTTrack 3Stubs TPart #phi", 180, -M_PI, M_PI ); + hTPart_Track_3Stubs_Eta_Pt5 = fs->make( "hTPart_Track_3Stubs_Eta_Pt5", "TTTrack 3Stubs TPart #eta", 180, -M_PI, M_PI ); + hTPart_Track_3Stubs_Pt->Sumw2(); + hTPart_Track_3Stubs_Phi_Pt5->Sumw2(); + hTPart_Track_3Stubs_Eta_Pt5->Sumw2(); + + hTPart_Track_2Stubs_Pt = fs->make( "hTPart_Track_2Stubs_Pt", "TTTrack 2Stubs TPart p_{T}", 100, 0, 50 ); + hTPart_Track_2Stubs_Phi_Pt5 = fs->make( "hTPart_Track_2Stubs_Phi_Pt5", "TTTrack 2Stubs TPart #phi", 180, -M_PI, M_PI ); + hTPart_Track_2Stubs_Eta_Pt5 = fs->make( "hTPart_Track_2Stubs_Eta_Pt5", "TTTrack 2Stubs TPart #eta", 180, -M_PI, M_PI ); + hTPart_Track_2Stubs_Pt->Sumw2(); + hTPart_Track_2Stubs_Phi_Pt5->Sumw2(); + hTPart_Track_2Stubs_Eta_Pt5->Sumw2(); + + hTPart_Cluster_Pt = fs->make( "hTPart_Cluster_Pt", "Cluster TPart p_{T}", 100, 0, 50 ); + hTPart_Cluster_Phi_Pt5 = fs->make( "hTPart_Cluster_Phi_Pt5", "Cluster TPart #phi", 180, -M_PI, M_PI ); + hTPart_Cluster_Eta_Pt5 = fs->make( "hTPart_Cluster_Eta_Pt5", "Cluster TPart #eta", 180, -M_PI, M_PI ); + hTPart_Cluster_Pt->Sumw2(); + hTPart_Cluster_Phi_Pt5->Sumw2(); + hTPart_Cluster_Eta_Pt5->Sumw2(); + + hTPart_Stub_Pt = fs->make( "hTPart_Stub_Pt", "Stub TPart p_{T}", 100, 0, 50 ); + hTPart_Stub_Phi_Pt5 = fs->make( "hTPart_Stub_Phi_Pt5", "Stub TPart #phi", 180, -M_PI, M_PI ); + hTPart_Stub_Eta_Pt5 = fs->make( "hTPart_Stub_Eta_Pt5", "Stub TPart #eta", 180, -M_PI, M_PI ); + hTPart_Stub_Pt->Sumw2(); + hTPart_Stub_Phi_Pt5->Sumw2(); + hTPart_Stub_Eta_Pt5->Sumw2(); + + hTrack_3Stubs_N = fs->make( "hTrack_3Stubs_N", "Number of TTTrack 3Stubs", 100, -0.5, 99.5 ); + hTrack_3Stubs_Pt_TPart_Pt = fs->make( "hTrack_3Stubs_Pt_TPart_Pt", "TTTrack 3Stubs p_{T} vs. TPart p_{T}", 100, 0, 50, 100, 0, 50 ); + hTrack_3Stubs_PtRes_TPart_Eta = fs->make( "hTrack_3Stubs_PtRes_TPart_Eta", "TTTrack 3Stubs p_{T} - TPart p_{T} vs. TPart #eta", 180, -M_PI, M_PI, 200, -4.0, 4.0 ); + hTrack_3Stubs_InvPt_TPart_InvPt = fs->make( "hTrack_3Stubs_InvPt_TPart_InvPt", "TTTrack 3Stubs p_{T}^{-1} vs. TPart p_{T}^{-1}", 200, 0, 0.8, 200, 0, 0.8 ); + hTrack_3Stubs_InvPt_TPart_InvPt->GetXaxis()->Set( NumBins, BinVec ); + hTrack_3Stubs_InvPt_TPart_InvPt->GetYaxis()->Set( NumBins, BinVec ); + hTrack_3Stubs_InvPtRes_TPart_Eta = fs->make( "hTrack_3Stubs_InvPtRes_TPart_Eta", "TTTrack 3Stubs p_{T}^{-1} - TPart p_{T}^{-1} vs. TPart #eta", 180, -M_PI, M_PI, 100, -1.0, 1.0 ); + hTrack_3Stubs_Phi_TPart_Phi = fs->make( "hTrack_3Stubs_Phi_TPart_Phi", "TTTrack 3Stubs #phi vs. TPart #phi", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); + hTrack_3Stubs_PhiRes_TPart_Eta = fs->make( "hTrack_3Stubs_PhiRes_TPart_Eta", "TTTrack 3Stubs #phi - TPart #phi vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); + hTrack_3Stubs_Eta_TPart_Eta = fs->make( "hTrack_3Stubs_Eta_TPart_Eta", "TTTrack 3Stubs #eta vs. TPart #eta", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); + hTrack_3Stubs_EtaRes_TPart_Eta = fs->make( "hTrack_3Stubs_EtaRes_TPart_Eta", "TTTrack 3Stubs #eta - TPart #eta vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); + hTrack_3Stubs_VtxZ0_TPart_VtxZ0 = fs->make( "hTrack_3Stubs_VtxZ0_TPart_VtxZ0", "TTTrack 3Stubs z_{vtx} vs. TPart z_{vtx}", 180, -30, 30, 180, -30, 30 ); + hTrack_3Stubs_VtxZ0Res_TPart_Eta = fs->make( "hTrack_3Stubs_VtxZ0Res_TPart_Eta", "TTTrack 3Stubs z_{vtx} - TPart z_{vtx} vs. TPart #eta", 180, -M_PI, M_PI, 100, -5, 5 ); + hTrack_3Stubs_Chi2_NStubs = fs->make( "hTrack_3Stubs_Chi2_NStubs", "TTTrack 3Stubs #chi^{2} vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 50 ); + hTrack_3Stubs_Chi2_TPart_Eta = fs->make( "hTrack_3Stubs_Chi2_TPart_Eta", "TTTrack 3Stubs #chi^{2} vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 50 ); + hTrack_3Stubs_Chi2Red_NStubs = fs->make( "hTrack_3Stubs_Chi2Red_NStubs", "TTTrack 3Stubs #chi^{2}/dof vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 10 ); + hTrack_3Stubs_Chi2Red_TPart_Eta = fs->make( "hTrack_3Stubs_Chi2Red_TPart_Eta", "TTTrack 3Stubs #chi^{2}/dof vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 10 ); + hTrack_3Stubs_N->Sumw2(); + hTrack_3Stubs_Pt_TPart_Pt->Sumw2(); + hTrack_3Stubs_PtRes_TPart_Eta->Sumw2(); + hTrack_3Stubs_InvPt_TPart_InvPt->Sumw2(); + hTrack_3Stubs_InvPtRes_TPart_Eta->Sumw2(); + hTrack_3Stubs_Phi_TPart_Phi->Sumw2(); + hTrack_3Stubs_PhiRes_TPart_Eta->Sumw2(); + hTrack_3Stubs_Eta_TPart_Eta->Sumw2(); + hTrack_3Stubs_EtaRes_TPart_Eta->Sumw2(); + hTrack_3Stubs_VtxZ0_TPart_VtxZ0->Sumw2(); + hTrack_3Stubs_VtxZ0Res_TPart_Eta->Sumw2(); + hTrack_3Stubs_Chi2_NStubs->Sumw2(); + hTrack_3Stubs_Chi2_TPart_Eta->Sumw2(); + hTrack_3Stubs_Chi2Red_NStubs->Sumw2(); + hTrack_3Stubs_Chi2Red_TPart_Eta->Sumw2(); + + hTPart_Eta_Normalization = fs->make("hTPart_Eta_Normalization", "TParticles vs. TPart #eta", 90, 0, M_PI ); + hTPart_Eta_NStubs = fs->make("hTPart_Eta_NStubs" , "N Stubs vs. TPart #eta" , 90, 0, M_PI ); + hTPart_Eta_Normalization->Sumw2(); + hTPart_Eta_NStubs->Sumw2(); + + /// Prepare for 1D resolution plots + + for ( unsigned int iPt = 0; iPt < maxPtBin; iPt++ ) + { + for ( unsigned int iEta = 0; iEta < maxEtaBin; iEta++ ) + { + std::pair< unsigned int, unsigned int > mapKey = std::make_pair( iPt, iEta ); + + histoName.str(""); histoName << "hTrack_3Stubs_Chi2_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track 3Stubs #chi^{2}, " << vStringPt.at(iPt).c_str() << " " << vStringEta.at(iEta).c_str(); + mapTrack_3Stubs_Chi2_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 50, 0, 50 ); + mapTrack_3Stubs_Chi2_PtEta[ mapKey ]->Sumw2(); + + histoName.str(""); histoName << "hTrack_3Stubs_Chi2Red_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track 3Stubs #chi^{2}/dof, " << vStringPt.at(iPt).c_str() << " " << vStringEta.at(iEta).c_str(); + mapTrack_3Stubs_Chi2Red_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 50, 0, 10 ); + mapTrack_3Stubs_Chi2Red_PtEta[ mapKey ]->Sumw2(); + } + } + + double minPt = 0; + double minEta = 0; + for ( unsigned int iPt = 0; iPt < maxPtBinRes; iPt++ ) + { + minPt = ptBinSize * iPt; + for ( unsigned int iEta = 0; iEta < maxEtaBinRes; iEta++ ) + { + std::pair< unsigned int, unsigned int > mapKey = std::make_pair( iPt, iEta ); + + minEta = etaBinSize * iEta; + + histoName.str(""); histoName << "hTrack_3Stubs_PtRes_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track p_{T} - TPart p_{T}, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_PtRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -4, 4 ); + mapTrack_3Stubs_PtRes_PtEta[ mapKey ]->Sumw2(); + + histoName.str(""); histoName << "hTrack_3Stubs_InvPtRes_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track p_{T}^{-1} - TPart p_{T}^{-1}, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_InvPtRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -1, 1 ); + mapTrack_3Stubs_InvPtRes_PtEta[ mapKey ]->Sumw2(); + + histoName.str(""); histoName << "hTrack_3Stubs_RelPtRes_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track p_{T}/TPart p_{T} - 1, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_RelPtRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); + mapTrack_3Stubs_RelPtRes_PtEta[ mapKey ]->Sumw2(); + + histoName.str(""); histoName << "hTrack_3Stubs_PhiRes_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track #phi - TPart #phi, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_PhiRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); + mapTrack_3Stubs_PhiRes_PtEta[ mapKey ]->Sumw2(); + + histoName.str(""); histoName << "hTrack_3Stubs_EtaRes_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track #eta - TPart #eta, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_EtaRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); + mapTrack_3Stubs_EtaRes_PtEta[ mapKey ]->Sumw2(); + + histoName.str(""); histoName << "hTrack_3Stubs_CotThetaRes_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track cot(#theta) - TPart cot(#theta), p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_CotThetaRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); + mapTrack_3Stubs_CotThetaRes_PtEta[ mapKey ]->Sumw2(); + + + histoName.str(""); histoName << "hTrack_3Stubs_VtxZ0Res_Pt" << iPt << "_Eta" << iEta; + histoTitle.str(""); histoTitle << "Track z_{vtx} - TPart z_{vtx}, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << + "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; + mapTrack_3Stubs_VtxZ0Res_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); + mapTrack_3Stubs_VtxZ0Res_PtEta[ mapKey ]->Sumw2(); + } + } + + hTrack_2Stubs_N = fs->make( "hTrack_2Stubs_N", "Number of TTTrack 2Stubs", 100, -0.5, 99.5 ); + hTrack_2Stubs_Pt_TPart_Pt = fs->make( "hTrack_2Stubs_Pt_TPart_Pt", "TTTrack 2Stubs p_{T} vs. TPart p_{T}", 100, 0, 50, 100, 0, 50 ); + hTrack_2Stubs_PtRes_TPart_Eta = fs->make( "hTrack_2Stubs_PtRes_TPart_Eta", "TTTrack 2Stubs p_{T} - TPart p_{T} vs. TPart #eta", 180, -M_PI, M_PI, 200, -4.0, 4.0 ); + hTrack_2Stubs_InvPt_TPart_InvPt = fs->make( "hTrack_2Stubs_InvPt_TPart_InvPt", "TTTrack 2Stubs p_{T}^{-1} vs. TPart p_{T}^{-1}", 200, 0, 0.8, 200, 0, 0.8 ); + hTrack_2Stubs_InvPt_TPart_InvPt->GetXaxis()->Set( NumBins, BinVec ); + hTrack_2Stubs_InvPt_TPart_InvPt->GetYaxis()->Set( NumBins, BinVec ); + hTrack_2Stubs_InvPtRes_TPart_Eta = fs->make( "hTrack_2Stubs_InvPtRes_TPart_Eta", "TTTrack 2Stubs p_{T}^{-1} - TPart p_{T}^{-1} vs. TPart #eta", 180, -M_PI, M_PI, 100, -1.0, 1.0 ); + hTrack_2Stubs_Phi_TPart_Phi = fs->make( "hTrack_2Stubs_Phi_TPart_Phi", "TTTrack 2Stubs #phi vs. TPart #phi", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); + hTrack_2Stubs_PhiRes_TPart_Eta = fs->make( "hTrack_2Stubs_PhiRes_TPart_Eta", "TTTrack 2Stubs #phi - TPart #phi vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); + hTrack_2Stubs_Eta_TPart_Eta = fs->make( "hTrack_2Stubs_Eta_TPart_Eta", "TTTrack 2Stubs #eta vs. TPart #eta", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); + hTrack_2Stubs_EtaRes_TPart_Eta = fs->make( "hTrack_2Stubs_EtaRes_TPart_Eta", "TTTrack 2Stubs #eta - TPart #eta vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); + hTrack_2Stubs_VtxZ0_TPart_VtxZ0 = fs->make( "hTrack_2Stubs_VtxZ0_TPart_VtxZ0", "TTTrack 2Stubs z_{vtx} vs. TPart z_{vtx}", 180, -30, 30, 180, -30, 30 ); + hTrack_2Stubs_VtxZ0Res_TPart_Eta = fs->make( "hTrack_2Stubs_VtxZ0Res_TPart_Eta", "TTTrack 2Stubs z_{vtx} - TPart z_{vtx} vs. TPart #eta", 180, -M_PI, M_PI, 100, -5, 5 ); + hTrack_2Stubs_Chi2_NStubs = fs->make( "hTrack_2Stubs_Chi2_NStubs", "TTTrack 2Stubs #chi^{2} vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 50 ); + hTrack_2Stubs_Chi2_TPart_Eta = fs->make( "hTrack_2Stubs_Chi2_TPart_Eta", "TTTrack 2Stubs #chi^{2} vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 50 ); + hTrack_2Stubs_Chi2Red_NStubs = fs->make( "hTrack_2Stubs_Chi2Red_NStubs", "TTTrack 2Stubs #chi^{2}/dof vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 10 ); + hTrack_2Stubs_Chi2Red_TPart_Eta = fs->make( "hTrack_2Stubs_Chi2Red_TPart_Eta", "TTTrack 2Stubs #chi^{2}/dof vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 10 ); + + hTrack_2Stubs_N->Sumw2(); + hTrack_2Stubs_Pt_TPart_Pt->Sumw2(); + hTrack_2Stubs_PtRes_TPart_Eta->Sumw2(); + hTrack_2Stubs_InvPt_TPart_InvPt->Sumw2(); + hTrack_2Stubs_InvPtRes_TPart_Eta->Sumw2(); + hTrack_2Stubs_Phi_TPart_Phi->Sumw2(); + hTrack_2Stubs_PhiRes_TPart_Eta->Sumw2(); + hTrack_2Stubs_Eta_TPart_Eta->Sumw2(); + hTrack_2Stubs_EtaRes_TPart_Eta->Sumw2(); + hTrack_2Stubs_VtxZ0_TPart_VtxZ0->Sumw2(); + hTrack_2Stubs_VtxZ0Res_TPart_Eta->Sumw2(); + hTrack_2Stubs_Chi2_NStubs->Sumw2(); + hTrack_2Stubs_Chi2_TPart_Eta->Sumw2(); + hTrack_2Stubs_Chi2Red_NStubs->Sumw2(); + hTrack_2Stubs_Chi2Red_TPart_Eta->Sumw2(); + + /// End of things to be done before entering the event Loop +} + +////////// +// ANALYZE +void AnalyzerL1Track::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + /// Track Trigger + //edm::Handle< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > > PixelDigiTTClusterHandle; + //edm::Handle< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > > > PixelDigiTTStubHandle; + edm::Handle< std::vector< TTTrack< Ref_PixelDigi_ > > > PixelDigiTTTrackHandle; + //iEvent.getByLabel( tagTTClusters, PixelDigiTTClusterHandle ); + //iEvent.getByLabel( tagTTStubs, PixelDigiTTStubHandle ); + iEvent.getByLabel( tagTTTracks, PixelDigiTTTrackHandle ); + + /// Track Trigger MC Truth + edm::Handle< TTClusterAssociationMap< Ref_PixelDigi_ > > MCTruthTTClusterHandle; + edm::Handle< TTStubAssociationMap< Ref_PixelDigi_ > > MCTruthTTStubHandle; + edm::Handle< TTTrackAssociationMap< Ref_PixelDigi_ > > MCTruthTTTrackHandle; + iEvent.getByLabel( tagTTClusterMCTruth, MCTruthTTClusterHandle ); + iEvent.getByLabel( tagTTStubMCTruth, MCTruthTTStubHandle ); + iEvent.getByLabel( tagTTTrackMCTruth, MCTruthTTTrackHandle ); + + /// TrackingParticles + edm::Handle< std::vector< TrackingParticle > > TrackingParticleHandle; + iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingParticleHandle ); + edm::Handle< std::vector< TrackingVertex > > TrackingVertexHandle; + iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingVertexHandle ); + + /// Loop over TrackingParticles + if ( TrackingParticleHandle->size() > 0 ) + { + unsigned int tpCnt = 0; + std::vector< TrackingParticle >::const_iterator iterTP; + for ( iterTP = TrackingParticleHandle->begin(); + iterTP != TrackingParticleHandle->end(); + ++iterTP ) + { + /// Make the pointer + edm::Ptr< TrackingParticle > tempTPPtr( TrackingParticleHandle, tpCnt++ ); + + /// Skip non-primary track + if ( tempTPPtr->vertex().rho() >= 2.0 ) + continue; + + /// Check if this TP produced any clusters + if ( MCTruthTTClusterHandle->findTTClusterRefs( tempTPPtr ).size() > 0 ) + { + hTPart_Cluster_Pt->Fill( tempTPPtr->p4().pt() ); + if ( tempTPPtr->p4().pt() > 5.0 ) + { + hTPart_Cluster_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); + hTPart_Cluster_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); + } + + /// Check if the TP produced any stubs + if ( MCTruthTTStubHandle->findTTStubRefs( tempTPPtr ).size() > 0 ) + { + hTPart_Stub_Pt->Fill( tempTPPtr->p4().pt() ); + if ( tempTPPtr->p4().pt() > 5.0 ) + { + hTPart_Stub_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); + hTPart_Stub_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); + } + + ///Check if the TP produced any Tracks + if ( MCTruthTTTrackHandle->findTTTrackPtrs( tempTPPtr ).size() > 0 ) + { + /// Distinguish between 2-stubs-only and 3-stubs-minimum + bool found2stubs = false; + bool found3stubs = false; + std::vector< edm::Ptr< TTTrack< Ref_PixelDigi_ > > > theseTracks = MCTruthTTTrackHandle->findTTTrackPtrs( tempTPPtr ); + for ( unsigned int it = 0; it < theseTracks.size(); it++ ) + { + if ( found2stubs && found3stubs ) + { + it = theseTracks.size(); + continue; + } + + if ( theseTracks.at(it)->getStubRefs().size() == 2 ) + { + found2stubs = true; + } + else if ( theseTracks.at(it)->getStubRefs().size() > 2 ) + { + /// Additional cross check + bool hasBL1 = theseTracks.at(it)->hasStubInBarrel(1) ; + if ( hasBL1 ) + { + } + found3stubs = true; + //} /// Additional cross check + } + } + + if ( found2stubs ) + { + hTPart_Track_2Stubs_Pt->Fill( tempTPPtr->p4().pt() ); + if ( tempTPPtr->p4().pt() > 5.0 ) + { + hTPart_Track_2Stubs_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); + hTPart_Track_2Stubs_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); + } + } + + if ( found3stubs ) + { + hTPart_Track_3Stubs_Pt->Fill( tempTPPtr->p4().pt() ); + if ( tempTPPtr->p4().pt() > 5.0 ) + { + hTPart_Track_3Stubs_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); + hTPart_Track_3Stubs_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); + } + } + } + } + } + } /// End of loop over TrackingParticles + } + + unsigned int num3Stubs = 0; + unsigned int num2Stubs = 0; + + /// Go on only if there are TTTracks from PixelDigis + if ( PixelDigiTTTrackHandle->size() > 0 ) + { + /// Loop over TTTracks + unsigned int tkCnt = 0; + std::vector< TTTrack< Ref_PixelDigi_ > >::const_iterator iterTTTrack; + for ( iterTTTrack = PixelDigiTTTrackHandle->begin(); + iterTTTrack != PixelDigiTTTrackHandle->end(); + ++iterTTTrack ) + { + /// Make the pointer + edm::Ptr< TTTrack< Ref_PixelDigi_ > > tempTrackPtr( PixelDigiTTTrackHandle, tkCnt++ ); + + /// Get everything is relevant + unsigned int nStubs = tempTrackPtr->getStubRefs().size(); + unsigned int seedSector = tempTrackPtr->getSector(); + unsigned int seedWedge = tempTrackPtr->getWedge(); + + hTrack_NStubs_Sector->Fill( seedSector, nStubs ); + hTrack_NStubs_Wedge->Fill( seedWedge, nStubs ); + + //double trackRInv = tempTrackPtr->getRInv(); + double trackPt = tempTrackPtr->getMomentum().perp(); + double trackPhi = tempTrackPtr->getMomentum().phi(); + double trackEta = tempTrackPtr->getMomentum().eta(); + double trackTheta = tempTrackPtr->getMomentum().theta(); + double trackVtxZ0 = tempTrackPtr->getPOCA().z(); + double trackChi2 = tempTrackPtr->getChi2(); + double trackChi2R = tempTrackPtr->getChi2Red(); + + hTrack_Sector_Phi->Fill( trackPhi, seedSector ); + hTrack_Wedge_Eta->Fill( trackEta, seedWedge ); + + bool genuineTrack = MCTruthTTTrackHandle->isGenuine( tempTrackPtr ); + + if ( !genuineTrack ) continue; + + edm::Ptr< TrackingParticle > tpPtr = MCTruthTTTrackHandle->findTrackingParticlePtr( tempTrackPtr ); + + /// Get the corresponding vertex and reject the track + /// if its vertex is outside the beampipe + if ( tpPtr->vertex().rho() >= 2 ) + continue; + + double tpPt = tpPtr->p4().pt(); + double tpEta = tpPtr->momentum().eta(); + double tpTheta = tpPtr->momentum().theta(); + double tpPhi = tpPtr->momentum().phi(); + double tpVtxZ0 = tpPtr->vertex().z(); + + if ( nStubs > 2 ) + { + + hTPart_Eta_Normalization->Fill( tpEta ); + hTPart_Eta_NStubs->Fill( tpEta, nStubs ); + + hTrack_3Stubs_Pt->Fill( trackPt ); + hTrack_3Stubs_Eta->Fill( trackEta ); + hTrack_3Stubs_Phi->Fill( trackPhi ); + + num3Stubs++; + hTrack_3Stubs_Pt_TPart_Pt->Fill( tpPt, trackPt ); + hTrack_3Stubs_PtRes_TPart_Eta->Fill( tpEta, trackPt - tpPt ); + hTrack_3Stubs_InvPt_TPart_InvPt->Fill( 1./tpPt, 1./trackPt ); + hTrack_3Stubs_InvPtRes_TPart_Eta->Fill( tpEta, 1./trackPt - 1./tpPt ); + hTrack_3Stubs_Phi_TPart_Phi->Fill( tpPhi, trackPhi ); + hTrack_3Stubs_PhiRes_TPart_Eta->Fill( tpEta, trackPhi - tpPhi ); + hTrack_3Stubs_Eta_TPart_Eta->Fill( tpEta, trackEta ); + hTrack_3Stubs_EtaRes_TPart_Eta->Fill( tpEta, trackEta - tpEta ); + hTrack_3Stubs_VtxZ0_TPart_VtxZ0->Fill( tpVtxZ0, trackVtxZ0 ); + hTrack_3Stubs_VtxZ0Res_TPart_Eta->Fill( tpEta, trackVtxZ0 - tpVtxZ0 ); + hTrack_3Stubs_Chi2_NStubs->Fill( nStubs, trackChi2 ); + hTrack_3Stubs_Chi2_TPart_Eta->Fill( tpEta, trackChi2 ); + hTrack_3Stubs_Chi2Red_NStubs->Fill( nStubs, trackChi2R ); + hTrack_3Stubs_Chi2Red_TPart_Eta->Fill( tpEta, trackChi2R ); + + /// Additional cross check + bool hasBL1 = tempTrackPtr->hasStubInBarrel(1); + if ( hasBL1 ) + { + } + + /// Find the Pt/Eta bin for the 1D performance plots + unsigned int binPt = maxPtBin; + unsigned int binEta = maxEtaBin; + for ( unsigned int iPt = maxPtBin; iPt > 0; ) + { + iPt--; + if ( tpPt < vLimitsPt.at(iPt) ) + binPt = iPt; + } + for ( unsigned int iEta = maxEtaBin; iEta > 0; ) + { + iEta--; + if ( fabs(tpEta) < vLimitsEta.at(iEta) ) + binEta = iEta; + } + + std::pair< unsigned int, unsigned int > mapKey = std::make_pair( binPt, binEta ); + + mapTrack_3Stubs_Chi2_PtEta[ mapKey ]->Fill( trackChi2 ); + mapTrack_3Stubs_Chi2Red_PtEta[ mapKey ]->Fill( trackChi2R ); + + /// Now, the different Pt/Eta mapping + binPt = 0; + binEta = 0; + for ( unsigned int iPt = 0; iPt < maxPtBinRes; iPt++ ) + { + if ( tpPt >= iPt*ptBinSize ) + binPt = iPt; + } + for ( unsigned int iEta = 0; iEta < maxEtaBinRes; iEta++ ) + { + if ( fabs(tpEta) >= iEta*etaBinSize ) + binEta = iEta; + } + + mapKey = std::make_pair( binPt, binEta ); + + mapTrack_3Stubs_PtRes_PtEta[ mapKey ]->Fill( trackPt - tpPt ); + mapTrack_3Stubs_InvPtRes_PtEta[ mapKey ]->Fill( 1./trackPt - 1./tpPt ); + mapTrack_3Stubs_RelPtRes_PtEta[ mapKey ]->Fill( trackPt / tpPt - 1 ); + mapTrack_3Stubs_PhiRes_PtEta[ mapKey ]->Fill( trackPhi - tpPhi ); + mapTrack_3Stubs_EtaRes_PtEta[ mapKey ]->Fill( trackEta - tpEta ); + mapTrack_3Stubs_CotThetaRes_PtEta[ mapKey ]->Fill( 1./tan(trackTheta) - 1./tan(tpTheta) ); + mapTrack_3Stubs_VtxZ0Res_PtEta[ mapKey ]->Fill( trackVtxZ0 - tpVtxZ0 ); + + //} /// Additional cross check + } + else + { + hTrack_2Stubs_Pt->Fill( trackPt ); + hTrack_2Stubs_Eta->Fill( trackEta ); + hTrack_2Stubs_Phi->Fill( trackPhi ); + + num2Stubs++; + hTrack_2Stubs_Pt_TPart_Pt->Fill( tpPt, trackPt ); + hTrack_2Stubs_PtRes_TPart_Eta->Fill( tpEta, trackPt - tpPt ); + hTrack_2Stubs_InvPt_TPart_InvPt->Fill( 1./tpPt, 1./trackPt ); + hTrack_2Stubs_InvPtRes_TPart_Eta->Fill( tpEta, 1./trackPt - 1./tpPt ); + hTrack_2Stubs_Phi_TPart_Phi->Fill( tpPhi, trackPhi ); + hTrack_2Stubs_PhiRes_TPart_Eta->Fill( tpEta, trackPhi - tpPhi ); + hTrack_2Stubs_Eta_TPart_Eta->Fill( tpEta, trackEta ); + hTrack_2Stubs_EtaRes_TPart_Eta->Fill( tpEta, trackEta - tpEta ); + hTrack_2Stubs_VtxZ0_TPart_VtxZ0->Fill( tpVtxZ0, trackVtxZ0 ); + hTrack_2Stubs_VtxZ0Res_TPart_Eta->Fill( tpEta, trackVtxZ0 - tpVtxZ0 ); + hTrack_2Stubs_Chi2_NStubs->Fill( nStubs, trackChi2 ); + hTrack_2Stubs_Chi2_TPart_Eta->Fill( tpEta, trackChi2 ); + hTrack_2Stubs_Chi2Red_NStubs->Fill( nStubs, trackChi2R ); + hTrack_2Stubs_Chi2Red_TPart_Eta->Fill( tpEta, trackChi2R ); + } + } /// End of loop over TTTracks + } + + hTrack_2Stubs_N->Fill( num2Stubs ); + hTrack_3Stubs_N->Fill( num3Stubs ); + +} /// End of analyze() + +/////////////////////////// +// DEFINE THIS AS A PLUG-IN +DEFINE_FWK_MODULE(AnalyzerL1Track); + diff --git a/L1Trigger/TrackTrigger/test/ValidateL1Track_ExtendedPhase2TkBE5D_cfg.py b/L1Trigger/TrackTrigger/test/AnalyzerL1Track_ExtendedPhase2TkBE5D_cfg.py similarity index 76% rename from L1Trigger/TrackTrigger/test/ValidateL1Track_ExtendedPhase2TkBE5D_cfg.py rename to L1Trigger/TrackTrigger/test/AnalyzerL1Track_ExtendedPhase2TkBE5D_cfg.py index 9942691481642..b29dcf526b297 100644 --- a/L1Trigger/TrackTrigger/test/ValidateL1Track_ExtendedPhase2TkBE5D_cfg.py +++ b/L1Trigger/TrackTrigger/test/AnalyzerL1Track_ExtendedPhase2TkBE5D_cfg.py @@ -14,7 +14,7 @@ ################################################################################################# import FWCore.ParameterSet.Config as cms #--------------------import os -process = cms.Process('ValidateL1Track') +process = cms.Process('AnalyzerL1Track') ################################################################################################# # global tag @@ -42,22 +42,11 @@ ################################################################################################# process.source = cms.Source("PoolSource", secondaryFileNames = cms.untracked.vstring(), - fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/p/pozzo/workspace0/CMSSW_6_2_0_SLHC1/src/L1Trigger/TrackTrigger/test/TenMuPt_0_100_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') -# fileNames = cms.untracked.vstring('file:TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') -# fileNames = cms.untracked.vstring('file:TenPiPt_0_50_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') -# fileNames = cms.untracked.vstring('file:TenElePt_0_50_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') - -# fileNames = cms.untracked.vstring('file:TenMuPt_0_100_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') - -# fileNames = cms.untracked.vstring('file:DYTauTau_ExtendedPhase2TkBE5D_750_DIGI_L1_DIGI2RAW_L1TT_RECO.root') - - + fileNames = cms.untracked.vstring('file:TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO.root') # fileNames = cms.untracked.vstring('file:TenMuPt_2_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root', # 'file:TenMuPt_10_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root', # 'file:TenMuPt_50_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root' # ) - - # fileNames = cms.untracked.vstring( 'file:TenMuPt_0_50_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root', # 'file:TenPiPt_0_50_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root', # 'file:TenElePt_0_50_ExtendedPhase2TkBE5D_5000_DIGI_L1_DIGI2RAW_L1TT_RECO.root' ) @@ -70,17 +59,34 @@ ################################################################################################ # produce the L1 Tracks ################################################################################################ -process.load('L1Trigger.TrackTrigger.TrackTrigger_cff') + +process.BeamSpotFromSim = cms.EDProducer("BeamSpotFromSimProducer") +process.load('L1Trigger.TrackFindingTracklet.L1TTrack_cfi') +process.TrackFindingTracklet_step = cms.Path(process.BeamSpotFromSim*process.TTTracksFromPixelDigisTracklet) + +process.load('L1Trigger.TrackFindingAM.L1AMTrack_cfi') +process.TrackFindingAM_step = cms.Path(process.TTTracksFromPixelDigisAM) + process.load('SimTracker.TrackTriggerAssociation.TrackTriggerAssociator_cff') -process.L1TrackTrigger_step = cms.Path(process.TrackTriggerTracks) process.L1TTAssociator_step = cms.Path(process.TrackTriggerAssociatorTracks) ################################################################################################# # load the analyzer ################################################################################################# -process.ValidateL1Track = cms.EDAnalyzer("ValidateL1Track", +process.AnalyzerL1Track = cms.EDAnalyzer("AnalyzerL1Track", DebugMode = cms.bool(True), + + TTClusters = cms.InputTag("TTStubsFromPixelDigis", "ClusterAccepted"), + TTClusterMCTruth = cms.InputTag("TTClusterAssociatorFromPixelDigis", "ClusterAccepted"), + TTStubs = cms.InputTag("TTStubsFromPixelDigis", "StubAccepted"), + TTStubMCTruth = cms.InputTag("TTStubAssociatorFromPixelDigis", "StubAccepted"), + #TTTracks = cms.InputTag("TTTracksFromPixelDigisTracklet", "TrackletBasedL1Tracks"), + #TTTrackMCTruth = cms.InputTag("TTTrackAssociatorFromPixelDigis", "TrackletBasedL1Tracks"), + + TTTracks = cms.InputTag("TTTracksFromPixelDigisAM", "AML1Tracks"), + TTTrackMCTruth = cms.InputTag("TTTrackAssociatorFromPixelDigis", "AML1Tracks"), + vLimitsPt = cms.vdouble( 5.0, 15.0, 9999.99 @@ -110,25 +116,22 @@ # define output file and message logger ################################################################################################# process.TFileService = cms.Service("TFileService", - fileName = cms.string('file:ValidateL1Track_ExtendedPhase2TkBE5D_Muon0100GeVNEWFIT.root') - -# fileName = cms.string('file:ValidateL1Track_ExtendedPhase2TkBE5D_Pion050GeV.root') -# fileName = cms.string('file:ValidateL1Track_ExtendedPhase2TkBE5D_Ele.root') - - -# fileName = cms.string('file:ValidateL1Track_ExtendedPhase2TkBE5D_Muon210100L1.root') - - -# fileName = cms.string('file:ValidateL1Track_ExtendedPhase2TkBE5D_DYTauTau.root') - -#fileName = cms.string('file:TEST.root') + fileName = cms.string('file:AnalyzerL1Track_ExtendedPhase2TkBE5D_Muon0100GeVNEWFIT.root') ) ################################################################################################# # define the final path to be fed to cmsRun ################################################################################################# -process.p = cms.Path( process.ValidateL1Track ) +process.p = cms.Path( process.AnalyzerL1Track ) -process.schedule = cms.Schedule( process.L1TrackTrigger_step,process.L1TTAssociator_step,process.p ) +process.eca = cms.EDAnalyzer("EventContentAnalyzer") +process.eca_step = cms.Path(process.eca) +process.schedule = cms.Schedule( +process.TrackFindingTracklet_step, +process.TrackFindingAM_step, +process.L1TTAssociator_step, +#process.eca_step, +process.p +) diff --git a/L1Trigger/TrackTrigger/test/ValidatePixelDigiMaps.cc b/L1Trigger/TrackTrigger/test/AnalyzerPixelDigiMaps.cc similarity index 94% rename from L1Trigger/TrackTrigger/test/ValidatePixelDigiMaps.cc rename to L1Trigger/TrackTrigger/test/AnalyzerPixelDigiMaps.cc index 7846bbaa88733..bb544faba98fb 100644 --- a/L1Trigger/TrackTrigger/test/ValidatePixelDigiMaps.cc +++ b/L1Trigger/TrackTrigger/test/AnalyzerPixelDigiMaps.cc @@ -29,13 +29,13 @@ // // ////////////////////////////// -class ValidatePixelDigiMaps : public edm::EDAnalyzer +class AnalyzerPixelDigiMaps : public edm::EDAnalyzer { /// Public methods public: /// Constructor/destructor - explicit ValidatePixelDigiMaps(const edm::ParameterSet& iConfig); - virtual ~ValidatePixelDigiMaps(); + explicit AnalyzerPixelDigiMaps(const edm::ParameterSet& iConfig); + virtual ~AnalyzerPixelDigiMaps(); // Typical methods used on Loops over events virtual void beginJob(); virtual void endJob(); @@ -64,14 +64,14 @@ class ValidatePixelDigiMaps : public edm::EDAnalyzer ////////////// // CONSTRUCTOR -ValidatePixelDigiMaps::ValidatePixelDigiMaps(edm::ParameterSet const& iConfig) +AnalyzerPixelDigiMaps::AnalyzerPixelDigiMaps(edm::ParameterSet const& iConfig) { /// Insert here what you need to initialize } ///////////// // DESTRUCTOR -ValidatePixelDigiMaps::~ValidatePixelDigiMaps() +AnalyzerPixelDigiMaps::~AnalyzerPixelDigiMaps() { /// Insert here what you need to delete /// when you close the class instance @@ -79,16 +79,16 @@ ValidatePixelDigiMaps::~ValidatePixelDigiMaps() ////////// // END JOB -void ValidatePixelDigiMaps::endJob() +void AnalyzerPixelDigiMaps::endJob() { /// Things to be done at the exit of the event Loop - std::cerr << " ValidatePixelDigiMaps::endJob" << std::endl; + std::cerr << " AnalyzerPixelDigiMaps::endJob" << std::endl; /// End of things to be done at the exit from the event Loop } //////////// // BEGIN JOB -void ValidatePixelDigiMaps::beginJob() +void AnalyzerPixelDigiMaps::beginJob() { /// Initialize all slave variables /// mainly histogram ranges and resolution @@ -96,7 +96,7 @@ void ValidatePixelDigiMaps::beginJob() std::ostringstream histoTitle; /// Things to be done before entering the event Loop - std::cerr << " ValidatePixelDigiMaps::beginJob" << std::endl; + std::cerr << " AnalyzerPixelDigiMaps::beginJob" << std::endl; /// Book histograms etc edm::Service fs; @@ -148,7 +148,7 @@ void ValidatePixelDigiMaps::beginJob() ////////// // ANALYZE -void ValidatePixelDigiMaps::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +void AnalyzerPixelDigiMaps::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { /// Geometry handles etc edm::ESHandle< TrackerGeometry > geometryHandle; @@ -227,5 +227,5 @@ std::cerr< fs; @@ -282,7 +282,7 @@ void PrintStackInfo::beginJob() ////////// // ANALYZE -void PrintStackInfo::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +void AnalyzerPrintGeomInfo::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { /// Geometry handles etc edm::ESHandle geometryHandle; @@ -1370,5 +1370,5 @@ void PrintStackInfo::analyze(const edm::Event& iEvent, const edm::EventSetup& iS /////////////////////////// // DEFINE THIS AS A PLUG-IN -DEFINE_FWK_MODULE(PrintStackInfo); +DEFINE_FWK_MODULE(AnalyzerPrintGeomInfo); diff --git a/L1Trigger/TrackTrigger/test/PrintStackInfo_ExtendedPhase2TkBE5D_cfg.py b/L1Trigger/TrackTrigger/test/AnalyzerPrintGeomInfo_ExtendedPhase2TkBE5D_cfg.py similarity index 94% rename from L1Trigger/TrackTrigger/test/PrintStackInfo_ExtendedPhase2TkBE5D_cfg.py rename to L1Trigger/TrackTrigger/test/AnalyzerPrintGeomInfo_ExtendedPhase2TkBE5D_cfg.py index 508a4b870986a..80dae26c7516f 100644 --- a/L1Trigger/TrackTrigger/test/PrintStackInfo_ExtendedPhase2TkBE5D_cfg.py +++ b/L1Trigger/TrackTrigger/test/AnalyzerPrintGeomInfo_ExtendedPhase2TkBE5D_cfg.py @@ -18,7 +18,7 @@ input = cms.untracked.int32(1) ) -process.MyModule = cms.EDAnalyzer("PrintStackInfo", +process.MyModule = cms.EDAnalyzer("AnalyzerPrintGeomInfo", TextOutput = cms.string('GeometrySummary_ExtendedPhase2TkBE5D.log'), DebugMode = cms.bool(False) ) diff --git a/L1Trigger/TrackTrigger/test/ValidateSimHitMaps.cc b/L1Trigger/TrackTrigger/test/AnalyzerSimHitMaps.cc similarity index 96% rename from L1Trigger/TrackTrigger/test/ValidateSimHitMaps.cc rename to L1Trigger/TrackTrigger/test/AnalyzerSimHitMaps.cc index d4e1f9c520c70..039a6df01cf07 100644 --- a/L1Trigger/TrackTrigger/test/ValidateSimHitMaps.cc +++ b/L1Trigger/TrackTrigger/test/AnalyzerSimHitMaps.cc @@ -26,13 +26,13 @@ // // ////////////////////////////// -class ValidateSimHitMaps : public edm::EDAnalyzer +class AnalyzerSimHitMaps : public edm::EDAnalyzer { /// Public methods public: /// Constructor/destructor - explicit ValidateSimHitMaps(const edm::ParameterSet& iConfig); - virtual ~ValidateSimHitMaps(); + explicit AnalyzerSimHitMaps(const edm::ParameterSet& iConfig); + virtual ~AnalyzerSimHitMaps(); // Typical methods used on Loops over events virtual void beginJob(); virtual void endJob(); @@ -61,14 +61,14 @@ class ValidateSimHitMaps : public edm::EDAnalyzer ////////////// // CONSTRUCTOR -ValidateSimHitMaps::ValidateSimHitMaps(edm::ParameterSet const& iConfig) +AnalyzerSimHitMaps::AnalyzerSimHitMaps(edm::ParameterSet const& iConfig) { /// Insert here what you need to initialize } ///////////// // DESTRUCTOR -ValidateSimHitMaps::~ValidateSimHitMaps() +AnalyzerSimHitMaps::~AnalyzerSimHitMaps() { /// Insert here what you need to delete /// when you close the class instance @@ -76,16 +76,16 @@ ValidateSimHitMaps::~ValidateSimHitMaps() ////////// // END JOB -void ValidateSimHitMaps::endJob() +void AnalyzerSimHitMaps::endJob() { /// Things to be done at the exit of the event Loop - std::cerr << " ValidateSimHitMaps::endJob" << std::endl; + std::cerr << " AnalyzerSimHitMaps::endJob" << std::endl; /// End of things to be done at the exit from the event Loop } //////////// // BEGIN JOB -void ValidateSimHitMaps::beginJob() +void AnalyzerSimHitMaps::beginJob() { /// Initialize all slave variables /// mainly histogram ranges and resolution @@ -93,7 +93,7 @@ void ValidateSimHitMaps::beginJob() std::ostringstream histoTitle; /// Things to be done before entering the event Loop - std::cerr << " ValidateSimHitMaps::beginJob" << std::endl; + std::cerr << " AnalyzerSimHitMaps::beginJob" << std::endl; /// Book histograms etc edm::Service fs; @@ -145,7 +145,7 @@ void ValidateSimHitMaps::beginJob() ////////// // ANALYZE -void ValidateSimHitMaps::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +void AnalyzerSimHitMaps::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { /// Geometry handles etc edm::ESHandle< TrackerGeometry > geometryHandle; @@ -322,5 +322,5 @@ void ValidateSimHitMaps::analyze(const edm::Event& iEvent, const edm::EventSetup /////////////////////////// // DEFINE THIS AS A PLUG-IN -DEFINE_FWK_MODULE(ValidateSimHitMaps); +DEFINE_FWK_MODULE(AnalyzerSimHitMaps); diff --git a/L1Trigger/TrackTrigger/test/ValidateSimHitMaps_ExtendedPhase2TkBE5D_cfg.py b/L1Trigger/TrackTrigger/test/AnalyzerSimHitMaps_ExtendedPhase2TkBE5D_cfg.py similarity index 93% rename from L1Trigger/TrackTrigger/test/ValidateSimHitMaps_ExtendedPhase2TkBE5D_cfg.py rename to L1Trigger/TrackTrigger/test/AnalyzerSimHitMaps_ExtendedPhase2TkBE5D_cfg.py index 361c705c6906d..a78e2d4fb7562 100644 --- a/L1Trigger/TrackTrigger/test/ValidateSimHitMaps_ExtendedPhase2TkBE5D_cfg.py +++ b/L1Trigger/TrackTrigger/test/AnalyzerSimHitMaps_ExtendedPhase2TkBE5D_cfg.py @@ -14,7 +14,7 @@ ################################################################################################# import FWCore.ParameterSet.Config as cms import os -process = cms.Process('ValidateSimHitMaps') +process = cms.Process('AnalyzerSimHitMaps') ################################################################################################# # global tag @@ -51,17 +51,17 @@ ################################################################################################# # load the analyzer ################################################################################################# -process.ValidateSimHitMaps = cms.EDAnalyzer("ValidateSimHitMaps") +process.AnalyzerSimHitMaps = cms.EDAnalyzer("AnalyzerSimHitMaps") ################################################################################################# # define output file and message logger ################################################################################################# process.TFileService = cms.Service("TFileService", - fileName = cms.string('file:ValidateSimHitMaps_ExtendedPhase2TkBE5D.root') + fileName = cms.string('file:AnalyzerSimHitMaps_ExtendedPhase2TkBE5D.root') ) ################################################################################################# # define the final path to be fed to cmsRun ################################################################################################# -process.p = cms.Path( process.ValidateSimHitMaps ) +process.p = cms.Path( process.AnalyzerSimHitMaps ) diff --git a/L1Trigger/TrackTrigger/test/TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO_cfg.py b/L1Trigger/TrackTrigger/test/TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO_cfg.py index da335ed4815ac..564729b26844f 100644 --- a/L1Trigger/TrackTrigger/test/TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO_cfg.py +++ b/L1Trigger/TrackTrigger/test/TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_DIGI_L1_DIGI2RAW_L1TT_RECO_cfg.py @@ -27,13 +27,13 @@ process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') process.maxEvents = cms.untracked.PSet( - input = cms.untracked.int32(-1) + input = cms.untracked.int32(1000) ) # Input source process.source = cms.Source("PoolSource", secondaryFileNames = cms.untracked.vstring(), - fileNames = cms.untracked.vstring('file:TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_GEN_SIM.root') + fileNames = cms.untracked.vstring('file:/afs/cern.ch/user/p/pozzo/workspace0/public/VALIDATION_6_2_0_SLHC1/TenMuPt_0_20_ExtendedPhase2TkBE5D_10000_GEN_SIM.root') ) process.options = cms.untracked.PSet( @@ -62,6 +62,18 @@ # Additional output definition +#process.EnableFloatingPointExceptions = cms.Service("EnableFloatingPointExceptions", +# moduleNames = cms.untracked.vstring('default'), +# default = cms.untracked.PSet( +# enableOverFlowEx = cms.untracked.bool(True), +# enableDivByZeroEx = cms.untracked.bool(True), +# enableInvalidEx = cms.untracked.bool(True), +# enableUnderFlowEx = cms.untracked.bool(True) +# ), +# setPrecisionDouble = cms.untracked.bool(True), +# reportSettings = cms.untracked.bool(False) +#) + # Other statements from Configuration.AlCa.GlobalTag import GlobalTag process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:upgradePLS3', '') @@ -83,7 +95,8 @@ # Schedule definition process.schedule = cms.Schedule(process.digitisation_step,process.L1simulation_step,process.digi2raw_step, process.L1TrackTrigger_step,process.L1TTAssociator_step, -process.reconstruction_step,process.endjob_step,process.FEVTDEBUGoutput_step)#,process.eca_step) +process.reconstruction_step, +process.endjob_step,process.FEVTDEBUGoutput_step)#,process.eca_step) # customisation of the process. diff --git a/L1Trigger/TrackTrigger/test/ValidateL1Track.cc b/L1Trigger/TrackTrigger/test/ValidateL1Track.cc deleted file mode 100644 index 85695a4fec4d2..0000000000000 --- a/L1Trigger/TrackTrigger/test/ValidateL1Track.cc +++ /dev/null @@ -1,1341 +0,0 @@ -/*! \brief Checklist - * \details TTTracks - * - * \author Nicola Pozzobon - * \author Anders Ryd - * \author Louise Skinnari - * \author David Sweigart - * \date 2013, Jul 22 - * - */ - -#include "FWCore/Framework/interface/MakerMacros.h" -#include "FWCore/Framework/interface/EDAnalyzer.h" -#include "FWCore/Framework/interface/Event.h" -#include "FWCore/Framework/interface/ESHandle.h" -#include "FWCore/PluginManager/interface/ModuleDef.h" -#include "FWCore/ServiceRegistry/interface/Service.h" -#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" -#include "MagneticField/Engine/interface/MagneticField.h" -#include "Geometry/Records/interface/StackedTrackerGeometryRecord.h" -#include "Geometry/TrackerGeometryBuilder/interface/StackedTrackerGeometry.h" -#include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" -#include "Geometry/CommonTopologies/interface/Topology.h" -#include "Geometry/TrackerGeometryBuilder/interface/PixelGeomDetUnit.h" -#include "Geometry/CommonTopologies/interface/PixelTopology.h" -#include "DataFormats/L1TrackTrigger/interface/TTTypes.h" -#include "DataFormats/L1TrackTrigger/interface/TTCluster.h" -#include "DataFormats/L1TrackTrigger/interface/TTStub.h" -#include "DataFormats/L1TrackTrigger/interface/TTTrack.h" -#include "SimDataFormats/Vertex/interface/SimVertexContainer.h" -#include "SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h" -#include "SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h" -#include "SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h" -#include "SimDataFormats/TrackingAnalysis/interface/TrackingParticle.h" -#include "SimDataFormats/TrackingAnalysis/interface/TrackingVertex.h" -#include "CommonTools/UtilAlgos/interface/TFileService.h" -#include -#include - -class ValidateL1Track : public edm::EDAnalyzer -{ - /// Public methods - public: - /// Constructor/destructor - explicit ValidateL1Track(const edm::ParameterSet& iConfig); - virtual ~ValidateL1Track(); - // Typical methods used on Loops over events - virtual void beginJob(); - virtual void endJob(); - virtual void analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup); - - /// Private methods and variables - private: - TH2D* hTrack_NStubs_Sector; - TH2D* hTrack_NStubs_Wedge; - TH2D* hTrack_Sector_Phi; - TH2D* hTrack_Wedge_Eta; - TH2D* hTrack_RInv_Seed_RInv; - TH2D* hTrack_RInvRes_Track_Eta; - TH2D* hTrack_InvPt_Seed_InvPt; - TH2D* hTrack_InvPtRes_Track_Eta; - TH2D* hTrack_Pt_Seed_Pt; - TH2D* hTrack_PtRes_Track_Eta; - TH2D* hTrack_Phi_Seed_Phi; - TH2D* hTrack_PhiRes_Track_Eta; - TH2D* hTrack_Eta_Seed_Eta; - TH2D* hTrack_EtaRes_Track_Eta; - TH2D* hTrack_VtxZ0_Seed_VtxZ0; - TH2D* hTrack_VtxZ0Res_Track_Eta; - - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropBB_deltaRhoPhi_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropBB_deltaRhoPhi; - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropBB_deltaZ_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropBB_deltaZ; - - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropBE_deltaRhoPhi_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropBE_deltaRhoPhi; - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropBE_deltaR_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropBE_deltaR; - - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropEB_deltaRhoPhi_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropEB_deltaRhoPhi; - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropEB_deltaZ_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropEB_deltaZ; - - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropEE_deltaRhoPhi_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropEE_deltaRhoPhi; - std::map< std::pair< unsigned int, unsigned int >, TH2D* > mapTrackPropEE_deltaR_Eta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrackPropEE_deltaR; - - TH1D* hTrack_3Stubs_Pt; - TH1D* hTrack_3Stubs_Phi; - TH1D* hTrack_3Stubs_Eta; - - TH1D* hTrack_2Stubs_Pt; - TH1D* hTrack_2Stubs_Phi; - TH1D* hTrack_2Stubs_Eta; - - TH1D* hTrack_Seed_Pt; - TH1D* hTrack_Seed_Phi; - TH1D* hTrack_Seed_Eta; - - TH1D* hSeed_Pt; - TH1D* hSeed_Phi; - TH1D* hSeed_Eta; - - TH1D* hTPart_Track_3Stubs_Pt; - TH1D* hTPart_Track_3Stubs_Phi_Pt5; - TH1D* hTPart_Track_3Stubs_Eta_Pt5; - - TH1D* hTPart_Track_2Stubs_Pt; - TH1D* hTPart_Track_2Stubs_Phi_Pt5; - TH1D* hTPart_Track_2Stubs_Eta_Pt5; - - TH1D* hTPart_Seed_Pt; - TH1D* hTPart_Seed_Phi_Pt5; - TH1D* hTPart_Seed_Eta_Pt5; - - TH1D* hTPart_Cluster_Pt; - TH1D* hTPart_Cluster_Phi_Pt5; - TH1D* hTPart_Cluster_Eta_Pt5; - - TH1D* hTPart_Stub_Pt; - TH1D* hTPart_Stub_Phi_Pt5; - TH1D* hTPart_Stub_Eta_Pt5; - - TH1D* hTrack_3Stubs_N; - TH2D* hTrack_3Stubs_Pt_TPart_Pt; - TH2D* hTrack_3Stubs_PtRes_TPart_Eta; - TH2D* hTrack_3Stubs_InvPt_TPart_InvPt; - TH2D* hTrack_3Stubs_InvPtRes_TPart_Eta; - TH2D* hTrack_3Stubs_Phi_TPart_Phi; - TH2D* hTrack_3Stubs_PhiRes_TPart_Eta; - TH2D* hTrack_3Stubs_Eta_TPart_Eta; - TH2D* hTrack_3Stubs_EtaRes_TPart_Eta; - TH2D* hTrack_3Stubs_VtxZ0_TPart_VtxZ0; - TH2D* hTrack_3Stubs_VtxZ0Res_TPart_Eta; - TH2D* hTrack_3Stubs_Chi2_NStubs; - TH2D* hTrack_3Stubs_Chi2_TPart_Eta; - TH2D* hTrack_3Stubs_Chi2Red_NStubs; - TH2D* hTrack_3Stubs_Chi2Red_TPart_Eta; - - TH1D* hTPart_Eta_Normalization; - TH1D* hTPart_Eta_NStubs; - - unsigned int maxPtBin; - unsigned int maxEtaBin; - std::vector< double > vLimitsPt; - std::vector< std::string > vStringPt; - std::vector< double > vLimitsEta; - std::vector< std::string > vStringEta; - - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_Chi2_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_Chi2Red_PtEta; - - unsigned int maxPtBinRes; - unsigned int maxEtaBinRes; - double ptBinSize; - double etaBinSize; - - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_PtRes_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_InvPtRes_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_RelPtRes_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_PhiRes_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_EtaRes_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_CotThetaRes_PtEta; - std::map< std::pair< unsigned int, unsigned int >, TH1D* > mapTrack_3Stubs_VtxZ0Res_PtEta; - - TH1D* hTrack_2Stubs_N; - TH2D* hTrack_2Stubs_Pt_TPart_Pt; - TH2D* hTrack_2Stubs_PtRes_TPart_Eta; - TH2D* hTrack_2Stubs_InvPt_TPart_InvPt; - TH2D* hTrack_2Stubs_InvPtRes_TPart_Eta; - TH2D* hTrack_2Stubs_Phi_TPart_Phi; - TH2D* hTrack_2Stubs_PhiRes_TPart_Eta; - TH2D* hTrack_2Stubs_Eta_TPart_Eta; - TH2D* hTrack_2Stubs_EtaRes_TPart_Eta; - TH2D* hTrack_2Stubs_VtxZ0_TPart_VtxZ0; - TH2D* hTrack_2Stubs_VtxZ0Res_TPart_Eta; - TH2D* hTrack_2Stubs_Chi2_NStubs; - TH2D* hTrack_2Stubs_Chi2_TPart_Eta; - TH2D* hTrack_2Stubs_Chi2Red_NStubs; - TH2D* hTrack_2Stubs_Chi2Red_TPart_Eta; - - TH1D* hSeed_N; - TH2D* hSeed_Pt_TPart_Pt; - TH2D* hSeed_PtRes_TPart_Eta; - TH2D* hSeed_InvPt_TPart_InvPt; - TH2D* hSeed_InvPtRes_TPart_Eta; - TH2D* hSeed_Phi_TPart_Phi; - TH2D* hSeed_PhiRes_TPart_Eta; - TH2D* hSeed_Eta_TPart_Eta; - TH2D* hSeed_EtaRes_TPart_Eta; - TH2D* hSeed_VtxZ0_TPart_VtxZ0; - TH2D* hSeed_VtxZ0Res_TPart_Eta; - TH2D* hSeed_Chi2_NStubs; - TH2D* hSeed_Chi2_TPart_Eta; - TH2D* hSeed_Chi2Red_NStubs; - TH2D* hSeed_Chi2Red_TPart_Eta; - -}; - -////////////////////////////////// -// // -// CLASS IMPLEMENTATION // -// // -////////////////////////////////// - -////////////// -// CONSTRUCTOR -ValidateL1Track::ValidateL1Track(edm::ParameterSet const& iConfig) -{ - /// Insert here what you need to initialize - vLimitsPt = iConfig.getParameter< std::vector< double > >("vLimitsPt"); - vLimitsEta = iConfig.getParameter< std::vector< double > >("vLimitsEta"); - vStringPt = iConfig.getParameter< std::vector< std::string > >("vStringPt"); - vStringEta = iConfig.getParameter< std::vector< std::string > >("vStringEta"); - - if ( vLimitsPt.size() != vStringPt.size() ) - { - exit(0); - } - else - { - maxPtBin = vLimitsPt.size(); - } - - if ( vLimitsEta.size() != vStringEta.size() ) - { - exit(0); - } - else - { - maxEtaBin = vLimitsEta.size(); - } - - maxPtBinRes = iConfig.getParameter< unsigned int >("maxPtBinRes"); - maxEtaBinRes = iConfig.getParameter< unsigned int >("maxEtaBinRes"); - ptBinSize = iConfig.getParameter< double >("ptBinSize"); - etaBinSize = iConfig.getParameter< double >("etaBinSize"); - - if ( maxPtBinRes == 0 || maxEtaBinRes == 0 ) - exit(0); - -} - -///////////// -// DESTRUCTOR -ValidateL1Track::~ValidateL1Track() -{ - /// Insert here what you need to delete - /// when you close the class instance -} - -////////// -// END JOB -void ValidateL1Track::endJob() -{ - /// Things to be done at the exit of the event Loop - std::cerr << " ValidateL1Track::endJob" << std::endl; - /// End of things to be done at the exit from the event Loop - - std::cerr<<"DeltaRhoPhi BB"< mapKey0 = std::make_pair( seed, targ ); - mapTrackPropBB_deltaRhoPhi[ mapKey0 ]->GetXaxis()->SetRangeUser(-0.6, 0.6); - std::cerr<< mapTrackPropBB_deltaRhoPhi[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - mapTrackPropBE_deltaRhoPhi[ mapKey0 ]->GetXaxis()->SetRangeUser(-0.6, 0.6); - std::cerr<< mapTrackPropBE_deltaRhoPhi[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - mapTrackPropEB_deltaRhoPhi[ mapKey0 ]->GetXaxis()->SetRangeUser(-0.6, 0.6); - std::cerr<< mapTrackPropEB_deltaRhoPhi[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - mapTrackPropEE_deltaRhoPhi[ mapKey0 ]->GetXaxis()->SetRangeUser(-0.6, 0.6); - std::cerr<< mapTrackPropEE_deltaRhoPhi[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - std::cerr<< mapTrackPropBB_deltaZ[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - std::cerr<< mapTrackPropBE_deltaR[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - std::cerr<< mapTrackPropEB_deltaZ[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< mapKey0 = std::make_pair( seed, targ ); - std::cerr<< mapTrackPropEE_deltaR[ mapKey0 ]->GetRMS() * 3.0 <<", "; - } - std::cerr< fs; - - /// Prepare for LogXY Plots - int NumBins = 200; - double MinPt = 0.0; - double MaxPt = 100.0; - - double* BinVec = new double[NumBins+1]; - for ( int iBin = 0; iBin < NumBins + 1; iBin++ ) - { - double temp = pow( 10, (- NumBins + iBin)/(MaxPt - MinPt) ); - BinVec[ iBin ] = temp; - } - - hTrack_NStubs_Sector = fs->make( "hTrack_NStubs_Sector", "TTTrack number of Stubs vs. Seed sector", 35, -0.5, 34.5, 20, -0.5, 19.5 ); - hTrack_NStubs_Wedge = fs->make( "hTrack_NStubs_Wedge", "TTTrack number of Stubs vs. Seed wedge", 35, -0.5, 34.5, 20, -0.5, 19.5 ); - hTrack_Sector_Phi = fs->make( "hTrack_Sector_Phi", "Seed sector vs. TTTrack #phi", 180, -M_PI, M_PI, 35, -0.5, 34.5 ); - hTrack_Wedge_Eta = fs->make( "hTrack_Wedge_Eta", "Seed wedge vs. TTTrack #eta", 180, -M_PI, M_PI, 35, -0.5, 34.5 ); - hTrack_RInv_Seed_RInv = fs->make( "hTrack_RInv_Seed_RInv", "TTTrack radius vs. Seed radius", 200, -0.01, 0.01, 200, -0.01, 0.01 ); - hTrack_RInvRes_Track_Eta = fs->make( "hTrack_RInvRes_Track_Eta", "TTTrack radius res. vs #eta", 180, -M_PI, M_PI, 100, -0.005, 0.005 ); - hTrack_Pt_Seed_Pt = fs->make( "hTrack_Pt_Seed_Pt", "TTTrack p_{T} vs. Seed p_{T}", 100, 0, 50, 100, 0, 50 ); - hTrack_PtRes_Track_Eta = fs->make( "hTrack_PtRes_Track_Eta", "TTTrack p_{T} res. vs #eta", 180, -M_PI, M_PI, 100, -4.0, 4.0 ); - hTrack_InvPt_Seed_InvPt = fs->make( "hTrack_InvPt_Seed_InvPt", "TTTrack p_{T}^{-1} vs. Seed p_{T}^{-1}", 200, 0, 0.8, 200, 0, 0.8 ); - hTrack_InvPt_Seed_InvPt->GetXaxis()->Set( NumBins, BinVec ); - hTrack_InvPt_Seed_InvPt->GetYaxis()->Set( NumBins, BinVec ); - hTrack_InvPtRes_Track_Eta = fs->make( "hTrack_InvPtRes_Track_Eta", "TTTrack p_{T}^{-1} res. vs #eta", 180, -M_PI, M_PI, 100, -0.4, 0.4 ); - hTrack_Phi_Seed_Phi = fs->make( "hTrack_Phi_Seed_Phi", "TTTrack #phi vs. Seed #phi", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hTrack_PhiRes_Track_Eta = fs->make( "hTrack_PhiRes_Track_Eta", "TTTrack #phi res. vs #eta", 180, -M_PI, M_PI, 100, -0.1, 0.1 ); - hTrack_Eta_Seed_Eta = fs->make( "hTrack_Eta_Seed_Eta", "TTTrack #eta vs. Seed #eta", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hTrack_EtaRes_Track_Eta = fs->make( "hTrack_EtaRes_Track_Eta", "TTTrack #eta res. vs #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hTrack_VtxZ0_Seed_VtxZ0 = fs->make( "hTrack_VtxZ0_Seed_VtxZ0", "TTTrack z_{vtx} vs. Seed z_{vtx}", 180, -30, 30, 180, -30, 30 ); - hTrack_VtxZ0Res_Track_Eta = fs->make( "hTrack_VtxZ0Res_Track_Eta", "TTTrack z_{vtx} res. vs #eta", 180, -M_PI, M_PI, 100, -20, 20 ); - - hTrack_NStubs_Sector->Sumw2(); - hTrack_NStubs_Wedge->Sumw2(); - hTrack_Sector_Phi->Sumw2(); - hTrack_Wedge_Eta->Sumw2(); - hTrack_RInv_Seed_RInv->Sumw2(); - hTrack_RInvRes_Track_Eta->Sumw2(); - hTrack_Pt_Seed_Pt->Sumw2(); - hTrack_PtRes_Track_Eta->Sumw2(); - hTrack_Phi_Seed_Phi->Sumw2(); - hTrack_PhiRes_Track_Eta->Sumw2(); - hTrack_Eta_Seed_Eta->Sumw2(); - hTrack_EtaRes_Track_Eta->Sumw2(); - hTrack_VtxZ0_Seed_VtxZ0->Sumw2(); - hTrack_VtxZ0Res_Track_Eta->Sumw2(); - - for ( unsigned int seed = 1; seed < 11; seed++ ) - { - for ( unsigned int targ = 1; targ < 11; targ++ ) - { - std::pair< unsigned int, unsigned int > mapKey = std::make_pair( seed, targ ); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_Eta_L" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi vs seed #eta, Propagation from L " << seed << " to L " << targ; - mapTrackPropBB_deltaRhoPhi_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_L" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi, Propagation from L " << seed << " to L " << targ; - mapTrackPropBB_deltaRhoPhi[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaZ_Eta_L" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Deltaz vs seed #eta, Propagation from L " << seed << " to L " << targ; - mapTrackPropBB_deltaZ_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 200, -4, 4 ); - - histoName.str(""); histoName << "hTrackProp_deltaZ_L" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Deltaz, Propagation from L " << seed << " to L " << targ; - mapTrackPropBB_deltaZ[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 200, -4, 4 ); - - mapTrackPropBB_deltaRhoPhi_Eta[ mapKey ]->Sumw2(); - mapTrackPropBB_deltaRhoPhi[ mapKey ]->Sumw2(); - mapTrackPropBB_deltaZ_Eta[ mapKey ]->Sumw2(); - mapTrackPropBB_deltaZ[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_Eta_L" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi vs seed #eta, Propagation from L " << seed << " to D " << targ; - mapTrackPropBE_deltaRhoPhi_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_L" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi, Propagation from L " << seed << " to D " << targ; - mapTrackPropBE_deltaRhoPhi[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaR_Eta_L" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho vs seed #eta, Propagation from L " << seed << " to D " << targ; - mapTrackPropBE_deltaR_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 200, -4, 4 ); - - histoName.str(""); histoName << "hTrackProp_deltaR_L" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho, Propagation from L " << seed << " to D " << targ; - mapTrackPropBE_deltaR[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 200, -4, 4 ); - - mapTrackPropBE_deltaRhoPhi_Eta[ mapKey ]->Sumw2(); - mapTrackPropBE_deltaRhoPhi[ mapKey ]->Sumw2(); - mapTrackPropBE_deltaR_Eta[ mapKey ]->Sumw2(); - mapTrackPropBE_deltaR[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_Eta_D" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi vs seed #eta, Propagation from D " << seed << " to L " << targ; - mapTrackPropEB_deltaRhoPhi_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_D" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi, Propagation from D " << seed << " to L " << targ; - mapTrackPropEB_deltaRhoPhi[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaZ_Eta_D" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Deltaz vs seed #eta, Propagation from D " << seed << " to L " << targ; - mapTrackPropEB_deltaZ_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 400, -8, 8 ); - - histoName.str(""); histoName << "hTrackProp_deltaZ_D" << seed << "_L" << targ; - histoTitle.str(""); histoTitle << "#Deltaz, Propagation from D " << seed << " to L " << targ; - mapTrackPropEB_deltaZ[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 400, -8, 8 ); - - mapTrackPropEB_deltaRhoPhi_Eta[ mapKey ]->Sumw2(); - mapTrackPropEB_deltaRhoPhi[ mapKey ]->Sumw2(); - mapTrackPropEB_deltaZ_Eta[ mapKey ]->Sumw2(); - mapTrackPropEB_deltaZ[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_Eta_D" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi vs seed #eta, Propagation from D " << seed << " to D " << targ; - mapTrackPropEE_deltaRhoPhi_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaRhoPhi_D" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho#phi, Propagation from D " << seed << " to D " << targ; - mapTrackPropEE_deltaRhoPhi[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 100, -1, 1 ); - - histoName.str(""); histoName << "hTrackProp_deltaR_Eta_D" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho vs seed #eta, Propagation from D " << seed << " to D " << targ; - mapTrackPropEE_deltaR_Eta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 180, -M_PI, M_PI, 200, -4, 4 ); - - histoName.str(""); histoName << "hTrackProp_deltaR_D" << seed << "_D" << targ; - histoTitle.str(""); histoTitle << "#Delta#rho, Propagation from D " << seed << " to D " << targ; - mapTrackPropEE_deltaR[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), - 200, -4, 4 ); - - mapTrackPropEE_deltaRhoPhi_Eta[ mapKey ]->Sumw2(); - mapTrackPropEE_deltaRhoPhi[ mapKey ]->Sumw2(); - mapTrackPropEE_deltaR_Eta[ mapKey ]->Sumw2(); - mapTrackPropEE_deltaR[ mapKey ]->Sumw2(); - } - } - - hTrack_3Stubs_Pt = fs->make( "hTrack_3Stubs_Pt", "TTTrack 3Stubs p_{T}", 100, 0, 50 ); - hTrack_3Stubs_Phi = fs->make( "hTrack_3Stubs_Phi", "TTTrack 3Stubs #phi", 180, -M_PI, M_PI ); - hTrack_3Stubs_Eta = fs->make( "hTrack_3Stubs_Eta", "TTTrack 3Stubs #eta", 180, -M_PI, M_PI ); - hTrack_3Stubs_Pt->Sumw2(); - hTrack_3Stubs_Phi->Sumw2(); - hTrack_3Stubs_Eta->Sumw2(); - - hTrack_2Stubs_Pt = fs->make( "hTrack_2Stubs_Pt", "TTTrack 2Stubs p_{T}", 100, 0, 50 ); - hTrack_2Stubs_Phi = fs->make( "hTrack_2Stubs_Phi", "TTTrack 2Stubs #phi", 180, -M_PI, M_PI ); - hTrack_2Stubs_Eta = fs->make( "hTrack_2Stubs_Eta", "TTTrack 2Stubs #eta", 180, -M_PI, M_PI ); - hTrack_2Stubs_Pt->Sumw2(); - hTrack_2Stubs_Phi->Sumw2(); - hTrack_2Stubs_Eta->Sumw2(); - - hTrack_Seed_Pt = fs->make( "hTrack_Seed_Pt", "TTTrack Seed p_{T}", 100, 0, 50 ); - hTrack_Seed_Phi = fs->make( "hTrack_Seed_Phi", "TTTrack Seed #phi", 180, -M_PI, M_PI ); - hTrack_Seed_Eta = fs->make( "hTrack_Seed_Eta", "TTTrack Seed #eta", 180, -M_PI, M_PI ); - hTrack_Seed_Pt->Sumw2(); - hTrack_Seed_Phi->Sumw2(); - hTrack_Seed_Eta->Sumw2(); - - hSeed_Pt = fs->make( "hSeed_Pt", "Seed p_{T}", 100, 0, 50 ); - hSeed_Phi = fs->make( "hSeed_Phi", "Seed #phi", 180, -M_PI, M_PI ); - hSeed_Eta = fs->make( "hSeed_Eta", "Seed #eta", 180, -M_PI, M_PI ); - hSeed_Pt->Sumw2(); - hSeed_Phi->Sumw2(); - hSeed_Eta->Sumw2(); - - hTPart_Track_3Stubs_Pt = fs->make( "hTPart_Track_3Stubs_Pt", "TTTrack 3Stubs TPart p_{T}", 100, 0, 50 ); - hTPart_Track_3Stubs_Phi_Pt5 = fs->make( "hTPart_Track_3Stubs_Phi_Pt5", "TTTrack 3Stubs TPart #phi", 180, -M_PI, M_PI ); - hTPart_Track_3Stubs_Eta_Pt5 = fs->make( "hTPart_Track_3Stubs_Eta_Pt5", "TTTrack 3Stubs TPart #eta", 180, -M_PI, M_PI ); - hTPart_Track_3Stubs_Pt->Sumw2(); - hTPart_Track_3Stubs_Phi_Pt5->Sumw2(); - hTPart_Track_3Stubs_Eta_Pt5->Sumw2(); - - hTPart_Track_2Stubs_Pt = fs->make( "hTPart_Track_2Stubs_Pt", "TTTrack 2Stubs TPart p_{T}", 100, 0, 50 ); - hTPart_Track_2Stubs_Phi_Pt5 = fs->make( "hTPart_Track_2Stubs_Phi_Pt5", "TTTrack 2Stubs TPart #phi", 180, -M_PI, M_PI ); - hTPart_Track_2Stubs_Eta_Pt5 = fs->make( "hTPart_Track_2Stubs_Eta_Pt5", "TTTrack 2Stubs TPart #eta", 180, -M_PI, M_PI ); - hTPart_Track_2Stubs_Pt->Sumw2(); - hTPart_Track_2Stubs_Phi_Pt5->Sumw2(); - hTPart_Track_2Stubs_Eta_Pt5->Sumw2(); - - hTPart_Seed_Pt = fs->make( "hTPart_Seed_Pt", "Seed TPart p_{T}", 100, 0, 50 ); - hTPart_Seed_Phi_Pt5 = fs->make( "hTPart_Seed_Phi_Pt5", "Seed TPart #phi", 180, -M_PI, M_PI ); - hTPart_Seed_Eta_Pt5 = fs->make( "hTPart_Seed_Eta_Pt5", "Seed TPart #eta", 180, -M_PI, M_PI ); - hTPart_Seed_Pt->Sumw2(); - hTPart_Seed_Phi_Pt5->Sumw2(); - hTPart_Seed_Eta_Pt5->Sumw2(); - - hTPart_Cluster_Pt = fs->make( "hTPart_Cluster_Pt", "Cluster TPart p_{T}", 100, 0, 50 ); - hTPart_Cluster_Phi_Pt5 = fs->make( "hTPart_Cluster_Phi_Pt5", "Cluster TPart #phi", 180, -M_PI, M_PI ); - hTPart_Cluster_Eta_Pt5 = fs->make( "hTPart_Cluster_Eta_Pt5", "Cluster TPart #eta", 180, -M_PI, M_PI ); - hTPart_Cluster_Pt->Sumw2(); - hTPart_Cluster_Phi_Pt5->Sumw2(); - hTPart_Cluster_Eta_Pt5->Sumw2(); - - hTPart_Stub_Pt = fs->make( "hTPart_Stub_Pt", "Stub TPart p_{T}", 100, 0, 50 ); - hTPart_Stub_Phi_Pt5 = fs->make( "hTPart_Stub_Phi_Pt5", "Stub TPart #phi", 180, -M_PI, M_PI ); - hTPart_Stub_Eta_Pt5 = fs->make( "hTPart_Stub_Eta_Pt5", "Stub TPart #eta", 180, -M_PI, M_PI ); - hTPart_Stub_Pt->Sumw2(); - hTPart_Stub_Phi_Pt5->Sumw2(); - hTPart_Stub_Eta_Pt5->Sumw2(); - - hTrack_3Stubs_N = fs->make( "hTrack_3Stubs_N", "Number of TTTrack 3Stubs", 100, -0.5, 99.5 ); - hTrack_3Stubs_Pt_TPart_Pt = fs->make( "hTrack_3Stubs_Pt_TPart_Pt", "TTTrack 3Stubs p_{T} vs. TPart p_{T}", 100, 0, 50, 100, 0, 50 ); - hTrack_3Stubs_PtRes_TPart_Eta = fs->make( "hTrack_3Stubs_PtRes_TPart_Eta", "TTTrack 3Stubs p_{T} - TPart p_{T} vs. TPart #eta", 180, -M_PI, M_PI, 200, -4.0, 4.0 ); - hTrack_3Stubs_InvPt_TPart_InvPt = fs->make( "hTrack_3Stubs_InvPt_TPart_InvPt", "TTTrack 3Stubs p_{T}^{-1} vs. TPart p_{T}^{-1}", 200, 0, 0.8, 200, 0, 0.8 ); - hTrack_3Stubs_InvPt_TPart_InvPt->GetXaxis()->Set( NumBins, BinVec ); - hTrack_3Stubs_InvPt_TPart_InvPt->GetYaxis()->Set( NumBins, BinVec ); - hTrack_3Stubs_InvPtRes_TPart_Eta = fs->make( "hTrack_3Stubs_InvPtRes_TPart_Eta", "TTTrack 3Stubs p_{T}^{-1} - TPart p_{T}^{-1} vs. TPart #eta", 180, -M_PI, M_PI, 100, -1.0, 1.0 ); - hTrack_3Stubs_Phi_TPart_Phi = fs->make( "hTrack_3Stubs_Phi_TPart_Phi", "TTTrack 3Stubs #phi vs. TPart #phi", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hTrack_3Stubs_PhiRes_TPart_Eta = fs->make( "hTrack_3Stubs_PhiRes_TPart_Eta", "TTTrack 3Stubs #phi - TPart #phi vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hTrack_3Stubs_Eta_TPart_Eta = fs->make( "hTrack_3Stubs_Eta_TPart_Eta", "TTTrack 3Stubs #eta vs. TPart #eta", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hTrack_3Stubs_EtaRes_TPart_Eta = fs->make( "hTrack_3Stubs_EtaRes_TPart_Eta", "TTTrack 3Stubs #eta - TPart #eta vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hTrack_3Stubs_VtxZ0_TPart_VtxZ0 = fs->make( "hTrack_3Stubs_VtxZ0_TPart_VtxZ0", "TTTrack 3Stubs z_{vtx} vs. TPart z_{vtx}", 180, -30, 30, 180, -30, 30 ); - hTrack_3Stubs_VtxZ0Res_TPart_Eta = fs->make( "hTrack_3Stubs_VtxZ0Res_TPart_Eta", "TTTrack 3Stubs z_{vtx} - TPart z_{vtx} vs. TPart #eta", 180, -M_PI, M_PI, 100, -5, 5 ); - hTrack_3Stubs_Chi2_NStubs = fs->make( "hTrack_3Stubs_Chi2_NStubs", "TTTrack 3Stubs #chi^{2} vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 50 ); - hTrack_3Stubs_Chi2_TPart_Eta = fs->make( "hTrack_3Stubs_Chi2_TPart_Eta", "TTTrack 3Stubs #chi^{2} vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 50 ); - hTrack_3Stubs_Chi2Red_NStubs = fs->make( "hTrack_3Stubs_Chi2Red_NStubs", "TTTrack 3Stubs #chi^{2}/dof vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 10 ); - hTrack_3Stubs_Chi2Red_TPart_Eta = fs->make( "hTrack_3Stubs_Chi2Red_TPart_Eta", "TTTrack 3Stubs #chi^{2}/dof vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 10 ); - hTrack_3Stubs_N->Sumw2(); - hTrack_3Stubs_Pt_TPart_Pt->Sumw2(); - hTrack_3Stubs_PtRes_TPart_Eta->Sumw2(); - hTrack_3Stubs_InvPt_TPart_InvPt->Sumw2(); - hTrack_3Stubs_InvPtRes_TPart_Eta->Sumw2(); - hTrack_3Stubs_Phi_TPart_Phi->Sumw2(); - hTrack_3Stubs_PhiRes_TPart_Eta->Sumw2(); - hTrack_3Stubs_Eta_TPart_Eta->Sumw2(); - hTrack_3Stubs_EtaRes_TPart_Eta->Sumw2(); - hTrack_3Stubs_VtxZ0_TPart_VtxZ0->Sumw2(); - hTrack_3Stubs_VtxZ0Res_TPart_Eta->Sumw2(); - hTrack_3Stubs_Chi2_NStubs->Sumw2(); - hTrack_3Stubs_Chi2_TPart_Eta->Sumw2(); - hTrack_3Stubs_Chi2Red_NStubs->Sumw2(); - hTrack_3Stubs_Chi2Red_TPart_Eta->Sumw2(); - - hTPart_Eta_Normalization = fs->make("hTPart_Eta_Normalization", "TParticles vs. TPart #eta", 90, 0, M_PI ); - hTPart_Eta_NStubs = fs->make("hTPart_Eta_NStubs" , "N Stubs vs. TPart #eta" , 90, 0, M_PI ); - hTPart_Eta_Normalization->Sumw2(); - hTPart_Eta_NStubs->Sumw2(); - - /// Prepare for 1D resolution plots - - for ( unsigned int iPt = 0; iPt < maxPtBin; iPt++ ) - { - for ( unsigned int iEta = 0; iEta < maxEtaBin; iEta++ ) - { - std::pair< unsigned int, unsigned int > mapKey = std::make_pair( iPt, iEta ); - - histoName.str(""); histoName << "hTrack_3Stubs_Chi2_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track 3Stubs #chi^{2}, " << vStringPt.at(iPt).c_str() << " " << vStringEta.at(iEta).c_str(); - mapTrack_3Stubs_Chi2_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 50, 0, 50 ); - mapTrack_3Stubs_Chi2_PtEta[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrack_3Stubs_Chi2Red_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track 3Stubs #chi^{2}/dof, " << vStringPt.at(iPt).c_str() << " " << vStringEta.at(iEta).c_str(); - mapTrack_3Stubs_Chi2Red_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 50, 0, 10 ); - mapTrack_3Stubs_Chi2Red_PtEta[ mapKey ]->Sumw2(); - } - } - - double minPt = 0; - double minEta = 0; - for ( unsigned int iPt = 0; iPt < maxPtBinRes; iPt++ ) - { - minPt = ptBinSize * iPt; - for ( unsigned int iEta = 0; iEta < maxEtaBinRes; iEta++ ) - { - std::pair< unsigned int, unsigned int > mapKey = std::make_pair( iPt, iEta ); - - minEta = etaBinSize * iEta; - - histoName.str(""); histoName << "hTrack_3Stubs_PtRes_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track p_{T} - TPart p_{T}, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_PtRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -4, 4 ); - mapTrack_3Stubs_PtRes_PtEta[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrack_3Stubs_InvPtRes_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track p_{T}^{-1} - TPart p_{T}^{-1}, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_InvPtRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -1, 1 ); - mapTrack_3Stubs_InvPtRes_PtEta[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrack_3Stubs_RelPtRes_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track p_{T}/TPart p_{T} - 1, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_RelPtRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); - mapTrack_3Stubs_RelPtRes_PtEta[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrack_3Stubs_PhiRes_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track #phi - TPart #phi, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_PhiRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); - mapTrack_3Stubs_PhiRes_PtEta[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrack_3Stubs_EtaRes_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track #eta - TPart #eta, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_EtaRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); - mapTrack_3Stubs_EtaRes_PtEta[ mapKey ]->Sumw2(); - - histoName.str(""); histoName << "hTrack_3Stubs_CotThetaRes_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track cot(#theta) - TPart cot(#theta), p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_CotThetaRes_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); - mapTrack_3Stubs_CotThetaRes_PtEta[ mapKey ]->Sumw2(); - - - histoName.str(""); histoName << "hTrack_3Stubs_VtxZ0Res_Pt" << iPt << "_Eta" << iEta; - histoTitle.str(""); histoTitle << "Track z_{vtx} - TPart z_{vtx}, p_{T} in [" << minPt << ", " << (minPt + ptBinSize) << - "), |#eta| in [" << minEta << ", " << (minEta + etaBinSize) << ")"; - mapTrack_3Stubs_VtxZ0Res_PtEta[ mapKey ] = fs->make( histoName.str().c_str(), histoTitle.str().c_str(), 200, -0.5, 0.5 ); - mapTrack_3Stubs_VtxZ0Res_PtEta[ mapKey ]->Sumw2(); - } - } - - hTrack_2Stubs_N = fs->make( "hTrack_2Stubs_N", "Number of TTTrack 2Stubs", 100, -0.5, 99.5 ); - hTrack_2Stubs_Pt_TPart_Pt = fs->make( "hTrack_2Stubs_Pt_TPart_Pt", "TTTrack 2Stubs p_{T} vs. TPart p_{T}", 100, 0, 50, 100, 0, 50 ); - hTrack_2Stubs_PtRes_TPart_Eta = fs->make( "hTrack_2Stubs_PtRes_TPart_Eta", "TTTrack 2Stubs p_{T} - TPart p_{T} vs. TPart #eta", 180, -M_PI, M_PI, 200, -4.0, 4.0 ); - hTrack_2Stubs_InvPt_TPart_InvPt = fs->make( "hTrack_2Stubs_InvPt_TPart_InvPt", "TTTrack 2Stubs p_{T}^{-1} vs. TPart p_{T}^{-1}", 200, 0, 0.8, 200, 0, 0.8 ); - hTrack_2Stubs_InvPt_TPart_InvPt->GetXaxis()->Set( NumBins, BinVec ); - hTrack_2Stubs_InvPt_TPart_InvPt->GetYaxis()->Set( NumBins, BinVec ); - hTrack_2Stubs_InvPtRes_TPart_Eta = fs->make( "hTrack_2Stubs_InvPtRes_TPart_Eta", "TTTrack 2Stubs p_{T}^{-1} - TPart p_{T}^{-1} vs. TPart #eta", 180, -M_PI, M_PI, 100, -1.0, 1.0 ); - hTrack_2Stubs_Phi_TPart_Phi = fs->make( "hTrack_2Stubs_Phi_TPart_Phi", "TTTrack 2Stubs #phi vs. TPart #phi", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hTrack_2Stubs_PhiRes_TPart_Eta = fs->make( "hTrack_2Stubs_PhiRes_TPart_Eta", "TTTrack 2Stubs #phi - TPart #phi vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hTrack_2Stubs_Eta_TPart_Eta = fs->make( "hTrack_2Stubs_Eta_TPart_Eta", "TTTrack 2Stubs #eta vs. TPart #eta", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hTrack_2Stubs_EtaRes_TPart_Eta = fs->make( "hTrack_2Stubs_EtaRes_TPart_Eta", "TTTrack 2Stubs #eta - TPart #eta vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hTrack_2Stubs_VtxZ0_TPart_VtxZ0 = fs->make( "hTrack_2Stubs_VtxZ0_TPart_VtxZ0", "TTTrack 2Stubs z_{vtx} vs. TPart z_{vtx}", 180, -30, 30, 180, -30, 30 ); - hTrack_2Stubs_VtxZ0Res_TPart_Eta = fs->make( "hTrack_2Stubs_VtxZ0Res_TPart_Eta", "TTTrack 2Stubs z_{vtx} - TPart z_{vtx} vs. TPart #eta", 180, -M_PI, M_PI, 100, -5, 5 ); - hTrack_2Stubs_Chi2_NStubs = fs->make( "hTrack_2Stubs_Chi2_NStubs", "TTTrack 2Stubs #chi^{2} vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 50 ); - hTrack_2Stubs_Chi2_TPart_Eta = fs->make( "hTrack_2Stubs_Chi2_TPart_Eta", "TTTrack 2Stubs #chi^{2} vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 50 ); - hTrack_2Stubs_Chi2Red_NStubs = fs->make( "hTrack_2Stubs_Chi2Red_NStubs", "TTTrack 2Stubs #chi^{2}/dof vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 10 ); - hTrack_2Stubs_Chi2Red_TPart_Eta = fs->make( "hTrack_2Stubs_Chi2Red_TPart_Eta", "TTTrack 2Stubs #chi^{2}/dof vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 10 ); - - hTrack_2Stubs_N->Sumw2(); - hTrack_2Stubs_Pt_TPart_Pt->Sumw2(); - hTrack_2Stubs_PtRes_TPart_Eta->Sumw2(); - hTrack_2Stubs_InvPt_TPart_InvPt->Sumw2(); - hTrack_2Stubs_InvPtRes_TPart_Eta->Sumw2(); - hTrack_2Stubs_Phi_TPart_Phi->Sumw2(); - hTrack_2Stubs_PhiRes_TPart_Eta->Sumw2(); - hTrack_2Stubs_Eta_TPart_Eta->Sumw2(); - hTrack_2Stubs_EtaRes_TPart_Eta->Sumw2(); - hTrack_2Stubs_VtxZ0_TPart_VtxZ0->Sumw2(); - hTrack_2Stubs_VtxZ0Res_TPart_Eta->Sumw2(); - hTrack_2Stubs_Chi2_NStubs->Sumw2(); - hTrack_2Stubs_Chi2_TPart_Eta->Sumw2(); - hTrack_2Stubs_Chi2Red_NStubs->Sumw2(); - hTrack_2Stubs_Chi2Red_TPart_Eta->Sumw2(); - - hSeed_N = fs->make( "hSeed_N", "Number of Seed", 100, -0.5, 99.5 ); - hSeed_Pt_TPart_Pt = fs->make( "hSeed_Pt_TPart_Pt", "Seed p_{T} vs. TPart p_{T}", 100, 0, 50, 100, 0, 50 ); - hSeed_PtRes_TPart_Eta = fs->make( "hSeed_PtRes_TPart_Eta", "Seed p_{T} - TPart p_{T} vs. TPart #eta", 180, -M_PI, M_PI, 200, -4.0, 4.0 ); - hSeed_InvPt_TPart_InvPt = fs->make( "hSeed_InvPt_TPart_InvPt", "Seed p_{T}^{-1} vs. TPart p_{T}^{-1}", 200, 0, 0.8, 200, 0, 0.8 ); - hSeed_InvPt_TPart_InvPt->GetXaxis()->Set( NumBins, BinVec ); - hSeed_InvPt_TPart_InvPt->GetYaxis()->Set( NumBins, BinVec ); - hSeed_InvPtRes_TPart_Eta = fs->make( "hSeed_InvPtRes_TPart_Eta", "Seed p_{T}^{-1} - TPart p_{T}^{-1} vs. TPart #eta", 180, -M_PI, M_PI, 100, -1.0, 1.0 ); - hSeed_Phi_TPart_Phi = fs->make( "hSeed_Phi_TPart_Phi", "Seed #phi vs. TPart #phi", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hSeed_PhiRes_TPart_Eta = fs->make( "hSeed_PhiRes_TPart_Eta", "Seed #phi - TPart #phi vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hSeed_Eta_TPart_Eta = fs->make( "hSeed_Eta_TPart_Eta", "Seed #eta vs. TPart #eta", 180, -M_PI, M_PI, 180, -M_PI, M_PI ); - hSeed_EtaRes_TPart_Eta = fs->make( "hSeed_EtaRes_TPart_Eta", "Seed #eta - TPart #eta vs. TPart #eta", 180, -M_PI, M_PI, 100, -0.5, 0.5 ); - hSeed_VtxZ0_TPart_VtxZ0 = fs->make( "hSeed_VtxZ0_TPart_VtxZ0", "Seed z_{vtx} vs. TPart z_{vtx}", 180, -30, 30, 180, -30, 30 ); - hSeed_VtxZ0Res_TPart_Eta = fs->make( "hSeed_VtxZ0Res_TPart_Eta", "Seed z_{vtx} - TPart z_{vtx} vs. TPart #eta", 180, -M_PI, M_PI, 100, -5, 5 ); - hSeed_Chi2_NStubs = fs->make( "hSeed_Chi2_NStubs", "Seed #chi^{2} vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 50 ); - hSeed_Chi2_TPart_Eta = fs->make( "hSeed_Chi2_TPart_Eta", "Seed #chi^{2} vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 50 ); - hSeed_Chi2Red_NStubs = fs->make( "hSeed_Chi2Red_NStubs", "Seed #chi^{2}/dof vs. number of Stubs", 20, -0.5, 19.5, 200, 0, 10 ); - hSeed_Chi2Red_TPart_Eta = fs->make( "hSeed_Chi2Red_TPart_Eta", "Seed #chi^{2}/dof vs. TPart #eta", 180, -M_PI, M_PI, 200, 0, 10 ); - hSeed_N->Sumw2(); - hSeed_Pt_TPart_Pt->Sumw2(); - hSeed_PtRes_TPart_Eta->Sumw2(); - hSeed_InvPt_TPart_InvPt->Sumw2(); - hSeed_InvPtRes_TPart_Eta->Sumw2(); - hSeed_Phi_TPart_Phi->Sumw2(); - hSeed_PhiRes_TPart_Eta->Sumw2(); - hSeed_Eta_TPart_Eta->Sumw2(); - hSeed_EtaRes_TPart_Eta->Sumw2(); - hSeed_VtxZ0_TPart_VtxZ0->Sumw2(); - hSeed_VtxZ0Res_TPart_Eta->Sumw2(); - hSeed_Chi2_NStubs->Sumw2(); - hSeed_Chi2_TPart_Eta->Sumw2(); - hSeed_Chi2Red_NStubs->Sumw2(); - hSeed_Chi2Red_TPart_Eta->Sumw2(); - - /// End of things to be done before entering the event Loop -} - -////////// -// ANALYZE -void ValidateL1Track::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) -{ - /// Get geometry - edm::ESHandle< StackedTrackerGeometry > StackedGeometryHandle; - const StackedTrackerGeometry* theStackedGeometry; - iSetup.get< StackedTrackerGeometryRecord >().get(StackedGeometryHandle); - theStackedGeometry = StackedGeometryHandle.product(); - - /// Track Trigger - edm::Handle< std::vector< TTCluster< Ref_PixelDigi_ > > > PixelDigiTTClusterHandle; - edm::Handle< std::vector< TTStub< Ref_PixelDigi_ > > > PixelDigiTTStubHandle; - iEvent.getByLabel( "TTClustersFromPixelDigis", PixelDigiTTClusterHandle ); - iEvent.getByLabel( "TTStubsFromPixelDigis", "StubsPass", PixelDigiTTStubHandle ); - edm::Handle< std::vector< TTTrack< Ref_PixelDigi_ > > > PixelDigiTTSeedHandle; - edm::Handle< std::vector< TTTrack< Ref_PixelDigi_ > > > PixelDigiTTTrackHandle; - iEvent.getByLabel( "TTTracksFromPixelDigis", "Seeds", PixelDigiTTSeedHandle ); - iEvent.getByLabel( "TTTracksFromPixelDigis", "NoDup", PixelDigiTTTrackHandle ); - - /// Track Trigger MC Truth - edm::Handle< TTClusterAssociationMap< Ref_PixelDigi_ > > MCTruthTTClusterHandle; - edm::Handle< TTStubAssociationMap< Ref_PixelDigi_ > > MCTruthTTStubHandle; - iEvent.getByLabel( "TTClusterAssociatorFromPixelDigis", MCTruthTTClusterHandle ); - iEvent.getByLabel( "TTStubAssociatorFromPixelDigis", MCTruthTTStubHandle ); - edm::Handle< TTTrackAssociationMap< Ref_PixelDigi_ > > MCTruthTTTrackHandle; - edm::Handle< TTTrackAssociationMap< Ref_PixelDigi_ > > MCTruthTTSeedHandle; - iEvent.getByLabel( "TTTrackAssociatorFromPixelDigis", "NoDup", MCTruthTTTrackHandle ); - iEvent.getByLabel( "TTTrackAssociatorFromPixelDigis", "Seeds", MCTruthTTSeedHandle ); - - /// TrackingParticles - edm::Handle< std::vector< TrackingParticle > > TrackingParticleHandle; - iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingParticleHandle ); - edm::Handle< std::vector< TrackingVertex > > TrackingVertexHandle; - iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingVertexHandle ); - - /// Loop over TrackingParticles - if ( TrackingParticleHandle->size() > 0 ) - { - unsigned int tpCnt = 0; - std::vector< TrackingParticle >::const_iterator iterTP; - for ( iterTP = TrackingParticleHandle->begin(); - iterTP != TrackingParticleHandle->end(); - ++iterTP ) - { - /// Make the pointer - edm::Ptr< TrackingParticle > tempTPPtr( TrackingParticleHandle, tpCnt++ ); - - /// Skip non-primary track - if ( tempTPPtr->vertex().rho() >= 2.0 ) - continue; - - /// Check if this TP produced any clusters - if ( MCTruthTTClusterHandle->findTTClusterPtrs( tempTPPtr ).size() > 0 ) - { - hTPart_Cluster_Pt->Fill( tempTPPtr->p4().pt() ); - if ( tempTPPtr->p4().pt() > 5.0 ) - { - hTPart_Cluster_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); - hTPart_Cluster_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); - } - - /// Check if the TP produced any stubs - if ( MCTruthTTStubHandle->findTTStubPtrs( tempTPPtr ).size() > 0 ) - { - hTPart_Stub_Pt->Fill( tempTPPtr->p4().pt() ); - if ( tempTPPtr->p4().pt() > 5.0 ) - { - hTPart_Stub_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); - hTPart_Stub_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); - } - - /// Check if the TP produced any seeds - if ( MCTruthTTSeedHandle->findTTTrackPtrs( tempTPPtr ).size() > 0 ) - { - hTPart_Seed_Pt->Fill( tempTPPtr->p4().pt() ); - if ( tempTPPtr->p4().pt() > 5.0 ) - { - hTPart_Seed_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); - hTPart_Seed_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); - } - - ///Check if the TP produced any Tracks - if ( MCTruthTTTrackHandle->findTTTrackPtrs( tempTPPtr ).size() > 0 ) - { - /// Distinguish between 2-stubs-only and 3-stubs-minimum - bool found2stubs = false; - bool found3stubs = false; - std::vector< edm::Ptr< TTTrack< Ref_PixelDigi_ > > > theseTracks = MCTruthTTTrackHandle->findTTTrackPtrs( tempTPPtr ); - for ( unsigned int it = 0; it < theseTracks.size(); it++ ) - { - if ( found2stubs && found3stubs ) - { - it = theseTracks.size(); - continue; - } - - if ( theseTracks.at(it)->getStubPtrs().size() == 2 ) - { - found2stubs = true; - } - else if ( theseTracks.at(it)->getStubPtrs().size() > 2 ) - { - - - /// Additional cross check - bool hasBL1 = theseTracks.at(it)->hasStubInBarrel(1) ; -if ( hasBL1 ) -{ -} - found3stubs = true; -//} - - } - } - - if ( found2stubs ) - { - hTPart_Track_2Stubs_Pt->Fill( tempTPPtr->p4().pt() ); - if ( tempTPPtr->p4().pt() > 5.0 ) - { - hTPart_Track_2Stubs_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); - hTPart_Track_2Stubs_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); - } - } - - if ( found3stubs ) - { - hTPart_Track_3Stubs_Pt->Fill( tempTPPtr->p4().pt() ); - if ( tempTPPtr->p4().pt() > 5.0 ) - { - hTPart_Track_3Stubs_Phi_Pt5->Fill( tempTPPtr->momentum().phi() ); - hTPart_Track_3Stubs_Eta_Pt5->Fill( tempTPPtr->momentum().eta() ); - } - } - } - } - } - } - } /// End of loop over TrackingParticles - } - - unsigned int num3Stubs = 0; - unsigned int num2Stubs = 0; - - /// Go on only if there are TTTracks from PixelDigis - if ( PixelDigiTTTrackHandle->size() > 0 ) - { - /// Loop over TTTracks - unsigned int tkCnt = 0; - std::vector< TTTrack< Ref_PixelDigi_ > >::const_iterator iterTTTrack; - for ( iterTTTrack = PixelDigiTTTrackHandle->begin(); - iterTTTrack != PixelDigiTTTrackHandle->end(); - ++iterTTTrack ) - { - /// Make the pointer - edm::Ptr< TTTrack< Ref_PixelDigi_ > > tempTrackPtr( PixelDigiTTTrackHandle, tkCnt++ ); - - /// Get everything is relevant - unsigned int nStubs = tempTrackPtr->getStubPtrs().size(); - unsigned int seedSector = tempTrackPtr->getSector(); - unsigned int seedWedge = tempTrackPtr->getWedge(); - - hTrack_NStubs_Sector->Fill( seedSector, nStubs ); - hTrack_NStubs_Wedge->Fill( seedWedge, nStubs ); - - double trackRInv = tempTrackPtr->getRInv(); - double trackPt = tempTrackPtr->getMomentum().perp(); - double trackPhi = tempTrackPtr->getMomentum().phi(); - double trackEta = tempTrackPtr->getMomentum().eta(); - double trackTheta = tempTrackPtr->getMomentum().theta(); - double trackVtxZ0 = tempTrackPtr->getVertex().z(); - double trackChi2 = tempTrackPtr->getChi2(); - double trackChi2R = tempTrackPtr->getChi2Red(); - - hTrack_Sector_Phi->Fill( trackPhi, seedSector ); - hTrack_Wedge_Eta->Fill( trackEta, seedWedge ); - - bool genuineTrack = MCTruthTTTrackHandle->isGenuine( tempTrackPtr ); - - if ( !genuineTrack ) continue; - - edm::Ptr< TrackingParticle > tpPtr = MCTruthTTTrackHandle->findTrackingParticlePtr( tempTrackPtr ); - - /// Get the corresponding vertex and reject the track - /// if its vertex is outside the beampipe - if ( tpPtr->vertex().rho() >= 2 ) - continue; - - double tpPt = tpPtr->p4().pt(); - double tpEta = tpPtr->momentum().eta(); - double tpTheta = tpPtr->momentum().theta(); - double tpPhi = tpPtr->momentum().phi(); - double tpVtxZ0 = tpPtr->vertex().z(); - - if ( nStubs > 2 ) - { - - hTPart_Eta_Normalization->Fill( tpEta ); - hTPart_Eta_NStubs->Fill( tpEta, nStubs ); - - hTrack_3Stubs_Pt->Fill( trackPt ); - hTrack_3Stubs_Eta->Fill( trackEta ); - hTrack_3Stubs_Phi->Fill( trackPhi ); - - num3Stubs++; - hTrack_3Stubs_Pt_TPart_Pt->Fill( tpPt, trackPt ); - hTrack_3Stubs_PtRes_TPart_Eta->Fill( tpEta, trackPt - tpPt ); - hTrack_3Stubs_InvPt_TPart_InvPt->Fill( 1./tpPt, 1./trackPt ); - hTrack_3Stubs_InvPtRes_TPart_Eta->Fill( tpEta, 1./trackPt - 1./tpPt ); - hTrack_3Stubs_Phi_TPart_Phi->Fill( tpPhi, trackPhi ); - hTrack_3Stubs_PhiRes_TPart_Eta->Fill( tpEta, trackPhi - tpPhi ); - hTrack_3Stubs_Eta_TPart_Eta->Fill( tpEta, trackEta ); - hTrack_3Stubs_EtaRes_TPart_Eta->Fill( tpEta, trackEta - tpEta ); - hTrack_3Stubs_VtxZ0_TPart_VtxZ0->Fill( tpVtxZ0, trackVtxZ0 ); - hTrack_3Stubs_VtxZ0Res_TPart_Eta->Fill( tpEta, trackVtxZ0 - tpVtxZ0 ); - hTrack_3Stubs_Chi2_NStubs->Fill( nStubs, trackChi2 ); - hTrack_3Stubs_Chi2_TPart_Eta->Fill( tpEta, trackChi2 ); - hTrack_3Stubs_Chi2Red_NStubs->Fill( nStubs, trackChi2R ); - hTrack_3Stubs_Chi2Red_TPart_Eta->Fill( tpEta, trackChi2R ); - - - /// Additional cross check - bool hasBL1 = tempTrackPtr->hasStubInBarrel(1); -if ( hasBL1 ) -{ -} - /// Find the Pt/Eta bin for the 1D performance plots - unsigned int binPt = maxPtBin; - unsigned int binEta = maxEtaBin; - for ( unsigned int iPt = maxPtBin; iPt > 0; ) - { - iPt--; - if ( tpPt < vLimitsPt.at(iPt) ) - binPt = iPt; - } - for ( unsigned int iEta = maxEtaBin; iEta > 0; ) - { - iEta--; - if ( fabs(tpEta) < vLimitsEta.at(iEta) ) - binEta = iEta; - } - - std::pair< unsigned int, unsigned int > mapKey = std::make_pair( binPt, binEta ); - - mapTrack_3Stubs_Chi2_PtEta[ mapKey ]->Fill( trackChi2 ); - mapTrack_3Stubs_Chi2Red_PtEta[ mapKey ]->Fill( trackChi2R ); - - /// Now, the different Pt/Eta mapping - binPt = 0; - binEta = 0; - for ( unsigned int iPt = 0; iPt < maxPtBinRes; iPt++ ) - { - if ( tpPt >= iPt*ptBinSize ) - binPt = iPt; - } - for ( unsigned int iEta = 0; iEta < maxEtaBinRes; iEta++ ) - { - if ( fabs(tpEta) >= iEta*etaBinSize ) - binEta = iEta; - } - - mapKey = std::make_pair( binPt, binEta ); - - mapTrack_3Stubs_PtRes_PtEta[ mapKey ]->Fill( trackPt - tpPt ); - mapTrack_3Stubs_InvPtRes_PtEta[ mapKey ]->Fill( 1./trackPt - 1./tpPt ); - mapTrack_3Stubs_RelPtRes_PtEta[ mapKey ]->Fill( trackPt / tpPt - 1 ); - mapTrack_3Stubs_PhiRes_PtEta[ mapKey ]->Fill( trackPhi - tpPhi ); - mapTrack_3Stubs_EtaRes_PtEta[ mapKey ]->Fill( trackEta - tpEta ); - mapTrack_3Stubs_CotThetaRes_PtEta[ mapKey ]->Fill( 1./tan(trackTheta) - 1./tan(tpTheta) ); - mapTrack_3Stubs_VtxZ0Res_PtEta[ mapKey ]->Fill( trackVtxZ0 - tpVtxZ0 ); -//} - } - else - { - hTrack_2Stubs_Pt->Fill( trackPt ); - hTrack_2Stubs_Eta->Fill( trackEta ); - hTrack_2Stubs_Phi->Fill( trackPhi ); - - num2Stubs++; - hTrack_2Stubs_Pt_TPart_Pt->Fill( tpPt, trackPt ); - hTrack_2Stubs_PtRes_TPart_Eta->Fill( tpEta, trackPt - tpPt ); - hTrack_2Stubs_InvPt_TPart_InvPt->Fill( 1./tpPt, 1./trackPt ); - hTrack_2Stubs_InvPtRes_TPart_Eta->Fill( tpEta, 1./trackPt - 1./tpPt ); - hTrack_2Stubs_Phi_TPart_Phi->Fill( tpPhi, trackPhi ); - hTrack_2Stubs_PhiRes_TPart_Eta->Fill( tpEta, trackPhi - tpPhi ); - hTrack_2Stubs_Eta_TPart_Eta->Fill( tpEta, trackEta ); - hTrack_2Stubs_EtaRes_TPart_Eta->Fill( tpEta, trackEta - tpEta ); - hTrack_2Stubs_VtxZ0_TPart_VtxZ0->Fill( tpVtxZ0, trackVtxZ0 ); - hTrack_2Stubs_VtxZ0Res_TPart_Eta->Fill( tpEta, trackVtxZ0 - tpVtxZ0 ); - hTrack_2Stubs_Chi2_NStubs->Fill( nStubs, trackChi2 ); - hTrack_2Stubs_Chi2_TPart_Eta->Fill( tpEta, trackChi2 ); - hTrack_2Stubs_Chi2Red_NStubs->Fill( nStubs, trackChi2R ); - hTrack_2Stubs_Chi2Red_TPart_Eta->Fill( tpEta, trackChi2R ); - } - - /// Go on only if there are TTTracks from PixelDigis - if ( PixelDigiTTSeedHandle->size() > 0 ) - { - /// Loop over TTTrack seeds - std::vector< TTTrack< Ref_PixelDigi_ > >::const_iterator iterSeed; - for ( iterSeed = PixelDigiTTSeedHandle->begin(); - iterSeed != PixelDigiTTSeedHandle->end(); - ++iterSeed ) - { - /// Check the track is the same - bool dontSkip = iterTTTrack->isTheSameAs( *iterSeed ); - if ( !dontSkip ) continue; - - /// Get everything is relevant - double seedRInv = iterSeed->getRInv(); - double seedPt = iterSeed->getMomentum().perp(); - double seedPhi = iterSeed->getMomentum().phi(); - double seedEta = iterSeed->getMomentum().eta(); - double seedVtxZ0 = iterSeed->getVertex().z(); - - hTrack_RInv_Seed_RInv->Fill( seedRInv, trackRInv ); - hTrack_RInvRes_Track_Eta->Fill( trackEta, trackRInv - seedRInv ); - hTrack_Pt_Seed_Pt->Fill( seedPt, trackPt ); - hTrack_PtRes_Track_Eta->Fill( trackEta, trackPt - seedPt ); - hTrack_InvPt_Seed_InvPt->Fill( 1./seedPt, 1./trackPt ); - hTrack_InvPtRes_Track_Eta->Fill( trackEta, 1./trackPt - 1./seedPt ); - hTrack_Phi_Seed_Phi->Fill( seedPhi, trackPhi ); - hTrack_PhiRes_Track_Eta->Fill( trackEta, trackPhi - seedPhi ); - hTrack_Eta_Seed_Eta->Fill( seedEta, trackEta ); - hTrack_EtaRes_Track_Eta->Fill( trackEta, trackEta - seedEta ); - hTrack_VtxZ0_Seed_VtxZ0->Fill( seedVtxZ0, trackVtxZ0 ); - hTrack_VtxZ0Res_Track_Eta->Fill( trackEta, trackVtxZ0 - seedVtxZ0 ); - - /// Propagate seed and check distances - StackedTrackerDetId detIdInner( iterSeed->getStubPtrs().at(0)->getDetId() ); -// unsigned int seedSL = (unsigned int)((detIdInner.iLayer() + 1)/2); -// seedSL = ( seedSL > 3 ) ? 3 : seedSL; /// Renormalize 1-3 - - unsigned int seedBarrel0 = 0; - unsigned int seedEndcap0 = 0; - if ( detIdInner.isBarrel() ) seedBarrel0 = detIdInner.iLayer(); - else if ( detIdInner.isEndcap() ) seedEndcap0 = detIdInner.iDisk(); - - /// Loop over track stubs - for ( unsigned int js = 0; js < iterTTTrack->getStubPtrs().size(); js++ ) - { - /// Skip Stubs in the Seed - bool isInSeed = false; - for ( unsigned int ks = 0; ks < iterSeed->getStubPtrs().size(); ks++ ) - { - if ( iterTTTrack->getStubPtrs().at(js) == iterSeed->getStubPtrs().at(ks) ) - isInSeed = true; - } - if ( isInSeed ) continue; - - /// Candidate SL - StackedTrackerDetId detIdCand( iterTTTrack->getStubPtrs().at(js)->getDetId() ); -// unsigned int candSL = (unsigned int)((detIdCand.iLayer() + 1)/2); -// candSL = ( candSL > 3 ) ? 3 : candSL; /// Renormalize 1-3 - - unsigned int candBarrel = 0; - unsigned int candEndcap = 0; - if ( detIdCand.isBarrel() ) candBarrel = detIdCand.iLayer(); - else if ( detIdCand.isEndcap() ) candEndcap = detIdCand.iDisk(); - -// if ( candSL == seedSL ) continue; - - GlobalPoint posStub = theStackedGeometry->findGlobalPosition( &(*iterTTTrack->getStubPtrs().at(js)) ); - - if ( candBarrel ) - { - /// Propagation - double propPsi = asin( posStub.perp() * 0.5 * seedRInv ); - double propPhi = seedPhi - propPsi; - double propRhoPsi = 2 * propPsi / seedRInv; - double propZ = seedVtxZ0 + propRhoPsi * tan( M_PI_2 - iterSeed->getMomentum().theta() ); - - /// Calculate displacement - /// Perform standard trigonometric operations - double deltaPhi = posStub.phi() - propPhi; - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - double deltaRPhi = deltaPhi * posStub.perp(); - double deltaZ = propZ - posStub.z(); - - if ( seedBarrel0 ) - { - std::pair< unsigned int, unsigned int > mapKey0 = std::make_pair( seedBarrel0, candBarrel ); - mapTrackPropBB_deltaRhoPhi_Eta[ mapKey0 ]->Fill( seedEta, deltaRPhi ); - mapTrackPropBB_deltaRhoPhi[ mapKey0 ]->Fill( deltaRPhi ); - mapTrackPropBB_deltaZ_Eta[ mapKey0 ]->Fill( seedEta, deltaZ ); - mapTrackPropBB_deltaZ[ mapKey0 ]->Fill( deltaZ ); - } - else if ( seedEndcap0 ) - { - std::pair< unsigned int, unsigned int > mapKey0 = std::make_pair( seedEndcap0, candBarrel ); - mapTrackPropEB_deltaRhoPhi_Eta[ mapKey0 ]->Fill( seedEta, deltaRPhi ); - mapTrackPropEB_deltaRhoPhi[ mapKey0 ]->Fill( deltaRPhi ); - mapTrackPropEB_deltaZ_Eta[ mapKey0 ]->Fill( seedEta, deltaZ ); - mapTrackPropEB_deltaZ[ mapKey0 ]->Fill( deltaZ ); - } - } - else if ( candEndcap ) - { - /// Propagation - double propPsi = 0.5*( posStub.z() - seedVtxZ0 ) * seedRInv / tan( M_PI_2 - iterSeed->getMomentum().theta() ); - double propPhi = seedPhi - propPsi; - double propRho = 2 * sin( propPsi ) / seedRInv; - double deltaPhi = posStub.phi() - propPhi; - - /// Calculate displacement - if ( fabs(deltaPhi) >= M_PI ) - { - if ( deltaPhi>0 ) - deltaPhi = deltaPhi - 2*M_PI; - else - deltaPhi = 2*M_PI + deltaPhi; - } - double deltaRPhi = deltaPhi * posStub.perp(); /// OLD VERSION (updated few lines below) - double deltaR = posStub.perp() - propRho; - - /// NEW VERSION - non-pointing strips correction - double rhoTrack = 2.0 * sin( 0.5 * seedRInv * ( posStub.z() - seedVtxZ0 ) / tan( M_PI_2 - iterSeed->getMomentum().theta() ) ) / seedRInv; - double phiTrack = iterSeed->getMomentum().phi() - 0.5 * seedRInv * ( posStub.z() - seedVtxZ0 ) / tan( M_PI_2 - iterSeed->getMomentum().theta() ); - - /// Calculate a correction for non-pointing-strips in square modules - /// Relevant angle is the one between hit and module center, with - /// vertex at (0, 0). Take snippet from HitMatchingAlgorithm_window201* - /// POSITION IN TERMS OF PITCH MULTIPLES: - /// 0 1 2 3 4 5 5 6 8 9 ... - /// COORD: 0 1 2 3 4 5 6 7 8 9 ... - /// OUT | | | | | |x| | | | | | | | | | - /// - /// IN | | | |x|x| | | | | | | | | | | - /// THIS is 3.5 (COORD) and 4.0 (POS) - /// The center of the module is at NROWS/2 (position) and NROWS-0.5 (coordinates) - const GeomDetUnit* det0 = theStackedGeometry->idToDetUnit( detIdCand, 0 ); - const PixelGeomDetUnit* pix0 = dynamic_cast< const PixelGeomDetUnit* >( det0 ); - const PixelTopology* top0 = dynamic_cast< const PixelTopology* >( &(pix0->specificTopology()) ); - std::pair< float, float > pitch0 = top0->pitch(); - MeasurementPoint stubCoord = iterTTTrack->getStubPtrs().at(js)->getClusterPtr(0)->findAverageLocalCoordinates(); - double stubTransvDispl = pitch0.first * ( stubCoord.x() - (top0->nrows()/2 - 0.5) ); /// Difference in coordinates is the same as difference in position - if ( posStub.z() > 0 ) - { - stubTransvDispl = - stubTransvDispl; - } - double stubPhiCorr = asin( stubTransvDispl / posStub.perp() ); - deltaRPhi = stubTransvDispl - rhoTrack * sin( stubPhiCorr - phiTrack + posStub.phi() ); - - if ( seedBarrel0 ) - { - std::pair< unsigned int, unsigned int > mapKey0 = std::make_pair( seedBarrel0, candEndcap ); - mapTrackPropBE_deltaRhoPhi_Eta[ mapKey0 ]->Fill( seedEta, deltaRPhi ); - mapTrackPropBE_deltaRhoPhi[ mapKey0 ]->Fill( deltaRPhi ); - mapTrackPropBE_deltaR_Eta[ mapKey0 ]->Fill( seedEta, deltaR); - mapTrackPropBE_deltaR[ mapKey0 ]->Fill( deltaR ); - } - else if ( seedEndcap0 ) - { - std::pair< unsigned int, unsigned int > mapKey0 = std::make_pair( seedEndcap0, candEndcap ); - mapTrackPropEE_deltaRhoPhi_Eta[ mapKey0 ]->Fill( seedEta, deltaRPhi ); - mapTrackPropEE_deltaRhoPhi[ mapKey0 ]->Fill( deltaRPhi ); - mapTrackPropEE_deltaR_Eta[ mapKey0 ]->Fill( seedEta, deltaR ); - mapTrackPropEE_deltaR[ mapKey0 ]->Fill( deltaR ); - } - } - - } /// End of loop over track stubs - } /// End of loop over TTTrack seeds - } - } /// End of loop over TTTracks - } - - hTrack_2Stubs_N->Fill( num2Stubs ); - hTrack_3Stubs_N->Fill( num3Stubs ); - - /// Operations needing reversed-nesting - unsigned int numSeeds = 0; - - if ( PixelDigiTTSeedHandle->size() > 0 ) - { - /// Loop over Seeds - unsigned int seedCnt = 0; - std::vector< TTTrack< Ref_PixelDigi_ > >::const_iterator iterSeed; - for ( iterSeed = PixelDigiTTSeedHandle->begin(); - iterSeed != PixelDigiTTSeedHandle->end(); - ++iterSeed ) - { - /// Make the pointer - edm::Ptr< TTTrack< Ref_PixelDigi_ > > tempSeedPtr( PixelDigiTTSeedHandle, seedCnt++ ); - - bool genuineSeed = MCTruthTTSeedHandle->isGenuine( tempSeedPtr ); - - if ( !genuineSeed ) continue; - - double seedPt = tempSeedPtr->getMomentum().perp(); - double seedPhi = tempSeedPtr->getMomentum().phi(); - double seedEta = tempSeedPtr->getMomentum().eta(); - double seedVtxZ0 = tempSeedPtr->getVertex().z(); - double seedChi2 = tempSeedPtr->getChi2(); - double seedChi2R = tempSeedPtr->getChi2Red(); - - hSeed_Pt->Fill( seedPt ); - hSeed_Phi->Fill( seedPhi ); - hSeed_Eta->Fill( seedEta ); - - edm::Ptr< TrackingParticle > tpPtr = MCTruthTTSeedHandle->findTrackingParticlePtr( tempSeedPtr ); - - /// Get the corresponding vertex and reject the track - /// if its vertex is outside the beampipe - if ( tpPtr->vertex().rho() >= 2 ) - continue; - - double tpPt = tpPtr->p4().pt(); - double tpEta = tpPtr->momentum().eta(); - double tpPhi = tpPtr->momentum().phi(); - double tpVtxZ0 = tpPtr->vertex().z(); - - numSeeds++; - hSeed_Pt_TPart_Pt->Fill( tpPt, seedPt ); - hSeed_PtRes_TPart_Eta->Fill( tpEta, seedPt - tpPt); - hSeed_InvPt_TPart_InvPt->Fill( 1./tpPt, 1./seedPt ); - hSeed_InvPtRes_TPart_Eta->Fill( tpEta, 1./seedPt - 1./tpPt); - hSeed_Phi_TPart_Phi->Fill( tpPhi, seedPhi ); - hSeed_PhiRes_TPart_Eta->Fill( tpEta, seedPhi - tpPhi); - hSeed_Eta_TPart_Eta->Fill( tpEta, seedEta ); - hSeed_EtaRes_TPart_Eta->Fill( tpEta, seedEta - tpEta); - hSeed_VtxZ0_TPart_VtxZ0->Fill( tpVtxZ0, seedVtxZ0); - hSeed_VtxZ0Res_TPart_Eta->Fill( tpEta, seedVtxZ0 - tpVtxZ0 ); - hSeed_Chi2_NStubs->Fill( iterSeed->getStubPtrs().size(), seedChi2 ); - hSeed_Chi2_TPart_Eta->Fill( tpEta, seedChi2 ); - hSeed_Chi2Red_NStubs->Fill( iterSeed->getStubPtrs().size(), seedChi2R ); - hSeed_Chi2Red_TPart_Eta->Fill( tpEta, seedChi2R ); - - unsigned int q = 0; - - if ( PixelDigiTTTrackHandle->size() > 0 ) - { - std::vector< TTTrack< Ref_PixelDigi_ > >::const_iterator iterTTTrack; - for ( iterTTTrack = PixelDigiTTTrackHandle->begin(); - iterTTTrack != PixelDigiTTTrackHandle->end(); - ++iterTTTrack ) - { - unsigned int nStubs = iterTTTrack->getStubPtrs().size(); - if ( nStubs < 3 ) continue; - - bool dontSkip = iterTTTrack->isTheSameAs( *iterSeed ); - if ( !dontSkip ) continue; - - q++; - hTrack_Seed_Pt->Fill( seedPt ); - hTrack_Seed_Phi->Fill( seedPhi ); - hTrack_Seed_Eta->Fill( seedEta ); - } - } - - if ( q > 1 ) std::cerr << "q is " << q << std::endl; - } - } - - hSeed_N->Fill( numSeeds ); - -} /// End of analyze() - -/////////////////////////// -// DEFINE THIS AS A PLUG-IN -DEFINE_FWK_MODULE(ValidateL1Track); - diff --git a/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py b/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py index 60c986b353f6e..5f4601432c699 100644 --- a/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py +++ b/RecoMuon/StandAloneMuonProducer/python/standAloneMuons_cfi.py @@ -34,7 +34,7 @@ CSCRecSegmentLabel = cms.InputTag("cscSegments"), EnableRPCMeasurement = cms.bool(True), RPCRecSegmentLabel = cms.InputTag("rpcRecHits"), - EnableGEMMeasurement = cms.bool(True), + EnableGEMMeasurement = cms.bool(False), GEMRecSegmentLabel = cms.InputTag("gemRecHits"), NumberOfSigma = cms.double(3.0), MaxChi2 = cms.double(1000.0), @@ -58,7 +58,7 @@ CSCRecSegmentLabel = cms.InputTag("cscSegments"), EnableRPCMeasurement = cms.bool(True), RPCRecSegmentLabel = cms.InputTag("rpcRecHits"), - EnableGEMMeasurement = cms.bool(True), + EnableGEMMeasurement = cms.bool(False), GEMRecSegmentLabel = cms.InputTag("gemRecHits"), NumberOfSigma = cms.double(3.0), MaxChi2 = cms.double(100.0), diff --git a/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py b/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py index 14c42c82712c1..4708c4adab62b 100644 --- a/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py +++ b/SLHCUpgradeSimulations/Configuration/python/gemCustoms.py @@ -15,10 +15,6 @@ def customise(process): process=customise_DQM(process) if hasattr(process,'dqmHarvesting'): process=customise_harvesting(process) - if hasattr( process,'prevalidation_step') and not hasattr(process,'reconstruction') : - process=customise_DigiPreValidation(process) - if hasattr(process,'validation_step') and not hasattr(process,'reconstruction'): - process=customise_DigiValidation(process) elif hasattr(process,'validation_step') : process=customise_Validation(process) return process @@ -65,26 +61,20 @@ def customise_L1Emulator(process): def customise_DQM(process): return process -def customise_DigiPreValidation(process): - process.prevalidation = cms.Sequence(process.hltassociation) - return process - -def customise_DigiValidation(process): - process.load('Validation.MuonGEMDigis.MuonGEMDigis_cfi') - process.validation = cms.Sequence( process.gemDigiValidation ) - process.validation_step = cms.EndPath(process.validation) - process = scheduleOrdering(process) - return process - def customise_Validation(process): + print "Loading gem digi validation module from SLHCUpgradeSimulations.Configuration.gemCustoms.py" + process.load('Validation.MuonGEMHits.MuonGEMHits_cfi') process.load('Validation.MuonGEMDigis.MuonGEMDigis_cfi') - process.validation += cms.Sequence( process.gemDigiValidation ) - process.validation_step = cms.EndPath( process.validation ) - process = scheduleOrdering(process) + process.genvalid_all += cms.Sequence( process.gemHitsValidation*process.gemDigiValidation) return process def customise_harvesting(process): + print "Loading gem digi harvesting module from SLHCUpgradeSimulations.Configuration.gemCustoms.py" + process.load('Validation.MuonGEMHits.PostProcessor_cff') + process.load('Validation.MuonGEMDigis.PostProcessor_cff') + process.genHarvesting += process.MuonGEMHitsPostProcessors + process.genHarvesting += process.MuonGEMDigisPostProcessors return (process) def customise_Reco(process): @@ -92,6 +82,8 @@ def customise_Reco(process): process.gemRecHits.gemDigiLabel = cms.InputTag("simMuonGEMDigis") process.muonlocalreco += process.gemRecHits process=outputCustoms(process) + process.standAloneMuons.STATrajBuilderParameters.EnableGEMMeasurement = cms.bool(True) + process.standAloneMuons.STATrajBuilderParameters.BWFilterParameters.EnableGEMMeasurement = cms.bool(True) return process @@ -107,10 +99,3 @@ def outputCustoms(process): return process -def scheduleOrdering(process): - process.schedule = cms.Schedule() - for path in process.paths : - process.schedule.append(process.paths.get(path)) - for endpath in process.endpaths : - process.schedule.append( process.endpaths.get(endpath) ) - return process diff --git a/SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h b/SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h index 04d738ee30b7b..5a90dd9e34f55 100644 --- a/SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h +++ b/SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h @@ -17,6 +17,7 @@ #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/SiPixelDigi/interface/PixelDigi.h" #include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" @@ -42,30 +43,30 @@ class TTClusterAssociationMap /// Helper methods: findABC( ... ) /// Maps - std::map< edm::Ptr< TTCluster< T > >, std::vector< edm::Ptr< TrackingParticle > > > getTTClusterToTrackingParticlesMap() const + 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::Ptr< TTCluster< T > > > > getTrackingParticleToTTClustersMap() const + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > > getTrackingParticleToTTClustersMap() const { return trackingParticleToClusterVectorMap; } - void setTTClusterToTrackingParticlesMap( std::map< edm::Ptr< TTCluster< T > >, std::vector< edm::Ptr< TrackingParticle > > > aMap ) + 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::Ptr< TTCluster< T > > > > aMap ) + void setTrackingParticleToTTClustersMap( std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > > aMap ) { trackingParticleToClusterVectorMap = aMap; } /// Operations - std::vector< edm::Ptr< TrackingParticle > > findTrackingParticlePtrs( edm::Ptr< TTCluster< T > > aCluster ) const; - edm::Ptr< TrackingParticle > findTrackingParticlePtr( edm::Ptr< TTCluster< T > > aCluster ) const; - std::vector< edm::Ptr< TTCluster< T > > > findTTClusterPtrs( edm::Ptr< TrackingParticle > aTrackingParticle ) const; + 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; /// MC Truth methods - bool isGenuine( edm::Ptr< TTCluster< T > > aCluster ) const; - bool isCombinatoric( edm::Ptr< TTCluster< T > > aCluster ) const; - bool isUnknown( edm::Ptr< TTCluster< T > > aCluster ) 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: /// Data members - std::map< edm::Ptr< TTCluster< T > >, std::vector< edm::Ptr< TrackingParticle > > > clusterToTrackingParticleVectorMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTCluster< T > > > > trackingParticleToClusterVectorMap; + 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; }; /// Close class @@ -92,20 +93,20 @@ TTClusterAssociationMap< T >::~TTClusterAssociationMap(){} /// Operations template< typename T > -std::vector< edm::Ptr< TTCluster< T > > > TTClusterAssociationMap< T >::findTTClusterPtrs( edm::Ptr< TrackingParticle > aTrackingParticle ) const +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::Ptr< TTCluster< T > > > tempVector; + 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::Ptr< TTCluster< T > > aCluster ) const +std::vector< edm::Ptr< TrackingParticle > > TTClusterAssociationMap< T >::findTrackingParticlePtrs( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const { if ( clusterToTrackingParticleVectorMap.find( aCluster ) != clusterToTrackingParticleVectorMap.end() ) { @@ -130,7 +131,7 @@ std::vector< edm::Ptr< TrackingParticle > > TTClusterAssociationMap< T >::findTr /// >0 | U | C | C /// template< typename T > -bool TTClusterAssociationMap< T >::isGenuine( edm::Ptr< TTCluster< T > > aCluster ) const +bool TTClusterAssociationMap< T >::isGenuine( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const { /// Get the TrackingParticles std::vector< edm::Ptr< TrackingParticle > > theseTrackingParticles = this->findTrackingParticlePtrs( aCluster ); @@ -173,7 +174,7 @@ bool TTClusterAssociationMap< T >::isGenuine( edm::Ptr< TTCluster< T > > aCluste } template< typename T > -bool TTClusterAssociationMap< T >::isUnknown( edm::Ptr< TTCluster< T > > aCluster ) const +bool TTClusterAssociationMap< T >::isUnknown( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const { /// Get the TrackingParticles std::vector< edm::Ptr< TrackingParticle > > theseTrackingParticles = this->findTrackingParticlePtrs( aCluster ); @@ -211,7 +212,7 @@ bool TTClusterAssociationMap< T >::isUnknown( edm::Ptr< TTCluster< T > > aCluste } template< typename T > -bool TTClusterAssociationMap< T >::isCombinatoric( edm::Ptr< TTCluster< T > > aCluster ) const +bool TTClusterAssociationMap< T >::isCombinatoric( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const { /// Get the TrackingParticles std::vector< edm::Ptr< TrackingParticle > > theseTrackingParticles = this->findTrackingParticlePtrs( aCluster ); @@ -255,7 +256,7 @@ bool TTClusterAssociationMap< T >::isCombinatoric( edm::Ptr< TTCluster< T > > aC } template< typename T > -edm::Ptr< TrackingParticle > TTClusterAssociationMap< T >::findTrackingParticlePtr( edm::Ptr< TTCluster< T > > aCluster ) const +edm::Ptr< TrackingParticle > TTClusterAssociationMap< T >::findTrackingParticlePtr( edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > aCluster ) const { if ( this->isGenuine( aCluster ) ) { diff --git a/SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h b/SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h index 4fb9ff05c97e1..09bf0f300bdd9 100644 --- a/SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h +++ b/SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h @@ -18,6 +18,7 @@ #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/SiPixelDigi/interface/PixelDigi.h" #include "DataFormats/GeometryCommonDetAlgo/interface/MeasurementPoint.h" @@ -42,32 +43,32 @@ class TTStubAssociationMap /// Helper methods: findABC( ... ) /// Maps - std::map< edm::Ptr< TTStub< T > >, edm::Ptr< TrackingParticle > > getTTStubToTrackingParticleMap() const + std::map< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > >, edm::Ptr< TrackingParticle > > getTTStubToTrackingParticleMap() const { return stubToTrackingParticleMap; } - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTStub< T > > > > getTrackingParticleToTTStubsMap() const + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > > getTrackingParticleToTTStubsMap() const { return trackingParticleToStubVectorMap; } - void setTTStubToTrackingParticleMap( std::map< edm::Ptr< TTStub< T > >, edm::Ptr< TrackingParticle > > aMap ) + void setTTStubToTrackingParticleMap( std::map< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > >, edm::Ptr< TrackingParticle > > aMap ) { stubToTrackingParticleMap = aMap; } - void setTrackingParticleToTTStubsMap( std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTStub< T > > > > aMap ) + void setTrackingParticleToTTStubsMap( std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > > aMap ) { trackingParticleToStubVectorMap = aMap; } void setTTClusterAssociationMap( edm::RefProd< TTClusterAssociationMap< T > > aCluAssoMap ) { theClusterAssociationMap = aCluAssoMap; } /// Operations - edm::Ptr< TrackingParticle > findTrackingParticlePtr( edm::Ptr< TTStub< T > > aStub ) const; - std::vector< edm::Ptr< TTStub< T > > > findTTStubPtrs( edm::Ptr< TrackingParticle > aTrackingParticle ) const; + edm::Ptr< TrackingParticle > findTrackingParticlePtr( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const; + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > findTTStubRefs( edm::Ptr< TrackingParticle > aTrackingParticle ) const; /// MC Truth methods - bool isGenuine( edm::Ptr< TTStub< T > > aStub ) const; - bool isCombinatoric( edm::Ptr< TTStub< T > > aStub ) const; - bool isUnknown( edm::Ptr< TTStub< T > > aStub ) const; + bool isGenuine( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const; + bool isCombinatoric( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const; + bool isUnknown( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const; private: /// Data members - std::map< edm::Ptr< TTStub< T > >, edm::Ptr< TrackingParticle > > stubToTrackingParticleMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTStub< T > > > > trackingParticleToStubVectorMap; - edm::RefProd< TTClusterAssociationMap< T > > theClusterAssociationMap; + std::map< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > >, edm::Ptr< TrackingParticle > > stubToTrackingParticleMap; + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > > trackingParticleToStubVectorMap; + edm::RefProd< TTClusterAssociationMap< T > > theClusterAssociationMap; }; /// Close class @@ -96,7 +97,7 @@ TTStubAssociationMap< T >::~TTStubAssociationMap(){} /// Operations template< typename T > -edm::Ptr< TrackingParticle > TTStubAssociationMap< T >::findTrackingParticlePtr( edm::Ptr< TTStub< T > > aStub ) const +edm::Ptr< TrackingParticle > TTStubAssociationMap< T >::findTrackingParticlePtr( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const { if ( stubToTrackingParticleMap.find( aStub ) != stubToTrackingParticleMap.end() ) { @@ -109,21 +110,21 @@ edm::Ptr< TrackingParticle > TTStubAssociationMap< T >::findTrackingParticlePtr( } template< typename T > -std::vector< edm::Ptr< TTStub< T > > > TTStubAssociationMap< T >::findTTStubPtrs( edm::Ptr< TrackingParticle > aTrackingParticle ) const +std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > TTStubAssociationMap< T >::findTTStubRefs( edm::Ptr< TrackingParticle > aTrackingParticle ) const { if ( trackingParticleToStubVectorMap.find( aTrackingParticle ) != trackingParticleToStubVectorMap.end() ) { return trackingParticleToStubVectorMap.find( aTrackingParticle )->second; } - std::vector< edm::Ptr< TTStub< T > > > tempVector; + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > tempVector; tempVector.clear(); return tempVector; } /// MC truth template< typename T > -bool TTStubAssociationMap< T >::isGenuine( edm::Ptr< TTStub< T > > aStub ) const +bool TTStubAssociationMap< T >::isGenuine( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const { /// Check if there is a SimTrack if ( (this->findTrackingParticlePtr( aStub )).isNull() ) @@ -133,7 +134,7 @@ bool TTStubAssociationMap< T >::isGenuine( edm::Ptr< TTStub< T > > aStub ) const } template< typename T > -bool TTStubAssociationMap< T >::isCombinatoric( edm::Ptr< TTStub< T > > aStub ) const +bool TTStubAssociationMap< T >::isCombinatoric( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const { /// Defined by exclusion if ( this->isGenuine( aStub ) ) @@ -146,10 +147,10 @@ bool TTStubAssociationMap< T >::isCombinatoric( edm::Ptr< TTStub< T > > aStub ) } template< typename T > -bool TTStubAssociationMap< T >::isUnknown( edm::Ptr< TTStub< T > > aStub ) const +bool TTStubAssociationMap< T >::isUnknown( edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > aStub ) const { /// UNKNOWN means that both clusters are unknown - std::vector< edm::Ptr< TTCluster< T > > > theseClusters = aStub->getClusterPtrs(); + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > theseClusters = aStub->getClusterRefs(); /// Sanity check if ( theClusterAssociationMap.isNull() ) diff --git a/SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h b/SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h index 597df5b925c62..974f0d9946057 100644 --- a/SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h +++ b/SimTracker/TrackTriggerAssociation/interface/TTTrackAssociationMap.h @@ -147,7 +147,7 @@ template< typename T > bool TTTrackAssociationMap< T >::isUnknown( edm::Ptr< TTTrack< T > > aTrack ) const { /// UNKNOWN means that all stubs are unknown - std::vector< edm::Ptr< TTStub< T > > > theseStubs = aTrack->getStubPtrs(); + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > theseStubs = aTrack->getStubRefs(); for ( unsigned int i = 0; i < theseStubs.size(); i++ ) { if ( theStubAssociationMap->isUnknown( theseStubs.at(i) ) == false ) diff --git a/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.cc b/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.cc index 69b8347784591..633dbffc44a24 100644 --- a/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.cc +++ b/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.cc @@ -17,164 +17,162 @@ void TTClusterAssociator< Ref_PixelDigi_ >::produce( edm::Event& iEvent, const e if ( iEvent.isRealData() ) return; - /// Prepare output - std::auto_ptr< TTClusterAssociationMap< Ref_PixelDigi_ > > AssociationMapForOutput( new TTClusterAssociationMap< Ref_PixelDigi_ > ); - /// Get the PixelDigiSimLink iEvent.getByLabel( "simSiPixelDigis", thePixelDigiSimLinkHandle ); - /// Get the Clusters already stored away - edm::Handle< std::vector< TTCluster< Ref_PixelDigi_ > > > TTClusterHandle; - iEvent.getByLabel( TTClustersInputTag, TTClusterHandle ); - - /// Preliminary task: map SimTracks by TrackingParticle /// Get the TrackingParticles edm::Handle< std::vector< TrackingParticle > > TrackingParticleHandle; iEvent.getByLabel( "mix", "MergedTrackTruth", TrackingParticleHandle ); - /// Prepare the map - std::map< std::pair< unsigned int, EncodedEventId >, edm::Ptr< TrackingParticle > > simTrackUniqueToTPMap; - simTrackUniqueToTPMap.clear(); - - if ( TrackingParticleHandle->size() != 0 ) - { - /// Loop over TrackingParticles - unsigned int tpCnt = 0; - std::vector< TrackingParticle >::const_iterator iterTPart; - for ( iterTPart = TrackingParticleHandle->begin(); - iterTPart != TrackingParticleHandle->end(); - ++iterTPart ) - { - /// Make the pointer to the TrackingParticle - edm::Ptr< TrackingParticle > tempTPPtr( TrackingParticleHandle, tpCnt++ ); - - /// Get the EncodedEventId - EncodedEventId eventId = EncodedEventId( tempTPPtr->eventId() ); - - /// Loop over SimTracks inside TrackingParticle - std::vector< SimTrack >::const_iterator iterSimTrack; - for ( iterSimTrack = tempTPPtr->g4Tracks().begin(); - iterSimTrack != tempTPPtr->g4Tracks().end(); - ++iterSimTrack ) - { - /// Build the unique SimTrack Id (which is SimTrack ID + EncodedEventId) - std::pair< unsigned int, EncodedEventId > simTrackUniqueId( iterSimTrack->trackId(), eventId ); - simTrackUniqueToTPMap.insert( std::make_pair( simTrackUniqueId, tempTPPtr ) ); - } - } /// End of loop over TrackingParticles - } - - /// Prepare the necessary maps - std::map< edm::Ptr< TTCluster< Ref_PixelDigi_ > >, std::vector< edm::Ptr< TrackingParticle > > > clusterToTrackingParticleVectorMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > > trackingParticleToClusterVectorMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< unsigned int > > trackingParticleToClusterIndexVectorMap; - - unsigned int j = 0; /// Counter needed to build the edm::Ptr to the TTCluster - typename std::vector< TTCluster< Ref_PixelDigi_ > >::const_iterator inputIter; - for ( inputIter = TTClusterHandle->begin(); - inputIter != TTClusterHandle->end(); - ++inputIter ) + /// Loop over InputTags to handle multiple collections + for ( unsigned int iTag = 0; iTag < TTClustersInputTags.size(); iTag++ ) { - /// Make the pointer to be put in the map - edm::Ptr< TTCluster< Ref_PixelDigi_ > > tempCluPtr( TTClusterHandle, j++ ); - - /// Prepare the maps wrt TTCluster - if ( clusterToTrackingParticleVectorMap.find( tempCluPtr ) == clusterToTrackingParticleVectorMap.end() ) - { - std::vector< edm::Ptr< TrackingParticle > > tpVector; - tpVector.clear(); - clusterToTrackingParticleVectorMap.insert( std::make_pair( tempCluPtr, tpVector ) ); - } + /// Prepare output + std::auto_ptr< TTClusterAssociationMap< Ref_PixelDigi_ > > AssociationMapForOutput( new TTClusterAssociationMap< Ref_PixelDigi_ > ); - /// Get the DetId - const DetId detId = theStackedTrackers->idToDet( tempCluPtr->getDetId(), tempCluPtr->getStackMember() )->geographicalId(); + /// Get the Clusters already stored away + edm::Handle< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > > > TTClusterHandle; + iEvent.getByLabel( TTClustersInputTags.at(iTag), TTClusterHandle ); - /// Get the PixelDigiSimLink - edm::DetSet thisDigiSimLink = (*(thePixelDigiSimLinkHandle) )[detId.rawId()]; - edm::DetSet::const_iterator iterSimLink; + /// Preliminary task: map SimTracks by TrackingParticle + /// Prepare the map + std::map< std::pair< unsigned int, EncodedEventId >, edm::Ptr< TrackingParticle > > simTrackUniqueToTPMap; + simTrackUniqueToTPMap.clear(); - /// Get the Digis and loop over them - std::vector< Ref_PixelDigi_ > theseHits = tempCluPtr->getHits(); - for ( unsigned int i = 0; i < theseHits.size(); i++ ) + if ( TrackingParticleHandle->size() != 0 ) { - /// Loop over PixelDigiSimLink - for ( iterSimLink = thisDigiSimLink.data.begin(); - iterSimLink != thisDigiSimLink.data.end(); - iterSimLink++ ) + /// Loop over TrackingParticles + unsigned int tpCnt = 0; + std::vector< TrackingParticle >::const_iterator iterTPart; + for ( iterTPart = TrackingParticleHandle->begin(); + iterTPart != TrackingParticleHandle->end(); + ++iterTPart ) { - /// Threshold (redundant, already applied within L1TkClusterBuilder) - //if ( theHit.adc() <= 30 ) continue; - /// Find the link and, if there's not, skip - if ( (int)iterSimLink->channel() != theseHits.at(i)->channel() ) - continue; + /// Make the pointer to the TrackingParticle + edm::Ptr< TrackingParticle > tempTPPtr( TrackingParticleHandle, tpCnt++ ); - /// Get SimTrack Id and type - unsigned int curSimTrkId = iterSimLink->SimTrackId(); - EncodedEventId curSimEvId = iterSimLink->eventId(); + /// Get the EncodedEventId + EncodedEventId eventId = EncodedEventId( tempTPPtr->eventId() ); - /// Prepare the SimTrack Unique ID - std::pair< unsigned int, EncodedEventId > thisUniqueId = std::make_pair( curSimTrkId, curSimEvId ); - - /// Get the corresponding TrackingParticle - if ( simTrackUniqueToTPMap.find( thisUniqueId ) != simTrackUniqueToTPMap.end() ) + /// Loop over SimTracks inside TrackingParticle + std::vector< SimTrack >::const_iterator iterSimTrack; + for ( iterSimTrack = tempTPPtr->g4Tracks().begin(); + iterSimTrack != tempTPPtr->g4Tracks().end(); + ++iterSimTrack ) { - edm::Ptr< TrackingParticle > thisTrackingParticle = simTrackUniqueToTPMap.find( thisUniqueId )->second; + /// Build the unique SimTrack Id (which is SimTrack ID + EncodedEventId) + std::pair< unsigned int, EncodedEventId > simTrackUniqueId( iterSimTrack->trackId(), eventId ); + simTrackUniqueToTPMap.insert( std::make_pair( simTrackUniqueId, tempTPPtr ) ); + } + } /// End of loop over TrackingParticles + } - /// Store the TrackingParticle - clusterToTrackingParticleVectorMap.find( tempCluPtr )->second.push_back( thisTrackingParticle ); + /// Prepare the necessary maps + std::map< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > >, std::vector< edm::Ptr< TrackingParticle > > > clusterToTrackingParticleVectorMap; + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > > trackingParticleToClusterVectorMap; + clusterToTrackingParticleVectorMap.clear(); + trackingParticleToClusterVectorMap.clear(); + + /// Loop over the input Clusters + typename edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >::const_iterator inputIter; + typename edmNew::DetSet< TTCluster< Ref_PixelDigi_ > >::const_iterator contentIter; + for ( inputIter = TTClusterHandle->begin(); + inputIter != TTClusterHandle->end(); + ++inputIter ) + { + for ( contentIter = inputIter->begin(); + contentIter != inputIter->end(); + ++contentIter ) + { + /// Make the reference to be put in the map + edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > tempCluRef = edmNew::makeRefTo( TTClusterHandle, contentIter ); - /// Prepare the maps wrt TrackingParticle - if ( trackingParticleToClusterIndexVectorMap.find( thisTrackingParticle ) == trackingParticleToClusterIndexVectorMap.end() ) - { - std::vector< unsigned int > clusterVector; - clusterVector.clear(); - trackingParticleToClusterIndexVectorMap.insert( std::make_pair( thisTrackingParticle, clusterVector ) ); - } - trackingParticleToClusterIndexVectorMap.find( thisTrackingParticle )->second.push_back( j-1 ); /// Fill the auxiliary map - } - else + /// Prepare the maps wrt TTCluster + if ( clusterToTrackingParticleVectorMap.find( tempCluRef ) == clusterToTrackingParticleVectorMap.end() ) { - /// In case no TrackingParticle is found, store a NULL pointer - edm::Ptr< TrackingParticle >* tempTPPtr = new edm::Ptr< TrackingParticle >(); - clusterToTrackingParticleVectorMap.find( tempCluPtr )->second.push_back( *tempTPPtr ); + std::vector< edm::Ptr< TrackingParticle > > tpVector; + tpVector.clear(); + clusterToTrackingParticleVectorMap.insert( std::make_pair( tempCluRef, tpVector ) ); } - } /// End of loop over PixelDigiSimLink - } /// End of loop over all the hits composing the L1TkCluster - } /// End of loop over all the TTClusters of the event - - /// Clean the maps that need cleaning - /// Prepare the output map wrt TrackingParticle - std::map< edm::Ptr< TrackingParticle >, std::vector< unsigned int > >::iterator iterMapToClean; - for ( iterMapToClean = trackingParticleToClusterIndexVectorMap.begin(); - iterMapToClean != trackingParticleToClusterIndexVectorMap.end(); - ++iterMapToClean ) - { - /// Get the vector of edm::Ptr< TTCluster > - std::vector< unsigned int > tempVector = iterMapToClean->second; - /// Sort and remove duplicates - std::sort( tempVector.begin(), tempVector.end() ); - tempVector.erase( std::unique( tempVector.begin(), tempVector.end() ), tempVector.end() ); + /// Get the DetId + const DetId detId = theStackedTrackers->idToDet( tempCluRef->getDetId(), tempCluRef->getStackMember() )->geographicalId(); - /// Create the vector for the output map - std::vector< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > outputVector; - outputVector.clear(); + /// Get the PixelDigiSimLink + edm::DetSet thisDigiSimLink = (*(thePixelDigiSimLinkHandle) )[detId.rawId()]; + edm::DetSet::const_iterator iterSimLink; - for ( unsigned int k = 0; k < tempVector.size(); k++ ) + /// Get the Digis and loop over them + std::vector< Ref_PixelDigi_ > theseHits = tempCluRef->getHits(); + for ( unsigned int i = 0; i < theseHits.size(); i++ ) + { + /// Loop over PixelDigiSimLink + for ( iterSimLink = thisDigiSimLink.data.begin(); + iterSimLink != thisDigiSimLink.data.end(); + iterSimLink++ ) + { + /// Find the link and, if there's not, skip + if ( (int)iterSimLink->channel() != theseHits.at(i)->channel() ) + continue; + + /// Get SimTrack Id and type + unsigned int curSimTrkId = iterSimLink->SimTrackId(); + EncodedEventId curSimEvId = iterSimLink->eventId(); + + /// Prepare the SimTrack Unique ID + std::pair< unsigned int, EncodedEventId > thisUniqueId = std::make_pair( curSimTrkId, curSimEvId ); + + /// Get the corresponding TrackingParticle + if ( simTrackUniqueToTPMap.find( thisUniqueId ) != simTrackUniqueToTPMap.end() ) + { + edm::Ptr< TrackingParticle > thisTrackingParticle = simTrackUniqueToTPMap.find( thisUniqueId )->second; + + /// Store the TrackingParticle + clusterToTrackingParticleVectorMap.find( tempCluRef )->second.push_back( thisTrackingParticle ); + + /// Prepare the maps wrt TrackingParticle + if ( trackingParticleToClusterVectorMap.find( thisTrackingParticle ) == trackingParticleToClusterVectorMap.end() ) + { + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > clusterVector; + clusterVector.clear(); + trackingParticleToClusterVectorMap.insert( std::make_pair( thisTrackingParticle, clusterVector ) ); + } + trackingParticleToClusterVectorMap.find( thisTrackingParticle )->second.push_back( tempCluRef ); /// Fill the auxiliary map + } + else + { + /// In case no TrackingParticle is found, store a NULL pointer + edm::Ptr< TrackingParticle >* tempTPPtr = new edm::Ptr< TrackingParticle >(); + clusterToTrackingParticleVectorMap.find( tempCluRef )->second.push_back( *tempTPPtr ); + } + } /// End of loop over PixelDigiSimLink + } /// End of loop over all the hits composing the Cluster + } + } /// End of loop over all the TTClusters of the event + + /// Clean the maps that need cleaning + /// Prepare the output map wrt TrackingParticle + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > >::iterator iterMapToClean; + for ( iterMapToClean = trackingParticleToClusterVectorMap.begin(); + iterMapToClean != trackingParticleToClusterVectorMap.end(); + ++iterMapToClean ) { - edm::Ptr< TTCluster< Ref_PixelDigi_ > > tempCluPtr( TTClusterHandle, tempVector.at(k) ); - outputVector.push_back( tempCluPtr ); + /// Get the vector of references to TTCluster + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > tempVector = iterMapToClean->second; + + /// Sort and remove duplicates + std::sort( tempVector.begin(), tempVector.end() ); + tempVector.erase( std::unique( tempVector.begin(), tempVector.end() ), tempVector.end() ); + iterMapToClean->second = tempVector; } - /// Put the vector in the output map - trackingParticleToClusterVectorMap.insert( std::make_pair( iterMapToClean->first, outputVector ) ); - } + /// Put the maps in the association object + AssociationMapForOutput->setTTClusterToTrackingParticlesMap( clusterToTrackingParticleVectorMap ); + AssociationMapForOutput->setTrackingParticleToTTClustersMap( trackingParticleToClusterVectorMap ); - /// Put the maps in the association object - AssociationMapForOutput->setTTClusterToTrackingParticlesMap( clusterToTrackingParticleVectorMap ); - AssociationMapForOutput->setTrackingParticleToTTClustersMap( trackingParticleToClusterVectorMap ); + /// Put output in the event + iEvent.put( AssociationMapForOutput, TTClustersInputTags.at(iTag).instance() ); - /// Put output in the event - iEvent.put( AssociationMapForOutput ); + } /// End of loop over input tags } diff --git a/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.h b/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.h index 30510bcc676f0..f633d1a5058f5 100644 --- a/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.h +++ b/SimTracker/TrackTriggerAssociation/plugins/TTClusterAssociator.h @@ -49,7 +49,7 @@ class TTClusterAssociator : public edm::EDProducer edm::Handle< edm::DetSetVector< PixelDigiSimLink > > thePixelDigiSimLinkHandle; edm::Handle< edm::SimTrackContainer > theSimTrackHandle; edm::InputTag simTrackInputTag; - edm::InputTag TTClustersInputTag; + std::vector< edm::InputTag > TTClustersInputTags; const StackedTrackerGeometry *theStackedTrackers; //unsigned int ADCThreshold; @@ -71,10 +71,12 @@ class TTClusterAssociator : public edm::EDProducer template< typename T > TTClusterAssociator< T >::TTClusterAssociator( const edm::ParameterSet& iConfig ) { - simTrackInputTag = iConfig.getParameter< edm::InputTag >("simTrackHits"); - TTClustersInputTag = iConfig.getParameter< edm::InputTag >( "TTClusters" ); - //ADCThreshold = iConfig.getParameter< unsigned int >("ADCThreshold"); - produces< TTClusterAssociationMap< T > >(); + simTrackInputTag = iConfig.getParameter< edm::InputTag >( "simTrackHits" ); + TTClustersInputTags = iConfig.getParameter< std::vector< edm::InputTag > >( "TTClusters" ); + for ( unsigned int iTag = 0; iTag < TTClustersInputTags.size(); iTag++ ) + { + produces< TTClusterAssociationMap< T > >( TTClustersInputTags.at(iTag).instance() ); + } } /// Destructor diff --git a/SimTracker/TrackTriggerAssociation/plugins/TTStubAssociator.h b/SimTracker/TrackTriggerAssociation/plugins/TTStubAssociator.h index e3d6470226aca..31959eab0c5db 100644 --- a/SimTracker/TrackTriggerAssociation/plugins/TTStubAssociator.h +++ b/SimTracker/TrackTriggerAssociation/plugins/TTStubAssociator.h @@ -47,8 +47,8 @@ class TTStubAssociator : public edm::EDProducer private: /// Data members - edm::InputTag TTStubsInputTag; - edm::InputTag TTClusterTruthInputTag; + std::vector< edm::InputTag > TTStubsInputTags; + std::vector< edm::InputTag > TTClusterTruthInputTags; /// Mandatory methods virtual void beginRun( const edm::Run& run, const edm::EventSetup& iSetup ); @@ -68,10 +68,13 @@ class TTStubAssociator : public edm::EDProducer template< typename T > TTStubAssociator< T >::TTStubAssociator( const edm::ParameterSet& iConfig ) { - TTStubsInputTag = iConfig.getParameter< edm::InputTag >( "TTStubs" ); - TTClusterTruthInputTag = iConfig.getParameter< edm::InputTag >( "TTClusterTruth" ); + TTStubsInputTags = iConfig.getParameter< std::vector< edm::InputTag > >( "TTStubs" ); + TTClusterTruthInputTags = iConfig.getParameter< std::vector< edm::InputTag > >( "TTClusterTruth" ); - produces< TTStubAssociationMap< T > >(); + for ( unsigned int iTag = 0; iTag < TTStubsInputTags.size(); iTag++ ) + { + produces< TTStubAssociationMap< T > >( TTStubsInputTags.at(iTag).instance() ); + } } /// Destructor @@ -101,217 +104,226 @@ void TTStubAssociator< T >::produce( edm::Event& iEvent, const edm::EventSetup& if ( iEvent.isRealData() ) return; - /// Prepare output - std::auto_ptr< TTStubAssociationMap< T > > AssociationMapForOutput( new TTStubAssociationMap< T > ); - - /// Get the Stubs already stored away - edm::Handle< std::vector< TTStub< T > > > TTStubHandle; - iEvent.getByLabel( TTStubsInputTag, TTStubHandle ); - - /// Get the Cluster MC truth - edm::Handle< TTClusterAssociationMap< T > > TTClusterAssociationMapHandle; - iEvent.getByLabel( TTClusterTruthInputTag, TTClusterAssociationMapHandle ); - - /// Prepare the necessary maps - std::map< edm::Ptr< TTStub< T > >, edm::Ptr< TrackingParticle > > stubToTrackingParticleMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTStub< T > > > > trackingParticleToStubVectorMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< unsigned int > > trackingParticleToStubIndexVectorMap; - - unsigned int j = 0; /// Counter needed to build the edm::Ptr to the TTStub - typename std::vector< TTStub< T > >::const_iterator inputIter; - for ( inputIter = TTStubHandle->begin(); - inputIter != TTStubHandle->end(); - ++inputIter ) + /// Exit if the vectors are uncorrectly dimensioned + if ( TTClusterTruthInputTags.size() != TTStubsInputTags.size() ) { - /// Make the pointer to be put in the map - edm::Ptr< TTStub< T > > tempStubPtr( TTStubHandle, j++ ); - - /// Get the two clusters - std::vector< edm::Ptr< TTCluster< T > > > theseClusters = tempStubPtr->getClusterPtrs(); + std::cerr << "E R R O R! the InputTag vectors have different size!" << std::endl; + exit(0); + } - /// Fill the inclusive map which is careless of the stub classification - for ( unsigned int ic = 0; ic < 2; ic++ ) + /// Loop over the InputTags to handle multiple collections + for ( unsigned int iTag = 0; iTag < TTStubsInputTags.size(); iTag++ ) + { + /// Prepare output + std::auto_ptr< TTStubAssociationMap< T > > AssociationMapForOutput( new TTStubAssociationMap< T > ); + + /// Get the Stubs already stored away + edm::Handle< edmNew::DetSetVector< TTStub< T > > > TTStubHandle; + iEvent.getByLabel( TTStubsInputTags.at(iTag), TTStubHandle ); + + /// Get the Cluster MC truth + edm::Handle< TTClusterAssociationMap< T > > TTClusterAssociationMapHandle; + iEvent.getByLabel( TTClusterTruthInputTags.at(iTag), TTClusterAssociationMapHandle ); + + /// Prepare the necessary maps + std::map< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > >, edm::Ptr< TrackingParticle > > stubToTrackingParticleMap; + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > > trackingParticleToStubVectorMap; + stubToTrackingParticleMap.clear(); + trackingParticleToStubVectorMap.clear(); + + /// Loop over the input Stubs + typename edmNew::DetSetVector< TTStub< T > >::const_iterator inputIter; + typename edmNew::DetSet< TTStub< T > >::const_iterator contentIter; + for ( inputIter = TTStubHandle->begin(); + inputIter != TTStubHandle->end(); + ++inputIter ) { - std::vector< edm::Ptr< TrackingParticle > > tempTPs = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(ic) ); - - for ( unsigned int itp = 0; itp < tempTPs.size(); itp++ ) + for ( contentIter = inputIter->begin(); + contentIter != inputIter->end(); + ++contentIter ) { - edm::Ptr< TrackingParticle > testTP = tempTPs.at(itp); + /// Make the reference to be put in the map + edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > tempStubRef = edmNew::makeRefTo( TTStubHandle, contentIter ); - if ( testTP.isNull() ) - continue; + /// Get the two clusters + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > theseClusters = tempStubRef->getClusterRefs(); - /// Prepare the maps wrt TrackingParticle - if ( trackingParticleToStubIndexVectorMap.find( testTP ) == trackingParticleToStubIndexVectorMap.end() ) + /// Fill the inclusive map which is careless of the stub classification + for ( unsigned int ic = 0; ic < 2; ic++ ) { - std::vector< unsigned int > stubVector; - stubVector.clear(); - trackingParticleToStubIndexVectorMap.insert( std::make_pair( testTP, stubVector ) ); - } - trackingParticleToStubIndexVectorMap.find( testTP )->second.push_back( j-1 ); /// Fill the auxiliary map - } - } + std::vector< edm::Ptr< TrackingParticle > > tempTPs = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(ic) ); - /// GENUINE for clusters means not combinatoric and - /// not unknown: same MC truth content MUST be found - /// in both clusters composing the stub - if ( TTClusterAssociationMapHandle->isUnknown( theseClusters.at(0) ) || - TTClusterAssociationMapHandle->isUnknown( theseClusters.at(1) ) ) - { - /* - if ( TTClusterAssociationMapHandle->isUnknown( theseClusters.at(0) ) && - TTClusterAssociationMapHandle->isUnknown( theseClusters.at(1) ) ) - { - /// If both are unknown, it means that no TP's were found at all! - /// hence the stub is UNKNOWN - } - */ + for ( unsigned int itp = 0; itp < tempTPs.size(); itp++ ) + { + edm::Ptr< TrackingParticle > testTP = tempTPs.at(itp); - /// If at least one cluster is unknown, it means - /// either unknown, either combinatoric - /// Do nothing, and go to the next Stub - continue; - } - else - { - /// Here both are clusters are genuine/combinatoric - /// If both clusters have some known SimTrack content - /// they must be compared to each other - if ( TTClusterAssociationMapHandle->isGenuine( theseClusters.at(0) ) && - TTClusterAssociationMapHandle->isGenuine( theseClusters.at(1) ) ) - { - /// If both clusters are genuine, they must be associated to the same TrackingParticle - /// in order to return a genuine stub. Period. Note we can perform safely - /// this comparison because, if both clusters are genuine, their TrackingParticle shall NEVER be NULL - if ( TTClusterAssociationMapHandle->findTrackingParticlePtr( theseClusters.at(0) ).get() == - TTClusterAssociationMapHandle->findTrackingParticlePtr( theseClusters.at(1) ).get() ) - { - /// Two genuine clusters with same SimTrack content mean genuine - edm::Ptr< TrackingParticle > testTP = TTClusterAssociationMapHandle->findTrackingParticlePtr( theseClusters.at(0) ); + if ( testTP.isNull() ) + continue; - /// Fill the map: by construction, this will always be the first time the - /// stub is inserted into the map: no need for "find" - stubToTrackingParticleMap.insert( std::make_pair( tempStubPtr, testTP ) ); + /// Prepare the maps wrt TrackingParticle + if ( trackingParticleToStubVectorMap.find( testTP ) == trackingParticleToStubVectorMap.end() ) + { + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > stubVector; + stubVector.clear(); + trackingParticleToStubVectorMap.insert( std::make_pair( testTP, stubVector ) ); + } + trackingParticleToStubVectorMap.find( testTP )->second.push_back( tempStubRef ); /// Fill the auxiliary map + } + } - /// At this point, go to the next Stub + /// GENUINE for clusters means not combinatoric and + /// not unknown: same MC truth content MUST be found + /// in both clusters composing the stub + if ( TTClusterAssociationMapHandle->isUnknown( theseClusters.at(0) ) || + TTClusterAssociationMapHandle->isUnknown( theseClusters.at(1) ) ) + { + /* + if ( TTClusterAssociationMapHandle->isUnknown( theseClusters.at(0) ) && + TTClusterAssociationMapHandle->isUnknown( theseClusters.at(1) ) ) + { + /// If both are unknown, it means that no TP's were found at all! + /// hence the stub is UNKNOWN + } + */ + + /// If at least one cluster is unknown, it means + /// either unknown, either combinatoric + /// Do nothing, and go to the next Stub continue; } else { - /// It means combinatoric - continue; - } - } /// End of two genuine clusters - else - { - /// Here, at least one cluster is combinatoric - TrackingParticle* prevTPAddress = NULL; - unsigned int whichTP = 0; + /// Here both are clusters are genuine/combinatoric + /// If both clusters have some known SimTrack content + /// they must be compared to each other + if ( TTClusterAssociationMapHandle->isGenuine( theseClusters.at(0) ) && + TTClusterAssociationMapHandle->isGenuine( theseClusters.at(1) ) ) + { + /// If both clusters are genuine, they must be associated to the same TrackingParticle + /// in order to return a genuine stub. Period. Note we can perform safely + /// this comparison because, if both clusters are genuine, their TrackingParticle shall NEVER be NULL + if ( TTClusterAssociationMapHandle->findTrackingParticlePtr( theseClusters.at(0) ).get() == + TTClusterAssociationMapHandle->findTrackingParticlePtr( theseClusters.at(1) ).get() ) + { + /// Two genuine clusters with same SimTrack content mean genuine + edm::Ptr< TrackingParticle > testTP = TTClusterAssociationMapHandle->findTrackingParticlePtr( theseClusters.at(0) ); - std::vector< edm::Ptr< TrackingParticle > > trackingParticles0 = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(0) ); - std::vector< edm::Ptr< TrackingParticle > > trackingParticles1 = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(1) ); + /// Fill the map: by construction, this will always be the first time the + /// stub is inserted into the map: no need for "find" + stubToTrackingParticleMap.insert( std::make_pair( tempStubRef, testTP ) ); - bool escape = false; + /// At this point, go to the next Stub + continue; + } + else + { + /// It means combinatoric + continue; + } + } /// End of two genuine clusters + else + { + /// Here, at least one cluster is combinatoric + TrackingParticle* prevTPAddress = NULL; + unsigned int whichTP = 0; - for ( unsigned int i = 0; i < trackingParticles0.size() && !escape; i++ ) - { - /// Skip NULL pointers - if ( trackingParticles0.at(i).isNull() ) - continue; + std::vector< edm::Ptr< TrackingParticle > > trackingParticles0 = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(0) ); + std::vector< edm::Ptr< TrackingParticle > > trackingParticles1 = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(1) ); - for ( unsigned int k = 0; k < trackingParticles1.size() && !escape; k++ ) - { - /// Skip NULL pointers - if ( trackingParticles1.at(k).isNull() ) - continue; + bool escape = false; - if ( trackingParticles0.at(i).get() == trackingParticles1.at(k).get() ) + for ( unsigned int i = 0; i < trackingParticles0.size() && !escape; i++ ) { - /// Same SimTrack is present in both clusters - if ( prevTPAddress == NULL ) - { - prevTPAddress = const_cast< TrackingParticle* >(trackingParticles1.at(k).get()); - whichTP = k; - } + /// Skip NULL pointers + if ( trackingParticles0.at(i).isNull() ) + continue; - /// If two different SimTracks are found in both clusters, - /// then the stub is for sure combinatoric - if ( prevTPAddress != const_cast< TrackingParticle* >(trackingParticles1.at(k).get()) ) + for ( unsigned int k = 0; k < trackingParticles1.size() && !escape; k++ ) { - escape = true; - continue; + /// Skip NULL pointers + if ( trackingParticles1.at(k).isNull() ) + continue; + + if ( trackingParticles0.at(i).get() == trackingParticles1.at(k).get() ) + { + /// Same SimTrack is present in both clusters + if ( prevTPAddress == NULL ) + { + prevTPAddress = const_cast< TrackingParticle* >(trackingParticles1.at(k).get()); + whichTP = k; + } + + /// If two different SimTracks are found in both clusters, + /// then the stub is for sure combinatoric + if ( prevTPAddress != const_cast< TrackingParticle* >(trackingParticles1.at(k).get()) ) + { + escape = true; + continue; + } + } } - } - } - } /// End of double loop over SimTracks of both clusters - - /// If two different SimTracks are found in both clusters, - /// go to the next stub - if ( escape ) - continue; + } /// End of double loop over SimTracks of both clusters - if ( prevTPAddress == NULL ) - { - /// No SimTracks were found to be in both clusters - continue; - } - else - { - /// Only one SimTrack was found to be present in both clusters - /// even if one of the clusters (or both) are combinatoric: - /// this means there is only one track that participates in - /// both clusters, hence the stub is genuine - edm::Ptr< TrackingParticle > testTP = trackingParticles1.at(whichTP); + /// If two different SimTracks are found in both clusters, + /// go to the next stub + if ( escape ) + continue; - /// Fill the map: by construction, this will always be the first time the - /// stub is inserted into the map: no need for "find" - stubToTrackingParticleMap.insert( std::make_pair( tempStubPtr, testTP ) ); + if ( prevTPAddress == NULL ) + { + /// No SimTracks were found to be in both clusters + continue; + } + else + { + /// Only one SimTrack was found to be present in both clusters + /// even if one of the clusters (or both) are combinatoric: + /// this means there is only one track that participates in + /// both clusters, hence the stub is genuine + edm::Ptr< TrackingParticle > testTP = trackingParticles1.at(whichTP); - /// At this point, go to the next Stub - continue; - } /// End of one single SimTrack in both clusters - } /// End of "at least one cluster is combinatoric" - } /// End of "both clusters are known, somehow..." - } /// End of loop over Stubs - - /// Clean the only map that needs cleaning - /// Prepare the output map wrt TrackingParticle - std::map< edm::Ptr< TrackingParticle >, std::vector< unsigned int > >::iterator iterMapToClean; - for ( iterMapToClean = trackingParticleToStubIndexVectorMap.begin(); - iterMapToClean != trackingParticleToStubIndexVectorMap.end(); - ++iterMapToClean ) - { - /// Get the vector of edm::Ptr< TTStub > - std::vector< unsigned int > tempVector = iterMapToClean->second; + /// Fill the map: by construction, this will always be the first time the + /// stub is inserted into the map: no need for "find" + stubToTrackingParticleMap.insert( std::make_pair( tempStubRef, testTP ) ); - /// Sort and remove duplicates - std::sort( tempVector.begin(), tempVector.end() ); - tempVector.erase( std::unique( tempVector.begin(), tempVector.end() ), tempVector.end() ); + /// At this point, go to the next Stub + continue; + } /// End of one single SimTrack in both clusters + } /// End of "at least one cluster is combinatoric" + } /// End of "both clusters are known, somehow..." + } + } /// End of loop over Stubs + + /// Clean the only map that needs cleaning + /// Prepare the output map wrt TrackingParticle + typename std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > >::iterator iterMapToClean; + for ( iterMapToClean = trackingParticleToStubVectorMap.begin(); + iterMapToClean != trackingParticleToStubVectorMap.end(); + ++iterMapToClean ) + { + /// Get the vector of references to TTStub + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > tempVector = iterMapToClean->second; - /// Create the vector for the output map - std::vector< edm::Ptr< TTStub< T > > > outputVector; - outputVector.clear(); + /// Sort and remove duplicates + std::sort( tempVector.begin(), tempVector.end() ); + tempVector.erase( std::unique( tempVector.begin(), tempVector.end() ), tempVector.end() ); - for ( unsigned int k = 0; k < tempVector.size(); k++ ) - { - edm::Ptr< TTStub< T > > tempStubPtr( TTStubHandle, tempVector.at(k) ); - outputVector.push_back( tempStubPtr ); + /// Put the vector in the output map + iterMapToClean->second = tempVector; } - /// Put the vector in the output map - trackingParticleToStubVectorMap.insert( std::make_pair( iterMapToClean->first, outputVector ) ); - } + /// Also, create the pointer to the TTClusterAssociationMap + edm::RefProd< TTClusterAssociationMap< T > > theCluAssoMap( TTClusterAssociationMapHandle ); - /// Also, create the pointer to the TTClusterAssociationMap - edm::RefProd< TTClusterAssociationMap< T > > theCluAssoMap( TTClusterAssociationMapHandle ); + /// Put the maps in the association object + AssociationMapForOutput->setTTStubToTrackingParticleMap( stubToTrackingParticleMap ); + AssociationMapForOutput->setTrackingParticleToTTStubsMap( trackingParticleToStubVectorMap ); + AssociationMapForOutput->setTTClusterAssociationMap( theCluAssoMap ); - /// Put the maps in the association object - AssociationMapForOutput->setTTStubToTrackingParticleMap( stubToTrackingParticleMap ); - AssociationMapForOutput->setTrackingParticleToTTStubsMap( trackingParticleToStubVectorMap ); - AssociationMapForOutput->setTTClusterAssociationMap( theCluAssoMap ); + /// Put output in the event + iEvent.put( AssociationMapForOutput, TTStubsInputTags.at(iTag).instance() ); - /// Put output in the event - iEvent.put( AssociationMapForOutput ); + } /// End of loop over InputTags } #endif diff --git a/SimTracker/TrackTriggerAssociation/plugins/TTTrackAssociator.h b/SimTracker/TrackTriggerAssociation/plugins/TTTrackAssociator.h index adac992b98b32..10cac39b84a46 100644 --- a/SimTracker/TrackTriggerAssociation/plugins/TTTrackAssociator.h +++ b/SimTracker/TrackTriggerAssociation/plugins/TTTrackAssociator.h @@ -48,8 +48,7 @@ class TTTrackAssociator : public edm::EDProducer private: /// Data members - edm::InputTag TTTracksInputTag; - edm::InputTag TTSeedsInputTag; + std::vector< edm::InputTag > TTTracksInputTags; edm::InputTag TTClusterTruthInputTag; edm::InputTag TTStubTruthInputTag; @@ -71,13 +70,14 @@ class TTTrackAssociator : public edm::EDProducer template< typename T > TTTrackAssociator< T >::TTTrackAssociator( const edm::ParameterSet& iConfig ) { - TTTracksInputTag = iConfig.getParameter< edm::InputTag >( "TTTracks" ); - TTSeedsInputTag = iConfig.getParameter< edm::InputTag >( "TTSeeds" ); + TTTracksInputTags = iConfig.getParameter< std::vector< edm::InputTag > >( "TTTracks" ); TTClusterTruthInputTag = iConfig.getParameter< edm::InputTag >( "TTClusterTruth" ); TTStubTruthInputTag = iConfig.getParameter< edm::InputTag >( "TTStubTruth" ); - produces< TTTrackAssociationMap< T > >( "Seeds" ); - produces< TTTrackAssociationMap< T > >( "NoDup" ); + for ( unsigned int iTag = 0; iTag < TTTracksInputTags.size(); iTag++ ) + { + produces< TTTrackAssociationMap< T > >( TTTracksInputTags.at(iTag).instance() ); + } } /// Destructor @@ -107,49 +107,40 @@ void TTTrackAssociator< T >::produce( edm::Event& iEvent, const edm::EventSetup& if ( iEvent.isRealData() ) return; - /// Prepare output - std::auto_ptr< TTTrackAssociationMap< T > > AssociationMapForOutput( new TTTrackAssociationMap< T > ); - std::auto_ptr< TTTrackAssociationMap< T > > AssociationMapForOutputSeeds( new TTTrackAssociationMap< T > ); - - /// Get the Tracks already stored away - edm::Handle< std::vector< TTTrack< T > > > TTTrackHandle; - iEvent.getByLabel( TTTracksInputTag, TTTrackHandle ); - edm::Handle< std::vector< TTTrack< T > > > TTSeedHandle; - iEvent.getByLabel( TTSeedsInputTag, TTSeedHandle ); - /// Get the Stub and Cluster MC truth edm::Handle< TTClusterAssociationMap< T > > TTClusterAssociationMapHandle; iEvent.getByLabel( TTClusterTruthInputTag, TTClusterAssociationMapHandle ); edm::Handle< TTStubAssociationMap< T > > TTStubAssociationMapHandle; iEvent.getByLabel( TTStubTruthInputTag, TTStubAssociationMapHandle ); - /// Do the stuff for both Tracks and Seeds - edm::Handle< std::vector< TTTrack< T > > > AuxHandle; - for ( unsigned int qh = 0; qh < 2; qh++ ) + /// Loop over InputTags to handle multiple collections + for ( unsigned int iTag = 0; iTag < TTTracksInputTags.size(); iTag++ ) { - if ( qh == 0 ) - AuxHandle = TTTrackHandle; - else if ( qh == 1 ) - AuxHandle = TTSeedHandle; - else - return; + /// Prepare output + std::auto_ptr< TTTrackAssociationMap< T > > AssociationMapForOutput( new TTTrackAssociationMap< T > ); + + /// Get the Tracks already stored away + edm::Handle< std::vector< TTTrack< T > > > TTTrackHandle; + iEvent.getByLabel( TTTracksInputTags.at(iTag), TTTrackHandle ); /// Prepare the necessary maps std::map< edm::Ptr< TTTrack< T > >, edm::Ptr< TrackingParticle > > trackToTrackingParticleMap; std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTTrack< T > > > > trackingParticleToTrackVectorMap; - std::map< edm::Ptr< TrackingParticle >, std::vector< unsigned int > > trackingParticleToTrackIndexVectorMap; + trackToTrackingParticleMap.clear(); + trackingParticleToTrackVectorMap.clear(); + unsigned int j = 0; /// Counter needed to build the edm::Ptr to the TTTrack typename std::vector< TTTrack< T > >::const_iterator inputIter; - for ( inputIter = AuxHandle->begin(); - inputIter != AuxHandle->end(); + for ( inputIter = TTTrackHandle->begin(); + inputIter != TTTrackHandle->end(); ++inputIter ) { /// Make the pointer to be put in the map - edm::Ptr< TTTrack< T > > tempTrackPtr( AuxHandle, j++ ); + edm::Ptr< TTTrack< T > > tempTrackPtr( TTTrackHandle, j++ ); /// Get the stubs - std::vector< edm::Ptr< TTStub< T > > > theseStubs = tempTrackPtr->getStubPtrs(); + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > theseStubs = tempTrackPtr->getStubRefs(); /// Auxiliary map to store TP addresses and TP edm::Ptr std::map< const TrackingParticle*, edm::Ptr< TrackingParticle > > auxMap; @@ -159,7 +150,7 @@ void TTTrackAssociator< T >::produce( edm::Event& iEvent, const edm::EventSetup& /// Fill the inclusive map which is careless of the stub classification for ( unsigned int is = 0; is < theseStubs.size(); is++ ) { - std::vector< edm::Ptr< TTCluster< T > > > theseClusters = theseStubs.at(is)->getClusterPtrs(); + std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< T > >, TTCluster< T > > > theseClusters = theseStubs.at(is)->getClusterRefs(); for ( unsigned int ic = 0; ic < 2; ic++ ) { std::vector< edm::Ptr< TrackingParticle > > tempTPs = TTClusterAssociationMapHandle->findTrackingParticlePtrs( theseClusters.at(ic) ); @@ -171,13 +162,13 @@ void TTTrackAssociator< T >::produce( edm::Event& iEvent, const edm::EventSetup& continue; /// Prepare the maps wrt TrackingParticle - if ( trackingParticleToTrackIndexVectorMap.find( testTP ) == trackingParticleToTrackIndexVectorMap.end() ) + if ( trackingParticleToTrackVectorMap.find( testTP ) == trackingParticleToTrackVectorMap.end() ) { - std::vector< unsigned int > trackVector; + std::vector< edm::Ptr< TTTrack< T > > > trackVector; trackVector.clear(); - trackingParticleToTrackIndexVectorMap.insert( std::make_pair( testTP, trackVector ) ); + trackingParticleToTrackVectorMap.insert( std::make_pair( testTP, trackVector ) ); } - trackingParticleToTrackIndexVectorMap.find( testTP )->second.push_back( j-1 ); /// Fill the auxiliary map + trackingParticleToTrackVectorMap.find( testTP )->second.push_back( tempTrackPtr ); /// Fill the auxiliary map /// Fill the other auxiliary map if ( auxMap.find( testTP.get() ) == auxMap.end() ) @@ -208,7 +199,7 @@ void TTTrackAssociator< T >::produce( edm::Event& iEvent, const edm::EventSetup& ++iterAuxMap ) { /// Get all the stubs from this TrackingParticle - std::vector< edm::Ptr< TTStub< T > > > tempStubs = TTStubAssociationMapHandle->findTTStubPtrs( iterAuxMap->second ); + std::vector< edm::Ref< edmNew::DetSetVector< TTStub< T > >, TTStub< T > > > tempStubs = TTStubAssociationMapHandle->findTTStubRefs( iterAuxMap->second ); bool allFound = true; /// Loop over the stubs @@ -253,57 +244,33 @@ void TTTrackAssociator< T >::produce( edm::Event& iEvent, const edm::EventSetup& /// Clean the only map that needs cleaning /// Prepare the output map wrt TrackingParticle - std::map< edm::Ptr< TrackingParticle >, std::vector< unsigned int > >::iterator iterMapToClean; - for ( iterMapToClean = trackingParticleToTrackIndexVectorMap.begin(); - iterMapToClean != trackingParticleToTrackIndexVectorMap.end(); + typename std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTTrack< T > > > >::iterator iterMapToClean; + for ( iterMapToClean = trackingParticleToTrackVectorMap.begin(); + iterMapToClean != trackingParticleToTrackVectorMap.end(); ++iterMapToClean ) { /// Get the vector of edm::Ptr< TTTrack > - std::vector< unsigned int > tempVector = iterMapToClean->second; + std::vector< edm::Ptr< TTTrack< T > > > tempVector = iterMapToClean->second; /// Sort and remove duplicates std::sort( tempVector.begin(), tempVector.end() ); tempVector.erase( std::unique( tempVector.begin(), tempVector.end() ), tempVector.end() ); - /// Create the vector for the output map - std::vector< edm::Ptr< TTTrack< T > > > outputVector; - outputVector.clear(); - - for ( unsigned int k = 0; k < tempVector.size(); k++ ) - { - edm::Ptr< TTTrack< T > > tempTrackPtr( TTTrackHandle, tempVector.at(k) ); - outputVector.push_back( tempTrackPtr ); - } - - /// Put the vector in the output map - trackingParticleToTrackVectorMap.insert( std::make_pair( iterMapToClean->first, outputVector ) ); + iterMapToClean->second = tempVector; } /// Also, create the pointer to the TTClusterAssociationMap edm::RefProd< TTStubAssociationMap< T > > theStubAssoMap( TTStubAssociationMapHandle ); /// Put the maps in the association object - /// Separate Tracks from Seeds - if ( qh == 0 ) - { - AssociationMapForOutput->setTTTrackToTrackingParticleMap( trackToTrackingParticleMap ); - AssociationMapForOutput->setTrackingParticleToTTTracksMap( trackingParticleToTrackVectorMap ); - AssociationMapForOutput->setTTStubAssociationMap( theStubAssoMap ); - } - else if ( qh == 1 ) - { - AssociationMapForOutputSeeds->setTTTrackToTrackingParticleMap( trackToTrackingParticleMap ); - AssociationMapForOutputSeeds->setTrackingParticleToTTTracksMap( trackingParticleToTrackVectorMap ); - AssociationMapForOutputSeeds->setTTStubAssociationMap( theStubAssoMap ); - } - else - return; + AssociationMapForOutput->setTTTrackToTrackingParticleMap( trackToTrackingParticleMap ); + AssociationMapForOutput->setTrackingParticleToTTTracksMap( trackingParticleToTrackVectorMap ); + AssociationMapForOutput->setTTStubAssociationMap( theStubAssoMap ); - } /// End of loop over the two products ( tracks and seeds ) + /// Put output in the event + iEvent.put( AssociationMapForOutput, TTTracksInputTags.at(iTag).instance() ); - /// Put output in the event - iEvent.put( AssociationMapForOutput, "NoDup" ); - iEvent.put( AssociationMapForOutputSeeds, "Seeds" ); + } /// End of loop over InputTags } #endif diff --git a/SimTracker/TrackTriggerAssociation/python/TTClusterAssociation_cfi.py b/SimTracker/TrackTriggerAssociation/python/TTClusterAssociation_cfi.py index 2137948e43072..a2291db75505c 100644 --- a/SimTracker/TrackTriggerAssociation/python/TTClusterAssociation_cfi.py +++ b/SimTracker/TrackTriggerAssociation/python/TTClusterAssociation_cfi.py @@ -1,7 +1,9 @@ import FWCore.ParameterSet.Config as cms TTClusterAssociatorFromPixelDigis = cms.EDProducer("TTClusterAssociator_PixelDigi_", - TTClusters = cms.InputTag("TTClustersFromPixelDigis"), + TTClusters = cms.VInputTag( cms.InputTag("TTClustersFromPixelDigis", "ClusterInclusive"), + cms.InputTag("TTStubsFromPixelDigis", "ClusterAccepted"), + ), simTrackHits = cms.InputTag("g4SimHits"), ) diff --git a/SimTracker/TrackTriggerAssociation/python/TTStubAssociation_cfi.py b/SimTracker/TrackTriggerAssociation/python/TTStubAssociation_cfi.py index fbe53ef59682c..ca5eee5a8f3cf 100644 --- a/SimTracker/TrackTriggerAssociation/python/TTStubAssociation_cfi.py +++ b/SimTracker/TrackTriggerAssociation/python/TTStubAssociation_cfi.py @@ -1,7 +1,14 @@ import FWCore.ParameterSet.Config as cms TTStubAssociatorFromPixelDigis = cms.EDProducer("TTStubAssociator_PixelDigi_", - TTStubs = cms.InputTag("TTStubsFromPixelDigis", "StubsPass"), - TTClusterTruth = cms.InputTag("TTClusterAssociatorFromPixelDigis"), + TTStubs = cms.VInputTag( cms.InputTag("TTStubsFromPixelDigis", "StubAccepted"), + cms.InputTag("TTStubsFromPixelDigis", "StubRejected"), + ), + TTClusterTruth = cms.VInputTag( cms.InputTag("TTClusterAssociatorFromPixelDigis", "ClusterAccepted"), + cms.InputTag("TTClusterAssociatorFromPixelDigis", "ClusterInclusive"), + ) # NOTE: the two vectors of input tags must be of the same size and in the correct order + # as the producer would run on a specific pair and return a big error message + # if the vectors are uncorrectly dimensioned + # so "StubAccepted" needs the "ClusterAccepted" MC truth, and "StubRejected" the "ClusterInclusive" MC truth ) diff --git a/SimTracker/TrackTriggerAssociation/python/TTTrackAssociation_cfi.py b/SimTracker/TrackTriggerAssociation/python/TTTrackAssociation_cfi.py index 1ed0f225450e2..67b00cdd6496d 100644 --- a/SimTracker/TrackTriggerAssociation/python/TTTrackAssociation_cfi.py +++ b/SimTracker/TrackTriggerAssociation/python/TTTrackAssociation_cfi.py @@ -1,9 +1,10 @@ import FWCore.ParameterSet.Config as cms TTTrackAssociatorFromPixelDigis = cms.EDProducer("TTTrackAssociator_PixelDigi_", - TTTracks = cms.InputTag("TTTracksFromPixelDigis", "NoDup"), - TTSeeds = cms.InputTag("TTTracksFromPixelDigis", "Seeds"), - TTClusterTruth = cms.InputTag("TTClusterAssociatorFromPixelDigis"), - TTStubTruth = cms.InputTag("TTStubAssociatorFromPixelDigis"), + TTTracks = cms.VInputTag( #cms.InputTag("TTTracksFromPixelDigisTracklet", "TrackletBasedL1Tracks"), + cms.InputTag("TTTracksFromPixelDigisAM", "AML1Tracks"), + ), + TTClusterTruth = cms.InputTag("TTClusterAssociatorFromPixelDigis", "ClusterAccepted"), + TTStubTruth = cms.InputTag("TTStubAssociatorFromPixelDigis", "StubAccepted"), ) diff --git a/SimTracker/TrackTriggerAssociation/src/classes.h b/SimTracker/TrackTriggerAssociation/src/classes.h index d573f8f466935..f13d196a3d9b7 100644 --- a/SimTracker/TrackTriggerAssociation/src/classes.h +++ b/SimTracker/TrackTriggerAssociation/src/classes.h @@ -7,6 +7,7 @@ */ #include "DataFormats/Common/interface/Wrapper.h" +#include "DataFormats/Common/interface/DetSetVectorNew.h" #include "DataFormats/L1TrackTrigger/interface/TTTypes.h" #include "SimTracker/TrackTriggerAssociation/interface/TTClusterAssociationMap.h" #include "SimTracker/TrackTriggerAssociation/interface/TTStubAssociationMap.h" @@ -22,16 +23,16 @@ namespace TTClusterAssociationMap< Ref_PixelDigi_ > CAM_PD; edm::Wrapper< TTClusterAssociationMap< Ref_PixelDigi_ > > W_CAM_PD; - std::map< edm::Ptr< TTCluster< Ref_PixelDigi_ > >, std::vector< edm::Ptr< TrackingParticle > > > M_CAM_C_TP_PD; - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTCluster< Ref_PixelDigi_ > > > > M_CAM_TP_C_PD; - edm::RefProd< TTClusterAssociationMap< Ref_PixelDigi_ > > R_CAM_PD; + std::map< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > >, std::vector< edm::Ptr< TrackingParticle > > > M_CAM_C_TP_PD; + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTCluster< Ref_PixelDigi_ > >, TTCluster< Ref_PixelDigi_ > > > > M_CAM_TP_C_PD; + edm::RefProd< TTClusterAssociationMap< Ref_PixelDigi_ > > R_CAM_PD; TTStubAssociationMap< Ref_PixelDigi_ > SAM_PD; edm::Wrapper< TTStubAssociationMap< Ref_PixelDigi_ > > W_SAM_PD; - std::map< edm::Ptr< TTStub< Ref_PixelDigi_ > >, edm::Ptr< TrackingParticle > > M_SAM_S_TP_PD; - std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ptr< TTStub< Ref_PixelDigi_ > > > > M_SAM_TP_S_PD; - edm::RefProd< TTStubAssociationMap< Ref_PixelDigi_ > > R_SAM_PD; + std::map< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > >, edm::Ptr< TrackingParticle > > M_SAM_S_TP_PD; + std::map< edm::Ptr< TrackingParticle >, std::vector< edm::Ref< edmNew::DetSetVector< TTStub< Ref_PixelDigi_ > >, TTStub< Ref_PixelDigi_ > > > > M_SAM_TP_S_PD; + edm::RefProd< TTStubAssociationMap< Ref_PixelDigi_ > > R_SAM_PD; TTTrackAssociationMap< Ref_PixelDigi_ > TAM_PD; edm::Wrapper< TTTrackAssociationMap< Ref_PixelDigi_ > > W_TAM_PD; diff --git a/SimTracker/TrackTriggerAssociation/src/classes_def.xml b/SimTracker/TrackTriggerAssociation/src/classes_def.xml index 7ddedbf8ce099..dfaae4210235e 100644 --- a/SimTracker/TrackTriggerAssociation/src/classes_def.xml +++ b/SimTracker/TrackTriggerAssociation/src/classes_def.xml @@ -1,21 +1,28 @@ - - + + + + + + + + + + + + + + + + + + + - - - - - - - - - - diff --git a/Validation/MuonGEMDigis/interface/GEMTrackMatch.h b/Validation/MuonGEMDigis/interface/GEMTrackMatch.h index 88ccc7cfd604a..0e43f84ea2c77 100644 --- a/Validation/MuonGEMDigis/interface/GEMTrackMatch.h +++ b/Validation/MuonGEMDigis/interface/GEMTrackMatch.h @@ -21,7 +21,7 @@ #include "Geometry/CommonTopologies/interface/StripTopology.h" -#include "Validation/MuonGEMDigis/interface/SimTrackMatchManager.h" +#include "Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h" class GEMTrackMatch @@ -36,21 +36,6 @@ class GEMTrackMatch bool isSimTrackGood(const SimTrack& ); void setGeometry(const GEMGeometry* geom); - TH1F** GetDgEta() { return dg_eta; } - TH1F** GetPadEta() { return pad_eta; } - TH1F** GetShEta() { return dg_sh_eta; } - - TH1F** GetDgPhi() { return dg_phi; } - TH1F** GetPadPhi() { return pad_phi; } - TH1F** GetShPhi() { return dg_sh_phi; } - - - TH1F* GetTrackEta() { return track_eta; } - TH1F* GetTrackDgEta() { return track_dg_eta; } - TH1F* GetTrackShEta() { return track_sh_eta; } - TH1F* GetTrackPhi() { return track_phi; } - - private: @@ -59,27 +44,22 @@ class GEMTrackMatch DQMStore* dbe_; const GEMGeometry* theGEMGeometry; - MonitorElement* theEff_eta_dg_l1; - TH1F* track_eta; - TH1F* track_phi; + MonitorElement* track_eta; + MonitorElement* track_phi; - TH1F* track_dg_eta; - TH1F* track_sh_eta; + MonitorElement* track_dg_eta; + MonitorElement* track_sh_eta; - TH1F* dg_eta[4]; + MonitorElement* dg_eta[4]; + MonitorElement* dg_sh_eta[4]; - TH1F* dg_sh_eta[4]; - - - TH1F* dg_phi[4]; - - TH1F* dg_sh_phi[4]; - - TH1F* pad_eta[4]; + MonitorElement* dg_phi[4]; + MonitorElement* dg_sh_phi[4]; - TH1F* pad_phi[4]; + MonitorElement* pad_eta[4]; + MonitorElement* pad_phi[4]; MonitorElement* dg_lx_even; diff --git a/Validation/MuonGEMDigis/interface/MuonGEMDigis.h b/Validation/MuonGEMDigis/interface/MuonGEMDigis.h index 3fd97d068b428..68baeea8510f6 100644 --- a/Validation/MuonGEMDigis/interface/MuonGEMDigis.h +++ b/Validation/MuonGEMDigis/interface/MuonGEMDigis.h @@ -45,7 +45,13 @@ class MuonGEMDigis : public edm::EDAnalyzer GEMCSCPadDigiValidation* theGEMCSCPadDigiValidation; GEMCSCCoPadDigiValidation* theGEMCSCCoPadDigiValidation; GEMTrackMatch* theGEMTrackMatch; - + + + edm::InputTag stripLabel_; + edm::InputTag cscPadLabel_; + edm::InputTag cscCopadLabel_; + std::string simInputLabel_; + edm::ParameterSet simTrackMatching_; void buildLUT(); std::pair getClosestChambers(int region, float phi); diff --git a/Validation/MuonGEMDigis/interface/MuonGEMDigis_Harvesting.h b/Validation/MuonGEMDigis/interface/MuonGEMDigis_Harvesting.h new file mode 100644 index 0000000000000..0438394380ae2 --- /dev/null +++ b/Validation/MuonGEMDigis/interface/MuonGEMDigis_Harvesting.h @@ -0,0 +1,44 @@ +#ifndef MuonGEMDigis_Harvesting_H +#define MuonGEMDigis_Harvesting_H + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" + + +#include "DQMServices/Core/interface/DQMStore.h" +#include "SimMuon/MCTruth/interface/PSimHitMap.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" + +#include "Validation/MuonGEMDigis/interface/GEMStripDigiValidation.h" +#include "Validation/MuonGEMDigis/interface/GEMCSCPadDigiValidation.h" +#include "Validation/MuonGEMDigis/interface/GEMCSCCoPadDigiValidation.h" +#include "Validation/MuonGEMDigis/interface/GEMTrackMatch.h" + + +class MuonGEMDigis_Harvesting : public edm::EDAnalyzer +{ +public: + /// constructor + explicit MuonGEMDigis_Harvesting(const edm::ParameterSet&); + /// destructor + ~MuonGEMDigis_Harvesting(); + + virtual void beginRun(edm::Run const&, edm::EventSetup const&); + + virtual void beginJob() ; + + virtual void analyze(const edm::Event&, const edm::EventSetup&); + + virtual void endJob() ; + + virtual void endRun(const edm::Run&, const edm::EventSetup&) ; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + + DQMStore* dbe_; + + +}; +#endif diff --git a/Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h b/Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h new file mode 100644 index 0000000000000..8a24d42b1c091 --- /dev/null +++ b/Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h @@ -0,0 +1,37 @@ +#ifndef GEMValidation_SimTrackDigiMatchManager_h +#define GEMValidation_SimTrackDigiMatchManager_h + +/**\class SimTrackMatchManager + + Description: Matching of SIM and Trigger info for a SimTrack in CSC & GEM + + It's a manager-matcher class, as it uses specialized matching classes to match SimHits, various digis and stubs. + + Original Author: "Vadim Khotilovich" + $Id: SimTrackMatchManager.h,v 1.1 2013/02/11 07:33:07 khotilov Exp $ + +*/ + +#include "Validation/MuonGEMDigis/interface/BaseMatcher.h" +#include "Validation/MuonGEMDigis/interface/SimHitMatcher.h" +#include "Validation/MuonGEMDigis/interface/GEMDigiMatcher.h" + +class SimTrackDigiMatchManager +{ +public: + + SimTrackDigiMatchManager(const SimTrack& t, const SimVertex& v, + const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es); + + ~SimTrackDigiMatchManager(); + + const SimHitMatcher& simhits() const {return simhits_;} + const GEMDigiMatcher& gemDigis() const {return gem_digis_;} + +private: + + SimHitMatcher simhits_; + GEMDigiMatcher gem_digis_; +}; + +#endif diff --git a/Validation/MuonGEMDigis/plugins/MuonGEMDigis.cc b/Validation/MuonGEMDigis/plugins/MuonGEMDigis.cc index 9abc159a84d7a..5befa51f7e20d 100644 --- a/Validation/MuonGEMDigis/plugins/MuonGEMDigis.cc +++ b/Validation/MuonGEMDigis/plugins/MuonGEMDigis.cc @@ -66,8 +66,8 @@ #include "FWCore/MessageLogger/interface/MessageLogger.h" #include "FWCore/ServiceRegistry/interface/Service.h" -#include "Validation/MuonGEMDigis/interface/SimTrackMatchManager.h" - +#include "Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h" +#include @@ -83,21 +83,24 @@ // constructors and destructor // MuonGEMDigis::MuonGEMDigis(const edm::ParameterSet& ps) -// , simInputLabel_(ps.getUntrackedParameter("simInputLabel", "g4SimHits")) -// , verbose_(ps.getUntrackedParameter("verbose", 0)) { - dbe_ = edm::Service().operator->(); - dbe_->setCurrentFolder("MuonGEMDigisV/GEMDigiTask"); outputFile_ = ps.getParameter("outputFile"); + + stripLabel_ = ps.getParameter("stripLabel"); + cscPadLabel_ = ps.getParameter("cscPadLabel"); + cscCopadLabel_ = ps.getParameter("cscCopadLabel"); + simInputLabel_ = ps.getUntrackedParameter("simInputLabel", "g4SimHits"); + simTrackMatching_ = ps.getParameterSet("simTrackMatching"); //now do what ever initialization is needed + dbe_ = edm::Service().operator->(); + dbe_->setCurrentFolder("MuonGEMDigisV/GEMDigiTask"); + theGEMStripDigiValidation = new GEMStripDigiValidation(dbe_, stripLabel_ ); + theGEMCSCPadDigiValidation = new GEMCSCPadDigiValidation(dbe_, cscPadLabel_ ); + theGEMCSCCoPadDigiValidation = new GEMCSCCoPadDigiValidation(dbe_, cscCopadLabel_ ); + theGEMTrackMatch = new GEMTrackMatch(dbe_, simInputLabel_ , simTrackMatching_ ); - theGEMStripDigiValidation = new GEMStripDigiValidation(dbe_, ps.getParameter("stripLabel")); - theGEMCSCPadDigiValidation = new GEMCSCPadDigiValidation(dbe_, ps.getParameter("cscPadLabel")); - theGEMCSCCoPadDigiValidation = new GEMCSCCoPadDigiValidation(dbe_, ps.getParameter("cscCopadLabel")); - theGEMTrackMatch = new GEMTrackMatch(dbe_, ps.getUntrackedParameter("simInputLabel", "g4SimHits"), - ps.getParameterSet("simTrackMatching") ); @@ -136,12 +139,8 @@ MuonGEMDigis::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) theGEMStripDigiValidation->analyze(iEvent,iSetup ); theGEMCSCPadDigiValidation->analyze(iEvent,iSetup ); theGEMCSCCoPadDigiValidation->analyze(iEvent,iSetup ); - - - - theGEMTrackMatch->analyze(iEvent,iSetup) ; - + } @@ -188,103 +187,7 @@ MuonGEMDigis::beginRun(edm::Run const&, edm::EventSetup const& iSetup) void MuonGEMDigis::endRun(edm::Run const&, edm::EventSetup const&) { -// if ( theDQM && ! outputFileName_.empty() ) theDQM->save(outputFileName_); - for ( int i =0 ; i< 4 ; i++) { - TH1F* dg = theGEMTrackMatch->GetDgEta()[i]; - TH1F* temp1 = (TH1F*)dg->Clone("temp1"); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetDgEta()[i]->GetName(),"_origin").Data(), temp1 ); - temp1->Divide( theGEMTrackMatch->GetTrackEta()); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetDgEta()[i]->GetName(),"_divided").Data(), temp1 ); - TH1F* temp2 = (TH1F*)dg->Clone("temp2"); - temp2->Divide( theGEMTrackMatch->GetShEta()[i]); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetShEta()[i]->GetName(),"_origin").Data(), theGEMTrackMatch->GetShEta()[i] ); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetShEta()[i]->GetName(),"_divided").Data(), temp2 ); - } - for ( int i =0 ; i< 4 ; i++) { - TH1F* pad = (TH1F*)theGEMTrackMatch->GetPadEta()[i]; - TH1F* temp1 = (TH1F*)pad->Clone("temp1"); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetPadEta()[i]->GetName(),"_origin").Data(), temp1 ); - temp1->Divide( theGEMTrackMatch->GetTrackEta()); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetPadEta()[i]->GetName(),"_divided").Data(), temp1 ); - - TH1F* temp2 = (TH1F*)pad->Clone("temp2"); - temp2->Divide( theGEMTrackMatch->GetShEta()[i]); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetPadEta()[i]->GetName(),"_sh_divided").Data(), temp1 ); - - } - for ( int i=0 ; i<4 ; i++) { - TH1F* dgphi = theGEMTrackMatch->GetDgPhi()[i]; - TH1F* temp1 = (TH1F*)dgphi->Clone("temp1"); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetDgPhi()[i]->GetName(),"_origin").Data(), temp1 ); - temp1->Divide( theGEMTrackMatch->GetTrackPhi()); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetDgPhi()[i]->GetName(),"_divided").Data(), temp1 ); - TH1F* temp2 = (TH1F*)dgphi->Clone("temp2"); - temp2->Divide( theGEMTrackMatch->GetShPhi()[i]); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetShPhi()[i]->GetName(),"_origin").Data(), theGEMTrackMatch->GetShPhi()[i] ); - dbe_->book1D( TString::Format("%s%s",theGEMTrackMatch->GetShPhi()[i]->GetName(),"_divided").Data(), temp2 ); - } - - - if( dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even") != nullptr) { - - TH1F* gem_dg_lx_even[5]; - gem_dg_lx_even[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even")->getTH1F()->Clone(); - gem_dg_lx_even[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l1")->getTH1F()->Clone(); - gem_dg_lx_even[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l2")->getTH1F()->Clone(); - gem_dg_lx_even[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l1or2")->getTH1F()->Clone(); - gem_dg_lx_even[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l1and2")->getTH1F()->Clone(); - - - TH1F* gem_dg_ly_even[5]; - gem_dg_ly_even[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even")->getTH1F()->Clone(); - gem_dg_ly_even[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l1")->getTH1F()->Clone(); - gem_dg_ly_even[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l2")->getTH1F()->Clone(); - gem_dg_ly_even[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l1or2")->getTH1F()->Clone(); - gem_dg_ly_even[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l1and2")->getTH1F()->Clone(); - - - TH1F* gem_dg_lx_odd[5]; - gem_dg_lx_odd[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd")->getTH1F()->Clone(); - gem_dg_lx_odd[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l1")->getTH1F()->Clone(); - gem_dg_lx_odd[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l2")->getTH1F()->Clone(); - gem_dg_lx_odd[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l1or2")->getTH1F()->Clone(); - gem_dg_lx_odd[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l1and2")->getTH1F()->Clone(); - - - TH1F* gem_dg_ly_odd[5]; - gem_dg_ly_odd[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd")->getTH1F()->Clone(); - gem_dg_ly_odd[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l1")->getTH1F()->Clone(); - gem_dg_ly_odd[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l2")->getTH1F()->Clone(); - gem_dg_ly_odd[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l1or2")->getTH1F()->Clone(); - gem_dg_ly_odd[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l1and2")->getTH1F()->Clone(); - - - for ( int i= 0; i<5 ; i++) { - gem_dg_lx_even[i]->Sumw2(); - gem_dg_ly_even[i]->Sumw2(); - - - gem_dg_lx_odd[i]->Sumw2(); - gem_dg_ly_odd[i]->Sumw2(); - - } - - - for( int i=1 ; i<5 ; i++) { - gem_dg_lx_even[i]->Divide( gem_dg_lx_even[0]); - gem_dg_ly_even[i]->Divide( gem_dg_ly_even[0]); - gem_dg_lx_odd[i]->Divide( gem_dg_lx_odd[0]); - gem_dg_ly_odd[i]->Divide( gem_dg_ly_odd[0]); - - dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_lx_even[i]->GetName()),gem_dg_lx_even[i] ); - dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_ly_even[i]->GetName()),gem_dg_ly_even[i] ); - dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_lx_odd[i]->GetName()),gem_dg_lx_odd[i] ); - dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_ly_odd[i]->GetName()),gem_dg_ly_odd[i] ); - } - - } // - //printf(" Call endRun!!\n"); if ( outputFile_.size() != 0 && dbe_ ) dbe_->save(outputFile_); } diff --git a/Validation/MuonGEMDigis/plugins/MuonGEMDigis_Harvesting.cc b/Validation/MuonGEMDigis/plugins/MuonGEMDigis_Harvesting.cc new file mode 100644 index 0000000000000..862d35fc9c710 --- /dev/null +++ b/Validation/MuonGEMDigis/plugins/MuonGEMDigis_Harvesting.cc @@ -0,0 +1,331 @@ +// -*- C++ -*- +// +// Package: MuonGEMDigis_Harvesting +// Class: MuonGEMDigis_Harvesting +// +/**\class MuonGEMDigis_Harvesting MuonGEMDigis_Harvesting.cc Validation/MuonGEMDigis_Harvesting/plugins/MuonGEMDigis_Harvesting.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Geonmo RYU +// Created: Mon, 07 Oct 2013 12:45:56 GMT +// Based on : /GEMCode/GEMValidation/plugin/GEMDigiAnalyzer.cc +// $Id$ +// +// + + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "TTree.h" +#include "TFile.h" +#include "TGraphAsymmErrors.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "Validation/MuonGEMDigis/interface/MuonGEMDigis_Harvesting.h" + +///Data Format +#include "DataFormats/GEMDigi/interface/GEMDigiCollection.h" +#include "DataFormats/GEMDigi/interface/GEMCSCPadDigiCollection.h" +#include "DataFormats/MuonDetId/interface/GEMDetId.h" +#include "DataFormats/GeometrySurface/interface/LocalError.h" +#include "DataFormats/GeometryVector/interface/LocalPoint.h" +#include "DataFormats/Scalers/interface/DcsStatus.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Math/interface/deltaPhi.h" + +#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" +#include "SimDataFormats/Track/interface/SimTrackContainer.h" + +///Geometry +#include "Geometry/Records/interface/MuonGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDet.h" + +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartition.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartitionSpecs.h" +#include "Geometry/CommonTopologies/interface/StripTopology.h" + +#include "DQMServices/Core/interface/DQMStore.h" + +///Log messages +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +#include "Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h" + + + + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +MuonGEMDigis_Harvesting::MuonGEMDigis_Harvesting(const edm::ParameterSet& ps) +{ + dbe_ = edm::Service().operator->(); +} + + + +MuonGEMDigis_Harvesting::~MuonGEMDigis_Harvesting() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) +} + + + + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +MuonGEMDigis_Harvesting::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + + +} + + +// ------------ method called once each job just before starting event loop ------------ + +void +MuonGEMDigis_Harvesting::beginJob() +{ + + +} + +// ------------ method called once each job just after ending the event loop ------------ + +void +MuonGEMDigis_Harvesting::endJob() +{ +} + +// ------------ method called when starting to processes a run ------------ + +void +MuonGEMDigis_Harvesting::beginRun(edm::Run const&, edm::EventSetup const& iSetup) +{ + + + + + +} + + +// ------------ method called when ending the processing of a run ------------ +void +MuonGEMDigis_Harvesting::endRun(edm::Run const&, edm::EventSetup const&) +{ + dbe_->cd(); + dbe_->setCurrentFolder("MuonGEMDigisV/GEMDigiTask"); + + std::vector< std::string > postfix; + postfix.push_back("_l1"); + postfix.push_back("_l2"); + postfix.push_back("_l1or2"); + postfix.push_back("_l1and2"); + TH1F* gem_trk_phi = nullptr; + TH1F* gem_trk_eta = nullptr; + TH1F* sh_eta[4]={nullptr}; + TH1F* sh_phi[4]={nullptr}; + + + if ( dbe_->get("MuonGEMDigisV/GEMDigiTask/track_phi") != nullptr && dbe_->get("MuonGEMDigisV/GEMDigiTask/track_eta") !=nullptr ) { + gem_trk_phi = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/track_phi")->getTH1F()->Clone(); + gem_trk_eta = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/track_eta")->getTH1F()->Clone(); + gem_trk_phi->Sumw2(); + gem_trk_eta->Sumw2(); + } + + if( dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_sh_eta"+postfix[0]) !=nullptr && dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_sh_phi"+postfix[0]) !=nullptr ) { + for ( int i =0 ; i< 4 ; i++) { + sh_eta[i] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_sh_eta"+postfix[i])->getTH1F()->Clone(); + sh_eta[i]->Sumw2(); + sh_phi[i] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_sh_phi"+postfix[i])->getTH1F()->Clone(); + sh_phi[i]->Sumw2(); + } + + } + if( dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_eta"+postfix[0]) !=nullptr && sh_eta[0] !=nullptr && gem_trk_eta !=nullptr ) { + for ( int i =0 ; i< 4 ; i++) { + TH1F* dg_eta = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_eta"+postfix[i])->getTH1F()->Clone(); + TH1F* dg_eta_2 = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_eta"+postfix[i])->getTH1F()->Clone(); + dg_eta->Sumw2(); + dg_eta_2->Sumw2(); + dg_eta->Divide(gem_trk_eta); + dg_eta_2->Divide(sh_eta[i]); + dbe_->book1D( TString::Format("eff_%s",dg_eta->GetName()),dg_eta); + dbe_->book1D( TString::Format("eff_%s_with_sh",dg_eta_2->GetName()),dg_eta_2); + } + } + if( dbe_->get("MuonGEMDigisV/GEMDigiTask/pad_eta"+postfix[0]) !=nullptr && sh_eta[0] !=nullptr && gem_trk_eta !=nullptr ) { + for ( int i =0 ; i< 4 ; i++) { + TH1F* pad_eta; + TH1F* pad_eta_2; + if ( i <3) { + pad_eta = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/pad_eta"+postfix[i])->getTH1F()->Clone(); + pad_eta_2 = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/pad_eta"+postfix[i])->getTH1F()->Clone(); + } + else { + pad_eta = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/copad_eta")->getTH1F()->Clone(); + pad_eta_2 = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/copad_eta")->getTH1F()->Clone(); + } + pad_eta->Sumw2(); + pad_eta_2->Sumw2(); + gem_trk_eta = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/track_eta")->getTH1F()->Clone(); + + pad_eta->Divide(gem_trk_eta); + pad_eta_2->Divide(sh_eta[i]); + dbe_->book1D( TString::Format("eff_%s",pad_eta->GetName()),pad_eta); + dbe_->book1D( TString::Format("eff_%s_with_sh",pad_eta_2->GetName()),pad_eta_2); + } + } + + if( dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_phi"+postfix[0]) !=nullptr && sh_eta[0] !=nullptr && gem_trk_phi !=nullptr) { + for ( int i =0 ; i< 4 ; i++) { + TH1F* dg_phi = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_phi"+postfix[i])->getTH1F()->Clone(); + TH1F* dg_phi_2 = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_phi"+postfix[i])->getTH1F()->Clone(); + dg_phi->Sumw2(); + dg_phi_2->Sumw2(); + dg_phi->Divide(gem_trk_phi); + dg_phi_2->Divide(sh_phi[i]); + dbe_->book1D( TString::Format("eff_%s",dg_phi->GetName()),dg_phi); + dbe_->book1D( TString::Format("eff_%s_with_sh",dg_phi_2->GetName()),dg_phi_2); + } + } + if( dbe_->get("MuonGEMDigisV/GEMDigiTask/pad_phi"+postfix[0]) !=nullptr && sh_phi[0] !=nullptr && gem_trk_phi !=nullptr) { + for ( int i =0 ; i< 4 ; i++) { + TH1F* pad_phi; + TH1F* pad_phi_2; + if ( i <3) { + pad_phi = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/pad_phi"+postfix[i])->getTH1F()->Clone(); + pad_phi_2 = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/pad_phi"+postfix[i])->getTH1F()->Clone(); + } + else { + pad_phi = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/copad_phi")->getTH1F()->Clone(); + pad_phi_2 = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/copad_phi")->getTH1F()->Clone(); + } + pad_phi->Sumw2(); + pad_phi_2->Sumw2(); + pad_phi->Divide(gem_trk_phi); + pad_phi_2->Divide(sh_phi[i]); + dbe_->book1D( TString::Format("eff_%s",pad_phi->GetName()),pad_phi); + dbe_->book1D( TString::Format("eff_%s_with_sh",pad_phi_2->GetName()),pad_phi_2); + } + } + + if( dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even") != nullptr) { + + TH1F* gem_dg_lx_even[5]; + gem_dg_lx_even[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even")->getTH1F()->Clone(); + gem_dg_lx_even[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l1")->getTH1F()->Clone(); + gem_dg_lx_even[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l2")->getTH1F()->Clone(); + gem_dg_lx_even[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l1or2")->getTH1F()->Clone(); + gem_dg_lx_even[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_even_l1and2")->getTH1F()->Clone(); + + TH1F* gem_dg_ly_even[5]; + gem_dg_ly_even[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even")->getTH1F()->Clone(); + gem_dg_ly_even[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l1")->getTH1F()->Clone(); + gem_dg_ly_even[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l2")->getTH1F()->Clone(); + gem_dg_ly_even[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l1or2")->getTH1F()->Clone(); + gem_dg_ly_even[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_even_l1and2")->getTH1F()->Clone(); + + TH1F* gem_dg_lx_odd[5]; + gem_dg_lx_odd[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd")->getTH1F()->Clone(); + gem_dg_lx_odd[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l1")->getTH1F()->Clone(); + gem_dg_lx_odd[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l2")->getTH1F()->Clone(); + gem_dg_lx_odd[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l1or2")->getTH1F()->Clone(); + gem_dg_lx_odd[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_lx_odd_l1and2")->getTH1F()->Clone(); + + TH1F* gem_dg_ly_odd[5]; + gem_dg_ly_odd[0] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd")->getTH1F()->Clone(); + gem_dg_ly_odd[1] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l1")->getTH1F()->Clone(); + gem_dg_ly_odd[2] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l2")->getTH1F()->Clone(); + gem_dg_ly_odd[3] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l1or2")->getTH1F()->Clone(); + gem_dg_ly_odd[4] = (TH1F*)dbe_->get("MuonGEMDigisV/GEMDigiTask/dg_ly_odd_l1and2")->getTH1F()->Clone(); + + for ( int i= 0; i<5 ; i++) { + gem_dg_lx_even[i]->Sumw2(); + gem_dg_ly_even[i]->Sumw2(); + gem_dg_lx_odd[i]->Sumw2(); + gem_dg_ly_odd[i]->Sumw2(); + + } + for( int i=1 ; i<5 ; i++) { + gem_dg_lx_even[i]->Divide( gem_dg_lx_even[0]); + gem_dg_ly_even[i]->Divide( gem_dg_ly_even[0]); + gem_dg_lx_odd[i]->Divide( gem_dg_lx_odd[0]); + gem_dg_ly_odd[i]->Divide( gem_dg_ly_odd[0]); + + dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_lx_even[i]->GetName()),gem_dg_lx_even[i] ); + dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_ly_even[i]->GetName()),gem_dg_ly_even[i] ); + dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_lx_odd[i]->GetName()),gem_dg_lx_odd[i] ); + dbe_->book1D( TString::Format("%s%s","eff_",gem_dg_ly_odd[i]->GetName()),gem_dg_ly_odd[i] ); + } + } +} + + +// ------------ method called when starting to processes a luminosity block ------------ +/* +void +MuonGEMDigis_Harvesting::beginLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) +{ +} +*/ + +// ------------ method called when ending the processing of a luminosity block ------------ +/* +void +MuonGEMDigis_Harvesting::endLuminosityBlock(edm::LuminosityBlock const&, edm::EventSetup const&) +{ +} +*/ + + + + + + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +void +MuonGEMDigis_Harvesting::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descriptions.addDefault(desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(MuonGEMDigis_Harvesting); diff --git a/Validation/MuonGEMDigis/python/PostProcessor_cff.py b/Validation/MuonGEMDigis/python/PostProcessor_cff.py new file mode 100644 index 0000000000000..b99053d5f9bc5 --- /dev/null +++ b/Validation/MuonGEMDigis/python/PostProcessor_cff.py @@ -0,0 +1,4 @@ +import FWCore.ParameterSet.Config as cms + +gemDigiHarvesting = cms.EDAnalyzer("MuonGEMDigis_Harvesting") +MuonGEMDigisPostProcessors = cms.Sequence(gemDigiHarvesting) diff --git a/Validation/MuonGEMDigis/src/GEMCSCCoPadDigiValidation.cc b/Validation/MuonGEMDigis/src/GEMCSCCoPadDigiValidation.cc index c718530ebff32..33e741c2a6dc9 100644 --- a/Validation/MuonGEMDigis/src/GEMCSCCoPadDigiValidation.cc +++ b/Validation/MuonGEMDigis/src/GEMCSCCoPadDigiValidation.cc @@ -25,8 +25,8 @@ GEMCSCCoPadDigiValidation::GEMCSCCoPadDigiValidation(DQMStore* dbe, , theCSCCoPad_bx_rp1( dbe_->book1D("copad_dg_bx_rp1", "Bunch crossing: region 1; bunch crossing ; entries", 11,-5.5,5.5)) -, theCSCCoPad_zr_rm1( dbe_->book2D("copad_dg_zr_rm1", "Digi occupancy: region-1; globalR [cm] ; globalZ [cm] ", 55,130,240,200,-573,-564)) -, theCSCCoPad_zr_rp1( dbe_->book2D("copad_dg_zr_rp1", "Digi occupancy: region 1; globalR [cm] ; globalZ [cm] ", 55,130,240,200, 564, 573)) +, theCSCCoPad_zr_rm1( dbe_->book2D("copad_dg_zr_rm1", "Digi occupancy: region-1; globalZ [cm] ; globalR [cm] ", 200,-573,-564,55,130,240)) +, theCSCCoPad_zr_rp1( dbe_->book2D("copad_dg_zr_rp1", "Digi occupancy: region 1; globalZ [cm] ; globalR [cm] ", 200, 564, 573,55,130,240)) { } @@ -89,14 +89,14 @@ void GEMCSCCoPadDigiValidation::analyze(const edm::Event& e, // fill hist if ( region== -1 ) { - theCSCCoPad_zr_rm1->Fill(g_r,g_z); + theCSCCoPad_zr_rm1->Fill(g_z,g_r); theCSCCoPad_xy_rm1->Fill(g_x,g_y); theCSCCoPad_phipad_rm1->Fill(pad,g_phi); theCSCCoPad_rm1->Fill(pad); theCSCCoPad_bx_rm1->Fill(bx); } else if ( region == 1 ) { - theCSCCoPad_zr_rp1->Fill(g_r,g_z); + theCSCCoPad_zr_rp1->Fill(g_z,g_r); theCSCCoPad_xy_rp1->Fill(g_x,g_y); theCSCCoPad_phipad_rp1->Fill(pad,g_phi); theCSCCoPad_rp1->Fill(pad); diff --git a/Validation/MuonGEMDigis/src/GEMCSCPadDigiValidation.cc b/Validation/MuonGEMDigis/src/GEMCSCPadDigiValidation.cc index 03d3fb9091d35..fd0d41d47ca46 100644 --- a/Validation/MuonGEMDigis/src/GEMCSCPadDigiValidation.cc +++ b/Validation/MuonGEMDigis/src/GEMCSCPadDigiValidation.cc @@ -32,8 +32,8 @@ GEMCSCPadDigiValidation::GEMCSCPadDigiValidation(DQMStore* dbe, , theCSCPad_bx_rp1_l2( dbe_->book1D("pad_dg_bx_rp1_l2", "Bunch crossing: region 1, layer2; bunch crossing ; entries", 11,-5.5,5.5)) -, theCSCPad_zr_rm1( dbe_->book2D("pad_dg_zr_rm1", "Digi occupancy: region-1; globalR [cm] ; globalZ [cm] ", 55,130,240,200,-573,-564)) -, theCSCPad_zr_rp1( dbe_->book2D("pad_dg_zr_rp1", "Digi occupancy: region 1; globalR [cm] ; globalZ [cm] ", 55,130,240,200, 564, 573)) +, theCSCPad_zr_rm1( dbe_->book2D("pad_dg_zr_rm1", "Digi occupancy: region-1; globalZ [cm] ; globalR [cm] ", 200,-573,-564,55,130,240)) +, theCSCPad_zr_rp1( dbe_->book2D("pad_dg_zr_rp1", "Digi occupancy: region 1; globalZ [cm] ; globalR [cm] ", 200,564,573,55,130,240)) { } @@ -96,7 +96,7 @@ void GEMCSCPadDigiValidation::analyze(const edm::Event& e, // fill hist if ( region== -1 ) { - theCSCPad_zr_rm1->Fill(g_r,g_z); + theCSCPad_zr_rm1->Fill(g_z,g_r); if ( layer == 1 ) { theCSCPad_xy_rm1_l1->Fill(g_x,g_y); theCSCPad_phipad_rm1_l1->Fill(g_phi, pad); @@ -114,7 +114,7 @@ void GEMCSCPadDigiValidation::analyze(const edm::Event& e, } } else if ( region == 1 ) { - theCSCPad_zr_rp1->Fill(g_r,g_z); + theCSCPad_zr_rp1->Fill(g_z,g_r); if ( layer == 1 ) { theCSCPad_xy_rp1_l1->Fill(g_x,g_y); diff --git a/Validation/MuonGEMDigis/src/GEMStripDigiValidation.cc b/Validation/MuonGEMDigis/src/GEMStripDigiValidation.cc index b8501b2922ac1..eed889de92f82 100644 --- a/Validation/MuonGEMDigis/src/GEMStripDigiValidation.cc +++ b/Validation/MuonGEMDigis/src/GEMStripDigiValidation.cc @@ -7,32 +7,32 @@ GEMStripDigiValidation::GEMStripDigiValidation(DQMStore* dbe, const edm::InputTag & inputTag) : GEMBaseValidation(dbe, inputTag) -, theStrip_xy_rm1_l1( dbe_->book2D("strip_dg_xy_rm1_l1", "Digi occupancy: region -1, layer1;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260)) -, theStrip_xy_rm1_l2( dbe_->book2D("strip_dg_xy_rm1_l2", "Digi occupancy: region -1, layer2;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260)) -, theStrip_xy_rp1_l1( dbe_->book2D("strip_dg_xy_rp1_l1", "Digi occupancy: region 1, layer1;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260)) -, theStrip_xy_rp1_l2( dbe_->book2D("strip_dg_xy_rp1_l2", "Digi occupancy: region 1, layer2;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260)) +{ + theStrip_xy_rm1_l1 = dbe_->book2D("strip_dg_xy_rm1_l1", "Digi occupancy: region -1, layer1;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260); + theStrip_xy_rm1_l2 = dbe_->book2D("strip_dg_xy_rm1_l2", "Digi occupancy: region -1, layer2;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260); + theStrip_xy_rp1_l1 = dbe_->book2D("strip_dg_xy_rp1_l1", "Digi occupancy: region 1, layer1;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260); + theStrip_xy_rp1_l2 = dbe_->book2D("strip_dg_xy_rp1_l2", "Digi occupancy: region 1, layer2;globalX [cm]; globalY[cm]", 260,-260,260,260,-260,260); -, theStrip_phistrip_rm1_l1( dbe_->book2D("strip_dg_phistrip_rm1_l1", "Digi occupancy: region -1, layer1; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi())) -, theStrip_phistrip_rm1_l2( dbe_->book2D("strip_dg_phistrip_rm1_l2", "Digi occupancy: region -1, layer2; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi())) -, theStrip_phistrip_rp1_l1( dbe_->book2D("strip_dg_phistrip_rp1_l1", "Digi occupancy: region 1, layer1; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi())) -, theStrip_phistrip_rp1_l2( dbe_->book2D("strip_dg_phistrip_rp1_l2", "Digi occupancy: region 1, layer2; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi())) + theStrip_phistrip_rm1_l1 = dbe_->book2D("strip_dg_phistrip_rm1_l1", "Digi occupancy: region -1, layer1; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi()); + theStrip_phistrip_rm1_l2 = dbe_->book2D("strip_dg_phistrip_rm1_l2", "Digi occupancy: region -1, layer2; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi()); + theStrip_phistrip_rp1_l1 = dbe_->book2D("strip_dg_phistrip_rp1_l1", "Digi occupancy: region 1, layer1; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi()); + theStrip_phistrip_rp1_l2 = dbe_->book2D("strip_dg_phistrip_rp1_l2", "Digi occupancy: region 1, layer2; strip number; phi [rad]", 192,0,384,280,-TMath::Pi(),TMath::Pi()); -, theStrip_rm1_l1( dbe_->book1D("strip_dg_rm1_l1", "Digi occupancy per stip number: region -1, layer1;strip number; entries", 384,0.5,384.5)) -, theStrip_rm1_l2( dbe_->book1D("strip_dg_rm1_l2", "Digi occupancy per stip number: region -1, layer2;strip number; entries", 384,0.5,384.5)) -, theStrip_rp1_l1( dbe_->book1D("strip_dg_rp1_l1", "Digi occupancy per stip number: region 1, layer1;strip number; entries", 384,0.5,384.5)) -, theStrip_rp1_l2( dbe_->book1D("strip_dg_rp1_l2", "Digi occupancy per stip number: region 1, layer2;strip number; entries", 384,0.5,384.5)) + theStrip_rm1_l1 = dbe_->book1D("strip_dg_rm1_l1", "Digi occupancy per stip number: region -1, layer1;strip number; entries", 384,0.5,384.5); + theStrip_rm1_l2 = dbe_->book1D("strip_dg_rm1_l2", "Digi occupancy per stip number: region -1, layer2;strip number; entries", 384,0.5,384.5); + theStrip_rp1_l1 = dbe_->book1D("strip_dg_rp1_l1", "Digi occupancy per stip number: region 1, layer1;strip number; entries", 384,0.5,384.5); + theStrip_rp1_l2 = dbe_->book1D("strip_dg_rp1_l2", "Digi occupancy per stip number: region 1, layer2;strip number; entries", 384,0.5,384.5); -, theStrip_bx_rm1_l1( dbe_->book1D("strip_dg_bx_rm1_l1", "Bunch crossing: region -1, layer1; bunch crossing ; entries", 11,-5.5,5.5)) -, theStrip_bx_rm1_l2( dbe_->book1D("strip_dg_bx_rm1_l2", "Bunch crossing: region -1, layer2; bunch crossing ; entries", 11,-5.5,5.5)) -, theStrip_bx_rp1_l1( dbe_->book1D("strip_dg_bx_rp1_l1", "Bunch crossing: region 1, layer1; bunch crossing ; entries", 11,-5.5,5.5)) -, theStrip_bx_rp1_l2( dbe_->book1D("strip_dg_bx_rp1_l2", "Bunch crossing: region 1, layer2; bunch crossing ; entries", 11,-5.5,5.5)) + theStrip_bx_rm1_l1 = dbe_->book1D("strip_dg_bx_rm1_l1", "Bunch crossing: region -1, layer1; bunch crossing ; entries", 11,-5.5,5.5); + theStrip_bx_rm1_l2 = dbe_->book1D("strip_dg_bx_rm1_l2", "Bunch crossing: region -1, layer2; bunch crossing ; entries", 11,-5.5,5.5); + theStrip_bx_rp1_l1 = dbe_->book1D("strip_dg_bx_rp1_l1", "Bunch crossing: region 1, layer1; bunch crossing ; entries", 11,-5.5,5.5); + theStrip_bx_rp1_l2 = dbe_->book1D("strip_dg_bx_rp1_l2", "Bunch crossing: region 1, layer2; bunch crossing ; entries", 11,-5.5,5.5); -, theStrip_zr_rm1( dbe_->book2D("strip_dg_zr_rm1", "Digi occupancy: region-1; globalR [cm] ; globalZ [cm] ", 55,130,240,200,-573,-564)) -, theStrip_zr_rp1( dbe_->book2D("strip_dg_zr_rp1", "Digi occupancy: region 1; globalR [cm] ; globalZ [cm] ", 55,130,240,200, 564, 573)) -{ + theStrip_zr_rm1 = dbe_->book2D("strip_dg_zr_rm1", "Digi occupancy: region-1; globalZ [cm] ; globalR [cm] ", 200,-573,-564, 55,130,240); + theStrip_zr_rp1 = dbe_->book2D("strip_dg_zr_rp1", "Digi occupancy: region 1; globalZ [cm] ; globalR [cm] ", 200,564,573,55,130,240); } @@ -52,8 +52,6 @@ void GEMStripDigiValidation::analyze(const edm::Event& e, edm::LogError("GEMDigiValidation") << "Cannot get strips by label " << theInputTag.encode(); } - //std::cout<<" Hello "<begin(); cItr!=gem_digis->end(); cItr++) { GEMDetId id = (*cItr).first; @@ -94,7 +92,7 @@ void GEMStripDigiValidation::analyze(const edm::Event& e, // fill hist if ( region== -1 ) { - theStrip_zr_rm1->Fill(g_r,g_z); + theStrip_zr_rm1->Fill(g_z,g_r); if ( layer == 1 ) { theStrip_xy_rm1_l1->Fill(g_x,g_y); theStrip_phistrip_rm1_l1->Fill(strip,g_phi); @@ -108,11 +106,11 @@ void GEMStripDigiValidation::analyze(const edm::Event& e, theStrip_bx_rm1_l2->Fill(bx); } else { - std::cout<<"layer : "<Fill(g_r,g_z); + theStrip_zr_rp1->Fill(g_z,g_r); if ( layer == 1 ) { theStrip_xy_rp1_l1->Fill(g_x,g_y); @@ -127,11 +125,11 @@ void GEMStripDigiValidation::analyze(const edm::Event& e, theStrip_bx_rp1_l2->Fill(bx); } else { - std::cout<<"layer : "< #include -const float PI=TMath::Pi(); -struct MySimTrack -{ - Float_t pt, eta, phi; - Char_t gem_sh_layer1, gem_sh_layer2; - Char_t gem_dg_layer1, gem_dg_layer2; - Char_t gem_pad_layer1, gem_pad_layer2; - Float_t gem_lx_even, gem_ly_even; - Float_t gem_lx_odd, gem_ly_odd; - Char_t has_gem_dg_l1, has_gem_dg_l2; - Char_t has_gem_pad_l1, has_gem_pad_l2; - Char_t has_gem_sh_l1, has_gem_sh_l2; -}; GEMTrackMatch::GEMTrackMatch(DQMStore* dbe, std::string simInputLabel , edm::ParameterSet cfg) { + const float PI=TMath::Pi(); cfg_= cfg; simInputLabel_= simInputLabel; dbe_= dbe; @@ -33,40 +21,38 @@ GEMTrackMatch::GEMTrackMatch(DQMStore* dbe, std::string simInputLabel , edm::Par minEta_ = cfg_.getUntrackedParameter("gemDigiMinEta",1.55); maxEta_ = cfg_.getUntrackedParameter("gemDigiMaxEta",2.18); buildLUT(); - track_eta = new TH1F("track_eta", "track_eta;SimTrack |#eta|;# of tracks", 140,1.5,2.2); - track_phi = new TH1F("track_phi", "track_phi;SimTrack |#eta|;# of tracks", 100,-PI,PI); - track_dg_eta = new TH1F("track_dg_eta", "track_eta;SimTrack |#eta|;# of tracks", 140,1.5,2.2); - track_sh_eta = new TH1F("track_sh_eta", "track_eta;SimTrack |#eta|;# of tracks", 140,1.5,2.2); - - dg_eta[0] = new TH1F("dg_eta_l1","dg_eta_l1",140,1.5,2.2); - dg_eta[1] = new TH1F("dg_eta_l2","dg_eta_l2",140,1.5,2.2); - dg_eta[2] = new TH1F("dg_eta_l1or2","dg_eta_l1or2",140,1.5,2.2); - dg_eta[3] = new TH1F("dg_eta_l1and2","dg_eta_l1and2",140,1.5,2.2); - - dg_sh_eta[0] = new TH1F("dg_sh_eta_l1","dg_sh_eta_l1",140,1.5,2.2); - dg_sh_eta[1] = new TH1F("dg_sh_eta_l2","dg_sh_eta_l2",140,1.5,2.2); - dg_sh_eta[2] = new TH1F("dg_sh_eta_l1or2","dg_sh_eta_l1or2",140,1.5,2.2); - dg_sh_eta[3] = new TH1F("dg_sh_eta_l1and2","dg_sh_eta_l1and2",140,1.5,2.2); - - dg_phi[0] = new TH1F("dg_phi_l1","dg_phi_l1",100,-PI,PI); - dg_phi[1] = new TH1F("dg_phi_l2","dg_phi_l2",100,-PI,PI); - dg_phi[2] = new TH1F("dg_phi_l1or2","dg_phi_l1or2",100,-PI,PI); - dg_phi[3] = new TH1F("dg_phi_l1and2","dg_phi_l1and2",100,-PI,PI); + track_eta = dbe_->book1D("track_eta", "track_eta;SimTrack |#eta|;# of tracks", 140,1.5,2.2); + track_phi = dbe_->book1D("track_phi", "track_phi;SimTrack |#eta|;# of tracks", 100,-PI,PI); + + dg_eta[0] = dbe_->book1D("dg_eta_l1","dg_eta_l1",140,1.5,2.2); + dg_eta[1] = dbe_->book1D("dg_eta_l2","dg_eta_l2",140,1.5,2.2); + dg_eta[2] = dbe_->book1D("dg_eta_l1or2","dg_eta_l1or2",140,1.5,2.2); + dg_eta[3] = dbe_->book1D("dg_eta_l1and2","dg_eta_l1and2",140,1.5,2.2); + + dg_sh_eta[0] = dbe_->book1D("dg_sh_eta_l1","dg_sh_eta_l1",140,1.5,2.2); + dg_sh_eta[1] = dbe_->book1D("dg_sh_eta_l2","dg_sh_eta_l2",140,1.5,2.2); + dg_sh_eta[2] = dbe_->book1D("dg_sh_eta_l1or2","dg_sh_eta_l1or2",140,1.5,2.2); + dg_sh_eta[3] = dbe_->book1D("dg_sh_eta_l1and2","dg_sh_eta_l1and2",140,1.5,2.2); + + dg_phi[0] = dbe_->book1D("dg_phi_l1","dg_phi_l1",100,-PI,PI); + dg_phi[1] = dbe_->book1D("dg_phi_l2","dg_phi_l2",100,-PI,PI); + dg_phi[2] = dbe_->book1D("dg_phi_l1or2","dg_phi_l1or2",100,-PI,PI); + dg_phi[3] = dbe_->book1D("dg_phi_l1and2","dg_phi_l1and2",100,-PI,PI); - dg_sh_phi[0] = new TH1F("dg_sh_phi_l1","dg_sh_phi_l1",100,-PI,PI); - dg_sh_phi[1] = new TH1F("dg_sh_phi_l2","dg_sh_phi_l2",100,-PI,PI); - dg_sh_phi[2] = new TH1F("dg_sh_phi_l1or2","dg_sh_phi_l1or2",100,-PI,PI); - dg_sh_phi[3] = new TH1F("dg_sh_phi_l1and2","dg_sh_phi_l1and2",100,-PI,PI); + dg_sh_phi[0] = dbe_->book1D("dg_sh_phi_l1","dg_sh_phi_l1",100,-PI,PI); + dg_sh_phi[1] = dbe_->book1D("dg_sh_phi_l2","dg_sh_phi_l2",100,-PI,PI); + dg_sh_phi[2] = dbe_->book1D("dg_sh_phi_l1or2","dg_sh_phi_l1or2",100,-PI,PI); + dg_sh_phi[3] = dbe_->book1D("dg_sh_phi_l1and2","dg_sh_phi_l1and2",100,-PI,PI); - pad_eta[0] = new TH1F("pad_eta_l1","pad_eta_l1",140,1.5,2.2); - pad_eta[1] = new TH1F("pad_eta_l2","pad_eta_l2",140,1.5,2.2); - pad_eta[2] = new TH1F("pad_eta_l1or2","pad_eta_l1or2",140,1.5,2.2); - pad_eta[3] = new TH1F("copad_eta","copad_eta",140,1.5,2.2); + pad_eta[0] = dbe_->book1D("pad_eta_l1","pad_eta_l1",140,1.5,2.2); + pad_eta[1] = dbe_->book1D("pad_eta_l2","pad_eta_l2",140,1.5,2.2); + pad_eta[2] = dbe_->book1D("pad_eta_l1or2","pad_eta_l1or2",140,1.5,2.2); + pad_eta[3] = dbe_->book1D("copad_eta","copad_eta",140,1.5,2.2); - pad_phi[0] = new TH1F("pad_phi_l1","pad_phi_l1",100,-PI,PI); - pad_phi[1] = new TH1F("pad_phi_l2","pad_phi_l2",100,-PI,PI); - pad_phi[2] = new TH1F("pad_phi_l1or2","pad_phi_l1or2",100,-PI,PI); - pad_phi[3] = new TH1F("copad_phi","copad_phi",100,-PI,PI); + pad_phi[0] = dbe_->book1D("pad_phi_l1","pad_phi_l1",100,-PI,PI); + pad_phi[1] = dbe_->book1D("pad_phi_l2","pad_phi_l2",100,-PI,PI); + pad_phi[2] = dbe_->book1D("pad_phi_l1or2","pad_phi_l1or2",100,-PI,PI); + pad_phi[3] = dbe_->book1D("copad_phi","copad_phi",100,-PI,PI); dg_lx_even = dbe_->book1D("dg_lx_even","dg_lx_even",100,-100,100); dg_lx_even_l1 = dbe_->book1D("dg_lx_even_l1","dg_lx_even_l1",100,-100,100); @@ -102,6 +88,7 @@ GEMTrackMatch::~GEMTrackMatch() { bool GEMTrackMatch::isSimTrackGood(const SimTrack &t) { + // SimTrack selection if (t.noVertex()) return false; if (t.noGenpart()) return false; @@ -109,12 +96,14 @@ bool GEMTrackMatch::isSimTrackGood(const SimTrack &t) if (t.momentum().pt() < 5 ) return false; float eta = fabs(t.momentum().eta()); if (eta > maxEta_ || eta < minEta_ ) return false; // no GEMs could be in such eta + return true; } void GEMTrackMatch::buildLUT() { + const int maxChamberId_ = GEMDetId().maxChamberId; std::vector pos_ids; pos_ids.push_back(GEMDetId(1,1,1,1,maxChamberId_,1).rawId()); @@ -134,6 +123,7 @@ void GEMTrackMatch::buildLUT() } positiveLUT_ = std::make_pair(phis,pos_ids); negativeLUT_ = std::make_pair(phis,neg_ids); + } @@ -153,23 +143,35 @@ void GEMTrackMatch::setGeometry(const GEMGeometry* geom) radiusCenter_ = (gp_bottom.perp() + gp_top.perp())/2.; chamberHeight_ = gp_top.perp() - gp_bottom.perp(); - std::cout<<"radiusCenter"< GEMTrackMatch::getClosestChambers(int region, float phi) { + auto& phis(positiveLUT_.first); auto upper = std::upper_bound(phis.begin(), phis.end(), phi); -// std::cout << "lower = " << upper - phis.begin() << std::endl; -// std::cout << "upper = " << upper - phis.begin() + 1 << std::endl; auto& LUT = (region == 1 ? positiveLUT_.second : negativeLUT_.second); + + return std::make_pair(LUT.at(upper - phis.begin()), (LUT.at((upper - phis.begin() + 1)%36))); } void GEMTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) { + struct MySimTrack + { + Float_t pt, eta, phi; + Char_t gem_sh_layer1, gem_sh_layer2; + Char_t gem_dg_layer1, gem_dg_layer2; + Char_t gem_pad_layer1, gem_pad_layer2; + Float_t gem_lx_even, gem_ly_even; + Float_t gem_lx_odd, gem_ly_odd; + Char_t has_gem_dg_l1, has_gem_dg_l2; + Char_t has_gem_pad_l1, has_gem_pad_l2; + Char_t has_gem_sh_l1, has_gem_sh_l2; + }; MySimTrack track_; iEvent.getByLabel(simInputLabel_, sim_tracks); @@ -178,6 +180,7 @@ void GEMTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe const edm::SimVertexContainer & sim_vert = *sim_vertices.product(); const edm::SimTrackContainer & sim_trks = *sim_tracks.product(); + for (auto& t: sim_trks) { if (!isSimTrackGood(t)) @@ -185,7 +188,7 @@ void GEMTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe //{ printf("skip!!\n"); continue; } // match hits and digis to this SimTrack - SimTrackMatchManager match(t, sim_vert[t.vertIndex()], cfg_, iEvent, iSetup); + SimTrackDigiMatchManager match(t, sim_vert[t.vertIndex()], cfg_, iEvent, iSetup); const SimHitMatcher& match_sh = match.simhits(); const GEMDigiMatcher& match_gd = match.gemDigis(); @@ -224,9 +227,12 @@ void GEMTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe } } + // ** GEM Digis, Pads and CoPads ** // + auto gem_dg_ids_ch = match_gd.chamberIds(); + for(auto d: gem_dg_ids_ch) { GEMDetId id(d); @@ -244,7 +250,6 @@ void GEMTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe } track_eta->Fill( fabs( track_.eta) ); - track_dg_eta->Fill( fabs( track_.eta)); if ( track_.gem_dg_layer1 > 0 ) { dg_eta[0]->Fill ( fabs( track_.eta ) ); } @@ -262,8 +267,6 @@ void GEMTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSe } - track_sh_eta->Fill( fabs( track_.eta)); - if ( track_.gem_sh_layer1 > 0 ) { dg_sh_eta[0]->Fill ( fabs(track_.eta)); } diff --git a/Validation/MuonGEMDigis/src/SimTrackDigiMatchManager.cc b/Validation/MuonGEMDigis/src/SimTrackDigiMatchManager.cc new file mode 100644 index 0000000000000..b5114d8bdd410 --- /dev/null +++ b/Validation/MuonGEMDigis/src/SimTrackDigiMatchManager.cc @@ -0,0 +1,9 @@ +#include "Validation/MuonGEMDigis/interface/SimTrackDigiMatchManager.h" + +SimTrackDigiMatchManager::SimTrackDigiMatchManager(const SimTrack& t, const SimVertex& v, + const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es) +: simhits_(t, v, ps, ev, es) +, gem_digis_(simhits_) +{} + +SimTrackDigiMatchManager::~SimTrackDigiMatchManager() {} diff --git a/Validation/MuonGEMDigis/test/MuonGEMDigi_cfg.py b/Validation/MuonGEMDigis/test/MuonGEMDigi_cfg.py index 492d3ab5c4879..ecb6b01ca7d07 100644 --- a/Validation/MuonGEMDigis/test/MuonGEMDigi_cfg.py +++ b/Validation/MuonGEMDigis/test/MuonGEMDigi_cfg.py @@ -37,7 +37,6 @@ DQMStore = cms.Service("DQMStore") dqmSaver.convention = 'Offline' -dqmSaver.workflow = '/MuonGEMDigisV/Workflow/DIGI' process.MEtoEDMConverter.Verbosity= cms.untracked.int32(1) process.MEtoEDMConverter.Frequency= cms.untracked.int32(1) diff --git a/Validation/MuonGEMHits/BuildFile.xml b/Validation/MuonGEMHits/BuildFile.xml new file mode 100644 index 0000000000000..58d5f63726420 --- /dev/null +++ b/Validation/MuonGEMHits/BuildFile.xml @@ -0,0 +1,33 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Validation/MuonGEMHits/README b/Validation/MuonGEMHits/README new file mode 100644 index 0000000000000..e69de29bb2d1d diff --git a/Validation/MuonGEMHits/interface/BaseMatcher.h b/Validation/MuonGEMHits/interface/BaseMatcher.h new file mode 100644 index 0000000000000..97cd16366535c --- /dev/null +++ b/Validation/MuonGEMHits/interface/BaseMatcher.h @@ -0,0 +1,89 @@ +#ifndef GEMValidation_BaseMatcher_h +#define GEMValidation_BaseMatcher_h + +/**\class BaseMatcher + + Base for Sim and Trigger info matchers for SimTrack in CSC & GEM + + Original Author: "Vadim Khotilovich" + $Id: BaseMatcher.h,v 1.1 2013/02/11 07:33:06 khotilov Exp $ + +*/ + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/EventSetup.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/ESHandle.h" + +#include +#include + +#include "MagneticField/Engine/interface/MagneticField.h" +#include "TrackingTools/GeomPropagators/interface/Propagator.h" + +//static const float AVERAGE_GEM_Z(587.5); // [cm] +static const float AVERAGE_GEM_Z(568.6); // [cm] + +class BaseMatcher +{ +public: + + /// CSC chamber types, according to CSCDetId::iChamberType() + enum CSCType {CSC_ALL = 0, CSC_ME1a, CSC_ME1b, CSC_ME12, CSC_ME13, + CSC_ME21, CSC_ME22, CSC_ME31, CSC_ME32, CSC_ME41, CSC_ME42}; + + + BaseMatcher(const SimTrack& t, const SimVertex& v, + const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es); + + ~BaseMatcher(); + + // non-copyable + BaseMatcher(const BaseMatcher&) = delete; + BaseMatcher& operator=(const BaseMatcher&) = delete; + + + const SimTrack& trk() const {return trk_;} + const SimVertex& vtx() const {return vtx_;} + + const edm::ParameterSet& conf() const {return conf_;} + + const edm::Event& event() const {return ev_;} + const edm::EventSetup& eventSetup() const {return es_;} + + /// check if CSC chamber type is in the used list + bool useCSCChamberType(int csc_type); + + void setVerbose(int v) { verbose_ = v; } + int verbose() const { return verbose_; } + + /// general interface to propagation + GlobalPoint propagateToZ(GlobalPoint &inner_point, GlobalVector &inner_vector, float z) const; + + /// propagation for a track starting from a vertex + GlobalPoint propagateToZ(float z) const; + + /// propagate the track to average GEM z-position + GlobalPoint propagatedPositionGEM() const; + +private: + + const SimTrack& trk_; + const SimVertex& vtx_; + + const edm::ParameterSet& conf_; + + const edm::Event& ev_; + const edm::EventSetup& es_; + + int verbose_; + + // list of CSC chamber types to use + bool useCSCChamberTypes_[11]; + + edm::ESHandle magfield_; + edm::ESHandle propagator_; + edm::ESHandle propagatorOpposite_; +}; + +#endif diff --git a/Validation/MuonGEMHits/interface/GEMBaseValidation.h b/Validation/MuonGEMHits/interface/GEMBaseValidation.h new file mode 100644 index 0000000000000..f4fe0ffebaeda --- /dev/null +++ b/Validation/MuonGEMHits/interface/GEMBaseValidation.h @@ -0,0 +1,36 @@ +#ifndef GEMBaseValidation_H +#define GEMBaseValidation_H + +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" +#include "SimDataFormats/Track/interface/SimTrackContainer.h" + +class GEMBaseValidation +{ +public: + GEMBaseValidation(DQMStore* dbe, + const edm::InputTag & inputTag); + virtual ~GEMBaseValidation(); + //virtual void analyze(const edm::Event& e, const edm::EventSetup&) = 0; + + void setGeometry(const GEMGeometry* geom) { theGEMGeometry = geom; } + // void set SimHitMap(const PSimHitMap* simHitMap) { theSimHitMap = simHitMap; } + + + protected: + + DQMStore* dbe_; + edm::InputTag theInputTag; + const GEMGeometry* theGEMGeometry; + +}; + +#endif diff --git a/Validation/MuonGEMHits/interface/GEMHitsValidation.h b/Validation/MuonGEMHits/interface/GEMHitsValidation.h new file mode 100644 index 0000000000000..ad65bcab6082c --- /dev/null +++ b/Validation/MuonGEMHits/interface/GEMHitsValidation.h @@ -0,0 +1,56 @@ +#ifndef GEMHitsValidation_H +#define GEMHitsValidation_H + +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "Validation/MuonGEMDigis/interface/GEMBaseValidation.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + + +#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" +#include "SimDataFormats/Track/interface/SimTrackContainer.h" + +class GEMHitsValidation : public GEMBaseValidation +{ +public: + GEMHitsValidation(DQMStore* dbe, + const edm::InputTag & inputTag, const edm::ParameterSet& cfg); + ~GEMHitsValidation(); + void analyze(const edm::Event& e, const edm::EventSetup&); + + private: + + MonitorElement* gem_sh_xy_rm1_l1[3]; + MonitorElement* gem_sh_xy_rm1_l2[3]; + MonitorElement* gem_sh_xy_rp1_l1[3]; + MonitorElement* gem_sh_xy_rp1_l2[3]; + + MonitorElement* gem_sh_zr_rm1[3]; + MonitorElement* gem_sh_zr_rp1[3]; + + MonitorElement* gem_sh_tof_rm1_l1[3]; + MonitorElement* gem_sh_tof_rm1_l2[3]; + MonitorElement* gem_sh_tof_rp1_l1[3]; + MonitorElement* gem_sh_tof_rp1_l2[3]; + + + MonitorElement* gem_sh_pabs[3]; + MonitorElement* gem_sh_pdgid[3]; + MonitorElement* gem_sh_global_eta[3]; + MonitorElement* gem_sh_energyloss[3]; + + Int_t npart; + Int_t nlayer; + Int_t nregion; + + +}; + +#endif diff --git a/Validation/MuonGEMHits/interface/GEMSimTrackMatch.h b/Validation/MuonGEMHits/interface/GEMSimTrackMatch.h new file mode 100644 index 0000000000000..80dd7060c0339 --- /dev/null +++ b/Validation/MuonGEMHits/interface/GEMSimTrackMatch.h @@ -0,0 +1,104 @@ +#ifndef GEMSimTrackMatch_H +#define GEMSimTrackMatch_H + +#include "DQMServices/Core/interface/DQMStore.h" +#include "DQMServices/Core/interface/MonitorElement.h" + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Utilities/interface/InputTag.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" + + +#include "SimDataFormats/Track/interface/SimTrackContainer.h" + +#include "Geometry/Records/interface/MuonGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDet.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartition.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartitionSpecs.h" +#include "Geometry/CommonTopologies/interface/StripTopology.h" + + +#include "Validation/MuonGEMHits/interface/SimTrackMatchManager.h" + + +class GEMSimTrackMatch +{ +public: + GEMSimTrackMatch(DQMStore* , std::string , edm::ParameterSet); + ~GEMSimTrackMatch(); + void analyze(const edm::Event& e, const edm::EventSetup&); + + void buildLUT(); + std::pair getClosestChambers(int region, float phi); + bool isSimTrackGood(const SimTrack& ); + void setGeometry(const GEMGeometry* geom); + + + + private: + + edm::ParameterSet cfg_; + std::string simInputLabel_; + DQMStore* dbe_; + const GEMGeometry* theGEMGeometry; + + + MonitorElement* track_eta; + MonitorElement* track_eta_l1; + MonitorElement* track_eta_l2; + MonitorElement* track_eta_l1or2; + MonitorElement* track_eta_l1and2; + + MonitorElement* track_phi; + MonitorElement* track_phi_l1; + MonitorElement* track_phi_l2; + MonitorElement* track_phi_l1or2; + MonitorElement* track_phi_l1and2; + + MonitorElement* gem_lx_even; + MonitorElement* gem_lx_even_l1; + MonitorElement* gem_lx_even_l2; + MonitorElement* gem_lx_even_l1or2; + MonitorElement* gem_lx_even_l1and2; + + MonitorElement* gem_ly_even; + MonitorElement* gem_ly_even_l1; + MonitorElement* gem_ly_even_l2; + MonitorElement* gem_ly_even_l1or2; + MonitorElement* gem_ly_even_l1and2; + + MonitorElement* gem_lx_odd; + MonitorElement* gem_lx_odd_l1; + MonitorElement* gem_lx_odd_l2; + MonitorElement* gem_lx_odd_l1or2; + MonitorElement* gem_lx_odd_l1and2; + + MonitorElement* gem_ly_odd; + MonitorElement* gem_ly_odd_l1; + MonitorElement* gem_ly_odd_l2; + MonitorElement* gem_ly_odd_l1or2; + MonitorElement* gem_ly_odd_l1and2; + + + + + + + std::pair,std::vector > positiveLUT_; + std::pair,std::vector > negativeLUT_; + + edm::Handle sim_tracks; + edm::Handle sim_vertices; + + float minPt_; + float minEta_; + float maxEta_; + float radiusCenter_, chamberHeight_; + + +}; + +#endif diff --git a/Validation/MuonGEMHits/interface/MuonGEMHits.h b/Validation/MuonGEMHits/interface/MuonGEMHits.h new file mode 100644 index 0000000000000..314818858c126 --- /dev/null +++ b/Validation/MuonGEMHits/interface/MuonGEMHits.h @@ -0,0 +1,56 @@ +#ifndef MuonGEMHits_H +#define MuonGEMHits_H + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" + + +#include "DQMServices/Core/interface/DQMStore.h" +#include "SimMuon/MCTruth/interface/PSimHitMap.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" + +#include "Validation/MuonGEMHits/interface/GEMHitsValidation.h" +#include "Validation/MuonGEMHits/interface/GEMSimTrackMatch.h" +class MuonGEMHits : public edm::EDAnalyzer +{ +public: + /// constructor + explicit MuonGEMHits(const edm::ParameterSet&); + /// destructor + ~MuonGEMHits(); + + virtual void beginRun(edm::Run const&, edm::EventSetup const&); + + virtual void beginJob() ; + + virtual void analyze(const edm::Event&, const edm::EventSetup&); + + virtual void endJob() ; + + virtual void endRun(const edm::Run&, const edm::EventSetup&) ; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + + DQMStore* dbe_; + std::string outputFile_; + + GEMHitsValidation* theGEMHitsValidation; + GEMSimTrackMatch* theGEMSimTrackMatch; + + + void buildLUT(); + std::pair getClosestChambers(int region, float phi); + + + edm::ESHandle gem_geom; + + const GEMGeometry* gem_geometry_; + + + + std::pair,std::vector > positiveLUT_; + std::pair,std::vector > negativeLUT_; +}; +#endif diff --git a/Validation/MuonGEMHits/interface/MuonGEMHits_Harvesting.h b/Validation/MuonGEMHits/interface/MuonGEMHits_Harvesting.h new file mode 100644 index 0000000000000..52c223d8df265 --- /dev/null +++ b/Validation/MuonGEMHits/interface/MuonGEMHits_Harvesting.h @@ -0,0 +1,39 @@ +#ifndef MuonGEMHits_Harvesting_H +#define MuonGEMHits_Harvesting_H + +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" + + +#include "DQMServices/Core/interface/DQMStore.h" +#include "SimMuon/MCTruth/interface/PSimHitMap.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" + +#include "Validation/MuonGEMHits/interface/GEMHitsValidation.h" +#include "Validation/MuonGEMHits/interface/GEMSimTrackMatch.h" +class MuonGEMHits_Harvesting : public edm::EDAnalyzer +{ +public: + /// constructor + explicit MuonGEMHits_Harvesting(const edm::ParameterSet&); + /// destructor + ~MuonGEMHits_Harvesting(); + + virtual void beginRun(edm::Run const&, edm::EventSetup const&); + + virtual void beginJob() ; + + virtual void analyze(const edm::Event&, const edm::EventSetup&); + + virtual void endJob() ; + + virtual void endRun(const edm::Run&, const edm::EventSetup&) ; + static void fillDescriptions(edm::ConfigurationDescriptions& descriptions); + +private: + + DQMStore* dbe_; + std::string outputFile_; +}; +#endif diff --git a/Validation/MuonGEMHits/interface/SimHitMatcher.h b/Validation/MuonGEMHits/interface/SimHitMatcher.h new file mode 100644 index 0000000000000..dec4087ab2c19 --- /dev/null +++ b/Validation/MuonGEMHits/interface/SimHitMatcher.h @@ -0,0 +1,129 @@ +#ifndef GEMValidation_SimHitMatcher_h +#define GEMValidation_SimHitMatcher_h + +/**\class SimHitMatcher + + Description: Matching of SimHit for SimTrack in CSC & GEM + + Original Author: "Vadim Khotilovich" + $Id: SimHitMatcher.h,v 1.3 2013/02/17 15:55:16 khotilov Exp $ +*/ + +#include "BaseMatcher.h" + +#include "SimDataFormats/Track/interface/SimTrackContainer.h" +#include "SimDataFormats/Vertex/interface/SimVertexContainer.h" +#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" +#include "DataFormats/GeometryVector/interface/GlobalPoint.h" + +#include +#include +#include + +class CSCGeometry; +class GEMGeometry; + +class SimHitMatcher : public BaseMatcher +{ +public: + + SimHitMatcher(const SimTrack& t, const SimVertex& v, + const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es); + + ~SimHitMatcher(); + + /// access to all the GEM SimHits + const edm::PSimHitContainer& simHitsGEM() const {return gem_hits_;} + /// access to all the CSC SimHits + const edm::PSimHitContainer& simHitsCSC() const {return csc_hits_;} + + /// GEM partitions' detIds with SimHits + std::set detIdsGEM() const; + /// CSC layers' detIds with SimHits + /// by default, only returns those from ME1b + std::set detIdsCSC(int csc_type = CSC_ME1b) const; + + /// GEM detid's with hits in 2 layers of coincidence pads + /// those are layer==1 only detid's + std::set detIdsGEMCoincidences() const; + + /// GEM chamber detIds with SimHits + std::set chamberIdsGEM() const; + /// CSC chamber detIds with SimHits + std::set chamberIdsCSC(int csc_type = CSC_ME1b) const; + + /// GEM superchamber detIds with SimHits + std::set superChamberIdsGEM() const; + /// GEM superchamber detIds with SimHits 2 layers of coincidence pads + std::set superChamberIdsGEMCoincidences() const; + + /// simhits from a particular partition (GEM)/layer (CSC), chamber or superchamber + const edm::PSimHitContainer& hitsInDetId(unsigned int) const; + const edm::PSimHitContainer& hitsInChamber(unsigned int) const; + const edm::PSimHitContainer& hitsInSuperChamber(unsigned int) const; + + /// #layers with hits + /// for CSC: "super-chamber" means chamber + int nLayersWithHitsInSuperChamber(unsigned int) const; + + /// How many pads with simhits in GEM did this simtrack get? + int nPadsWithHits() const; + /// How many coincidence pads with simhits in GEM did this simtrack get? + int nCoincidencePadsWithHits() const; + + /// How many CSC chambers with minimum number of layer with simhits did this simtrack get? + int nCoincidenceCSCChambers(int min_n_layers = 4) const; + + /// calculate Global average position for a provided collection of simhits + GlobalPoint simHitsMeanPosition(const edm::PSimHitContainer& sim_hits) const; + + /// calculate average strip (strip for GEM, half-strip for CSC) number for a provided collection of simhits + float simHitsMeanStrip(const edm::PSimHitContainer& sim_hits) const; + + std::set hitStripsInDetId(unsigned int, int margin_n_strips = 0) const; // GEM or CSC + std::set hitWiregroupsInDetId(unsigned int, int margin_n_wg = 0) const; // CSC + std::set hitPadsInDetId(unsigned int) const; // GEM + std::set hitCoPadsInDetId(unsigned int) const; // GEM coincidence pads with hits + + // what unique partitions numbers were hit by this simtrack? + std::set hitPartitions() const; // GEM + +private: + + void init(); + + std::vector getIdsOfSimTrackShower(unsigned trk_id, + const edm::SimTrackContainer& simTracks, const edm::SimVertexContainer& simVertices); + + void matchSimHitsToSimTrack(std::vector track_ids, + const edm::PSimHitContainer& csc_hits, const edm::PSimHitContainer& gem_hits); + + bool simMuOnlyCSC_; + bool simMuOnlyGEM_; + bool discardEleHitsCSC_; + bool discardEleHitsGEM_; + std::string simInputLabel_; + + const CSCGeometry* csc_geo_; + const GEMGeometry* gem_geo_; + + std::map trkid_to_index_; + + edm::PSimHitContainer no_hits_; + + edm::PSimHitContainer csc_hits_; + std::map csc_detid_to_hits_; + std::map csc_chamber_to_hits_; + + edm::PSimHitContainer gem_hits_; + std::map gem_detid_to_hits_; + std::map gem_chamber_to_hits_; + std::map gem_superchamber_to_hits_; + + // detids with hits in pads + std::map > gem_detids_to_pads_; + // detids with hits in 2-layer pad coincidences + std::map > gem_detids_to_copads_; +}; + +#endif diff --git a/Validation/MuonGEMDigis/interface/SimTrackMatchManager.h b/Validation/MuonGEMHits/interface/SimTrackMatchManager.h similarity index 85% rename from Validation/MuonGEMDigis/interface/SimTrackMatchManager.h rename to Validation/MuonGEMHits/interface/SimTrackMatchManager.h index 4a86073905228..69a677d78719f 100644 --- a/Validation/MuonGEMDigis/interface/SimTrackMatchManager.h +++ b/Validation/MuonGEMHits/interface/SimTrackMatchManager.h @@ -14,7 +14,6 @@ #include "Validation/MuonGEMDigis/interface/BaseMatcher.h" #include "Validation/MuonGEMDigis/interface/SimHitMatcher.h" -#include "Validation/MuonGEMDigis/interface/GEMDigiMatcher.h" class SimTrackMatchManager { @@ -26,12 +25,10 @@ class SimTrackMatchManager ~SimTrackMatchManager(); const SimHitMatcher& simhits() const {return simhits_;} - const GEMDigiMatcher& gemDigis() const {return gem_digis_;} private: SimHitMatcher simhits_; - GEMDigiMatcher gem_digis_; }; #endif diff --git a/Validation/MuonGEMHits/plugins/BuildFile.xml b/Validation/MuonGEMHits/plugins/BuildFile.xml new file mode 100644 index 0000000000000..772c77f1a0f88 --- /dev/null +++ b/Validation/MuonGEMHits/plugins/BuildFile.xml @@ -0,0 +1,10 @@ + + + + + + + + + + diff --git a/Validation/MuonGEMHits/plugins/MuonGEMHits.cc b/Validation/MuonGEMHits/plugins/MuonGEMHits.cc new file mode 100644 index 0000000000000..3d1d0baeacfea --- /dev/null +++ b/Validation/MuonGEMHits/plugins/MuonGEMHits.cc @@ -0,0 +1,191 @@ +// -*- C++ -*- +// +// Package: MuonGEMHits +// Class: MuonGEMHits +// +/**\class MuonGEMHits MuonGEMHits.cc Validation/MuonGEMHits/plugins/MuonGEMHits.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Geonmo RYU +// Created: Mon, 07 Oct 2013 12:45:56 GMT +// Based on : /GEMCode/GEMValidation/plugin/GEMDigiAnalyzer.cc +// $Id$ +// +// + + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "TTree.h" +#include "TFile.h" +#include "TGraphAsymmErrors.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "Validation/MuonGEMHits/interface/MuonGEMHits.h" + +///Data Format +#include "DataFormats/GEMDigi/interface/GEMDigiCollection.h" +#include "DataFormats/GEMDigi/interface/GEMCSCPadDigiCollection.h" +#include "DataFormats/MuonDetId/interface/GEMDetId.h" +#include "DataFormats/GeometrySurface/interface/LocalError.h" +#include "DataFormats/GeometryVector/interface/LocalPoint.h" +#include "DataFormats/Scalers/interface/DcsStatus.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Math/interface/deltaPhi.h" + +#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" +#include "SimDataFormats/Track/interface/SimTrackContainer.h" + +///Geometry +#include "Geometry/Records/interface/MuonGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDet.h" + +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartition.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartitionSpecs.h" +#include "Geometry/CommonTopologies/interface/StripTopology.h" + +#include "DQMServices/Core/interface/DQMStore.h" + +///Log messages +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +#include "Validation/MuonGEMHits/interface/SimTrackMatchManager.h" + + + + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +MuonGEMHits::MuonGEMHits(const edm::ParameterSet& ps) +{ + dbe_ = edm::Service().operator->(); + dbe_->setCurrentFolder("MuonGEMHitsV/GEMHitsTask"); + outputFile_ = ps.getParameter("outputFile"); + + //now do what ever initialization is needed + + std::string simInputLabel_ = ps.getUntrackedParameter("simInputLabel","g4SimHits"); + theGEMHitsValidation = new GEMHitsValidation(dbe_, edm::InputTag(simInputLabel_,"MuonGEMHits"),ps.getParameterSet("gemSystemSetting") ); + theGEMSimTrackMatch = new GEMSimTrackMatch(dbe_, simInputLabel_ , ps.getParameterSet("simTrackMatching") ); +} + + + +MuonGEMHits::~MuonGEMHits() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + + + delete theGEMHitsValidation; + delete theGEMSimTrackMatch; + + +} + + + + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +MuonGEMHits::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + using namespace edm; + theGEMHitsValidation->analyze(iEvent,iSetup ); + theGEMSimTrackMatch->analyze(iEvent,iSetup ); + + + + + + +} + + +// ------------ method called once each job just before starting event loop ------------ + +void +MuonGEMHits::beginJob() +{ + + +} + +// ------------ method called once each job just after ending the event loop ------------ + +void +MuonGEMHits::endJob() +{ +} + +// ------------ method called when starting to processes a run ------------ + +void +MuonGEMHits::beginRun(edm::Run const&, edm::EventSetup const& iSetup) +{ + + iSetup.get().get(gem_geom); + gem_geometry_ = &*gem_geom; + + + + theGEMHitsValidation->setGeometry(gem_geometry_); + theGEMSimTrackMatch->setGeometry(gem_geometry_); + + + + +} + + +// ------------ method called when ending the processing of a run ------------ +void +MuonGEMHits::endRun(edm::Run const&, edm::EventSetup const&) +{ + if ( outputFile_.size() != 0 && dbe_ ) dbe_->save(outputFile_); +} + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +void +MuonGEMHits::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descriptions.addDefault(desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(MuonGEMHits); diff --git a/Validation/MuonGEMHits/plugins/MuonGEMHits_Harvesting.cc b/Validation/MuonGEMHits/plugins/MuonGEMHits_Harvesting.cc new file mode 100644 index 0000000000000..142d0c8ae5f3b --- /dev/null +++ b/Validation/MuonGEMHits/plugins/MuonGEMHits_Harvesting.cc @@ -0,0 +1,247 @@ +// -*- C++ -*- +// +// Package: MuonGEMHits_Harversting +// Class: MuonGEMHits +// +/**\class MuonGEMHits MuonGEMHits.cc Validation/MuonGEMHits/plugins/MuonGEMHits.cc + + Description: [one line class summary] + + Implementation: + [Notes on implementation] +*/ +// +// Original Author: Geonmo RYU +// Created: Mon, 07 Oct 2013 12:45:56 GMT +// Based on : /GEMCode/GEMValidation/plugin/GEMDigiAnalyzer.cc +// $Id$ +// +// + + +// system include files +#include + +// user include files +#include "FWCore/Framework/interface/Frameworkfwd.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Framework/interface/Event.h" +#include "FWCore/Framework/interface/MakerMacros.h" +#include "FWCore/ParameterSet/interface/ParameterSet.h" +#include "FWCore/Framework/interface/ESHandle.h" +#include "FWCore/ServiceRegistry/interface/Service.h" +#include "TTree.h" +#include "TFile.h" +#include "TGraphAsymmErrors.h" +#include "FWCore/Framework/interface/EDAnalyzer.h" +#include "FWCore/Utilities/interface/InputTag.h" + +#include "Validation/MuonGEMHits/interface/MuonGEMHits_Harvesting.h" + +///Data Format +#include "DataFormats/GEMDigi/interface/GEMDigiCollection.h" +#include "DataFormats/GEMDigi/interface/GEMCSCPadDigiCollection.h" +#include "DataFormats/MuonDetId/interface/GEMDetId.h" +#include "DataFormats/GeometrySurface/interface/LocalError.h" +#include "DataFormats/GeometryVector/interface/LocalPoint.h" +#include "DataFormats/Scalers/interface/DcsStatus.h" +#include "DataFormats/Common/interface/Handle.h" +#include "DataFormats/Math/interface/deltaPhi.h" + +#include "SimDataFormats/TrackingHit/interface/PSimHitContainer.h" +#include "SimDataFormats/Track/interface/SimTrackContainer.h" + +///Geometry +#include "Geometry/Records/interface/MuonGeometryRecord.h" +#include "Geometry/CommonDetUnit/interface/GeomDet.h" + +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartition.h" +#include "Geometry/GEMGeometry/interface/GEMEtaPartitionSpecs.h" +#include "Geometry/CommonTopologies/interface/StripTopology.h" + +#include "DQMServices/Core/interface/DQMStore.h" + +///Log messages +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "FWCore/ServiceRegistry/interface/Service.h" + +#include "Validation/MuonGEMHits/interface/SimTrackMatchManager.h" + + + + +// +// constants, enums and typedefs +// + +// +// static data member definitions +// + +// +// constructors and destructor +// +MuonGEMHits_Harvesting::MuonGEMHits_Harvesting(const edm::ParameterSet& ps) +{ + dbe_ = edm::Service().operator->(); + //now do what ever initialization is needed + +} + + + +MuonGEMHits_Harvesting::~MuonGEMHits_Harvesting() +{ + + // do anything here that needs to be done at desctruction time + // (e.g. close files, deallocate resources etc.) + + + + +} + + + + + +// +// member functions +// + +// ------------ method called for each event ------------ +void +MuonGEMHits_Harvesting::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + + + + + + +} + + +// ------------ method called once each job just before starting event loop ------------ + +void +MuonGEMHits_Harvesting::beginJob() +{ + + +} + +// ------------ method called once each job just after ending the event loop ------------ + +void +MuonGEMHits_Harvesting::endJob() +{ +} + +// ------------ method called when starting to processes a run ------------ + +void +MuonGEMHits_Harvesting::beginRun(edm::Run const&, edm::EventSetup const& iSetup) +{ + + + +} + + +// ------------ method called when ending the processing of a run ------------ +void +MuonGEMHits_Harvesting::endRun(edm::Run const&, edm::EventSetup const&) +{ + dbe_->cd(); + dbe_->setCurrentFolder("MuonGEMHitsV/GEMHitsTask"); + TH1F* track_eta[5]={nullptr}; + TH1F* track_phi[5]={nullptr}; + TH1F* gem_lx_even[5]={nullptr}; + TH1F* gem_ly_even[5]={nullptr}; + TH1F* gem_lx_odd[5]={nullptr}; + TH1F* gem_ly_odd[5]={nullptr}; + if ( dbe_->get("MuonGEMHitsV/GEMHitsTask/track_eta")!=nullptr ) { + track_eta[0] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_eta")->getTH1F()->Clone(); + track_eta[1] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_eta_l1")->getTH1F()->Clone(); + track_eta[2] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_eta_l2")->getTH1F()->Clone(); + track_eta[3] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_eta_l1or2")->getTH1F()->Clone(); + track_eta[4] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_eta_l1and2")->getTH1F()->Clone(); + } + if ( dbe_->get("MuonGEMHitsV/GEMHitsTask/track_phi")!=nullptr ) { + track_phi[0] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_phi")->getTH1F()->Clone(); + track_phi[1] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_phi_l1")->getTH1F()->Clone(); + track_phi[2] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_phi_l2")->getTH1F()->Clone(); + track_phi[3] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_phi_l1or2")->getTH1F()->Clone(); + track_phi[4] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/track_phi_l1and2")->getTH1F()->Clone(); + } + + if ( dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_even")!=nullptr ) { + gem_lx_even[0] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_even")->getTH1F()->Clone(); + gem_lx_even[1] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_even_l1")->getTH1F()->Clone(); + gem_lx_even[2] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_even_l2")->getTH1F()->Clone(); + gem_lx_even[3] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_even_l1or2")->getTH1F()->Clone(); + gem_lx_even[4] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_even_l1and2")->getTH1F()->Clone(); + } + if ( dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_even")!=nullptr ) { + gem_ly_even[0] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_even")->getTH1F()->Clone(); + gem_ly_even[1] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_even_l1")->getTH1F()->Clone(); + gem_ly_even[2] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_even_l2")->getTH1F()->Clone(); + gem_ly_even[3] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_even_l1or2")->getTH1F()->Clone(); + gem_ly_even[4] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_even_l1and2")->getTH1F()->Clone(); + } + if ( dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_odd")!=nullptr ) { + gem_lx_odd[0] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_odd")->getTH1F()->Clone(); + gem_lx_odd[1] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_odd_l1")->getTH1F()->Clone(); + gem_lx_odd[2] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_odd_l2")->getTH1F()->Clone(); + gem_lx_odd[3] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_odd_l1or2")->getTH1F()->Clone(); + gem_lx_odd[4] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_lx_odd_l1and2")->getTH1F()->Clone(); + } + if ( dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_odd")!=nullptr ) { + gem_ly_odd[0] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_odd")->getTH1F()->Clone(); + gem_ly_odd[1] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_odd_l1")->getTH1F()->Clone(); + gem_ly_odd[2] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_odd_l2")->getTH1F()->Clone(); + gem_ly_odd[3] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_odd_l1or2")->getTH1F()->Clone(); + gem_ly_odd[4] = (TH1F*)dbe_->get("MuonGEMHitsV/GEMHitsTask/gem_ly_odd_l1and2")->getTH1F()->Clone(); + } + if( track_eta[0] !=nullptr ) { + for ( int i= 0; i<5 ; i++) { + track_eta[i]->Sumw2(); + track_phi[i]->Sumw2(); + gem_lx_even[i]->Sumw2(); + gem_ly_even[i]->Sumw2(); + gem_lx_odd[i]->Sumw2(); + gem_ly_odd[i]->Sumw2(); + } + for ( int i= 1; i<5 ; i++) { + track_eta[i]->Divide( track_eta[0]); + track_phi[i]->Divide( track_phi[0]); + gem_lx_even[i]->Divide( gem_lx_even[0]); + gem_ly_even[i]->Divide( gem_ly_even[0]); + gem_lx_odd[i]->Divide( gem_lx_odd[0]); + gem_ly_odd[i]->Divide( gem_ly_odd[0]); + + dbe_->book1D( TString::Format("%s%s","eff_",track_eta[i]->GetName()),track_eta[i]); + dbe_->book1D( TString::Format("%s%s","eff_",track_phi[i]->GetName()),track_phi[i]); + dbe_->book1D( TString::Format("%s%s","eff_",gem_lx_even[i]->GetName()),gem_lx_even[i]); + dbe_->book1D( TString::Format("%s%s","eff_",gem_ly_even[i]->GetName()),gem_ly_even[i]); + dbe_->book1D( TString::Format("%s%s","eff_",gem_lx_odd[i]->GetName()),gem_lx_odd[i]); + dbe_->book1D( TString::Format("%s%s","eff_",gem_ly_odd[i]->GetName()),gem_ly_odd[i]); + } + } + if ( outputFile_.size() != 0 && dbe_ ) dbe_->save(outputFile_); +} + +// ------------ method fills 'descriptions' with the allowed parameters for the module ------------ +void +MuonGEMHits_Harvesting::fillDescriptions(edm::ConfigurationDescriptions& descriptions) { + //The following says we do not know what parameters are allowed so do no validation + // Please change this to state exactly what you do use, even if it is no parameters + edm::ParameterSetDescription desc; + desc.setUnknown(); + descriptions.addDefault(desc); +} + +//define this as a plug-in +DEFINE_FWK_MODULE(MuonGEMHits_Harvesting); diff --git a/Validation/MuonGEMHits/python/MuonGEMHits_cfi.py b/Validation/MuonGEMHits/python/MuonGEMHits_cfi.py new file mode 100644 index 0000000000000..e8776e5d2781a --- /dev/null +++ b/Validation/MuonGEMHits/python/MuonGEMHits_cfi.py @@ -0,0 +1,15 @@ +import FWCore.ParameterSet.Config as cms + + + +from Validation.MuonGEMHits.simTrackMatching_cfi import SimTrackMatching +from Validation.MuonGEMHits.gemSystemSetting_cfi import gemSetting +gemHitsValidation = cms.EDAnalyzer('MuonGEMHits', + outputFile = cms.string(''), + simInputLabel = cms.untracked.string('g4SimHits'), + minPt = cms.untracked.double(4.5), + ntupleTrackChamberDelta = cms.untracked.bool(True), + ntupleTrackEff = cms.untracked.bool(True), + simTrackMatching = SimTrackMatching, + gemSystemSetting = gemSetting +) diff --git a/Validation/MuonGEMHits/python/PostProcessor_cff.py b/Validation/MuonGEMHits/python/PostProcessor_cff.py new file mode 100644 index 0000000000000..49ee6627d2ea0 --- /dev/null +++ b/Validation/MuonGEMHits/python/PostProcessor_cff.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + + + +gemHitHarvesting = cms.EDAnalyzer("MuonGEMHits_Harvesting") +MuonGEMHitsPostProcessors = cms.Sequence( gemHitHarvesting ) + diff --git a/Validation/MuonGEMHits/python/gemSystemSetting_cfi.py b/Validation/MuonGEMHits/python/gemSystemSetting_cfi.py new file mode 100644 index 0000000000000..797bd48dfb551 --- /dev/null +++ b/Validation/MuonGEMHits/python/gemSystemSetting_cfi.py @@ -0,0 +1,7 @@ +import FWCore.ParameterSet.Config as cms + +gemSetting = cms.PSet( + gemNPart = cms.untracked.int32(8), + gemNRegion = cms.untracked.int32(2), + gemNLayer = cms.untracked.int32(2) +) diff --git a/Validation/MuonGEMHits/python/simTrackMatching_cfi.py b/Validation/MuonGEMHits/python/simTrackMatching_cfi.py new file mode 100644 index 0000000000000..4c74ef1aacaf1 --- /dev/null +++ b/Validation/MuonGEMHits/python/simTrackMatching_cfi.py @@ -0,0 +1,45 @@ +import FWCore.ParameterSet.Config as cms + +SimTrackMatching = cms.PSet( + # common + useCSCChamberTypes = cms.untracked.vint32( 2, ), # by default, only use simhits from ME1/b (CSC type == 2) + # SimHit matching: + verboseSimHit = cms.untracked.int32(0), + simMuOnlyCSC = cms.untracked.bool(True), + simMuOnlyGEM = cms.untracked.bool(True), + discardEleHitsCSC = cms.untracked.bool(True), + discardEleHitsGEM = cms.untracked.bool(True), + simInputLabel = cms.untracked.string('g4SimHits'), + # GEM digi matching: + verboseGEMDigi = cms.untracked.int32(0), + gemDigiInput = cms.untracked.InputTag("simMuonGEMDigis"), + gemPadDigiInput = cms.untracked.InputTag("simMuonGEMCSCPadDigis"), + gemCoPadDigiInput = cms.untracked.InputTag("simMuonGEMCSCPadDigis", "Coincidence"), + minBXGEM = cms.untracked.int32(-1), + maxBXGEM = cms.untracked.int32(1), + matchDeltaStripGEM = cms.untracked.int32(1), + gemDigiMinEta = cms.untracked.double(1.55), + gemDigiMaxEta = cms.untracked.double(2.18), + gemDigiMinPt = cms.untracked.double(5.0), + # CSC digi matching: + verboseCSCDigi = cms.untracked.int32(0), + cscComparatorDigiInput = cms.untracked.InputTag("simMuonCSCDigis", "MuonCSCComparatorDigi"), + cscWireDigiInput = cms.untracked.InputTag("simMuonCSCDigis", "MuonCSCWireDigi"), + minBXCSCComp = cms.untracked.int32(3), + maxBXCSCComp = cms.untracked.int32(9), + minBXCSCWire = cms.untracked.int32(3), + maxBXCSCWire = cms.untracked.int32(8), + matchDeltaStripCSC = cms.untracked.int32(1), + matchDeltaWireGroupCSC = cms.untracked.int32(1), + # CSC trigger stubs + verboseCSCStub = cms.untracked.int32(0), + cscCLCTInput = cms.untracked.InputTag("simCscTriggerPrimitiveDigis"), + cscALCTInput = cms.untracked.InputTag("simCscTriggerPrimitiveDigis"), + cscLCTInput = cms.untracked.InputTag("simCscTriggerPrimitiveDigis"), + minBXCLCT = cms.untracked.int32(3), + maxBXCLCT = cms.untracked.int32(9), + minBXALCT = cms.untracked.int32(3), + maxBXALCT = cms.untracked.int32(8), + minBXLCT = cms.untracked.int32(3), + maxBXLCT = cms.untracked.int32(8) +) diff --git a/Validation/MuonGEMHits/src/BaseMatcher.cc b/Validation/MuonGEMHits/src/BaseMatcher.cc new file mode 100644 index 0000000000000..c3fb5c66bcb10 --- /dev/null +++ b/Validation/MuonGEMHits/src/BaseMatcher.cc @@ -0,0 +1,75 @@ +#include "Validation/MuonGEMDigis/interface/BaseMatcher.h" + +#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h" +#include "TrackingTools/Records/interface/TrackingComponentsRecord.h" +#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h" +#include "DataFormats/GeometrySurface/interface/Plane.h" + + +BaseMatcher::BaseMatcher(const SimTrack& t, const SimVertex& v, + const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es) +: trk_(t), vtx_(v), conf_(ps), ev_(ev), es_(es), verbose_(0) +{ + // list of CSC chamber type numbers to use + std::vector csc_types = conf().getUntrackedParameter >("useCSCChamberTypes", std::vector() ); + for (int i=0; i <= CSC_ME42; ++i) useCSCChamberTypes_[i] = false; + for (auto t: csc_types) + { + if (t >= 0 && t <= CSC_ME42) useCSCChamberTypes_[t] = 1; + } + // empty list means use all the chamber types + if (csc_types.empty()) useCSCChamberTypes_[CSC_ALL] = 1; + + // Get the magnetic field + es.get< IdealMagneticFieldRecord >().get(magfield_); + + // Get the propagators + es.get< TrackingComponentsRecord >().get("SteppingHelixPropagatorAlong", propagator_); + es.get< TrackingComponentsRecord >().get("SteppingHelixPropagatorOpposite", propagatorOpposite_); +} + + +BaseMatcher::~BaseMatcher() +{ +} + + +bool BaseMatcher::useCSCChamberType(int csc_type) +{ + if (csc_type < 0 || csc_type > CSC_ME42) return false; + return useCSCChamberTypes_[csc_type]; +} + + +GlobalPoint +BaseMatcher::propagateToZ(GlobalPoint &inner_point, GlobalVector &inner_vec, float z) const +{ + Plane::PositionType pos(0.f, 0.f, z); + Plane::RotationType rot; + Plane::PlanePointer my_plane(Plane::build(pos, rot)); + + FreeTrajectoryState state_start(inner_point, inner_vec, trk_.charge(), &*magfield_); + + TrajectoryStateOnSurface tsos(propagator_->propagate(state_start, *my_plane)); + if (!tsos.isValid()) tsos = propagatorOpposite_->propagate(state_start, *my_plane); + + if (tsos.isValid()) return tsos.globalPosition(); + return GlobalPoint(); +} + + +GlobalPoint +BaseMatcher::propagateToZ(float z) const +{ + GlobalPoint inner_point(vtx_.position().x(), vtx_.position().y(), vtx_.position().z()); + GlobalVector inner_vec (trk_.momentum().x(), trk_.momentum().y(), trk_.momentum().z()); + return propagateToZ(inner_point, inner_vec, z); +} + +GlobalPoint +BaseMatcher::propagatedPositionGEM() const +{ + const double eta(trk().momentum().eta()); + const int endcap( (eta > 0.) ? 1 : -1); + return propagateToZ(endcap*AVERAGE_GEM_Z); +} diff --git a/Validation/MuonGEMHits/src/GEMBaseValidation.cc b/Validation/MuonGEMHits/src/GEMBaseValidation.cc new file mode 100644 index 0000000000000..48cec5524bc2e --- /dev/null +++ b/Validation/MuonGEMHits/src/GEMBaseValidation.cc @@ -0,0 +1,24 @@ +#include "Validation/MuonGEMDigis/interface/GEMBaseValidation.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/GEMDigi/interface/GEMDigiCollection.h" +#include "DQMServices/Core/interface/DQMStore.h" + + +GEMBaseValidation::GEMBaseValidation(DQMStore* dbe, + const edm::InputTag & inputTag) +{ + dbe_ = dbe; + theInputTag = inputTag; + +} + + +GEMBaseValidation::~GEMBaseValidation() { + + +} + + + + diff --git a/Validation/MuonGEMHits/src/GEMHitsValidation.cc b/Validation/MuonGEMHits/src/GEMHitsValidation.cc new file mode 100644 index 0000000000000..2a224733fa2af --- /dev/null +++ b/Validation/MuonGEMHits/src/GEMHitsValidation.cc @@ -0,0 +1,164 @@ +#include "Validation/MuonGEMHits/interface/GEMHitsValidation.h" +#include "DataFormats/Common/interface/Handle.h" +#include "FWCore/MessageLogger/interface/MessageLogger.h" +#include "DataFormats/GEMDigi/interface/GEMDigiCollection.h" +#include "DQMServices/Core/interface/DQMStore.h" +#include + +GEMHitsValidation::GEMHitsValidation(DQMStore* dbe, const edm::InputTag & inputTag, const edm::ParameterSet& cfg) +: GEMBaseValidation(dbe, inputTag) +{ + npart = cfg.getUntrackedParameter("gemNPart",8); + nlayer = cfg.getUntrackedParameter("gemNLayer",2); + nregion = cfg.getUntrackedParameter("gemNRegion",2); + + + std::string has_muon[3]= { "_Muon","_noMuon","_All"} ; + + for( int i=0 ; i <3 ; i++) { + gem_sh_xy_rm1_l1[i] = dbe_->book2D("gem_sh_xy_rm1_l1"+has_muon[i], "SimHit occupancy : region -1, layer1;globalX [cm]; globalY[cm]", 100,-260,260,100,-260,260); + gem_sh_xy_rm1_l2[i] = dbe_->book2D("gem_sh_xy_rm1_l2"+has_muon[i], "SimHit occupancy : region -1, layer2;globalX [cm]; globalY[cm]", 100,-260,260,100,-260,260); + gem_sh_xy_rp1_l1[i] = dbe_->book2D("gem_sh_xy_rp1_l1"+has_muon[i], "SimHit occupancy : region 1, layer1;globalX [cm]; globalY[cm]", 100,-260,260,100,-260,260); + gem_sh_xy_rp1_l2[i] = dbe_->book2D("gem_sh_xy_rp1_l2"+has_muon[i], "SimHit occupancy : region 1, layer2;globalX [cm]; globalY[cm]", 100,-260,260,100,-260,260); + + gem_sh_zr_rm1[i] = dbe_->book2D("gem_sh_zr_rm1"+has_muon[i], "SimHit occupancy: region-1; globalZ [cm] ; globalR [cm] ", 200,-573,-564,110,130,240); + gem_sh_zr_rp1[i] = dbe_->book2D("gem_sh_zr_rp1"+has_muon[i], "SimHit occupancy: region 1; globalZ [cm] ; globalR [cm] ", 200, 564, 573,110,130,240); + + gem_sh_tof_rm1_l1[i] = dbe_->book1D("gem_sh_tof_rm1_l1"+has_muon[i], "SimHit TOF : region-1, layer 1 ; Time of flight [ns] ; entries", 40,18,22); + gem_sh_tof_rm1_l2[i] = dbe_->book1D("gem_sh_tof_rm1_l2"+has_muon[i], "SimHit TOF : region-1, layer 2 ; Time of flight [ns] ; entries", 40,18,22); + gem_sh_tof_rp1_l1[i] = dbe_->book1D("gem_sh_tof_rp1_l1"+has_muon[i], "SimHit TOF : region 1, layer 1 ; Time of flight [ns] ; entries", 40,18,22); + gem_sh_tof_rp1_l2[i] = dbe_->book1D("gem_sh_tof_rp1_l2"+has_muon[i], "SimHit TOF : region 1, layer 2 ; Time of flight [ns] ; entries", 40,18,22); + + gem_sh_pabs[i] = dbe_->book1D("gem_sh_pabs"+has_muon[i], "SimHit absolute momentum; Momentum [GeV/c]; entries", 200,0.,200.); + + gem_sh_pdgid[i] = dbe_->book1D("gem_sh_pdgid"+has_muon[i], "SimHit PDG ID ; PDG ID ; entries", 200,-100.,100.); + + gem_sh_global_eta[i] = dbe_->book1D("gem_sh_global_eta"+has_muon[i],"SimHit occupancy in eta partitions; occupancy in #eta partition; entries",4*npart,1.,1+4*npart); + + gem_sh_energyloss[i] = dbe_->book1D("gem_sh_energyloss"+has_muon[i],"SimHit energy loss;Energy loss [eV];entries",60,0.,6000.); + + } +} + + +GEMHitsValidation::~GEMHitsValidation() { +} + + +void GEMHitsValidation::analyze(const edm::Event& e, + const edm::EventSetup&) +{ + + edm::Handle GEMHits; + e.getByLabel(theInputTag, GEMHits); + if (!GEMHits.isValid()) { + edm::LogError("GEMHitsValidation") << "Cannot get GEMHits by label " + << theInputTag.encode(); + } + + //Int_t eventNumber = e.id().event(); + for (auto hits=GEMHits->begin(); hits!=GEMHits->end(); hits++) { + Int_t particleType = hits->particleType(); + //Float_t lx = hits->localPosition().x(); + //Float_t ly = hits->localPosition().y(); + Float_t energyLoss = hits->energyLoss(); + Float_t pabs = hits->pabs(); + Float_t timeOfFlight = hits->timeOfFlight(); + + const GEMDetId id(hits->detUnitId()); + + Int_t region = id.region(); + //Int_t ring = id.ring(); + //Int_t station = id.station(); + Int_t layer = id.layer(); + //Int_t chamber = id.chamber(); + Int_t roll = id.roll(); + + const LocalPoint p0(0., 0., 0.); + const GlobalPoint Gp0(theGEMGeometry->idToDet(hits->detUnitId())->surface().toGlobal(p0)); + + //Float_t Phi_0 = Gp0.phi(); + //Float_t R_0 = Gp0.perp(); + //Float_t DeltaPhi = atan(-1*id.region()*pow(-1,id.chamber())*hits->localPosition().x()/(Gp0.perp() + hits->localPosition().y())); + + const LocalPoint hitLP(hits->localPosition()); + const GlobalPoint hitGP(theGEMGeometry->idToDet(hits->detUnitId())->surface().toGlobal(hitLP)); + Float_t g_r = hitGP.perp(); + //Float_t g_eta = hitGP.eta(); + //Float_t g_phi = hitGP.phi(); + Float_t g_x = hitGP.x(); + Float_t g_y = hitGP.y(); + Float_t g_z = hitGP.z(); + + const LocalPoint hitEP(hits->entryPoint()); + //Int_t strip = theGEMGeometry->etaPartition(hits->detUnitId())->strip(hitEP); + + // fill hist + int muonSel=999; + int all = 2 ; + if ( TMath::Abs(particleType)== 13 ) { muonSel = 0 ; } + else { muonSel=1; } + // First, fill variable has no condition. + gem_sh_pabs[all]->Fill(pabs); + gem_sh_pdgid[all]->Fill(particleType); + gem_sh_energyloss[all]->Fill( energyLoss*1.e9); + + gem_sh_pabs[muonSel]->Fill(pabs); + gem_sh_pdgid[muonSel]->Fill(particleType); + gem_sh_energyloss[muonSel]->Fill( energyLoss*1.e9); + + if ( region== -1 ) { + gem_sh_zr_rm1[all]->Fill(g_z,g_r); + gem_sh_zr_rm1[muonSel]->Fill(g_z,g_r); + if ( layer == 1 ) { + gem_sh_xy_rm1_l1[all]->Fill(g_x,g_y); + gem_sh_tof_rm1_l1[all]->Fill(timeOfFlight); + gem_sh_global_eta[all]->Fill( roll+ 0 + 0); // roll + layer + region + + gem_sh_xy_rm1_l1[muonSel]->Fill(g_x,g_y); + gem_sh_tof_rm1_l1[muonSel]->Fill(timeOfFlight); + gem_sh_global_eta[muonSel]->Fill( roll+ 0 + 0); // roll + layer + region + } + else if ( layer ==2 ) { + gem_sh_xy_rm1_l2[all]->Fill(g_x,g_y); + gem_sh_tof_rm1_l2[all]->Fill(timeOfFlight); + gem_sh_global_eta[all]->Fill( roll+ npart + 0); + + gem_sh_xy_rm1_l2[muonSel]->Fill(g_x,g_y); + gem_sh_tof_rm1_l2[muonSel]->Fill(timeOfFlight); + gem_sh_global_eta[muonSel]->Fill( roll+ npart + 0); + } + else { + //std::cout<<"layer : "<Fill(g_z,g_r); + gem_sh_zr_rp1[muonSel]->Fill(g_z,g_r); + if ( layer == 1 ) { + gem_sh_xy_rp1_l1[all]->Fill(g_x,g_y); + gem_sh_tof_rp1_l1[all]->Fill(timeOfFlight); + gem_sh_global_eta[all]->Fill( roll+ 0 + 2*npart ); + + gem_sh_xy_rp1_l1[muonSel]->Fill(g_x,g_y); + gem_sh_tof_rp1_l1[muonSel]->Fill(timeOfFlight); + gem_sh_global_eta[muonSel]->Fill( roll+ 0 + 2*npart ); + } + else if ( layer == 2 ) { + gem_sh_xy_rp1_l2[all]->Fill(g_x,g_y); + gem_sh_tof_rp1_l2[all]->Fill(timeOfFlight); + gem_sh_global_eta[all]->Fill( roll+ npart + 2*npart ); + + gem_sh_xy_rp1_l2[muonSel]->Fill(g_x,g_y); + gem_sh_tof_rp1_l2[muonSel]->Fill(timeOfFlight); + gem_sh_global_eta[muonSel]->Fill( roll+ npart + 2*npart ); + } + else { + //std::cout<<"layer : "< +#include + + + + + + +GEMSimTrackMatch::GEMSimTrackMatch(DQMStore* dbe, std::string simInputLabel , edm::ParameterSet cfg) +{ + const float PI=TMath::Pi(); + cfg_= cfg; + simInputLabel_= simInputLabel; + dbe_= dbe; + minPt_ = cfg_.getUntrackedParameter("gemMinPt",5.0); + minEta_ = cfg_.getUntrackedParameter("gemMinEta",1.55); + maxEta_ = cfg_.getUntrackedParameter("gemMaxEta",2.18); + buildLUT(); + + track_eta = dbe_->book1D("track_eta", "track_eta;SimTrack |#eta|;# of tracks", 140,1.5,2.2); + track_eta_l1 = dbe_->book1D("track_eta_l1","track_eta_l1",140,1.5,2.2); + track_eta_l2 = dbe_->book1D("track_eta_l2","track_eta_l2",140,1.5,2.2); + track_eta_l1or2 = dbe_->book1D("track_eta_l1or2","track_eta_l1or2",140,1.5,2.2); + track_eta_l1and2 = dbe_->book1D("track_eta_l1and2","track_eta_l1and2",140,1.5,2.2); + + + track_phi = dbe_->book1D("track_phi", "track_phi;SimTrack |#eta|;# of tracks", 100,-PI,PI); + track_phi_l1 = dbe_->book1D("track_phi_l1","track_phi_l1",100,-PI,PI); + track_phi_l2 = dbe_->book1D("track_phi_l2","track_phi_l2",100,-PI,PI); + track_phi_l1or2 = dbe_->book1D("track_phi_l1or2","track_phi_l1or2",100,-PI,PI); + track_phi_l1and2 = dbe_->book1D("track_phi_l1and2","track_phi_l1and2",100,-PI,PI); + + gem_lx_even = dbe_->book1D("gem_lx_even","gem_lx_even",100,-100,100); + gem_lx_even_l1 = dbe_->book1D("gem_lx_even_l1","gem_lx_even_l1",100,-100,100); + gem_lx_even_l2 = dbe_->book1D("gem_lx_even_l2","gem_lx_even_l2",100,-100,100); + gem_lx_even_l1or2 = dbe_->book1D("gem_lx_even_l1or2","gem_lx_even_l1or2",100,-100,100); + gem_lx_even_l1and2 = dbe_->book1D("gem_lx_even_l1and2","gem_lx_even_l1and2",100,-100,100); + + gem_ly_even = dbe_->book1D("gem_ly_even","gem_ly_even",100,-100,100); + gem_ly_even_l1 = dbe_->book1D("gem_ly_even_l1","gem_ly_even_l1",100,-100,100); + gem_ly_even_l2 = dbe_->book1D("gem_ly_even_l2","gem_ly_even_l2",100,-100,100); + gem_ly_even_l1or2 = dbe_->book1D("gem_ly_even_l1or2","gem_ly_even_l1or2",100,-100,100); + gem_ly_even_l1and2 = dbe_->book1D("gem_ly_even_l1and2","gem_ly_even_l1and2",100,-100,100); + + gem_lx_odd = dbe_->book1D("gem_lx_odd","gem_lx_odd",100,-100,100); + gem_lx_odd_l1 = dbe_->book1D("gem_lx_odd_l1","gem_lx_odd_l1",100,-100,100); + gem_lx_odd_l2 = dbe_->book1D("gem_lx_odd_l2","gem_lx_odd_l2",100,-100,100); + gem_lx_odd_l1or2 = dbe_->book1D("gem_lx_odd_l1or2","gem_lx_odd_l1or2",100,-100,100); + gem_lx_odd_l1and2 = dbe_->book1D("gem_lx_odd_l1and2","gem_lx_odd_l1and2",100,-100,100); + + gem_ly_odd = dbe_->book1D("gem_ly_odd","gem_ly_odd",100,-100,100); + gem_ly_odd_l1 = dbe_->book1D("gem_ly_odd_l1","gem_ly_odd_l1",100,-100,100); + gem_ly_odd_l2 = dbe_->book1D("gem_ly_odd_l2","gem_ly_odd_l2",100,-100,100); + gem_ly_odd_l1or2 = dbe_->book1D("gem_ly_odd_l1or2","gem_ly_odd_l1or2",100,-100,100); + gem_ly_odd_l1and2 = dbe_->book1D("gem_ly_odd_l1and2","gem_ly_odd_l1and2",100,-100,100); +} + + + + + +GEMSimTrackMatch::~GEMSimTrackMatch() { +} + +bool GEMSimTrackMatch::isSimTrackGood(const SimTrack &t) +{ + // SimTrack selection + if (t.noVertex()) return false; + if (t.noGenpart()) return false; + if (std::abs(t.type()) != 13) return false; // only interested in direct muon simtracks + if (t.momentum().pt() < minPt_ ) return false; + const float eta(std::abs(t.momentum().eta())); + if (eta > maxEta_ || eta < minEta_ ) return false; // no GEMs could be in such eta + return true; +} + + +void GEMSimTrackMatch::buildLUT() +{ + const int maxChamberId_ = GEMDetId().maxChamberId; + std::vector pos_ids; + pos_ids.push_back(GEMDetId(1,1,1,1,maxChamberId_,1).rawId()); + + std::vector neg_ids; + neg_ids.push_back(GEMDetId(-1,1,1,1,maxChamberId_,1).rawId()); + + // VK: I would really suggest getting phis from GEMGeometry + + std::vector phis; + phis.push_back(0.); + for(int i=1; i(theGEMGeometry->idToDetUnit(GEMDetId(1,1,1,1,1,1))); + const int nEtaPartitions(theGEMGeometry->chamber(GEMDetId(1,1,1,1,1,1))->nEtaPartitions()); + const auto bottom_chamber = static_cast(theGEMGeometry->idToDetUnit(GEMDetId(1,1,1,1,1,nEtaPartitions))); + const float top_half_striplength = top_chamber->specs()->specificTopology().stripLength()/2.; + const float bottom_half_striplength = bottom_chamber->specs()->specificTopology().stripLength()/2.; + const LocalPoint lp_top(0., top_half_striplength, 0.); + const LocalPoint lp_bottom(0., -bottom_half_striplength, 0.); + const GlobalPoint gp_top = top_chamber->toGlobal(lp_top); + const GlobalPoint gp_bottom = bottom_chamber->toGlobal(lp_bottom); + + radiusCenter_ = (gp_bottom.perp() + gp_top.perp())/2.; + chamberHeight_ = gp_top.perp() - gp_bottom.perp(); + +} + + +std::pair GEMSimTrackMatch::getClosestChambers(int region, float phi) +{ + const int maxChamberId_ = GEMDetId().maxChamberId; + auto& phis(positiveLUT_.first); + auto upper = std::upper_bound(phis.begin(), phis.end(), phi); + auto& LUT = (region == 1 ? positiveLUT_.second : negativeLUT_.second); + return std::make_pair(LUT.at(upper - phis.begin()), (LUT.at((upper - phis.begin() + 1)%maxChamberId_))); +} + + +void GEMSimTrackMatch::analyze(const edm::Event& iEvent, const edm::EventSetup& iSetup) +{ + struct MySimTrack + { + Float_t pt, eta, phi; + Char_t endcap; + Char_t gem_sh_layer1, gem_sh_layer2; + Float_t gem_sh_eta, gem_sh_phi; + Float_t gem_trk_eta, gem_trk_phi; + Float_t gem_lx_even, gem_ly_even; + Float_t gem_lx_odd, gem_ly_odd; + Char_t has_gem_sh_l1, has_gem_sh_l2; + }; + MySimTrack track_; + + iEvent.getByLabel(simInputLabel_, sim_tracks); + iEvent.getByLabel(simInputLabel_, sim_vertices); + + const edm::SimVertexContainer & sim_vert = *sim_vertices.product(); + const edm::SimTrackContainer & sim_trks = *sim_tracks.product(); + + for (auto& t: sim_trks) + { + if (!isSimTrackGood(t)) + { continue; } + + // match hits to this SimTrack + SimTrackMatchManager match(t, sim_vert[t.vertIndex()], cfg_, iEvent, iSetup); + const SimHitMatcher& match_sh = match.simhits(); + + track_.pt = t.momentum().pt(); + track_.phi = t.momentum().phi(); + track_.eta = t.momentum().eta(); + track_.gem_sh_layer1 = 0; + track_.gem_sh_layer2 = 0; + track_.gem_sh_eta = -9.; + track_.gem_sh_phi = -9.; + track_.gem_trk_eta = -999.; + track_.gem_trk_phi = -999.; + track_.gem_lx_even =0; + track_.gem_ly_even =0; + track_.gem_lx_odd =0; + track_.gem_ly_odd =0; + track_.has_gem_sh_l1 = 0; + track_.has_gem_sh_l2 = 0; + + + // check for hit chambers + const auto gem_sh_ids_ch = match_sh.chamberIdsGEM(); + for(auto d: gem_sh_ids_ch) + { + const GEMDetId id(d); + const bool odd(id.chamber() & 1); + + if (id.layer() == 1) + { + if (odd) track_.gem_sh_layer1 |= 1; + else track_.gem_sh_layer1 |= 2; + } + else if (id.layer() == 2) + { + if (odd) track_.gem_sh_layer2 |= 1; + else track_.gem_sh_layer2 |= 2; + } + } + + track_eta->Fill( fabs( track_.eta) ); + if ( track_.gem_sh_layer1 > 0 ) { + track_eta_l1->Fill ( fabs(track_.eta)); + } + if ( track_.gem_sh_layer2 > 0 ) { + track_eta_l2->Fill( fabs(track_.eta)); + } + if (track_.gem_sh_layer1 >0 || track_.gem_sh_layer2>0 ) { + track_eta_l1or2->Fill( fabs(track_.eta)); + } + if (track_.gem_sh_layer1 >0 && track_.gem_sh_layer2>0 ) { + track_eta_l1and2->Fill( fabs(track_.eta)); + } + if ( track_.gem_sh_layer1 ==0 && track_.gem_sh_layer2==0) { + edm::LogInfo("GEMSIM")<<"it has no layer on sh hit!"; + } + + // phi efficiency. + if( fabs(track_.eta) < 2.12 && fabs( track_.eta) > 1.64 ) { + track_phi->Fill( track_.phi ); + if ( track_.gem_sh_layer1 > 0 ) { + track_phi_l1->Fill ( track_.phi); + } + if ( track_.gem_sh_layer2 > 0 ) { + track_phi_l2->Fill( track_.phi); + } + if (track_.gem_sh_layer1 >0 || track_.gem_sh_layer2>0 ) { + track_phi_l1or2->Fill( track_.phi); + } + if (track_.gem_sh_layer1 >0 && track_.gem_sh_layer2>0 ) { + track_phi_l1and2->Fill( track_.phi); + } + + } + + + // Calculation of the localXY efficiency + GlobalPoint gp_track(match_sh.propagatedPositionGEM()); + track_.gem_trk_eta = gp_track.eta(); + float track_angle = gp_track.phi().degrees(); + if (track_angle < 0.) track_angle += 360.; + const int track_region = (gp_track.z() > 0 ? 1 : -1); + // closest chambers in phi + const auto mypair = getClosestChambers(track_region, track_angle); + + GEMDetId detId_first(mypair.first); + GEMDetId detId_second(mypair.second); + + // assignment of local even and odd chambers (there is always an even and an odd chamber) + bool firstIsOdd = detId_first.chamber() & 1; + + GEMDetId detId_even_L1(firstIsOdd ? detId_second : detId_first); + GEMDetId detId_odd_L1(firstIsOdd ? detId_first : detId_second); + + auto even_partition = theGEMGeometry->idToDetUnit(detId_even_L1)->surface(); + auto odd_partition = theGEMGeometry->idToDetUnit(detId_odd_L1)->surface(); + + LocalPoint p0(0.,0.,0.); + GlobalPoint gp_even_partition = even_partition.toGlobal(p0); + GlobalPoint gp_odd_partition = odd_partition.toGlobal(p0); + + LocalPoint lp_track_even_partition = even_partition.toLocal(gp_track); + LocalPoint lp_track_odd_partition = odd_partition.toLocal(gp_track); + + // track chamber local x is the same as track partition local x + track_.gem_lx_even = lp_track_even_partition.x(); + track_.gem_lx_odd = lp_track_odd_partition.x(); + + // track chamber local y is the same as track partition local y + // corrected for partition's local y WRT chamber + track_.gem_ly_even = lp_track_even_partition.y() + (gp_even_partition.perp() - radiusCenter_); + track_.gem_ly_odd = lp_track_odd_partition.y() + (gp_odd_partition.perp() - radiusCenter_); + + GEMDetId id_ch_even_L1(detId_even_L1.region(), detId_even_L1.ring(), detId_even_L1.station(), 1, detId_even_L1.chamber(), 0); + GEMDetId id_ch_odd_L1(detId_odd_L1.region(), detId_odd_L1.ring(), detId_odd_L1.station(), 1, detId_odd_L1.chamber(), 0); + GEMDetId id_ch_even_L2(detId_even_L1.region(), detId_even_L1.ring(), detId_even_L1.station(), 2, detId_even_L1.chamber(), 0); + GEMDetId id_ch_odd_L2(detId_odd_L1.region(), detId_odd_L1.ring(), detId_odd_L1.station(), 2, detId_odd_L1.chamber(), 0); + + if(gem_sh_ids_ch.count(id_ch_even_L1)!=0) track_.has_gem_sh_l1 |= 2; + if(gem_sh_ids_ch.count(id_ch_odd_L1)!=0) track_.has_gem_sh_l1 |= 1; + if(gem_sh_ids_ch.count(id_ch_even_L2)!=0) track_.has_gem_sh_l2 |= 2; + if(gem_sh_ids_ch.count(id_ch_odd_L2)!=0) track_.has_gem_sh_l2 |= 1; + + gem_lx_even->Fill( track_.gem_lx_even); + gem_lx_odd->Fill( track_.gem_lx_odd); + gem_ly_even->Fill( track_.gem_ly_even); + gem_ly_odd->Fill( track_.gem_ly_odd); + + if ( track_.has_gem_sh_l1 > 0 ) { + gem_lx_even_l1->Fill ( track_.gem_lx_even); + gem_ly_even_l1->Fill ( track_.gem_ly_even); + gem_lx_odd_l1->Fill ( track_.gem_lx_odd); + gem_ly_odd_l1->Fill ( track_.gem_ly_odd); + } + if ( track_.has_gem_sh_l2 > 0 ) { + gem_lx_even_l2->Fill ( track_.gem_lx_even); + gem_ly_even_l2->Fill ( track_.gem_ly_even); + gem_lx_odd_l2->Fill ( track_.gem_lx_odd); + gem_ly_odd_l2->Fill ( track_.gem_ly_odd); + } + if ( track_.has_gem_sh_l1 > 0 || track_.has_gem_sh_l2 > 0 ) { + gem_lx_even_l1or2->Fill ( track_.gem_lx_even); + gem_ly_even_l1or2->Fill ( track_.gem_ly_even); + gem_lx_odd_l1or2->Fill ( track_.gem_lx_odd); + gem_ly_odd_l1or2->Fill ( track_.gem_ly_odd); + } + if ( track_.has_gem_sh_l1 > 0 && track_.has_gem_sh_l2 > 0 ) { + gem_lx_even_l1and2->Fill ( track_.gem_lx_even); + gem_ly_even_l1and2->Fill ( track_.gem_ly_even); + gem_lx_odd_l1and2->Fill ( track_.gem_lx_odd); + gem_ly_odd_l1and2->Fill ( track_.gem_ly_odd); + } + } +} diff --git a/Validation/MuonGEMHits/src/SimHitMatcher.cc b/Validation/MuonGEMHits/src/SimHitMatcher.cc new file mode 100644 index 0000000000000..7b50c3d2825eb --- /dev/null +++ b/Validation/MuonGEMHits/src/SimHitMatcher.cc @@ -0,0 +1,602 @@ +#include "Validation/MuonGEMDigis/interface/SimHitMatcher.h" + +#include "FWCore/Framework/interface/ESHandle.h" + +#include "DataFormats/MuonDetId/interface/CSCDetId.h" +#include "DataFormats/MuonDetId/interface/GEMDetId.h" + +#include "Geometry/Records/interface/MuonGeometryRecord.h" +#include "Geometry/CSCGeometry/interface/CSCGeometry.h" +#include "Geometry/GEMGeometry/interface/GEMGeometry.h" + +#include +#include + +using namespace std; + +namespace { + +bool is_gem(unsigned int detid) +{ + DetId id(detid); + if (id.subdetId() == MuonSubdetId::GEM) return true; + return false; +} + +bool is_csc(unsigned int detid) +{ + DetId id(detid); + if (id.subdetId() == MuonSubdetId::CSC) return true; + return false; +} + +} + + +SimHitMatcher::SimHitMatcher(const SimTrack& t, const SimVertex& v, + const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es) +: BaseMatcher(t, v, ps, ev, es) +{ + simMuOnlyCSC_ = conf().getUntrackedParameter("simMuOnlyCSC", true); + simMuOnlyGEM_ = conf().getUntrackedParameter("simMuOnlyGEM", true); + discardEleHitsCSC_ = conf().getUntrackedParameter("discardEleHitsCSC", true); + discardEleHitsGEM_ = conf().getUntrackedParameter("discardEleHitsGEM", true); + simInputLabel_ = conf().getUntrackedParameter("simInputLabel", "g4SimHits"); + + setVerbose(conf().getUntrackedParameter("verboseSimHit", 0)); + + init(); +} + + +SimHitMatcher::~SimHitMatcher() {} + + +void SimHitMatcher::init() +{ + edm::ESHandle csc_g; + eventSetup().get().get(csc_g); + csc_geo_ = &*csc_g; + + edm::ESHandle gem_g; + eventSetup().get().get(gem_g); + gem_geo_ = &*gem_g; + + edm::Handle csc_hits; + edm::Handle gem_hits; + edm::Handle sim_tracks; + edm::Handle sim_vertices; + + event().getByLabel(simInputLabel_, sim_tracks); + event().getByLabel(simInputLabel_, sim_vertices); + event().getByLabel(edm::InputTag(simInputLabel_,"MuonCSCHits"), csc_hits); + event().getByLabel(edm::InputTag(simInputLabel_,"MuonGEMHits"), gem_hits); + + // fill trkId2Index associoation: + int no = 0; + trkid_to_index_.clear(); + for (auto& t: *sim_tracks.product()) + { + trkid_to_index_[t.trackId()] = no; + no++; + } + vector track_ids = getIdsOfSimTrackShower(trk().trackId(), *sim_tracks.product(), *sim_vertices.product()); + + // select CSC simhits + edm::PSimHitContainer csc_hits_select; + for (auto& h: *csc_hits.product()) + { + CSCDetId id(h.detUnitId()); + if ( useCSCChamberType(id.iChamberType()) ) csc_hits_select.push_back(h); + } + + matchSimHitsToSimTrack(track_ids, csc_hits_select, *gem_hits.product()); + + if (verbose()) + { + cout<<"sh tn ntids "<(cout, " ")); cout< +SimHitMatcher::getIdsOfSimTrackShower(unsigned int initial_trk_id, + const edm::SimTrackContainer & sim_tracks, const edm::SimVertexContainer & sim_vertices) +{ + vector result; + result.push_back(initial_trk_id); + + if (! (simMuOnlyGEM_ || simMuOnlyCSC_) ) return result; + + for (auto& t: sim_tracks) + { + SimTrack last_trk = t; + bool is_child = 0; + while (1) + { + if ( last_trk.noVertex() ) break; + if ( sim_vertices[last_trk.vertIndex()].noParent() ) break; + + unsigned parentId = sim_vertices[last_trk.vertIndex()].parentIndex(); + if ( parentId == initial_trk_id ) + { + is_child = 1; + break; + } + + auto association = trkid_to_index_.find( parentId ); + if ( association == trkid_to_index_.end() ) break; + + last_trk = sim_tracks[ association->second ]; + } + if (is_child) + { + result.push_back(t.trackId()); + } + } + return result; +} + + +void +SimHitMatcher::matchSimHitsToSimTrack(std::vector track_ids, + const edm::PSimHitContainer& csc_hits, const edm::PSimHitContainer& gem_hits) +{ + for (auto& track_id: track_ids) + { + for (auto& h: csc_hits) + { + if (h.trackId() != track_id) continue; + int pdgid = h.particleType(); + if (simMuOnlyCSC_ && std::abs(pdgid) != 13) continue; + if (discardEleHitsCSC_ && std::abs(pdgid) == 11) continue; + + csc_detid_to_hits_[ h.detUnitId() ].push_back(h); + csc_hits_.push_back(h); + CSCDetId layer_id( h.detUnitId() ); + csc_chamber_to_hits_[ layer_id.chamberId().rawId() ].push_back(h); + } + for (auto& h: gem_hits) + { + if (h.trackId() != track_id) continue; + int pdgid = h.particleType(); + if (simMuOnlyGEM_ && std::abs(pdgid) != 13) continue; + if (discardEleHitsGEM_ && std::abs(pdgid) == 11) continue; + + gem_detid_to_hits_[ h.detUnitId() ].push_back(h); + gem_hits_.push_back(h); + GEMDetId p_id( h.detUnitId() ); + gem_chamber_to_hits_[ p_id.chamberId().rawId() ].push_back(h); + GEMDetId superch_id(p_id.region(), p_id.ring(), p_id.station(), 1, p_id.chamber(), 0); + gem_superchamber_to_hits_[ superch_id() ].push_back(h); + } + } + + // find pads with hits + auto detids = detIdsGEM(); + // find 2-layer coincidence pads with hits + for (auto d: detids) + { + GEMDetId id(d); + auto hits = hitsInDetId(d); + auto roll = gem_geo_->etaPartition(id); + //int max_npads = roll->npads(); + set pads; + for (auto& h: hits) + { + LocalPoint lp = h.entryPoint(); + pads.insert( 1 + static_cast(roll->padTopology().channel(lp)) ); + } + gem_detids_to_pads_[d] = pads; + } + + // find 2-layer coincidence pads with hits + for (auto d: detids) + { + GEMDetId id1(d); + if (id1.layer() != 1) continue; + GEMDetId id2(id1.region(), id1.ring(), id1.station(), 2, id1.chamber(), id1.roll()); + // does layer 2 has simhits? + if (detids.find(id2()) == detids.end()) continue; + + // find pads with hits in layer1 + auto hits1 = hitsInDetId(d); + auto roll1 = gem_geo_->etaPartition(id1); + set pads1; + for (auto& h: hits1) + { + LocalPoint lp = h.entryPoint(); + pads1.insert( 1 + static_cast(roll1->padTopology().channel(lp)) ); + } + + // find pads with hits in layer2 + auto hits2 = hitsInDetId(id2()); + auto roll2 = gem_geo_->etaPartition(id2); + set pads2; + for (auto& h: hits2) + { + LocalPoint lp = h.entryPoint(); + pads2.insert( 1 + static_cast(roll2->padTopology().channel(lp)) ); + } + + set copads; + std::set_intersection(pads1.begin(), pads1.end(), pads2.begin(), pads2.end(), std::inserter(copads, copads.begin())); + if (copads.empty()) continue; + gem_detids_to_copads_[d] = copads; + } +} + + +std::set SimHitMatcher::detIdsGEM() const +{ + std::set result; + for (auto& p: gem_detid_to_hits_) result.insert(p.first); + return result; +} + + +std::set SimHitMatcher::detIdsCSC(int csc_type) const +{ + std::set result; + for (auto& p: csc_detid_to_hits_) + { + auto id = p.first; + if (csc_type > 0) + { + CSCDetId detId(id); + if (detId.iChamberType() != csc_type) continue; + } + result.insert(id); + } + return result; +} + + +std::set SimHitMatcher::detIdsGEMCoincidences() const +{ + std::set result; + for (auto& p: gem_detids_to_copads_) result.insert(p.first); + return result; +} + + +std::set SimHitMatcher::chamberIdsGEM() const +{ + std::set result; + for (auto& p: gem_chamber_to_hits_) result.insert(p.first); + return result; +} + + +std::set SimHitMatcher::chamberIdsCSC(int csc_type) const +{ + std::set result; + for (auto& p: csc_chamber_to_hits_) + { + auto id = p.first; + if (csc_type > 0) + { + CSCDetId detId(id); + if (detId.iChamberType() != csc_type) continue; + } + result.insert(id); + } + return result; +} + + +std::set +SimHitMatcher::superChamberIdsGEM() const +{ + std::set result; + for (auto& p: gem_superchamber_to_hits_) result.insert(p.first); + return result; +} + + +std::set +SimHitMatcher::superChamberIdsGEMCoincidences() const +{ + std::set result; + for (auto& p: gem_detids_to_copads_) + { + GEMDetId id(p.first); + result.insert(id.chamberId().rawId()); + } + return result; +} + + +const edm::PSimHitContainer& +SimHitMatcher::hitsInDetId(unsigned int detid) const +{ + if (is_gem(detid)) + { + if (gem_detid_to_hits_.find(detid) == gem_detid_to_hits_.end()) return no_hits_; + return gem_detid_to_hits_.at(detid); + } + if (is_csc(detid)) + { + if (csc_detid_to_hits_.find(detid) == csc_detid_to_hits_.end()) return no_hits_; + return csc_detid_to_hits_.at(detid); + } + return no_hits_; +} + + +const edm::PSimHitContainer& +SimHitMatcher::hitsInChamber(unsigned int detid) const +{ + if (is_gem(detid)) // make sure we use chamber id + { + GEMDetId id(detid); + if (gem_chamber_to_hits_.find(id.chamberId().rawId()) == gem_chamber_to_hits_.end()) return no_hits_; + return gem_chamber_to_hits_.at(id.chamberId().rawId()); + } + if (is_csc(detid)) + { + CSCDetId id(detid); + if (csc_chamber_to_hits_.find(id.chamberId().rawId()) == gem_chamber_to_hits_.end()) return no_hits_; + return csc_chamber_to_hits_.at(id.chamberId().rawId()); + } + return no_hits_; +} + + +const edm::PSimHitContainer& +SimHitMatcher::hitsInSuperChamber(unsigned int detid) const +{ + if (is_gem(detid)) + { + GEMDetId id(detid); + if (gem_superchamber_to_hits_.find(id.chamberId().rawId()) == gem_superchamber_to_hits_.end()) return no_hits_; + return gem_superchamber_to_hits_.at(id.chamberId().rawId()); + } + if (is_csc(detid)) return hitsInChamber(detid); + + return no_hits_; +} + + +int +SimHitMatcher::nLayersWithHitsInSuperChamber(unsigned int detid) const +{ + set layers_with_hits; + auto hits = hitsInSuperChamber(detid); + for (auto& h: hits) + { + if (is_gem(detid)) + { + GEMDetId idd(h.detUnitId()); + layers_with_hits.insert(idd.layer()); + } + if (is_csc(detid)) + { + CSCDetId idd(h.detUnitId()); + layers_with_hits.insert(idd.layer()); + } + } + return layers_with_hits.size(); +} + + +GlobalPoint +SimHitMatcher::simHitsMeanPosition(const edm::PSimHitContainer& sim_hits) const +{ + if (sim_hits.empty()) return GlobalPoint(); // point "zero" + + float sumx, sumy, sumz; + sumx = sumy = sumz = 0.f; + size_t n = 0; + for (auto& h: sim_hits) + { + LocalPoint lp = h.entryPoint(); + GlobalPoint gp; + if ( is_gem(h.detUnitId()) ) + { + gp = gem_geo_->idToDet(h.detUnitId())->surface().toGlobal(lp); + } + else if (is_csc(h.detUnitId())) + { + gp = csc_geo_->idToDet(h.detUnitId())->surface().toGlobal(lp); + } + else continue; + sumx += gp.x(); + sumy += gp.y(); + sumz += gp.z(); + ++n; + } + if (n == 0) return GlobalPoint(); + return GlobalPoint(sumx/n, sumy/n, sumz/n); +} + + +float SimHitMatcher::simHitsMeanStrip(const edm::PSimHitContainer& sim_hits) const +{ + if (sim_hits.empty()) return -1.f; + + float sums = 0.f; + size_t n = 0; + for (auto& h: sim_hits) + { + LocalPoint lp = h.entryPoint(); + float s; + auto d = h.detUnitId(); + if ( is_gem(d) ) + { + s = gem_geo_->etaPartition(d)->strip(lp); + } + else if (is_csc(d)) + { + s = csc_geo_->layer(d)->geometry()->strip(lp); + // convert to half-strip: + s *= 2.; + } + else continue; + sums += s; + ++n; + } + if (n == 0) return -1.f; + return sums/n; +} + + +std::set SimHitMatcher::hitStripsInDetId(unsigned int detid, int margin_n_strips) const +{ + set result; + auto simhits = hitsInDetId(detid); + if ( is_gem(detid) ) + { + GEMDetId id(detid); + int max_nstrips = gem_geo_->etaPartition(id)->nstrips(); + for (auto& h: simhits) + { + LocalPoint lp = h.entryPoint(); + int central_strip = 1 + static_cast(gem_geo_->etaPartition(id)->topology().channel(lp)); + int smin = central_strip - margin_n_strips; + smin = (smin > 0) ? smin : 1; + int smax = central_strip + margin_n_strips; + smax = (smax <= max_nstrips) ? smax : max_nstrips; + for (int ss = smin; ss <= smax; ++ss) result.insert(ss); + } + } + else if ( is_csc(detid) ) + { + CSCDetId id(detid); + int max_nstrips = csc_geo_->layer(id)->geometry()->numberOfStrips(); + for (auto& h: simhits) + { + LocalPoint lp = h.entryPoint(); + int central_strip = csc_geo_->layer(id)->geometry()->nearestStrip(lp); + int smin = central_strip - margin_n_strips; + smin = (smin > 0) ? smin : 1; + int smax = central_strip + margin_n_strips; + smax = (smax <= max_nstrips) ? smax : max_nstrips; + for (int ss = smin; ss <= smax; ++ss) result.insert(ss); + } + } + return result; +} + + +std::set SimHitMatcher::hitWiregroupsInDetId(unsigned int detid, int margin_n_wg) const +{ + set result; + if ( !is_csc(detid) ) return result; + + auto simhits = hitsInDetId(detid); + CSCDetId id(detid); + int max_n_wg = csc_geo_->layer(id)->geometry()->numberOfWireGroups(); + for (auto& h: simhits) + { + LocalPoint lp = h.entryPoint(); + auto layer_geo = csc_geo_->layer(id)->geometry(); + int central_wg = layer_geo->wireGroup(layer_geo->nearestWire(lp)); + int wg_min = central_wg - margin_n_wg; + wg_min = (wg_min > 0) ? wg_min : 1; + int wg_max = central_wg + margin_n_wg; + wg_max = (wg_max <= max_n_wg) ? wg_max : max_n_wg; + for (int wg = wg_min; wg <= wg_max; ++wg) result.insert(wg); + + } + return result; +} + + +std::set SimHitMatcher::hitPadsInDetId(unsigned int detid) const +{ + set none; + if (gem_detids_to_pads_.find(detid) == gem_detids_to_pads_.end()) return none; + return gem_detids_to_pads_.at(detid); +} + + +std::set +SimHitMatcher::hitCoPadsInDetId(unsigned int detid) const +{ + set none; + if (gem_detids_to_copads_.find(detid) == gem_detids_to_copads_.end()) return none; + return gem_detids_to_copads_.at(detid); +} + + +std::set SimHitMatcher::hitPartitions() const +{ + std::set result; + + auto detids = detIdsGEM(); + for (auto id: detids) + { + GEMDetId idd(id); + result.insert( idd.roll() ); + } + return result; +} + + +int +SimHitMatcher::nPadsWithHits() const +{ + int result = 0; + auto pad_ids = detIdsGEM(); + for (auto id: pad_ids) + { + result += hitPadsInDetId(id).size(); + } + return result; +} + + +int +SimHitMatcher::nCoincidencePadsWithHits() const +{ + int result = 0; + auto copad_ids = detIdsGEMCoincidences(); + for (auto id: copad_ids) + { + result += hitCoPadsInDetId(id).size(); + } + return result; +} + + +int +SimHitMatcher::nCoincidenceCSCChambers(int min_n_layers) const +{ + int result = 0; + auto chamber_ids = chamberIdsCSC(); + for (auto id: chamber_ids) + { + if (nLayersWithHitsInSuperChamber(id) >= min_n_layers) result += 1; + } + return result; +} + + diff --git a/Validation/MuonGEMDigis/src/SimTrackMatchManager.cc b/Validation/MuonGEMHits/src/SimTrackMatchManager.cc similarity index 73% rename from Validation/MuonGEMDigis/src/SimTrackMatchManager.cc rename to Validation/MuonGEMHits/src/SimTrackMatchManager.cc index 30b29555e5dad..feeca07a173e0 100644 --- a/Validation/MuonGEMDigis/src/SimTrackMatchManager.cc +++ b/Validation/MuonGEMHits/src/SimTrackMatchManager.cc @@ -1,9 +1,8 @@ -#include "Validation/MuonGEMDigis/interface/SimTrackMatchManager.h" +#include "Validation/MuonGEMHits/interface/SimTrackMatchManager.h" SimTrackMatchManager::SimTrackMatchManager(const SimTrack& t, const SimVertex& v, const edm::ParameterSet& ps, const edm::Event& ev, const edm::EventSetup& es) : simhits_(t, v, ps, ev, es) -, gem_digis_(simhits_) {} SimTrackMatchManager::~SimTrackMatchManager() {} diff --git a/Validation/MuonGEMHits/test/MuonGEMHits_cfg.py b/Validation/MuonGEMHits/test/MuonGEMHits_cfg.py new file mode 100644 index 0000000000000..ee5cb89b7d751 --- /dev/null +++ b/Validation/MuonGEMHits/test/MuonGEMHits_cfg.py @@ -0,0 +1,68 @@ +import FWCore.ParameterSet.Config as cms + +process = cms.Process("Demo") + +process.load("FWCore.MessageService.MessageLogger_cfi") + +process.load("DQMServices.Components.MEtoEDMConverter_cfi") + + +process.load("Configuration.EventContent.EventContent_cff") +process.load("DQMServices.Core.DQM_cfg") +## Standard sequence +process.load('Configuration.StandardSequences.Services_cff') +process.load('FWCore.MessageService.MessageLogger_cfi') +process.load('Configuration.Geometry.GeometryExtended2019Reco_cff') +process.load('Configuration.Geometry.GeometryExtended2019_cff') +process.load('Configuration.StandardSequences.MagneticField_38T_PostLS1_cff') +process.load('Configuration.StandardSequences.FrontierConditions_GlobalTag_cff') + +process.load("FWCore.MessageLogger.MessageLogger_cfi") + +## TrackingComponentsRecord required for matchers +process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorOpposite_cfi') +process.load('TrackPropagation.SteppingHelixPropagator.SteppingHelixPropagatorAlong_cfi') + +## global tag for 2019 upgrade studies +from Configuration.AlCa.GlobalTag import GlobalTag +process.GlobalTag = GlobalTag(process.GlobalTag, 'auto:upgrade2019', '') + +process.maxEvents = cms.untracked.PSet( input = cms.untracked.int32(-1) ) + +from DQMServices.Components.DQMEnvironment_cfi import * + +from DQMServices.Examples.test.ConverterTester_cfi import * +#from DQMServices.Components.MEtoEDMConverter.cfi import * + +DQMStore = cms.Service("DQMStore") + + +process.MEtoEDMConverter.Verbosity= cms.untracked.int32(1) +process.MEtoEDMConverter.Frequency= cms.untracked.int32(1) +process.MEtoEDMConverter.deleteAfterCopy = cms.untracked.bool(False) + + + +process.source = cms.Source("PoolSource", + # replace 'myfile.root' with the source file you want to use + fileNames = cms.untracked.vstring( +# 'file:/pnfs/user/geonmo/CMSSW_6_2_0_SLHC1/src/Validation/MuonGEMDigis/data/out_digi_2.root' +# 'file:/pnfs/user/unclok/digi/4954.uosaf0008.sscc.uos.ac.kr/out_sim.root' + 'file:/pnfs/user/unclok/gemsim2/4919.uosaf0008.sscc.uos.ac.kr/out_sim.root' + ) +) + +process.o1 = cms.OutputModule("PoolOutputModule", + outputCommands = cms.untracked.vstring('keep *'), + fileName = cms.untracked.string('out_simhit_validation.root') +) + +from Validation.MuonGEMHits.simTrackMatching_cfi import SimTrackMatching +process.load('Validation.MuonGEMHits.MuonGEMHits_cfi') +process.gemHitsValidation.outputFile= cms.string('valid.root') +process.gemHitsValidation.simTrackMatching = SimTrackMatching + + + +process.p = cms.Path(process.gemHitsValidation*process.MEtoEDMConverter) +process.outpath = cms.EndPath(process.o1)