VertexSelector.cpp

Go to the documentation of this file.

#include "caf_util/VertexSelector.hpp"
#include "cafe/Config.hpp"

#include <string>
#include <sstream>

using namespace std ;
using namespace cafe ;
 
namespace {
  bool lessThan(const TMBPrimaryVertex& a, const TMBPrimaryVertex& b) {
    return a.probMB() < b.probMB();    
  }
}

namespace caf_util {

  VertexSelector::VertexSelector(const char *name) : 
    cafe::SelectUserObjects<TMBPrimaryVertex>(name),
    _nselected(0), 
    _muvars("_hasCentral", "_chptr"), 
    _emvars()
  {
    // get parameters from the configuration file
    cafe::Config config(name);

    _zmax = config.get("zmax", 60) ;
    _ntracks = config.get("ntracks", 3) ;
    _dz_muon = config.get("dz_muon", 0) ;
    _muonBranch = config.get("muonBranch", "") ;

    _dz_electron = config.get("dz_electron", 0) ;
    _electronBranch = config.get("electronBranch", "") ;
    _useEOPetrack = config.get("UseEOPTrackMatchElectron", false) ;
    if (_useEOPetrack) {
      _emvars.add("_SpatialTrMatchChi2Prob") ;
      _emvars.add("_chptrBest") ;
    } else {
      _emvars.add("_SpatialTrMatchChi2ProbBest") ;
      _emvars.add("_chptr") ;
    }

    _sort = config.get("Sort", 0);
    _nvsmax = config.get("nPVMax", -1);

    _finder.SetVariablesTrack(Variables("fUniqueID", "_z")) ;
    addVariable("_VertexZ") ;
    addVariable("_ntrack") ;
  };
  
  void VertexSelector::begin() {
    _finder.setDebug(debug()) ;
  }

  bool VertexSelector::processEvent(cafe::Event &event)
  {
    //get pointer to statistics collector
    event.get("StatPointer", _stat) ;
    _event = &event ;
    _nselected = 0 ;
    SelectUserObjects<TMBPrimaryVertex>::processEvent(event) ;

    if (_nselected == 0) return false ;

    if (_nvsmax >= 0) {
      if (_nselected > _nvsmax) return false ; 
      ostringstream st ;
      st << "Number of vertices <= " << _nvsmax ;
      _stat.EventSelected(st.str()) ;      
    }

    return true ;
  };
  
  bool VertexSelector::selectObject(const TMBPrimaryVertex &vertex)
  {     
    if (fabs(vertex.vz()) >= _zmax) return false ;
    {
      ostringstream st ;
      st << "Vertex Z < " << _zmax << " cm" ;
      _stat.EventSelected(st.str()) ;     
    }

    if (fabs(vertex.ntrack()) < _ntracks) return false ;
    {
      ostringstream st ;
      st << "N tracks for vertex >= " << _ntracks ;
      _stat.EventSelected(st.str()) ;     
    }

    if (_dz_muon > 0) {
      Collection<TMBMuon> from(_event->getCollection<TMBMuon>(_muonBranch.c_str(),_muvars));
      if (from.size() == 0) {
        out() << "VERTEX SELECTOR WARNING in dz(muon,vertex) cut! Branch " 
              << _muonBranch << " is empty or is not existing! "
              << endl ;
        return false ;
      }

      Collection<TMBMuon>::const_iterator it = from.begin();
      for(; it != from.end(); ++it) {

        if (debug()>2) 
          cout << "PROCESSOR \"" << name() 
               << "\" READ MUON: pT = " << it->Pt() 
               << " eta = " << it->Eta() 
               << " phi = " << it->Phi() 
               << endl ;
        
        if (!it->hasCentral()) {

          err() << "VERTEX SELECTOR WARNING! "
                << "You should use only muon with central track for the cut "
                << "dz(muon,vertex)."
                << endl ;
          continue ;
        }
        const TMBTrack* trk =  _finder.FindTrack(*_event, it->GetChargedTrackRef()) ;
        if (!trk) {
          err() << "VERTEX SELECTOR ERROR!"
                << " Track pointer from the muon is 0!"
                << endl ;
          continue ;
        }   
        
        if (debug()>2) 
          cout << " MUON TRACK: pT = " << trk->Pt() 
               << " eta = " << trk->Eta() 
               << " phi = " << trk->Phi() 
               << endl ;

        if (fabs(vertex.vz() - trk->z()) < _dz_muon) break ;
      }
      if (!(it != from.end())) return false ;

      ostringstream st ;
      st << "dZ(muon, vertex) < " << (float) _dz_muon << " cm" ;
      _stat.EventSelected(st.str()) ;     
    }

    if (_dz_electron > 0) {
      Collection<TMBEMCluster> from(_event->getCollection<TMBEMCluster>(_electronBranch.c_str(),_emvars));

      if (from.size() == 0) {
        out() << "VERTEX SELECTOR WARNING in dz(electron,vertex) cut! Branch " 
              << _electronBranch << " is empty or is not existing! "
              << endl ;
        return false ;
      }

      Collection<TMBEMCluster>::const_iterator it = from.begin();
      for(; it != from.end(); ++it) {   
        
        if (debug()>2) 
          cout << "PROCESSOR \"" << name() 
               << "\" READ ELECTRON: pT = " << it->Pt() 
               << " eta = " << it->Eta() 
               << " phi = " << it->Phi() 
               << endl ;

        const TMBTrack* trk = 0 ;
        if ( (_useEOPetrack && !it->has_track_match(0.0) ) ||
             (!_useEOPetrack && !it->has_spatial_track_match(0.0))) {
          err() << "VERTEX SELECTOR WARNING! "
                << "You should use only track matched electron for the cut "
                << "dz(electron,vertex)."
                << endl ;
          continue ;
        }
        
        if (_useEOPetrack) 
          trk = _finder.FindTrack(*_event, it->getPtrChpRef()) ;
        else 
          trk = _finder.FindTrack(*_event, it->GetChargedTrackRef()) ;

        if (!trk) {
          err() << "VERTEX SELECTOR WARNING! "
                << "No track was found for track matched electron!"
                << endl ;
          continue ;
        }   
        
        if (debug()>2) 
          cout << " ELECTRON TRACK: pT = " << trk->Pt() 
               << " eta = " << trk->Eta() 
               << " phi = " << trk->Phi() 
               << endl ;

        if (fabs(vertex.vz() - trk->z()) < _dz_electron) break ;
      }
      if (!(it != from.end())) return false ;

      ostringstream st ;
      st << "dZ(electron, vertex) < " << (float) _dz_electron << " cm" ;
      _stat.EventSelected(st.str()) ;     
    }

    _nselected++ ;

    return true ;

  }
  
  void VertexSelector::before(cafe::Collection<TMBPrimaryVertex>& from) {
      if(_sort) {
          from.sort(from.begin(),from.end(),::lessThan) ;
      }
  }

}
ClassImp(caf_util::VertexSelector) ;
  

---