MuonTimingFiller Class Reference

#include <RecoMuon/MuonIdentification/src/MuonTimingFiller.cc>

Public Member Functions
void	fillTiming (const reco::Muon &muon, reco::MuonTimeExtra &dtTime, reco::MuonTimeExtra &cscTime, reco::MuonTime &rpcTime, reco::MuonTimeExtra &combinedTime, edm::Event &iEvent, const edm::EventSetup &iSetup)
	MuonTimingFiller (const edm::ParameterSet &, edm::ConsumesCollector &&iC)
	~MuonTimingFiller ()

Private Member Functions
void	addEcalTime (const reco::Muon &muon, TimeMeasurementSequence &cmbSeq)
void	combineTMSequences (const reco::Muon &muon, const TimeMeasurementSequence &dtSeq, const TimeMeasurementSequence &cscSeq, TimeMeasurementSequence &cmbSeq)
void	fillRPCTime (const reco::Muon &muon, reco::MuonTime &muTime, edm::Event &iEvent)
void	fillTimeFromMeasurements (const TimeMeasurementSequence &tmSeq, reco::MuonTimeExtra &muTime)
void	rawFit (double &a, double &da, double &b, double &db, const std::vector< double > &hitsx, const std::vector< double > &hitsy)

Private Attributes
double	ecalEcut_
double	errorEB_
double	errorEE_
std::unique_ptr< CSCTimingExtractor >	theCSCTimingExtractor_
std::unique_ptr< DTTimingExtractor >	theDTTimingExtractor_
std::unique_ptr< MuonSegmentMatcher >	theMatcher_
bool	useCSC_
bool	useDT_
bool	useECAL_

Detailed Description

Description: Class filling the DT, CSC and Combined MuonTimeExtra objects

Implementation: <Notes on="" implementation>="">

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 42 of file MuonTimingFiller.h.

Constructor & Destructor Documentation

MuonTimingFiller::MuonTimingFiller	(	const edm::ParameterSet &	iConfig,
		edm::ConsumesCollector &&	iC
	)

Definition at line 44 of file MuonTimingFiller.cc.

References ecalEcut_, errorEB_, errorEE_, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), theCSCTimingExtractor_, theDTTimingExtractor_, theMatcher_, useCSC_, useDT_, and useECAL_.

{
   // Load parameters for the DTTimingExtractor
   edm::ParameterSet dtTimingParameters = iConfig.getParameter<edm::ParameterSet>("DTTimingParameters");

   // Load parameters for the CSCTimingExtractor
   edm::ParameterSet cscTimingParameters = iConfig.getParameter<edm::ParameterSet>("CSCTimingParameters");

   // Fallback mechanism for old configs (there the segment matcher was built inside the timing extractors)
   edm::ParameterSet matchParameters;
   if (iConfig.existsAs<edm::ParameterSet>("MatchParameters")) 
       matchParameters = iConfig.getParameter<edm::ParameterSet>("MatchParameters");
     else 
       matchParameters = dtTimingParameters.getParameter<edm::ParameterSet>("MatchParameters");
   
   theMatcher_ = std::make_unique<MuonSegmentMatcher>(matchParameters, iC);
   theDTTimingExtractor_ = std::make_unique<DTTimingExtractor>(dtTimingParameters,theMatcher_.get());
   theCSCTimingExtractor_ = std::make_unique<CSCTimingExtractor>(cscTimingParameters,theMatcher_.get());
   
   errorEB_ = iConfig.getParameter<double>("ErrorEB");
   errorEE_ = iConfig.getParameter<double>("ErrorEE");
   ecalEcut_ = iConfig.getParameter<double>("EcalEnergyCut");
   
   useDT_ = iConfig.getParameter<bool>("UseDT");
   useCSC_ = iConfig.getParameter<bool>("UseCSC");
   useECAL_ = iConfig.getParameter<bool>("UseECAL");
   
}

MuonTimingFiller::~MuonTimingFiller

(

)

Definition at line 74 of file MuonTimingFiller.cc.

{
}

Member Function Documentation

void MuonTimingFiller::addEcalTime ( const reco::Muon &  muon, TimeMeasurementSequence &  cmbSeq  )

private

Definition at line 262 of file MuonTimingFiller.cc.

References reco::Muon::calEnergy(), TimeMeasurementSequence::dstnc, reco::MuonEnergy::ecal_id, reco::MuonEnergy::ecal_position, reco::MuonEnergy::ecal_time, EcalBarrel, ecalEcut_, reco::MuonEnergy::emMax, errorEB_, errorEE_, reco::Muon::isEnergyValid(), TimeMeasurementSequence::local_t0, DetId::subdetId(), TimeMeasurementSequence::totalWeightInvbeta, TimeMeasurementSequence::totalWeightTimeVtx, TimeMeasurementSequence::weightInvbeta, and TimeMeasurementSequence::weightTimeVtx.

Referenced by fillTiming().

                                                                 {

  reco::MuonEnergy muonE;
  if (muon.isEnergyValid())  
    muonE = muon.calEnergy();
  
  // Cut on the crystal energy and restrict to the ECAL barrel for now
//  if (muonE.emMax<ecalEcut_ || fabs(muon.eta())>1.5) return;    
  if (muonE.emMax<ecalEcut_) return;    
  
  // A simple parametrization of the error on the ECAL time measurement
  double emErr;
  if (muonE.ecal_id.subdetId()==EcalBarrel) emErr= errorEB_/muonE.emMax; else
    emErr=errorEE_/muonE.emMax;
  double hitWeight = 1/(emErr*emErr);
  double hitDist=muonE.ecal_position.r();
        
  cmbSeq.local_t0.push_back(muonE.ecal_time);
  cmbSeq.weightTimeVtx.push_back(hitWeight);
  cmbSeq.weightInvbeta.push_back(hitDist*hitDist*hitWeight/(30.*30.));

  cmbSeq.dstnc.push_back(hitDist);
  
  cmbSeq.totalWeightTimeVtx+=hitWeight;
  cmbSeq.totalWeightInvbeta+=hitDist*hitDist*hitWeight/(30.*30.);
                                      
}

void MuonTimingFiller::combineTMSequences ( const reco::Muon &  muon, const TimeMeasurementSequence &  dtSeq, const TimeMeasurementSequence &  cscSeq, TimeMeasurementSequence &  cmbSeq  )

private

Definition at line 234 of file MuonTimingFiller.cc.

References TimeMeasurementSequence::dstnc, mps_fire::i, TimeMeasurementSequence::local_t0, TimeMeasurementSequence::totalWeightInvbeta, TimeMeasurementSequence::totalWeightTimeVtx, useCSC_, useDT_, TimeMeasurementSequence::weightInvbeta, and TimeMeasurementSequence::weightTimeVtx.

Referenced by fillTiming().

                                                                        {
                                        
  if (useDT_) for (unsigned int i=0;i<dtSeq.dstnc.size();i++) {
    cmbSeq.dstnc.push_back(dtSeq.dstnc.at(i));
    cmbSeq.local_t0.push_back(dtSeq.local_t0.at(i));
    cmbSeq.weightTimeVtx.push_back(dtSeq.weightTimeVtx.at(i));
    cmbSeq.weightInvbeta.push_back(dtSeq.weightInvbeta.at(i));

    cmbSeq.totalWeightTimeVtx+=dtSeq.weightTimeVtx.at(i);
    cmbSeq.totalWeightInvbeta+=dtSeq.weightInvbeta.at(i);
  }

  if (useCSC_) for (unsigned int i=0;i<cscSeq.dstnc.size();i++) {
    cmbSeq.dstnc.push_back(cscSeq.dstnc.at(i));
    cmbSeq.local_t0.push_back(cscSeq.local_t0.at(i));
    cmbSeq.weightTimeVtx.push_back(cscSeq.weightTimeVtx.at(i));
    cmbSeq.weightInvbeta.push_back(cscSeq.weightInvbeta.at(i));

    cmbSeq.totalWeightTimeVtx+=cscSeq.weightTimeVtx.at(i);
    cmbSeq.totalWeightInvbeta+=cscSeq.weightInvbeta.at(i);
  }
}

void MuonTimingFiller::fillRPCTime ( const reco::Muon &  muon, reco::MuonTime &  muTime, edm::Event &  iEvent  )

private

Definition at line 202 of file MuonTimingFiller.cc.

References edm::Ref< C, T, F >::isNull(), SiStripPI::max, reco::MuonTime::nDof, mathSSE::sqrt(), reco::Muon::standAloneMuon(), theMatcher_, ntuplemaker::time, reco::MuonTime::timeAtIpInOut, reco::MuonTime::timeAtIpInOutErr, reco::MuonTime::timeAtIpOutIn, and reco::MuonTime::timeAtIpOutInErr.

Referenced by fillTiming().

                                                                                             {

  double trpc=0,trpc2=0;

  reco::TrackRef staTrack = muon.standAloneMuon();
  if (staTrack.isNull()) return;

  const std::vector<const RPCRecHit*> rpcHits = theMatcher_->matchRPC(*staTrack,iEvent);
  const int nrpc = rpcHits.size();
  for ( const auto& hitRPC : rpcHits ) {
    const double time = hitRPC->timeError() < 0 ? hitRPC->BunchX()*25. : hitRPC->time();
    trpc += time;
    trpc2 += time*time;
  }

  if (nrpc==0) return;
  
  trpc2 = trpc2/nrpc;
  trpc = trpc/nrpc;
  const double trpcerr = sqrt(std::max(0., trpc2-trpc*trpc));

  rpcTime.timeAtIpInOut=trpc;
  rpcTime.timeAtIpInOutErr=trpcerr;
  rpcTime.nDof=nrpc;

  // currently unused
  rpcTime.timeAtIpOutIn=0.;
  rpcTime.timeAtIpOutInErr=0.;
}

void MuonTimingFiller::fillTimeFromMeasurements ( const TimeMeasurementSequence &  tmSeq, reco::MuonTimeExtra &  muTime  )

private

Definition at line 154 of file MuonTimingFiller.cc.

References diffTreeTool::diff, TimeMeasurementSequence::dstnc, mps_fire::i, TimeMeasurementSequence::local_t0, rawFit(), reco::MuonTimeExtra::setFreeInverseBeta(), reco::MuonTimeExtra::setFreeInverseBetaErr(), reco::MuonTimeExtra::setInverseBeta(), reco::MuonTimeExtra::setInverseBetaErr(), reco::MuonTimeExtra::setNDof(), reco::MuonTimeExtra::setTimeAtIpInOut(), reco::MuonTimeExtra::setTimeAtIpInOutErr(), reco::MuonTimeExtra::setTimeAtIpOutIn(), reco::MuonTimeExtra::setTimeAtIpOutInErr(), mathSSE::sqrt(), TimeMeasurementSequence::totalWeightInvbeta, TimeMeasurementSequence::totalWeightTimeVtx, TimeMeasurementSequence::weightInvbeta, TimeMeasurementSequence::weightTimeVtx, x, and y.

Referenced by fillTiming().

                                                                                                            {
  std::vector <double> x,y;
  double invbeta(0), invbetaerr(0);
  double vertexTime(0), vertexTimeErr(0), vertexTimeR(0), vertexTimeRErr(0);    
  double freeBeta(0), freeBetaErr(0), freeTime(0), freeTimeErr(0);

  if (tmSeq.dstnc.size()<=1) return;

  for (unsigned int i=0;i<tmSeq.dstnc.size();i++) {
    invbeta+=(1.+tmSeq.local_t0.at(i)/tmSeq.dstnc.at(i)*30.)*tmSeq.weightInvbeta.at(i)/tmSeq.totalWeightInvbeta;
    x.push_back(tmSeq.dstnc.at(i)/30.);
    y.push_back(tmSeq.local_t0.at(i)+tmSeq.dstnc.at(i)/30.);
    vertexTime+=tmSeq.local_t0.at(i)*tmSeq.weightTimeVtx.at(i)/tmSeq.totalWeightTimeVtx;
    vertexTimeR+=(tmSeq.local_t0.at(i)+2*tmSeq.dstnc.at(i)/30.)*tmSeq.weightTimeVtx.at(i)/tmSeq.totalWeightTimeVtx;
  }

  double diff;
  for (unsigned int i=0;i<tmSeq.dstnc.size();i++) {
    diff=(1.+tmSeq.local_t0.at(i)/tmSeq.dstnc.at(i)*30.)-invbeta;
    invbetaerr+=diff*diff*tmSeq.weightInvbeta.at(i);
    diff=tmSeq.local_t0.at(i)-vertexTime;
    vertexTimeErr+=diff*diff*tmSeq.weightTimeVtx.at(i);
    diff=tmSeq.local_t0.at(i)+2*tmSeq.dstnc.at(i)/30.-vertexTimeR;
    vertexTimeRErr+=diff*diff*tmSeq.weightTimeVtx.at(i);
  }
  
  double cf = 1./(tmSeq.dstnc.size()-1);
  invbetaerr=sqrt(invbetaerr/tmSeq.totalWeightInvbeta*cf);
  vertexTimeErr=sqrt(vertexTimeErr/tmSeq.totalWeightTimeVtx*cf);
  vertexTimeRErr=sqrt(vertexTimeRErr/tmSeq.totalWeightTimeVtx*cf);

  muTime.setInverseBeta(invbeta);
  muTime.setInverseBetaErr(invbetaerr);
  muTime.setTimeAtIpInOut(vertexTime);
  muTime.setTimeAtIpInOutErr(vertexTimeErr);
  muTime.setTimeAtIpOutIn(vertexTimeR);
  muTime.setTimeAtIpOutInErr(vertexTimeRErr);
      
  rawFit(freeBeta, freeBetaErr, freeTime, freeTimeErr, x, y);

  muTime.setFreeInverseBeta(freeBeta);
  muTime.setFreeInverseBetaErr(freeBetaErr);
    
  muTime.setNDof(tmSeq.dstnc.size());
}

void MuonTimingFiller::fillTiming	(	const reco::Muon &	muon,
		reco::MuonTimeExtra &	dtTime,
		reco::MuonTimeExtra &	cscTime,
		reco::MuonTime &	rpcTime,
		reco::MuonTimeExtra &	combinedTime,
		edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

Definition at line 84 of file MuonTimingFiller.cc.

References addEcalTime(), reco::MuonSegmentMatch::BelongsToTrackByDR, reco::MuonSegmentMatch::BestInStationByDR, relativeConstraints::chamber, reco::Muon::combinedMuon(), combineTMSequences(), cscSegments_cfi::cscSegments, reco::MuonTimeExtra::direction(), fillRPCTime(), fillTimeFromMeasurements(), reco::MuonTimeExtra::freeInverseBeta(), reco::MuonTimeExtra::freeInverseBetaErr(), iEvent, reco::Muon::innerTrack(), reco::MuonTimeExtra::inverseBeta(), reco::MuonTimeExtra::inverseBetaErr(), edm::Ref< C, T, F >::isNull(), reco::Muon::isTrackerMuon(), LogTrace, reco::Muon::matches(), reco::MuonTimeExtra::nDof(), reco::Muon::standAloneMuon(), theCSCTimingExtractor_, theDTTimingExtractor_, reco::MuonTimeExtra::timeAtIpInOut(), reco::MuonTimeExtra::timeAtIpInOutErr(), reco::MuonTimeExtra::timeAtIpOutIn(), reco::MuonTimeExtra::timeAtIpOutInErr(), and useECAL_.

Referenced by MuonTimingProducer::produce(), and MuonIdProducer::produce().

{
  TimeMeasurementSequence dtTmSeq,cscTmSeq;
     
  if ( !(muon.combinedMuon().isNull()) ) {
    theDTTimingExtractor_->fillTiming(dtTmSeq, muon.combinedMuon(), iEvent, iSetup);
    theCSCTimingExtractor_->fillTiming(cscTmSeq, muon.combinedMuon(), iEvent, iSetup);
  } else {
    if ( !(muon.standAloneMuon().isNull()) ) {
      theDTTimingExtractor_->fillTiming(dtTmSeq, muon.standAloneMuon(), iEvent, iSetup);
      theCSCTimingExtractor_->fillTiming(cscTmSeq, muon.standAloneMuon(), iEvent, iSetup);
    } else {
      if ( muon.isTrackerMuon() ) {
    std::vector<const DTRecSegment4D*> dtSegments;
    std::vector<const CSCSegment*> cscSegments;
    for( auto& chamber: muon.matches() ){
      for ( auto& segment : chamber.segmentMatches ){
        // Use only the segments that passed arbitration to avoid mixing
        // segments from in-time and out-of-time muons that may bias the result
        // SegmentAndTrackArbitration
            if(segment.isMask(reco::MuonSegmentMatch::BestInStationByDR) &&
           segment.isMask(reco::MuonSegmentMatch::BelongsToTrackByDR)){
          if ( !(segment.dtSegmentRef.isNull()))
        dtSegments.push_back(segment.dtSegmentRef.get());
          if ( !(segment.cscSegmentRef.isNull()))
        cscSegments.push_back(segment.cscSegmentRef.get());
        }
      }
    }
    theDTTimingExtractor_->fillTiming(dtTmSeq, dtSegments, muon.innerTrack(), iEvent, iSetup);
    theCSCTimingExtractor_->fillTiming(cscTmSeq, cscSegments, muon.innerTrack(), iEvent, iSetup);
      }
    }
  }
  
  // Fill DT-specific timing information block     
  fillTimeFromMeasurements(dtTmSeq, dtTime);

  // Fill CSC-specific timing information block     
  fillTimeFromMeasurements(cscTmSeq, cscTime);

  // Fill RPC-specific timing information block     
  fillRPCTime(muon, rpcTime, iEvent);
       
  // Combine the TimeMeasurementSequences from DT/CSC subdetectors
  TimeMeasurementSequence combinedTmSeq;
  combineTMSequences(muon,dtTmSeq,cscTmSeq,combinedTmSeq);
  // add ECAL info
  if (useECAL_) addEcalTime(muon,combinedTmSeq);

  // Fill the master timing block
  fillTimeFromMeasurements(combinedTmSeq, combinedTime);
    
  LogTrace("MuonTime") << "Global 1/beta: " << combinedTime.inverseBeta() << " +/- " << combinedTime.inverseBetaErr()<<std::endl;
  LogTrace("MuonTime") << "  Free 1/beta: " << combinedTime.freeInverseBeta() << " +/- " << combinedTime.freeInverseBetaErr()<<std::endl;
  LogTrace("MuonTime") << "  Vertex time (in-out): " << combinedTime.timeAtIpInOut() << " +/- " << combinedTime.timeAtIpInOutErr()
                       << "  # of points: " << combinedTime.nDof() <<std::endl;
  LogTrace("MuonTime") << "  Vertex time (out-in): " << combinedTime.timeAtIpOutIn() << " +/- " << combinedTime.timeAtIpOutInErr()<<std::endl;
  LogTrace("MuonTime") << "  direction: "   << combinedTime.direction() << std::endl;
     
}

void MuonTimingFiller::rawFit ( double &  a, double &  da, double &  b, double &  db, const std::vector< double > &  hitsx, const std::vector< double > &  hitsy  )

private

Definition at line 294 of file MuonTimingFiller.cc.

References edmIntegrityCheck::d, mps_fire::i, alignCSCRings::s, mathSSE::sqrt(), fftjetcommon_cfi::sx, fftjetcommon_cfi::sy, x, and y.

Referenced by fillTimeFromMeasurements().

                                                                             {

  double s=0,sx=0,sy=0,x,y;
  double sxx=0,sxy=0;

  freeBeta = 0;
  freeBetaErr = 0;
  freeTime = 0;
  freeTimeErr = 0;

  if (hitsx.empty()) return;
  if (hitsx.size()==1) {
    freeTime=hitsy[0];
  } else {
    for (unsigned int i = 0; i != hitsx.size(); i++) {
      x=hitsx[i];
      y=hitsy[i];
      sy += y;
      sxy+= x*y;
      s += 1.;
      sx += x;
      sxx += x*x;
    }

    double d = s*sxx - sx*sx;
    freeTime = (sxx*sy- sx*sxy)/ d;
    freeBeta = (s*sxy - sx*sy) / d;
    freeBetaErr = sqrt(sxx/d);
    freeTimeErr = sqrt(s/d);
  }
}

Member Data Documentation

double MuonTimingFiller::ecalEcut_

private

Definition at line 63 of file MuonTimingFiller.h.

Referenced by addEcalTime(), and MuonTimingFiller().

double MuonTimingFiller::errorEB_

private

Definition at line 63 of file MuonTimingFiller.h.

Referenced by addEcalTime(), and MuonTimingFiller().

double MuonTimingFiller::errorEE_

private

Definition at line 63 of file MuonTimingFiller.h.

Referenced by addEcalTime(), and MuonTimingFiller().

std::unique_ptr<CSCTimingExtractor> MuonTimingFiller::theCSCTimingExtractor_

private

Definition at line 62 of file MuonTimingFiller.h.

Referenced by fillTiming(), and MuonTimingFiller().

std::unique_ptr<DTTimingExtractor> MuonTimingFiller::theDTTimingExtractor_

private

Definition at line 61 of file MuonTimingFiller.h.

Referenced by fillTiming(), and MuonTimingFiller().

std::unique_ptr<MuonSegmentMatcher> MuonTimingFiller::theMatcher_

private

Definition at line 60 of file MuonTimingFiller.h.

Referenced by fillRPCTime(), and MuonTimingFiller().

bool MuonTimingFiller::useCSC_

private

Definition at line 64 of file MuonTimingFiller.h.

Referenced by combineTMSequences(), and MuonTimingFiller().

bool MuonTimingFiller::useDT_

private

Definition at line 64 of file MuonTimingFiller.h.

Referenced by combineTMSequences(), and MuonTimingFiller().

bool MuonTimingFiller::useECAL_

private

Definition at line 64 of file MuonTimingFiller.h.

Referenced by fillTiming(), and MuonTimingFiller().