ResidualRefitting Class Reference

#include <ResidualRefitting.h>

Inheritance diagram for ResidualRefitting:

Classes
struct	storage_event
struct	StorageHit
struct	StorageMuon
struct	StorageTrackExtrap
struct	StorageTrackHit

Public Types
typedef struct ResidualRefitting::StorageHit	storage_hit
typedef struct ResidualRefitting::StorageMuon	storage_muon
typedef struct ResidualRefitting::StorageTrackExtrap	storage_trackExtrap
typedef struct ResidualRefitting::StorageTrackHit	storage_trackHit
Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType
Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Public Member Functions
void	analyze (const edm::Event &, const edm::EventSetup &) override
void	beginJob () override
void	branchMuon (ResidualRefitting::storage_muon &storageTmp, std::string branchName)
void	branchTrackExtrap (ResidualRefitting::storage_trackExtrap &storageTmp, std::string branchName)
void	CollectTrackHits (edm::Handle< reco::TrackCollection > trackColl, ResidualRefitting::storage_trackExtrap &trackExtrap, const edm::EventSetup &eventSetup)
void	cylExtrapTrkSam (int recNum, reco::TrackRef track, ResidualRefitting::storage_trackExtrap &storage, double rho)
void	dumpMuonRecHits (const ResidualRefitting::storage_hit &hit)
void	dumpTrackExtrap (const ResidualRefitting::storage_trackExtrap &track)
void	dumpTrackHits (const ResidualRefitting::storage_trackHit &hit)
void	dumpTrackRef (reco::TrackRef muon, std::string str)
void	endJob () override
FreeTrajectoryState	freeTrajStateMuon (reco::TrackRef muon)
bool	IsSameHit (TrackingRecHit const &hit1, TrackingRecHit const &hit2)
int	MatchTrackWithRecHits (reco::TrackCollection::const_iterator trackIt, edm::Handle< reco::TrackCollection > ref)
void	muonInfo (ResidualRefitting::storage_muon &storeMuon, reco::TrackRef muon, int val)
void	NewTrackMeasurements (edm::Handle< reco::TrackCollection > trackCollOrig, edm::Handle< reco::TrackCollection > trackColl, ResidualRefitting::storage_trackExtrap &trackExtrap)
void	omitStation (edm::Handle< reco::MuonCollection > funcMuons, edm::Handle< reco::TrackCollection >, ResidualRefitting::storage_muon &storeGmr, ResidualRefitting::storage_muon &storeSam, ResidualRefitting::storage_trackExtrap &storeExtrap, int omitStation)
void	omitTrackerSystem (edm::Handle< reco::MuonCollection > trkMuons, ResidualRefitting::storage_muon &storeGmr, ResidualRefitting::storage_muon &storeTrk, ResidualRefitting::storage_trackExtrap &storeExtrap, int omitSystem)
	ResidualRefitting (const edm::ParameterSet &)
int	ReturnSector (DetId detid)
int	ReturnStation (DetId detid)
void	StoreTrackerRecHits (DetId detid, const TrackerTopology *tTopo, int iTrack, int iRec)
void	trkExtrap (const DetId &detid, int iTrkLink, int iTrk, int iRec, const FreeTrajectoryState &freeTrajState, const LocalPoint &recPoint, storage_trackExtrap &storeTemp)
void	zero_muon (ResidualRefitting::storage_muon *str)
void	zero_storage ()
void	zero_trackExtrap (ResidualRefitting::storage_trackExtrap *str)
	~ResidualRefitting () override
Public Member Functions inherited from edm::EDAnalyzer
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzer ()
SerialTaskQueue *	globalLuminosityBlocksQueue ()
SerialTaskQueue *	globalRunsQueue ()
ModuleDescription const &	moduleDescription () const
std::string	workerType () const
	~EDAnalyzer () override
Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const
void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...
	EDConsumerBase ()
	EDConsumerBase (EDConsumerBase &&)=default
	EDConsumerBase (EDConsumerBase const &)=delete
ESProxyIndex const *	esGetTokenIndices (edm::Transition iTrans) const
ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const
void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const
std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const
void	labelsForToken (EDGetToken iToken, Labels &oLabels) const
void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const
EDConsumerBase &	operator= (EDConsumerBase &&)=default
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
bool	registeredToConsumeMany (TypeID const &, BranchType) const
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProxyIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Public Attributes
bool	debug_
ResidualRefitting::storage_event	eventInfo_
edm::InputTag	muons_
edm::InputTag	muonsNoPXBLayer1_
edm::InputTag	muonsNoPXBLayer2_
edm::InputTag	muonsNoPXBLayer3_
edm::InputTag	muonsNoPXF_
edm::InputTag	muonsNoStation1_
edm::InputTag	muonsNoStation2_
edm::InputTag	muonsNoStation3_
edm::InputTag	muonsNoStation4_
edm::InputTag	muonsNoTEC_
edm::InputTag	muonsNoTIBLayer1_
edm::InputTag	muonsNoTIBLayer2_
edm::InputTag	muonsNoTIBLayer3_
edm::InputTag	muonsNoTIBLayer4_
edm::InputTag	muonsNoTID_
edm::InputTag	muonsNoTOBLayer1_
edm::InputTag	muonsNoTOBLayer2_
edm::InputTag	muonsNoTOBLayer3_
edm::InputTag	muonsNoTOBLayer4_
edm::InputTag	muonsNoTOBLayer5_
edm::InputTag	muonsNoTOBLayer6_
edm::InputTag	muonsRemake_
TBranch *	outputBranch_
TFile *	outputFile_
std::string	outputFileName_
TTree *	outputTree_
std::string	PropagatorSource_
ResidualRefitting::storage_trackExtrap	samExtrap120_
ResidualRefitting::storage_muon	storageGmrNew_
ResidualRefitting::storage_muon	storageGmrNoPXBLayer1
ResidualRefitting::storage_muon	storageGmrNoPXBLayer2
ResidualRefitting::storage_muon	storageGmrNoPXBLayer3
ResidualRefitting::storage_muon	storageGmrNoPXF
ResidualRefitting::storage_muon	storageGmrNoSt1_
ResidualRefitting::storage_muon	storageGmrNoSt2_
ResidualRefitting::storage_muon	storageGmrNoSt3_
ResidualRefitting::storage_muon	storageGmrNoSt4_
ResidualRefitting::storage_muon	storageGmrNoTEC
ResidualRefitting::storage_muon	storageGmrNoTIBLayer1
ResidualRefitting::storage_muon	storageGmrNoTIBLayer2
ResidualRefitting::storage_muon	storageGmrNoTIBLayer3
ResidualRefitting::storage_muon	storageGmrNoTIBLayer4
ResidualRefitting::storage_muon	storageGmrNoTID
ResidualRefitting::storage_muon	storageGmrNoTOBLayer1
ResidualRefitting::storage_muon	storageGmrNoTOBLayer2
ResidualRefitting::storage_muon	storageGmrNoTOBLayer3
ResidualRefitting::storage_muon	storageGmrNoTOBLayer4
ResidualRefitting::storage_muon	storageGmrNoTOBLayer5
ResidualRefitting::storage_muon	storageGmrNoTOBLayer6
ResidualRefitting::storage_muon	storageGmrOld_
ResidualRefitting::storage_hit	storageRecMuon_
ResidualRefitting::storage_muon	storageSamNew_
ResidualRefitting::storage_muon	storageSamNoSt1_
ResidualRefitting::storage_muon	storageSamNoSt2_
ResidualRefitting::storage_muon	storageSamNoSt3_
ResidualRefitting::storage_muon	storageSamNoSt4_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRec_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt1_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt2_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt3_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt4_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapTracker_
ResidualRefitting::storage_trackHit	storageTrackHit_
ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer1
ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer2
ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer3
ResidualRefitting::storage_trackExtrap	storageTrackNoPXF
ResidualRefitting::storage_trackExtrap	storageTrackNoTEC
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer1
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer2
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer3
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer4
ResidualRefitting::storage_trackExtrap	storageTrackNoTID
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer1
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer2
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer3
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer4
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer5
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer6
ResidualRefitting::storage_muon	storageTrkNew_
ResidualRefitting::storage_muon	storageTrkNoPXBLayer1
ResidualRefitting::storage_muon	storageTrkNoPXBLayer2
ResidualRefitting::storage_muon	storageTrkNoPXBLayer3
ResidualRefitting::storage_muon	storageTrkNoPXF
ResidualRefitting::storage_muon	storageTrkNoTEC
ResidualRefitting::storage_muon	storageTrkNoTIBLayer1
ResidualRefitting::storage_muon	storageTrkNoTIBLayer2
ResidualRefitting::storage_muon	storageTrkNoTIBLayer3
ResidualRefitting::storage_muon	storageTrkNoTIBLayer4
ResidualRefitting::storage_muon	storageTrkNoTID
ResidualRefitting::storage_muon	storageTrkNoTOBLayer1
ResidualRefitting::storage_muon	storageTrkNoTOBLayer2
ResidualRefitting::storage_muon	storageTrkNoTOBLayer3
ResidualRefitting::storage_muon	storageTrkNoTOBLayer4
ResidualRefitting::storage_muon	storageTrkNoTOBLayer5
ResidualRefitting::storage_muon	storageTrkNoTOBLayer6
const MagneticField *	theField
edm::ESHandle< Propagator >	thePropagator
MuonServiceProxy *	theService
ResidualRefitting::storage_trackExtrap	trackExtrap120_
const edm::ESHandle< GlobalTrackingGeometry >	trackingGeometry
edm::InputTag	tracks_

Static Private Attributes
static const int	N_MAX_STORED = 10
static const int	N_MAX_STORED_HIT = 1000
static const int	PXB = 1
static const int	PXF = 2
static const int	TEC = 6
static const int	TIB = 3
static const int	TID = 4
static const int	TOB = 5

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &)
static bool	wantsGlobalLuminosityBlocks ()
static bool	wantsGlobalRuns ()
static bool	wantsStreamLuminosityBlocks ()
static bool	wantsStreamRuns ()
Protected Member Functions inherited from edm::EDConsumerBase
EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)
ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...
template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()
void	consumesMany (const TypeToGet &id)
template<BranchType B>
void	consumesMany (const TypeToGet &id)
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

Detailed Description

Definition at line 39 of file ResidualRefitting.h.

Member Typedef Documentation

storage_hit

typedef struct ResidualRefitting::StorageHit ResidualRefitting::storage_hit

storage_muon

typedef struct ResidualRefitting::StorageMuon ResidualRefitting::storage_muon

storage_trackExtrap

typedef struct ResidualRefitting::StorageTrackExtrap ResidualRefitting::storage_trackExtrap

storage_trackHit

typedef struct ResidualRefitting::StorageTrackHit ResidualRefitting::storage_trackHit

Constructor & Destructor Documentation

ResidualRefitting()

ResidualRefitting::ResidualRefitting ( const edm::ParameterSet &  cfg )

explicit

Definition at line 37 of file ResidualRefitting.cc.

    : outputFileName_(cfg.getUntrackedParameter<std::string>("histoutputFile")),
      PropagatorSource_(cfg.getParameter<std::string>("propagator")),
      muons_(cfg.getParameter<edm::InputTag>("muons")),
      muonsRemake_(cfg.getParameter<edm::InputTag>("muonsRemake")),  //This Feels Misalignment
      muonsNoStation1_(cfg.getParameter<edm::InputTag>("muonsNoStation1")),
      muonsNoStation2_(cfg.getParameter<edm::InputTag>("muonsNoStation2")),
      muonsNoStation3_(cfg.getParameter<edm::InputTag>("muonsNoStation3")),
      muonsNoStation4_(cfg.getParameter<edm::InputTag>("muonsNoStation4")),
 
      /*
  muonsNoPXBLayer1_     ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1"    ) ),
  muonsNoPXBLayer2_     ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1"    ) ),
  muonsNoPXBLayer3_     ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1"    ) ),
 
  muonsNoTIBLayer1_         ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer1"    ) ),
  muonsNoTIBLayer2_         ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer2"    ) ),
  muonsNoTIBLayer3_         ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer3"    ) ),
  muonsNoTIBLayer4_         ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer4"    ) ),
 
  muonsNoTOBLayer1_         ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer1"    ) ),
  muonsNoTOBLayer2_         ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer2"    ) ),
  muonsNoTOBLayer3_         ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer3"    ) ),
  muonsNoTOBLayer4_         ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer4"    ) ),
  muonsNoTOBLayer5_         ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer5"    ) ),
  muonsNoTOBLayer6_         ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer6"    ) ),*/
      debug_(cfg.getUntrackedParameter<bool>("doDebug")),
      outputFile_(nullptr),
      outputTree_(nullptr),
      outputBranch_(nullptr),
      theField(nullptr) {
  eventInfo_.evtNum_ = 0;
  eventInfo_.evtNum_ = 0;
 
  // service parameters
  edm::ParameterSet serviceParameters = cfg.getParameter<edm::ParameterSet>("ServiceParameters");
 
  // the services
  theService = new MuonServiceProxy(serviceParameters, consumesCollector());
 
}  //The constructor

References looper::cfg, edm::EDConsumerBase::consumesCollector(), eventInfo_, ResidualRefitting::storage_event::evtNum_, MuonServiceProxy_cff::MuonServiceProxy, and theService.

~ResidualRefitting()

ResidualRefitting::~ResidualRefitting ( )

override

Definition at line 261 of file ResidualRefitting.cc.

                                      {
  delete outputFile_;
  delete theService;
}

References outputFile_, and theService.

Member Function Documentation

analyze()

void ResidualRefitting::analyze ( const edm::Event &  event, const edm::EventSetup &  eventSetup  )

overridevirtual

Implements edm::EDAnalyzer.

Definition at line 79 of file ResidualRefitting.cc.

                                                                                      {
  if (debug_)
    printf("STARTING EVENT\n");
 
  eventInfo_.evtNum_ = (int)event.id().run();
  eventInfo_.runNum_ = (int)event.id().event();
 
  // Generator Collection
 
  // The original muon collection that is sitting in memory
  edm::Handle<reco::MuonCollection> muons;
 
  edm::Handle<reco::TrackCollection> muonTracks;
  edm::Handle<reco::TrackCollection> muonsNoSt1;
  edm::Handle<reco::TrackCollection> muonsNoSt2;
  edm::Handle<reco::TrackCollection> muonsNoSt3;
  edm::Handle<reco::TrackCollection> muonsNoSt4;
 
  event.getByLabel(muons_, muons);  //set label to muons
  event.getByLabel(muonsRemake_, muonTracks);
  event.getByLabel(muonsNoStation1_, muonsNoSt1);
  event.getByLabel(muonsNoStation2_, muonsNoSt2);
  event.getByLabel(muonsNoStation3_, muonsNoSt3);
  event.getByLabel(muonsNoStation4_, muonsNoSt4);
 
  /*
//  std::cout<<"Muon Collection No PXB "<<std::endl;
//Tracker Barrel Pixel Refits
    edm::Handle<MuonCollection> muonsNoPXBLayer1Coll;
    event.getByLabel(muonsNoPXBLayer1_, muonsNoPXBLayer1Coll);
    edm::Handle<MuonCollection> muonsNoPXBLayer2Coll;
    event.getByLabel(muonsNoPXBLayer2_, muonsNoPXBLayer2Coll);
    edm::Handle<MuonCollection> muonsNoPXBLayer3Coll;
    event.getByLabel(muonsNoPXBLayer3_, muonsNoPXBLayer3Coll);
//  std::cout<<"Muon Collection No TIB "<<std::endl;
// Tracker Inner Barrel Refits
    edm::Handle<MuonCollection> muonsNoTIBLayer1Coll;
    event.getByLabel(muonsNoTIBLayer1_, muonsNoTIBLayer1Coll);
    edm::Handle<MuonCollection> muonsNoTIBLayer2Coll;
    event.getByLabel(muonsNoTIBLayer2_, muonsNoTIBLayer2Coll);
    edm::Handle<MuonCollection> muonsNoTIBLayer3Coll;
    event.getByLabel(muonsNoTIBLayer3_, muonsNoTIBLayer3Coll);
    edm::Handle<MuonCollection> muonsNoTIBLayer4Coll;
    event.getByLabel(muonsNoTIBLayer4_, muonsNoTIBLayer4Coll);
 
//  std::cout<<"Muon Collection No TOB "<<std::endl;
 
//Tracker outer barrel refits
    edm::Handle<MuonCollection> muonsNoTOBLayer1Coll;
    event.getByLabel(muonsNoTOBLayer1_, muonsNoTOBLayer1Coll);
    edm::Handle<MuonCollection> muonsNoTOBLayer2Coll;
    event.getByLabel(muonsNoTOBLayer2_, muonsNoTOBLayer2Coll);
    edm::Handle<MuonCollection> muonsNoTOBLayer3Coll;
    event.getByLabel(muonsNoTOBLayer3_, muonsNoTOBLayer3Coll);
    edm::Handle<MuonCollection> muonsNoTOBLayer4Coll;
    event.getByLabel(muonsNoTOBLayer4_, muonsNoTOBLayer4Coll);
    edm::Handle<MuonCollection> muonsNoTOBLayer5Coll;
    event.getByLabel(muonsNoTOBLayer5_, muonsNoTOBLayer5Coll);
    edm::Handle<MuonCollection> muonsNoTOBLayer6Coll;
    event.getByLabel(muonsNoTOBLayer6_, muonsNoTOBLayer6Coll);
*/
  //magnetic field information
  edm::ESHandle<MagneticField> field;
  edm::ESHandle<GlobalTrackingGeometry> globalTrackingGeometry;
  eventSetup.get<IdealMagneticFieldRecord>().get(field);
  eventSetup.get<GlobalTrackingGeometryRecord>().get(globalTrackingGeometry);
  eventSetup.get<TrackingComponentsRecord>().get(PropagatorSource_, thePropagator);
  theField = &*field;
 
  theService->update(eventSetup);
 
  //Zero storage
  zero_storage();
 
  //Do the Gmr Muons from the unModified Collection
 
  /*
    int iGmr = 0;
    if ( (muons->end() - muons->begin()) > 0) printf("Data Dump:: Original GMR Muons\n");
    for ( MuonCollection::const_iterator muon = muons->begin(); muon!=muons->end(); muon++, iGmr++) {
        if ( iGmr >= ResidualRefitting::N_MAX_STORED) break; // error checking
        if (!debug
        
        dumpTrackRef(muon->combinedMuon(), "cmb"); 
        dumpTrackRef(muon->standAloneMuon(), "sam");
        dumpTrackRef(muon->track(), "trk");
        
 
    }
    storageGmrOld_.n_ = iGmr;
    storageSamNew_.n_ = iGmr;
*/
 
  //Refitted muons
  if (debug_)
    printf("Data Dump:: Rebuilt GMR Muon Track With TeV refitter default\n");
  int iGmrRemake = 0;
  for (reco::TrackCollection::const_iterator muon = muonTracks->begin(); muon != muonTracks->end();
       muon++, iGmrRemake++) {
    if (iGmrRemake >= ResidualRefitting::N_MAX_STORED)
      break;  // error checking
              // from TrackInfoProducer/test/TrackInfoAnalyzerExample.cc
    reco::TrackRef trackref = reco::TrackRef(muonTracks, iGmrRemake);
 
    if (debug_)
      dumpTrackRef(trackref, "gmr");
    muonInfo(storageGmrNew_, trackref, iGmrRemake);
  }
  storageGmrNew_.n_ = iGmrRemake;
 
  if (debug_)
    printf("muons Remake");
  if (debug_)
    printf("-----------------------------------------\n");
  CollectTrackHits(muonTracks, storageTrackExtrapRec_, eventSetup);
 
  if (true) {
    printf("muons No Station 1");
    printf("-----------------------------------------\n");
  }
  NewTrackMeasurements(muonTracks, muonsNoSt1, storageTrackExtrapRecNoSt1_);
 
  if (true) {
    printf("muons No Station 2");
    printf("-----------------------------------------\n");
  }
  NewTrackMeasurements(muonTracks, muonsNoSt2, storageTrackExtrapRecNoSt2_);
 
  if (true) {
    printf("muons No Station 3");
    printf("-----------------------------------------\n");
  }
  NewTrackMeasurements(muonTracks, muonsNoSt3, storageTrackExtrapRecNoSt3_);
 
  if (true) {
    printf("muons No Station 4");
    printf("-----------------------------------------\n");
  }
  NewTrackMeasurements(muonTracks, muonsNoSt4, storageTrackExtrapRecNoSt4_);
 
  //    dumpMuonRecHits(storageRecMuon_);
 
  /****************************************************************************************************************************************/
 
  /*
 *  extrapolates track to a cylinder.
 *  commented for cosmic runs with no tracker in reco muons!!
 *
*/
 
  int iGmrCyl = 0;
  for (reco::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); muon++, iGmrCyl++) {
    dumpTrackRef(muon->combinedMuon(), "cmb");
    dumpTrackRef(muon->standAloneMuon(), "sam");
    dumpTrackRef(muon->track(), "trk");
 
    cylExtrapTrkSam(iGmrCyl, muon->standAloneMuon(), samExtrap120_, 120.);
    cylExtrapTrkSam(iGmrCyl, muon->track(), trackExtrap120_, 120.);
  }
  samExtrap120_.n_ = iGmrCyl;
  trackExtrap120_.n_ = iGmrCyl;
 
  if (iGmrRemake > 0 || iGmrCyl > 0) {
    outputTree_->Fill();
    std::cout << "FILLING NTUPLE!" << std::endl;
    std::cout << "Entries Recorded: " << outputTree_->GetEntries() << " Branch :: " << outputBranch_->GetEntries()
              << std::endl
              << std::endl;
  } else
    std::cout << "no tracks -- no fill!\n" << std::endl << std::endl;
 
  //  /*************************************************************************************************************/
  //  //END OF ntuple dumper
  //  //END OF ntuple dumper
  //  /***********************************************************************************************************/
}

References CollectTrackHits(), gather_cfg::cout, cylExtrapTrkSam(), debug_, dumpTrackRef(), eventInfo_, ResidualRefitting::storage_event::evtNum_, edm::EventSetup::get(), get, createfilelist::int, muonInfo(), PDWG_BPHSkim_cff::muons, muons_, muonsNoStation1_, muonsNoStation2_, muonsNoStation3_, muonsNoStation4_, muonsRemake_, ResidualRefitting::StorageMuon::n_, ResidualRefitting::StorageTrackExtrap::n_, N_MAX_STORED, NewTrackMeasurements(), outputBranch_, outputTree_, PropagatorSource_, ResidualRefitting::storage_event::runNum_, samExtrap120_, storageGmrNew_, storageTrackExtrapRec_, storageTrackExtrapRecNoSt1_, storageTrackExtrapRecNoSt2_, storageTrackExtrapRecNoSt3_, storageTrackExtrapRecNoSt4_, theField, thePropagator, theService, trackExtrap120_, MuonServiceProxy::update(), and zero_storage().

beginJob()

void ResidualRefitting::beginJob ( void  )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 966 of file ResidualRefitting.cc.

                                 {
  std::cout << "Creating file " << outputFileName_.c_str() << std::endl;
 
  outputFile_ = new TFile(outputFileName_.c_str(), "RECREATE");
 
  outputTree_ = new TTree("outputTree", "outputTree");
 
  outputTree_->Branch("eventInfo",
                      &eventInfo_,
                      "evtNum_/I:"
                      "runNum_/I");
 
  ResidualRefitting::branchMuon(storageGmrOld_, "gmrOld");
  ResidualRefitting::branchMuon(storageGmrNew_, "gmrNew");
  ResidualRefitting::branchMuon(storageGmrNoSt1_, "gmrNoSt1");
  ResidualRefitting::branchMuon(storageGmrNoSt2_, "gmrNoSt2");
  ResidualRefitting::branchMuon(storageGmrNoSt3_, "gmrNoSt3");
  ResidualRefitting::branchMuon(storageGmrNoSt4_, "gmrNoSt4");
 
  ResidualRefitting::branchMuon(storageSamNew_, "samNew");
  ResidualRefitting::branchMuon(storageSamNoSt1_, "samNoSt1");
  ResidualRefitting::branchMuon(storageSamNoSt2_, "samNoSt2");
  ResidualRefitting::branchMuon(storageSamNoSt3_, "samNoSt3");
  ResidualRefitting::branchMuon(storageSamNoSt4_, "samNoSt4");
 
  ResidualRefitting::branchMuon(storageTrkNew_, "trkNew");
  ResidualRefitting::branchMuon(storageGmrNoPXBLayer1, "gmrNoPXBLayer1");
  ResidualRefitting::branchMuon(storageGmrNoPXBLayer2, "gmrNoPXBLayer2");
  ResidualRefitting::branchMuon(storageGmrNoPXBLayer3, "gmrNoPXBLayer3");
  ResidualRefitting::branchMuon(storageGmrNoPXF, "gmrNoPXF");
  ResidualRefitting::branchMuon(storageGmrNoTIBLayer1, "gmrNoTIBLayer1");
  ResidualRefitting::branchMuon(storageGmrNoTIBLayer2, "gmrNoTIBLayer2");
  ResidualRefitting::branchMuon(storageGmrNoTIBLayer3, "gmrNoTIBLayer3");
  ResidualRefitting::branchMuon(storageGmrNoTIBLayer4, "gmrNoTIBLayer4");
  ResidualRefitting::branchMuon(storageGmrNoTID, "gmrNoTID");
  ResidualRefitting::branchMuon(storageGmrNoTOBLayer1, "gmrNoTOBLayer1");
  ResidualRefitting::branchMuon(storageGmrNoTOBLayer2, "gmrNoTOBLayer2");
  ResidualRefitting::branchMuon(storageGmrNoTOBLayer3, "gmrNoTOBLayer3");
  ResidualRefitting::branchMuon(storageGmrNoTOBLayer4, "gmrNoTOBLayer4");
  ResidualRefitting::branchMuon(storageGmrNoTOBLayer5, "gmrNoTOBLayer5");
  ResidualRefitting::branchMuon(storageGmrNoTOBLayer6, "gmrNoTOBLayer6");
  ResidualRefitting::branchMuon(storageGmrNoTEC, "gmrNoTEC");
 
  ResidualRefitting::branchMuon(storageTrkNoPXBLayer1, "trkNoPXBLayer1");
  ResidualRefitting::branchMuon(storageTrkNoPXBLayer2, "trkNoPXBLayer2");
  ResidualRefitting::branchMuon(storageTrkNoPXBLayer3, "trkNoPXBLayer3");
  ResidualRefitting::branchMuon(storageTrkNoPXF, "trkNoPXF");
  ResidualRefitting::branchMuon(storageTrkNoTIBLayer1, "trkNoTIBLayer1");
  ResidualRefitting::branchMuon(storageTrkNoTIBLayer2, "trkNoTIBLayer2");
  ResidualRefitting::branchMuon(storageTrkNoTIBLayer3, "trkNoTIBLayer3");
  ResidualRefitting::branchMuon(storageTrkNoTIBLayer4, "trkNoTIBLayer4");
  ResidualRefitting::branchMuon(storageTrkNoTID, "trkNoTID");
  ResidualRefitting::branchMuon(storageTrkNoTOBLayer1, "trkNoTOBLayer1");
  ResidualRefitting::branchMuon(storageTrkNoTOBLayer2, "trkNoTOBLayer2");
  ResidualRefitting::branchMuon(storageTrkNoTOBLayer3, "trkNoTOBLayer3");
  ResidualRefitting::branchMuon(storageTrkNoTOBLayer4, "trkNoTOBLayer4");
  ResidualRefitting::branchMuon(storageTrkNoTOBLayer5, "trkNoTOBLayer5");
  ResidualRefitting::branchMuon(storageTrkNoTOBLayer6, "trkNoTOBLayer6");
  ResidualRefitting::branchMuon(storageTrkNoTEC, "trkNoTEC");
 
  outputBranch_ = outputTree_->Branch("recHitsNew",
                                      &storageRecMuon_,
 
                                      "n_/I:"
                                      "muonLink_[1000]/I:"
 
                                      "system_[1000]/I:"
                                      "endcap_[1000]/I:"
                                      "station_[1000]/I:"
                                      "ring_[1000]/I:"
                                      "chamber_[1000]/I:"
                                      "layer_[1000]/I:"
                                      "superLayer_[1000]/I:"
                                      "wheel_[1000]/I:"
                                      "sector_[1000]/I:"
 
                                      "gpX_[1000]/F:"
                                      "gpY_[1000]/F:"
                                      "gpZ_[1000]/F:"
                                      "gpEta_[1000]/F:"
                                      "gpPhi_[1000]/F:"
                                      "lpX_[1000]/F:"
                                      "lpY_[1000]/F:"
                                      "lpZ_[1000]/F");
 
  outputBranch_ = outputTree_->Branch("recHitsTracker",
                                      &storageTrackHit_,
 
                                      "n_/I:"
 
                                      "muonLink_[1000]/I:"
                                      "detector_[1000]/I:"
                                      "subdetector_[1000]/I:"
                                      "blade_[1000]/I:"
                                      "disk_[1000]/I:"
                                      "ladder_[1000]/I:"
                                      "layer_[1000]/I:"
                                      "module_[1000]/I:"
                                      "panel_[1000]/I:"
                                      "ring_[1000]/I:"
                                      "side_[1000]/I:"
                                      "wheel_[1000]/I:"
 
                                      "gpX_[1000]/F:"
                                      "gpY_[1000]/F:"
                                      "gpZ_[1000]/F:"
                                      "gpEta_[1000]/F:"
                                      "gpPhi_[1000]/F:"
                                      "lpX_[1000]/F:"
                                      "lpY_[1000]/F:"
                                      "lpZ_[1000]/F");
 
  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRec_, "trkExtrap");
  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt1_, "trkExtrapNoSt1");
  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt2_, "trkExtrapNoSt2");
  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt3_, "trkExtrapNoSt3");
  ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt4_, "trkExtrapNoSt4");
 
  ResidualRefitting::branchTrackExtrap(storageTrackExtrapTracker_, "trkExtrapTracker");
  ResidualRefitting::branchTrackExtrap(storageTrackNoPXF, "trkExtrapNoPXF");
  ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer1, "trkExtrapNoPXBLayer1");
  ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer2, "trkExtrapNoPXBLayer2");
  ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer3, "trkExtrapNoPXBLayer3");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer1, "trkExtrapNoTIBLayer1");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer2, "trkExtrapNoTIBLayer2");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer3, "trkExtrapNoTIBLayer3");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer4, "trkExtrapNoTIBLayer4");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTID, "trkExtrapNoTID");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer1, "trkExtrapNoTOBLayer1");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer2, "trkExtrapNoTOBLayer2");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer3, "trkExtrapNoTOBLayer3");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer4, "trkExtrapNoTOBLayer4");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer5, "trkExtrapNoTOBLayer5");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer6, "trkExtrapNoTOBLayer6");
  ResidualRefitting::branchTrackExtrap(storageTrackNoTEC, "trkExtrapNoTEC");
 
  ResidualRefitting::branchTrackExtrap(trackExtrap120_, "trackCyl120");
  ResidualRefitting::branchTrackExtrap(samExtrap120_, "samCyl120");
}

References branchMuon(), branchTrackExtrap(), gather_cfg::cout, eventInfo_, outputBranch_, outputFile_, outputFileName_, outputTree_, samExtrap120_, storageGmrNew_, storageGmrNoPXBLayer1, storageGmrNoPXBLayer2, storageGmrNoPXBLayer3, storageGmrNoPXF, storageGmrNoSt1_, storageGmrNoSt2_, storageGmrNoSt3_, storageGmrNoSt4_, storageGmrNoTEC, storageGmrNoTIBLayer1, storageGmrNoTIBLayer2, storageGmrNoTIBLayer3, storageGmrNoTIBLayer4, storageGmrNoTID, storageGmrNoTOBLayer1, storageGmrNoTOBLayer2, storageGmrNoTOBLayer3, storageGmrNoTOBLayer4, storageGmrNoTOBLayer5, storageGmrNoTOBLayer6, storageGmrOld_, storageRecMuon_, storageSamNew_, storageSamNoSt1_, storageSamNoSt2_, storageSamNoSt3_, storageSamNoSt4_, storageTrackExtrapRec_, storageTrackExtrapRecNoSt1_, storageTrackExtrapRecNoSt2_, storageTrackExtrapRecNoSt3_, storageTrackExtrapRecNoSt4_, storageTrackExtrapTracker_, storageTrackHit_, storageTrackNoPXBLayer1, storageTrackNoPXBLayer2, storageTrackNoPXBLayer3, storageTrackNoPXF, storageTrackNoTEC, storageTrackNoTIBLayer1, storageTrackNoTIBLayer2, storageTrackNoTIBLayer3, storageTrackNoTIBLayer4, storageTrackNoTID, storageTrackNoTOBLayer1, storageTrackNoTOBLayer2, storageTrackNoTOBLayer3, storageTrackNoTOBLayer4, storageTrackNoTOBLayer5, storageTrackNoTOBLayer6, storageTrkNew_, storageTrkNoPXBLayer1, storageTrkNoPXBLayer2, storageTrkNoPXBLayer3, storageTrkNoPXF, storageTrkNoTEC, storageTrkNoTIBLayer1, storageTrkNoTIBLayer2, storageTrkNoTIBLayer3, storageTrkNoTIBLayer4, storageTrkNoTID, storageTrkNoTOBLayer1, storageTrkNoTOBLayer2, storageTrkNoTOBLayer3, storageTrkNoTOBLayer4, storageTrkNoTOBLayer5, storageTrkNoTOBLayer6, and trackExtrap120_.

branchMuon()

void ResidualRefitting::branchMuon	(	ResidualRefitting::storage_muon &	storageTmp,
		std::string	branchName
	)

Definition at line 1108 of file ResidualRefitting.cc.

                                                                                                  {
  outputBranch_ = outputTree_->Branch(branchName.c_str(),
                                      &storageTmp,
                                      "n_/I:"
                                      "charge_[10]/I:"
                                      "pt_[10]/F:"
                                      "eta_[10]/F:"
                                      "p_[10]/F:"
                                      "phi_[10]/F:"
                                      "numRecHits_[10]/I:"
                                      "chiSq_[10]/F:"
                                      "ndf_[10]/F:"
                                      "chiSqOvrNdf_[10]/F"
 
  );
}

References electrons_cff::branchName, outputBranch_, and outputTree_.

Referenced by beginJob().

branchTrackExtrap()

void ResidualRefitting::branchTrackExtrap	(	ResidualRefitting::storage_trackExtrap &	storageTmp,
		std::string	branchName
	)

Definition at line 1127 of file ResidualRefitting.cc.

                                                                                                                {
  outputBranch_ = outputTree_->Branch(branchName.c_str(),
                                      &storageTmp,
                                      "n_/I:"
                                      "muonLink_[1000]/I:"
                                      "recLink_[1000]/I:"
                                      "gpX_[1000]/F:"
                                      "gpY_[1000]/F:"
                                      "gpZ_[1000]/F:"
                                      "gpEta_[1000]/F:"
                                      "gpPhi_[1000]/F:"
                                      "lpX_[1000]/F:"
                                      "lpY_[1000]/F:"
                                      "lpZ_[1000]/F:"
                                      "resX_[1000]/F:"
                                      "resY_[1000]/F:"
                                      "resZ_[1000]/F"
 
  );
}

References electrons_cff::branchName, outputBranch_, and outputTree_.

Referenced by beginJob().

CollectTrackHits()

void ResidualRefitting::CollectTrackHits	(	edm::Handle< reco::TrackCollection >	trackColl,
		ResidualRefitting::storage_trackExtrap &	trackExtrap,
		const edm::EventSetup &	eventSetup
	)

Definition at line 268 of file ResidualRefitting.cc.

                                                                          {
  //Retrieve tracker topology from geometry
  edm::ESHandle<TrackerTopology> tTopoHandle;
  eventSetup.get<TrackerTopologyRcd>().get(tTopoHandle);
  const TrackerTopology* const tTopo = tTopoHandle.product();
 
  int iMuonHit = 0;
  int iTrackHit = 0;
  int numTracks = 0;
 
  for (reco::TrackCollection::const_iterator muon = trackColl->begin(); muon != trackColl->end(); muon++) {
    int iTrack = muon - trackColl->begin();
    reco::TrackRef trackref = reco::TrackRef(trackColl, iTrack);
    FreeTrajectoryState recoStart = ResidualRefitting::freeTrajStateMuon(trackref);
 
    if (debug_)
      dumpTrackRef(trackref, "CollectTrackHits Track");
 
    int iRec = 0;
    for (auto const& rec : muon->recHits()) {
      DetId detid = rec->geographicalId();
 
      if (detid.det() != DetId::Muon && detid.det() != DetId::Tracker) {
        if (debug_)
          printf("Rec Hit not from muon system or tracker... continuing...\n");
        continue;
      }
      //            numTracks++;
      // Get Local and Global Position of Hits
 
      LocalPoint lp = rec->localPosition();
      float lpX = lp.x();
      float lpY = lp.y();
      float lpZ = lp.z();
 
      auto mrhp = MuonTransientTrackingRecHit::specificBuild(
          theService->trackingGeometry()->idToDet(rec->geographicalId()), rec);
 
      GlobalPoint gp = mrhp->globalPosition();
      float gpRecX = gp.x();
      float gpRecY = gp.y();
      float gpRecZ = gp.z();
      float gpRecEta = gp.eta();
      float gpRecPhi = gp.phi();
 
      if (detid.det() == DetId::Muon) {
        int systemMuon = detid.subdetId();  // 1 DT; 2 CSC; 3 RPC
        int endcap = -999;
        int station = -999;
        int ring = -999;
        int chamber = -999;
        int layer = -999;
        int superLayer = -999;
        int wheel = -999;
        int sector = -999;
        if (systemMuon == MuonSubdetId::CSC) {
          CSCDetId id(detid.rawId());
          endcap = id.endcap();
          station = id.station();
          ring = id.ring();
          chamber = id.chamber();
          layer = id.layer();
          if (debug_)
            printf("CSC\t[endcap][station][ringN][chamber][layer]:[%d][%d][%d][%d][%d]\t",
                   endcap,
                   station,
                   ring,
                   chamber,
                   layer);
 
        } else if (systemMuon == MuonSubdetId::DT) {
          DTWireId id(detid.rawId());
          station = id.station();
          layer = id.layer();
          superLayer = id.superLayer();
          wheel = id.wheel();
          sector = id.sector();
          if (debug_)
            printf("DT \t[station][layer][superlayer]:[%d][%d][%d]\n", station, layer, superLayer);
 
        } else if (systemMuon == MuonSubdetId::RPC) {
          RPCDetId id(detid.rawId());
          station = id.station();
          if (debug_)
            printf("RPC\t[station]:[%d]\n", station);
        }
 
        storageRecMuon_.muonLink_[iMuonHit] = iTrack;
        storageRecMuon_.system_[iMuonHit] = systemMuon;
        storageRecMuon_.endcap_[iMuonHit] = endcap;
        storageRecMuon_.station_[iMuonHit] = station;
        storageRecMuon_.ring_[iMuonHit] = ring;
        storageRecMuon_.chamber_[iMuonHit] = chamber;
        storageRecMuon_.layer_[iMuonHit] = layer;
        storageRecMuon_.superLayer_[iMuonHit] = superLayer;
        storageRecMuon_.wheel_[iMuonHit] = wheel;
        storageRecMuon_.sector_[iMuonHit] = sector;
 
        storageRecMuon_.gpX_[iMuonHit] = gpRecX;
        storageRecMuon_.gpY_[iMuonHit] = gpRecY;
        storageRecMuon_.gpZ_[iMuonHit] = gpRecZ;
        storageRecMuon_.gpEta_[iMuonHit] = gpRecEta;
        storageRecMuon_.gpPhi_[iMuonHit] = gpRecPhi;
        storageRecMuon_.lpX_[iMuonHit] = lpX;
        storageRecMuon_.lpY_[iMuonHit] = lpY;
        storageRecMuon_.lpZ_[iMuonHit] = lpZ;
        iMuonHit++;
 
      } else if (detid.det() == DetId::Tracker) {
        if (debug_)
          printf("Tracker\n");
 
        StoreTrackerRecHits(detid, tTopo, iTrack, iTrackHit);
 
        storageTrackHit_.gpX_[iTrackHit] = gpRecX;
        storageTrackHit_.gpY_[iTrackHit] = gpRecY;
        storageTrackHit_.gpZ_[iTrackHit] = gpRecZ;
        storageTrackHit_.gpEta_[iTrackHit] = gpRecEta;
        storageTrackHit_.gpPhi_[iTrackHit] = gpRecPhi;
        storageTrackHit_.lpX_[iTrackHit] = lpX;
        storageTrackHit_.lpY_[iTrackHit] = lpY;
        storageTrackHit_.lpZ_[iTrackHit] = lpZ;
        iTrackHit++;
      } else
        printf("THIS CAN NOT HAPPEN\n");
 
      trkExtrap(detid, numTracks, iTrack, iRec, recoStart, lp, trackExtrap);
      numTracks++;
 
      if (debug_)
        printf("\tLocal Positon:  \tx = %2.2f\ty = %2.2f\tz = %2.2f\n", lpX, lpY, lpZ);
      if (debug_)
        printf("\tGlobal Position: \tx = %6.2f\ty = %6.2f\tz = %6.2f\teta = %4.2f\tphi = %3.2f\n",
               gpRecX,
               gpRecY,
               gpRecZ,
               gpRecEta,
               gpRecPhi);
 
      ++iRec;
    }
  }
 
  storageRecMuon_.n_ = iMuonHit;
  storageTrackHit_.n_ = iTrackHit;
  trackExtrap.n_ = numTracks;
}

References relativeConstraints::chamber, ResidualRefitting::StorageHit::chamber_, MuonSubdetId::CSC, debug_, DetId::det(), MuonSubdetId::DT, dumpTrackRef(), makeMuonMisalignmentScenario::endcap, ResidualRefitting::StorageHit::endcap_, freeTrajStateMuon(), edm::EventSetup::get(), get, runTauDisplay::gp, ResidualRefitting::StorageHit::gpEta_, ResidualRefitting::StorageTrackHit::gpEta_, ResidualRefitting::StorageHit::gpPhi_, ResidualRefitting::StorageTrackHit::gpPhi_, ResidualRefitting::StorageHit::gpX_, ResidualRefitting::StorageTrackHit::gpX_, ResidualRefitting::StorageHit::gpY_, ResidualRefitting::StorageTrackHit::gpY_, ResidualRefitting::StorageHit::gpZ_, ResidualRefitting::StorageTrackHit::gpZ_, triggerObjects_cff::id, GlobalTrackingGeometry::idToDet(), ResidualRefitting::StorageHit::layer_, ResidualRefitting::StorageHit::lpX_, ResidualRefitting::StorageTrackHit::lpX_, ResidualRefitting::StorageHit::lpY_, ResidualRefitting::StorageTrackHit::lpY_, ResidualRefitting::StorageHit::lpZ_, ResidualRefitting::StorageTrackHit::lpZ_, DetId::Muon, ResidualRefitting::StorageHit::muonLink_, ResidualRefitting::StorageHit::n_, ResidualRefitting::StorageTrackExtrap::n_, ResidualRefitting::StorageTrackHit::n_, edm::ESHandle< T >::product(), DetId::rawId(), relativeConstraints::ring, ResidualRefitting::StorageHit::ring_, MuonSubdetId::RPC, ResidualRefitting::StorageHit::sector_, MuonTransientTrackingRecHit::specificBuild(), relativeConstraints::station, ResidualRefitting::StorageHit::station_, storageRecMuon_, storageTrackHit_, StoreTrackerRecHits(), DetId::subdetId(), ResidualRefitting::StorageHit::superLayer_, ResidualRefitting::StorageHit::system_, theService, pfDisplacedTrackerVertex_cfi::trackColl, DetId::Tracker, MuonServiceProxy::trackingGeometry(), trkExtrap(), makeMuonMisalignmentScenario::wheel, ResidualRefitting::StorageHit::wheel_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

cylExtrapTrkSam()

void ResidualRefitting::cylExtrapTrkSam	(	int	recNum,
		reco::TrackRef	track,
		ResidualRefitting::storage_trackExtrap &	storage,
		double	rho
	)

Definition at line 780 of file ResidualRefitting.cc.

                                                    {
  Cylinder::PositionType pos(0, 0, 0);
  Cylinder::RotationType rot;
 
  Cylinder::CylinderPointer myCylinder = Cylinder::build(pos, rot, rho);
  //    SteppingHelixPropagator inwardProp  ( theField, oppositeToMomentum );
  //    SteppingHelixPropagator outwardProp ( theField, alongMomentum );
  FreeTrajectoryState recoStart = freeTrajStateMuon(track);
  //    TrajectoryStateOnSurface recoProp = outwardProp.propagate(recoStart, *myCylinder);
  TrajectoryStateOnSurface recoProp = thePropagator->propagate(recoStart, *myCylinder);
 
  double xVal = -9999;
  double yVal = -9999;
  double zVal = -9999;
  double phiVal = -9999;
  double etaVal = -9999;
 
  if (recoProp.isValid()) {
    GlobalPoint recoPoint = recoProp.globalPosition();
    xVal = recoPoint.x();
    yVal = recoPoint.y();
    zVal = recoPoint.z();
    phiVal = recoPoint.phi();
    etaVal = recoPoint.eta();
  }
  storage.muonLink_[recNum] = recNum;
  storage.gpX_[recNum] = xVal;
  storage.gpY_[recNum] = yVal;
  storage.gpZ_[recNum] = zVal;
  storage.gpEta_[recNum] = etaVal;
  storage.gpPhi_[recNum] = phiVal;
 
  float rhoVal = sqrt(xVal * xVal + yVal * yVal);
 
  printf("Cylinder: rho = %4.2f\tphi = %4.2f\teta = %4.2f\n", rhoVal, phiVal, etaVal);
  if (debug_)
    printf("Cylinder: rho = %4.2f\tphi = %4.2f\teta = %4.2f\n", rhoVal, phiVal, etaVal);
}

References Cylinder::build(), debug_, PV3DBase< T, PVType, FrameType >::eta(), freeTrajStateMuon(), TrajectoryStateOnSurface::globalPosition(), ResidualRefitting::StorageTrackExtrap::gpEta_, ResidualRefitting::StorageTrackExtrap::gpPhi_, ResidualRefitting::StorageTrackExtrap::gpX_, ResidualRefitting::StorageTrackExtrap::gpY_, ResidualRefitting::StorageTrackExtrap::gpZ_, TrajectoryStateOnSurface::isValid(), ResidualRefitting::StorageTrackExtrap::muonLink_, PV3DBase< T, PVType, FrameType >::phi(), Propagator::propagate(), rho, makeMuonMisalignmentScenario::rot, mathSSE::sqrt(), thePropagator, HLT_2018_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

dumpMuonRecHits()

void ResidualRefitting::dumpMuonRecHits

(

const ResidualRefitting::storage_hit &

hit

)

Definition at line 1200 of file ResidualRefitting.cc.

                                                                               {
  std::cout << "Muon Rec Hits Dump:\n";
  for (unsigned int i = 0; i < (unsigned int)hit.n_; i++) {
    //      double rho = sqrt( (float)hit.gpX_[i] * (float)hit.gpX_[i] + (float)hit.gpY_[i] * (float)hit.gpY_[i]  );
 
    printf("%d\tsubdetector = %d\t superLayer =%d", i, (int)hit.system_[i], (int)hit.superLayer_[i]);
    //      printf ("\tGlobal\tx = %0.3f"           ,       (float)hit.gpX_[i]          );
    //      printf ("\ty = %0.3f"               ,       (float)hit.gpY_[i]          );
    //      printf ("\tz = %0.3f"               ,       (float)hit.gpZ_[i]          );
    //      printf ("\trho =%0.3f"              ,       rho                         );
    //      printf ("\teta = %0.3f"             ,       (float)hit.gpEta_[i]        );
    //      printf ("\tphi = %0.3f\n"           ,       (float)hit.gpPhi_[i]        );
    printf("\t\tLocal\tx = %0.3f", (float)hit.lpX_[i]);
    printf("\ty = %0.3f", (float)hit.lpY_[i]);
    printf("\tz = %0.3f\n", (float)hit.lpZ_[i]);
  }
}

References gather_cfg::cout, mps_fire::i, and createfilelist::int.

dumpTrackExtrap()

void ResidualRefitting::dumpTrackExtrap

(

const ResidualRefitting::storage_trackExtrap &

track

)

Definition at line 1179 of file ResidualRefitting.cc.

                                                                                         {
  std::cout << "\n\nExtrapolation Dump:\n";
  for (unsigned int i = 0; i < (unsigned int)track.n_; i++) {
    //      double rho = sqrt( (float)track.gpX_[i] * (float)track.gpX_[i] + (float)track.gpY_[i] * (float)track.gpY_[i]  );
 
    printf("%d\tmuonLink= %d", i, (int)track.muonLink_[i]);
    printf("\trecLink = %d", (int)track.recLink_[i]);
    //      printf ("\tGlobal\tx = %0.3f"       ,       (float)track.gpX_[i]    );
    //      printf ("\ty = %0.3f"       ,       (float)track.gpY_[i]    );
    //      printf ("\tz = %0.3f"       ,       (float)track.gpZ_[i]    );
    //      printf ("\trho =%0.3f"      ,       rho                     );
    //      printf ("\teta = %0.3f"     ,       (float)track.gpEta_[i]  );
    //      printf ("\tphi = %0.3f"     ,       (float)track.gpPhi_[i]  );
    printf("\t\tLocal\tx = %0.3f", (float)track.lpX_[i]);
    printf("\ty = %0.3f", (float)track.lpY_[i]);
    printf("\tz = %0.3f\n", (float)track.lpZ_[i]);
  }
}

References gather_cfg::cout, mps_fire::i, createfilelist::int, and HLT_2018_cff::track.

dumpTrackHits()

void ResidualRefitting::dumpTrackHits

(

const ResidualRefitting::storage_trackHit &

hit

)

Definition at line 1220 of file ResidualRefitting.cc.

                                                                                  {
  std::cout << "Tracker Rec Hits Dump:\n";
  for (unsigned int i = 0; i < (unsigned int)hit.n_; i++) {
    //      double rho = sqrt( (float)hit.gpX_[i] * (float)hit.gpX_[i] + (float)hit.gpY_[i] * (float)hit.gpY_[i]  );
 
    printf("%d\tsubdetector = %d", i, (int)hit.subdetector_[i]);
    printf("\tlayer = %d", (int)hit.layer_[i]);
    //      printf ("\tGlobal\tx = %0.3f"           ,       (float)hit.gpX_[i]          );
    //      printf ("\ty = %0.3f"               ,       (float)hit.gpY_[i]          );
    //      printf ("\tz = %0.3f"               ,       (float)hit.gpZ_[i]          );
    //      printf ("\trho =%0.3f"              ,       rho                         );
    //      printf ("\teta = %0.3f"             ,       (float)hit.gpEta_[i]        );
    //      printf ("\tphi = %0.3f\n"           ,       (float)hit.gpPhi_[i]        );
    printf("\t\tLocal\tx = %0.3f", (float)hit.lpX_[i]);
    printf("\ty = %0.3f", (float)hit.lpY_[i]);
    printf("\tz = %0.3f\n", (float)hit.lpZ_[i]);
  }
}

References gather_cfg::cout, mps_fire::i, and createfilelist::int.

dumpTrackRef()

void ResidualRefitting::dumpTrackRef	(	reco::TrackRef	muon,
		std::string	str
	)

Definition at line 1241 of file ResidualRefitting.cc.

                                                                     {
  float pt = muon->pt();
  float p = muon->p();
  float eta = muon->eta();
  float phi = muon->phi();
  printf("\t%s: \tp = %4.2f \t pt = %4.2f \t eta = %4.2f \t phi = %4.2f\n", str.c_str(), p, pt, eta, phi);
}

References PVValHelper::eta, AlCaHLTBitMon_ParallelJobs::p, phi, DiDispStaMuonMonitor_cfi::pt, and str.

Referenced by analyze(), and CollectTrackHits().

endJob()

void ResidualRefitting::endJob ( void  )

overridevirtual

Reimplemented from edm::EDAnalyzer.

Definition at line 1150 of file ResidualRefitting.cc.

                               {
  outputFile_->Write();
 
  outputFile_->Close();
}

References outputFile_.

Referenced by o2olib.O2ORunMgr::executeJob().

freeTrajStateMuon()

FreeTrajectoryState ResidualRefitting::freeTrajStateMuon

(

reco::TrackRef

muon

)

Definition at line 1158 of file ResidualRefitting.cc.

                                                                          {
  math::XYZPoint innerPos = muon->referencePoint();
  math::XYZVector innerMom = muon->momentum();
  if (debug_)
    std::cout << "Inner Pos: "
              << "\tx = " << innerPos.X() << "\ty = " << innerPos.Y() << "\tz = " << innerPos.Z() << std::endl;
 
  GlobalPoint innerPoint(innerPos.X(), innerPos.Y(), innerPos.Z());
  GlobalVector innerVec(innerMom.X(), innerMom.Y(), innerMom.Z());
 
  FreeTrajectoryState recoStart(innerPoint, innerVec, muon->charge(), theField);
  return recoStart;
}

References gather_cfg::cout, debug_, and theField.

Referenced by CollectTrackHits(), cylExtrapTrkSam(), and NewTrackMeasurements().

IsSameHit()

bool ResidualRefitting::IsSameHit	(	TrackingRecHit const &	hit1,
		TrackingRecHit const &	hit2
	)

Definition at line 533 of file ResidualRefitting.cc.

                                                                                        {
  double lpx1 = hit1.localPosition().x();
  double lpy1 = hit1.localPosition().y();
  double lpz1 = hit1.localPosition().z();
 
  double lpx2 = hit2.localPosition().x();
  double lpy2 = hit2.localPosition().y();
  double lpz2 = hit2.localPosition().z();
  if (fabs(lpx1 - lpx2) > 1e-3)
    return false;
  //    printf("Match lpx...\n");
  if (fabs(lpy1 - lpy2) > 1e-3)
    return false;
  //    printf("Match lpy...\n");
  if (fabs(lpz1 - lpz2) > 1e-3)
    return false;
  //    printf("Match lpz...\n");
 
  return true;
}

References MillePedeFileConverter_cfg::e, TrackingRecHit::localPosition(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by MatchTrackWithRecHits(), and NewTrackMeasurements().

MatchTrackWithRecHits()

int ResidualRefitting::MatchTrackWithRecHits	(	reco::TrackCollection::const_iterator	trackIt,
		edm::Handle< reco::TrackCollection >	ref
	)

Definition at line 467 of file ResidualRefitting.cc.

                                                                                 {
  if (debug_)
    printf("Matching a re-fitted track to the original track.\n");
 
  int TrackMatch = -1;
 
  for (auto const& rec : trackIt->recHits()) {
    bool foundMatch = false;
    for (reco::TrackCollection::const_iterator refIt = ref->begin(); refIt != ref->end(); refIt++) {
      int iTrackMatch = refIt - ref->begin();
      if (foundMatch && TrackMatch != iTrackMatch)
        break;
      for (auto const& recRef : refIt->recHits()) {
        if (!IsSameHit(*rec, *recRef))
          continue;
 
        foundMatch = true;
        TrackMatch = iTrackMatch;
        //  printf("Rec hit match for original track %d\n", iTrackMatch);
      }
    }
    if (!foundMatch) {
      printf("SOMETHING WENT WRONG! Could not match Track with original track!");
      exit(1);
    }
  }
  if (debug_)
    printf("Rec hit match for original track %d\n", TrackMatch);
 
  //    reco::TrackRef trackref=reco::TrackRef(ref,TrackMatch);
  return TrackMatch;
}

References debug_, beamvalidation::exit(), and IsSameHit().

Referenced by NewTrackMeasurements().

muonInfo()

void ResidualRefitting::muonInfo	(	ResidualRefitting::storage_muon &	storeMuon,
		reco::TrackRef	muon,
		int	val
	)

Definition at line 649 of file ResidualRefitting.cc.

                                                                                                     {
  storeMuon.pt_[val] = muon->pt();
  storeMuon.p_[val] = muon->p();
  storeMuon.eta_[val] = muon->eta();
  storeMuon.phi_[val] = muon->phi();
  storeMuon.charge_[val] = muon->charge();
  storeMuon.numRecHits_[val] = muon->numberOfValidHits();
  storeMuon.chiSq_[val] = muon->chi2();
  storeMuon.ndf_[val] = muon->ndof();
  storeMuon.chiSqOvrNdf_[val] = muon->normalizedChi2();
}

References ResidualRefitting::StorageMuon::charge_, ResidualRefitting::StorageMuon::chiSq_, ResidualRefitting::StorageMuon::chiSqOvrNdf_, ResidualRefitting::StorageMuon::eta_, ResidualRefitting::StorageMuon::ndf_, ResidualRefitting::StorageMuon::numRecHits_, ResidualRefitting::StorageMuon::p_, ResidualRefitting::StorageMuon::phi_, ResidualRefitting::StorageMuon::pt_, and heppy_batch::val.

Referenced by analyze().

NewTrackMeasurements()

void ResidualRefitting::NewTrackMeasurements	(	edm::Handle< reco::TrackCollection >	trackCollOrig,
		edm::Handle< reco::TrackCollection >	trackColl,
		ResidualRefitting::storage_trackExtrap &	trackExtrap
	)

Definition at line 425 of file ResidualRefitting.cc.

                                                                                                {
  int numTracks = 0;
  int recCounter = 0;
 
  for (reco::TrackCollection::const_iterator muon = trackColl->begin(); muon != trackColl->end(); muon++) {
    int iTrack = muon - trackColl->begin();
 
    reco::TrackRef trackref = reco::TrackRef(trackColl, iTrack);
    FreeTrajectoryState recoStart = ResidualRefitting::freeTrajStateMuon(trackref);
 
    int iTrackLink = MatchTrackWithRecHits(muon, trackCollOrig);
    reco::TrackRef ref = reco::TrackRef(trackCollOrig, iTrackLink);
 
    for (auto const& rec1 : ref->recHits()) {
      bool unbiasedRec = true;
 
      for (auto const& rec2 : muon->recHits()) {
        if (IsSameHit(*rec1, *rec2)) {
          unbiasedRec = false;
          break;
        }
      }
      if (!unbiasedRec)
        continue;
 
      DetId detid = rec1->geographicalId();
 
      auto mrhp = MuonTransientTrackingRecHit::specificBuild(
          theService->trackingGeometry()->idToDet(rec1->geographicalId()), rec1);
 
      trkExtrap(detid, numTracks, iTrackLink, recCounter, recoStart, rec1->localPosition(), trackExtrap);
      numTracks++;
    }
  }
 
  trackExtrap.n_ = numTracks;
}

References freeTrajStateMuon(), GlobalTrackingGeometry::idToDet(), IsSameHit(), MatchTrackWithRecHits(), ResidualRefitting::StorageTrackExtrap::n_, MuonTransientTrackingRecHit::specificBuild(), theService, pfDisplacedTrackerVertex_cfi::trackColl, MuonServiceProxy::trackingGeometry(), and trkExtrap().

Referenced by analyze().

omitStation()

void ResidualRefitting::omitStation	(	edm::Handle< reco::MuonCollection >	funcMuons,
		edm::Handle< reco::TrackCollection >	,
		ResidualRefitting::storage_muon &	storeGmr,
		ResidualRefitting::storage_muon &	storeSam,
		ResidualRefitting::storage_trackExtrap &	storeExtrap,
		int	omitStation
	)

omitTrackerSystem()

void ResidualRefitting::omitTrackerSystem	(	edm::Handle< reco::MuonCollection >	trkMuons,
		ResidualRefitting::storage_muon &	storeGmr,
		ResidualRefitting::storage_muon &	storeTrk,
		ResidualRefitting::storage_trackExtrap &	storeExtrap,
		int	omitSystem
	)

ReturnSector()

int ResidualRefitting::ReturnSector

(

DetId

detid

)

Definition at line 763 of file ResidualRefitting.cc.

                                               {
  int sector = -999;
 
  if (detid.det() == DetId::Muon) {
    int systemMuon = detid.subdetId();  // 1 DT; 2 CSC; 3 RPC
    if (systemMuon == MuonSubdetId::DT) {
      DTWireId id(detid.rawId());
      sector = id.sector();
    }
  }
 
  return sector;
}

References DetId::det(), MuonSubdetId::DT, triggerObjects_cff::id, DetId::Muon, DetId::rawId(), and DetId::subdetId().

Referenced by trkExtrap().

ReturnStation()

int ResidualRefitting::ReturnStation

(

DetId

detid

)

Definition at line 739 of file ResidualRefitting.cc.

                                                {
  int station = -999;
 
  if (detid.det() == DetId::Muon) {
    int systemMuon = detid.subdetId();  // 1 DT; 2 CSC; 3 RPC
    if (systemMuon == MuonSubdetId::CSC) {
      CSCDetId id(detid.rawId());
      station = id.station();
 
    } else if (systemMuon == MuonSubdetId::DT) {
      DTWireId id(detid.rawId());
      station = id.station();
 
    } else if (systemMuon == MuonSubdetId::RPC) {
      RPCDetId id(detid.rawId());
      station = id.station();
    }
  }
 
  return station;
}

References MuonSubdetId::CSC, DetId::det(), MuonSubdetId::DT, triggerObjects_cff::id, DetId::Muon, DetId::rawId(), MuonSubdetId::RPC, relativeConstraints::station, and DetId::subdetId().

Referenced by trkExtrap().

StoreTrackerRecHits()

void ResidualRefitting::StoreTrackerRecHits	(	DetId	detid,
		const TrackerTopology *	tTopo,
		int	iTrack,
		int	iRec
	)

Definition at line 557 of file ResidualRefitting.cc.

                                                                                                           {
  int detector = -1;
  int subdetector = -1;
  int blade = -1;
  int disk = -1;
  int ladder = -1;
  int layer = -1;
  int module = -1;
  int panel = -1;
  int ring = -1;
  int side = -1;
  int wheel = -1;
 
  //Detector Info
 
  detector = detid.det();
  subdetector = detid.subdetId();
 
  if (detector != DetId::Tracker) {
    std::cout << "OMFG NOT THE TRACKER\n" << std::endl;
    return;
  }
 
  if (debug_)
    std::cout << "Tracker:: ";
  if (subdetector == ResidualRefitting::PXB) {
    layer = tTopo->pxbLayer(detid.rawId());
    ladder = tTopo->pxbLadder(detid.rawId());
    module = tTopo->pxbModule(detid.rawId());
    if (debug_)
      std::cout << "PXB"
                << "\tlayer = " << layer << "\tladder = " << ladder << "\tmodule = " << module;
 
  } else if (subdetector == ResidualRefitting::PXF) {
    side = tTopo->pxfSide(detid.rawId());
    disk = tTopo->pxfDisk(detid.rawId());
    blade = tTopo->pxfBlade(detid.rawId());
    panel = tTopo->pxfPanel(detid.rawId());
    module = tTopo->pxfModule(detid.rawId());
    if (debug_)
      std::cout << "PXF"
                << "\tside = " << side << "\tdisk = " << disk << "\tblade = " << blade << "\tpanel = " << panel
                << "\tmodule = " << module;
 
  } else if (subdetector == ResidualRefitting::TIB) {
    layer = tTopo->tibLayer(detid.rawId());
    module = tTopo->tibModule(detid.rawId());
    if (debug_)
      std::cout << "TIB"
                << "\tlayer = " << layer << "\tmodule = " << module;
  } else if (subdetector == ResidualRefitting::TID) {
    side = tTopo->tidSide(detid.rawId());
    wheel = tTopo->tidWheel(detid.rawId());
    ring = tTopo->tidRing(detid.rawId());
    if (debug_)
      std::cout << "TID"
                << "\tside = " << side << "\twheel = " << wheel << "\tring = " << ring;
 
  } else if (subdetector == ResidualRefitting::TOB) {
    layer = tTopo->tobLayer(detid.rawId());
    module = tTopo->tobModule(detid.rawId());
    if (debug_)
      std::cout << "TOB"
                << "\tlayer = " << layer << "\tmodule = " << module;
 
  } else if (subdetector == ResidualRefitting::TEC) {
    ring = tTopo->tecRing(detid.rawId());
    module = tTopo->tecModule(detid.rawId());
    if (debug_)
      std::cout << "TEC"
                << "\tring = " << ring << "\tmodule = " << module;
  }
 
  //Do Storage
 
  storageTrackHit_.muonLink_[iRec] = iTrack;
  storageTrackHit_.detector_[iRec] = detector;
  storageTrackHit_.subdetector_[iRec] = subdetector;
  storageTrackHit_.blade_[iRec] = blade;
  storageTrackHit_.disk_[iRec] = disk;
  storageTrackHit_.ladder_[iRec] = ladder;
  storageTrackHit_.layer_[iRec] = layer;
  storageTrackHit_.module_[iRec] = module;
  storageTrackHit_.panel_[iRec] = panel;
  storageTrackHit_.ring_[iRec] = ring;
  storageTrackHit_.side_[iRec] = side;
  storageTrackHit_.wheel_[iRec] = wheel;
}

References ResidualRefitting::StorageTrackHit::blade_, gather_cfg::cout, debug_, DetId::det(), hgcalTestNeighbor_cfi::detector, ResidualRefitting::StorageTrackHit::detector_, ResidualRefitting::StorageTrackHit::disk_, PVValHelper::ladder, ResidualRefitting::StorageTrackHit::ladder_, ResidualRefitting::StorageTrackHit::layer_, ResidualRefitting::StorageTrackHit::module_, ResidualRefitting::StorageTrackHit::muonLink_, ResidualRefitting::StorageTrackHit::panel_, PXB, TrackerTopology::pxbLadder(), TrackerTopology::pxbLayer(), TrackerTopology::pxbModule(), PXF, TrackerTopology::pxfBlade(), TrackerTopology::pxfDisk(), TrackerTopology::pxfModule(), TrackerTopology::pxfPanel(), TrackerTopology::pxfSide(), DetId::rawId(), relativeConstraints::ring, ResidualRefitting::StorageTrackHit::ring_, ResidualRefitting::StorageTrackHit::side_, storageTrackHit_, subdetector, ResidualRefitting::StorageTrackHit::subdetector_, DetId::subdetId(), TEC, TrackerTopology::tecModule(), TrackerTopology::tecRing(), TIB, TrackerTopology::tibLayer(), TrackerTopology::tibModule(), TID, TrackerTopology::tidRing(), TrackerTopology::tidSide(), TrackerTopology::tidWheel(), TOB, TrackerTopology::tobLayer(), TrackerTopology::tobModule(), DetId::Tracker, makeMuonMisalignmentScenario::wheel, and ResidualRefitting::StorageTrackHit::wheel_.

Referenced by CollectTrackHits().

trkExtrap()

void ResidualRefitting::trkExtrap	(	const DetId &	detid,
		int	iTrkLink,
		int	iTrk,
		int	iRec,
		const FreeTrajectoryState &	freeTrajState,
		const LocalPoint &	recPoint,
		storage_trackExtrap &	storeTemp
	)

Definition at line 663 of file ResidualRefitting.cc.

                                                                  {
  bool dump_ = debug_;
 
  if (dump_)
    std::cout << "In the trkExtrap function" << std::endl;
 
  float gpExtrapX = -99999;
  float gpExtrapY = -99999;
  float gpExtrapZ = -99999;
  float gpExtrapEta = -99999;
  float gpExtrapPhi = -99999;
 
  float lpX = -99999;
  float lpY = -99999;
  float lpZ = -99999;
 
  //
  // Get the local positions for the recHits
  //
 
  float recLpX = recPoint.x();
  float recLpY = recPoint.y();
  float recLpZ = recPoint.z();
 
  float resX = -9999;
  float resY = -9999;
  float resZ = -9999;
 
  const GeomDet* gdet = theService->trackingGeometry()->idToDet(detid);
 
  //    TrajectoryStateOnSurface surfTest =  prop.propagate(freeTrajState, gdet->surface());
  TrajectoryStateOnSurface surfTest = thePropagator->propagate(freeTrajState, gdet->surface());
 
  if (surfTest.isValid()) {
    GlobalPoint globTest = surfTest.globalPosition();
    gpExtrapX = globTest.x();
    gpExtrapY = globTest.y();
    gpExtrapZ = globTest.z();
    gpExtrapEta = globTest.eta();
    gpExtrapPhi = globTest.phi();
    LocalPoint loc = surfTest.localPosition();
    if (detid.det() == DetId::Muon || detid.det() == DetId::Tracker) {
      lpX = loc.x();
      lpY = loc.y();
      lpZ = loc.z();
 
      resX = lpX - recLpX;
      resY = lpY - recLpY;
      resZ = lpZ - recLpZ;
    }
  }
  storeTemp.muonLink_[iTrk] = iTrkLink;
  storeTemp.recLink_[iTrk] = iRec;
  storeTemp.gpX_[iTrk] = gpExtrapX;
  storeTemp.gpY_[iTrk] = gpExtrapY;
  storeTemp.gpZ_[iTrk] = gpExtrapZ;
  storeTemp.gpEta_[iTrk] = gpExtrapEta;
  storeTemp.gpPhi_[iTrk] = gpExtrapPhi;
  storeTemp.lpX_[iTrk] = lpX;
  storeTemp.lpY_[iTrk] = lpY;
  storeTemp.lpZ_[iTrk] = lpZ;
  storeTemp.resX_[iTrk] = resX;
  storeTemp.resY_[iTrk] = resY;
  storeTemp.resZ_[iTrk] = resZ;
 
  printf("station: %d\tsector: %d\tresX storage: %4.2f\n", ReturnStation(detid), ReturnSector(detid), resX);
}

References gather_cfg::cout, debug_, DetId::det(), PV3DBase< T, PVType, FrameType >::eta(), TrajectoryStateOnSurface::globalPosition(), ResidualRefitting::StorageTrackExtrap::gpEta_, ResidualRefitting::StorageTrackExtrap::gpPhi_, ResidualRefitting::StorageTrackExtrap::gpX_, ResidualRefitting::StorageTrackExtrap::gpY_, ResidualRefitting::StorageTrackExtrap::gpZ_, GlobalTrackingGeometry::idToDet(), TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localPosition(), ResidualRefitting::StorageTrackExtrap::lpX_, ResidualRefitting::StorageTrackExtrap::lpY_, ResidualRefitting::StorageTrackExtrap::lpZ_, DetId::Muon, ResidualRefitting::StorageTrackExtrap::muonLink_, PV3DBase< T, PVType, FrameType >::phi(), Propagator::propagate(), ResidualRefitting::StorageTrackExtrap::recLink_, ResidualRefitting::StorageTrackExtrap::resX_, ResidualRefitting::StorageTrackExtrap::resY_, ResidualRefitting::StorageTrackExtrap::resZ_, ReturnSector(), ReturnStation(), GeomDet::surface(), thePropagator, theService, DetId::Tracker, MuonServiceProxy::trackingGeometry(), PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by CollectTrackHits(), and NewTrackMeasurements().

zero_muon()

void ResidualRefitting::zero_muon

(

ResidualRefitting::storage_muon *

str

)

Definition at line 928 of file ResidualRefitting.cc.

                                                                    {
  str->n_ = 0;
 
  for (int i = 0; i < ResidualRefitting::N_MAX_STORED; i++) {
    str->pt_[i] = -9999;
    str->eta_[i] = -9999;
    str->p_[i] = -9999;
    str->phi_[i] = -9999;
    str->numRecHits_[i] = -9999;
    str->chiSq_[i] = -9999;
    str->ndf_[i] = -9999;
    str->chiSqOvrNdf_[i] = -9999;
  }
}

References mps_fire::i, N_MAX_STORED, and str.

Referenced by zero_storage().

zero_storage()

void ResidualRefitting::zero_storage

(

)

Definition at line 828 of file ResidualRefitting.cc.

                                     {
  if (debug_)
    printf("zero_storage\n");
 
  zero_muon(&storageGmrOld_);
  zero_muon(&storageGmrNew_);
  zero_muon(&storageSamNew_);
  zero_muon(&storageTrkNew_);
  zero_muon(&storageGmrNoSt1_);
  zero_muon(&storageSamNoSt1_);
  zero_muon(&storageGmrNoSt2_);
  zero_muon(&storageSamNoSt2_);
  zero_muon(&storageGmrNoSt3_);
  zero_muon(&storageSamNoSt3_);
  zero_muon(&storageGmrNoSt4_);
  zero_muon(&storageSamNoSt4_);
  //zero out the tracker
  zero_muon(&storageGmrNoPXBLayer1);
  zero_muon(&storageGmrNoPXBLayer2);
  zero_muon(&storageGmrNoPXBLayer3);
 
  zero_muon(&storageGmrNoPXF);
 
  zero_muon(&storageGmrNoTIBLayer1);
  zero_muon(&storageGmrNoTIBLayer2);
  zero_muon(&storageGmrNoTIBLayer3);
  zero_muon(&storageGmrNoTIBLayer4);
 
  zero_muon(&storageGmrNoTID);
 
  zero_muon(&storageGmrNoTOBLayer1);
  zero_muon(&storageGmrNoTOBLayer2);
  zero_muon(&storageGmrNoTOBLayer3);
  zero_muon(&storageGmrNoTOBLayer4);
  zero_muon(&storageGmrNoTOBLayer5);
  zero_muon(&storageGmrNoTOBLayer6);
 
  zero_muon(&storageGmrNoTEC);
 
  zero_muon(&storageTrkNoPXBLayer1);
  zero_muon(&storageTrkNoPXBLayer2);
  zero_muon(&storageTrkNoPXBLayer3);
 
  zero_muon(&storageTrkNoPXF);
 
  zero_muon(&storageTrkNoTIBLayer1);
  zero_muon(&storageTrkNoTIBLayer2);
  zero_muon(&storageTrkNoTIBLayer3);
  zero_muon(&storageTrkNoTIBLayer4);
 
  zero_muon(&storageTrkNoTID);
 
  zero_muon(&storageTrkNoTOBLayer1);
  zero_muon(&storageTrkNoTOBLayer2);
  zero_muon(&storageTrkNoTOBLayer3);
  zero_muon(&storageTrkNoTOBLayer4);
  zero_muon(&storageTrkNoTOBLayer5);
  zero_muon(&storageTrkNoTOBLayer6);
 
  zero_muon(&storageTrkNoTEC);
 
  zero_trackExtrap(&storageTrackExtrapRec_);
  zero_trackExtrap(&storageTrackExtrapTracker_);
  zero_trackExtrap(&storageTrackExtrapRecNoSt1_);
  zero_trackExtrap(&storageTrackExtrapRecNoSt2_);
  zero_trackExtrap(&storageTrackExtrapRecNoSt3_);
  zero_trackExtrap(&storageTrackExtrapRecNoSt4_);
 
  zero_trackExtrap(&trackExtrap120_);
 
  zero_trackExtrap(&samExtrap120_);
 
  zero_trackExtrap(&storageTrackNoPXBLayer1);
  zero_trackExtrap(&storageTrackNoPXBLayer2);
  zero_trackExtrap(&storageTrackNoPXBLayer3);
 
  zero_trackExtrap(&storageTrackNoPXF);
 
  zero_trackExtrap(&storageTrackNoTIBLayer1);
  zero_trackExtrap(&storageTrackNoTIBLayer2);
  zero_trackExtrap(&storageTrackNoTIBLayer3);
  zero_trackExtrap(&storageTrackNoTIBLayer4);
 
  zero_trackExtrap(&storageTrackNoTOBLayer1);
  zero_trackExtrap(&storageTrackNoTOBLayer2);
  zero_trackExtrap(&storageTrackNoTOBLayer3);
  zero_trackExtrap(&storageTrackNoTOBLayer4);
  zero_trackExtrap(&storageTrackNoTOBLayer5);
  zero_trackExtrap(&storageTrackNoTOBLayer6);
 
  zero_trackExtrap(&storageTrackNoTEC);
 
  zero_trackExtrap(&storageTrackNoTID);
 
  storageRecMuon_.n_ = 0;
  storageTrackHit_.n_ = 0;
}

References debug_, ResidualRefitting::StorageHit::n_, ResidualRefitting::StorageTrackHit::n_, samExtrap120_, storageGmrNew_, storageGmrNoPXBLayer1, storageGmrNoPXBLayer2, storageGmrNoPXBLayer3, storageGmrNoPXF, storageGmrNoSt1_, storageGmrNoSt2_, storageGmrNoSt3_, storageGmrNoSt4_, storageGmrNoTEC, storageGmrNoTIBLayer1, storageGmrNoTIBLayer2, storageGmrNoTIBLayer3, storageGmrNoTIBLayer4, storageGmrNoTID, storageGmrNoTOBLayer1, storageGmrNoTOBLayer2, storageGmrNoTOBLayer3, storageGmrNoTOBLayer4, storageGmrNoTOBLayer5, storageGmrNoTOBLayer6, storageGmrOld_, storageRecMuon_, storageSamNew_, storageSamNoSt1_, storageSamNoSt2_, storageSamNoSt3_, storageSamNoSt4_, storageTrackExtrapRec_, storageTrackExtrapRecNoSt1_, storageTrackExtrapRecNoSt2_, storageTrackExtrapRecNoSt3_, storageTrackExtrapRecNoSt4_, storageTrackExtrapTracker_, storageTrackHit_, storageTrackNoPXBLayer1, storageTrackNoPXBLayer2, storageTrackNoPXBLayer3, storageTrackNoPXF, storageTrackNoTEC, storageTrackNoTIBLayer1, storageTrackNoTIBLayer2, storageTrackNoTIBLayer3, storageTrackNoTIBLayer4, storageTrackNoTID, storageTrackNoTOBLayer1, storageTrackNoTOBLayer2, storageTrackNoTOBLayer3, storageTrackNoTOBLayer4, storageTrackNoTOBLayer5, storageTrackNoTOBLayer6, storageTrkNew_, storageTrkNoPXBLayer1, storageTrkNoPXBLayer2, storageTrkNoPXBLayer3, storageTrkNoPXF, storageTrkNoTEC, storageTrkNoTIBLayer1, storageTrkNoTIBLayer2, storageTrkNoTIBLayer3, storageTrkNoTIBLayer4, storageTrkNoTID, storageTrkNoTOBLayer1, storageTrkNoTOBLayer2, storageTrkNoTOBLayer3, storageTrkNoTOBLayer4, storageTrkNoTOBLayer5, storageTrkNoTOBLayer6, trackExtrap120_, zero_muon(), and zero_trackExtrap().

Referenced by analyze().

zero_trackExtrap()

void ResidualRefitting::zero_trackExtrap

(

ResidualRefitting::storage_trackExtrap *

str

)

Definition at line 945 of file ResidualRefitting.cc.

                                                                                  {
  str->n_ = 0;
  for (int i = 0; i < ResidualRefitting::N_MAX_STORED_HIT; i++) {
    str->muonLink_[i] = -9999;
    str->recLink_[i] = -9999;
    str->gpX_[i] = -9999;
    str->gpY_[i] = -9999;
    str->gpZ_[i] = -9999;
    str->gpEta_[i] = -9999;
    str->gpPhi_[i] = -9999;
    str->lpX_[i] = -9999;
    str->lpY_[i] = -9999;
    str->lpZ_[i] = -9999;
    str->resX_[i] = -9999;
    str->resY_[i] = -9999;
    str->resZ_[i] = -9999;
  }
}

References mps_fire::i, N_MAX_STORED_HIT, and str.

Referenced by zero_storage().

Member Data Documentation

debug_

bool ResidualRefitting::debug_

Definition at line 337 of file ResidualRefitting.h.

Referenced by analyze(), CollectTrackHits(), cylExtrapTrkSam(), freeTrajStateMuon(), MatchTrackWithRecHits(), StoreTrackerRecHits(), trkExtrap(), and zero_storage().

eventInfo_

ResidualRefitting::storage_event ResidualRefitting::eventInfo_

Definition at line 59 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and ResidualRefitting().

muons_

edm::InputTag ResidualRefitting::muons_

Definition at line 330 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoPXBLayer1_

edm::InputTag ResidualRefitting::muonsNoPXBLayer1_

Definition at line 330 of file ResidualRefitting.h.

muonsNoPXBLayer2_

edm::InputTag ResidualRefitting::muonsNoPXBLayer2_

Definition at line 330 of file ResidualRefitting.h.

muonsNoPXBLayer3_

edm::InputTag ResidualRefitting::muonsNoPXBLayer3_

Definition at line 330 of file ResidualRefitting.h.

muonsNoPXF_

edm::InputTag ResidualRefitting::muonsNoPXF_

Definition at line 330 of file ResidualRefitting.h.

muonsNoStation1_

edm::InputTag ResidualRefitting::muonsNoStation1_

Definition at line 330 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoStation2_

edm::InputTag ResidualRefitting::muonsNoStation2_

Definition at line 330 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoStation3_

edm::InputTag ResidualRefitting::muonsNoStation3_

Definition at line 330 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoStation4_

edm::InputTag ResidualRefitting::muonsNoStation4_

Definition at line 330 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoTEC_

edm::InputTag ResidualRefitting::muonsNoTEC_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTIBLayer1_

edm::InputTag ResidualRefitting::muonsNoTIBLayer1_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTIBLayer2_

edm::InputTag ResidualRefitting::muonsNoTIBLayer2_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTIBLayer3_

edm::InputTag ResidualRefitting::muonsNoTIBLayer3_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTIBLayer4_

edm::InputTag ResidualRefitting::muonsNoTIBLayer4_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTID_

edm::InputTag ResidualRefitting::muonsNoTID_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTOBLayer1_

edm::InputTag ResidualRefitting::muonsNoTOBLayer1_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTOBLayer2_

edm::InputTag ResidualRefitting::muonsNoTOBLayer2_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTOBLayer3_

edm::InputTag ResidualRefitting::muonsNoTOBLayer3_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTOBLayer4_

edm::InputTag ResidualRefitting::muonsNoTOBLayer4_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTOBLayer5_

edm::InputTag ResidualRefitting::muonsNoTOBLayer5_

Definition at line 330 of file ResidualRefitting.h.

muonsNoTOBLayer6_

edm::InputTag ResidualRefitting::muonsNoTOBLayer6_

Definition at line 330 of file ResidualRefitting.h.

muonsRemake_

edm::InputTag ResidualRefitting::muonsRemake_

Definition at line 330 of file ResidualRefitting.h.

Referenced by analyze().

N_MAX_STORED

const int ResidualRefitting::N_MAX_STORED = 10

staticprivate

Definition at line 40 of file ResidualRefitting.h.

Referenced by analyze(), ResidualRefitting::StorageMuon::StorageMuon(), and zero_muon().

N_MAX_STORED_HIT

const int ResidualRefitting::N_MAX_STORED_HIT = 1000

staticprivate

Definition at line 41 of file ResidualRefitting.h.

Referenced by ResidualRefitting::StorageHit::StorageHit(), ResidualRefitting::StorageTrackExtrap::StorageTrackExtrap(), ResidualRefitting::StorageTrackHit::StorageTrackHit(), and zero_trackExtrap().

outputBranch_

TBranch* ResidualRefitting::outputBranch_

Definition at line 343 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), branchMuon(), and branchTrackExtrap().

outputFile_

TFile* ResidualRefitting::outputFile_

Definition at line 340 of file ResidualRefitting.h.

Referenced by beginJob(), endJob(), and ~ResidualRefitting().

outputFileName_

std::string ResidualRefitting::outputFileName_

Definition at line 325 of file ResidualRefitting.h.

Referenced by beginJob().

outputTree_

TTree* ResidualRefitting::outputTree_

Definition at line 342 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), branchMuon(), and branchTrackExtrap().

PropagatorSource_

std::string ResidualRefitting::PropagatorSource_

Definition at line 327 of file ResidualRefitting.h.

Referenced by analyze().

PXB

const int ResidualRefitting::PXB = 1

staticprivate

Definition at line 43 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

PXF

const int ResidualRefitting::PXF = 2

staticprivate

Definition at line 44 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

samExtrap120_

ResidualRefitting::storage_trackExtrap ResidualRefitting::samExtrap120_

Definition at line 248 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageGmrNew_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNew_

Definition at line 224 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageGmrNoPXBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer1

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoPXBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer2

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoPXBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer3

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoPXF

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXF

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt1_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt1_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt2_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt2_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt3_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt3_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt4_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt4_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTEC

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTEC

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer1

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer2

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer3

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer4

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTID

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTID

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer1

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer2

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer3

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer4

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer5

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer5

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer6

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer6

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrOld_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrOld_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageRecMuon_

ResidualRefitting::storage_hit ResidualRefitting::storageRecMuon_

Definition at line 240 of file ResidualRefitting.h.

Referenced by beginJob(), CollectTrackHits(), and zero_storage().

storageSamNew_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNew_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt1_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt1_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt2_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt2_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt3_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt3_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt4_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt4_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackExtrapRec_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRec_

Definition at line 244 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageTrackExtrapRecNoSt1_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt1_

Definition at line 244 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageTrackExtrapRecNoSt2_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt2_

Definition at line 244 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageTrackExtrapRecNoSt3_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt3_

Definition at line 244 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageTrackExtrapRecNoSt4_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt4_

Definition at line 244 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

storageTrackExtrapTracker_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapTracker_

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackHit_

ResidualRefitting::storage_trackHit ResidualRefitting::storageTrackHit_

Definition at line 241 of file ResidualRefitting.h.

Referenced by beginJob(), CollectTrackHits(), StoreTrackerRecHits(), and zero_storage().

storageTrackNoPXBLayer1

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer1

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoPXBLayer2

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer2

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoPXBLayer3

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer3

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoPXF

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXF

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTEC

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTEC

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer1

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer1

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer2

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer2

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer3

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer3

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer4

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer4

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTID

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTID

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer1

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer1

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer2

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer2

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer3

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer3

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer4

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer4

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer5

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer5

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer6

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer6

Definition at line 251 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNew_

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNew_

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer1

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer2

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer3

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXF

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXF

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTEC

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTEC

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer1

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer2

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer3

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer4

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTID

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTID

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer1

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer2

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer3

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer4

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer5

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer5

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer6

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer6

Definition at line 224 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

TEC

const int ResidualRefitting::TEC = 6

staticprivate

Definition at line 48 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

theField

const MagneticField* ResidualRefitting::theField

Definition at line 347 of file ResidualRefitting.h.

Referenced by analyze(), and freeTrajStateMuon().

thePropagator

edm::ESHandle<Propagator> ResidualRefitting::thePropagator

Definition at line 350 of file ResidualRefitting.h.

Referenced by analyze(), cylExtrapTrkSam(), and trkExtrap().

theService

MuonServiceProxy* ResidualRefitting::theService

Definition at line 349 of file ResidualRefitting.h.

Referenced by analyze(), CollectTrackHits(), NewTrackMeasurements(), ResidualRefitting(), trkExtrap(), and ~ResidualRefitting().

TIB

const int ResidualRefitting::TIB = 3

staticprivate

Definition at line 45 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

TID

const int ResidualRefitting::TID = 4

staticprivate

Definition at line 46 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

TOB

const int ResidualRefitting::TOB = 5

staticprivate

Definition at line 47 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

trackExtrap120_

ResidualRefitting::storage_trackExtrap ResidualRefitting::trackExtrap120_

Definition at line 248 of file ResidualRefitting.h.

Referenced by analyze(), beginJob(), and zero_storage().

trackingGeometry

const edm::ESHandle<GlobalTrackingGeometry> ResidualRefitting::trackingGeometry

Definition at line 348 of file ResidualRefitting.h.

tracks_

edm::InputTag ResidualRefitting::tracks_

Definition at line 330 of file ResidualRefitting.h.