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::one::EDAnalyzerBase
typedef EDAnalyzerBase	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 (const edm::Handle< reco::TrackCollection > &trackCollOrig, const 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::one::EDAnalyzer<>
	EDAnalyzer ()=default
	EDAnalyzer (const EDAnalyzer &)=delete
SerialTaskQueue *	globalLuminosityBlocksQueue () final
SerialTaskQueue *	globalRunsQueue () final
const EDAnalyzer &	operator= (const EDAnalyzer &)=delete
bool	wantsGlobalLuminosityBlocks () const final
bool	wantsGlobalRuns () const final
bool	wantsInputProcessBlocks () const final
bool	wantsProcessBlocks () const final
Public Member Functions inherited from edm::one::EDAnalyzerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)
	EDAnalyzerBase ()
ModuleDescription const &	moduleDescription () const
bool	wantsStreamLuminosityBlocks () const
bool	wantsStreamRuns () const
	~EDAnalyzerBase () 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 const &)=delete
	EDConsumerBase (EDConsumerBase &&)=default
ESResolverIndex const *	esGetTokenIndices (edm::Transition iTrans) const
std::vector< ESResolverIndex > const &	esGetTokenIndicesVector (edm::Transition iTrans) const
std::vector< ESRecordIndex > const &	esGetTokenRecordIndicesVector (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::array< std::vector< ModuleDescription const *> *, NumBranchTypes > &modulesAll, std::vector< ModuleProcessName > &modulesInPreviousProcesses, ProductRegistry const &preg, std::map< std::string, ModuleDescription const *> const &labelsToDesc, std::string const &processName) const
EDConsumerBase const &	operator= (EDConsumerBase const &)=delete
EDConsumerBase &	operator= (EDConsumerBase &&)=default
bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const
void	selectInputProcessBlocks (ProductRegistry const &productRegistry, ProcessBlockHelperBase const &processBlockHelperBase)
ProductResolverIndexAndSkipBit	uncheckedIndexFrom (EDGetToken) const
void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)
void	updateLookup (eventsetup::ESRecordsToProductResolverIndices const &)
virtual	~EDConsumerBase () noexcept(false)

Static Public Member Functions
static void	fillDescriptions (edm::ConfigurationDescriptions &descriptions)
Static Public Member Functions inherited from edm::one::EDAnalyzerBase
static const std::string &	baseType ()
static void	fillDescriptions (ConfigurationDescriptions &descriptions)
static void	prevalidate (ConfigurationDescriptions &descriptions)

Public Attributes
const bool	debug_
ResidualRefitting::storage_event	eventInfo_
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magFieldToken_
const edm::InputTag	muons_
const edm::EDGetTokenT< reco::TrackCollection >	muonsNoSt1Token_
const edm::EDGetTokenT< reco::TrackCollection >	muonsNoSt2Token_
const edm::EDGetTokenT< reco::TrackCollection >	muonsNoSt3Token_
const edm::EDGetTokenT< reco::TrackCollection >	muonsNoSt4Token_
const edm::InputTag	muonsNoStation1_
const edm::InputTag	muonsNoStation2_
const edm::InputTag	muonsNoStation3_
const edm::InputTag	muonsNoStation4_
const edm::InputTag	muonsRemake_
const edm::EDGetTokenT< reco::MuonCollection >	muonsToken_
const edm::EDGetTokenT< reco::TrackCollection >	muonTracksToken_
TBranch *	outputBranch_
TFile *	outputFile_
std::string	outputFileName_
TTree *	outputTree_
std::string	PropagatorSource_
const edm::ESGetToken< Propagator, TrackingComponentsRecord >	propagatorToken_
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
const edm::ESGetToken< TrackerTopology, TrackerTopologyRcd >	topoToken_
ResidualRefitting::storage_trackExtrap	trackExtrap120_
const edm::ESHandle< GlobalTrackingGeometry >	trackingGeometry
const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	trackingGeometryToken_
const 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
Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)
template<BranchType B = InEvent>
EDConsumerBaseAdaptor< B >	consumes (edm::InputTag tag) noexcept
EDGetToken	consumes (const TypeToGet &id, 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 ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes ()
template<typename ESProduct , typename ESRecord , Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag const &tag)
template<Transition Tr = Transition::Event>
constexpr auto	esConsumes ()
template<Transition Tr = Transition::Event>
auto	esConsumes (ESInputTag tag)
template<Transition Tr = Transition::Event>
ESGetTokenGeneric	esConsumes (eventsetup::EventSetupRecordKey const &iRecord, eventsetup::DataKey const &iKey)
	Used with EventSetupRecord::doGet. More...
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)
void	resetItemsToGetFrom (BranchType iType)

Detailed Description

Definition at line 33 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 36 of file ResidualRefitting.cc.

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

    : magFieldToken_(esConsumes()),
      topoToken_(esConsumes()),
      trackingGeometryToken_(esConsumes()),
      propagatorToken_(esConsumes(edm::ESInputTag("", cfg.getParameter<std::string>("propagator")))),
      outputFileName_(cfg.getUntrackedParameter<std::string>("histoutputFile")),
      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")),
      debug_(cfg.getUntrackedParameter<bool>("doDebug")),
      muonsToken_(consumes<reco::MuonCollection>(muons_)),
      muonTracksToken_(consumes<reco::TrackCollection>(muonsRemake_)),
      muonsNoSt1Token_(consumes<reco::TrackCollection>(muonsNoStation1_)),
      muonsNoSt2Token_(consumes<reco::TrackCollection>(muonsNoStation2_)),
      muonsNoSt3Token_(consumes<reco::TrackCollection>(muonsNoStation3_)),
      muonsNoSt4Token_(consumes<reco::TrackCollection>(muonsNoStation4_)),
      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

~ResidualRefitting()

ResidualRefitting::~ResidualRefitting ( )

override

Definition at line 198 of file ResidualRefitting.cc.

References outputFile_, and theService.

                                      {
  delete outputFile_;
  delete theService;
}

Member Function Documentation

analyze()

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

overridevirtual

Implements edm::one::EDAnalyzerBase.

Definition at line 82 of file ResidualRefitting.cc.

References CollectTrackHits(), cylExtrapTrkSam(), debug_, dumpTrackRef(), eventInfo_, options_cfi::eventSetup, ResidualRefitting::storage_event::evtNum_, createfilelist::int, magFieldToken_, muonInfo(), PDWG_BPHSkim_cff::muons, muonsNoSt1Token_, muonsNoSt2Token_, muonsNoSt3Token_, muonsNoSt4Token_, muonsToken_, TrackingDataMCValidation_Standalone_cff::muonTracks, muonTracksToken_, ResidualRefitting::StorageMuon::n_, ResidualRefitting::StorageTrackExtrap::n_, N_MAX_STORED, NewTrackMeasurements(), outputBranch_, outputTree_, propagatorToken_, ResidualRefitting::storage_event::runNum_, samExtrap120_, storageGmrNew_, storageTrackExtrapRec_, storageTrackExtrapRecNoSt1_, storageTrackExtrapRecNoSt2_, storageTrackExtrapRecNoSt3_, storageTrackExtrapRecNoSt4_, theField, thePropagator, theService, trackExtrap120_, trackingGeometryToken_, MuonServiceProxy::update(), and zero_storage().

                                                                                      {
  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
  const edm::Handle<reco::MuonCollection>& muons = event.getHandle(muonsToken_);
  const edm::Handle<reco::TrackCollection>& muonTracks = event.getHandle(muonTracksToken_);
  const edm::Handle<reco::TrackCollection>& muonsNoSt1 = event.getHandle(muonsNoSt1Token_);
  const edm::Handle<reco::TrackCollection>& muonsNoSt2 = event.getHandle(muonsNoSt2Token_);
  const edm::Handle<reco::TrackCollection>& muonsNoSt3 = event.getHandle(muonsNoSt3Token_);
  const edm::Handle<reco::TrackCollection>& muonsNoSt4 = event.getHandle(muonsNoSt4Token_);

  //magnetic field information
  theField = &eventSetup.getData(magFieldToken_);
  edm::ESHandle<GlobalTrackingGeometry> globalTrackingGeometry = eventSetup.getHandle(trackingGeometryToken_);
  thePropagator = eventSetup.getHandle(propagatorToken_);
  theService->update(eventSetup);

  //Zero storage
  zero_storage();

  //Do the Gmr Muons from the unModified Collection

  //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();
    edm::LogVerbatim("ResidualRefitting") << "FILLING NTUPLE!";
    edm::LogVerbatim("ResidualRefitting")
        << "Entries Recorded: " << outputTree_->GetEntries() << " Branch :: " << outputBranch_->GetEntries();
  } else
    edm::LogVerbatim("ResidualRefitting") << "no tracks -- no fill!\n";

  //  /*************************************************************************************************************/
  //  //END OF ntuple dumper
  //  //END OF ntuple dumper
  //  /***********************************************************************************************************/
}

beginJob()

void ResidualRefitting::beginJob ( )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 902 of file ResidualRefitting.cc.

References branchMuon(), branchTrackExtrap(), 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_.

                                 {
  edm::LogVerbatim("ResidualRefitting") << "Creating file " << outputFileName_.c_str();

  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");
}

branchMuon()

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

Definition at line 1044 of file ResidualRefitting.cc.

References electrons_cff::branchName, outputBranch_, and outputTree_.

Referenced by beginJob().

                                                                                                  {
  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"

  );
}

branchTrackExtrap()

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

Definition at line 1063 of file ResidualRefitting.cc.

References electrons_cff::branchName, outputBranch_, and outputTree_.

Referenced by beginJob().

                                                                                                                {
  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"

  );
}

CollectTrackHits()

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

Definition at line 205 of file ResidualRefitting.cc.

References relativeConstraints::chamber, ResidualRefitting::StorageHit::chamber_, MuonSubdetId::CSC, debug_, DetId::det(), MuonSubdetId::DT, dumpTrackRef(), makeMuonMisalignmentScenario::endcap, ResidualRefitting::StorageHit::endcap_, options_cfi::eventSetup, freeTrajStateMuon(), 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_, l1ctLayer2EG_cff::id, GlobalTrackingGeometry::idToDet(), nano_mu_digi_cff::layer, 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_, DetId::rawId(), relativeConstraints::ring, ResidualRefitting::StorageHit::ring_, MuonSubdetId::RPC, nano_mu_digi_cff::sector, ResidualRefitting::StorageHit::sector_, MuonTransientTrackingRecHit::specificBuild(), relativeConstraints::station, ResidualRefitting::StorageHit::station_, storageRecMuon_, storageTrackHit_, StoreTrackerRecHits(), DetId::subdetId(), nano_mu_digi_cff::superLayer, ResidualRefitting::StorageHit::superLayer_, ResidualRefitting::StorageHit::system_, theService, topoToken_, 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().

                                                                          {
  //Retrieve tracker topology from geometry
  const TrackerTopology* const tTopo = &eventSetup.getData(topoToken_);

  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;
}

cylExtrapTrkSam()

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

Definition at line 716 of file ResidualRefitting.cc.

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_2023v12_cff::track, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

                                                    {
  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);
}

dumpMuonRecHits()

void ResidualRefitting::dumpMuonRecHits

(

const ResidualRefitting::storage_hit &

hit

)

Definition at line 1137 of file ResidualRefitting.cc.

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

                                                                               {
  edm::LogVerbatim("ResidualRefitting") << "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]);
  }
}

dumpTrackExtrap()

void ResidualRefitting::dumpTrackExtrap

(

const ResidualRefitting::storage_trackExtrap &

track

)

Definition at line 1116 of file ResidualRefitting.cc.

References mps_fire::i, createfilelist::int, and HLT_2023v12_cff::track.

                                                                                         {
  edm::LogVerbatim("ResidualRefitting") << "\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]);
  }
}

dumpTrackHits()

void ResidualRefitting::dumpTrackHits

(

const ResidualRefitting::storage_trackHit &

hit

)

Definition at line 1157 of file ResidualRefitting.cc.

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

                                                                                  {
  edm::LogVerbatim("ResidualRefitting") << "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]);
  }
}

dumpTrackRef()

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

Definition at line 1178 of file ResidualRefitting.cc.

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

Referenced by analyze(), and CollectTrackHits().

                                                                     {
  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);
}

endJob()

void ResidualRefitting::endJob ( void  )

overridevirtual

Reimplemented from edm::one::EDAnalyzerBase.

Definition at line 1086 of file ResidualRefitting.cc.

References outputFile_.

Referenced by o2olib.O2ORunMgr::executeJob().

                               {
  outputFile_->Write();

  outputFile_->Close();
}

fillDescriptions()

void ResidualRefitting::fillDescriptions ( edm::ConfigurationDescriptions &  descriptions )

static

Definition at line 69 of file ResidualRefitting.cc.

References edm::ConfigurationDescriptions::add(), submitPVResolutionJobs::desc, ProducerED_cfi::InputTag, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                   {
  edm::ParameterSetDescription desc;
  desc.add<edm::InputTag>("muons", edm::InputTag("muons"));
  desc.add<edm::InputTag>("muonsRemake", edm::InputTag("globalMuons"));
  desc.add<edm::InputTag>("muonsNoStation1", edm::InputTag("muonsNoSt1"));
  desc.add<edm::InputTag>("muonsNoStation2", edm::InputTag("muonsNoSt2"));
  desc.add<edm::InputTag>("muonsNoStation3", edm::InputTag("muonsNoSt3"));
  desc.add<edm::InputTag>("muonsNoStation4", edm::InputTag("muonsNoSt4"));
  desc.addUntracked<std::string>("histoutputFile", "histFile.root");
  desc.addUntracked<bool>("doDebug", false);
  descriptions.add("residualRefitting", desc);
}

freeTrajStateMuon()

FreeTrajectoryState ResidualRefitting::freeTrajStateMuon

(

reco::TrackRef

muon

)

Definition at line 1094 of file ResidualRefitting.cc.

References debug_, and theField.

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

                                                                          {
  math::XYZPoint innerPos = muon->referencePoint();
  math::XYZVector innerMom = muon->momentum();
  if (debug_)
    edm::LogVerbatim("ResidualRefitting")
        << "Inner Pos: "
        << "\tx = " << innerPos.X() << "\ty = " << innerPos.Y() << "\tz = " << innerPos.Z();

  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;
}

IsSameHit()

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

Definition at line 468 of file ResidualRefitting.cc.

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().

                                                                                        {
  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;
}

MatchTrackWithRecHits()

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

Definition at line 402 of file ResidualRefitting.cc.

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

Referenced by NewTrackMeasurements().

                                                                                 {
  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;
}

muonInfo()

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

Definition at line 585 of file ResidualRefitting.cc.

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().

                                                                                                     {
  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();
}

NewTrackMeasurements()

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

Definition at line 360 of file ResidualRefitting.cc.

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

Referenced by analyze().

                                                                                                {
  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;
}

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 699 of file ResidualRefitting.cc.

References DetId::det(), MuonSubdetId::DT, l1ctLayer2EG_cff::id, DetId::Muon, DetId::rawId(), nano_mu_digi_cff::sector, and DetId::subdetId().

Referenced by trkExtrap().

                                               {
  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;
}

ReturnStation()

int ResidualRefitting::ReturnStation

(

DetId

detid

)

Definition at line 675 of file ResidualRefitting.cc.

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

Referenced by trkExtrap().

                                                {
  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;
}

StoreTrackerRecHits()

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

Definition at line 492 of file ResidualRefitting.cc.

References ResidualRefitting::StorageTrackHit::blade_, debug_, DetId::det(), hgcalTestNeighbor_cfi::detector, ResidualRefitting::StorageTrackHit::detector_, ResidualRefitting::StorageTrackHit::disk_, PVValHelper::ladder, ResidualRefitting::StorageTrackHit::ladder_, nano_mu_digi_cff::layer, ResidualRefitting::StorageTrackHit::layer_, callgraph::module, 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().

                                                                                                           {
  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) {
    edm::LogVerbatim("ResidualRefitting") << "OMFG NOT THE TRACKER\n";
    return;
  }

  if (debug_)
    edm::LogVerbatim("ResidualRefitting") << "Tracker:: ";
  if (subdetector == ResidualRefitting::PXB) {
    layer = tTopo->pxbLayer(detid.rawId());
    ladder = tTopo->pxbLadder(detid.rawId());
    module = tTopo->pxbModule(detid.rawId());
    if (debug_)
      edm::LogVerbatim("ResidualRefitting")
          << "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_)
      edm::LogVerbatim("ResidualRefitting") << "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_)
      edm::LogVerbatim("ResidualRefitting") << "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_)
      edm::LogVerbatim("ResidualRefitting") << "TID"
                                            << "\tside = " << side << "\twheel = " << wheel << "\tring = " << ring;

  } else if (subdetector == ResidualRefitting::TOB) {
    layer = tTopo->tobLayer(detid.rawId());
    module = tTopo->tobModule(detid.rawId());
    if (debug_)
      edm::LogVerbatim("ResidualRefitting") << "TOB"
                                            << "\tlayer = " << layer << "\tmodule = " << module;

  } else if (subdetector == ResidualRefitting::TEC) {
    ring = tTopo->tecRing(detid.rawId());
    module = tTopo->tecModule(detid.rawId());
    if (debug_)
      edm::LogVerbatim("ResidualRefitting") << "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;
}

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 599 of file ResidualRefitting.cc.

References 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().

                                                                  {
  bool dump_ = debug_;

  if (dump_)
    edm::LogVerbatim("ResidualRefitting") << "In the trkExtrap function";

  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);
}

zero_muon()

void ResidualRefitting::zero_muon

(

ResidualRefitting::storage_muon *

str

)

Definition at line 864 of file ResidualRefitting.cc.

References mps_fire::i, N_MAX_STORED, and str.

Referenced by zero_storage().

                                                                    {
  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;
  }
}

zero_storage()

void ResidualRefitting::zero_storage

(

)

Definition at line 764 of file ResidualRefitting.cc.

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().

                                     {
  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;
}

zero_trackExtrap()

void ResidualRefitting::zero_trackExtrap

(

ResidualRefitting::storage_trackExtrap *

str

)

Definition at line 881 of file ResidualRefitting.cc.

References mps_fire::i, N_MAX_STORED_HIT, and str.

Referenced by zero_storage().

                                                                                  {
  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;
  }
}

Member Data Documentation

debug_

const bool ResidualRefitting::debug_

Definition at line 333 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 53 of file ResidualRefitting.h.

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

magFieldToken_

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> ResidualRefitting::magFieldToken_

Definition at line 319 of file ResidualRefitting.h.

Referenced by analyze().

muons_

const edm::InputTag ResidualRefitting::muons_

Definition at line 330 of file ResidualRefitting.h.

muonsNoSt1Token_

const edm::EDGetTokenT<reco::TrackCollection> ResidualRefitting::muonsNoSt1Token_

Definition at line 336 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoSt2Token_

const edm::EDGetTokenT<reco::TrackCollection> ResidualRefitting::muonsNoSt2Token_

Definition at line 337 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoSt3Token_

const edm::EDGetTokenT<reco::TrackCollection> ResidualRefitting::muonsNoSt3Token_

Definition at line 338 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoSt4Token_

const edm::EDGetTokenT<reco::TrackCollection> ResidualRefitting::muonsNoSt4Token_

Definition at line 339 of file ResidualRefitting.h.

Referenced by analyze().

muonsNoStation1_

const edm::InputTag ResidualRefitting::muonsNoStation1_

Definition at line 330 of file ResidualRefitting.h.

muonsNoStation2_

const edm::InputTag ResidualRefitting::muonsNoStation2_

Definition at line 330 of file ResidualRefitting.h.

muonsNoStation3_

const edm::InputTag ResidualRefitting::muonsNoStation3_

Definition at line 330 of file ResidualRefitting.h.

muonsNoStation4_

const edm::InputTag ResidualRefitting::muonsNoStation4_

Definition at line 330 of file ResidualRefitting.h.

muonsRemake_

const edm::InputTag ResidualRefitting::muonsRemake_

Definition at line 330 of file ResidualRefitting.h.

muonsToken_

const edm::EDGetTokenT<reco::MuonCollection> ResidualRefitting::muonsToken_

Definition at line 334 of file ResidualRefitting.h.

Referenced by analyze().

muonTracksToken_

const edm::EDGetTokenT<reco::TrackCollection> ResidualRefitting::muonTracksToken_

Definition at line 335 of file ResidualRefitting.h.

Referenced by analyze().

N_MAX_STORED

const int ResidualRefitting::N_MAX_STORED = 10

staticprivate

Definition at line 34 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 35 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 345 of file ResidualRefitting.h.

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

outputFile_

TFile* ResidualRefitting::outputFile_

Definition at line 342 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 344 of file ResidualRefitting.h.

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

PropagatorSource_

std::string ResidualRefitting::PropagatorSource_

Definition at line 327 of file ResidualRefitting.h.

propagatorToken_

const edm::ESGetToken<Propagator, TrackingComponentsRecord> ResidualRefitting::propagatorToken_

Definition at line 322 of file ResidualRefitting.h.

Referenced by analyze().

PXB

const int ResidualRefitting::PXB = 1

staticprivate

Definition at line 37 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

PXF

const int ResidualRefitting::PXF = 2

staticprivate

Definition at line 38 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

samExtrap120_

ResidualRefitting::storage_trackExtrap ResidualRefitting::samExtrap120_

Definition at line 242 of file ResidualRefitting.h.

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

storageGmrNew_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNew_

Definition at line 218 of file ResidualRefitting.h.

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

storageGmrNoPXBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer1

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoPXBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer2

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoPXBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer3

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoPXF

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXF

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt1_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt1_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt2_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt2_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt3_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt3_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoSt4_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt4_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTEC

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTEC

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer1

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer2

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer3

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTIBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer4

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTID

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTID

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer1

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer2

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer3

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer4

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer5

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer5

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrNoTOBLayer6

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer6

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageGmrOld_

ResidualRefitting::storage_muon ResidualRefitting::storageGmrOld_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageRecMuon_

ResidualRefitting::storage_hit ResidualRefitting::storageRecMuon_

Definition at line 234 of file ResidualRefitting.h.

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

storageSamNew_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNew_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt1_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt1_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt2_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt2_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt3_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt3_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageSamNoSt4_

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt4_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackExtrapRec_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRec_

Definition at line 238 of file ResidualRefitting.h.

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

storageTrackExtrapRecNoSt1_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt1_

Definition at line 238 of file ResidualRefitting.h.

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

storageTrackExtrapRecNoSt2_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt2_

Definition at line 238 of file ResidualRefitting.h.

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

storageTrackExtrapRecNoSt3_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt3_

Definition at line 238 of file ResidualRefitting.h.

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

storageTrackExtrapRecNoSt4_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt4_

Definition at line 238 of file ResidualRefitting.h.

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

storageTrackExtrapTracker_

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapTracker_

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackHit_

ResidualRefitting::storage_trackHit ResidualRefitting::storageTrackHit_

Definition at line 235 of file ResidualRefitting.h.

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

storageTrackNoPXBLayer1

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer1

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoPXBLayer2

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer2

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoPXBLayer3

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer3

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoPXF

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXF

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTEC

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTEC

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer1

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer1

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer2

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer2

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer3

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer3

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTIBLayer4

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer4

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTID

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTID

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer1

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer1

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer2

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer2

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer3

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer3

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer4

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer4

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer5

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer5

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrackNoTOBLayer6

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer6

Definition at line 245 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNew_

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNew_

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer1

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer2

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer3

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoPXF

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXF

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTEC

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTEC

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer1

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer2

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer3

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTIBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer4

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTID

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTID

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer1

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer1

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer2

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer2

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer3

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer3

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer4

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer4

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer5

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer5

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

storageTrkNoTOBLayer6

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer6

Definition at line 218 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

TEC

const int ResidualRefitting::TEC = 6

staticprivate

Definition at line 42 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

theField

const MagneticField* ResidualRefitting::theField

Definition at line 349 of file ResidualRefitting.h.

Referenced by analyze(), and freeTrajStateMuon().

thePropagator

edm::ESHandle<Propagator> ResidualRefitting::thePropagator

Definition at line 352 of file ResidualRefitting.h.

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

theService

MuonServiceProxy* ResidualRefitting::theService

Definition at line 351 of file ResidualRefitting.h.

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

TIB

const int ResidualRefitting::TIB = 3

staticprivate

Definition at line 39 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

TID

const int ResidualRefitting::TID = 4

staticprivate

Definition at line 40 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

TOB

const int ResidualRefitting::TOB = 5

staticprivate

Definition at line 41 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

topoToken_

const edm::ESGetToken<TrackerTopology, TrackerTopologyRcd> ResidualRefitting::topoToken_

Definition at line 320 of file ResidualRefitting.h.

Referenced by CollectTrackHits().

trackExtrap120_

ResidualRefitting::storage_trackExtrap ResidualRefitting::trackExtrap120_

Definition at line 242 of file ResidualRefitting.h.

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

trackingGeometry

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

Definition at line 350 of file ResidualRefitting.h.

trackingGeometryToken_

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> ResidualRefitting::trackingGeometryToken_

Definition at line 321 of file ResidualRefitting.h.

Referenced by analyze().

tracks_

const edm::InputTag ResidualRefitting::tracks_

Definition at line 330 of file ResidualRefitting.h.