StandAloneMuonRefitter.cc

Go to the documentation of this file.

#include "RecoMuon/StandAloneTrackFinder/interface/StandAloneMuonRefitter.h"

#include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h"

#include "TrackingTools/TrackFitters/interface/TrajectoryFitter.h"

#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Framework/interface/EventSetup.h"
#include "TrackingTools/Records/interface/TrackingComponentsRecord.h"

using namespace edm;
using namespace std;

StandAloneMuonRefitter::StandAloneMuonRefitter(const ParameterSet& par, const MuonServiceProxy* service):theService(service) {
  LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "Constructor called." << endl;

  theFitterName = par.getParameter<string>("FitterName");
  theNumberOfIterations = par.getParameter<unsigned int>("NumberOfIterations");
  isForceAllIterations = par.getParameter<bool>("ForceAllIterations");
  theMaxFractionOfLostHits = par.getParameter<double>("MaxFractionOfLostHits");
  errorRescale = par.getParameter<double>("RescaleError");
}

StandAloneMuonRefitter::~StandAloneMuonRefitter() {
  LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "Destructor called." << endl;
}

  // Operations

StandAloneMuonRefitter::RefitResult StandAloneMuonRefitter::singleRefit(const Trajectory& trajectory) {
  
  theService->eventSetup().get<TrajectoryFitter::Record>().get(theFitterName, theFitter);

  vector<Trajectory> refitted;

  TrajectoryMeasurement lastTM = trajectory.lastMeasurement();                                      

  TrajectoryStateOnSurface firstTsos(lastTM.updatedState());

  // Rescale errors before refit, not to bias the result
  firstTsos.rescaleError(errorRescale);

  TransientTrackingRecHit::ConstRecHitContainer trajRH = trajectory.recHits();                      
  reverse(trajRH.begin(),trajRH.end());                                                             
  refitted = theFitter->fit(trajectory.seed(), trajRH, firstTsos);                                  

  if(!refitted.empty()) return RefitResult(true,refitted.front());
  else return RefitResult(false,trajectory);
}


StandAloneMuonRefitter::RefitResult StandAloneMuonRefitter::refit(const Trajectory& trajectory) {

  LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "---------------------------------" << endl;
  LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "Starting refitting loop:" << endl;

  unsigned int nSuccess=0;
  unsigned int nOrigHits=trajectory.recHits().size();
  Trajectory lastFitted=trajectory;
  bool allIter=true;
  bool enoughRH=true;

  for(unsigned int j=0; j<theNumberOfIterations; ++j) {

    StandAloneMuonRefitter::RefitResult singleRefitResult = singleRefit(lastFitted);
    lastFitted = singleRefitResult.second;
    unsigned int nLastHits=lastFitted.recHits().size();

    if(!singleRefitResult.first) {
      allIter=false;
      LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "  refit n. " << nSuccess+1 << ": failed" << endl;
      break;
    }

    double lostFract= 1 - double(nLastHits)/nOrigHits;
    if(lostFract>theMaxFractionOfLostHits) {
      enoughRH=false;
      LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "  refit n. " << nSuccess+1 << ": too many RH lost" << endl;
      LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "     Survived RecHits: " << nLastHits << "/" << nOrigHits << endl;
      break;
    }

    nSuccess++;
    LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "  refit n. " << nSuccess << ": OK" << endl;
    LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << "     Survived RecHits: " << nLastHits << "/" << nOrigHits << endl;

  } // end for

  LogDebug("Muon|RecoMuon|StandAloneMuonRefitter") << nSuccess << " successful refits!" << endl;

  // if isForceAllIterations==true  =>   3 successful refits: (true, refitted trajectory)
  //                                    <3 successful refits: (false, original trajectory)
  // if isForceAllIterations==false =>  >0 successful refits: (true, last refitted trajectory)
  //                                     0 successful refits: (false, original trajectory)
  if(!enoughRH)
    return RefitResult(false, trajectory);
  else if(isForceAllIterations)
    return allIter ? RefitResult(allIter, lastFitted) : RefitResult(allIter, trajectory);
  else
    return nSuccess==0 ? RefitResult(false, trajectory) : RefitResult(true, lastFitted);
}