MuonTrajectoryUpdator.cc

Go to the documentation of this file.

#include "RecoMuon/TrackingTools/interface/MuonTrajectoryUpdator.h"
#include "RecoMuon/TrackingTools/interface/MuonPatternRecoDumper.h"
#include "DataFormats/MuonDetId/interface/MuonSubdetId.h"

#include "TrackingTools/KalmanUpdators/interface/Chi2MeasurementEstimator.h"
#include "TrackingTools/PatternTools/interface/TrajectoryMeasurement.h"
#include "TrackingTools/PatternTools/interface/Trajectory.h"
#include "TrackingTools/TrajectoryState/interface/TrajectoryStateOnSurface.h"
#include "TrackingTools/GeomPropagators/interface/Propagator.h"
#include "TrackingTools/KalmanUpdators/interface/KFUpdator.h"
#include "TrackingTools/DetLayers/interface/DetLayer.h"

#include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHit.h"
#include "RecoMuon/TransientTrackingRecHit/interface/MuonTransientTrackingRecHitBreaker.h"

#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"

#include <algorithm>

using namespace edm;
using namespace std;

MuonTrajectoryUpdator::MuonTrajectoryUpdator(const edm::ParameterSet& par,
                         NavigationDirection fitDirection): theFitDirection(fitDirection){
  
  // The max allowed chi2 to accept a rechit in the fit
  theMaxChi2 = par.getParameter<double>("MaxChi2");
  theEstimator = new Chi2MeasurementEstimator(theMaxChi2);
  
  // The KF updator
  theUpdator= new KFUpdator();

  // The granularity
  theGranularity = par.getParameter<int>("Granularity");

  // Rescale the error of the first state?
  theRescaleErrorFlag =  par.getParameter<bool>("RescaleError");

  if(theRescaleErrorFlag)
    // The rescale factor
    theRescaleFactor =  par.getParameter<double>("RescaleErrorFactor");
  
  // Use the invalid hits?
  useInvalidHits =  par.getParameter<bool>("UseInvalidHits");

  // Flag needed for the rescaling
  theFirstTSOSFlag = true;

  // Exlude RPC from the fit?
   theRPCExFlag = par.getParameter<bool>("ExcludeRPCFromFit");
}

MuonTrajectoryUpdator::MuonTrajectoryUpdator( NavigationDirection fitDirection,
                          double chi2, int granularity): theMaxChi2(chi2),
                                         theGranularity(granularity),
                                         theFitDirection(fitDirection){
  theEstimator = new Chi2MeasurementEstimator(theMaxChi2);
  
  // The KF updator
  theUpdator= new KFUpdator();
}

MuonTrajectoryUpdator::~MuonTrajectoryUpdator(){
  delete theEstimator;
  delete theUpdator;
}

void MuonTrajectoryUpdator::makeFirstTime(){
  theFirstTSOSFlag = true;
}


pair<bool,TrajectoryStateOnSurface> 
MuonTrajectoryUpdator::update(const TrajectoryMeasurement* measurement,
                  Trajectory& trajectory,
                  const Propagator *propagator){
  
  const std::string metname = "Muon|RecoMuon|MuonTrajectoryUpdator";

  MuonPatternRecoDumper muonDumper;

  // Status of the updating
  bool updated=false;
  
  if(!measurement) return pair<bool,TrajectoryStateOnSurface>(updated,TrajectoryStateOnSurface() );

  // measurement layer
  const DetLayer* detLayer=measurement->layer();

  // these are the 4D segment for the CSC/DT and a point for the RPC 
  TransientTrackingRecHit::ConstRecHitPointer muonRecHit = measurement->recHit();
 
  // The KFUpdator takes TransientTrackingRecHits as arg.
  TransientTrackingRecHit::ConstRecHitContainer recHitsForFit =
  MuonTransientTrackingRecHitBreaker::breakInSubRecHits(muonRecHit,theGranularity);

  // sort the container in agreement with the porpagation direction
  sort(recHitsForFit,detLayer);
  
  TrajectoryStateOnSurface lastUpdatedTSOS = measurement->predictedState();
  
  LogTrace(metname)<<"Number of rechits for the fit: "<<recHitsForFit.size()<<endl;
 
  TransientTrackingRecHit::ConstRecHitContainer::iterator recHit;
  for(recHit = recHitsForFit.begin(); recHit != recHitsForFit.end(); ++recHit ) {
    if ((*recHit)->isValid() ) {

      // propagate the TSOS onto the rechit plane
      TrajectoryStateOnSurface propagatedTSOS  = propagateState(lastUpdatedTSOS, measurement, 
                                *recHit, propagator);
      
      if ( propagatedTSOS.isValid() ) {
        pair<bool,double> thisChi2 = estimator()->estimate(propagatedTSOS, *((*recHit).get()));

    LogTrace(metname) << "Estimation for Kalman Fit. Chi2: " << thisChi2.second;

    // Is an RPC hit? Prepare the variable to possibly exluding it from the fit
    bool wantIncludeThisHit = true;
    if (theRPCExFlag && 
        (*recHit)->geographicalId().det() == DetId::Muon &&
        (*recHit)->geographicalId().subdetId() == MuonSubdetId::RPC){
      wantIncludeThisHit = false;   
      LogTrace(metname) << "This is an RPC hit and the present configuration is such that it will be excluded from the fit";
    }

    
        // The Chi2 cut was already applied in the estimator, which
        // returns 0 if the chi2 is bigger than the cut defined in its
        // constructor
    if (thisChi2.first) {
          updated=true;
      if (wantIncludeThisHit) { // This split is a trick to have the RPC hits counted as updatable (in used chamber counting), while are not actually included in the fit when the proper obtion is activated.

          LogTrace(metname) << endl 
                << "     Kalman Start" << "\n" << "\n";
          LogTrace(metname) << "  Meas. Position : " << (**recHit).globalPosition() << "\n"
                << "  Pred. Position : " << propagatedTSOS.globalPosition()
                << "  Pred Direction : " << propagatedTSOS.globalDirection()<< endl;

      if(theRescaleErrorFlag && theFirstTSOSFlag){
        propagatedTSOS.rescaleError(theRescaleFactor);
        theFirstTSOSFlag = false;
      }

          lastUpdatedTSOS = measurementUpdator()->update(propagatedTSOS,*((*recHit).get()));

          LogTrace(metname) << "  Fit   Position : " << lastUpdatedTSOS.globalPosition()
                << "  Fit  Direction : " << lastUpdatedTSOS.globalDirection()
                << "\n"
                << "  Fit position radius : " 
                << lastUpdatedTSOS.globalPosition().perp()
                << "filter updated" << endl;
      
      LogTrace(metname) << muonDumper.dumpTSOS(lastUpdatedTSOS);
      
      LogTrace(metname) << "\n\n     Kalman End" << "\n" << "\n";         
      
      TrajectoryMeasurement && updatedMeasurement = updateMeasurement( propagatedTSOS, lastUpdatedTSOS, 
                                    *recHit, thisChi2.second, detLayer, 
                                    measurement);
      // FIXME: check!
      trajectory.push(std::move(updatedMeasurement), thisChi2.second);  
      }
      else {
        LogTrace(metname) << "  Compatible RecHit with good chi2 but made with RPC when it was decided to not include it in the fit"
                  << "  --> trajectory NOT updated, invalid RecHit added." << endl;
          
        MuonTransientTrackingRecHit::MuonRecHitPointer invalidRhPtr = MuonTransientTrackingRecHit::specificBuild( (*recHit)->det(), (*recHit)->hit() );
        invalidRhPtr->invalidateHit();
        TrajectoryMeasurement invalidRhMeasurement(propagatedTSOS, propagatedTSOS, invalidRhPtr,  thisChi2.second, detLayer);
        trajectory.push(std::move(invalidRhMeasurement), thisChi2.second);          
      }
    }
    else {
          if(useInvalidHits) {
            LogTrace(metname) << "  Compatible RecHit with too large chi2"
                << "  --> trajectory NOT updated, invalid RecHit added." << endl;

        MuonTransientTrackingRecHit::MuonRecHitPointer invalidRhPtr = MuonTransientTrackingRecHit::specificBuild( (*recHit)->det(), (*recHit)->hit() );
        invalidRhPtr->invalidateHit();
        TrajectoryMeasurement invalidRhMeasurement(propagatedTSOS, propagatedTSOS, invalidRhPtr, thisChi2.second, detLayer);
        trajectory.push(std::move(invalidRhMeasurement), thisChi2.second);    
          }
    }
      }
    }
  }
  recHitsForFit.clear();
  return pair<bool,TrajectoryStateOnSurface>(updated,lastUpdatedTSOS);
}

TrajectoryStateOnSurface 
MuonTrajectoryUpdator::propagateState(const TrajectoryStateOnSurface& state,
                      const TrajectoryMeasurement* measurement, 
                      const TransientTrackingRecHit::ConstRecHitPointer  & current,
                      const Propagator *propagator) const{

  const TransientTrackingRecHit::ConstRecHitPointer& mother = measurement->recHit();

  if( current->geographicalId() == mother->geographicalId() )
    return measurement->predictedState();
  
  const TrajectoryStateOnSurface  tsos =
    propagator->propagate(state, current->det()->surface());
  return tsos;

}

// FIXME: would I a different threatment for the two prop dirrections??
TrajectoryMeasurement MuonTrajectoryUpdator::updateMeasurement(  const TrajectoryStateOnSurface &propagatedTSOS, 
                                 const TrajectoryStateOnSurface &lastUpdatedTSOS, 
                                 const TransientTrackingRecHit::ConstRecHitPointer &recHit,
                                 const double &chi2, const DetLayer *detLayer, 
                                 const TrajectoryMeasurement *initialMeasurement){
  return TrajectoryMeasurement(propagatedTSOS, lastUpdatedTSOS, 
                   recHit,chi2,detLayer);

  //   // FIXME: put a better check! One could fit in first out-in and then in - out 
  //   if(propagator()->propagationDirection() == alongMomentum) 
  //     return TrajectoryMeasurement(propagatedTSOS, lastUpdatedTSOS, 
  //                 recHit,thisChi2.second,detLayer);
  
  //   // FIXME: Check this carefully!!
  //   else if(propagator()->propagationDirection() == oppositeToMomentum)
  //     return TrajectoryMeasurement(initialMeasurement->forwardPredictedState(),
  //                 propagatedTSOS, lastUpdatedTSOS, 
  //                 recHit,thisChi2.second,detLayer);
  //   else{
  //     LogError("MuonTrajectoryUpdator::updateMeasurement") <<"Wrong propagation direction!!";
  //   }
}


void MuonTrajectoryUpdator::sort(TransientTrackingRecHit::ConstRecHitContainer& recHitsForFit, 
                 const DetLayer* detLayer){
  
  if(detLayer->subDetector()==GeomDetEnumerators::DT){
    if(fitDirection() == insideOut)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), RadiusComparatorInOut() );
    else if(fitDirection() == outsideIn)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(),RadiusComparatorOutIn() ); 
    else
      LogError("Muon|RecoMuon|MuonTrajectoryUpdator") <<"MuonTrajectoryUpdator::sort: Wrong propagation direction!!";
  }

  else if(detLayer->subDetector()==GeomDetEnumerators::CSC){
    if(fitDirection() == insideOut)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorInOut() );
    else if(fitDirection() == outsideIn)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorOutIn() );  
    else
      LogError("Muon|RecoMuon|MuonTrajectoryUpdator") <<"MuonTrajectoryUpdator::sort: Wrong propagation direction!!";
  }

  else if(detLayer->subDetector()==GeomDetEnumerators::GEM){
    if(fitDirection() == insideOut)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorInOut() );
    else if(fitDirection() == outsideIn)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorOutIn() );  
    else
      LogError("Muon|RecoMuon|MuonTrajectoryUpdator") <<"MuonTrajectoryUpdator::sort: Wrong propagation direction!!";
  }
  else if(detLayer->subDetector()==GeomDetEnumerators::ME0){
    if(fitDirection() == insideOut)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorInOut() );
    else if(fitDirection() == outsideIn)
      stable_sort(recHitsForFit.begin(),recHitsForFit.end(), ZedComparatorOutIn() );  
    else
      LogError("Muon|RecoMuon|MuonTrajectoryUpdator") <<"MuonTrajectoryUpdator::sort: Wrong propagation direction!!";
  }
}