#include <ResidualRefitting.h>

Inheritance diagram for ResidualRefitting:

Classes
struct	storage_event

struct	StorageHit

struct	StorageMuon

struct	StorageTrackExtrap

struct	StorageTrackHit

Public Types
typedef struct ResidualRefitting::StorageHit	storage_hit

typedef struct ResidualRefitting::StorageMuon	storage_muon

typedef struct ResidualRefitting::StorageTrackExtrap	storage_trackExtrap

typedef struct ResidualRefitting::StorageTrackHit	storage_trackHit

Public Types inherited from edm::EDAnalyzer
typedef EDAnalyzer	ModuleType

typedef WorkerT< EDAnalyzer >	WorkerType

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 Member Functions inherited from edm::EDAnalyzer
	EDAnalyzer ()

std::string	workerType () const

virtual	~EDAnalyzer ()

Public Attributes
bool	debug_

ResidualRefitting::storage_event	eventInfo_

edm::InputTag	muons_

edm::InputTag	muonsNoPXBLayer1_

edm::InputTag	muonsNoPXBLayer2_

edm::InputTag	muonsNoPXBLayer3_

edm::InputTag	muonsNoPXF_

edm::InputTag	muonsNoStation1_

edm::InputTag	muonsNoStation2_

edm::InputTag	muonsNoStation3_

edm::InputTag	muonsNoStation4_

edm::InputTag	muonsNoTEC_

edm::InputTag	muonsNoTIBLayer1_

edm::InputTag	muonsNoTIBLayer2_

edm::InputTag	muonsNoTIBLayer3_

edm::InputTag	muonsNoTIBLayer4_

edm::InputTag	muonsNoTID_

edm::InputTag	muonsNoTOBLayer1_

edm::InputTag	muonsNoTOBLayer2_

edm::InputTag	muonsNoTOBLayer3_

edm::InputTag	muonsNoTOBLayer4_

edm::InputTag	muonsNoTOBLayer5_

edm::InputTag	muonsNoTOBLayer6_

edm::InputTag	muonsRemake_

TBranch *	outputBranch_

TFile *	outputFile_

std::string	outputFileName_

TTree *	outputTree_

std::string	PropagatorSource_

ResidualRefitting::storage_trackExtrap	samExtrap120_

ResidualRefitting::storage_muon	storageGmrNew_

ResidualRefitting::storage_muon	storageGmrNoPXBLayer1

ResidualRefitting::storage_muon	storageGmrNoPXBLayer2

ResidualRefitting::storage_muon	storageGmrNoPXBLayer3

ResidualRefitting::storage_muon	storageGmrNoPXF

ResidualRefitting::storage_muon	storageGmrNoSt1_

ResidualRefitting::storage_muon	storageGmrNoSt2_

ResidualRefitting::storage_muon	storageGmrNoSt3_

ResidualRefitting::storage_muon	storageGmrNoSt4_

ResidualRefitting::storage_muon	storageGmrNoTEC

ResidualRefitting::storage_muon	storageGmrNoTIBLayer1

ResidualRefitting::storage_muon	storageGmrNoTIBLayer2

ResidualRefitting::storage_muon	storageGmrNoTIBLayer3

ResidualRefitting::storage_muon	storageGmrNoTIBLayer4

ResidualRefitting::storage_muon	storageGmrNoTID

ResidualRefitting::storage_muon	storageGmrNoTOBLayer1

ResidualRefitting::storage_muon	storageGmrNoTOBLayer2

ResidualRefitting::storage_muon	storageGmrNoTOBLayer3

ResidualRefitting::storage_muon	storageGmrNoTOBLayer4

ResidualRefitting::storage_muon	storageGmrNoTOBLayer5

ResidualRefitting::storage_muon	storageGmrNoTOBLayer6

ResidualRefitting::storage_muon	storageGmrOld_

ResidualRefitting::storage_hit	storageRecMuon_

ResidualRefitting::storage_muon	storageSamNew_

ResidualRefitting::storage_muon	storageSamNoSt1_

ResidualRefitting::storage_muon	storageSamNoSt2_

ResidualRefitting::storage_muon	storageSamNoSt3_

ResidualRefitting::storage_muon	storageSamNoSt4_

ResidualRefitting::storage_trackExtrap	storageTrackExtrapRec_

ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt1_

ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt2_

ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt3_

ResidualRefitting::storage_trackExtrap	storageTrackExtrapRecNoSt4_

ResidualRefitting::storage_trackExtrap	storageTrackExtrapTracker_

ResidualRefitting::storage_trackHit	storageTrackHit_

ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer1

ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer2

ResidualRefitting::storage_trackExtrap	storageTrackNoPXBLayer3

ResidualRefitting::storage_trackExtrap	storageTrackNoPXF

ResidualRefitting::storage_trackExtrap	storageTrackNoTEC

ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer1

ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer2

ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer3

ResidualRefitting::storage_trackExtrap	storageTrackNoTIBLayer4

ResidualRefitting::storage_trackExtrap	storageTrackNoTID

ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer1

ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer2

ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer3

ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer4

ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer5

ResidualRefitting::storage_trackExtrap	storageTrackNoTOBLayer6

ResidualRefitting::storage_muon	storageTrkNew_

ResidualRefitting::storage_muon	storageTrkNoPXBLayer1

ResidualRefitting::storage_muon	storageTrkNoPXBLayer2

ResidualRefitting::storage_muon	storageTrkNoPXBLayer3

ResidualRefitting::storage_muon	storageTrkNoPXF

ResidualRefitting::storage_muon	storageTrkNoTEC

ResidualRefitting::storage_muon	storageTrkNoTIBLayer1

ResidualRefitting::storage_muon	storageTrkNoTIBLayer2

ResidualRefitting::storage_muon	storageTrkNoTIBLayer3

ResidualRefitting::storage_muon	storageTrkNoTIBLayer4

ResidualRefitting::storage_muon	storageTrkNoTID

ResidualRefitting::storage_muon	storageTrkNoTOBLayer1

ResidualRefitting::storage_muon	storageTrkNoTOBLayer2

ResidualRefitting::storage_muon	storageTrkNoTOBLayer3

ResidualRefitting::storage_muon	storageTrkNoTOBLayer4

ResidualRefitting::storage_muon	storageTrkNoTOBLayer5

ResidualRefitting::storage_muon	storageTrkNoTOBLayer6

const MagneticField *	theField

edm::ESHandle< Propagator >	thePropagator

MuonServiceProxy *	theService

ResidualRefitting::storage_trackExtrap	trackExtrap120_

const edm::ESHandle < GlobalTrackingGeometry >	trackingGeometry

edm::InputTag	tracks_

Static Private Attributes
static const int	N_MAX_STORED = 10

static const int	N_MAX_STORED_HIT = 1000

static const int	PXB = 1

static const int	PXF = 2

static const int	TEC = 6

static const int	TIB = 3

static const int	TID = 4

static const int	TOB = 5

Additional Inherited Members
Static Public Member Functions inherited from edm::EDAnalyzer
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDAnalyzer
CurrentProcessingContext const *	currentContext () const

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::StorageMuon::n_, ResidualRefitting::StorageTrackExtrap::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.

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 Cylinder::build(), debug_, PV3DBase< T, PVType, FrameType >::eta(), freeTrajStateMuon(), TrajectoryStateOnSurface::globalPosition(), ResidualRefitting::StorageTrackExtrap::gpEta_, ResidualRefitting::StorageTrackExtrap::gpPhi_, ResidualRefitting::StorageTrackExtrap::gpX_, ResidualRefitting::StorageTrackExtrap::gpY_, ResidualRefitting::StorageTrackExtrap::gpZ_, TrajectoryStateOnSurface::isValid(), ResidualRefitting::StorageTrackExtrap::muonLink_, PV3DBase< T, PVType, FrameType >::phi(), 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, errorMatrix2Lands_multiChannel::id, DetId::Muon, DetId::rawId(), 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, errorMatrix2Lands_multiChannel::id, DetId::Muon, DetId::rawId(), MuonSubdetId::RPC, relativeConstraints::station, and DetId::subdetId().

Referenced by trkExtrap().

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

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

Definition at line 568 of file ResidualRefitting.cc.

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.

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

Referenced by analyze().

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

void ResidualRefitting::zero_trackExtrap ( ResidualRefitting::storage_trackExtrap * str )

Definition at line 989 of file ResidualRefitting.cc.

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