#include <MeasurementTracker.h>

Inheritance diagram for MeasurementTracker:

Public Types
typedef std::map< DetId, MeasurementDet * >	DetContainer
enum	QualityFlags { BadModules = 1, BadAPVFibers = 2, BadStrips = 4, MaskBad128StripBlocks = 8, BadROCs = 2 }
Public Member Functions
const DetContainer &	allDets () const
	For debug only.
const GeometricSearchTracker *	geometricSearchTracker () const
const TrackingGeometry *	geomTracker () const
const std::vector < TkGluedMeasurementDet * > &	gluedDets () const
virtual const MeasurementDet *	idToDet (const DetId &id) const
	MeasurementDetSystem interface.
	MeasurementTracker (const edm::ParameterSet &conf, const PixelClusterParameterEstimator pixelCPE, const StripClusterParameterEstimator stripCPE, const SiStripRecHitMatcher hitMatcher, const TrackerGeometry trackerGeom, const GeometricSearchTracker geometricSearchTracker, const SiStripQuality stripQuality, int stripQualityFlags, int stripQualityDebugFlags, const SiPixelQuality pixelQuality, const SiPixelFedCabling pixelCabling, int pixelQualityFlags, int pixelQualityDebugFlags, bool isRegional=false)
const std::vector < TkPixelMeasurementDet * > &	pixelDets () const
void	setClusterToSkip (const edm::InputTag &cluster, const edm::Event &event) const
const std::vector < TkStripMeasurementDet * > &	stripDets () const
void	unsetClusterToSkip () const
virtual void	update (const edm::Event &) const
void	updatePixels (const edm::Event &) const
void	updateStrips (const edm::Event &) const
virtual	~MeasurementTracker ()
Protected Member Functions
void	addGluedDet (const GluedGeomDet gd, const SiStripRecHitMatcher matcher) const
void	addPixelDet (const GeomDet gd, const PixelClusterParameterEstimator cpe) const
void	addPixelDets (const TrackingGeometry::DetContainer &dets) const
void	addStripDet (const GeomDet gd, const StripClusterParameterEstimator cpe) const
void	addStripDets (const TrackingGeometry::DetContainer &dets) const
void	getInactiveStrips (const edm::Event &event, std::vector< uint32_t > &rawInactiveDetIds) const
void	initialize () const
void	initializePixelStatus (const SiPixelQuality stripQuality, const SiPixelFedCabling pixelCabling, int qualityFlags, int qualityDebugFlags) const
void	initializeStripStatus (const SiStripQuality *stripQuality, int qualityFlags, int qualityDebugFlags) const
Protected Attributes
bool	isRegional_
const std::string	name_
const edm::ParameterSet &	pset_
bool	selfUpdateSkipClusters_
DetContainer	theDetMap
const GeometricSearchTracker *	theGeometricSearchTracker
std::vector < TkGluedMeasurementDet * >	theGluedDets
const SiStripRecHitMatcher *	theHitMatcher
const std::vector< edm::InputTag >	theInactivePixelDetectorLabels
const std::vector< edm::InputTag >	theInactiveStripDetectorLabels
const SiPixelFedCabling *	thePixelCabling
const PixelClusterParameterEstimator *	thePixelCPE
std::vector < TkPixelMeasurementDet * >	thePixelDets
const StripClusterParameterEstimator *	theStripCPE
std::vector < TkStripMeasurementDet * >	theStripDets
const TrackerGeometry *	theTrackerGeom

Detailed Description

Definition at line 40 of file MeasurementTracker.h.

Member Typedef Documentation

typedef std::map<DetId,MeasurementDet*> MeasurementTracker::DetContainer

Definition at line 74 of file MeasurementTracker.h.

Member Enumeration Documentation

enum MeasurementTracker::QualityFlags

Enumerator:

BadModules
BadAPVFibers
BadStrips
MaskBad128StripBlocks
BadROCs

Definition at line 42 of file MeasurementTracker.h.

                     { BadModules=1, // for everybody
                       /* Strips: */ BadAPVFibers=2, BadStrips=4, MaskBad128StripBlocks=8, 
                       /* Pixels: */ BadROCs=2 };

Constructor & Destructor Documentation

MeasurementTracker::MeasurementTracker	(	const edm::ParameterSet &	conf,
		const PixelClusterParameterEstimator *	pixelCPE,
		const StripClusterParameterEstimator *	stripCPE,
		const SiStripRecHitMatcher *	hitMatcher,
		const TrackerGeometry *	trackerGeom,
		const GeometricSearchTracker *	geometricSearchTracker,
		const SiStripQuality *	stripQuality,
		int	stripQualityFlags,
		int	stripQualityDebugFlags,
		const SiPixelQuality *	pixelQuality,
		const SiPixelFedCabling *	pixelCabling,
		int	pixelQualityFlags,
		int	pixelQualityDebugFlags,
		bool	isRegional = `false`
	)

Definition at line 86 of file MeasurementTracker.cc.

References edm::ParameterSet::exists(), edm::ParameterSet::getParameter(), initialize(), initializePixelStatus(), initializeStripStatus(), LogDebug, selfUpdateSkipClusters_, and createPayload::skip.

                                                        :
  pset_(conf),
  name_(conf.getParameter<std::string>("ComponentName")),
  thePixelCPE(pixelCPE),theStripCPE(stripCPE),theHitMatcher(hitMatcher),
  theTrackerGeom(trackerGeom),theGeometricSearchTracker(geometricSearchTracker),
  theInactivePixelDetectorLabels(conf.getParameter<std::vector<edm::InputTag> >("inactivePixelDetectorLabels")),
  theInactiveStripDetectorLabels(conf.getParameter<std::vector<edm::InputTag> >("inactiveStripDetectorLabels")),
  isRegional_(isRegional)
{
  this->initialize();
  this->initializeStripStatus(stripQuality, stripQualityFlags, stripQualityDebugFlags);
  this->initializePixelStatus(pixelQuality, pixelCabling, pixelQualityFlags, pixelQualityDebugFlags);
  //the measurement tracking is set to skip clusters, the other option is set from outside
  selfUpdateSkipClusters_=conf.exists("skipClusters");
  if (selfUpdateSkipClusters_)
    {
      edm::InputTag skip=conf.getParameter<edm::InputTag>("skipClusters");
      if (skip==edm::InputTag("")) selfUpdateSkipClusters_=false;
    }
  
  LogDebug("MeasurementTracker")<<"skipping clusters: "<<selfUpdateSkipClusters_;
}

MeasurementTracker::~MeasurementTracker ( ) [virtual]

Definition at line 122 of file MeasurementTracker.cc.

{
  for(vector<TkPixelMeasurementDet*>::const_iterator it=thePixelDets.begin(); it!=thePixelDets.end(); ++it){
    delete *it;
  }

  for(vector<TkStripMeasurementDet*>::const_iterator it=theStripDets.begin(); it!=theStripDets.end(); ++it){
    delete *it;
  }

  for(vector<TkGluedMeasurementDet*>::const_iterator it=theGluedDets.begin(); it!=theGluedDets.end(); ++it){
    delete *it;
  }
}

Member Function Documentation

void MeasurementTracker::addGluedDet	(	const GluedGeomDet *	gd,
		const SiStripRecHitMatcher *	matcher
	)		const `[protected]`

Definition at line 208 of file MeasurementTracker.cc.

References GeomDet::geographicalId(), GluedGeomDet::monoDet(), and GluedGeomDet::stereoDet().

{
  const MeasurementDet* monoDet = idToDet( gd->monoDet()->geographicalId());
  if (monoDet == 0) {
    addStripDet(gd->monoDet(), theStripCPE);  // in case glued det comes before components
    monoDet = idToDet( gd->monoDet()->geographicalId());
  }

  const MeasurementDet* stereoDet = idToDet( gd->stereoDet()->geographicalId());
  if (stereoDet == 0) {
    addStripDet(gd->stereoDet(), theStripCPE);  // in case glued det comes before components
    stereoDet = idToDet( gd->stereoDet()->geographicalId());
  }

  if (monoDet == 0 || stereoDet == 0) {
    edm::LogError("MeasurementDet") << "MeasurementTracker ERROR: GluedDet components not found as MeasurementDets ";
    throw MeasurementDetException("MeasurementTracker ERROR: GluedDet components not found as MeasurementDets");
  }

  TkGluedMeasurementDet* det = new TkGluedMeasurementDet( gd, theHitMatcher,
                                                          monoDet, stereoDet);
  theGluedDets.push_back( det);
  theDetMap[gd->geographicalId()] = det;
}

void MeasurementTracker::addPixelDet	(	const GeomDet *	gd,
		const PixelClusterParameterEstimator *	cpe
	)		const `[protected]`

Definition at line 200 of file MeasurementTracker.cc.

References GeomDet::geographicalId().

{
  TkPixelMeasurementDet* det = new TkPixelMeasurementDet( gd, cpe);
  thePixelDets.push_back(det);
  theDetMap[gd->geographicalId()] = det;
}

void MeasurementTracker::addPixelDets ( const TrackingGeometry::DetContainer & dets ) const [protected]

Definition at line 154 of file MeasurementTracker.cc.

{
  for (TrackerGeometry::DetContainer::const_iterator gd=dets.begin();
       gd != dets.end(); gd++) {
    addPixelDet(*gd, thePixelCPE);
  }  
}

void MeasurementTracker::addStripDet	(	const GeomDet *	gd,
		const StripClusterParameterEstimator *	cpe
	)		const `[protected]`

Definition at line 187 of file MeasurementTracker.cc.

References GeomDet::geographicalId(), and cms::Exception::what().

{
  try {
    TkStripMeasurementDet* det = new TkStripMeasurementDet( gd, cpe,isRegional_);
    theStripDets.push_back(det);
    theDetMap[gd->geographicalId()] = det;
  }
  catch(MeasurementDetException& err){
    edm::LogError("MeasurementDet") << "Oops, got a MeasurementDetException: " << err.what() ;
  }
}

void MeasurementTracker::addStripDets ( const TrackingGeometry::DetContainer & dets ) const [protected]

Definition at line 162 of file MeasurementTracker.cc.

{
  for (TrackerGeometry::DetContainer::const_iterator gd=dets.begin();
       gd != dets.end(); gd++) {

    const GeomDetUnit* gdu = dynamic_cast<const GeomDetUnit*>(*gd);

    //    StripSubdetector stripId( (**gd).geographicalId());
    //     bool isDetUnit( gdu != 0);
    //     cout << "StripSubdetector glued? " << stripId.glued() 
    //   << " is DetUnit? " << isDetUnit << endl;

    if (gdu != 0) {
      addStripDet(*gd, theStripCPE);
    }
    else {
      const GluedGeomDet* gluedDet = dynamic_cast<const GluedGeomDet*>(*gd);
      if (gluedDet == 0) {
        throw MeasurementDetException("MeasurementTracker ERROR: GeomDet neither DetUnit nor GluedDet");
      }
      addGluedDet(gluedDet, theHitMatcher);
    }  
  }
}

const DetContainer& MeasurementTracker::allDets ( ) const [inline]

For debug only.

Definition at line 77 of file MeasurementTracker.h.

References theDetMap.

{return theDetMap;}

const GeometricSearchTracker* MeasurementTracker::geometricSearchTracker ( ) const [inline]

Definition at line 69 of file MeasurementTracker.h.

References theGeometricSearchTracker.

Referenced by MuonRoadTrajectoryBuilder::cleanTrajectory(), RoadSearchTrackCandidateMakerAlgorithm::extrapolateTrajectory(), RoadSearchTrackCandidateMakerAlgorithm::FindBestHit(), RoadSearchTrackCandidateMakerAlgorithm::FindBestHits(), RoadSearchTrackCandidateMakerAlgorithm::FindBestHitsByDet(), MuonCkfTrajectoryBuilder::findCompatibleMeasurements(), BaseCkfTrajectoryBuilder::findStateAndLayers(), MuonRoadTrajectoryBuilder::makeTrajectories_0(), RoadSearchTrackCandidateMakerAlgorithm::PrepareTrackCandidates(), RoadSearchTrackCandidateMakerAlgorithm::run(), and BaseCkfTrajectoryBuilder::seedMeasurements().

{return theGeometricSearchTracker;}

const TrackingGeometry* MeasurementTracker::geomTracker ( ) const [inline]

Definition at line 67 of file MeasurementTracker.h.

References theTrackerGeom.

Referenced by MuonCkfTrajectoryBuilder::findCompatibleMeasurements(), BaseCkfTrajectoryBuilder::findStateAndLayers(), MuonRoadTrajectoryBuilder::makeTrajectories_0(), BaseCkfTrajectoryBuilder::seedMeasurements(), ConversionSeedFinder::setEvent(), and OutInConversionTrackFinder::tracks().

{ return theTrackerGeom;}

void MeasurementTracker::getInactiveStrips	(	const edm::Event &	event,
		std::vector< uint32_t > &	rawInactiveDetIds
	)		const `[protected]`

Definition at line 380 of file MeasurementTracker.cc.

References python::multivaluedict::sort().

                                                                                          {
  if (!theInactiveStripDetectorLabels.empty()) {
    edm::Handle<DetIdCollection> detIds;
    for (std::vector<edm::InputTag>::const_iterator itt = theInactiveStripDetectorLabels.begin(), edt = theInactiveStripDetectorLabels.end();
         itt != edt; ++itt) {
      event.getByLabel(*itt, detIds);
      rawInactiveDetIds.insert(rawInactiveDetIds.end(), detIds->begin(), detIds->end());
    }
    if (!rawInactiveDetIds.empty()) std::sort(rawInactiveDetIds.begin(), rawInactiveDetIds.end());
  }
}

const std::vector<TkGluedMeasurementDet*>& MeasurementTracker::gluedDets ( ) const [inline]

Definition at line 80 of file MeasurementTracker.h.

References theGluedDets.

{return theGluedDets;}

virtual const MeasurementDet* MeasurementTracker::idToDet ( const DetId & id ) const [virtual]

MeasurementDetSystem interface.

Implements MeasurementDetSystem.

Reimplemented in OnDemandMeasurementTracker.

Referenced by MuonRoadTrajectoryBuilder::GatherHits().

void MeasurementTracker::initialize ( ) const [protected]

Referenced by MeasurementTracker().

void MeasurementTracker::initializePixelStatus	(	const SiPixelQuality *	stripQuality,
		const SiPixelFedCabling *	pixelCabling,
		int	qualityFlags,
		int	qualityDebugFlags
	)		const `[protected]`

Definition at line 649 of file MeasurementTracker.cc.

References cond::rpcobgas::detid, SiPixelQuality::getBadRocPositions(), SiPixelQuality::getBadRocs(), i, and SiPixelQuality::IsModuleUsable().

Referenced by MeasurementTracker().

                                                                                                                                                                  {
  if ((quality != 0) && (qualityFlags != 0))  {
    edm::LogInfo("MeasurementTracker") << "qualityFlags = " << qualityFlags;
    unsigned int on = 0, tot = 0, badrocs = 0; 
    for (std::vector<TkPixelMeasurementDet*>::const_iterator i=thePixelDets.begin();
         i!=thePixelDets.end(); i++) {
      uint32_t detid = ((**i).geomDet().geographicalId()).rawId();
      if (qualityFlags & BadModules) {
          bool isOn = quality->IsModuleUsable(detid);
          (*i)->setActive(isOn);
          tot++; on += (unsigned int) isOn;
          if (qualityDebugFlags & BadModules) {
            edm::LogInfo("MeasurementTracker")<< "MeasurementTracker::initializePixelStatus : detid " << detid << " is " << (isOn ?  "on" : "off");
          }
       } else {
          (*i)->setActive(true);
       }
       if ((qualityFlags & BadROCs) && (quality->getBadRocs(detid) != 0)) {
          std::vector<LocalPoint> badROCs = quality->getBadRocPositions(detid, *theTrackerGeom, pixelCabling);
          badrocs += badROCs.size();
          (*i)->setBadRocPositions(badROCs);
       } else {
          (*i)->clearBadRocPositions();  
       }
    }
    if (qualityDebugFlags & BadModules) {
        edm::LogInfo("MeasurementTracker PixelModuleStatus") << 
            " Total modules: " << tot << ", active " << on <<", inactive " << (tot - on);
    }
    if (qualityDebugFlags & BadROCs) {
        edm::LogInfo("MeasurementTracker PixelROCStatus") << " Total of bad ROCs: " << badrocs ;
    }
  } else {
    for (std::vector<TkPixelMeasurementDet*>::const_iterator i=thePixelDets.begin();
         i!=thePixelDets.end(); i++) {
      (*i)->setActive(true);          // module ON
    }
  }
}

void MeasurementTracker::initializeStripStatus	(	const SiStripQuality *	stripQuality,
		int	qualityFlags,
		int	qualityDebugFlags
	)		const `[protected]`

Definition at line 571 of file MeasurementTracker.cc.

References SiStripBadStrip::decode(), cond::rpcobgas::detid, SiStripQuality::getBadApvs(), SiStripQuality::getBadFibers(), edm::ParameterSet::getParameter(), SiStripBadStrip::getRange(), i, SiStripQuality::IsModuleUsable(), j, SiStripDetId::TEC, SiStripDetId::TIB, SiStripDetId::TID, and SiStripDetId::TOB.

Referenced by MeasurementTracker().

                                                                                                                           {
  TkStripMeasurementDet::BadStripCuts badStripCuts[4];
  if (qualityFlags & BadStrips) {
     edm::ParameterSet cutPset = pset_.getParameter<edm::ParameterSet>("badStripCuts");
     badStripCuts[SiStripDetId::TIB-3] = TkStripMeasurementDet::BadStripCuts(cutPset.getParameter<edm::ParameterSet>("TIB"));
     badStripCuts[SiStripDetId::TOB-3] = TkStripMeasurementDet::BadStripCuts(cutPset.getParameter<edm::ParameterSet>("TOB"));
     badStripCuts[SiStripDetId::TID-3] = TkStripMeasurementDet::BadStripCuts(cutPset.getParameter<edm::ParameterSet>("TID"));
     badStripCuts[SiStripDetId::TEC-3] = TkStripMeasurementDet::BadStripCuts(cutPset.getParameter<edm::ParameterSet>("TEC"));
  }

  if ((quality != 0) && (qualityFlags != 0))  {
    edm::LogInfo("MeasurementTracker") << "qualityFlags = " << qualityFlags;
    unsigned int on = 0, tot = 0; 
    unsigned int foff = 0, ftot = 0, aoff = 0, atot = 0; 
    for (std::vector<TkStripMeasurementDet*>::const_iterator i=theStripDets.begin();
         i!=theStripDets.end(); i++) {
      uint32_t detid = ((**i).geomDet().geographicalId()).rawId();
      if (qualityFlags & BadModules) {
          bool isOn = quality->IsModuleUsable(detid);
          (*i)->setActive(isOn);
          tot++; on += (unsigned int) isOn;
          if (qualityDebugFlags & BadModules) {
            edm::LogInfo("MeasurementTracker")<< "MeasurementTracker::initializeStripStatus : detid " << detid << " is " << (isOn ?  "on" : "off");
          }
       } else {
          (*i)->setActive(true);
       }
       // first turn all APVs and fibers ON
       (*i)->set128StripStatus(true); 
       if (qualityFlags & BadAPVFibers) {
          short badApvs   = quality->getBadApvs(detid);
          short badFibers = quality->getBadFibers(detid);
          for (int j = 0; j < 6; j++) {
             atot++;
             if (badApvs & (1 << j)) {
                (*i)->set128StripStatus(false, j);
                aoff++;
             }
          }
          for (int j = 0; j < 3; j++) {
             ftot++;
             if (badFibers & (1 << j)) {
                (*i)->set128StripStatus(false, 2*j);
                (*i)->set128StripStatus(false, 2*j+1);
                foff++;
             }
          }
          (*i)->setMaskBad128StripBlocks((qualityFlags & MaskBad128StripBlocks) != 0);
       } 
       std::vector<TkStripMeasurementDet::BadStripBlock> &badStrips = (*i)->getBadStripBlocks();
       badStrips.clear();
       if (qualityFlags & BadStrips) {
            SiStripBadStrip::Range range = quality->getRange(detid);
            for (SiStripBadStrip::ContainerIterator bit = range.first; bit != range.second; ++bit) {
                badStrips.push_back(quality->decode(*bit));
            }
            (*i)->setBadStripCuts(badStripCuts[SiStripDetId(detid).subdetId()-3]);
       }
    }
    if (qualityDebugFlags & BadModules) {
        edm::LogInfo("MeasurementTracker StripModuleStatus") << 
            " Total modules: " << tot << ", active " << on <<", inactive " << (tot - on);
    }
    if (qualityDebugFlags & BadAPVFibers) {
        edm::LogInfo("MeasurementTracker StripAPVStatus") << 
            " Total APVs: " << atot << ", active " << (atot-aoff) <<", inactive " << (aoff);
        edm::LogInfo("MeasurementTracker StripFiberStatus") << 
            " Total Fibers: " << ftot << ", active " << (ftot-foff) <<", inactive " << (foff);
    }
  } else {
    for (std::vector<TkStripMeasurementDet*>::const_iterator i=theStripDets.begin();
         i!=theStripDets.end(); i++) {
      (*i)->setActive(true);          // module ON
      (*i)->set128StripStatus(true);  // all APVs and fibers ON
    }
  }
}

const std::vector<TkPixelMeasurementDet*>& MeasurementTracker::pixelDets ( ) const [inline]

Definition at line 79 of file MeasurementTracker.h.

References thePixelDets.

{return thePixelDets;}

void MeasurementTracker::setClusterToSkip	(	const edm::InputTag &	cluster,
		const edm::Event &	event
	)		const

Referenced by BaseCkfTrajectoryBuilder::setEvent().

const std::vector<TkStripMeasurementDet*>& MeasurementTracker::stripDets ( ) const [inline]

Definition at line 78 of file MeasurementTracker.h.

References theStripDets.

{return theStripDets;}

void MeasurementTracker::unsetClusterToSkip ( ) const

Definition at line 283 of file MeasurementTracker.cc.

References i, and LogDebug.

Referenced by BaseCkfTrajectoryBuilder::unset().

                                                  {
  LogDebug("MeasurementTracker")<<"unsetClusterToSkip";
  if (selfUpdateSkipClusters_)
    edm::LogError("MeasurementTracker")<<"this mode of operation is not supported, either the measurement tracker is set to skip clusters, or is being told to skip clusters. not both";

  for (std::vector<TkPixelMeasurementDet*>::const_iterator i=thePixelDets.begin();
       i!=thePixelDets.end(); i++) {
    (**i).unset();
  }
  for (std::vector<TkStripMeasurementDet*>::const_iterator i=theStripDets.begin();
       i!=theStripDets.end(); i++){
    (**i).unset();
  }
}

virtual void MeasurementTracker::update ( const edm::Event & ) const [virtual]

Reimplemented in OnDemandMeasurementTracker.

Referenced by SiStripElectronSeedGenerator::run(), RoadSearchTrackCandidateMakerAlgorithm::run(), MuonRoadTrajectoryBuilder::setEvent(), NuclearInteractionFinder::setEvent(), ConversionTrackFinder::setEvent(), BaseCkfTrajectoryBuilder::setEvent(), ConversionSeedFinder::setEvent(), MultiTrackFilterHitCollector::updateEvent(), and MultiRecHitCollector::updateEvent().

void MeasurementTracker::updatePixels ( const edm::Event & event ) const

Definition at line 298 of file MeasurementTracker.cc.

References edmNew::DetSetVector< T >::begin(), edmNew::DetSetVector< T >::empty(), edmNew::DetSetVector< T >::end(), edm::HandleBase::failedToGet(), edmNew::DetSetVector< T >::find(), i, LogDebug, edm::Handle< T >::product(), and python::multivaluedict::sort().

Referenced by OnDemandMeasurementTracker::update().

{
  // avoid to update twice from the same event
  if (!edm::Service<UpdaterService>()->checkOnce("MeasurementTracker::updatePixels::"+name_)) return;

  typedef edmNew::DetSet<SiPixelCluster> PixelDetSet;

  bool switchOffPixelsIfEmpty = (!pset_.existsAs<bool>("switchOffPixelsIfEmpty")) ||
                                (pset_.getParameter<bool>("switchOffPixelsIfEmpty"));

  std::vector<uint32_t> rawInactiveDetIds; 
  if (!theInactivePixelDetectorLabels.empty()) {
    edm::Handle<DetIdCollection> detIds;
    for (std::vector<edm::InputTag>::const_iterator itt = theInactivePixelDetectorLabels.begin(), edt = theInactivePixelDetectorLabels.end(); 
            itt != edt; ++itt) {
        event.getByLabel(*itt, detIds);
        rawInactiveDetIds.insert(rawInactiveDetIds.end(), detIds->begin(), detIds->end());
    }
    if (!rawInactiveDetIds.empty()) std::sort(rawInactiveDetIds.begin(), rawInactiveDetIds.end());
  }
  // Pixel Clusters
  std::string pixelClusterProducer = pset_.getParameter<std::string>("pixelClusterProducer");
  if( pixelClusterProducer.empty() ) { //clusters have not been produced
    for (std::vector<TkPixelMeasurementDet*>::const_iterator i=thePixelDets.begin();
         i!=thePixelDets.end(); i++) {
      if (switchOffPixelsIfEmpty) {
        (**i).setActiveThisEvent(false);
      }else{
        (**i).setEmpty();
      }
    }
  }else{  

    edm::Handle<edmNew::DetSetVector<SiPixelClusterRefNew> > pixelClusterRefs;
    if (selfUpdateSkipClusters_){
      //and get the collection of pixel ref to skip
      event.getByLabel(pset_.getParameter<edm::InputTag>("skipClusters"),pixelClusterRefs);
      LogDebug("MeasurementTracker")<<"getting pxl refs to skip";
      if (pixelClusterRefs.failedToGet())edm::LogError("MeasurementTracker")<<"not getting the pixel clusters to skip";
    }

    edm::Handle<edmNew::DetSetVector<SiPixelCluster> > pixelClusters;
    event.getByLabel(pixelClusterProducer, pixelClusters);
    const  edmNew::DetSetVector<SiPixelCluster>* pixelCollection = pixelClusters.product();
   
    if (switchOffPixelsIfEmpty && pixelCollection->empty()) {
        for (std::vector<TkPixelMeasurementDet*>::const_iterator i=thePixelDets.begin();
             i!=thePixelDets.end(); i++) {
              (**i).setActiveThisEvent(false);
        }
    } else { 

    for (std::vector<TkPixelMeasurementDet*>::const_iterator i=thePixelDets.begin();
         i!=thePixelDets.end(); i++) {

      // foreach det get cluster range
      unsigned int id = (**i).geomDet().geographicalId().rawId();
      if (!rawInactiveDetIds.empty() && std::binary_search(rawInactiveDetIds.begin(), rawInactiveDetIds.end(), id)) {
        (**i).setActiveThisEvent(false); continue;
      }
      //FIXME
      //fill the set with what needs to be skipped
      edmNew::DetSetVector<SiPixelCluster>::const_iterator it = pixelCollection->find( id );
      if ( it != pixelCollection->end() ){            
        // push cluster range in det
        (**i).update( *it, pixelClusters, id );
        if (selfUpdateSkipClusters_){
          edmNew::DetSetVector<SiPixelClusterRefNew>::const_iterator f=pixelClusterRefs->find(id);
          if (f!=pixelClusterRefs->end())
            (**i).setClusterToSkip(f->begin(),f->end());
        }
      }else{
        (**i).setEmpty();
      }
    }
    }
  }


  
}