/Users/jmonk/Physics/ForIA/src/AnalysisTools/TruthJetSelection.cxx

Go to the documentation of this file.

#include "ForIA/AnalysisTools/TruthJetSelection.hh"
#include "ForIA/Units.hh"
#include <cmath>
#include <stdexcept>

namespace ForIA {

  TruthJetSelection::TruthJetSelection(): 
    FourVectorSelection(),
    m_haveSeteMin(false),
    m_haveSetetMin(false),
    m_haveSetptMin(false),
    m_haveSetetaMin(false),
    m_haveSetetaMax(false),
    m_haveSetetMinTruthJet1(false),
    m_haveSetetMinTruthJet2(false),
    m_haveSetetaMinTruthJet1(false),
    m_haveSetetaMaxTruthJet1(false),
    m_haveSetetaMinTruthJet2(false),
    m_haveSetetaMaxTruthJet2(false),
    m_haveSetDeltaPhi(false),
    m_haveSetJet2ETOverJet1ET(false)
  {
    
  }

  const TruthJetVector &TruthJetSelection::acceptedTruthJets() const{
    if(m_freshEvent) fillVectors();
    return m_acceptedTruthJets;
  }
  const TruthJetVector &TruthJetSelection::rejectedTruthJets() const{
    if(m_freshEvent) fillVectors();
    return m_rejectedTruthJets;
  }

  bool TruthJetSelection::setSelection(DefinedSelection selection){
    if(!m_canSetCuts) return false;

    m_haveSeteMin  = false;
    m_haveSetetMin = false;
    m_haveSetptMin  = false;
    m_haveSetetaMin= false;
    m_haveSetetaMax= false;

    switch (selection) {
    case LOOSE:
      setSelection(LOOSE);
      setETMinTruthJet1(10.0 * GeV);
      break;
      
    case MEDIUM:
      setSelection(MEDIUM);
      setETMinTruthJet1(10.0 * GeV);
      setETMinTruthJet2(10.0 * GeV);
      break;

    case TIGHT:
      setSelection(TIGHT);
      setEMin(20.0 * GeV);
      break;

    }

    return true;
  }

  void TruthJetSelection::fillVectors() const{
    
    //std::cout<<"TruthJetSelection fillVectors!" <<std::endl;

    m_freshEvent = false;
    
    m_acceptedTruthJets.clear();
    m_passedFourVectors.clear();
    m_rejectedTruthJets.clear();
    m_rejectedFourVectors.clear();

    if(m_event == 0) return;

    TruthJetVector input = m_event->truthJets();

    if(input.size() == 0 ) return;

    bool passedCuts = true;
    /*
    if(m_haveSetetMinTruthJet1 && passedCuts){
      passedCuts = input.at(0)->ET() > m_etMinTruthJet1;
      if(m_haveSetetaMinTruthJet1 && passedCuts ) 
        passedCuts = fabs( input.at(0)->eta() ) >= m_etaMinTruthJet1;
      if(m_haveSetetaMaxTruthJet1 && passedCuts )
        passedCuts = fabs( input.at(0)->eta() ) <=  m_etaMaxTruthJet1;
    }
    if(m_haveSetetMinTruthJet2 && passedCuts){
      passedCuts = (input.size()>1) ? (input.at(1)->ET() > m_etMinTruthJet2) : false;
      if(m_haveSetetaMinTruthJet1 && passedCuts )
        passedCuts = fabs( input.at(1)->eta() ) >= m_etaMinTruthJet2;
      if(m_haveSetetaMaxTruthJet2 && passedCuts )
        passedCuts = fabs( input.at(1)->eta() ) <=  m_etaMaxTruthJet2;
      if(m_haveSetJet2ETOverJet1ET && passedCuts )
        passedCuts = input.at(1)->ET() / input.at(0)->ET() > m_jet2ETOverjet1ET;
      if(m_haveSetDeltaPhi && passedCuts){
        double dphi = input.at(0)->phi() - input.at(1)->phi();
        dphi = (fmod( dphi + 3.0 * M_PI, 2.0 * M_PI ) - M_PI );
        passedCuts = dphi > m_deltaPhi;
      }
    }
    */
    if(passedCuts){
      for(TruthJetVector::const_iterator jet = input.begin();
          jet != input.end(); ++jet){
                        
        if(m_haveSeteMin   && passedCuts){
          passedCuts = ((*jet)->E() > m_eMin);
        }
        if (m_haveSetetMin && passedCuts){
          passedCuts = ((*jet)->ET() >= m_etMin);     
        }
        if (m_haveSetptMin && passedCuts){
          passedCuts = ((*jet)->PT() >= m_ptMin);
        }
        if(m_haveSetetaMin && passedCuts){ passedCuts = (fabs((*jet)->eta()) >= m_etaMin);}
        if(m_haveSetetaMax && passedCuts){ passedCuts = (fabs((*jet)->eta()) <= m_etaMax);}
        
        if(passedCuts){
          m_acceptedTruthJets.push_back( *jet );
          m_passedFourVectors.push_back( *jet ); 
        } else {
          m_rejectedTruthJets.push_back( *jet );
          m_rejectedFourVectors.push_back( *jet );
        }
      }
    }
    return;
  }

  bool TruthJetSelection::setETMin(double etMin){
    if(!m_canSetCuts) return false;
    m_haveSetetMin = true;
    m_etMin = etMin;
    return true;
  }

  bool TruthJetSelection::setETMinTruthJet1(double etMinTruthJet1){
    if(!m_canSetCuts) return false;
    m_haveSetetMinTruthJet1 = true;
    m_etMinTruthJet1 = etMinTruthJet1;
    return true;
  }

  bool TruthJetSelection::setETMinTruthJet2(double etMinTruthJet2){
    if(!m_canSetCuts) return false;
    m_haveSetetMinTruthJet2 = true;
    m_etMinTruthJet2 = etMinTruthJet2;
    return true;
  }

  bool TruthJetSelection::setEtaMinTruthJet1(double etaMinTruthJet1){
    if(!m_canSetCuts) return false;
    m_haveSetetaMinTruthJet1 = true;
    m_etaMinTruthJet1 = etaMinTruthJet1;
    return true;
  }

  bool TruthJetSelection::setEtaMaxTruthJet1(double etaMaxTruthJet1){
    if(!m_canSetCuts) return false;
    m_haveSetetaMaxTruthJet1 = true;
    m_etaMaxTruthJet1 = etaMaxTruthJet1;
    return true;
  }

  bool TruthJetSelection::setEtaMinTruthJet2(double etaMinTruthJet2){
    if(!m_canSetCuts) return false;
    m_haveSetetaMinTruthJet2 = true;
    m_etaMinTruthJet2 = etaMinTruthJet2;
    return true;
  }

  bool TruthJetSelection::setEtaMaxTruthJet2(double etaMaxTruthJet2){
    if(!m_canSetCuts) return false;
    m_haveSetetaMaxTruthJet2 = true;
    m_etaMaxTruthJet2 = etaMaxTruthJet2;
    return true;
  }

  bool TruthJetSelection::setDeltaPhi( double deltaPhi ){
    if(!m_canSetCuts) return false;
    m_haveSetDeltaPhi = true;
    m_deltaPhi = deltaPhi;
    return true;
  }
  
  bool TruthJetSelection::setJet2ETOverJet1ET( double jet2ETOverjet1ET ){
    if(!m_canSetCuts) return false;
    m_haveSetJet2ETOverJet1ET = true;
    m_jet2ETOverjet1ET = jet2ETOverjet1ET;
    return true;
  }
  
  bool TruthJetSelection::setPTMin(double ptMin){
    if(!m_canSetCuts) return false;
    m_haveSetptMin = true;
    m_ptMin = ptMin;
    return true;
  }

  bool TruthJetSelection::setEMin(double eMin){
    if(!m_canSetCuts) return false;
    m_haveSeteMin = true;
    m_eMin = eMin;
    return true;
  }

  bool TruthJetSelection::setEtaMin(double etaMin){
    if(!m_canSetCuts) return false;
    m_haveSetetaMin = true;
    m_etaMin = etaMin;
    return true;
  }

  bool TruthJetSelection::setEtaMax(double etaMax){
    if(!m_canSetCuts) return false;
    m_haveSetetaMax = true;
    m_etaMax = etaMax;
    return true;
  }

}//end