TrgTrackConverter.cpp

Go to the documentation of this file.

#include "TrgConverter/TrgTrackConverter.h"
#include "Event/TrackKeys.h"

void TrgTrackConverter::toTrack(const TrgTrack& gtrack, Track& track) {
  
  // reset the track
  track.reset();

  // set the fields
  setFields(gtrack,track);
  
  // set the chi2
  track.setChi2PerDoF(gtrack.chiSquared());
  track.setNDoF(gtrack.degreeOfFreedom());
  
  // set the physics state
  toState(gtrack.firstState(),track.firstState());
  
  // set the other states
  for (std::vector<TrgState>::const_iterator it = gtrack.otherStates().begin();
       it != gtrack.otherStates().end(); it++) {
    const TrgState& gstate = *it;
    State* state = new State();
    toState(gstate,*state);
    track.addToStates(*state);
  }
  
  // set the LHCbIDs
  std::vector<LHCbID> ids = lhcbIDs(gtrack);
  track.setLhcbIDs(ids);

}

void TrgTrackConverter::setFields(const TrgTrack& gtrack, Track& track) {
  
  // setting the type
  TrgTrack::TrgTrackType gtype = (TrgTrack::TrgTrackType) gtrack.type();
  if (gtype == TrgTrack::TypeVeloR ) track.setType(TrackKeys::VeloR);
  if (gtype == TrgTrack::TypeVelo3D) track.setType(TrackKeys::Velo);
  if (gtype == TrgTrack::TypeVeloTT) track.setType(TrackKeys::Downstream);
  if (gtype == TrgTrack::TypeLong)   track.setType(TrackKeys::Long);
  if (gtype == TrgTrack::TypeDownstream) track.setType(TrackKeys::Downstream);

  // setting the history
  track.setHistory(TrackKeys::TrgVelo);
  if (gtype == TrgTrack::TypeDownstream) 
    track.setHistory(TrackKeys::TrgVeloTT);
  if (gtype == TrgTrack::TypeLong) track.setHistory(TrackKeys::TrgForward);
  if (gtype == TrgTrack::TypeKShort) track.setHistory(TrackKeys::TrKshort);
  
  // set the flags
  track.setFlag(TrackKeys::Valid,true);
  track.setFlag(TrackKeys::Unique,true);
  if (gtrack.backward()) track.setFlag(TrackKeys::Backward,true);

  if (gtrack.selectedIP2D()) track.setFlag(TrackKeys::IPSelected,true);
  if (gtrack.selectedMuon2D()) track.setFlag(TrackKeys::PIDSelected,true);
 
}

std::vector<LHCbID>  TrgTrackConverter::lhcbIDs(const TrgTrack& gtrack) {

  std::vector<LHCbID> ids;
  
  const std::vector< std::pair<VeloChannelID,int> >& vref 
    = gtrack.veloReference();
  for (std::vector< std::pair<VeloChannelID,int> >::const_iterator
         it = vref.begin(); it != vref.end(); it++) {
    const std::pair<VeloChannelID,int>& velo = *it;
    LHCbID id = LHCbID(velo.first);
    id.setSpareBits((unsigned) velo.second);
    ids.push_back(id);
  }
  
  const std::vector< std::pair<ITChannelID,int> >& itref 
    = gtrack.itReference();
  for (std::vector< std::pair<ITChannelID,int> >::const_iterator
         it = itref.begin(); it != itref.end(); it++) {
    const std::pair<ITChannelID,int>& si = *it;
    LHCbID id = LHCbID(si.first);
    id.setSpareBits((unsigned) si.second);
    ids.push_back(id);
  }
  
  
  const std::vector< std::pair<OTChannelID,int> >& otref 
    = gtrack.otReference();
  for (std::vector< std::pair<OTChannelID,int> >::const_iterator
         it = otref.begin(); it != otref.end(); it++) {
    const std::pair<OTChannelID,int>& ot = *it;
    LHCbID id = LHCbID(ot.first);
    // id.setSpareBits((unsigned) ot.second);
    ids.push_back(id);
  }

  return ids;
}

void TrgTrackConverter::toState(const TrgState& gstate, State& state) {
  state.setState(gstate.stateVector());
  state.setCovariance(gstate.covariance());
  state.setZ(gstate.z());
}

//----------- To Trg  

void TrgTrackConverter::toTrgTrack(const Track& track, TrgTrack& gtrack) {

  gtrack.reset();

  // set the types
  setTrgFields(track,gtrack);
  
  // set the chi2
  gtrack.setChiSquared(track.chi2());
  gtrack.setDegreeOfFreedom(track.nDoF());
  
  // set the main state
  toTrgState(track.firstState(),gtrack.firstState());
  
  // set the other states
  for (std::vector<State*>::const_iterator 
         it = track.states().begin(); it != track.states().end(); it++) {
    const State& state = *(*it);
    TrgState gstate;
    toTrgState(state,gstate);
    gtrack.otherStates().push_back(gstate);
  }
  
  // set the references
  const std::vector<LHCbID>& ids = track.lhcbIDs();
  setTrgTrackReferences(ids,gtrack);
  
}

void TrgTrackConverter::toTrgState(const State& state, TrgState& gstate) {
  gstate.setStateVector(state.stateVector());
  gstate.setCovariance(state.covariance());
  gstate.setZ(state.z());
}

void TrgTrackConverter::setTrgTrackReferences(const std::vector<LHCbID>& ids, 
                                              TrgTrack& gtrack) {
  
  std::vector< std::pair<VeloChannelID,int> > veref;
  std::vector< std::pair<ITChannelID,int> > siref; 
  std::vector< std::pair<OTChannelID,int> > otref;

  for (std::vector<LHCbID>::const_iterator it = ids.begin();
       it != ids.end(); it++) {
    const LHCbID& id = *it;
    int size = (int) id.spareBits();
    if (id.isVelo()) {
      veref.push_back( std::pair<VeloChannelID,int>(id.veloID(),size));
    } else if (id.isST()) {
      size = 1;
      veref.push_back( std::pair<ITChannelID,int>(id.stID(),size));
    } else if (id.isOT()) {
      veref.push_back( std::pair<OTChannelID,int>(id.otID(),size));
    }
  }
  
  gtrack.setVeloReference(veref);
  gtrack.setITReference(siref);
  gtrack.setOTReference(otref);
}

void TrgTrackConverter::setTrgFields(const Track& track, TrgTrack& gtrack) {

  // setting the type
  gtrack.setType(TrgTrack::TypeUnknown);
  if (track.type() == TrackKeys::VeloR);
    gtrack.setType( TrgTrack::TypeUnknown);
  if (track.checkFlag(TrackKeys::Backward)) gtrack.setBackward(true);
  if (track.type() == TrackKeys::Long)
      gtrack.setType(TrgTrack::TypeLong);
  if (track.type() == TrackKeys::Upstream) 
      gtrack.setType(TrgTrack::TypeVeloTT);
  if (track.type() == TrackKeys::Downstream) 
      gtrack.setType(TrgTrack::TypeVeloTT);
  
  // setting the flags
  if (track.checkFlag(TrackKeys::Valid)) gtrack.setBadTrack(false);
  else gtrack.setBadTrack(true);
  
  if (track.checkFlag(TrackKeys::IPSelected)) gtrack.setSelectedIP2D(true);
  if (track.checkFlag(TrackKeys::PIDSelected)) gtrack.setSelectedMuon2D(true);
  
}
 

---