TrgTrackConverter.cpp

Go to the documentation of this file.

#include "TrgTrackConverter.h"

Track* TrgTrackConverter::toTrack(const TrgTrack& gtrack) {

  // construct the track
  Track* track = new Track();

  // set the types
  std::vector<Track::TrackType> types = TrackTypes(gtrack);
  for (std::vector<Track::TrackType>::const_iterator 
         it = types.begin(); it != types.end(); it++) {
    track->setType(*it);
  }
    
  // set the flags
  std::vector<Track::Flag> flags = TrackFlags(gtrack);
  for (std::vector<Track::Flag>::const_iterator 
         it = flags.begin(); it != flags.end(); it++) {
    track->setFlag(*it);
  }

  // set the chi2
  track->setChi2PerDoF(gtrack.chiSquared());
  track->setNDoF(1);

  // set the main state
  toState(gtrack.firstState(),track->physicsState());

  // 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 = TrackIDs(gtrack);
  track->setLhcbIDs(ids);

  return track;
}

std::vector<Track::TrackType> 
TrgTrackConverter::TrackTypes(const TrgTrack& gtrack) {
  std::vector<Track::TrackType> types;
  TrgTrack::TrgTrackType gtype = (TrgTrack::TrgTrackType) gtrack.type();
  Track::TrackType type = Track::Velo;
  if (gtype == TrgTrack::TypeVeloR )
    type = Track::VeloR;
  else if (gtype == TrgTrack::TypeVelo3D)
    type = Track::Velo;
  else if (gtype == TrgTrack::TypeVeloTT)
    type = Track::Downstream;
  else if (gtype == TrgTrack::TypeLong)
    type = Track::Long;
  else if (gtype == TrgTrack::TypeDownstream)
    type = Track::Downstream;
  //  else if (gtype == TrgTrack::TypeKShort)
  //  type = Track::KShort;
  
  types.push_back(type);
  
  return types;


}

std::vector<Track::HistoryFlag> 
TrgTrackConverter::TrackHistory(const TrgTrack& gtrack) {
  std::vector<Track::HistoryFlag> history;
  return history;
}

std::vector<Track::Flag> 
TrgTrackConverter::TrackFlags(const TrgTrack& gtrack) {
  std::vector<Track::Flag> flags;
  // if (gtrack.badTrack())
  //  flags.push_back(TrackFlag::valid);
  //   else if (gtrack.alreadyUsed())
  //     flags.push_back(TrackFlag::used);
  //   else if (gtrack.backward())
  //     flags.push_back(TrackFlag::backward);
  //   else if (gtrack.selectedIP2D())
  //     flags.push_back(TrackFlag::IPselected);
  return flags;
}

std::vector<LHCbID> 
TrgTrackConverter::TrackIDs(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);
    // vid.setSpecific((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);
    // vid.setSpecific((unsigned) velo.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<VeloChannelID,int>& ot = *it;
    LHCbID id = LHCbID(ot.first);
    // vid.setSpecific((unsigned) velo.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());
}

TrgTrack* TrgTrackConverter::toTrgTrack(const Track& track) {

  TrgTrack* gtrack = new TrgTrack();
  return gtrack;
}


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

}

std::ostream& TrgTrackConverter::str(const Track& track, std::ostream& os) {
  os << " flags " << track.flags() << std::endl;
  os << " chi2  " << track.chi2() << std::endl;
  os << " physics state "; str(track.physicsState(),os); 
  return os; 
}



std::ostream& TrgTrackConverter::str(const State& state, std::ostream& os) {
  os << " flags " << state.flags() << std::endl;
  os << " z " << state.z() << std::endl;
  os << " state " << state.state() << std::endl;
  os << " cov " << state.covariance() << std::endl;
  return os;
}

---