|
|
|
#include <L1TkTrackBuilder.h>
Public Member Functions | |
| L1TkTrackBuilder (const edm::ParameterSet &iConfig) | |
| Constructor. | |
| ~L1TkTrackBuilder () | |
| Destructor;. | |
Private Member Functions | |
| virtual void | beginRun (edm::Run &run, const edm::EventSetup &iSetup) |
| Tracklet Seeds? | |
| virtual void | endRun (edm::Run &run, const edm::EventSetup &iSetup) |
| End run. | |
| virtual void | produce (edm::Event &iEvent, const edm::EventSetup &iSetup) |
| Implement the producer. | |
Private Attributes | |
| edm::InputTag | L1TkStubsInputTag |
| const StackedTrackerGeometry * | theStackedTracker |
| edm::ESHandle < TrackingAlgorithm< T > > | TrackingAlgoHandle |
| Tracking algorithm. | |
//////////////////////////////////////// Stacked Tracker Simulations /// / Nicola Pozzobon, UNIPD /// / 2011, September /// ////////////////////////////////////// ************************ DECLARATION OF CLASS ************************
Definition at line 36 of file L1TkTrackBuilder.h.
| L1TkTrackBuilder< T >::L1TkTrackBuilder | ( | const edm::ParameterSet & | iConfig | ) | [explicit] |
Constructor.
Close class.
***************************** IMPLEMENTATION OF METHODS ***************************** Constructors
The kind of bricks
Definition at line 102 of file L1TkTrackBuilder.h.
References edm::ParameterSet::getParameter().
{
produces< std::vector< L1TkTrack< T > > >();
L1TkStubsInputTag = iConfig.getParameter< edm::InputTag >("L1TkStubsBricks");
// L1TkTrackletInputTag = iConfig.getParameter< edm::InputTag >("L1TkTrackletSeed"); /// The kind of seed
// useAlsoSeedVtx = iConfig.getParameter< bool >("UseAlsoSeedVertex");
// doHelixFit = iConfig.getParameter< bool >("DoHelixFit");
// removeDuplicates = iConfig.getParameter< bool >("RemoveDuplicates");
// allowedDoubleStacks = iConfig.getParameter< std::vector< unsigned int > >("SeedDoubleStacks");
}
| L1TkTrackBuilder< T >::~L1TkTrackBuilder | ( | ) |
| void L1TkTrackBuilder< T >::beginRun | ( | edm::Run & | run, |
| const edm::EventSetup & | iSetup | ||
| ) | [private, virtual] |
Tracklet Seeds?
Begin run.
Magnetic field Other stuff ///////////////// /// MANDATORY METHODS ///
Get the geometry references
Get the tracking algorithm
Print some information when loaded
Get magnetic field
Calculate B rounded to 4.0 or 3.8
Reimplemented from edm::EDProducer.
Definition at line 121 of file L1TkTrackBuilder.h.
References gather_cfg::cout, edm::EventSetup::get(), and edm::ESHandle< T >::product().
{
edm::ESHandle< StackedTrackerGeometry > StackedTrackerGeomHandle;
iSetup.get< StackedTrackerGeometryRecord >().get( StackedTrackerGeomHandle );
theStackedTracker = StackedTrackerGeomHandle.product();
iSetup.get< TrackingAlgorithmRecord >().get( TrackingAlgoHandle );
std::cout << "L1TkTrackBuilder<" << templateNameFinder<T>() << "> loaded modules:"
<< "\n\tTrackingAlgorithm:\t" << TrackingAlgoHandle->AlgorithmName()
<< std::endl;
// edm::ESHandle<MagneticField> magnet;
// iSetup.get<IdealMagneticFieldRecord>().get(magnet);
// mMagneticFieldStrength = magnet->inTesla(GlobalPoint(0,0,0)).z();
// mMagneticFieldStrength = (floor(mMagneticFieldStrength*10.0 + 0.5))/10.0;
}
| void L1TkTrackBuilder< T >::endRun | ( | edm::Run & | run, |
| const edm::EventSetup & | iSetup | ||
| ) | [private, virtual] |
| void L1TkTrackBuilder< T >::produce | ( | edm::Event & | iEvent, |
| const edm::EventSetup & | iSetup | ||
| ) | [private, virtual] |
Implement the producer.
Prepare output The temporary collection is used to store tracks before removal of duplicates
Get the Stubs already stored away
Store
Implements edm::EDProducer.
Definition at line 150 of file L1TkTrackBuilder.h.
References edm::Event::getByLabel().
{
std::vector< L1TkTrack< T > > tempTrackCollection;
tempTrackCollection.clear();
std::auto_ptr< std::vector< L1TkTrack< T > > > L1TkTracksForOutput( new std::vector< L1TkTrack< T > > );
edm::Handle< std::vector< L1TkStub< T > > > L1TkStubHandle;
iEvent.getByLabel( L1TkStubsInputTag, L1TkStubHandle);
std::vector< L1TkTrack< T > > theseSeeds;
TrackingAlgoHandle->CreateSeeds( theseSeeds, L1TkStubHandle );
/*
edm::Handle< L1TkStubCollectionType > L1TkStubHandleBricks;
edm::Handle< L1TkTrackletCollectionType > L1TkTrackletHandleSeed;
iEvent.getByLabel( L1TkStubsInputTag, L1TkStubHandleBricks );
iEvent.getByLabel( L1TkTrackletInputTag, L1TkTrackletHandleSeed );
L1TkTrackCollectionType tempTrackCollection;
tempTrackCollection.clear();
std::auto_ptr< L1TkTrackCollectionType > L1TkTracksForOutput( new L1TkTrackCollectionType );
L1TkTrackletMapType SeedTracklets;
for ( unsigned int i = 0; i != L1TkTrackletHandleSeed->size(); ++i )
{
StackedTrackerDetId stDetId0( L1TkTrackletHandleSeed->at(i).getStubRef(0)->getDetId() );
StackedTrackerDetId stDetId1( L1TkTrackletHandleSeed->at(i).getStubRef(1)->getDetId() );
unsigned int stack0 = stDetId0.iLayer();
unsigned int stack1 = stDetId1.iLayer();
unsigned int doubleStack = stack0/2;
if ( doubleStack != (stack1-1)/2 ) continue; /// Reject bad formed Tracklets
unsigned int ladder0 = stDetId0.iPhi();
unsigned int ladder1 = stDetId1.iPhi();
if ( ladder0 != ladder1 ) continue; /// Reject bad formed Tracklets
bool skip = true;
for ( unsigned int t = 0; t < allowedDoubleStacks.size(); t++ )
if ( allowedDoubleStacks.at(t) == doubleStack )
skip = false;
if ( allowedDoubleStacks.size() != 0 && skip ) continue;
SeedTracklets[ doubleStack ].push_back( L1TkTrackletPtrType( L1TkTrackletHandleSeed, i ) );
}
L1TkStubMapType BrickStubs;
for ( unsigned int i = 0; i != L1TkStubHandleBricks->size(); ++i )
{
StackedTrackerDetId stDetId( L1TkStubHandleBricks->at(i).getDetId() );
unsigned int stack = stDetId.iLayer();
unsigned int doubleStack;
if ( stack%2 == 0 ) doubleStack = stack/2;
else doubleStack = (stack-1)/2;
bool skip = true;
for ( unsigned int t = 0; t < allowedDoubleStacks.size(); t++ )
if ( allowedDoubleStacks.at(t) == doubleStack )
skip = false;
if ( allowedDoubleStacks.size() != 0 && skip ) continue;
for ( unsigned int q = 0; q < 5; q++ )
{
if ( doubleStack != q) BrickStubs[ q ].push_back( L1TkStubPtrType( L1TkStubHandleBricks , i ) );
}
}
for ( unsigned int j = 0; j < 5; j++ )
{
std::vector< L1TkTrackletPtrType > theSeeds = SeedTracklets[j];
std::vector< L1TkStubPtrType > theBricks = BrickStubs[j];
for ( unsigned int k = 0; k < theSeeds.size(); k++ )
{
std::vector< L1TkTrack< T > > allCandTracks;
allCandTracks.clear();
allCandTracks = TrackingAlgoHandle->PropagateSeed( theSeeds.at(k), theBricks );
for ( unsigned int h = 0; h < allCandTracks.size(); h++ )
{
if ( iEvent.isRealData() == false )
allCandTracks.at(h).checkSimTrack();
allCandTracks.at(h).fitTrack( mMagneticFieldStrength, useAlsoSeedVtx, doHelixFit );
if ( removeDuplicates )
tempTrackCollection.push_back( allCandTracks.at(h) );
else
L1TkTracksForOutput->push_back( allCandTracks.at(h) );
} /// End of loop on candidates
} /// End of loop on seeds
} /// End of loop on Superlayers
unsigned int minForDupl = 2;
unsigned int plusVtx = 0;
if ( useAlsoSeedVtx ) plusVtx = 1;
if ( removeDuplicates )
{
if ( tempTrackCollection.size() != 0 )
{
for ( unsigned int tk = 0; tk < tempTrackCollection.size()-1; tk++ )
{
L1TkStubCollectionType tkStubs0 = tempTrackCollection.at(tk).getStubs();
unsigned int tkNum0 = tkStubs0.size();
if ( tkNum0 == 0 ) continue;
unsigned int tkSeed0 = tempTrackCollection.at(tk).getSeedDoubleStack();
if ( tempTrackCollection.size() == 1 ) continue;
for ( unsigned int tkk = tk+1; tkk < tempTrackCollection.size(); tkk++ )
{
L1TkStubCollectionType tkStubs1 = tempTrackCollection.at(tkk).getStubs();
unsigned int tkNum1 = tkStubs1.size();
if ( tkNum1 == 0 ) continue;
unsigned int tkSeed1 = tempTrackCollection.at(tkk).getSeedDoubleStack();
unsigned int numShared = 0;
for ( unsigned int st = 0; st < tkStubs0.size(); st++ )
{
if ( numShared >= minForDupl ) continue;
for ( unsigned int stt = 0; stt < tkStubs1.size(); stt++ )
{
if ( numShared >= minForDupl ) continue;
if ( tkStubs0.at(st).getClusterPtr(0) == tkStubs1.at(stt).getClusterPtr(0) &&
tkStubs0.at(st).getClusterPtr(1) == tkStubs1.at(stt).getClusterPtr(1) )
numShared++;
}
} /// End of check if they are shared or not
if ( numShared < minForDupl ) continue;
if ( tkSeed1 > tkSeed0 )
tempTrackCollection.at(tkk) = L1TkTrackType();
else if ( tkSeed1 < tkSeed0 )
tempTrackCollection.at(tk) = L1TkTrackType();
else
{
if ( tempTrackCollection.at(tkk).getChi2RPhi() / tkNum1 > tempTrackCollection.at(tk).getChi2RPhi() / tkNum0 )
tempTrackCollection.at(tkk) = L1TkTrackType();
else if ( tempTrackCollection.at(tkk).getChi2RPhi() / tkNum1 < tempTrackCollection.at(tk).getChi2RPhi() / tkNum0 )
tempTrackCollection.at(tk) = L1TkTrackType();
else
std::cerr << "*** I CAN'T BELIEVE IT!! ***" << std::endl;
}
} /// End of Nested loop
} /// End of Loop over pairs Candidate L1TkTracks
for ( unsigned int tk = 0; tk < tempTrackCollection.size(); tk++ )
{
if ( tempTrackCollection.at(tk).getStubs().size() != 0 )
L1TkTracksForOutput->push_back( tempTrackCollection.at(tk) );
}
} /// End of if ( tempTrackCollection.size() != 0 ) {
} /// End of Implement Duplicate Removal
*/
// if ( doHelixFit && useAlsoSeedVtx )
// iEvent.put( L1TkTracksForOutput, "Level1TracksHelFitVtxYes" );
// else if ( useAlsoSeedVtx )
// iEvent.put( L1TkTracksForOutput, "Level1TracksStdFitVtxYes" );
// else if ( doHelixFit )
// iEvent.put( L1TkTracksForOutput, "Level1TracksHelFitVtxNo" );
// else
// iEvent.put( L1TkTracksForOutput, "Level1TracksStdFitVtxNo" );
}
edm::InputTag L1TkTrackBuilder< T >::L1TkStubsInputTag [private] |
Definition at line 67 of file L1TkTrackBuilder.h.
const StackedTrackerGeometry* L1TkTrackBuilder< T >::theStackedTracker [private] |
Data members Geometry
Definition at line 63 of file L1TkTrackBuilder.h.
edm::ESHandle< TrackingAlgorithm< T > > L1TkTrackBuilder< T >::TrackingAlgoHandle [private] |
Tracking algorithm.
Definition at line 66 of file L1TkTrackBuilder.h.
1.7.3