ResidualRefitting Class Reference

#include <ResidualRefitting.h>

Inheritance diagram for ResidualRefitting:

List of all members.

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 Member Functions
virtual void	analyze (const edm::Event &, const edm::EventSetup &)
virtual void	beginJob ()
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)
void	cylExtrapTrkSam (int recNum, reco::TrackRef track, ResidualRefitting::storage_trackExtrap &storage, double rho)
void	dumpMuonRecHits (ResidualRefitting::storage_hit hit)
void	dumpTrackExtrap (ResidualRefitting::storage_trackExtrap track)
void	dumpTrackHits (ResidualRefitting::storage_trackHit hit)
void	dumpTrackRef (reco::TrackRef muon, std::string str)
virtual void	endJob ()
FreeTrajectoryState	freeTrajStateMuon (reco::TrackRef muon)
bool	IsSameHit (trackingRecHit_iterator hit1, trackingRecHit_iterator hit2)
int	MatchTrackWithRecHits (reco::TrackCollection::const_iterator trackIt, edm::Handle< reco::TrackCollection > ref)
void	muonInfo (ResidualRefitting::storage_muon &storeMuon, reco::TrackRef muon, int val)
void	NewTrackMeasurements (edm::Handle< reco::TrackCollection > trackCollOrig, edm::Handle< reco::TrackCollection > trackColl, ResidualRefitting::storage_trackExtrap &trackExtrap)
void	omitStation (edm::Handle< reco::MuonCollection > funcMuons, edm::Handle< reco::TrackCollection >, ResidualRefitting::storage_muon &storeGmr, ResidualRefitting::storage_muon &storeSam, ResidualRefitting::storage_trackExtrap &storeExtrap, int omitStation)
void	omitTrackerSystem (edm::Handle< reco::MuonCollection > trkMuons, ResidualRefitting::storage_muon &storeGmr, ResidualRefitting::storage_muon &storeTrk, ResidualRefitting::storage_trackExtrap &storeExtrap, int omitSystem)
	ResidualRefitting (const edm::ParameterSet &)
int	ReturnSector (DetId detid)
int	ReturnStation (DetId detid)
void	StoreTrackerRecHits (DetId detid, 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 ()
Public Attributes
bool	debug_
ResidualRefitting::storage_event	eventInfo_
edm::InputTag	muons_
edm::InputTag	muonsNoPXBLayer1_
edm::InputTag	muonsNoPXBLayer2_
edm::InputTag	muonsNoPXBLayer3_
edm::InputTag	muonsNoPXF_
edm::InputTag	muonsNoStation1_
edm::InputTag	muonsNoStation2_
edm::InputTag	muonsNoStation3_
edm::InputTag	muonsNoStation4_
edm::InputTag	muonsNoTEC_
edm::InputTag	muonsNoTIBLayer1_
edm::InputTag	muonsNoTIBLayer2_
edm::InputTag	muonsNoTIBLayer3_
edm::InputTag	muonsNoTIBLayer4_
edm::InputTag	muonsNoTID_
edm::InputTag	muonsNoTOBLayer1_
edm::InputTag	muonsNoTOBLayer2_
edm::InputTag	muonsNoTOBLayer3_
edm::InputTag	muonsNoTOBLayer4_
edm::InputTag	muonsNoTOBLayer5_
edm::InputTag	muonsNoTOBLayer6_
edm::InputTag	muonsRemake_
TBranch *	outputBranch_
TFile *	outputFile_
std::string	outputFileName_
TTree *	outputTree_
std::string	PropagatorSource_
ResidualRefitting::storage_trackExtrap	samExtrap120_
ResidualRefitting::storage_muon	storageGmrNew_
ResidualRefitting::storage_muon	storageGmrNoPXBLayer1
ResidualRefitting::storage_muon	storageGmrNoPXBLayer2
ResidualRefitting::storage_muon	storageGmrNoPXBLayer3
ResidualRefitting::storage_muon	storageGmrNoPXF
ResidualRefitting::storage_muon	storageGmrNoSt1_
ResidualRefitting::storage_muon	storageGmrNoSt2_
ResidualRefitting::storage_muon	storageGmrNoSt3_
ResidualRefitting::storage_muon	storageGmrNoSt4_
ResidualRefitting::storage_muon	storageGmrNoTEC
ResidualRefitting::storage_muon	storageGmrNoTIBLayer1
ResidualRefitting::storage_muon	storageGmrNoTIBLayer2
ResidualRefitting::storage_muon	storageGmrNoTIBLayer3
ResidualRefitting::storage_muon	storageGmrNoTIBLayer4
ResidualRefitting::storage_muon	storageGmrNoTID
ResidualRefitting::storage_muon	storageGmrNoTOBLayer1
ResidualRefitting::storage_muon	storageGmrNoTOBLayer2
ResidualRefitting::storage_muon	storageGmrNoTOBLayer3
ResidualRefitting::storage_muon	storageGmrNoTOBLayer4
ResidualRefitting::storage_muon	storageGmrNoTOBLayer5
ResidualRefitting::storage_muon	storageGmrNoTOBLayer6
ResidualRefitting::storage_muon	storageGmrOld_
ResidualRefitting::storage_hit	storageRecMuon_
ResidualRefitting::storage_muon	storageSamNew_
ResidualRefitting::storage_muon	storageSamNoSt1_
ResidualRefitting::storage_muon	storageSamNoSt2_
ResidualRefitting::storage_muon	storageSamNoSt3_
ResidualRefitting::storage_muon	storageSamNoSt4_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRec_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt1_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt2_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt3_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt4_
ResidualRefitting::storage_trackExtrap	storageTrackExtrapTracker_
ResidualRefitting::storage_trackHit	storageTrackHit_
ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer1
ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer2
ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer3
ResidualRefitting::storage_trackExtrap	storageTrackNoPXF
ResidualRefitting::storage_trackExtrap	storageTrackNoTEC
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer1
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer2
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer3
ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer4
ResidualRefitting::storage_trackExtrap	storageTrackNoTID
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer1
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer2
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer3
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer4
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer5
ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer6
ResidualRefitting::storage_muon	storageTrkNew_
ResidualRefitting::storage_muon	storageTrkNoPXBLayer1
ResidualRefitting::storage_muon	storageTrkNoPXBLayer2
ResidualRefitting::storage_muon	storageTrkNoPXBLayer3
ResidualRefitting::storage_muon	storageTrkNoPXF
ResidualRefitting::storage_muon	storageTrkNoTEC
ResidualRefitting::storage_muon	storageTrkNoTIBLayer1
ResidualRefitting::storage_muon	storageTrkNoTIBLayer2
ResidualRefitting::storage_muon	storageTrkNoTIBLayer3
ResidualRefitting::storage_muon	storageTrkNoTIBLayer4
ResidualRefitting::storage_muon	storageTrkNoTID
ResidualRefitting::storage_muon	storageTrkNoTOBLayer1
ResidualRefitting::storage_muon	storageTrkNoTOBLayer2
ResidualRefitting::storage_muon	storageTrkNoTOBLayer3
ResidualRefitting::storage_muon	storageTrkNoTOBLayer4
ResidualRefitting::storage_muon	storageTrkNoTOBLayer5
ResidualRefitting::storage_muon	storageTrkNoTOBLayer6
const MagneticField *	theField
edm::ESHandle< Propagator >	thePropagator
MuonServiceProxy *	theService
ResidualRefitting::storage_trackExtrap	trackExtrap120_
const edm::ESHandle < GlobalTrackingGeometry >	trackingGeometry
edm::InputTag	tracks_
Static Private Attributes
static const int	N_MAX_STORED = 10
static const int	N_MAX_STORED_HIT = 1000
static const int	PXB = 1
static const int	PXF = 2
static const int	TEC = 6
static const int	TIB = 3
static const int	TID = 4
static const int	TOB = 5

---

Detailed Description

Definition at line 38 of file ResidualRefitting.h.

---

Member Typedef Documentation

typedef struct ResidualRefitting::StorageHit ResidualRefitting::storage_hit

typedef struct ResidualRefitting::StorageMuon ResidualRefitting::storage_muon

typedef struct ResidualRefitting::StorageTrackExtrap ResidualRefitting::storage_trackExtrap

typedef struct ResidualRefitting::StorageTrackHit ResidualRefitting::storage_trackHit

---

Constructor & Destructor Documentation

ResidualRefitting::ResidualRefitting

(

const edm::ParameterSet &

cfg

)

[explicit]

Definition at line 43 of file ResidualRefitting.cc.

References eventInfo_, ResidualRefitting::storage_event::evtNum_, edm::ParameterSet::getParameter(), MuonServiceProxy_cff::MuonServiceProxy, and theService.

                                                                  :
  outputFileName_               ( cfg.getUntrackedParameter<std::string>("histoutputFile") ),
  PropagatorSource_             ( cfg.getParameter<std::string>("propagator")), 
  muons_                        ( cfg.getParameter<edm::InputTag>( "muons"              ) ),
  muonsRemake_                  ( cfg.getParameter<edm::InputTag>("muonsRemake" ) ),                    //This Feels Misalignment
  muonsNoStation1_              ( cfg.getParameter<edm::InputTag>("muonsNoStation1") ),
  muonsNoStation2_              ( cfg.getParameter<edm::InputTag>("muonsNoStation2") ),
  muonsNoStation3_              ( cfg.getParameter<edm::InputTag>("muonsNoStation3") ),
  muonsNoStation4_              ( cfg.getParameter<edm::InputTag>("muonsNoStation4") ),

/*
  muonsNoPXBLayer1_             ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1"    ) ),
  muonsNoPXBLayer2_             ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1"    ) ),
  muonsNoPXBLayer3_             ( cfg.getParameter<edm::InputTag>("muonsNoPXBLayer1"    ) ),

  muonsNoTIBLayer1_                     ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer1"    ) ),
  muonsNoTIBLayer2_                     ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer2"    ) ),
  muonsNoTIBLayer3_                     ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer3"    ) ),
  muonsNoTIBLayer4_                     ( cfg.getParameter<edm::InputTag>("muonsNoTIBLayer4"    ) ),

  muonsNoTOBLayer1_                     ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer1"    ) ),
  muonsNoTOBLayer2_                     ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer2"    ) ),
  muonsNoTOBLayer3_                     ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer3"    ) ),
  muonsNoTOBLayer4_                     ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer4"    ) ),
  muonsNoTOBLayer5_                     ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer5"    ) ),
  muonsNoTOBLayer6_                     ( cfg.getParameter<edm::InputTag>("muonsNoTOBLayer6"    ) ),*/
  debug_                                ( cfg.getUntrackedParameter<bool>("doDebug"     ) ),
  outputFile_(0),
  outputTree_(0),
  outputBranch_(0),
  theField(0)
{
        eventInfo_.evtNum_ = 0;
        eventInfo_.evtNum_ = 0;

// service parameters
        edm::ParameterSet serviceParameters = cfg.getParameter<edm::ParameterSet>("ServiceParameters");
  
// the services
        theService = new MuonServiceProxy(serviceParameters);
        
}  //The constructor

ResidualRefitting::~ResidualRefitting

(

)

Definition at line 273 of file ResidualRefitting.cc.

References outputFile_, and theService.

                                      {
  delete outputFile_;
  delete theService;
}

---

Member Function Documentation

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

Implements edm::EDAnalyzer.

Definition at line 86 of file ResidualRefitting.cc.

References CollectTrackHits(), gather_cfg::cout, cylExtrapTrkSam(), debug_, dumpTrackRef(), edm::EventID::event(), eventInfo_, ResidualRefitting::storage_event::evtNum_, HcalObjRepresent::Fill(), edm::EventSetup::get(), edm::EventBase::id(), metsig::muon, muonInfo(), patZpeak::muons, muons_, muonsNoStation1_, muonsNoStation2_, muonsNoStation3_, muonsNoStation4_, muonsRemake_, ResidualRefitting::StorageTrackExtrap::n_, ResidualRefitting::StorageMuon::n_, N_MAX_STORED, NewTrackMeasurements(), outputBranch_, outputTree_, PropagatorSource_, edm::EventID::run(), ResidualRefitting::storage_event::runNum_, samExtrap120_, storageGmrNew_, storageTrackExtrapRec_, storageTrackExtrapRecNoSt1_, storageTrackExtrapRecNoSt2_, storageTrackExtrapRecNoSt3_, storageTrackExtrapRecNoSt4_, theField, thePropagator, theService, trackExtrap120_, 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
        edm::Handle<reco::MuonCollection> muons;

        edm::Handle<reco::TrackCollection> muonTracks;
        edm::Handle<reco::TrackCollection> muonsNoSt1;
        edm::Handle<reco::TrackCollection> muonsNoSt2;
        edm::Handle<reco::TrackCollection> muonsNoSt3;
        edm::Handle<reco::TrackCollection> muonsNoSt4;


        event.getByLabel(muons_                         , muons ); //set label to muons
        event.getByLabel(muonsRemake_           , muonTracks);  
        event.getByLabel(muonsNoStation1_       , muonsNoSt1);
        event.getByLabel(muonsNoStation2_       , muonsNoSt2);
        event.getByLabel(muonsNoStation3_       , muonsNoSt3);
        event.getByLabel(muonsNoStation4_       , muonsNoSt4);
        
        
/*
//      std::cout<<"Muon Collection No PXB "<<std::endl;
//Tracker Barrel Pixel Refits
        edm::Handle<MuonCollection> muonsNoPXBLayer1Coll;
        event.getByLabel(muonsNoPXBLayer1_, muonsNoPXBLayer1Coll);
        edm::Handle<MuonCollection> muonsNoPXBLayer2Coll;
        event.getByLabel(muonsNoPXBLayer2_, muonsNoPXBLayer2Coll);
        edm::Handle<MuonCollection> muonsNoPXBLayer3Coll;
        event.getByLabel(muonsNoPXBLayer3_, muonsNoPXBLayer3Coll);
//      std::cout<<"Muon Collection No TIB "<<std::endl;
// Tracker Inner Barrel Refits
        edm::Handle<MuonCollection> muonsNoTIBLayer1Coll;
        event.getByLabel(muonsNoTIBLayer1_, muonsNoTIBLayer1Coll);
        edm::Handle<MuonCollection> muonsNoTIBLayer2Coll;
        event.getByLabel(muonsNoTIBLayer2_, muonsNoTIBLayer2Coll);
        edm::Handle<MuonCollection> muonsNoTIBLayer3Coll;
        event.getByLabel(muonsNoTIBLayer3_, muonsNoTIBLayer3Coll);
        edm::Handle<MuonCollection> muonsNoTIBLayer4Coll;
        event.getByLabel(muonsNoTIBLayer4_, muonsNoTIBLayer4Coll);

//      std::cout<<"Muon Collection No TOB "<<std::endl;

//Tracker outer barrel refits
        edm::Handle<MuonCollection> muonsNoTOBLayer1Coll;
        event.getByLabel(muonsNoTOBLayer1_, muonsNoTOBLayer1Coll);
        edm::Handle<MuonCollection> muonsNoTOBLayer2Coll;
        event.getByLabel(muonsNoTOBLayer2_, muonsNoTOBLayer2Coll);
        edm::Handle<MuonCollection> muonsNoTOBLayer3Coll;
        event.getByLabel(muonsNoTOBLayer3_, muonsNoTOBLayer3Coll);
        edm::Handle<MuonCollection> muonsNoTOBLayer4Coll;
        event.getByLabel(muonsNoTOBLayer4_, muonsNoTOBLayer4Coll);
        edm::Handle<MuonCollection> muonsNoTOBLayer5Coll;
        event.getByLabel(muonsNoTOBLayer5_, muonsNoTOBLayer5Coll);
        edm::Handle<MuonCollection> muonsNoTOBLayer6Coll;
        event.getByLabel(muonsNoTOBLayer6_, muonsNoTOBLayer6Coll);
*/
        //magnetic field information    
        edm::ESHandle<MagneticField> field;
        edm::ESHandle<GlobalTrackingGeometry> globalTrackingGeometry;
        eventSetup.get<IdealMagneticFieldRecord>().get(field);
        eventSetup.get<GlobalTrackingGeometryRecord>().get(globalTrackingGeometry);
        eventSetup.get<TrackingComponentsRecord>().get( PropagatorSource_, thePropagator );
        theField = &*field;
        
        
        theService->update(eventSetup);

//Zero storage
    zero_storage();

  
//Do the Gmr Muons from the unModified Collection

/*
        int iGmr = 0;
        if ( (muons->end() - muons->begin()) > 0) printf("Data Dump:: Original GMR Muons\n");
        for ( MuonCollection::const_iterator muon = muons->begin(); muon!=muons->end(); muon++, iGmr++) {
                if ( iGmr >= ResidualRefitting::N_MAX_STORED) break; // error checking
                if (!debug
                
                dumpTrackRef(muon->combinedMuon(), "cmb"); 
                dumpTrackRef(muon->standAloneMuon(), "sam");
                dumpTrackRef(muon->track(), "trk");
                

        }
        storageGmrOld_.n_ = iGmr;
        storageSamNew_.n_ = iGmr;
*/

//Refitted muons
        if (debug_) printf("Data Dump:: Rebuilt GMR Muon Track With TeV refitter default\n");
        int iGmrRemake = 0;
        for ( reco::TrackCollection::const_iterator muon = muonTracks->begin(); muon!=muonTracks->end(); muon++, iGmrRemake++) {
                if ( iGmrRemake >= ResidualRefitting::N_MAX_STORED) break; // error checking
                        // from TrackInfoProducer/test/TrackInfoAnalyzerExample.cc
                reco::TrackRef trackref=reco::TrackRef(muonTracks,iGmrRemake);

                        if (debug_) dumpTrackRef(trackref, "gmr");
                        muonInfo(storageGmrNew_,trackref,iGmrRemake);

        }
        storageGmrNew_.n_ = iGmrRemake;
                


        if (debug_) printf("muons Remake");
        if (debug_) printf("-----------------------------------------\n");
        CollectTrackHits(muonTracks, storageTrackExtrapRec_);


        if (true) {
                printf("muons No Station 1");
                printf("-----------------------------------------\n");
        }
        NewTrackMeasurements(muonTracks, muonsNoSt1, storageTrackExtrapRecNoSt1_);

        if (true) {
                printf("muons No Station 2");
                printf("-----------------------------------------\n");
        }
        NewTrackMeasurements(muonTracks, muonsNoSt2, storageTrackExtrapRecNoSt2_);

        if (true) {
                printf("muons No Station 3");
                printf("-----------------------------------------\n");
        }
        NewTrackMeasurements(muonTracks, muonsNoSt3, storageTrackExtrapRecNoSt3_);

        if (true) {
                printf("muons No Station 4");
                printf("-----------------------------------------\n");
        }
        NewTrackMeasurements(muonTracks, muonsNoSt4, storageTrackExtrapRecNoSt4_);


//      dumpMuonRecHits(storageRecMuon_); 
                
/****************************************************************************************************************************************/

  
/*
 *      extrapolates track to a cylinder.
 *  commented for cosmic runs with no tracker in reco muons!!
 *
*/


        int iGmrCyl = 0;
        for (reco::MuonCollection::const_iterator muon = muons->begin(); muon != muons->end(); muon++, iGmrCyl++) {

                dumpTrackRef(muon->combinedMuon(), "cmb"); 
                dumpTrackRef(muon->standAloneMuon(), "sam");
                dumpTrackRef(muon->track(), "trk");

                cylExtrapTrkSam(iGmrCyl, muon->standAloneMuon() , samExtrap120_         , 120.);
                cylExtrapTrkSam(iGmrCyl, muon->track()                  , trackExtrap120_       , 120.);

        }
        samExtrap120_.n_         = iGmrCyl;
        trackExtrap120_.n_       = iGmrCyl; 


        if (iGmrRemake > 0 || iGmrCyl > 0) {
                outputTree_ -> Fill();
                std::cout << "FILLING NTUPLE!" << std::endl;
                std::cout << "Entries Recorded: " << outputTree_ -> GetEntries() << " Branch :: " << outputBranch_ -> GetEntries() <<  std::endl<<std::endl;
        } else std::cout<<"no tracks -- no fill!\n"<<std::endl<<std::endl;

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

void ResidualRefitting::beginJob

(

void

)

[virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 1013 of file ResidualRefitting.cc.

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

                                 {

        std::cout<<"Creating file "<< outputFileName_.c_str()<<std::endl;

        outputFile_  = new TFile( outputFileName_.c_str(), "RECREATE" ) ; 

        outputTree_ = new TTree("outputTree","outputTree");

        outputTree_->Branch("eventInfo",&eventInfo_,
                                                "evtNum_/I:"
                                                "runNum_/I"
                                );


        ResidualRefitting::branchMuon(storageGmrOld_    , "gmrOld");
        ResidualRefitting::branchMuon(storageGmrNew_    , "gmrNew");
        ResidualRefitting::branchMuon(storageGmrNoSt1_  , "gmrNoSt1");
        ResidualRefitting::branchMuon(storageGmrNoSt2_  , "gmrNoSt2");
        ResidualRefitting::branchMuon(storageGmrNoSt3_  , "gmrNoSt3");
        ResidualRefitting::branchMuon(storageGmrNoSt4_  , "gmrNoSt4");

        ResidualRefitting::branchMuon(storageSamNew_    , "samNew");
        ResidualRefitting::branchMuon(storageSamNoSt1_  , "samNoSt1");
        ResidualRefitting::branchMuon(storageSamNoSt2_  , "samNoSt2");
        ResidualRefitting::branchMuon(storageSamNoSt3_  , "samNoSt3");
        ResidualRefitting::branchMuon(storageSamNoSt4_  , "samNoSt4");

        ResidualRefitting::branchMuon(storageTrkNew_    , "trkNew");
        ResidualRefitting::branchMuon(storageGmrNoPXBLayer1     , "gmrNoPXBLayer1");
        ResidualRefitting::branchMuon(storageGmrNoPXBLayer2     , "gmrNoPXBLayer2");
        ResidualRefitting::branchMuon(storageGmrNoPXBLayer3     , "gmrNoPXBLayer3");
        ResidualRefitting::branchMuon(storageGmrNoPXF   , "gmrNoPXF");
        ResidualRefitting::branchMuon(storageGmrNoTIBLayer1     , "gmrNoTIBLayer1");
        ResidualRefitting::branchMuon(storageGmrNoTIBLayer2     , "gmrNoTIBLayer2");
        ResidualRefitting::branchMuon(storageGmrNoTIBLayer3     , "gmrNoTIBLayer3");
        ResidualRefitting::branchMuon(storageGmrNoTIBLayer4     , "gmrNoTIBLayer4");
        ResidualRefitting::branchMuon(storageGmrNoTID   , "gmrNoTID");
        ResidualRefitting::branchMuon(storageGmrNoTOBLayer1     , "gmrNoTOBLayer1");
        ResidualRefitting::branchMuon(storageGmrNoTOBLayer2     , "gmrNoTOBLayer2");
        ResidualRefitting::branchMuon(storageGmrNoTOBLayer3     , "gmrNoTOBLayer3");
        ResidualRefitting::branchMuon(storageGmrNoTOBLayer4     , "gmrNoTOBLayer4");
        ResidualRefitting::branchMuon(storageGmrNoTOBLayer5     , "gmrNoTOBLayer5");
        ResidualRefitting::branchMuon(storageGmrNoTOBLayer6     , "gmrNoTOBLayer6");
        ResidualRefitting::branchMuon(storageGmrNoTEC   , "gmrNoTEC");

        ResidualRefitting::branchMuon(storageTrkNoPXBLayer1     , "trkNoPXBLayer1");
        ResidualRefitting::branchMuon(storageTrkNoPXBLayer2     , "trkNoPXBLayer2");
        ResidualRefitting::branchMuon(storageTrkNoPXBLayer3     , "trkNoPXBLayer3");
        ResidualRefitting::branchMuon(storageTrkNoPXF   , "trkNoPXF");
        ResidualRefitting::branchMuon(storageTrkNoTIBLayer1     , "trkNoTIBLayer1");
        ResidualRefitting::branchMuon(storageTrkNoTIBLayer2     , "trkNoTIBLayer2");
        ResidualRefitting::branchMuon(storageTrkNoTIBLayer3     , "trkNoTIBLayer3");
        ResidualRefitting::branchMuon(storageTrkNoTIBLayer4     , "trkNoTIBLayer4");
        ResidualRefitting::branchMuon(storageTrkNoTID   , "trkNoTID");
        ResidualRefitting::branchMuon(storageTrkNoTOBLayer1     , "trkNoTOBLayer1");
        ResidualRefitting::branchMuon(storageTrkNoTOBLayer2     , "trkNoTOBLayer2");
        ResidualRefitting::branchMuon(storageTrkNoTOBLayer3     , "trkNoTOBLayer3");
        ResidualRefitting::branchMuon(storageTrkNoTOBLayer4     , "trkNoTOBLayer4");
        ResidualRefitting::branchMuon(storageTrkNoTOBLayer5     , "trkNoTOBLayer5");
        ResidualRefitting::branchMuon(storageTrkNoTOBLayer6     , "trkNoTOBLayer6");
        ResidualRefitting::branchMuon(storageTrkNoTEC   , "trkNoTEC");
                                        
        outputBranch_ = outputTree_ -> Branch("recHitsNew", &storageRecMuon_, 

                "n_/I:"
                "muonLink_[1000]/I:"
                
                "system_[1000]/I:"
                "endcap_[1000]/I:"
                "station_[1000]/I:"
                "ring_[1000]/I:"
                "chamber_[1000]/I:"
                "layer_[1000]/I:"
                "superLayer_[1000]/I:"
                "wheel_[1000]/I:"
                "sector_[1000]/I:"
                
        
                "gpX_[1000]/F:"
                "gpY_[1000]/F:"
                "gpZ_[1000]/F:"
                "gpEta_[1000]/F:"
                "gpPhi_[1000]/F:"
                "lpX_[1000]/F:"
                "lpY_[1000]/F:"
                "lpZ_[1000]/F"
                );
                
                
        outputBranch_ = outputTree_ -> Branch("recHitsTracker", &storageTrackHit_,
        
                "n_/I:"
                
                "muonLink_[1000]/I:"
                "detector_[1000]/I:"
                "subdetector_[1000]/I:"
                "blade_[1000]/I:"
                "disk_[1000]/I:"
                "ladder_[1000]/I:"
                "layer_[1000]/I:"
                "module_[1000]/I:"
                "panel_[1000]/I:"
                "ring_[1000]/I:"
                "side_[1000]/I:"
                "wheel_[1000]/I:"
                                
                "gpX_[1000]/F:"
                "gpY_[1000]/F:"
                "gpZ_[1000]/F:"
                "gpEta_[1000]/F:"
                "gpPhi_[1000]/F:"
                "lpX_[1000]/F:"
                "lpY_[1000]/F:"
                "lpZ_[1000]/F"
                );      
                
                
        ResidualRefitting::branchTrackExtrap(storageTrackExtrapRec_             , "trkExtrap");
        ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt1_        , "trkExtrapNoSt1");
        ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt2_        , "trkExtrapNoSt2");
        ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt3_        , "trkExtrapNoSt3");
        ResidualRefitting::branchTrackExtrap(storageTrackExtrapRecNoSt4_        , "trkExtrapNoSt4");

        ResidualRefitting::branchTrackExtrap(storageTrackExtrapTracker_, "trkExtrapTracker");
        ResidualRefitting::branchTrackExtrap(storageTrackNoPXF                  , "trkExtrapNoPXF");
        ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer1                    , "trkExtrapNoPXBLayer1");
        ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer2                    , "trkExtrapNoPXBLayer2");
        ResidualRefitting::branchTrackExtrap(storageTrackNoPXBLayer3                    , "trkExtrapNoPXBLayer3");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer1                    , "trkExtrapNoTIBLayer1");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer2                    , "trkExtrapNoTIBLayer2");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer3                    , "trkExtrapNoTIBLayer3");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTIBLayer4                    , "trkExtrapNoTIBLayer4");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTID                  , "trkExtrapNoTID");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer1                    , "trkExtrapNoTOBLayer1");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer2                    , "trkExtrapNoTOBLayer2");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer3                    , "trkExtrapNoTOBLayer3");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer4                    , "trkExtrapNoTOBLayer4");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer5                    , "trkExtrapNoTOBLayer5");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTOBLayer6                    , "trkExtrapNoTOBLayer6");
        ResidualRefitting::branchTrackExtrap(storageTrackNoTEC                  , "trkExtrapNoTEC");

        ResidualRefitting::branchTrackExtrap(trackExtrap120_                    , "trackCyl120");
        ResidualRefitting::branchTrackExtrap(samExtrap120_                              , "samCyl120");

}

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

Definition at line 1161 of file ResidualRefitting.cc.

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

}

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

Definition at line 1181 of file ResidualRefitting.cc.

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

}

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

Definition at line 280 of file ResidualRefitting.cc.

References ResidualRefitting::StorageHit::chamber_, MuonSubdetId::CSC, debug_, DetId::det(), cond::rpcobgas::detid, MuonSubdetId::DT, dumpTrackRef(), Reference_intrackfit_cff::endcap, CSCDetId::endcap(), ResidualRefitting::StorageHit::endcap_, freeTrajStateMuon(), ResidualRefitting::StorageTrackHit::gpEta_, ResidualRefitting::StorageHit::gpEta_, ResidualRefitting::StorageTrackHit::gpPhi_, ResidualRefitting::StorageHit::gpPhi_, ResidualRefitting::StorageTrackHit::gpX_, ResidualRefitting::StorageHit::gpX_, ResidualRefitting::StorageHit::gpY_, ResidualRefitting::StorageTrackHit::gpY_, ResidualRefitting::StorageTrackHit::gpZ_, ResidualRefitting::StorageHit::gpZ_, ResidualRefitting::StorageHit::layer_, ResidualRefitting::StorageTrackHit::lpX_, ResidualRefitting::StorageHit::lpX_, ResidualRefitting::StorageHit::lpY_, ResidualRefitting::StorageTrackHit::lpY_, ResidualRefitting::StorageTrackHit::lpZ_, ResidualRefitting::StorageHit::lpZ_, metsig::muon, DetId::Muon, ResidualRefitting::StorageHit::muonLink_, ResidualRefitting::StorageTrackHit::n_, ResidualRefitting::StorageTrackExtrap::n_, ResidualRefitting::StorageHit::n_, DetId::rawId(), relativeConstraints::ring, ResidualRefitting::StorageHit::ring_, MuonSubdetId::RPC, ResidualRefitting::StorageHit::sector_, MuonTransientTrackingRecHit::specificBuild(), relativeConstraints::station, RPCDetId::station(), DTChamberId::station(), ResidualRefitting::StorageHit::station_, storageRecMuon_, storageTrackHit_, StoreTrackerRecHits(), DetId::subdetId(), ResidualRefitting::StorageHit::superLayer_, ResidualRefitting::StorageHit::system_, theService, align::Tracker, MuonServiceProxy::trackingGeometry(), trkExtrap(), ResidualRefitting::StorageHit::wheel_, PV3DBase< T, PVType, FrameType >::x(), PV3DBase< T, PVType, FrameType >::y(), and PV3DBase< T, PVType, FrameType >::z().

Referenced by analyze().

                                                                                                                                    {

        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");
        
                for (trackingRecHit_iterator rec = muon->recHitsBegin(); rec != muon->recHitsEnd(); rec++) {

                        int iRec = rec - muon->recHitsBegin();  
                        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();

                        MuonTransientTrackingRecHit::MuonRecHitPointer 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, 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);
                                

                }

        }

        storageRecMuon_ .n_     = iMuonHit; 
        storageTrackHit_.n_             = iTrackHit;
        trackExtrap             .n_     = numTracks;

}

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

Definition at line 822 of file ResidualRefitting.cc.

References newFWLiteAna::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(), pos, makeMuonMisalignmentScenario::rot, mathSSE::sqrt(), thePropagator, 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);


}

void ResidualRefitting::dumpMuonRecHits

(

ResidualRefitting::storage_hit

hit

)

Definition at line 1265 of file ResidualRefitting.cc.

References gather_cfg::cout, i, ResidualRefitting::StorageHit::lpX_, ResidualRefitting::StorageHit::lpY_, ResidualRefitting::StorageHit::lpZ_, ResidualRefitting::StorageHit::n_, ResidualRefitting::StorageHit::superLayer_, and ResidualRefitting::StorageHit::system_.

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

void ResidualRefitting::dumpTrackExtrap

(

ResidualRefitting::storage_trackExtrap

track

)

Definition at line 1241 of file ResidualRefitting.cc.

References gather_cfg::cout, i, ResidualRefitting::StorageTrackExtrap::lpX_, ResidualRefitting::StorageTrackExtrap::lpY_, ResidualRefitting::StorageTrackExtrap::lpZ_, ResidualRefitting::StorageTrackExtrap::muonLink_, ResidualRefitting::StorageTrackExtrap::n_, and ResidualRefitting::StorageTrackExtrap::recLink_.

                                                                                  {
        std::cout<<"\n\nExtrapolation Dump:\n";
        for (unsigned int i = 0; i < (unsigned int)track.n_; i++) {
                
//              double rho = sqrt( (float)track.gpX_[i] * (float)track.gpX_[i] + (float)track.gpY_[i] * (float)track.gpY_[i]  );

                printf ("%d\tmuonLink= %d",i, (int)track.muonLink_[i]);         
                printf ("\trecLink = %d",       (int)track.recLink_[i]  );
//              printf ("\tGlobal\tx = %0.3f"           ,               (float)track.gpX_[i]    );
//              printf ("\ty = %0.3f"           ,               (float)track.gpY_[i]    );
//              printf ("\tz = %0.3f"           ,               (float)track.gpZ_[i]    );
//              printf ("\trho =%0.3f"          ,               rho                                             );
//              printf ("\teta = %0.3f"         ,               (float)track.gpEta_[i]  );
//              printf ("\tphi = %0.3f"         ,               (float)track.gpPhi_[i]  );
                printf ("\t\tLocal\tx = %0.3f"  ,               (float)track.lpX_[i]    );
                printf ("\ty = %0.3f"           ,       (float)track.lpY_[i]            );
                printf ("\tz = %0.3f\n" ,       (float)track.lpZ_[i]            );
                
        }
        
}

void ResidualRefitting::dumpTrackHits

(

ResidualRefitting::storage_trackHit

hit

)

Definition at line 1288 of file ResidualRefitting.cc.

References gather_cfg::cout, i, ResidualRefitting::StorageTrackHit::layer_, ResidualRefitting::StorageTrackHit::lpX_, ResidualRefitting::StorageTrackHit::lpY_, ResidualRefitting::StorageTrackHit::lpZ_, ResidualRefitting::StorageTrackHit::n_, and ResidualRefitting::StorageTrackHit::subdetector_.

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

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

Definition at line 1312 of file ResidualRefitting.cc.

References eta(), AlCaHLTBitMon_ParallelJobs::p, and phi.

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

}

void ResidualRefitting::endJob

(

void

)

[virtual]

Reimplemented from edm::EDAnalyzer.

Definition at line 1205 of file ResidualRefitting.cc.

References outputFile_.

                               {


  outputFile_ -> Write();

  outputFile_ -> Close() ;

}

FreeTrajectoryState ResidualRefitting::freeTrajStateMuon

(

reco::TrackRef

muon

)

Definition at line 1216 of file ResidualRefitting.cc.

References DeDxDiscriminatorTools::charge(), gather_cfg::cout, debug_, and theField.

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

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

                        FreeTrajectoryState recoStart( innerPoint, innerVec, muon ->charge(), theField ); 
                        return recoStart;

}

bool ResidualRefitting::IsSameHit	(	trackingRecHit_iterator	hit1,
		trackingRecHit_iterator	hit2
	)

Definition at line 544 of file ResidualRefitting.cc.

References alignCSCRings::e.

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;

}

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

Definition at line 476 of file ResidualRefitting.cc.

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

Referenced by NewTrackMeasurements().

                                             {

        if (debug_) printf("Matching a re-fitted track to the original track.\n");
        
        int TrackMatch = -1;

        for (trackingRecHit_iterator rec = trackIt->recHitsBegin(); rec!=trackIt->recHitsEnd(); rec++) {
                
                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 (trackingRecHit_iterator recRef = refIt->recHitsBegin(); recRef!=refIt->recHitsEnd(); recRef++) {

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

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

Definition at line 678 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_, and ResidualRefitting::StorageMuon::pt_.

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

}

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

Definition at line 426 of file ResidualRefitting.cc.

References cond::rpcobgas::detid, freeTrajStateMuon(), IsSameHit(), MatchTrackWithRecHits(), metsig::muon, 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 (trackingRecHit_iterator rec1 = ref->recHitsBegin(); rec1!= ref->recHitsEnd(); rec1++, recCounter++) {

                        //int iRec = rec1 - ref->recHitsBegin();
                        
                        bool unbiasedRec = true;

                        for ( trackingRecHit_iterator rec2 = muon->recHitsBegin(); rec2!=muon->recHitsEnd();rec2++) {
                                                
                                if (IsSameHit(rec1,rec2)) {
                                        unbiasedRec = false;
                                        break;
                                }
                        }
                        if (!unbiasedRec) continue;
                                
                        DetId detid = (*rec1)->geographicalId(); 

                        MuonTransientTrackingRecHit::MuonRecHitPointer mrhp =   
                                MuonTransientTrackingRecHit::specificBuild(theService->trackingGeometry()->idToDet((**rec1).geographicalId())
                                ,&(**rec1)); 
                
                        trkExtrap(detid, numTracks, iTrackLink, recCounter, recoStart, (*rec1)->localPosition(), trackExtrap);
                        numTracks++;    
                
                }       

        }

        trackExtrap.n_ = numTracks;

}

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
	)

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

int ResidualRefitting::ReturnSector

(

DetId

detid

)

Definition at line 801 of file ResidualRefitting.cc.

References DetId::det(), MuonSubdetId::DT, DetId::Muon, DetId::rawId(), DTChamberId::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;          
}

int ResidualRefitting::ReturnStation

(

DetId

detid

)

Definition at line 772 of file ResidualRefitting.cc.

References MuonSubdetId::CSC, DetId::det(), MuonSubdetId::DT, DetId::Muon, DetId::rawId(), MuonSubdetId::RPC, relativeConstraints::station, RPCDetId::station(), DTChamberId::station(), CSCDetId::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;         
}

void ResidualRefitting::StoreTrackerRecHits	(	DetId	detid,
		int	iTrack,
		int	iRec
	)

Definition at line 568 of file ResidualRefitting.cc.

References ResidualRefitting::StorageTrackHit::blade_, gather_cfg::cout, debug_, DetId::det(), ResidualRefitting::StorageTrackHit::detector_, ResidualRefitting::StorageTrackHit::disk_, ResidualRefitting::StorageTrackHit::ladder_, TIBDetId::layer(), TOBDetId::layer(), PXBDetId::layer(), ResidualRefitting::StorageTrackHit::layer_, python::rootplot::argparse::module, ResidualRefitting::StorageTrackHit::module_, ResidualRefitting::StorageTrackHit::muonLink_, ResidualRefitting::StorageTrackHit::panel_, PXB, PXF, DetId::rawId(), relativeConstraints::ring, TECDetId::ring(), ResidualRefitting::StorageTrackHit::ring_, PXFDetId::side(), TIDDetId::side(), ResidualRefitting::StorageTrackHit::side_, storageTrackHit_, ResidualRefitting::StorageTrackHit::subdetector_, DetId::subdetId(), TEC, TIB, TID, TOB, DetId::Tracker, 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) { 
                                std::cout<<"OMFG NOT THE TRACKER\n"<<std::endl;
                                return;
                        }

                        if (debug_) std::cout<<"Tracker:: ";
                        if (subdetector == ResidualRefitting::PXB) {
                                PXBDetId id(detid.rawId());
                                layer   = id.layer();
                                ladder  = id.ladder();
                                module  = id.module();
                                if (debug_)     std::cout       <<      "PXB"
                                                                                <<      "\tlayer = "    << layer
                                                                                <<      "\tladder = "   << ladder
                                                                                <<      "\tmodule = "   << module;
                                
                        } 
                        else if (subdetector == ResidualRefitting::PXF) {
                                PXFDetId id(detid.rawId());
                                side    = id.side();
                                disk    = id.disk();
                                blade   = id.blade();
                                panel   = id.panel();
                                module  = id.module();
                                if (debug_)     std::cout       <<  "PXF"
                                                                                <<      "\tside = "             << side
                                                                                <<      "\tdisk = "             << disk
                                                                                <<      "\tblade = "    << blade
                                                                                <<      "\tpanel = "    << panel
                                                                                <<      "\tmodule = "   << module;
                                                        
                        }
                        else if (subdetector == ResidualRefitting::TIB) {
                                TIBDetId id(detid.rawId());
                                layer   = id.layer();
                                module  = id.module();
                                if (debug_)     std::cout       << "TIB"
                                                                                << "\tlayer = " << layer
                                                                                << "\tmodule = "<< module;
                        }
                        else if (subdetector == ResidualRefitting::TID) {
                                TIDDetId id(detid.rawId());
                                side    = id.side();
                                wheel   = id.wheel();
                                ring    = id.ring();
                                if (debug_)     std::cout       <<"TID"
                                                                                << "\tside = "  << side
                                                                                << "\twheel = " << wheel
                                                                                << "\tring = "  << ring;
                        
                        }
                        else if (subdetector == ResidualRefitting::TOB) {
                                TOBDetId id(detid.rawId());
                                layer   = id.layer();
                                module  = id.module();
                                if (debug_)     std::cout       <<"TOB"
                                                                                <<"\tlayer = "  << layer
                                                                                <<"\tmodule = " << module;
                        
                        }
                        else if (subdetector == ResidualRefitting::TEC) {
                                TECDetId id(detid.rawId());
                                ring    = id.ring();
                                module  = id.module();
                                if (debug_)     std::cout       <<"TEC"
                                                                                << "\tring = "  << ring
                                                                                << "\tmodule = "<< module;
                        }


//Do Storage

                        storageTrackHit_.muonLink_              [iRec] =iTrack          ;
                        storageTrackHit_.detector_              [iRec] =detector        ;
                        storageTrackHit_.subdetector_   [iRec] =subdetector ;
                        storageTrackHit_.blade_                 [iRec] =blade           ;
                        storageTrackHit_.disk_                  [iRec] =disk            ;
                        storageTrackHit_.ladder_                [iRec] =ladder          ;
                        storageTrackHit_.layer_                 [iRec] =layer           ;
                        storageTrackHit_.module_                [iRec] =module          ;
                        storageTrackHit_.panel_                 [iRec] =panel           ;
                        storageTrackHit_.ring_                  [iRec] =ring            ;
                        storageTrackHit_.side_                  [iRec] =side            ;
                        storageTrackHit_.wheel_                 [iRec] =wheel           ;
                        
}

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

Definition at line 695 of file ResidualRefitting.cc.

References gather_cfg::cout, debug_, DetId::det(), PV3DBase< T, PVType, FrameType >::eta(), TrajectoryStateOnSurface::globalPosition(), ResidualRefitting::StorageTrackExtrap::gpEta_, ResidualRefitting::StorageTrackExtrap::gpPhi_, ResidualRefitting::StorageTrackExtrap::gpX_, ResidualRefitting::StorageTrackExtrap::gpY_, ResidualRefitting::StorageTrackExtrap::gpZ_, TrajectoryStateOnSurface::isValid(), TrajectoryStateOnSurface::localPosition(), ResidualRefitting::StorageTrackExtrap::lpX_, ResidualRefitting::StorageTrackExtrap::lpY_, ResidualRefitting::StorageTrackExtrap::lpZ_, DetId::Muon, ResidualRefitting::StorageTrackExtrap::muonLink_, PV3DBase< T, PVType, FrameType >::phi(), ResidualRefitting::StorageTrackExtrap::recLink_, ResidualRefitting::StorageTrackExtrap::resX_, ResidualRefitting::StorageTrackExtrap::resY_, ResidualRefitting::StorageTrackExtrap::resZ_, ReturnSector(), ReturnStation(), GeomDet::surface(), thePropagator, theService, align::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_) std::cout<< "In the trkExtrap function"<<std::endl;

        float gpExtrapX         = -99999;
        float gpExtrapY         = -99999;
        float gpExtrapZ         = -99999;
        float gpExtrapEta       = -99999;
        float gpExtrapPhi       = -99999;

        float lpX                       = -99999;
        float lpY                       = -99999;
        float lpZ                       = -99999;

        //
        // Get the local positions for the recHits
        //

        float recLpX = recPoint.x();
        float recLpY = recPoint.y();
        float recLpZ = recPoint.z();

        float resX = -9999;
        float resY = -9999;
        float resZ = -9999;

        const GeomDet* gdet = theService->trackingGeometry()->idToDet(detid);
        
//      TrajectoryStateOnSurface surfTest =  prop.propagate(freeTrajState, gdet->surface());
        TrajectoryStateOnSurface surfTest =  thePropagator->propagate(freeTrajState, gdet->surface());
        
        if (surfTest.isValid()) {
        
                GlobalPoint globTest    = surfTest.globalPosition();            
                gpExtrapX                               = globTest.x();
                gpExtrapY                               = globTest.y();
                gpExtrapZ                               = globTest.z();
                gpExtrapEta                             = globTest.eta();
                gpExtrapPhi                             = globTest.phi();
                LocalPoint loc                  = surfTest.localPosition();
                if (detid.det() == DetId::Muon || detid.det() == DetId::Tracker) {
                        lpX                                             = loc.x();
                        lpY                                             = loc.y();
                        lpZ                                             = loc.z();

                        resX = lpX - recLpX;
                        resY = lpY - recLpY;
                        resZ = lpZ - recLpZ;
                        
                }

        }
        storeTemp.muonLink_     [iTrk] = iTrkLink       ;
        storeTemp.recLink_      [iTrk] = iRec           ;
        storeTemp.gpX_          [iTrk] = gpExtrapX      ;
        storeTemp.gpY_          [iTrk] = gpExtrapY      ;
        storeTemp.gpZ_          [iTrk] = gpExtrapZ      ;
        storeTemp.gpEta_        [iTrk] = gpExtrapEta;
        storeTemp.gpPhi_        [iTrk] = gpExtrapPhi;   
        storeTemp.lpX_          [iTrk] = lpX            ;
        storeTemp.lpY_          [iTrk] = lpY            ;
        storeTemp.lpZ_          [iTrk] = lpZ            ;
        storeTemp.resX_         [iTrk] = resX           ;
        storeTemp.resY_         [iTrk] = resY           ;
        storeTemp.resZ_         [iTrk] = resZ           ;
        
        printf("station: %d\tsector: %d\tresX storage: %4.2f\n", ReturnStation(detid), ReturnSector(detid), resX);

}

void ResidualRefitting::zero_muon

(

ResidualRefitting::storage_muon *

str

)

Definition at line 969 of file ResidualRefitting.cc.

References ResidualRefitting::StorageMuon::chiSq_, ResidualRefitting::StorageMuon::chiSqOvrNdf_, ResidualRefitting::StorageMuon::eta_, i, ResidualRefitting::StorageMuon::n_, N_MAX_STORED, ResidualRefitting::StorageMuon::ndf_, ResidualRefitting::StorageMuon::numRecHits_, ResidualRefitting::StorageMuon::p_, ResidualRefitting::StorageMuon::phi_, and ResidualRefitting::StorageMuon::pt_.

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

}

void ResidualRefitting::zero_storage

(

)

Definition at line 869 of file ResidualRefitting.cc.

References debug_, ResidualRefitting::StorageTrackHit::n_, ResidualRefitting::StorageHit::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;

}

void ResidualRefitting::zero_trackExtrap

(

ResidualRefitting::storage_trackExtrap *

str

)

Definition at line 989 of file ResidualRefitting.cc.

References ResidualRefitting::StorageTrackExtrap::gpEta_, ResidualRefitting::StorageTrackExtrap::gpPhi_, ResidualRefitting::StorageTrackExtrap::gpX_, ResidualRefitting::StorageTrackExtrap::gpY_, ResidualRefitting::StorageTrackExtrap::gpZ_, i, ResidualRefitting::StorageTrackExtrap::lpX_, ResidualRefitting::StorageTrackExtrap::lpY_, ResidualRefitting::StorageTrackExtrap::lpZ_, ResidualRefitting::StorageTrackExtrap::muonLink_, ResidualRefitting::StorageTrackExtrap::n_, N_MAX_STORED_HIT, ResidualRefitting::StorageTrackExtrap::recLink_, ResidualRefitting::StorageTrackExtrap::resX_, ResidualRefitting::StorageTrackExtrap::resY_, and ResidualRefitting::StorageTrackExtrap::resZ_.

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

bool ResidualRefitting::debug_

Definition at line 356 of file ResidualRefitting.h.

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

ResidualRefitting::storage_event ResidualRefitting::eventInfo_

Definition at line 61 of file ResidualRefitting.h.

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

edm::InputTag ResidualRefitting::muons_

Definition at line 344 of file ResidualRefitting.h.

Referenced by analyze().

edm::InputTag ResidualRefitting::muonsNoPXBLayer1_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoPXBLayer2_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoPXBLayer3_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoPXF_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoStation1_

Definition at line 344 of file ResidualRefitting.h.

Referenced by analyze().

edm::InputTag ResidualRefitting::muonsNoStation2_

Definition at line 344 of file ResidualRefitting.h.

Referenced by analyze().

edm::InputTag ResidualRefitting::muonsNoStation3_

Definition at line 344 of file ResidualRefitting.h.

Referenced by analyze().

edm::InputTag ResidualRefitting::muonsNoStation4_

Definition at line 344 of file ResidualRefitting.h.

Referenced by analyze().

edm::InputTag ResidualRefitting::muonsNoTEC_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTIBLayer1_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTIBLayer2_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTIBLayer3_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTIBLayer4_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTID_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTOBLayer1_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTOBLayer2_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTOBLayer3_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTOBLayer4_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTOBLayer5_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsNoTOBLayer6_

Definition at line 344 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::muonsRemake_

Definition at line 344 of file ResidualRefitting.h.

Referenced by analyze().

const int ResidualRefitting::N_MAX_STORED = 10 [static, private]

Definition at line 40 of file ResidualRefitting.h.

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

const int ResidualRefitting::N_MAX_STORED_HIT = 1000 [static, private]

Definition at line 41 of file ResidualRefitting.h.

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

TBranch* ResidualRefitting::outputBranch_

Definition at line 362 of file ResidualRefitting.h.

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

TFile* ResidualRefitting::outputFile_

Definition at line 359 of file ResidualRefitting.h.

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

std::string ResidualRefitting::outputFileName_

Definition at line 339 of file ResidualRefitting.h.

Referenced by beginJob().

TTree* ResidualRefitting::outputTree_

Definition at line 361 of file ResidualRefitting.h.

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

std::string ResidualRefitting::PropagatorSource_

Definition at line 341 of file ResidualRefitting.h.

Referenced by analyze().

const int ResidualRefitting::PXB = 1 [static, private]

Definition at line 43 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

const int ResidualRefitting::PXF = 2 [static, private]

Definition at line 44 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

ResidualRefitting::storage_trackExtrap ResidualRefitting::samExtrap120_

Definition at line 266 of file ResidualRefitting.h.

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

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNew_

Definition at line 236 of file ResidualRefitting.h.

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

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer1

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer2

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXBLayer3

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoPXF

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt1_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt2_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt3_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoSt4_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTEC

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer1

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer2

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer3

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTIBLayer4

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTID

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer1

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer2

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer3

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer4

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer5

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrNoTOBLayer6

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageGmrOld_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_hit ResidualRefitting::storageRecMuon_

Definition at line 258 of file ResidualRefitting.h.

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

ResidualRefitting::storage_muon ResidualRefitting::storageSamNew_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt1_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt2_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt3_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageSamNoSt4_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRec_

Definition at line 262 of file ResidualRefitting.h.

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

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt1_

Definition at line 262 of file ResidualRefitting.h.

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

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt2_

Definition at line 262 of file ResidualRefitting.h.

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

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt3_

Definition at line 262 of file ResidualRefitting.h.

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

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapRecNoSt4_

Definition at line 262 of file ResidualRefitting.h.

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

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackExtrapTracker_

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackHit ResidualRefitting::storageTrackHit_

Definition at line 259 of file ResidualRefitting.h.

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

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer1

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer2

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXBLayer3

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoPXF

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTEC

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer1

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer2

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer3

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTIBLayer4

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTID

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer1

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer2

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer3

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer4

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer5

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_trackExtrap ResidualRefitting::storageTrackNoTOBLayer6

Definition at line 269 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNew_

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer1

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer2

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXBLayer3

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoPXF

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTEC

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer1

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer2

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer3

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTIBLayer4

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTID

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer1

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer2

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer3

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer4

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer5

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

ResidualRefitting::storage_muon ResidualRefitting::storageTrkNoTOBLayer6

Definition at line 236 of file ResidualRefitting.h.

Referenced by beginJob(), and zero_storage().

const int ResidualRefitting::TEC = 6 [static, private]

Definition at line 48 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

const MagneticField* ResidualRefitting::theField

Definition at line 366 of file ResidualRefitting.h.

Referenced by analyze(), and freeTrajStateMuon().

edm::ESHandle<Propagator> ResidualRefitting::thePropagator

Definition at line 369 of file ResidualRefitting.h.

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

MuonServiceProxy* ResidualRefitting::theService

Definition at line 368 of file ResidualRefitting.h.

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

const int ResidualRefitting::TIB = 3 [static, private]

Definition at line 45 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

const int ResidualRefitting::TID = 4 [static, private]

Definition at line 46 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

const int ResidualRefitting::TOB = 5 [static, private]

Definition at line 47 of file ResidualRefitting.h.

Referenced by StoreTrackerRecHits().

ResidualRefitting::storage_trackExtrap ResidualRefitting::trackExtrap120_

Definition at line 266 of file ResidualRefitting.h.

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

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

Definition at line 367 of file ResidualRefitting.h.

edm::InputTag ResidualRefitting::tracks_

Definition at line 344 of file ResidualRefitting.h.