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 noexcept final
bool	wantsGlobalRuns () const noexcept final
bool	wantsInputProcessBlocks () const noexcept final
bool	wantsProcessBlocks () const noexcept 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 noexcept
bool	wantsStreamRuns () const noexcept
	~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(), DiMuonV_cfg::muons, muonsNoSt1Token_, muonsNoSt2Token_, muonsNoSt3Token_, muonsNoSt4Token_, muonsToken_, DiMuonV_cfg::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_, ALCARECOPPSCalTrackBasedSel_cff::detid, 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_, EcalPhiSymFlatTableProducers_cfi::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_, 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(), nano_mu_digi_cff::superLayer, ResidualRefitting::StorageHit::superLayer_, ResidualRefitting::StorageHit::system_, theService, topoToken_, 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_2024v14_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_2024v14_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 ALCARECOPPSCalTrackBasedSel_cff::detid, freeTrajStateMuon(), GlobalTrackingGeometry::idToDet(), IsSameHit(), MatchTrackWithRecHits(), ResidualRefitting::StorageTrackExtrap::n_, MuonTransientTrackingRecHit::specificBuild(), theService, 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 ALCARECOPPSCalTrackBasedSel_cff::detid, MuonSubdetId::DT, EcalPhiSymFlatTableProducers_cfi::id, DetId::Muon, and nano_mu_digi_cff::sector.

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, ALCARECOPPSCalTrackBasedSel_cff::detid, MuonSubdetId::DT, EcalPhiSymFlatTableProducers_cfi::id, DetId::Muon, MuonSubdetId::RPC, and relativeConstraints::station.

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_, hgcalTestNeighbor_cfi::detector, ResidualRefitting::StorageTrackHit::detector_, ALCARECOPPSCalTrackBasedSel_cff::detid, 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(), relativeConstraints::ring, ResidualRefitting::StorageTrackHit::ring_, ALPAKA_ACCELERATOR_NAMESPACE::ecal::reconstruction::internal::barrel::side(), ResidualRefitting::StorageTrackHit::side_, storageTrackHit_, subdetector, ResidualRefitting::StorageTrackHit::subdetector_, 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_, ALCARECOPPSCalTrackBasedSel_cff::detid, 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(), isotrackTrainRegressor::loc, 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.