// McRecoTrackNtuple.cpp

#include "McRecoTrackNtuple.h"
#include "trffit/TrackMatch.h"

using std::vector;
using std::string;

using trf::MCTrackList;
using trf::RTrackList;
using trf::TrackMatch;
using trf::McRecoTrackNtuple;

//**********************************************************************
// Local definitions.
//**********************************************************************

namespace {

// Ntuple names.
vector<string> names;

int name_count = 0;

}  // end unnamed namespoace

//**********************************************************************
// Member functions.
//**********************************************************************

// constructor

McRecoTrackNtuple::McRecoTrackNtuple(bool mc, bool reco, bool mc2)
: _mc(mc), _reco(reco), _mc2(mc&&mc2) {

}

//**********************************************************************

// Fill tuple from a match.

void McRecoTrackNtuple::fill_match(const TrackMatch& match) {

  // Fetch the matches.
  MCTrackList mctracks = match.get_matched1();
  RTrackList rtracks = match.get_matched2_in_order1();

  // Loop over matched tracks and fill tuple.
  assert( mctracks.size() == rtracks.size() );
  RTrackList::const_iterator itrr = rtracks.begin();
  MCTrackList::const_iterator itrmc;
  for ( itrmc=mctracks.begin();  itrmc!=mctracks.end(); ++itrmc )
    fill( **itrmc, **itrr++ );

  // Fill tuple for unmatched MC tracks.
  MCTrackList mcmiss = match.get_unmatched1();
  for ( itrmc=mcmiss.begin(); itrmc!=mcmiss.end(); ++itrmc ) {
    fill( **itrmc );
  }

  // Fill tuple for unmatched reco tracks.
  RTrackList rmiss = match.get_unmatched2();
  for ( itrr=rmiss.begin(); itrr!=rmiss.end(); ++itrr ) {
    fill( **itrr );
  }

}

//**********************************************************************

// Fill tuple from a match plus final MC tracks.

void McRecoTrackNtuple::
fill_match(const TrackMatch& match, const MCTrackList& mc2s) {

  // Fetch the matches.
  MCTrackList mctracks = match.get_matched1();
  RTrackList rtracks = match.get_matched2_in_order1();
  MCTrackList mcmiss = match.get_unmatched1();
  assert( mctracks.size() == rtracks.size() );
  assert( mctracks.size() + mcmiss.size() == mc2s.size() );

  // Loop over matched tracks and fill tuple.
  assert( mctracks.size() == rtracks.size() );
  RTrackList::const_iterator itrr = rtracks.begin();
  MCTrackList::const_iterator itrmc;
  MCTrackList::const_iterator itrmc2 = mc2s.begin();;
  for ( itrmc=mctracks.begin(); itrmc!=mctracks.end(); ++itrmc )
    fill( **itrmc, **itrr++, **itrmc2++ );

  // Fill tuple for unmatched MC tracks.
  for ( itrmc=mcmiss.begin(); itrmc!=mcmiss.end(); ++itrmc ) {
    fill( **itrmc, **itrmc2++ );
  }

  // Fill tuple for unmatched reco tracks.
  RTrackList rmiss = match.get_unmatched2();
  for ( itrr=rmiss.begin(); itrr!=rmiss.end(); ++itrr ) {
    fill( **itrr );
  }

}

//**********************************************************************

// Fill ntuple from a list of (unmatched) MC tracks.

void McRecoTrackNtuple::fill_list(const MCTrackList& mctrks) {
  for ( MCTrackList::const_iterator itrmc=mctrks.begin();
        itrmc!=mctrks.end(); ++itrmc ) fill(**itrmc);
}

//**********************************************************************

// Fill ntuple from a pair of lists of (unmatched) MC tracks.

void McRecoTrackNtuple::
fill_list(const MCTrackList& mctrks1, const MCTrackList& mctrks2) {
  assert( mctrks1.size() == mctrks2.size() );
  MCTrackList::const_iterator itrmc2 = mctrks2.begin();
  for ( MCTrackList::const_iterator itrmc1=mctrks1.begin();
        itrmc1!=mctrks1.end(); ++itrmc1 ) fill(**itrmc1,**itrmc2++);
}

//**********************************************************************

// Fill ntuple from a list of (unmatched) reconstructed tracks.

void McRecoTrackNtuple::fill_list(const RTrackList& rtrks) {
  for ( RTrackList::const_iterator itrr=rtrks.begin();
        itrr!=rtrks.end(); ++itrr ) fill(**itrr);
}

//**********************************************************************