CRackTrajectoryBuilder.cc

Go to the documentation of this file.

//
// Package:         RecoTracker/SingleTrackPattern
// Class:           CRackTrajectoryBuilder
// Original Author:  Michele Pioppi-INFN perugia
//
// Package:         RecoTracker/SingleTrackPattern
// Class:           CRackTrajectoryBuilder
// Original Author:  Michele Pioppi-INFN perugia

#include <vector>
#include <iostream>
#include <cmath>

#include "RecoTracker/SingleTrackPattern/interface/CRackTrajectoryBuilder.h"
#include "DataFormats/Common/interface/OwnVector.h"
#include "TrackingTools/TransientTrackingRecHit/interface/TransientTrackingRecHit.h"
#include "TrackingTools/TrajectoryState/interface/BasicSingleTrajectoryState.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "DataFormats/GeometryVector/interface/GlobalPoint.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "TrackingTools/Records/interface/TrackingComponentsRecord.h" 
#include "TrackingTools/Records/interface/TransientRecHitRecord.h" 
#include "TrackingTools/TrackFitters/interface/TrajectoryStateWithArbitraryError.h"


//#include "RecoTracker/CkfPattern/interface/TransientInitialStateEstimator.h"

using namespace std;


CRackTrajectoryBuilder::CRackTrajectoryBuilder(const edm::ParameterSet& conf) {
  //minimum number of hits per tracks

  theMinHits=conf.getParameter<int>("MinHits");
  //cut on chi2
  chi2cut=conf.getParameter<double>("Chi2Cut");
  edm::LogInfo("CosmicTrackFinder")<<"Minimum number of hits "<<theMinHits<<" Cut on Chi2= "<<chi2cut;

  debug_info=conf.getUntrackedParameter<bool>("debug", false);
  fastPropagation=conf.getUntrackedParameter<bool>("fastPropagation", false);
  useMatchedHits=conf.getUntrackedParameter<bool>("useMatchedHits", true);


  geometry=conf.getUntrackedParameter<std::string>("GeometricStructure","STANDARD");
  theBuilderName = conf.getParameter<std::string>("TTRHBuilder");

  

}


CRackTrajectoryBuilder::~CRackTrajectoryBuilder() {
//  delete theInitialState;
}


void CRackTrajectoryBuilder::init(const edm::EventSetup& es, bool seedplus){

//  edm::ParameterSet tise_params = conf_.getParameter<edm::ParameterSet>("TransientInitialStateEstimatorParameters") ;
// theInitialState          = new TransientInitialStateEstimator( es,tise_params);

  //services
  es.get<IdealMagneticFieldRecord>().get(magfield);
  es.get<TrackerDigiGeometryRecord>().get(tracker);
  
 
  
  if (seedplus) {    
    seed_plus=true;      
    thePropagator=      new PropagatorWithMaterial(alongMomentum,0.1057,&(*magfield) );      
    thePropagatorOp=    new PropagatorWithMaterial(oppositeToMomentum,0.1057,&(*magfield) );}    
  else {
    seed_plus=false;
    thePropagator=      new PropagatorWithMaterial(oppositeToMomentum,0.1057,&(*magfield) );    
    thePropagatorOp=    new PropagatorWithMaterial(alongMomentum,0.1057,&(*magfield) );
  }
  
  theUpdator=       new KFUpdator();
//  theUpdator=       new KFStripUpdator();
  theEstimator=     new Chi2MeasurementEstimator(chi2cut);
  

  edm::ESHandle<TransientTrackingRecHitBuilder> theBuilder;
  es.get<TransientRecHitRecord>().get(theBuilderName,theBuilder);
  

  RHBuilder=   theBuilder.product();




  theFitter=        new KFTrajectoryFitter(*thePropagator,
                       *theUpdator, 
                       *theEstimator) ;
  

  theSmoother=      new KFTrajectorySmoother(*thePropagatorOp,
                         *theUpdator,   
                         *theEstimator);
  
}


void CRackTrajectoryBuilder::run(const TrajectorySeedCollection &collseed,
                  const SiStripRecHit2DCollection &collstereo,
                  const SiStripRecHit2DCollection &collrphi ,
                  const SiStripMatchedRecHit2DCollection &collmatched,
                  const SiPixelRecHitCollection &collpixel,
                  const edm::EventSetup& es,
                  edm::Event& e,
                  vector<Trajectory> &trajoutput)
{

  std::vector<Trajectory> trajSmooth;
  std::vector<Trajectory>::iterator trajIter;
  
  TrajectorySeedCollection::const_iterator iseed;
  unsigned int IS=0;
  for(iseed=collseed.begin();iseed!=collseed.end();iseed++){
    bool seedplus=((*iseed).direction()==alongMomentum);
    init(es,seedplus);
    hits.clear();
    trajFit.clear();
    trajSmooth.clear();

    Trajectory startingTraj = createStartingTrajectory(*iseed);
    Trajectory trajTmp; // used for the opposite direction
    Trajectory traj = startingTraj;

   
    //first propagate track in opposite direction ...
    seed_plus = !seed_plus;
    vector<const TrackingRecHit*> allHitsOppsite = SortHits(collstereo,collrphi,collmatched,collpixel, *iseed, true);
    seed_plus = !seed_plus;
    if (!allHitsOppsite.empty())
      {
    //there are hits which are above the seed,
    //cout << "Number of hits higher than seed " <<allHitsOppsite.size() << endl;   
    
    AddHit( traj, allHitsOppsite, thePropagatorOp);
    
    
    if (debug_info)
      {
        cout << "Hits in opposite direction..." << endl;
        TransientTrackingRecHit::RecHitContainer::const_iterator iHit;
        for ( iHit = hits.begin(); iHit!=hits.end(); iHit++)
          {
        cout <<  (**iHit).globalPosition() << endl;
          }
      }
    
    
    // now add hist opposite to seed
    //now crate new starting trajectory
    reverse(hits.begin(), hits.end());
    if (thePropagatorOp->propagate(traj.firstMeasurement().updatedState(),
                       tracker->idToDet((hits.front())->geographicalId())->surface()).isValid()){
      TSOS startingStateNew =  //TrajectoryStateWithArbitraryError()//
        (thePropagatorOp->propagate(traj.firstMeasurement().updatedState(),
                    tracker->idToDet((hits.front())->geographicalId())->surface()));
      
      if (debug_info)
        {
          cout << "Hits in opposite direction reversed..." << endl;
          TransientTrackingRecHit::RecHitContainer::const_iterator iHit;
          for ( iHit = hits.begin(); iHit!=hits.end(); iHit++)
        {
          cout <<  (**iHit).globalPosition() << endl;
        }
        }
      
      const TrajectorySeed& tmpseed=traj.seed();
      trajTmp = theFitter->fit(tmpseed,hits, startingStateNew ).front();
      
      if(debug_info){
        cout << "Debugging show fitted hits" << endl;       
            auto hitsFit= trajTmp.recHits();
            for(auto hit=hitsFit.begin();hit!=hitsFit.end();hit++){
          
              cout << RHBuilder->build( &(*(*hit)->hit()) )->globalPosition() << endl;
            }
      }
      
    }
      }
    else 
      {
    if(debug_info) cout << "There are no hits in opposite direction ..." << endl;
      }

    vector<const TrackingRecHit*> allHits;
    if (trajTmp.foundHits())
      {
    traj = trajTmp;
    allHits= SortHits(collstereo,collrphi,collmatched,collpixel,*iseed, false);   
      }
    else
      {
    traj = startingTraj;
    hits.clear();
    allHits= SortHits(collstereo,collrphi,collmatched,collpixel,*iseed, true);    
      }
    
    AddHit( traj,allHits, thePropagator);
    
    
    if(debug_info){
      cout << "Debugging show All fitted hits" << endl;     
      auto hits= traj.recHits();
        for(auto hit=hits.begin();hit!=hits.end();hit++){
          
          cout << (*hit)->globalPosition() << endl;
        }

        cout << qualityFilter( traj) << " <- quality filter good?" << endl;
      }


    if (debug_info) cout << "now do quality checks" << endl;
    if ( qualityFilter( traj) ) {
      const TrajectorySeed& tmpseed=traj.seed();
      std::pair<TrajectoryStateOnSurface, const GeomDet*> initState =  innerState(traj); //theInitialState->innerState(traj);
    if (initState.first.isValid())
          trajFit = theFitter->fit(tmpseed,hits, initState.first);
    }

    for (trajIter=trajFit.begin(); trajIter!=trajFit.end();trajIter++){
      trajSmooth=theSmoother->trajectories((*trajIter));
    }
    for (trajIter= trajSmooth.begin(); trajIter!=trajSmooth.end();trajIter++){
      if((*trajIter).isValid()){

    if (debug_info) cout << "adding track ... " << endl;
    trajoutput.push_back((*trajIter));
      }
    }
    delete theUpdator;
    delete theEstimator;
    delete thePropagator;
    delete thePropagatorOp;
    delete theFitter;
    delete theSmoother;
    //Only the first 30 seeds are considered
    if (IS>30) return;
    IS++;

  }
}

Trajectory CRackTrajectoryBuilder::createStartingTrajectory( const TrajectorySeed& seed) const
{
  Trajectory result( seed, seed.direction());
  std::vector<TM> && seedMeas = seedMeasurements(seed);
  for (auto i : seedMeas) result.push(std::move(i));
  return result;
}


std::vector<TrajectoryMeasurement> 
CRackTrajectoryBuilder::seedMeasurements(const TrajectorySeed& seed) const
{
  std::vector<TrajectoryMeasurement> result;
  TrajectorySeed::range hitRange = seed.recHits();
  for (TrajectorySeed::const_iterator ihit = hitRange.first; 
       ihit != hitRange.second; ihit++) {
    //RC TransientTrackingRecHit* recHit = RHBuilder->build(&(*ihit));
    TransientTrackingRecHit::RecHitPointer recHit = RHBuilder->build(&(*ihit));
    const GeomDet* hitGeomDet = (&(*tracker))->idToDet( ihit->geographicalId());
    TSOS invalidState( new BasicSingleTrajectoryState( hitGeomDet->surface()));

    if (ihit == hitRange.second - 1) {
      TSOS  updatedState=startingTSOS(seed);
      result.push_back(std::move(TM( invalidState, updatedState, recHit)));

    } 
    else {
      result.push_back(std::move(TM( invalidState, recHit)));
    }
    
  }

  return result;
}

vector<const TrackingRecHit*> 
CRackTrajectoryBuilder::SortHits(const SiStripRecHit2DCollection &collstereo,
                  const SiStripRecHit2DCollection &collrphi ,
                  const SiStripMatchedRecHit2DCollection &collmatched,
                  const SiPixelRecHitCollection &collpixel,
                  const TrajectorySeed &seed,
                  const bool bAddSeedHits
                  ){


  //The Hits with global y more than the seed are discarded
  //The Hits correspondign to the seed are discarded
  //At the end all the hits are sorted in y
  vector<const TrackingRecHit*> allHits;

  SiStripRecHit2DCollection::DataContainer::const_iterator istrip;
  TrajectorySeed::range hRange= seed.recHits();
  TrajectorySeed::const_iterator ihit;
  float yref=0.;

  if (debug_info) cout << "SEED " << startingTSOS(seed) << endl; 
  if (debug_info) cout << "seed hits size " << seed.nHits() << endl;


  //seed debugging:
 // GeomDet *seedDet =  tracker->idToDet(seed.startingState().detId());


//  edm::LogInfo("CRackTrajectoryBuilder::SortHits") << "SEED " << seed.startingState(); 

  edm::LogInfo("CRackTrajectoryBuilder::SortHits") << "SEED " << startingTSOS(seed); 
//  edm::LogInfo("CRackTrajectoryBuilder::SortHits" << "seed hits size " << seed.nHits();



  //  if (seed.nHits()<2)
  //  return allHits;

  float_t yMin=0.;
  float_t yMax=0.;

  int seedHitSize= hRange.second - hRange.first;

  vector <int> detIDSeedMatched (seedHitSize);
  vector <int> detIDSeedRphi (seedHitSize);
  vector <int> detIDSeedStereo (seedHitSize);

  for (ihit = hRange.first; 
       ihit != hRange.second; ihit++) {

     // need to find track with lowest (seed_plus)/ highest y (seed_minus)
    // split matched hits ...
   const SiStripMatchedRecHit2D* matchedhit=dynamic_cast<const SiStripMatchedRecHit2D*>(&(*ihit));

   yref=RHBuilder->build(&(*ihit))->globalPosition().y();
   if (ihit == hRange.first)
     {
        yMin = yref;
    yMax = yref; 
     }

   if (matchedhit)
     {
       auto m = matchedhit->monoHit();
       auto s = matchedhit->stereoHit();
       float_t yGlobRPhi   = RHBuilder->build(&m)->globalPosition().y();
       float_t yGlobStereo = RHBuilder->build(&s)->globalPosition().y();

       if (debug_info) cout << "Rphi ..." << yGlobRPhi << endl;
       if (debug_info) cout << "Stereo ..." << yGlobStereo << endl;

       if ( yGlobStereo < yMin ) yMin = yGlobStereo;
       if ( yGlobRPhi   < yMin ) yMin = yGlobRPhi;

       if ( yGlobStereo > yMax ) yMax = yGlobStereo;
       if ( yGlobRPhi   > yMax ) yMax = yGlobRPhi;

       detIDSeedMatched.push_back (  matchedhit->geographicalId().rawId() );
       detIDSeedRphi.push_back ( m.geographicalId().rawId() );
       detIDSeedStereo.push_back ( s.geographicalId().rawId() );

      if (bAddSeedHits)
    {
      if (useMatchedHits) 
        {
          
          hits.push_back((RHBuilder->build(&(*ihit)))); 
        }
      else
        {
          if ( ( (yGlobRPhi > yGlobStereo ) && seed_plus ) || ((yGlobRPhi < yGlobStereo ) && !seed_plus ))  
        {
          hits.push_back((RHBuilder->build(&m)));
          hits.push_back((RHBuilder->build(&s)));
        }
          else
        {
          hits.push_back((RHBuilder->build(&s)));     
          hits.push_back((RHBuilder->build(&m)));
          
        }
        }
    }
     }
   else if (bAddSeedHits)
     {
       hits.push_back((RHBuilder->build(&(*ihit)))); 
       detIDSeedRphi.push_back ( ihit->geographicalId().rawId() );
       detIDSeedMatched.push_back ( -1 );
       detIDSeedStereo.push_back ( -1 );
       
     }
       
   if ( yref < yMin ) yMin = yref;
   if ( yref > yMax ) yMax = yref;
   
//    if (bAddSeedHits)
//      hits.push_back((RHBuilder->build(&(*ihit)))); 

    LogDebug("CosmicTrackFinder")<<"SEED HITS"<<RHBuilder->build(&(*ihit))->globalPosition();
    if (debug_info) cout <<"SEED HITS"<<RHBuilder->build(&(*ihit))->globalPosition() << endl;
//    if (debug_info) cout <<"SEED HITS"<< seed.startingState().parameters() << endl;


  }
  
  yref = (seed_plus) ? yMin : yMax;
  
  SiPixelRecHitCollection::DataContainer::const_iterator ipix;
  for(ipix=collpixel.data().begin();ipix!=collpixel.data().end();ipix++){
    float ych= RHBuilder->build(&(*ipix))->globalPosition().y();
    if ((seed_plus && (ych<yref)) || (!(seed_plus) && (ych>yref)))
      allHits.push_back(&(*ipix));
  }

  if (useMatchedHits) // use matched
    {
        //add the matched hits ...
      SiStripMatchedRecHit2DCollection::DataContainer::const_iterator istripm;

      for(istripm=collmatched.data().begin();istripm!=collmatched.data().end();istripm++){
    float ych= RHBuilder->build(&(*istripm))->globalPosition().y();
    
    int cDetId=istripm->geographicalId().rawId();
    bool noSeedDet = ( detIDSeedMatched.end() == find (detIDSeedMatched.begin(), detIDSeedMatched.end(), cDetId ) ) ;
    
    if ( noSeedDet )
      if ((seed_plus && (ych<yref)) || (!(seed_plus) && (ych>yref)))
          allHits.push_back(&(*istripm));
      }

   //add the rpi hits, but only accept hits that are not matched hits
      for(istrip=collrphi.data().begin();istrip!=collrphi.data().end();istrip++){
    float ych= RHBuilder->build(&(*istrip))->globalPosition().y();
    StripSubdetector monoDetId(istrip->geographicalId());
    if (monoDetId.partnerDetId())
      {
        edm::LogInfo("CRackTrajectoryBuilder::SortHits")  << "this det belongs to a glued det " << ych << endl;
        continue;
      }
    int cDetId=istrip->geographicalId().rawId();
    bool noSeedDet = ( detIDSeedRphi.end()== find (detIDSeedRphi.begin(), detIDSeedRphi.end(), cDetId ) ) ;
    if (noSeedDet)
      if ((seed_plus && (ych<yref)) || (!(seed_plus) && (ych>yref)))
        {
          
          bool hitIsUnique = true;
          //now 
          for(istripm=collmatched.data().begin();istripm!=collmatched.data().end();istripm++)
        {
          //         if ( isDifferentStripReHit2D ( *istrip, (istripm->stereoHit() ) ) == false)
          if ( isDifferentStripReHit2D ( *istrip, (istripm->monoHit() ) ) == false)
            {
              hitIsUnique = false;
              edm::LogInfo("CRackTrajectoryBuilder::SortHits")  << "rphi hit is in matched hits; y: " << ych << endl;
              break;
            }
        } //end loop over all matched
          if (hitIsUnique)
        {
          //      if (debug_info) cout << "adding rphi hit " << &(*istrip) << endl; 
          allHits.push_back(&(*istrip));   
        }
        }
      }

  
    }
  else // dont use matched ...
    {
      
      for(istrip=collrphi.data().begin();istrip!=collrphi.data().end();istrip++){
    float ych= RHBuilder->build(&(*istrip))->globalPosition().y();
    if ((seed_plus && (ych<yref)) || (!(seed_plus) && (ych>yref)))
      allHits.push_back(&(*istrip));   
      }

      for(istrip=collstereo.data().begin();istrip!=collstereo.data().end();istrip++){
    float ych= RHBuilder->build(&(*istrip))->globalPosition().y();
    if ((seed_plus && (ych<yref)) || (!(seed_plus) && (ych>yref)))
      allHits.push_back(&(*istrip));
      }
    }



  if (seed_plus)
      stable_sort(allHits.begin(),allHits.end(),CompareHitY_plus(*tracker));
  else 
      stable_sort(allHits.begin(),allHits.end(),CompareHitY(*tracker));

  if (debug_info) 
    {
      if (debug_info) cout << "all hits" << endl;

      //starting trajectory
      Trajectory startingTraj = createStartingTrajectory(seed);

      if (debug_info) cout << "START " << startingTraj.lastMeasurement().updatedState() << endl;
      if (debug_info) cout << "START  Err" << startingTraj.lastMeasurement().updatedState().localError().matrix() << endl;


      vector<const TrackingRecHit*>::iterator iHit;
      for (iHit=allHits.begin(); iHit<allHits.end(); iHit++)
    {
          GlobalPoint gphit=RHBuilder->build(*iHit)->globalPosition();
          if (debug_info) cout << "GH " << gphit << endl;

          //      tracker->idToDet((*iHit)->geographicalId())->surface();

      TSOS prSt = thePropagator->propagate(startingTraj.lastMeasurement().updatedState(),
                  tracker->idToDet((*iHit)->geographicalId())->surface());
          
          if(prSt.isValid()) 
        {
      if (debug_info) cout << "PR " << prSt.globalPosition() << endl;
      //if (debug_info) cout << "PR  Err" << prSt.localError().matrix() << endl;
          
        }
          else
        {
          if (debug_info) cout << "not valid" << endl;
        }
    }
          if (debug_info) cout << "all hits end" << endl;
    }


  return allHits;
}

TrajectoryStateOnSurface
CRackTrajectoryBuilder::startingTSOS(const TrajectorySeed& seed)const
{
  PTrajectoryStateOnDet pState( seed.startingState());
  const GeomDet* gdet  = (&(*tracker))->idToDet(DetId(pState.detId()));
  TSOS  State= trajectoryStateTransform::transientState( pState, &(gdet->surface()), 
                       &(*magfield));
  return State;

}

void CRackTrajectoryBuilder::AddHit(Trajectory &traj,
                                     const vector<const TrackingRecHit*>& _Hits, Propagator *currPropagator){
   vector<const TrackingRecHit*> Hits = _Hits;
   if ( Hits.empty() )
     return;
  
   if (debug_info) cout << "CRackTrajectoryBuilder::AddHit" << endl;
   if (debug_info) cout << "START " << traj.lastMeasurement().updatedState() << endl;
 
   vector <TrackingRecHitRange> hitRangeByDet;
   TrackingRecHitIterator prevDet;
 
   prevDet = Hits.begin();
   for( TrackingRecHitIterator iHit = Hits.begin(); iHit != Hits.end(); iHit++ )
     {
       if ( (*prevDet)->geographicalId() == (*iHit)->geographicalId() ) 
    continue;
        
       hitRangeByDet.push_back( make_pair( prevDet, iHit ) );
       prevDet = iHit;
      }
   hitRangeByDet.push_back( make_pair( prevDet, Hits.end() ) );
 
 
     if (fastPropagation) {
       for( TrackingRecHitRangeIterator iHitRange = hitRangeByDet.begin(); iHitRange != hitRangeByDet.end(); iHitRange++ )
         {
            const TrackingRecHit *currHit = *(iHitRange->first);
      DetId      currDet = currHit->geographicalId();
  
           TSOS prSt= currPropagator->propagate(traj.lastMeasurement().updatedState(),
                          tracker->idToDet(currDet)->surface());
  
           if ( !prSt.isValid())
        {
          if (debug_info) cout << "Not Valid: PRST" << prSt.globalPosition();
 //       if (debug_info) cout << "Not Valid: HIT" << *currHit;
 
 
          continue;
        }
 
           TransientTrackingRecHit::RecHitPointer bestHit = RHBuilder->build( currHit );
           double chi2min = theEstimator->estimate( prSt, *bestHit).second;
 
           if (debug_info) cout << "Size " << iHitRange->first - (*iHitRange).second << endl;
           for( TrackingRecHitIterator iHit = (*iHitRange).first+1; iHit != iHitRange->second; iHit++ )
             {
               if (debug_info) cout << "loop3 " <<" "<< Hits.end() - iHit << endl;
 
               TransientTrackingRecHit::RecHitPointer tmpHit = RHBuilder->build( *iHit );
               double currChi2 = theEstimator->estimate(prSt, *tmpHit).second;
               if ( currChi2 < chi2min )
                 {
                   chi2min = currChi2;
                   bestHit = tmpHit;
                 }
             }
           //now we have check if the track can be added to the trajectory
           if (debug_info) cout << chi2min << endl;
           if (chi2min < chi2cut)
             {
               if (debug_info) cout << "chi2 fine : " << chi2min << endl;
               TSOS UpdatedState= theUpdator->update( prSt, *bestHit );
               if (UpdatedState.isValid()){
        hits.push_back(bestHit);
                 traj.push( TM(prSt,UpdatedState, bestHit, chi2min) );
        if (debug_info) edm::LogInfo("CosmicTrackFinder") <<
                   "STATE UPDATED WITH HIT AT POSITION "
          
                          << bestHit->globalPosition()
                                               <<UpdatedState<<" "
                                               <<traj.chiSquared();
        if (debug_info) cout  <<
                   "STATE UPDATED WITH HIT AT POSITION "
          
                          << bestHit->globalPosition()
                                               <<UpdatedState<<" "
                                               <<traj.chiSquared();
                 if (debug_info) cout << "State is valid ..." << endl;
        break; // now we need to 
               }
               else
                 {
          edm::LogWarning("CosmicTrackFinder")<<" State can not be updated with hit at position " << endl;
          TSOS UpdatedState= theUpdator->update( prSt, *bestHit );
          if (UpdatedState.isValid()){
            cout  <<
              "NOT! UPDATED WITH HIT AT POSITION "
              
              << bestHit->globalPosition()
              <<UpdatedState<<" "
              <<traj.chiSquared();
            
          }
        }
        } 
         }
     } //simple version end
     else 
     {
       //first sort the dets in the order they are traversed by the trajectory
       // we need three loops:
       // 1: loop as long as there can be an new hit added to the trajectory
       // 2: loop over all dets that might be hit
       // 3: loop over all hits on a certain det
       
       
       std::vector < std::pair<TrackingRecHitRangeIterator, TSOS> > trackHitCandidates;
       std::vector <std::pair<TrackingRecHitRangeIterator, TSOS> >::iterator iHitRange;
       std::vector <uint32_t> processedDets;
       do
    {
      
      //create vector of possibly hit detectors...
      trackHitCandidates.clear();      
      DetId currDet;
      for( TrackingRecHitRangeIterator iHit = hitRangeByDet.begin(); iHit != hitRangeByDet.end(); iHit++ )
        {
          const TrackingRecHit *currHit = *(iHit->first);
          currDet = currHit->geographicalId();
 
          if ( find(processedDets.begin(), processedDets.end(), currDet.rawId()) != processedDets.end() )
        continue;
          
          TSOS prSt= currPropagator->propagate(traj.lastMeasurement().updatedState(),
                        tracker->idToDet(currDet)->surface());
          if ( ( !prSt.isValid() ) ||  (theEstimator->Chi2MeasurementEstimatorBase::estimate(prSt,tracker->idToDet(currDet)->surface() ) == false) )
 //       if ( ( !prSt.isValid() ) ||  (theEstimator->estimate(prSt,tracker->idToDet(currDet)->surface() ) == false) )  
        continue;
     
          trackHitCandidates.push_back(  make_pair(iHit, prSt) );
        }
      
      if (trackHitCandidates.empty())
      break;
 
      if (debug_info) cout << Hits.size() << " (int) trackHitCandidates.begin() " << trackHitCandidates.size() << endl;
      if (debug_info) cout << "Before sorting ... " << endl; 
 
      if (debug_info)     
      for( iHitRange = trackHitCandidates.begin(); iHitRange != trackHitCandidates.end(); iHitRange++ )
        {
          if (debug_info) cout << (tracker->idToDet((*(iHitRange->first->first))->geographicalId()))->position();
        }
      if (debug_info) cout << endl;
      
 
      stable_sort( trackHitCandidates.begin(), trackHitCandidates.end(), CompareDetByTraj(traj.lastMeasurement().updatedState())  );
      
      if (debug_info) cout << "After sorting ... " << endl; 
      if (debug_info)
        {
        for( iHitRange = trackHitCandidates.begin(); iHitRange != trackHitCandidates.end(); iHitRange++ )
          {
        if (debug_info) cout << (tracker->idToDet((*(iHitRange->first->first))->geographicalId()))->position();
          }
        cout << endl;
        }
 
    for( iHitRange = trackHitCandidates.begin(); iHitRange != trackHitCandidates.end(); iHitRange++ )      //loop over dets
      {
        
        //now find the best hit of the detector
        if (debug_info) cout << "loop2 " << trackHitCandidates.size()  <<" " << trackHitCandidates.end() - iHitRange << endl;
        const TrackingRecHit *currHit = *(iHitRange->first->first);
        
        TransientTrackingRecHit::RecHitPointer bestHit = RHBuilder->build( currHit );
        TSOS currPrSt = (*iHitRange).second;
    
        if (debug_info) cout << "curr position" << bestHit->globalPosition();
        for( TrackingRecHitIterator iHit = (*iHitRange).first->first+1; iHit != iHitRange->first->second; iHit++ )
          {
        TransientTrackingRecHit::RecHitPointer tmpHit = RHBuilder->build( *iHit );
        if (debug_info) cout << "curr position" << tmpHit->globalPosition() ;
      
          }
      }
    if (debug_info) cout << "Cross check end ..." << endl;
 
 
    //just a simple test if the same hit can be added twice ...
    //      for( iHitRange = trackHitCandidates.begin(); iHitRange != trackHitCandidates.end(); iHitRange++ )      //loop over all hits
    
    //      break;
    
    for( iHitRange = trackHitCandidates.begin(); iHitRange != trackHitCandidates.end(); iHitRange++ )      //loop over detsall hits
      {
        
        //now find the best hit of the detector
        if (debug_info) cout << "loop2 " << trackHitCandidates.size()  <<" " << trackHitCandidates.end() - iHitRange << endl;
        
        const TrackingRecHit *currHit = *(iHitRange->first->first);
 
        processedDets.push_back(currHit->geographicalId().rawId());
        
        
        TransientTrackingRecHit::RecHitPointer bestHit = RHBuilder->build( currHit );
 
        if (debug_info) cout << "curr position A" << bestHit->globalPosition() << endl;
        TSOS currPrSt = (*iHitRange).second;
        double chi2min = theEstimator->estimate( currPrSt, *bestHit).second;
 
        if (debug_info) cout << "Size " << iHitRange->first->second - (*iHitRange).first->first << endl; 
        for( TrackingRecHitIterator iHit = (*iHitRange).first->first+1; iHit != iHitRange->first->second; iHit++ )
          {
        if (debug_info) cout << "loop3 " <<" "<< Hits.end() - iHit << endl;
          
        TransientTrackingRecHit::RecHitPointer tmpHit = RHBuilder->build( *iHit );
        if (debug_info) cout << "curr position B" << tmpHit->globalPosition() << endl;
        double currChi2 = theEstimator->estimate(currPrSt, *tmpHit).second;
        if ( currChi2 < chi2min )
          {
            if (debug_info) cout << "Is best hit" << endl;
            chi2min = currChi2;
            bestHit = tmpHit;
          }
          }
        //now we have checked the det and can remove the entry from the vector...
      
        //if (debug_info) cout << "before erase ..." << endl;
        //this is to slow ...
        // hitRangeByDet.erase( (*iHitRange).first,(*iHitRange).first+1 );    
        //if (debug_info) cout << "after erase ..." << endl;
 
        if (debug_info) cout << chi2min << endl;
        //if the track can be added to the trajectory 
        if (chi2min < chi2cut)
          {
        if (debug_info) cout << "chi2 fine : " << chi2min << endl;
 
        //  if (debug_info) cout << "previaous state " << traj.lastMeasurement().updatedState() <<endl;
        TSOS UpdatedState= theUpdator->update( currPrSt, *bestHit );
        if (UpdatedState.isValid()){
 
          hits.push_back(bestHit);
          traj.push( TM(currPrSt,UpdatedState, bestHit, chi2min) );
          if (debug_info) edm::LogInfo("CosmicTrackFinder") <<
            "STATE UPDATED WITH HIT AT POSITION "
            //   <<tmphitbestdet->globalPosition()
                        <<UpdatedState<<" "
                        <<traj.chiSquared();
          if (debug_info) cout << "Added Hit" << bestHit->globalPosition() << endl;
          if (debug_info) cout << "State is valid ..." << UpdatedState << endl;
          //cout << "updated state " << traj.lastMeasurement().updatedState() <<endl;
 
          //          return; //break;
          //
          //          TSOS prSt= currPropagator->propagate(traj.lastMeasurement().updatedState(),
          //                          tracker->idToDet( bestHit->geographicalId() )->surface());
          //      
          //          if ( prSt.isValid())
          //        cout << "the same hit can be added twice ..." << endl;  
          //
          
          break;
        }
        else
          {
            if (debug_info) edm::LogWarning("CosmicTrackFinder")<<" State can not be updated with hit at position "
                            << bestHit->globalPosition();  
            //      cout << "State can not be updated with hit at " << bestHit->globalPosition() << endl;
          }
        continue;
          }
        else
          {
        //      cout << "chi2 to big : " << chi2min << endl;
          }
        if (debug_info) cout << " continue 1 " << endl;
      }
    //now we remove all already processed dets from the list ...
    // hitRangeByDet.erase( (*trackHitCandidates.begin()).first,(*iHitRange).first+1 );   
 
    if (debug_info) cout << " continue 2 " << endl;
       }
     //if this was the last exit
     while ( iHitRange != trackHitCandidates.end() );
     }
 
 
}


bool 
CRackTrajectoryBuilder::qualityFilter(const Trajectory& traj){
  int ngoodhits=0;
  if(geometry=="MTCC"){
    auto hits= traj.recHits();
    for(auto hit=hits.begin();hit!=hits.end();hit++){
      unsigned int iid=(*hit)->hit()->geographicalId().rawId();
      //CHECK FOR 3 hits r-phi
      if(((iid>>0)&0x3)!=1) ngoodhits++;
    }
  }
  else ngoodhits=traj.foundHits();
  
  if ( ngoodhits >= theMinHits) {
    return true;
  }
  else {
    return false;
  }
}

//----------------------------------------------------------------------------------------------------------
// little helper function that returns false if both hits conatin the same information

bool CRackTrajectoryBuilder::isDifferentStripReHit2D  (const SiStripRecHit2D& hitA, const  SiStripRecHit2D& hitB )
{
  if ( hitA.geographicalId() != hitB.geographicalId() )
    return true;
  if ( hitA.localPosition().x() != hitB.localPosition().x() )
    return true;
  if ( hitA.localPosition().y() != hitB.localPosition().y() )
    return true;
  if ( hitA.localPosition().z() != hitB.localPosition().z() )
    return true;

  //  if (debug_info) cout << hitA.localPosition() << endl;
  //  if (debug_info) cout << hitB << endl;

  return false;
}



//----backfitting
std::pair<TrajectoryStateOnSurface, const GeomDet*> 
CRackTrajectoryBuilder::innerState( const Trajectory& traj) const
{
  int lastFitted = 999;
  int nhits = traj.foundHits();
  if (nhits < lastFitted+1) lastFitted = nhits-1;

  std::vector<TrajectoryMeasurement> measvec = traj.measurements();
  TransientTrackingRecHit::ConstRecHitContainer firstHits;

  bool foundLast = false;
  int actualLast = -99;
  for (int i=lastFitted; i >= 0; i--) {
    if(measvec[i].recHit()->isValid()){
      if(!foundLast){
    actualLast = i; 
    foundLast = true;
      }
      firstHits.push_back( measvec[i].recHit());
    }
  }
  TSOS unscaledState = measvec[actualLast].updatedState();
  AlgebraicSymMatrix55 C=ROOT::Math::SMatrixIdentity();
  // C *= 100.;

  TSOS startingState( unscaledState.localParameters(), LocalTrajectoryError(C),
              unscaledState.surface(),
              thePropagator->magneticField());

  // cout << endl << "FitTester starts with state " << startingState << endl;

  KFTrajectoryFitter backFitter( *thePropagator,
                 KFUpdator(),
                 Chi2MeasurementEstimator( 100., 3));

  PropagationDirection backFitDirection = traj.direction() == alongMomentum ? oppositeToMomentum: alongMomentum;

  // only direction matters in this contest
  TrajectorySeed fakeSeed = TrajectorySeed(PTrajectoryStateOnDet() , 
                       edm::OwnVector<TrackingRecHit>(),
                       backFitDirection);

  vector<Trajectory> fitres = backFitter.fit( fakeSeed, firstHits, startingState);

  if (fitres.size() != 1) {
    // cout << "FitTester: first hits fit failed!" << endl;
    return std::pair<TrajectoryStateOnSurface, const GeomDet*>();
  }

  TrajectoryMeasurement firstMeas = fitres[0].lastMeasurement();
  const TSOS& firstState = firstMeas.updatedState();

  //  cout << "FitTester: Fitted first state " << firstState << endl;
  //cout << "FitTester: chi2 = " << fitres[0].chiSquared() << endl;

  TSOS initialState( firstState.localParameters(), LocalTrajectoryError(C),
             firstState.surface(),
             thePropagator->magneticField());

  return std::pair<TrajectoryStateOnSurface, const GeomDet*>( initialState, 
                                  firstMeas.recHit()->det());
}