#include <EventLoop/Job.h>
#include <EventLoop/StatusCode.h>
#include <EventLoop/Worker.h>
#include <MyAnalysis/MyxAODAnalysis.h>

#include "xAODRootAccess/Init.h"
#include "xAODRootAccess/TEvent.h"

#include "xAODTau/TauJetContainer.h"
#include "xAODMuon/MuonContainer.h"
#include "xAODTau/TauDefs.h" 
#include "xAODTau/TauJet.h"
#include "xAODTruth/TruthParticleAuxContainer.h"
#include "xAODTruth/TruthParticleContainer.h"

#include "TauAnalysisTools/TauTruthMatchingTool.h"
#include "TauAnalysisTools/TauTruthTrackMatchingTool.h"

#include <iostream>

// this is needed to distribute the algorithm to the workers
ClassImp(MyxAODAnalysis)



MyxAODAnalysis :: MyxAODAnalysis ()
{
  // Here you put any code for the base initialization of variables,
  // e.g. initialize all pointers to 0.  Note that you should only put
  // the most basic initialization here, since this method will be
  // called on both the submission and the worker node.  Most of your
  // initialization code will go into histInitialize() and
  // initialize().
}



EL::StatusCode MyxAODAnalysis :: setupJob (EL::Job& job)
{
  // Here you put code that sets up the job on the submission object
  // so that it is ready to work with your algorithm, e.g. you can
  // request the D3PDReader service or add output files.  Any code you
  // put here could instead also go into the submission script.  The
  // sole advantage of putting it here is that it gets automatically
  // activated/deactivated when you add/remove the algorithm from your
  // job, which may or may not be of value to you.

  job.useXAOD();
  xAOD::Init( "MyxAODAnalysis" ).ignore(); // call before opening first file
  
  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: histInitialize ()
{
  // Here you do everything that needs to be done at the very
  // beginning on each worker node, e.g. create histograms and output
  // trees.  This method gets called before any input files are
  // connected.

  double n_eta = 10;  double min_eta = -2.5;   double max_eta = 2.5;
  double n_pt = 100;   double min_pt = 0;       double max_pt = 200.;

  h_1p_true_pion_tracks_eta = new TH1F("h_1p_true_pion_tracks_eta", "h_1p_true_pion_tracks_eta", n_eta, min_eta, max_eta);
  h_1p_true_pion_tracks_eta_passfilter = new TH1F("h_1p_true_pion_tracks_eta_passfilter", "h_1p_true_pion_tracks_eta_passfilter", n_eta, min_eta, max_eta);
  h_3p_true_pion_tracks_eta = new TH1F("h_3p_true_pion_tracks_eta", "h_3p_true_pion_tracks_eta", n_eta, min_eta, max_eta);
  h_3p_true_pion_tracks_eta_passfilter = new TH1F("h_3p_true_pion_tracks_eta_passfilter", "h_3p_true_pion_tracks_eta_passfilter", n_eta, min_eta, max_eta);

  h_1p_true_spurious_tracks_eta = new TH1F("h_1p_true_spurious_tracks_eta", "h_1p_true_spurious_tracks_eta", n_eta, min_eta, max_eta);
  h_1p_true_spurious_tracks_eta_passfilter = new TH1F("h_1p_true_spurious_tracks_eta_passfilter", "h_1p_true_spurious_tracks_eta_passfilter", n_eta, min_eta, max_eta);
  h_3p_true_spurious_tracks_eta = new TH1F("h_3p_true_spurious_tracks_eta", "h_3p_true_spurious_tracks_eta", n_eta, min_eta, max_eta);
  h_3p_true_spurious_tracks_eta_passfilter = new TH1F("h_3p_true_spurious_tracks_eta_passfilter", "h_3p_true_spurious_tracks_eta_passfilter", n_eta, min_eta, max_eta);

  h_1p_true_spurious_conversion_tracks_eta = new TH1F("h_1p_true_spurious_conversion_tracks_eta", "h_1p_true_spurious_conversion_tracks_eta", n_eta, min_eta, max_eta);
  h_1p_true_spurious_conversion_tracks_eta_passfilter = new TH1F("h_1p_true_spurious_conversion_tracks_eta_passfilter", "h_1p_true_spurious_conversion_tracks_eta_passfilter", n_eta, min_eta, max_eta);
  h_3p_true_spurious_conversion_tracks_eta = new TH1F("h_3p_true_spurious_conversion_tracks_eta", "h_3p_true_spurious_conversion_tracks_eta", n_eta, min_eta, max_eta);
  h_3p_true_spurious_conversion_tracks_eta_passfilter = new TH1F("h_3p_true_spurious_conversion_tracks_eta_passfilter", "h_3p_true_spurious_conversion_tracks_eta_passfilter", n_eta, min_eta, max_eta);

  h_1p_true_taus_eta        = new TH1F("h_1p_true_taus_eta", "h_1p_true_taus_eta", n_eta, min_eta, max_eta);
  h_1p_true_taus_eta_reco1p = new TH1F("h_1p_true_taus_eta_reco1p", "h_1p_true_taus_eta_reco1p", n_eta, min_eta, max_eta);
  h_1p_true_taus_eta_filter1p = new TH1F("h_1p_true_taus_eta_filter1p", "h_1p_true_taus_eta_filter1p", n_eta, min_eta, max_eta);
  h_3p_true_taus_eta        = new TH1F("h_3p_true_taus_eta", "h_3p_true_taus_eta", n_eta, min_eta, max_eta);
  h_3p_true_taus_eta_reco3p = new TH1F("h_3p_true_taus_eta_reco3p", "h_3p_true_taus_eta_reco3p", n_eta, min_eta, max_eta);
  h_3p_true_taus_eta_filter3p = new TH1F("h_3p_true_taus_eta_filter3p", "h_3p_true_taus_eta_filter3p", n_eta, min_eta, max_eta);


  h_fake_taus_eta =  new TH1F("h_fake_taus_eta", "h_fake_taus_eta", n_eta, min_eta, max_eta);
  h_fake_taus_pt =  new TH1F("h_fake_taus_eta", "h_fake_taus_eta", n_pt, min_pt, max_pt);
  h_fake_taus_1t_eta =  new TH1F("h_fake_taus_1t_eta", "h_fake_taus_1t_eta", n_eta, min_eta, max_eta);
  h_fake_taus_1t_pt =  new TH1F("h_fake_taus_1t_eta", "h_fake_taus_1t_eta", n_pt, min_pt, max_pt);
  h_fake_taus_1ft_eta =  new TH1F("h_fake_taus_1ft_eta", "h_fake_taus_1ft_eta", n_eta, min_eta, max_eta);
  h_fake_taus_1ft_pt =  new TH1F("h_fake_taus_1ft_eta", "h_fake_taus_1ft_eta", n_pt, min_pt, max_pt);

  h_fake_taus_3t_eta =  new TH1F("h_fake_taus_3t_eta", "h_fake_taus_3t_eta", n_eta, min_eta, max_eta);
  h_fake_taus_3t_pt =  new TH1F("h_fake_taus_3t_eta", "h_fake_taus_3t_eta", n_pt, min_pt, max_pt);
  h_fake_taus_3ft_eta =  new TH1F("h_fake_taus_3ft_eta", "h_fake_taus_3ft_eta", n_eta, min_eta, max_eta);
  h_fake_taus_3ft_pt =  new TH1F("h_fake_taus_3ft_eta", "h_fake_taus_3ft_eta", n_pt, min_pt, max_pt);

  wk()->addOutput (h_1p_true_pion_tracks_eta);
  wk()->addOutput (h_1p_true_pion_tracks_eta_passfilter);
  wk()->addOutput (h_3p_true_pion_tracks_eta);
  wk()->addOutput (h_3p_true_pion_tracks_eta_passfilter);

  wk()->addOutput (h_1p_true_spurious_tracks_eta);
  wk()->addOutput (h_1p_true_spurious_tracks_eta_passfilter);
  wk()->addOutput (h_3p_true_spurious_tracks_eta);
  wk()->addOutput (h_3p_true_spurious_tracks_eta_passfilter);

  wk()->addOutput (h_1p_true_spurious_conversion_tracks_eta);
  wk()->addOutput (h_1p_true_spurious_conversion_tracks_eta_passfilter);
  wk()->addOutput (h_3p_true_spurious_conversion_tracks_eta);
  wk()->addOutput (h_3p_true_spurious_conversion_tracks_eta_passfilter);

  wk()->addOutput (h_1p_true_taus_eta);
  wk()->addOutput (h_1p_true_taus_eta_reco1p);
  wk()->addOutput (h_1p_true_taus_eta_filter1p);
  wk()->addOutput (h_3p_true_taus_eta);
  wk()->addOutput (h_3p_true_taus_eta_reco3p);
  wk()->addOutput (h_3p_true_taus_eta_filter3p);

  wk()->addOutput (h_fake_taus_eta);
  wk()->addOutput (h_fake_taus_pt);
  wk()->addOutput (h_fake_taus_1t_eta);
  wk()->addOutput (h_fake_taus_1t_pt);
  wk()->addOutput (h_fake_taus_1ft_eta);
  wk()->addOutput (h_fake_taus_1ft_pt);
  wk()->addOutput (h_fake_taus_3t_eta);
  wk()->addOutput (h_fake_taus_3t_pt);
  wk()->addOutput (h_fake_taus_3ft_eta);
  wk()->addOutput (h_fake_taus_3ft_pt);

  h_1p_true_pion_tracks_pt = new TH1F("h_1p_true_pion_tracks_pt", "h_1p_true_pion_tracks_pt", n_pt, min_pt, max_pt);
  h_1p_true_pion_tracks_pt_passfilter  = new TH1F("h_1p_true_pion_tracks_pt_passfilter", "h_1p_true_pion_tracks_pt_passfilter", n_pt, min_pt, max_pt);
  h_3p_true_pion_tracks_pt = new TH1F("h_3p_true_pion_tracks_pt", "h_3p_true_pion_tracks_pt", n_pt, min_pt, max_pt);
  h_3p_true_pion_tracks_pt_passfilter = new TH1F("h_3p_true_pion_tracks_pt_passfilter", "h_3p_true_pion_tracks_pt_passfilter", n_pt, min_pt, max_pt);

  h_1p_true_spurious_tracks_pt = new TH1F("h_1p_true_spurious_tracks_pt", "h_1p_true_spurious_tracks_pt", n_pt, min_pt, max_pt);
  h_1p_true_spurious_tracks_pt_passfilter = new TH1F("h_1p_true_spurious_tracks_pt_passfilter", "h_1p_true_spurious_tracks_pt_passfilter", n_pt, min_pt, max_pt);
  h_3p_true_spurious_tracks_pt = new TH1F("h_3p_true_spurious_tracks_pt", "h_3p_true_spurious_tracks_pt", n_pt, min_pt, max_pt);
  h_3p_true_spurious_tracks_pt_passfilter = new TH1F("h_3p_true_spurious_tracks_pt_passfilter", "h_3p_true_spurious_tracks_pt_passfilter", n_pt, min_pt, max_pt);

  h_1p_true_spurious_conversion_tracks_pt = new TH1F("h_1p_true_spurious_conversion_tracks_pt", "h_1p_true_spurious_conversion_tracks_pt", n_pt, min_pt, max_pt);
  h_1p_true_spurious_conversion_tracks_pt_passfilter = new TH1F("h_1p_true_spurious_conversion_tracks_pt_passfilter", "h_1p_true_spurious_conversion_tracks_pt_passfilter", n_pt, min_pt, max_pt);
  h_3p_true_spurious_conversion_tracks_pt = new TH1F("h_3p_true_spurious_conversion_tracks_pt", "h_3p_true_spurious_conversion_tracks_pt", n_pt, min_pt, max_pt);
  h_3p_true_spurious_conversion_tracks_pt_passfilter = new TH1F("h_3p_true_spurious_conversion_tracks_pt_passfilter", "h_3p_true_spurious_conversion_tracks_pt_passfilter", n_pt, min_pt, max_pt);

  h_1p_true_taus_pt        = new TH1F("h_1p_true_taus_pt", "h_1p_true_taus_pt", n_pt, min_pt, max_pt);
  h_1p_true_taus_pt_reco1p = new TH1F("h_1p_true_taus_pt_reco1p", "h_1p_true_taus_pt_reco1p", n_pt, min_pt, max_pt);
  h_3p_true_taus_pt        = new TH1F("h_3p_true_taus_pt", "h_3p_true_taus_pt", n_pt, min_pt, max_pt);
  h_3p_true_taus_pt_reco3p = new TH1F("h_3p_true_taus_pt_reco3p", "h_3p_true_taus_pt_reco3p", n_pt, min_pt, max_pt);

  h_1p_true_taus_pt_filter1p = new TH1F("h_1p_true_taus_pt_filter1p", "h_1p_true_taus_pt_filter1p", n_pt, min_pt, max_pt);
  h_3p_true_taus_pt_filter3p = new TH1F("h_3p_true_taus_pt_filter3p", "h_3p_true_taus_pt_filter3p", n_pt, min_pt, max_pt);

  wk()->addOutput (h_1p_true_pion_tracks_pt);
  wk()->addOutput (h_1p_true_pion_tracks_pt_passfilter);
  wk()->addOutput (h_3p_true_pion_tracks_pt);
  wk()->addOutput (h_3p_true_pion_tracks_pt_passfilter);

  wk()->addOutput (h_1p_true_spurious_tracks_pt);
  wk()->addOutput (h_1p_true_spurious_tracks_pt_passfilter);
  wk()->addOutput (h_3p_true_spurious_tracks_pt);
  wk()->addOutput (h_3p_true_spurious_tracks_pt_passfilter);

  wk()->addOutput (h_1p_true_spurious_conversion_tracks_pt);
  wk()->addOutput (h_1p_true_spurious_conversion_tracks_pt_passfilter);
  wk()->addOutput (h_3p_true_spurious_conversion_tracks_pt);
  wk()->addOutput (h_3p_true_spurious_conversion_tracks_pt_passfilter);

  wk()->addOutput (h_1p_true_taus_pt);
  wk()->addOutput (h_1p_true_taus_pt_reco1p);
  wk()->addOutput (h_1p_true_taus_pt_filter1p);
  wk()->addOutput (h_3p_true_taus_pt);
  wk()->addOutput (h_3p_true_taus_pt_reco3p);
  wk()->addOutput (h_3p_true_taus_pt_filter3p);

  n_1p_true_pion_tracks  =  0;
  n_1p_true_pion_tracks_passfilter = 0;
  n_1p_true_spurious_tracks = 0;
  n_1p_true_spurious_tracks_passfilter = 0;
  n_1p_true_spurious_conversion_tracks = 0;
  n_1p_true_spurious_conversion_tracks_passfilter = 0;


  n_3p_true_pion_tracks  =  0;
  n_3p_true_pion_tracks_passfilter = 0;
  n_3p_true_spurious_tracks = 0;
  n_3p_true_spurious_tracks_passfilter = 0;
  n_3p_true_spurious_conversion_tracks = 0;
  n_3p_true_spurious_conversion_tracks_passfilter = 0;

  n_1p_true_spurious_not_hadronic_tracks = 0;
  n_3p_true_spurious_not_hadronic_tracks = 0;
  n_1p_true_spurious_not_hadronic_tracks_passfilter =0 ;
  n_3p_true_spurious_not_hadronic_tracks_passfilter =0 ;

  n_3p_true_true_taus = 0;
  n_3p_true_true_taus_reco0p = 0;
  n_3p_true_true_taus_reco1p = 0;
  n_3p_true_true_taus_reco2p = 0;
  n_3p_true_true_taus_reco3p = 0;
  n_3p_true_true_taus_recoNp = 0;
  n_1p_true_true_taus = 0;
  n_1p_true_true_taus_reco0p = 0;
  n_1p_true_true_taus_reco1p = 0;
  n_1p_true_true_taus_reco2p = 0;
  n_1p_true_true_taus_reco3p = 0;
  n_1p_true_true_taus_recoNp = 0;
  ///////////////////////////////
  n_3p_true_true_taus_loose = 0;
  n_3p_true_true_taus_reco0p_loose = 0;
  n_3p_true_true_taus_reco1p_loose = 0;
  n_3p_true_true_taus_reco2p_loose = 0;
  n_3p_true_true_taus_reco3p_loose = 0;
  n_3p_true_true_taus_recoNp_loose = 0;
  n_1p_true_true_taus_loose = 0;
  n_1p_true_true_taus_reco0p_loose = 0;
  n_1p_true_true_taus_reco1p_loose = 0;
  n_1p_true_true_taus_reco2p_loose = 0;
  n_1p_true_true_taus_reco3p_loose = 0;
  n_1p_true_true_taus_recoNp_loose = 0;
  ////////////////////////////////
  n_3p_true_true_taus_medium = 0;
  n_3p_true_true_taus_reco0p_medium = 0;
  n_3p_true_true_taus_reco1p_medium = 0;
  n_3p_true_true_taus_reco2p_medium = 0;
  n_3p_true_true_taus_reco3p_medium = 0;
  n_3p_true_true_taus_recoNp_medium = 0;
  n_1p_true_true_taus_medium = 0;
  n_1p_true_true_taus_reco0p_medium = 0;
  n_1p_true_true_taus_reco1p_medium = 0;
  n_1p_true_true_taus_reco2p_medium = 0;
  n_1p_true_true_taus_reco3p_medium = 0;
  n_1p_true_true_taus_recoNp_medium = 0;
  ///////////////////////////////
  n_3p_true_true_taus_tight = 0;
  n_3p_true_true_taus_reco0p_tight = 0;
  n_3p_true_true_taus_reco1p_tight = 0;
  n_3p_true_true_taus_reco2p_tight = 0;
  n_3p_true_true_taus_reco3p_tight = 0;
  n_3p_true_true_taus_recoNp_tight = 0;
  n_1p_true_true_taus_tight = 0;
  n_1p_true_true_taus_reco0p_tight = 0;
  n_1p_true_true_taus_reco1p_tight = 0;
  n_1p_true_true_taus_reco2p_tight = 0;
  n_1p_true_true_taus_reco3p_tight = 0;
  n_1p_true_true_taus_recoNp_tight = 0;
  /////////////////////////////////

  n_1p_true_true_taus_filter1p = 0;
  n_3p_true_true_taus_filter3p = 0;

  n_1p_all_tracks=0;
  n_3p_all_tracks=0;

  n_1p_true_true_taus_trackFilterProngs_0 = 0;
  n_1p_true_true_taus_trackFilterProngs_1 = 0;
  n_1p_true_true_taus_trackFilterProngs_2 = 0;
  n_1p_true_true_taus_trackFilterProngs_3 = 0;
  n_1p_true_true_taus_trackFilterProngs_4 = 0;

  n_3p_true_true_taus_trackFilterProngs_3 = 0;
  n_3p_true_true_taus_trackFilterProngs_0 = 0;
  n_3p_true_true_taus_trackFilterProngs_1 = 0;
  n_3p_true_true_taus_trackFilterProngs_2 = 0;
  n_3p_true_true_taus_trackFilterProngs_4 = 0;


  n_1p_migr_1t_0ft =0;    n_3p_migr_1t_0ft =0;
  n_1p_migr_1t_1ft =0;	  n_3p_migr_1t_1ft =0;
  n_1p_migr_2t_0ft =0;	  n_3p_migr_2t_0ft =0;
  n_1p_migr_2t_1ft =0;	  n_3p_migr_2t_1ft =0;
  n_1p_migr_2t_2ft =0;	  n_3p_migr_2t_2ft =0;
  n_1p_migr_3t_0ft =0;	  n_3p_migr_3t_0ft =0;
  n_1p_migr_3t_1ft =0;	  n_3p_migr_3t_1ft =0;
  n_1p_migr_3t_2ft =0;	  n_3p_migr_3t_2ft =0;
  n_1p_migr_3t_3ft =0;	  n_3p_migr_3t_3ft =0;
  n_1p_migr_Nt_0ft =0;	  n_3p_migr_Nt_0ft =0;
  n_1p_migr_Nt_1ft =0;	  n_3p_migr_Nt_1ft =0;
  n_1p_migr_Nt_2ft =0;	  n_3p_migr_Nt_2ft =0;
  n_1p_migr_Nt_3ft =0;	  n_3p_migr_Nt_3ft =0;
  n_1p_migr_Nt_Nft =0;	  n_3p_migr_Nt_Nft =0;
  /////////////////////////////////////
  n_1p_migr_1t_0ft_loose =0;  n_3p_migr_1t_0ft_loose =0;     n_1p_migr_1t_0ft_medium =0;  n_3p_migr_1t_0ft_medium =0;
  n_1p_migr_1t_1ft_loose =0;  n_3p_migr_1t_1ft_loose =0;     n_1p_migr_1t_1ft_medium =0;  n_3p_migr_1t_1ft_medium =0;
  n_1p_migr_2t_0ft_loose =0;  n_3p_migr_2t_0ft_loose =0;     n_1p_migr_2t_0ft_medium =0;  n_3p_migr_2t_0ft_medium =0;
  n_1p_migr_2t_1ft_loose =0;  n_3p_migr_2t_1ft_loose =0;     n_1p_migr_2t_1ft_medium =0;  n_3p_migr_2t_1ft_medium =0;
  n_1p_migr_2t_2ft_loose =0;  n_3p_migr_2t_2ft_loose =0;     n_1p_migr_2t_2ft_medium =0;  n_3p_migr_2t_2ft_medium =0;
  n_1p_migr_3t_0ft_loose =0;  n_3p_migr_3t_0ft_loose =0;     n_1p_migr_3t_0ft_medium =0;  n_3p_migr_3t_0ft_medium =0;
  n_1p_migr_3t_1ft_loose =0;  n_3p_migr_3t_1ft_loose =0;     n_1p_migr_3t_1ft_medium =0;  n_3p_migr_3t_1ft_medium =0;
  n_1p_migr_3t_2ft_loose =0;  n_3p_migr_3t_2ft_loose =0;     n_1p_migr_3t_2ft_medium =0;  n_3p_migr_3t_2ft_medium =0;
  n_1p_migr_3t_3ft_loose =0;  n_3p_migr_3t_3ft_loose =0;     n_1p_migr_3t_3ft_medium =0;  n_3p_migr_3t_3ft_medium =0;
  n_1p_migr_Nt_0ft_loose =0;  n_3p_migr_Nt_0ft_loose =0;     n_1p_migr_Nt_0ft_medium =0;  n_3p_migr_Nt_0ft_medium =0;
  n_1p_migr_Nt_1ft_loose =0;  n_3p_migr_Nt_1ft_loose =0;     n_1p_migr_Nt_1ft_medium =0;  n_3p_migr_Nt_1ft_medium =0;
  n_1p_migr_Nt_2ft_loose =0;  n_3p_migr_Nt_2ft_loose =0;     n_1p_migr_Nt_2ft_medium =0;  n_3p_migr_Nt_2ft_medium =0;
  n_1p_migr_Nt_3ft_loose =0;  n_3p_migr_Nt_3ft_loose =0;     n_1p_migr_Nt_3ft_medium =0;  n_3p_migr_Nt_3ft_medium =0;
  n_1p_migr_Nt_Nft_loose =0;  n_3p_migr_Nt_Nft_loose =0;     n_1p_migr_Nt_Nft_medium =0;  n_3p_migr_Nt_Nft_medium =0;

   n_1p_migr_1t_0ft_tight =0;  n_3p_migr_1t_0ft_tight =0;
   n_1p_migr_1t_1ft_tight =0;  n_3p_migr_1t_1ft_tight =0;
   n_1p_migr_2t_0ft_tight =0;  n_3p_migr_2t_0ft_tight =0;
   n_1p_migr_2t_1ft_tight =0;  n_3p_migr_2t_1ft_tight =0;
   n_1p_migr_2t_2ft_tight =0;  n_3p_migr_2t_2ft_tight =0;
   n_1p_migr_3t_0ft_tight =0;  n_3p_migr_3t_0ft_tight =0;
   n_1p_migr_3t_1ft_tight =0;  n_3p_migr_3t_1ft_tight =0;
   n_1p_migr_3t_2ft_tight =0;  n_3p_migr_3t_2ft_tight =0;
   n_1p_migr_3t_3ft_tight =0;  n_3p_migr_3t_3ft_tight =0;
   n_1p_migr_Nt_0ft_tight =0;  n_3p_migr_Nt_0ft_tight =0;
   n_1p_migr_Nt_1ft_tight =0;  n_3p_migr_Nt_1ft_tight =0;
   n_1p_migr_Nt_2ft_tight =0;  n_3p_migr_Nt_2ft_tight =0;
   n_1p_migr_Nt_3ft_tight =0;  n_3p_migr_Nt_3ft_tight =0;
   n_1p_migr_Nt_Nft_tight =0;  n_3p_migr_Nt_Nft_tight =0;

  /////////////////////////////////////



  /////////////////////////////////////
  n_1p_migr_1t_0ft_tq[0] = 0;     n_3p_migr_1t_0ft_tq[0] = 0;
  n_1p_migr_1t_0ft_tq[1] = 0;	  n_3p_migr_1t_0ft_tq[1] = 0;
  n_1p_migr_1t_0ft_tq[2] = 0;	  n_3p_migr_1t_0ft_tq[2] = 0;
  n_1p_migr_1t_1ft_tq[0] = 0;     n_3p_migr_1t_1ft_tq[0] = 0;
  n_1p_migr_1t_1ft_tq[1] = 0;	  n_3p_migr_1t_1ft_tq[1] = 0;
  n_1p_migr_1t_1ft_tq[2] = 0;	  n_3p_migr_1t_1ft_tq[2] = 0;		
	       			     
  n_1p_migr_2t_0ft_tq[0] = 0;	  n_3p_migr_2t_0ft_tq[0] = 0;
  n_1p_migr_2t_0ft_tq[1] = 0;	  n_3p_migr_2t_0ft_tq[1] = 0;
  n_1p_migr_2t_0ft_tq[2] = 0;	  n_3p_migr_2t_0ft_tq[2] = 0;
  n_1p_migr_2t_1ft_tq[0] = 0;	  n_3p_migr_2t_1ft_tq[0] = 0;
  n_1p_migr_2t_1ft_tq[1] = 0;	  n_3p_migr_2t_1ft_tq[1] = 0;
  n_1p_migr_2t_1ft_tq[2] = 0;	  n_3p_migr_2t_1ft_tq[2] = 0;
  n_1p_migr_2t_2ft_tq[0] = 0;	  n_3p_migr_2t_2ft_tq[0] = 0;
  n_1p_migr_2t_2ft_tq[1] = 0;	  n_3p_migr_2t_2ft_tq[1] = 0;
  n_1p_migr_2t_2ft_tq[2] = 0;	  n_3p_migr_2t_2ft_tq[2] = 0;
							     
  n_1p_migr_3t_0ft_tq[0] = 0;	  n_3p_migr_3t_0ft_tq[0] = 0;
  n_1p_migr_3t_0ft_tq[1] = 0;	  n_3p_migr_3t_0ft_tq[1] = 0;
  n_1p_migr_3t_0ft_tq[2] = 0;	  n_3p_migr_3t_0ft_tq[2] = 0;
  n_1p_migr_3t_0ft_tq[3] = 0;	  n_3p_migr_3t_0ft_tq[3] = 0;
							     
  n_1p_migr_3t_1ft_tq[0] = 0;	  n_3p_migr_3t_1ft_tq[0] = 0;
  n_1p_migr_3t_1ft_tq[1] = 0;	  n_3p_migr_3t_1ft_tq[1] = 0;
  n_1p_migr_3t_1ft_tq[2] = 0;	  n_3p_migr_3t_1ft_tq[2] = 0;
  n_1p_migr_3t_1ft_tq[3] = 0;	  n_3p_migr_3t_1ft_tq[3] = 0;
							     
  n_1p_migr_3t_2ft_tq[0] = 0;	  n_3p_migr_3t_2ft_tq[0] = 0;
  n_1p_migr_3t_2ft_tq[1] = 0;	  n_3p_migr_3t_2ft_tq[1] = 0;
  n_1p_migr_3t_2ft_tq[2] = 0;	  n_3p_migr_3t_2ft_tq[2] = 0;
  n_1p_migr_3t_2ft_tq[3] = 0;	  n_3p_migr_3t_2ft_tq[3] = 0;
							     
  n_1p_migr_3t_3ft_tq[0] = 0;	  n_3p_migr_3t_3ft_tq[0] = 0;
  n_1p_migr_3t_3ft_tq[1] = 0;	  n_3p_migr_3t_3ft_tq[1] = 0;
  n_1p_migr_3t_3ft_tq[2] = 0;	  n_3p_migr_3t_3ft_tq[2] = 0;
  n_1p_migr_3t_3ft_tq[3] = 0;	  n_3p_migr_3t_3ft_tq[3] = 0;
  ///////////////////////////////////////////////////////
  n_1p_migr_1t_0ft_tq_loose[0] = 0;  n_3p_migr_1t_0ft_tq_loose[0] = 0;
  n_1p_migr_1t_0ft_tq_loose[1] = 0;  n_3p_migr_1t_0ft_tq_loose[1] = 0;
  n_1p_migr_1t_0ft_tq_loose[2] = 0;  n_3p_migr_1t_0ft_tq_loose[2] = 0;
  n_1p_migr_1t_1ft_tq_loose[0] = 0;  n_3p_migr_1t_1ft_tq_loose[0] = 0;
  n_1p_migr_1t_1ft_tq_loose[1] = 0;  n_3p_migr_1t_1ft_tq_loose[1] = 0;
  n_1p_migr_1t_1ft_tq_loose[2] = 0;  n_3p_migr_1t_1ft_tq_loose[2] = 0;		
	       			     				   
  n_1p_migr_2t_0ft_tq_loose[0] = 0;  n_3p_migr_2t_0ft_tq_loose[0] = 0;
  n_1p_migr_2t_0ft_tq_loose[1] = 0;  n_3p_migr_2t_0ft_tq_loose[1] = 0;
  n_1p_migr_2t_0ft_tq_loose[2] = 0;  n_3p_migr_2t_0ft_tq_loose[2] = 0;
  n_1p_migr_2t_1ft_tq_loose[0] = 0;  n_3p_migr_2t_1ft_tq_loose[0] = 0;
  n_1p_migr_2t_1ft_tq_loose[1] = 0;  n_3p_migr_2t_1ft_tq_loose[1] = 0;
  n_1p_migr_2t_1ft_tq_loose[2] = 0;  n_3p_migr_2t_1ft_tq_loose[2] = 0;
  n_1p_migr_2t_2ft_tq_loose[0] = 0;  n_3p_migr_2t_2ft_tq_loose[0] = 0;
  n_1p_migr_2t_2ft_tq_loose[1] = 0;  n_3p_migr_2t_2ft_tq_loose[1] = 0;
  n_1p_migr_2t_2ft_tq_loose[2] = 0;  n_3p_migr_2t_2ft_tq_loose[2] = 0;
								        
  n_1p_migr_3t_0ft_tq_loose[0] = 0;  n_3p_migr_3t_0ft_tq_loose[0] = 0;
  n_1p_migr_3t_0ft_tq_loose[1] = 0;  n_3p_migr_3t_0ft_tq_loose[1] = 0;
  n_1p_migr_3t_0ft_tq_loose[2] = 0;  n_3p_migr_3t_0ft_tq_loose[2] = 0;
  n_1p_migr_3t_0ft_tq_loose[3] = 0;  n_3p_migr_3t_0ft_tq_loose[3] = 0;
								        
  n_1p_migr_3t_1ft_tq_loose[0] = 0;  n_3p_migr_3t_1ft_tq_loose[0] = 0;
  n_1p_migr_3t_1ft_tq_loose[1] = 0;  n_3p_migr_3t_1ft_tq_loose[1] = 0;
  n_1p_migr_3t_1ft_tq_loose[2] = 0;  n_3p_migr_3t_1ft_tq_loose[2] = 0;
  n_1p_migr_3t_1ft_tq_loose[3] = 0;  n_3p_migr_3t_1ft_tq_loose[3] = 0;
								        
  n_1p_migr_3t_2ft_tq_loose[0] = 0;  n_3p_migr_3t_2ft_tq_loose[0] = 0;
  n_1p_migr_3t_2ft_tq_loose[1] = 0;  n_3p_migr_3t_2ft_tq_loose[1] = 0;
  n_1p_migr_3t_2ft_tq_loose[2] = 0;  n_3p_migr_3t_2ft_tq_loose[2] = 0;
  n_1p_migr_3t_2ft_tq_loose[3] = 0;  n_3p_migr_3t_2ft_tq_loose[3] = 0;
								        
  n_1p_migr_3t_3ft_tq_loose[0] = 0;  n_3p_migr_3t_3ft_tq_loose[0] = 0;
  n_1p_migr_3t_3ft_tq_loose[1] = 0;  n_3p_migr_3t_3ft_tq_loose[1] = 0;
  n_1p_migr_3t_3ft_tq_loose[2] = 0;  n_3p_migr_3t_3ft_tq_loose[2] = 0;
  n_1p_migr_3t_3ft_tq_loose[3] = 0;  n_3p_migr_3t_3ft_tq_loose[3] = 0;
  ///////////////////////////////////////////////////////
  n_1p_migr_1t_0ft_tq_medium[0] = 0;  n_3p_migr_1t_0ft_tq_medium[0] = 0;
  n_1p_migr_1t_0ft_tq_medium[1] = 0;  n_3p_migr_1t_0ft_tq_medium[1] = 0;
  n_1p_migr_1t_0ft_tq_medium[2] = 0;  n_3p_migr_1t_0ft_tq_medium[2] = 0;
  n_1p_migr_1t_1ft_tq_medium[0] = 0;  n_3p_migr_1t_1ft_tq_medium[0] = 0;
  n_1p_migr_1t_1ft_tq_medium[1] = 0;  n_3p_migr_1t_1ft_tq_medium[1] = 0;
  n_1p_migr_1t_1ft_tq_medium[2] = 0;  n_3p_migr_1t_1ft_tq_medium[2] = 0;		
	       			     				   
  n_1p_migr_2t_0ft_tq_medium[0] = 0;  n_3p_migr_2t_0ft_tq_medium[0] = 0;
  n_1p_migr_2t_0ft_tq_medium[1] = 0;  n_3p_migr_2t_0ft_tq_medium[1] = 0;
  n_1p_migr_2t_0ft_tq_medium[2] = 0;  n_3p_migr_2t_0ft_tq_medium[2] = 0;
  n_1p_migr_2t_1ft_tq_medium[0] = 0;  n_3p_migr_2t_1ft_tq_medium[0] = 0;
  n_1p_migr_2t_1ft_tq_medium[1] = 0;  n_3p_migr_2t_1ft_tq_medium[1] = 0;
  n_1p_migr_2t_1ft_tq_medium[2] = 0;  n_3p_migr_2t_1ft_tq_medium[2] = 0;
  n_1p_migr_2t_2ft_tq_medium[0] = 0;  n_3p_migr_2t_2ft_tq_medium[0] = 0;
  n_1p_migr_2t_2ft_tq_medium[1] = 0;  n_3p_migr_2t_2ft_tq_medium[1] = 0;
  n_1p_migr_2t_2ft_tq_medium[2] = 0;  n_3p_migr_2t_2ft_tq_medium[2] = 0;
								        
  n_1p_migr_3t_0ft_tq_medium[0] = 0;  n_3p_migr_3t_0ft_tq_medium[0] = 0;
  n_1p_migr_3t_0ft_tq_medium[1] = 0;  n_3p_migr_3t_0ft_tq_medium[1] = 0;
  n_1p_migr_3t_0ft_tq_medium[2] = 0;  n_3p_migr_3t_0ft_tq_medium[2] = 0;
  n_1p_migr_3t_0ft_tq_medium[3] = 0;  n_3p_migr_3t_0ft_tq_medium[3] = 0;
								        
  n_1p_migr_3t_1ft_tq_medium[0] = 0;  n_3p_migr_3t_1ft_tq_medium[0] = 0;
  n_1p_migr_3t_1ft_tq_medium[1] = 0;  n_3p_migr_3t_1ft_tq_medium[1] = 0;
  n_1p_migr_3t_1ft_tq_medium[2] = 0;  n_3p_migr_3t_1ft_tq_medium[2] = 0;
  n_1p_migr_3t_1ft_tq_medium[3] = 0;  n_3p_migr_3t_1ft_tq_medium[3] = 0;
								        
  n_1p_migr_3t_2ft_tq_medium[0] = 0;  n_3p_migr_3t_2ft_tq_medium[0] = 0;
  n_1p_migr_3t_2ft_tq_medium[1] = 0;  n_3p_migr_3t_2ft_tq_medium[1] = 0;
  n_1p_migr_3t_2ft_tq_medium[2] = 0;  n_3p_migr_3t_2ft_tq_medium[2] = 0;
  n_1p_migr_3t_2ft_tq_medium[3] = 0;  n_3p_migr_3t_2ft_tq_medium[3] = 0;
								        
  n_1p_migr_3t_3ft_tq_medium[0] = 0;  n_3p_migr_3t_3ft_tq_medium[0] = 0;
  n_1p_migr_3t_3ft_tq_medium[1] = 0;  n_3p_migr_3t_3ft_tq_medium[1] = 0;
  n_1p_migr_3t_3ft_tq_medium[2] = 0;  n_3p_migr_3t_3ft_tq_medium[2] = 0;
  n_1p_migr_3t_3ft_tq_medium[3] = 0;  n_3p_migr_3t_3ft_tq_medium[3] = 0;
  ///////////////////////////////////////////////////////
  n_1p_migr_1t_0ft_tq_tight[0] = 0;  n_3p_migr_1t_0ft_tq_tight[0] = 0;
  n_1p_migr_1t_0ft_tq_tight[1] = 0;  n_3p_migr_1t_0ft_tq_tight[1] = 0;
  n_1p_migr_1t_0ft_tq_tight[2] = 0;  n_3p_migr_1t_0ft_tq_tight[2] = 0;
  n_1p_migr_1t_1ft_tq_tight[0] = 0;  n_3p_migr_1t_1ft_tq_tight[0] = 0;
  n_1p_migr_1t_1ft_tq_tight[1] = 0;  n_3p_migr_1t_1ft_tq_tight[1] = 0;
  n_1p_migr_1t_1ft_tq_tight[2] = 0;  n_3p_migr_1t_1ft_tq_tight[2] = 0;		
	       			     				   
  n_1p_migr_2t_0ft_tq_tight[0] = 0;  n_3p_migr_2t_0ft_tq_tight[0] = 0;
  n_1p_migr_2t_0ft_tq_tight[1] = 0;  n_3p_migr_2t_0ft_tq_tight[1] = 0;
  n_1p_migr_2t_0ft_tq_tight[2] = 0;  n_3p_migr_2t_0ft_tq_tight[2] = 0;
  n_1p_migr_2t_1ft_tq_tight[0] = 0;  n_3p_migr_2t_1ft_tq_tight[0] = 0;
  n_1p_migr_2t_1ft_tq_tight[1] = 0;  n_3p_migr_2t_1ft_tq_tight[1] = 0;
  n_1p_migr_2t_1ft_tq_tight[2] = 0;  n_3p_migr_2t_1ft_tq_tight[2] = 0;
  n_1p_migr_2t_2ft_tq_tight[0] = 0;  n_3p_migr_2t_2ft_tq_tight[0] = 0;
  n_1p_migr_2t_2ft_tq_tight[1] = 0;  n_3p_migr_2t_2ft_tq_tight[1] = 0;
  n_1p_migr_2t_2ft_tq_tight[2] = 0;  n_3p_migr_2t_2ft_tq_tight[2] = 0;
								        
  n_1p_migr_3t_0ft_tq_tight[0] = 0;  n_3p_migr_3t_0ft_tq_tight[0] = 0;
  n_1p_migr_3t_0ft_tq_tight[1] = 0;  n_3p_migr_3t_0ft_tq_tight[1] = 0;
  n_1p_migr_3t_0ft_tq_tight[2] = 0;  n_3p_migr_3t_0ft_tq_tight[2] = 0;
  n_1p_migr_3t_0ft_tq_tight[3] = 0;  n_3p_migr_3t_0ft_tq_tight[3] = 0;
								        
  n_1p_migr_3t_1ft_tq_tight[0] = 0;  n_3p_migr_3t_1ft_tq_tight[0] = 0;
  n_1p_migr_3t_1ft_tq_tight[1] = 0;  n_3p_migr_3t_1ft_tq_tight[1] = 0;
  n_1p_migr_3t_1ft_tq_tight[2] = 0;  n_3p_migr_3t_1ft_tq_tight[2] = 0;
  n_1p_migr_3t_1ft_tq_tight[3] = 0;  n_3p_migr_3t_1ft_tq_tight[3] = 0;
								        
  n_1p_migr_3t_2ft_tq_tight[0] = 0;  n_3p_migr_3t_2ft_tq_tight[0] = 0;
  n_1p_migr_3t_2ft_tq_tight[1] = 0;  n_3p_migr_3t_2ft_tq_tight[1] = 0;
  n_1p_migr_3t_2ft_tq_tight[2] = 0;  n_3p_migr_3t_2ft_tq_tight[2] = 0;
  n_1p_migr_3t_2ft_tq_tight[3] = 0;  n_3p_migr_3t_2ft_tq_tight[3] = 0;
								        
  n_1p_migr_3t_3ft_tq_tight[0] = 0;  n_3p_migr_3t_3ft_tq_tight[0] = 0;
  n_1p_migr_3t_3ft_tq_tight[1] = 0;  n_3p_migr_3t_3ft_tq_tight[1] = 0;
  n_1p_migr_3t_3ft_tq_tight[2] = 0;  n_3p_migr_3t_3ft_tq_tight[2] = 0;
  n_1p_migr_3t_3ft_tq_tight[3] = 0;  n_3p_migr_3t_3ft_tq_tight[3] = 0;
  ///////////////////////////////////////////////////////

  for (int i=0; i <= 2; ++i) {
    for (int j=0; j<=1; ++j) {
      n_1p_migr_1t_1ft_tq_[i][j] = 0;
      n_1p_migr_1t_1ft_tq_loose_[i][j] = 0;
      n_1p_migr_1t_1ft_tq_medium_[i][j] = 0;
      n_1p_migr_1t_1ft_tq_tight_[i][j] = 0;
    }
  }
  ///////////////////////////////////////////////////////
  n_1p_migr_Nt_0ft_tq[0] = 0;  n_3p_migr_Nt_0ft_tq[0] = 0;
  n_1p_migr_Nt_0ft_tq[1] = 0;  n_3p_migr_Nt_0ft_tq[1] = 0;
  n_1p_migr_Nt_0ft_tq[2] = 0;  n_3p_migr_Nt_0ft_tq[2] = 0;
  n_1p_migr_Nt_0ft_tq[3] = 0;  n_3p_migr_Nt_0ft_tq[3] = 0;
  n_1p_migr_Nt_0ft_tq[4] = 0;  n_3p_migr_Nt_0ft_tq[4] = 0;

  n_1p_migr_Nt_1ft_tq[0] = 0;  n_3p_migr_Nt_1ft_tq[0] = 0;
  n_1p_migr_Nt_1ft_tq[1] = 0;  n_3p_migr_Nt_1ft_tq[1] = 0;
  n_1p_migr_Nt_1ft_tq[2] = 0;  n_3p_migr_Nt_1ft_tq[2] = 0;
  n_1p_migr_Nt_1ft_tq[3] = 0;  n_3p_migr_Nt_1ft_tq[3] = 0;
  n_1p_migr_Nt_1ft_tq[4] = 0;  n_3p_migr_Nt_1ft_tq[4] = 0;
	     
  n_1p_migr_Nt_2ft_tq[0] = 0;  n_3p_migr_Nt_2ft_tq[0] = 0;
  n_1p_migr_Nt_2ft_tq[1] = 0;  n_3p_migr_Nt_2ft_tq[1] = 0;
  n_1p_migr_Nt_2ft_tq[2] = 0;  n_3p_migr_Nt_2ft_tq[2] = 0;
  n_1p_migr_Nt_2ft_tq[3] = 0;  n_3p_migr_Nt_2ft_tq[3] = 0;
  n_1p_migr_Nt_2ft_tq[4] = 0;  n_3p_migr_Nt_2ft_tq[4] = 0;
			     
  n_1p_migr_Nt_3ft_tq[0] = 0;  n_3p_migr_Nt_3ft_tq[0] = 0;
  n_1p_migr_Nt_3ft_tq[1] = 0;  n_3p_migr_Nt_3ft_tq[1] = 0;
  n_1p_migr_Nt_3ft_tq[2] = 0;  n_3p_migr_Nt_3ft_tq[2] = 0;
  n_1p_migr_Nt_3ft_tq[3] = 0;  n_3p_migr_Nt_3ft_tq[3] = 0;
  n_1p_migr_Nt_3ft_tq[4] = 0;  n_3p_migr_Nt_3ft_tq[4] = 0;

  n_1p_migr_Nt_Nft_tq[0] = 0;  n_3p_migr_Nt_Nft_tq[0] = 0;
  n_1p_migr_Nt_Nft_tq[1] = 0;  n_3p_migr_Nt_Nft_tq[1] = 0;
  n_1p_migr_Nt_Nft_tq[2] = 0;  n_3p_migr_Nt_Nft_tq[2] = 0;
  n_1p_migr_Nt_Nft_tq[3] = 0;  n_3p_migr_Nt_Nft_tq[3] = 0;
  n_1p_migr_Nt_Nft_tq[4] = 0;  n_3p_migr_Nt_Nft_tq[4] = 0;
  ///////////////////////////////////////////////////////
  n_1p_migr_Nt_0ft_tq_loose[0] = 0;  n_3p_migr_Nt_0ft_tq_loose[0] = 0;
  n_1p_migr_Nt_0ft_tq_loose[1] = 0;  n_3p_migr_Nt_0ft_tq_loose[1] = 0;
  n_1p_migr_Nt_0ft_tq_loose[2] = 0;  n_3p_migr_Nt_0ft_tq_loose[2] = 0;
  n_1p_migr_Nt_0ft_tq_loose[3] = 0;  n_3p_migr_Nt_0ft_tq_loose[3] = 0;
  n_1p_migr_Nt_0ft_tq_loose[4] = 0;  n_3p_migr_Nt_0ft_tq_loose[4] = 0;
							      
  n_1p_migr_Nt_1ft_tq_loose[0] = 0;  n_3p_migr_Nt_1ft_tq_loose[0] = 0;
  n_1p_migr_Nt_1ft_tq_loose[1] = 0;  n_3p_migr_Nt_1ft_tq_loose[1] = 0;
  n_1p_migr_Nt_1ft_tq_loose[2] = 0;  n_3p_migr_Nt_1ft_tq_loose[2] = 0;
  n_1p_migr_Nt_1ft_tq_loose[3] = 0;  n_3p_migr_Nt_1ft_tq_loose[3] = 0;
  n_1p_migr_Nt_1ft_tq_loose[4] = 0;  n_3p_migr_Nt_1ft_tq_loose[4] = 0;
	     						      
  n_1p_migr_Nt_2ft_tq_loose[0] = 0;  n_3p_migr_Nt_2ft_tq_loose[0] = 0;
  n_1p_migr_Nt_2ft_tq_loose[1] = 0;  n_3p_migr_Nt_2ft_tq_loose[1] = 0;
  n_1p_migr_Nt_2ft_tq_loose[2] = 0;  n_3p_migr_Nt_2ft_tq_loose[2] = 0;
  n_1p_migr_Nt_2ft_tq_loose[3] = 0;  n_3p_migr_Nt_2ft_tq_loose[3] = 0;
  n_1p_migr_Nt_2ft_tq_loose[4] = 0;  n_3p_migr_Nt_2ft_tq_loose[4] = 0;
			     					   
  n_1p_migr_Nt_3ft_tq_loose[0] = 0;  n_3p_migr_Nt_3ft_tq_loose[0] = 0;
  n_1p_migr_Nt_3ft_tq_loose[1] = 0;  n_3p_migr_Nt_3ft_tq_loose[1] = 0;
  n_1p_migr_Nt_3ft_tq_loose[2] = 0;  n_3p_migr_Nt_3ft_tq_loose[2] = 0;
  n_1p_migr_Nt_3ft_tq_loose[3] = 0;  n_3p_migr_Nt_3ft_tq_loose[3] = 0;
  n_1p_migr_Nt_3ft_tq_loose[4] = 0;  n_3p_migr_Nt_3ft_tq_loose[4] = 0;
							      
  n_1p_migr_Nt_Nft_tq_loose[0] = 0;  n_3p_migr_Nt_Nft_tq_loose[0] = 0;
  n_1p_migr_Nt_Nft_tq_loose[1] = 0;  n_3p_migr_Nt_Nft_tq_loose[1] = 0;
  n_1p_migr_Nt_Nft_tq_loose[2] = 0;  n_3p_migr_Nt_Nft_tq_loose[2] = 0;
  n_1p_migr_Nt_Nft_tq_loose[3] = 0;  n_3p_migr_Nt_Nft_tq_loose[3] = 0;
  n_1p_migr_Nt_Nft_tq_loose[4] = 0;  n_3p_migr_Nt_Nft_tq_loose[4] = 0;
  ///////////////////////////////////////////////////////
  n_1p_migr_Nt_0ft_tq_medium[0] = 0;  n_3p_migr_Nt_0ft_tq_medium[0] = 0;
  n_1p_migr_Nt_0ft_tq_medium[1] = 0;  n_3p_migr_Nt_0ft_tq_medium[1] = 0;
  n_1p_migr_Nt_0ft_tq_medium[2] = 0;  n_3p_migr_Nt_0ft_tq_medium[2] = 0;
  n_1p_migr_Nt_0ft_tq_medium[3] = 0;  n_3p_migr_Nt_0ft_tq_medium[3] = 0;
  n_1p_migr_Nt_0ft_tq_medium[4] = 0;  n_3p_migr_Nt_0ft_tq_medium[4] = 0;
							      
  n_1p_migr_Nt_1ft_tq_medium[0] = 0;  n_3p_migr_Nt_1ft_tq_medium[0] = 0;
  n_1p_migr_Nt_1ft_tq_medium[1] = 0;  n_3p_migr_Nt_1ft_tq_medium[1] = 0;
  n_1p_migr_Nt_1ft_tq_medium[2] = 0;  n_3p_migr_Nt_1ft_tq_medium[2] = 0;
  n_1p_migr_Nt_1ft_tq_medium[3] = 0;  n_3p_migr_Nt_1ft_tq_medium[3] = 0;
  n_1p_migr_Nt_1ft_tq_medium[4] = 0;  n_3p_migr_Nt_1ft_tq_medium[4] = 0;
	     						      
  n_1p_migr_Nt_2ft_tq_medium[0] = 0;  n_3p_migr_Nt_2ft_tq_medium[0] = 0;
  n_1p_migr_Nt_2ft_tq_medium[1] = 0;  n_3p_migr_Nt_2ft_tq_medium[1] = 0;
  n_1p_migr_Nt_2ft_tq_medium[2] = 0;  n_3p_migr_Nt_2ft_tq_medium[2] = 0;
  n_1p_migr_Nt_2ft_tq_medium[3] = 0;  n_3p_migr_Nt_2ft_tq_medium[3] = 0;
  n_1p_migr_Nt_2ft_tq_medium[4] = 0;  n_3p_migr_Nt_2ft_tq_medium[4] = 0;
			     					   
  n_1p_migr_Nt_3ft_tq_medium[0] = 0;  n_3p_migr_Nt_3ft_tq_medium[0] = 0;
  n_1p_migr_Nt_3ft_tq_medium[1] = 0;  n_3p_migr_Nt_3ft_tq_medium[1] = 0;
  n_1p_migr_Nt_3ft_tq_medium[2] = 0;  n_3p_migr_Nt_3ft_tq_medium[2] = 0;
  n_1p_migr_Nt_3ft_tq_medium[3] = 0;  n_3p_migr_Nt_3ft_tq_medium[3] = 0;
  n_1p_migr_Nt_3ft_tq_medium[4] = 0;  n_3p_migr_Nt_3ft_tq_medium[4] = 0;
							      
  n_1p_migr_Nt_Nft_tq_medium[0] = 0;  n_3p_migr_Nt_Nft_tq_medium[0] = 0;
  n_1p_migr_Nt_Nft_tq_medium[1] = 0;  n_3p_migr_Nt_Nft_tq_medium[1] = 0;
  n_1p_migr_Nt_Nft_tq_medium[2] = 0;  n_3p_migr_Nt_Nft_tq_medium[2] = 0;
  n_1p_migr_Nt_Nft_tq_medium[3] = 0;  n_3p_migr_Nt_Nft_tq_medium[3] = 0;
  n_1p_migr_Nt_Nft_tq_medium[4] = 0;  n_3p_migr_Nt_Nft_tq_medium[4] = 0;
  ///////////////////////////////////////////////////////
  n_1p_migr_Nt_0ft_tq_tight[0] = 0;  n_3p_migr_Nt_0ft_tq_tight[0] = 0;
  n_1p_migr_Nt_0ft_tq_tight[1] = 0;  n_3p_migr_Nt_0ft_tq_tight[1] = 0;
  n_1p_migr_Nt_0ft_tq_tight[2] = 0;  n_3p_migr_Nt_0ft_tq_tight[2] = 0;
  n_1p_migr_Nt_0ft_tq_tight[3] = 0;  n_3p_migr_Nt_0ft_tq_tight[3] = 0;
  n_1p_migr_Nt_0ft_tq_tight[4] = 0;  n_3p_migr_Nt_0ft_tq_tight[4] = 0;
							      
  n_1p_migr_Nt_1ft_tq_tight[0] = 0;  n_3p_migr_Nt_1ft_tq_tight[0] = 0;
  n_1p_migr_Nt_1ft_tq_tight[1] = 0;  n_3p_migr_Nt_1ft_tq_tight[1] = 0;
  n_1p_migr_Nt_1ft_tq_tight[2] = 0;  n_3p_migr_Nt_1ft_tq_tight[2] = 0;
  n_1p_migr_Nt_1ft_tq_tight[3] = 0;  n_3p_migr_Nt_1ft_tq_tight[3] = 0;
  n_1p_migr_Nt_1ft_tq_tight[4] = 0;  n_3p_migr_Nt_1ft_tq_tight[4] = 0;
	     						      
  n_1p_migr_Nt_2ft_tq_tight[0] = 0;  n_3p_migr_Nt_2ft_tq_tight[0] = 0;
  n_1p_migr_Nt_2ft_tq_tight[1] = 0;  n_3p_migr_Nt_2ft_tq_tight[1] = 0;
  n_1p_migr_Nt_2ft_tq_tight[2] = 0;  n_3p_migr_Nt_2ft_tq_tight[2] = 0;
  n_1p_migr_Nt_2ft_tq_tight[3] = 0;  n_3p_migr_Nt_2ft_tq_tight[3] = 0;
  n_1p_migr_Nt_2ft_tq_tight[4] = 0;  n_3p_migr_Nt_2ft_tq_tight[4] = 0;
			     					   
  n_1p_migr_Nt_3ft_tq_tight[0] = 0;  n_3p_migr_Nt_3ft_tq_tight[0] = 0;
  n_1p_migr_Nt_3ft_tq_tight[1] = 0;  n_3p_migr_Nt_3ft_tq_tight[1] = 0;
  n_1p_migr_Nt_3ft_tq_tight[2] = 0;  n_3p_migr_Nt_3ft_tq_tight[2] = 0;
  n_1p_migr_Nt_3ft_tq_tight[3] = 0;  n_3p_migr_Nt_3ft_tq_tight[3] = 0;
  n_1p_migr_Nt_3ft_tq_tight[4] = 0;  n_3p_migr_Nt_3ft_tq_tight[4] = 0;
							      
  n_1p_migr_Nt_Nft_tq_tight[0] = 0;  n_3p_migr_Nt_Nft_tq_tight[0] = 0;
  n_1p_migr_Nt_Nft_tq_tight[1] = 0;  n_3p_migr_Nt_Nft_tq_tight[1] = 0;
  n_1p_migr_Nt_Nft_tq_tight[2] = 0;  n_3p_migr_Nt_Nft_tq_tight[2] = 0;
  n_1p_migr_Nt_Nft_tq_tight[3] = 0;  n_3p_migr_Nt_Nft_tq_tight[3] = 0;
  n_1p_migr_Nt_Nft_tq_tight[4] = 0;  n_3p_migr_Nt_Nft_tq_tight[4] = 0;
  ///////////////////////////////////////////////////////

  for (int i=0; i<6; ++i) {
    for (int j=0; j<6; ++j) {
      n_not_matched[i][j] = 0;      
      n_not_matched_loose[i][j] = 0;  n_not_matched_medium[i][j] = 0;  n_not_matched_tight[i][j] = 0;
      for (int k=0; k<6; ++k) {
	n_not_matched_[i][j][k] = 0;      
	n_not_matched_loose_[i][j][k] = 0;  n_not_matched_medium_[i][j][k] = 0;  n_not_matched_tight_[i][j][k] = 0;
      }
    }
  }
  /////////////////////////////////////
  // Info("finalize()", "DEBUG-0: %i : %i : %i : %i : %i ",
  //      n_3p_migr_Nt_3ft_tq[0], n_3p_migr_Nt_3ft_tq[1], n_3p_migr_Nt_3ft_tq[2],
  //      n_3p_migr_Nt_3ft_tq[3], n_3p_migr_Nt_3ft_tq[4] );

  //n_1p_migr_2t[3][3][3][3];

  for (int i=0; i<3; ++i) {
    for (int j=0; j<3; ++j) {
      for (int k=0; k<3; ++k) {
	  n_1p_migr_2t[i][j][k] =0;
	  n_3p_migr_2t[i][j][k] =0;
	  n_1p_migr_2t_loose[i][j][k] =0;n_1p_migr_2t_medium[i][j][k] =0;n_1p_migr_2t_tight[i][j][k] =0;
	  n_3p_migr_2t_loose[i][j][k] =0;n_3p_migr_2t_medium[i][j][k] =0;n_3p_migr_2t_tight[i][j][k] =0;
	  for (int l=0; l<3; ++l) {  
	    n_1p_migr_2t_[i][j][k][l] =0;
	    n_3p_migr_2t_[i][j][k][l] =0;
	    n_1p_migr_2t_loose_[i][j][k][l] =0;n_1p_migr_2t_medium_[i][j][k][l] =0;n_1p_migr_2t_tight_[i][j][k][l] =0;
	    n_3p_migr_2t_loose_[i][j][k][l] =0;n_3p_migr_2t_medium_[i][j][k][l] =0;n_3p_migr_2t_tight_[i][j][k][l] =0;
	  }
      }
    }
  }

  n_1p_migr_1t_all=0;
  for (int i=0; i<3; ++i) {
    for (int j=0; j<2; ++j) {
      for (int k=0; k<2; ++k) {
	n_1p_migr_1t[i][j][k]=0;
	n_1p_migr_1t_loose[i][j][k]=0;
	n_1p_migr_1t_medium[i][j][k]=0;
	n_1p_migr_1t_tight[i][j][k]=0;
      }
    }
  }
  for (int i=0; i<4; ++i) {
    for (int j=0; j<6; ++j) {
      for (int k=0; k<6; ++k) {
	n_table_noconv[i][j][k]=0; n_table_noconv_STF[i][j][k]=0; n_table_STF[i][j][k]=0;
	n_table_noconv_loose[i][j][k]=0; n_table_noconv_STF_loose[i][j][k]=0; n_table_STF_loose[i][j][k]=0;
	n_table_noconv_medium[i][j][k]=0; n_table_noconv_STF_medium[i][j][k]=0; n_table_STF_medium[i][j][k]=0;
	n_table_noconv_tight[i][j][k]=0; n_table_noconv_STF_tight[i][j][k]=0; n_table_STF_tight[i][j][k]=0;

	for (int i1=0; i1<6; ++i1) {
	  for (int j1=0; j1<6; ++j1) {
	    for (int k1=0; k1<6; ++k1) {
	      n_table_all_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_STF_1[i][j][k][i1][j1][k1]=0; 
	      n_table_STF_1[i][j][k][i1][j1][k1]=0;

	      n_table_all_loose_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_loose_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_STF_loose_1[i][j][k][i1][j1][k1]=0; 
	      n_table_STF_loose_1[i][j][k][i1][j1][k1]=0;

	      n_table_all_medium_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_medium_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_STF_medium_1[i][j][k][i1][j1][k1]=0; 
	      n_table_STF_medium_1[i][j][k][i1][j1][k1]=0;

	      n_table_all_tight_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_tight_1[i][j][k][i1][j1][k1]=0; 
	      n_table_noconv_STF_tight_1[i][j][k][i1][j1][k1]=0; 
	      n_table_STF_tight_1[i][j][k][i1][j1][k1]=0;

	    }
	  }	
	}

      }
    }
  }

  //printf("here SUCCESS\n");

  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: fileExecute ()
{
  // Here you do everything that needs to be done exactly once for every
  // single file, e.g. collect a list of all lumi-blocks processed
  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: changeInput (bool firstFile)
{
  // Here you do everything you need to do when we change input files,
  // e.g. resetting branch addresses on trees.  If you are using
  // D3PDReader or a similar service this method is not needed.
  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: initialize ()
{
  // Here you do everything that you need to do after the first input
  // file has been connected and before the first event is processed,
  // e.g. create additional histograms based on which variables are
  // available in the input files.  You can also create all of your
  // histograms and trees in here, but be aware that this method
  // doesn't get called if no events are processed.  So any objects
  // you create here won't be available in the output if you have no
  // input events.

  m_event = wk()->xaodEvent();
  Info("initialize()", "Number of events = %lli", m_event->getEntries() );

  n_tracks_total = 0;
  n_taus_total = 0;
  n_taus_selected = 0;
  n_tau_tracks=0;

  n_taus_truthmatched = 0;
  n_taus_not_truthmatched = 0;

  n_taus_truthmatched_1=0;
  n_taus_not_truthmatched_1=0;

  n_tau_tracks_real_matched = 0;
  n_tau_tracks_real_notmatched = 0;
  n_tau_tracks_spur_matched = 0;
  n_tau_tracks_spur_notmatched = 0;


  n_tracks_trackFilterPassCorrect = 0;
  n_trackFilterProngs_wrong =0;
  n_trackFilterQuality_wrong =0;
  n_trackFilterQuality_trackFilterProngs_wrong =0;
  n_tracks_trackFilterPassAmbiguous = 0;

  n_tracks_tfp0_rm1=0;
  n_tracks_tfp1_rm1=0;
  n_tracks_tfp0_r0=0;
  n_tracks_tfp1_r0=0;
  n_tracks_tfp0_r1=0;
  n_tracks_tfp1_r1=0;

  //m_store = new xAOD::TStore();
 
  // Deep copy for TauJets
  //m_newTauJets = new xAOD::TauJetContainer();
  //m_newTauJetsAux = new xAOD::TauJetAuxContainer();
  //m_newTauJets->setStore(m_newTauJetsAux);


  // TauAnalysisTools::TauTruthMatchingTool* T2MT = new TauAnalysisTools::TauTruthMatchingTool("T2MT");
  // T2MT = new TauAnalysisTools::TauTruthMatchingTool("T2MT");
  // T2MT->msg().setLevel( MSG::ERROR );
  // T2MT->setProperty("SampleType", (int)TauAnalysisTools::PYTHIA);


  printf("Here OK\n");

  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: execute ()
{
  // Here you do everything that needs to be done on every single
  // events, e.g. read input variables, apply cuts, and fill
  // histograms and trees.  This is where most of your actual analysis
  // code will go.

  // look into the tau container
  const xAOD::TauJetContainer* tau_cont = 0;

  if ( !m_event->retrieve(tau_cont, "TauRecContainer" ).isSuccess() ){
    Error("execute()", "Failed to retrieve Tau container. Exiting." );
    return EL::StatusCode::FAILURE;
  }
  xAOD::TauJetContainer::const_iterator tau_itr = tau_cont->begin();
  xAOD::TauJetContainer::const_iterator tau_end = tau_cont->end();

  const xAOD::TruthParticleContainer* truePart_cont = 0;
  if ( !m_event->retrieve(truePart_cont, "TruthParticle" ).isSuccess() ){
    Error("execute()", "Failed to retrieve True particle container. Exiting." );
    return EL::StatusCode::FAILURE;
  }

  TauAnalysisTools::TauTruthMatchingTool* T2MT = new TauAnalysisTools::TauTruthMatchingTool("T2MT");
  T2MT->msg().setLevel( MSG::ERROR );
  T2MT->setProperty("SampleType", (int)TauAnalysisTools::PYTHIA);
  // bool check_init = T2MT->initialize();
  //  bool check_setcont =  T2MT->setTruthParticleContainer( truePart_cont  );

  //  std::cout << "CHECKS:  " <<   check_init  << " , " << check_setcont << std::endl;

  TauAnalysisTools::TauTruthTrackMatchingTool* T3MT = new TauAnalysisTools::TauTruthTrackMatchingTool("T3MT");
  T3MT->msg().setLevel( MSG::ERROR );
  T3MT->initialize();
  


  for (; tau_itr != tau_end; ++tau_itr) {
    ++n_taus_total;

    int nCoreTracks = (*tau_itr)->nTracks();
    //Info("execute()", "  tau with tracks: %i ", nCoreTracks);
    // bool isTau13prong = ( (nCoreTracks == 1) || (nCoreTracks == 3) ) ;
    //    bool isTau13prong = ( nCoreTracks == 1 && (*tau_itr)->pt() > 8000.) ;
    // if (! isTau13prong ) continue;
    if ((*tau_itr)->pt() < 15000) continue;
    //if ( ! (nCoreTracks == 1 || nCoreTracks == 3)) continue;
    ++n_taus_selected;

    bool check_setcont =  T2MT->setTruthParticleContainer( truePart_cont  );	
    const  xAOD::TruthParticle* tau_truth_part = T2MT->applyTruthMatch( *(*tau_itr) );
    bool tau_isTruthMatched = (*tau_itr)->auxdata<bool>("IsTruthMatched");
    int tau_TruthProng = -1;
    if (tau_isTruthMatched) {
      ++n_taus_truthmatched;
      tau_TruthProng = (*tau_itr)->auxdata<size_t>("TruthProng");
    } else {  
      ++n_taus_not_truthmatched;
    }

    // for these taus check whether they have passes tau ID
    bool isJetBDTSigLoose = (*tau_itr)->isTau( xAOD::TauJetParameters::JetBDTSigLoose );
    bool isJetBDTSigMedium = (*tau_itr)->isTau( xAOD::TauJetParameters::JetBDTSigMedium );
    bool isJetBDTSigTight = (*tau_itr)->isTau( xAOD::TauJetParameters::JetBDTSigTight );

    // if tau is not truth matched it is still good to get a record of 
    // what the spurious track filter is doing
    if (!tau_isTruthMatched) {
      int nProngs_filter = (*tau_itr)->trackFilterProngs();
      int nProngs =  nCoreTracks;
      TLorentzVector v_tau;
      double tau_pt =(*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Pt();
      double tau_phi =(*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Phi();
      double tau_eta =(*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Eta();
      v_tau.SetPtEtaPhiM(tau_pt/1000,  tau_eta,  tau_phi, 1.77);
      //v_tau.SetPtEtaPhiM(tau_pt,  tau_eta,  tau_phi, 1.77*1000);
      std::vector<TLorentzVector> inputtracks20, inputtracks40;
      std::vector<int> inputtracks20charge, inputtracks40charge;
      for (int i=0;i<nCoreTracks;++i) { 
        const xAOD::TrackParticle* trk = (*tau_itr)->track(i);    
        if (!trk) {
      	std::cout << "Could not get track" << std::endl;
        }
        TLorentzVector v_track; 
        v_track.SetPtEtaPhiE(trk->pt()/1000, trk->eta(), trk->phi(), trk->e()/1000.);
	//v_track.SetPtEtaPhiE(trk->pt(), trk->eta(), trk->phi(), trk->e());
        double dR = v_tau.DeltaR(v_track);
        if (dR < 0.2) {
      	inputtracks20.push_back(v_track);
      	inputtracks20charge.push_back( int(  trk->charge()  ));
        }
        else if (dR < 0.4) {
      	inputtracks40.push_back(v_track);
      	inputtracks40charge.push_back(int(  trk->charge()  ));
        }
      }
      //output objects needed
      std::vector<TLorentzVector> outputtracksgood;
      std::vector<TLorentzVector> outputtracksbad;
      std::vector<int> outputtracksgoodcharge;
      std::vector<int> outputtracksbadcharge;
      int nProng_c=0, flag_c=0;
      float  pi0angle_c=0;
      TLorentzVector barycenter_c;
      // run the shrinking cone algorithm
      ShrinkingConeD3PDAlg(v_tau, &inputtracks20, &inputtracks20charge, &inputtracks40, &inputtracks40charge, 
			   &outputtracksgood, &outputtracksgoodcharge, &outputtracksbad, &outputtracksbadcharge, 
			   nProng_c, flag_c, pi0angle_c, &barycenter_c);
      nProngs_filter = nProng_c;
      //
      // study on what goes what 
      int nConversionTracks_i = (*tau_itr)->nConversionTracks();
      if (nConversionTracks_i > 5) nConversionTracks_i = 5;
      int nCoreTracks_i = nCoreTracks;
      if (nCoreTracks_i > 5) nCoreTracks_i = 5;
      int nProngs_filter_i = nProngs_filter;
      if (nProngs_filter_i > 5) nProngs_filter_i = 5;
      // array [6][6]
      ++n_not_matched[nCoreTracks_i][nProngs_filter_i];
      ++n_not_matched_[nCoreTracks_i][nProngs_filter_i][nConversionTracks_i];
      if (isJetBDTSigLoose)  {++n_not_matched_loose[nCoreTracks_i][nProngs_filter_i];  ++n_not_matched_loose_[nCoreTracks_i][nProngs_filter_i][nConversionTracks_i]; }
      if (isJetBDTSigMedium) {++n_not_matched_medium[nCoreTracks_i][nProngs_filter_i]; ++n_not_matched_medium_[nCoreTracks_i][nProngs_filter_i][nConversionTracks_i];}
      if (isJetBDTSigTight)  {++n_not_matched_tight[nCoreTracks_i][nProngs_filter_i];  ++n_not_matched_tight_[nCoreTracks_i][nProngs_filter_i][nConversionTracks_i];}

      if (nCoreTracks_i >=1 && nCoreTracks_i <= 4) {
	h_fake_taus_eta->Fill(tau_eta);
	h_fake_taus_pt->Fill(tau_pt/1000);
      }
      if (nCoreTracks_i == 1) {
	h_fake_taus_3t_eta->Fill(tau_eta);
	h_fake_taus_3t_pt->Fill(tau_pt/1000);
      }
      if (nCoreTracks_i == 3) {
	h_fake_taus_3t_eta->Fill(tau_eta);
	h_fake_taus_3t_pt->Fill(tau_pt/1000);
      }
      
      if (nProngs_filter_i == 1) {
	h_fake_taus_1ft_eta->Fill(tau_eta);
	h_fake_taus_1ft_pt->Fill(tau_pt/1000);
      }
      if (nProngs_filter_i == 3) {
	h_fake_taus_3ft_eta->Fill(tau_eta);
	h_fake_taus_3ft_pt->Fill(tau_pt/1000);
      }

      
    }
    //////////////////////////////////////////////////////

    if (tau_isTruthMatched) {
      // compare them to the number of tracks
      int nProngs_filter = (*tau_itr)->trackFilterProngs();
      int nProngs =  nCoreTracks;


      ///////////////////////////////////////////////
      /// 
      TLorentzVector v_tau;
      double tau_pt =(*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Pt();
      double tau_phi =(*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Phi();
      double tau_eta =(*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Eta();
      v_tau.SetPtEtaPhiM(tau_pt/1000,  tau_eta,  tau_phi, 1.77);
      //v_tau.SetPtEtaPhiM(tau_pt,  tau_eta,  tau_phi, 1.77*1000);
      std::vector<TLorentzVector> inputtracks20, inputtracks40;
      std::vector<int> inputtracks20charge, inputtracks40charge;
      for (int i=0;i<nCoreTracks;++i) { 
        const xAOD::TrackParticle* trk = (*tau_itr)->track(i);    
        if (!trk) {
      	std::cout << "Could not get track" << std::endl;
        }
        TLorentzVector v_track; 
        v_track.SetPtEtaPhiE(trk->pt()/1000, trk->eta(), trk->phi(), trk->e()/1000.);
	//v_track.SetPtEtaPhiE(trk->pt(), trk->eta(), trk->phi(), trk->e());
        double dR = v_tau.DeltaR(v_track);
        if (dR < 0.2) {
      	inputtracks20.push_back(v_track);
      	inputtracks20charge.push_back( int(  trk->charge()  ));
        }
        else if (dR < 0.4) {
      	inputtracks40.push_back(v_track);
      	inputtracks40charge.push_back(int(  trk->charge()  ));
        }
      }
      ///////////////////////////////////////////////////////


      //output objects needed
      std::vector<TLorentzVector> outputtracksgood;
      std::vector<TLorentzVector> outputtracksbad;
      std::vector<int> outputtracksgoodcharge;
      std::vector<int> outputtracksbadcharge;
      int nProng_c=0, flag_c=0;
      float  pi0angle_c=0;
      TLorentzVector barycenter_c;
      // run the shrinking cone algorithm
      ShrinkingConeD3PDAlg(v_tau, &inputtracks20, &inputtracks20charge, &inputtracks40, &inputtracks40charge, 
			   &outputtracksgood, &outputtracksgoodcharge, &outputtracksbad, &outputtracksbadcharge, 
			   nProng_c, flag_c, pi0angle_c, &barycenter_c);
      nProngs_filter = nProng_c;

      /////////////////////////////////////////
      // if you have 3 tracks calculate whether pass3prong is true
      int pass3prong_res = -1;
      int pass2prong_res = -1;
      int pass1prong_res = -1;
      unsigned int tracknum = inputtracks20.size();
      unsigned int widetracknum = inputtracks40.size();
      int charge = 0;
      if (nCoreTracks == 3) {
	
	std::vector<TrackInfo> unsorted,tracks,SScombination;
	TrackInfo track;
	for(unsigned int i=0;i<tracknum;i++){
	  track.p4 = inputtracks20[i];
	  track.charge = inputtracks20charge[i];
	  if(track.p4.M() < 1e-3) std::cerr << "WARNING: Track Mass might be incorrectly set (to zero) - Please Check and Correct." << std::endl;
	  unsorted.push_back(track);
	}
	while (unsorted.size() > 0){
	  float trackP = unsorted[0].p4.P();
	  int index = 0;
	  for(unsigned int i=1;i<unsorted.size();i++){
	    if(unsorted[i].p4.P() > trackP){
	      index = i;
	      trackP = unsorted[i].p4.P();
	    }
	  }
	  tracks.push_back(unsorted[index]);
	  tracks[tracks.size()-1].index = tracks.size()-1;
	  unsorted.erase(unsorted.begin()+index);            
	}

	std::vector<TrackInfo> combination;
	for(unsigned int i=0;i<3;i++){
	  combination.push_back(tracks[i]); //Only Care about 3 Highest pT Tracks
	  charge+=tracks[i].charge;
	}
	pass3prong_res = int(pass3prong(combination,v_tau));
	
	std::vector<TrackInfo> pair;
	for(unsigned int i=0;i<2;i++) pair.push_back(tracks[i]);
	pass2prong_res = int(pass2prong(pair,v_tau));
	pass1prong_res = pass1prong(tracks[0].p4,v_tau);
      }
      ////////////////////////////////////////



      ///////////////////////////////////////////////




      if (tau_TruthProng == 1) {
      	++n_1p_true_true_taus;
	if (isJetBDTSigLoose)  {++n_1p_true_true_taus_loose;}
	if (isJetBDTSigMedium) {++n_1p_true_true_taus_medium;}
	if (isJetBDTSigTight)  {++n_1p_true_true_taus_tight;}
      	h_1p_true_taus_eta->Fill((*tau_itr)->eta());
      	h_1p_true_taus_pt->Fill((*tau_itr)->pt()*0.001);
      	if (nProngs == 1) { // true 1-prong that are reco-ed as 1-prong
      	  ++n_1p_true_true_taus_reco1p;
	  if (isJetBDTSigLoose)  {++n_1p_true_true_taus_reco1p_loose;}
	  if (isJetBDTSigMedium) {++n_1p_true_true_taus_reco1p_medium;}
	  if (isJetBDTSigTight)  {++n_1p_true_true_taus_reco1p_tight;}
      	  h_1p_true_taus_eta_reco1p->Fill((*tau_itr)->eta());
      	  h_1p_true_taus_pt_reco1p->Fill((*tau_itr)->pt()*0.001);
      	}
      	else if (nProngs == 2) {
	  ++n_1p_true_true_taus_reco2p;
	  if (isJetBDTSigLoose)  {++n_1p_true_true_taus_reco2p_loose;}
	  if (isJetBDTSigMedium) {++n_1p_true_true_taus_reco2p_medium;}
	  if (isJetBDTSigTight)  {++n_1p_true_true_taus_reco2p_tight;}
	}
      	else if (nProngs == 3) {
	  ++n_1p_true_true_taus_reco3p;
	  if (isJetBDTSigLoose)  {++n_1p_true_true_taus_reco3p_loose;}
	  if (isJetBDTSigMedium) {++n_1p_true_true_taus_reco3p_medium;}
	  if (isJetBDTSigTight)  {++n_1p_true_true_taus_reco3p_tight;}
	}
      	else if (nProngs == 0) {
	  ++n_1p_true_true_taus_reco0p;
	  if (isJetBDTSigLoose)  {++n_1p_true_true_taus_reco0p_loose;}
	  if (isJetBDTSigMedium) {++n_1p_true_true_taus_reco0p_medium;}
	  if (isJetBDTSigTight)  {++n_1p_true_true_taus_reco0p_tight;}
	}
      	else {++n_1p_true_true_taus_recoNp; //printf("Found 1-prong with %i tracks\n", nProngs);
	  if (isJetBDTSigLoose)  {++n_1p_true_true_taus_recoNp_loose;}
	  if (isJetBDTSigMedium) {++n_1p_true_true_taus_recoNp_medium;}
	  if (isJetBDTSigTight)  {++n_1p_true_true_taus_recoNp_tight;}
	}

	if (nProngs_filter == 1) {
	  ++n_1p_true_true_taus_filter1p;
      	  h_1p_true_taus_eta_filter1p->Fill((*tau_itr)->eta());
      	  h_1p_true_taus_pt_filter1p->Fill((*tau_itr)->pt()*0.001);
	}

	if (nProngs_filter == 1) { ++n_1p_true_true_taus_trackFilterProngs_1;}
	else if (nProngs_filter == 2) { ++n_1p_true_true_taus_trackFilterProngs_2;}
	else if (nProngs_filter == 0) { ++n_1p_true_true_taus_trackFilterProngs_0;}
	else if (nProngs_filter == 3) { ++n_1p_true_true_taus_trackFilterProngs_3;}
	else { ++n_1p_true_true_taus_trackFilterProngs_4; }

      } 
      else if (tau_TruthProng == 3) {
      	++n_3p_true_true_taus;
	if (isJetBDTSigLoose)  {++n_3p_true_true_taus_loose;}
	if (isJetBDTSigMedium) {++n_3p_true_true_taus_medium;}
	if (isJetBDTSigTight)  {++n_3p_true_true_taus_tight;}
      	h_3p_true_taus_eta->Fill((*tau_itr)->eta());
      	h_3p_true_taus_pt->Fill((*tau_itr)->pt()*0.001);
      	if (nProngs == 1) {
	  ++n_3p_true_true_taus_reco1p;
	  if (isJetBDTSigLoose)  {++n_3p_true_true_taus_reco1p_loose;}
	  if (isJetBDTSigMedium) {++n_3p_true_true_taus_reco1p_medium;}
	  if (isJetBDTSigTight)  {++n_3p_true_true_taus_reco1p_tight;}
	}
      	else if (nProngs == 0) {
	  ++n_3p_true_true_taus_reco0p;
	  if (isJetBDTSigLoose)  {++n_3p_true_true_taus_reco0p_loose;}
	  if (isJetBDTSigMedium) {++n_3p_true_true_taus_reco0p_medium;}
	  if (isJetBDTSigTight)  {++n_3p_true_true_taus_reco0p_tight;}
	}
      	else if (nProngs == 2) {
	  ++n_3p_true_true_taus_reco2p;
	  if (isJetBDTSigLoose)  {++n_3p_true_true_taus_reco2p_loose;}
	  if (isJetBDTSigMedium) {++n_3p_true_true_taus_reco2p_medium;}
	  if (isJetBDTSigTight)  {++n_3p_true_true_taus_reco2p_tight;}	
	}
      	else if (nProngs == 3) {
      	  ++n_3p_true_true_taus_reco3p;
	  if (isJetBDTSigLoose)  {++n_3p_true_true_taus_reco3p_loose;}
	  if (isJetBDTSigMedium) {++n_3p_true_true_taus_reco3p_medium;}
	  if (isJetBDTSigTight)  {++n_3p_true_true_taus_reco3p_tight;}
      	  h_3p_true_taus_eta_reco3p->Fill((*tau_itr)->eta());
      	  h_3p_true_taus_pt_reco3p->Fill((*tau_itr)->pt()*0.001);
      	}
      	else {
	  ++n_3p_true_true_taus_recoNp;
	  if (isJetBDTSigLoose)  {++n_3p_true_true_taus_recoNp_loose;}
	  if (isJetBDTSigMedium) {++n_3p_true_true_taus_recoNp_medium;}
	  if (isJetBDTSigTight)  {++n_3p_true_true_taus_recoNp_tight;}
	}
	if (nProngs_filter == 3) { ++n_3p_true_true_taus_trackFilterProngs_3;}
	else if (nProngs_filter == 1) { ++n_3p_true_true_taus_trackFilterProngs_1;}
	else if (nProngs_filter == 0) { ++n_3p_true_true_taus_trackFilterProngs_0;}
	else if (nProngs_filter == 2) { ++n_3p_true_true_taus_trackFilterProngs_2;}
	else { ++n_3p_true_true_taus_trackFilterProngs_4; }

	if (nProngs_filter == 3) {
	  ++n_3p_true_true_taus_filter3p;
      	  h_3p_true_taus_eta_filter3p->Fill((*tau_itr)->eta());
      	  h_3p_true_taus_pt_filter3p->Fill((*tau_itr)->pt()*0.001);
	}

      }
      std::vector<int> track_result;
      std::vector<int> track_conversion_tagger_result;
      std::vector<int> track_SPT_result;
      for (int i=0;i<nCoreTracks;++i) { 
	const xAOD::TrackParticle* trk = (*tau_itr)->track(i);    

	TLorentzVector v_track; 
	v_track.SetPtEtaPhiE(trk->pt()/1000., trk->eta(), trk->phi(), trk->e()/1000.);
	// check whether this is a conversion track:
	int is_conversion_tagger_track=0;
	for (int i_track=0; i_track < (int) (*tau_itr)->nConversionTracks(); ++ i_track){
	  const xAOD::TrackParticle* conv_trk = *(((*tau_itr)->conversionTrackLinks()).at(i_track));
	  TLorentzVector v_track_conv; v_track_conv.SetPtEtaPhiE(conv_trk->pt()/1000., conv_trk->eta(), conv_trk->phi(), conv_trk->e()/1000.);
	  if (v_track_conv.DeltaR(v_track) < 0.001) { is_conversion_tagger_track=1; }
	}
	track_conversion_tagger_result.push_back(is_conversion_tagger_track);

	//v_track.SetPtEtaPhiE(trk->pt(), trk->eta(), trk->phi(), trk->e());
	int trackFilterPass = (*tau_itr)->trackFilterPass(i); 
	int trackFilterPass_calc = Compare4VectorWithList(v_track, outputtracksgood);
	if (trackFilterPass_calc > -1) { trackFilterPass_calc =1; } else { trackFilterPass_calc=0;}
	trackFilterPass = trackFilterPass_calc;

	track_SPT_result.push_back(trackFilterPass);

	T3MT->classifyTrack( *trk);

	bool IsHadronicTrack =	trk->auxdecor<bool>("IsHadronicTrack");
	int  SpuriousType    =  trk->auxdecor<int>("SpuriousType");
	std::string DecayHistory = trk->auxdecor<std::string>("DecayHistory");
	int  IsHadronicTrackDecayDepth = trk->auxdecor<int>("IsHadronicTrackDecayDepth");

	//	std::cout << "IsHadronicTrack: " << IsHadronicTrack << std::endl;
	//	std::cout << "DecayHistory: " << DecayHistory << std::endl;
	bool tau_track_is_pion = false;	  
	bool tau_track_is_spurious = false;	  
	bool tau_isconversion = false;
	bool tau_track_is_not_hadronic_track = false;
	if (DecayHistory == "15:-211" || DecayHistory == "15:-213" || DecayHistory == "15:-321" ||
	    DecayHistory == "-15:211" || DecayHistory == "-15:213" || DecayHistory == "-15:321" ||
	    DecayHistory == "15:211"  || DecayHistory == "-15:-211") {
	  if (IsHadronicTrackDecayDepth == 0 && IsHadronicTrack) {
	    tau_track_is_pion = true; }
	}
	//else if (IsHadronicTrack == false) {
	else {
	  tau_track_is_spurious = true;
	  if (DecayHistory == "-15:111:22:11" || DecayHistory == "-15:111:22:-11" || 
	      DecayHistory == "15:111:22:11"  || DecayHistory == "15:111:22:-11") {
	    if (IsHadronicTrackDecayDepth > 0) { tau_isconversion = true; }
	  }
	  if (IsHadronicTrack == false) {
	    tau_track_is_not_hadronic_track = true;
	  }
	}
	//..... keep the result for future  use .....//
	if (tau_track_is_pion) {
	  track_result.push_back(0);
	}
	else {
	  if (tau_isconversion) {
	    track_result.push_back(2);
	  }
	  else { // tau is spurious is true
	    track_result.push_back(1);
	  }
	}
	////////////////////////////////////////////////

	if (tau_TruthProng == 1) {
	  ++n_1p_all_tracks;
	  if (tau_track_is_pion) { // true pion track
	    h_1p_true_pion_tracks_eta->Fill(trk->eta()); 
	    h_1p_true_pion_tracks_pt->Fill(trk->pt()*0.001); 
	    ++n_1p_true_pion_tracks;
	    if (trackFilterPass == 1) {
	      h_1p_true_pion_tracks_eta_passfilter->Fill(trk->eta());
	      h_1p_true_pion_tracks_pt_passfilter->Fill(trk->pt()*0.001);
	      ++n_1p_true_pion_tracks_passfilter;
	      //printf("CASE: pass");
	    } //else {
	      //printf("CASE: NOT pass");
	      //}
	  }
	  //else { // track is not a pion, ie., it is a spurious track
	  if (tau_track_is_spurious) {
	    h_1p_true_spurious_tracks_eta->Fill(trk->eta()); 
	    h_1p_true_spurious_tracks_pt->Fill(trk->pt()*0.001); 
	    ++n_1p_true_spurious_tracks;
	    if (trackFilterPass == 0) {
	      h_1p_true_spurious_tracks_eta_passfilter->Fill(trk->eta()); 
	      h_1p_true_spurious_tracks_pt_passfilter->Fill(trk->pt()*0.001); 
	      ++n_1p_true_spurious_tracks_passfilter;
	    }
	    if (tau_isconversion) {
	      ++n_1p_true_spurious_conversion_tracks;
	      h_1p_true_spurious_conversion_tracks_eta->Fill(trk->eta());
	      h_1p_true_spurious_conversion_tracks_pt->Fill(trk->pt()*0.001);
	      if (trackFilterPass == 0) {
		++n_1p_true_spurious_conversion_tracks_passfilter;
		h_1p_true_spurious_conversion_tracks_eta_passfilter->Fill(trk->eta());
		h_1p_true_spurious_conversion_tracks_pt_passfilter->Fill(trk->pt()*0.001);
	      }
	    }
	    if (tau_track_is_not_hadronic_track) {
	      ++n_1p_true_spurious_not_hadronic_tracks;
	      if (trackFilterPass == 0) {
		++n_1p_true_spurious_not_hadronic_tracks_passfilter;
	      }
	    }

	  }
	}
	/// do the same with the 3 prong taus:
	if (tau_TruthProng == 3) {
	  ++n_3p_all_tracks;

	  if (tau_track_is_pion) { // true pion track
	    h_3p_true_pion_tracks_eta->Fill(trk->eta()); 
	    h_3p_true_pion_tracks_pt->Fill(trk->pt()*0.001); 
	    ++n_3p_true_pion_tracks;
	    if (trackFilterPass == 1) {
	      h_3p_true_pion_tracks_eta_passfilter->Fill(trk->eta());
	      h_3p_true_pion_tracks_pt_passfilter->Fill(trk->pt()*0.001);
	      ++n_3p_true_pion_tracks_passfilter;
	      std::cout << "filter pass: " << DecayHistory <<  " Decay depth: " << IsHadronicTrackDecayDepth  
			<< " isHadtrack:  " << IsHadronicTrack << " Spurious type: " << SpuriousType
			<< " eta: " << trk->eta() << " trk pT: " << trk->pt()*0.001 << " charge: " << trk->charge()
			<< " tau pT: " << (*tau_itr)->pt()<< " this tau: " 
			<< pass3prong_res << pass2prong_res << pass3prong_res 
			<< " tracks: " << tracknum << " / " << widetracknum << " q: " << charge 
			<< " nProng: "  << nProngs_filter
			<< std::endl;
	    } else {
	      std::cout << "filter fail: " << DecayHistory <<  " Decay depth: " << IsHadronicTrackDecayDepth  
			<< " isHadtrack:  " << IsHadronicTrack << " Spurious type: " << SpuriousType
			<< " eta: " << trk->eta() << " trk pT: " << trk->pt()*0.001 << " charge: " << trk->charge()
			<< " tau pT: " << (*tau_itr)->pt()<< " this tau: " 
			<< pass3prong_res << pass2prong_res << pass3prong_res 
			<< " tracks: " << tracknum << " / " << widetracknum << " q: " << charge
			<< " nProng: "  << nProngs_filter
			<< std::endl;
	    }

	  }
	  //else { // track is not a pion, ie., it is a spurious track
	  if (tau_track_is_spurious) {
	    h_3p_true_spurious_tracks_eta->Fill(trk->eta()); 
	    h_3p_true_spurious_tracks_pt->Fill(trk->pt()*0.001); 
	    ++n_3p_true_spurious_tracks;
	    if (trackFilterPass == 0) {
	      h_3p_true_spurious_tracks_eta_passfilter->Fill(trk->eta()); 
	      h_3p_true_spurious_tracks_pt_passfilter->Fill(trk->pt()*0.001); 
	      ++n_3p_true_spurious_tracks_passfilter;
	    }
	    if (tau_isconversion) {
	      ++n_3p_true_spurious_conversion_tracks;
	      h_3p_true_spurious_conversion_tracks_eta->Fill(trk->eta());
	      h_3p_true_spurious_conversion_tracks_pt->Fill(trk->pt()*0.001);
	      if (trackFilterPass == 0) {
		++n_3p_true_spurious_conversion_tracks_passfilter;
		h_3p_true_spurious_conversion_tracks_eta_passfilter->Fill(trk->eta());
		h_3p_true_spurious_conversion_tracks_pt_passfilter->Fill(trk->pt()*0.001);
	      }
	      if (tau_track_is_not_hadronic_track) {
		++n_3p_true_spurious_not_hadronic_tracks;
		if (trackFilterPass == 0) {
		  ++n_3p_true_spurious_not_hadronic_tracks_passfilter;
		}
	      }
	    } 
	    if (trackFilterPass == 0) {
	      std::cout << "spurious: filter fail: " << DecayHistory <<  " Decay depth: " << IsHadronicTrackDecayDepth  
			<< " isHadtrack:  " << IsHadronicTrack << " Spurious type: " << SpuriousType
			<< " eta: " << trk->eta() << " trk pT: " << trk->pt()*0.001 << " charge: " << trk->charge()
			<< " tau pT: " << (*tau_itr)->pt() << " this tau: " 
			<< pass3prong_res << pass2prong_res << pass3prong_res 
			<< " tracks: " << tracknum << " / " << widetracknum << " q: " << charge
			<< " nProng: "  << nProngs_filter
			<< std::endl;
	    } else {
	      std::cout << "spurious: filter pass: " << DecayHistory <<  " Decay depth: " << IsHadronicTrackDecayDepth  
			<< " isHadtrack:  " << IsHadronicTrack << " Spurious type: " << SpuriousType
			<< " eta: " << trk->eta() << " trk pT: " << trk->pt()*0.001 << " charge: " << trk->charge()
			<< " tau pT: " << (*tau_itr)->pt()<< " this tau: " 
			<< pass3prong_res << pass2prong_res << pass3prong_res 
			<< " tracks: " << tracknum << " / " << widetracknum << " q: " << charge
			<< " nProng: "  << nProngs_filter
			<< std::endl;
	    }
	  }
	}

	++n_tau_tracks;
	// if (trackFilterPass == 1 && tau_track_is_pion)   {++n_tau_tracks_real_matched;}
	// if (trackFilterPass == 0 && tau_track_is_pion)   {++n_tau_tracks_spur_matched;}
	// if (trackFilterPass == 1 && ! tau_track_is_pion) {++n_tau_tracks_real_notmatched;}
	// if (trackFilterPass == 0 && ! tau_track_is_pion) {++n_tau_tracks_spur_notmatched;}
      }

      countMigration(tau_TruthProng , nProngs, nProngs_filter, track_result, track_SPT_result, track_conversion_tagger_result,
		     isJetBDTSigLoose, isJetBDTSigMedium, isJetBDTSigTight, (*tau_itr)->nConversionTracks());
    }
    //    delete    T2MT;
    // for (int i=0;i<nCoreTracks;++i) { 
    //   const xAOD::TrackParticle* trk = (*tau_itr)->track(i);    
    //   if (!trk) {
    // 	std::cout << "Could not get track" << std::endl;
    //   }
    //   TLorentzVector v_track; 
    //   v_track.SetPtEtaPhiE(trk->pt(), trk->eta(), trk->phi(), trk->e());
    //   double dR = v_tau.DeltaR(v_track);
    //   if (dR < 0.2) {
    // 	inputtracks20.push_back(v_track);
    // 	inputtracks20charge.push_back( int(  trk->charge()  ));
    //   }
    //   else if (dR < 0.4) {
    // 	inputtracks40.push_back(v_track);
    // 	inputtracks40charge.push_back(int(  trk->charge()  ));
    //   }
    // }

    // output objects needed
    // std::vector<TLorentzVector> outputtracksgood;
    // std::vector<TLorentzVector> outputtracksbad;
    // std::vector<int> outputtracksgoodcharge;
    // std::vector<int> outputtracksbadcharge;
    // int nProng=0, flag=0;
    // float  pi0angle=0;
    // TLorentzVector barycenter;
    // // run the shrinking cone algorithm
    // ShrinkingConeD3PDAlg(v_tau, &inputtracks20, &inputtracks20charge, &inputtracks40, &inputtracks40charge, 
    //   			 &outputtracksgood, &outputtracksgoodcharge, &outputtracksbad, &outputtracksbadcharge, 
    //   			 nProng, flag, pi0angle, &barycenter);
    // int nProng_rec = 0; if (nProng == 1) {nProng_rec =1; } else {nProng_rec =3;}
    // float pi0angle_calc = ComputePi0Cone(nProng_rec, v_tau);
    // float pi0angle_calc_xAOD = ComputePi0Cone(nProng_rec, v_tau_xAOD);
    // float pi0angle_calc_xAOD_1 = ComputePi0Cone_1(nProng_rec, v_tau_xAOD);

    // float pi0conedr = std::min(pi0angle*cosh((*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Eta()), 0.2);
    // float pi0conedr_taueta = std::min(pi0angle*cosh((*tau_itr)->eta()), 0.2);
    // float pi0conedr_xAOD = std::min(pi0angle_calc_xAOD*cosh((*tau_itr)->eta()), 0.2);
    // float pi0conedr_xAOD_1 = std::min(pi0angle_calc_xAOD_1*cosh((*tau_itr)->eta()), 0.2);
    // float pi0conedr_xAOD_2 = std::min(pi0angle_calc_xAOD_1*cosh((*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Eta()), 0.2);


    // int trackFilterProngs = (*tau_itr)->trackFilterProngs();
    // int trackFilterQuality = (*tau_itr)->trackFilterQuality();

    // if (! nProng==trackFilterProngs) { ++n_trackFilterProngs_wrong; }
    // if (! trackFilterQuality==flag) { ++n_trackFilterQuality_wrong; }
    // if ( (! trackFilterQuality==flag)  && (! nProng==trackFilterProngs)) { ++n_trackFilterQuality_trackFilterProngs_wrong; }

    // bool Isproblem = false;


    // if ((! nProng==trackFilterProngs) || (! trackFilterQuality==flag)) {
    //   Isproblem = true;
    // }


    // bool first = true;
    // for (int i=0;i<nCoreTracks;++i) { 
    //   const xAOD::TrackParticle* trk = (*tau_itr)->track(i);
    //   int trackFilterPass = (*tau_itr)->trackFilterPass(i);
    //   double track_pt = trk->pt()/1000.;
    //   // identify this particular track with one in the outputtracksgood or outputtracksbad tracks
    //   TLorentzVector v_track; 
    //   v_track.SetPtEtaPhiM(trk->pt(), trk->eta(), trk->phi(), 0.13957*1000.);
    //   //v_track.SetPtEtaPhiE(trk->pt(), trk->eta(), trk->phi(), trk->e());
    //   double dr_tau = v_track.DeltaR(v_tau);
    //   int i_good = Compare4VectorWithList(v_track, outputtracksgood);
    //   int i_bad = Compare4VectorWithList(v_track, outputtracksbad);
    //   int res = -1;
    //   if (i_good >= 0 && i_bad < 0) res = 1;
    //   if (i_bad >= 0  && i_good <0) res = 0;
    //   if (i_good >= 0  && i_bad >= 0) res = 3;
    //   if (outputtracksgood.size() == 0 && outputtracksbad.size() == 0) res = 0; // in that case consider it a bad track
    //   if (res == trackFilterPass) {
    // 	++n_tracks_trackFilterPassCorrect;
    //   } 
    //   else if (res == 3) {
    // 	++n_tracks_trackFilterPassAmbiguous;
    //   }
    //   else {
    // 	if (trackFilterPass == 0 && res == -1) ++n_tracks_tfp0_rm1;
    // 	if (trackFilterPass == 1 && res == -1) ++n_tracks_tfp1_rm1;
    // 	if (trackFilterPass == 0 && res ==  0) ++n_tracks_tfp0_r0;
    // 	if (trackFilterPass == 1 && res ==  0) ++n_tracks_tfp1_r0;
    // 	if (trackFilterPass == 0 && res ==  1) ++n_tracks_tfp0_r1;
    // 	if (trackFilterPass == 1 && res ==  1) ++n_tracks_tfp1_r1;
    //   }

    //   if ((res != trackFilterPass) && res != 3) {
    // 	if (first) {
    // 	  printf( ">> Tau with tracks: %i good: %i  bad: %i\n", nCoreTracks, outputtracksgood.size(), outputtracksbad.size());
    // 	  first = false;
    // 	}
    // 	printf("-- track # %2i pT: %10.3f GeV eta: %f phi %f dr(tau) %f ch: %f | filter %i  VS  %i  CHECK>>>>  %i\n", 
    // 	       i, track_pt, trk->eta(), trk->phi(), dr_tau, trk->charge(), trackFilterPass, res, (res == trackFilterPass));
    // 	std::cout << "  ----- track charge: " << trk->charge() << std::endl;
    // 	Isproblem = true;
    //   }
    //   ++n_tracks_total;
    // }

    // if (Isproblem) {
    // //if (flag == 1) {
    //   if (first) {
    // 	printf( ">> Tau with tracks: %i good: %i  bad: %i \n", 
    // 		nCoreTracks, outputtracksgood.size(), outputtracksbad.size());
    //   }
    //   printf( "Tau properties: pT: %f  eta: %f  phi: %f pi0angle: %f vs %f pi0conedr: %f vs %f vs %f : diff: %f %f \n", 
    // 	      (*tau_itr)->pt(), (*tau_itr)->eta(), (*tau_itr)->phi(), pi0angle, pi0angle_calc, pi0conedr, 
    // 	      pi0conedr_taueta, (*tau_itr)->pi0ConeDR(),  
    // 	      (*tau_itr)->pi0ConeDR() - pi0angle, (*tau_itr)->pi0ConeDR() - pi0conedr_taueta);
    //   printf( "Tau with tracks: %i (%i) (%i %i) prongs: %i quality: %i   VS prongs: %i quality: %i   CHECK: %i%i \n",
    // 	      nCoreTracks,  (outputtracksgood.size() + outputtracksbad.size()),
    // 	      inputtracks20.size(),inputtracks40.size(),
    // 	      trackFilterProngs, trackFilterQuality, nProng, flag, 
    // 	      (nProng==trackFilterProngs), (trackFilterQuality==flag));
    //   if ((*tau_itr)->nTracks()==1) {
    // 	printf("Tau track charge: %f\n", (*tau_itr)->track(0)->charge());
    //   }

    //   printf("  problem detected and will print out track details for %i good and %i bad tracks\n", 
    // 	     (int)outputtracksgood.size(),int(outputtracksbad.size()));
    //   for (int i=0; i< (int)outputtracksgood.size(); ++i) {
    // 	TLorentzVector vec = outputtracksgood[i];
    // 	double angle = vec.Angle(v_tau.Vect());
    // 	float angle99 = Compute99angle(vec, v_tau);
    // 	printf(" -- GoodTrk %i pT: %f  eta: %f phi: %f charge: %i angle: %f vs angle99 %f\n", i, vec.Pt(), vec.Eta(), vec.Phi(),
    // 	       outputtracksgoodcharge[i], angle, angle99);
    //   }
    //   for (int i=0; i< (int)outputtracksbad.size(); ++i) {
    // 	TLorentzVector vec = outputtracksbad[i];
    // 	double angle = vec.Angle(v_tau.Vect());
    // 	float angle99 = Compute99angle(vec, v_tau);
    // 	printf(" -- BadTrk %i pT: %f  eta: %f phi: %f charge: %i angle: %f vs angle99 %f\n", i, vec.Pt(), vec.Eta(), vec.Phi(),
    // 	       outputtracksbadcharge[i], angle, angle99);
    //   }
      
    // }
    // if (flag == 1) { // this will print information about the 3d angle calculation
    //  printf( ">> Tau with tracks: %i nProng: %i pi0angle: %f vs %f vs %f vs %f pi0conedr: %f vs %f vs %f vs %f  vs  %f : diff: %f %f %f %f\n", 
    // 	     nCoreTracks, nProng, pi0angle, pi0angle_calc, pi0angle_calc_xAOD,  pi0angle_calc_xAOD_1, 
    // 	     pi0conedr, pi0conedr_xAOD, pi0conedr_xAOD_1, pi0conedr_xAOD_2,  (*tau_itr)->pi0ConeDR(),  
    // 	     (*tau_itr)->pi0ConeDR() - pi0conedr,
    // 	     (*tau_itr)->pi0ConeDR() - pi0conedr_xAOD, (*tau_itr)->pi0ConeDR() - pi0conedr_xAOD_1,
    // 	     (*tau_itr)->pi0ConeDR() - pi0conedr_xAOD_2
    // 	     );
    //  printf( "   tau pt: %f eta: %f phi: %f  InterAxis: pT: %f  eta: %f phi: %f \n", 
    // 	     (*tau_itr)->pt(),(*tau_itr)->eta(), (*tau_itr)->phi(),  
    // 	     (*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Pt(),
    // 	     (*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Eta(),
    // 	     (*tau_itr)->p4(xAOD::TauJetParameters::IntermediateAxis).Phi()
    // 	     );

    // }


  }

  return EL::StatusCode::SUCCESS;
}

void MyxAODAnalysis :: countMigration( int in_truthProng, int in_nProngs, int in_nProngs_filter,
				       std::vector<int> track_result, std::vector<int> track_STF_result, std::vector<int> track_conversion_tagger_result, 
				       bool isLoose, bool isMedium, bool isTight, int in_nConvTracks) {
  ////////////////////////////////////////////////////////
  // make a generic selection for the table

  int  c_noconv = 0,  c_noconv_STF=0, c_STF=0;
  int  c_noconv_piontracks=0, c_noconv_spurioustracks=0, c_noconv_conversiontracks=0;
  int  c_noconv_STF_piontracks=0, c_noconv_STF_spurioustracks=0, c_noconv_STF_conversiontracks=0;
  int  c_STF_piontracks=0, c_STF_spurioustracks=0, c_STF_conversiontracks=0;

  int  c_all = 0;
  int  c_all_piontracks=0, c_all_spurioustracks=0, c_all_conversiontracks=0;

  for (int i=0; i < in_nProngs; ++i) {
    ++c_all;
    if (track_result.at(i) == 0) ++c_all_piontracks;
    if (track_result.at(i) == 1) ++c_all_spurioustracks;
    if (track_result.at(i) == 2) ++c_all_conversiontracks;

    if (track_conversion_tagger_result.at(i) == 0) {
      ++c_noconv;
      if (track_result.at(i) == 0) ++c_noconv_piontracks;
      if (track_result.at(i) == 1) ++c_noconv_spurioustracks;
      if (track_result.at(i) == 2) ++c_noconv_conversiontracks;

      if (track_STF_result.at(i) == 1) { 
	++c_noconv_STF;
	if (track_result.at(i) == 0) ++c_noconv_STF_piontracks;
	if (track_result.at(i) == 1) ++c_noconv_STF_spurioustracks;
	if (track_result.at(i) == 2) ++c_noconv_STF_conversiontracks;
      }
    }
    if (track_STF_result.at(i) == 1) {
      ++c_STF; 
      if (track_result.at(i) == 0) ++c_STF_piontracks;
      if (track_result.at(i) == 1) ++c_STF_spurioustracks;
      if (track_result.at(i) == 2) ++c_STF_conversiontracks;
    }
  }
  //
  if (c_noconv > 5)     c_noconv = 5;
  if (c_noconv_STF > 5) c_noconv_STF = 5;
  if (c_STF > 5)        c_STF = 5;
  if (c_all > 5)        c_all = 5;
  int  c_nProngs = in_nProngs; if (c_nProngs > 5) c_nProngs = 5;
  //
  ++n_table_noconv[in_truthProng][c_nProngs][c_noconv];
  ++n_table_noconv_STF[in_truthProng][c_nProngs][c_noconv_STF];
  ++n_table_STF[in_truthProng][c_nProngs][c_STF];

  if (c_noconv_piontracks > 5)       c_noconv_piontracks = 5;
  if (c_noconv_spurioustracks > 5)   c_noconv_spurioustracks = 5;
  if (c_noconv_conversiontracks > 5) c_noconv_conversiontracks = 5;

  if (c_noconv_STF_piontracks > 5)       c_noconv_STF_piontracks = 5;
  if (c_noconv_STF_spurioustracks > 5)   c_noconv_STF_spurioustracks = 5;
  if (c_noconv_STF_conversiontracks > 5) c_noconv_STF_conversiontracks = 5;

  if (c_STF_piontracks > 5)       c_STF_piontracks = 5;
  if (c_STF_spurioustracks > 5)   c_STF_spurioustracks = 5;
  if (c_STF_conversiontracks > 5) c_STF_conversiontracks = 5;

  if (c_all_piontracks > 5)       c_all_piontracks = 5;
  if (c_all_spurioustracks > 5)   c_all_spurioustracks = 5;
  if (c_all_conversiontracks > 5) c_all_conversiontracks = 5;

  ++n_table_all_1[in_truthProng][c_nProngs][c_all][c_all_piontracks][c_all_spurioustracks][c_all_conversiontracks];
  ++n_table_noconv_1[in_truthProng][c_nProngs][c_noconv][c_noconv_piontracks][c_noconv_spurioustracks][c_noconv_conversiontracks];
  ++n_table_noconv_STF_1[in_truthProng][c_nProngs][c_noconv_STF][c_noconv_STF_piontracks][c_noconv_STF_spurioustracks][c_noconv_STF_conversiontracks];
  ++n_table_STF_1[in_truthProng][c_nProngs][c_STF][c_STF_piontracks][c_STF_spurioustracks][c_STF_conversiontracks];
  ////////////////////////////////////////////////////////
  if (isLoose) {
    int  c_noconv = 0,  c_noconv_STF=0, c_STF=0;
    int  c_noconv_piontracks=0, c_noconv_spurioustracks=0, c_noconv_conversiontracks=0;
    int  c_noconv_STF_piontracks=0, c_noconv_STF_spurioustracks=0, c_noconv_STF_conversiontracks=0;
    int  c_STF_piontracks=0, c_STF_spurioustracks=0, c_STF_conversiontracks=0;
    int  c_all = 0;
    int  c_all_piontracks=0, c_all_spurioustracks=0, c_all_conversiontracks=0;
  
    for (int i=0; i < in_nProngs; ++i) {
      ++c_all;
      if (track_result.at(i) == 0) ++c_all_piontracks;
      if (track_result.at(i) == 1) ++c_all_spurioustracks;
      if (track_result.at(i) == 2) ++c_all_conversiontracks;

      if (track_conversion_tagger_result.at(i) == 0) {
	++c_noconv;
	if (track_result.at(i) == 0) ++c_noconv_piontracks;
	if (track_result.at(i) == 1) ++c_noconv_spurioustracks;
	if (track_result.at(i) == 2) ++c_noconv_conversiontracks;
	
	if (track_STF_result.at(i) == 1) { 
	  ++c_noconv_STF;
	  if (track_result.at(i) == 0) ++c_noconv_STF_piontracks;
	  if (track_result.at(i) == 1) ++c_noconv_STF_spurioustracks;
	  if (track_result.at(i) == 2) ++c_noconv_STF_conversiontracks;
	}
      }
      if (track_STF_result.at(i) == 1) {
	++c_STF; 
	if (track_result.at(i) == 0) ++c_STF_piontracks;
	if (track_result.at(i) == 1) ++c_STF_spurioustracks;
	if (track_result.at(i) == 2) ++c_STF_conversiontracks;
      }
    }
    //
    if (c_noconv > 5)     c_noconv = 5;
    if (c_noconv_STF > 5) c_noconv_STF = 5;
    if (c_STF > 5)        c_STF = 5;
    int  c_nProngs = in_nProngs; if (c_nProngs > 5) c_nProngs = 5;
    //
    ++n_table_noconv_loose[in_truthProng][c_nProngs][c_noconv];
    ++n_table_noconv_STF_loose[in_truthProng][c_nProngs][c_noconv_STF];
    ++n_table_STF_loose[in_truthProng][c_nProngs][c_STF];
    
    if (c_noconv_piontracks > 5)       c_noconv_piontracks = 5;
    if (c_noconv_spurioustracks > 5)   c_noconv_spurioustracks = 5;
    if (c_noconv_conversiontracks > 5) c_noconv_conversiontracks = 5;
    
    if (c_noconv_STF_piontracks > 5)       c_noconv_STF_piontracks = 5;
    if (c_noconv_STF_spurioustracks > 5)   c_noconv_STF_spurioustracks = 5;
    if (c_noconv_STF_conversiontracks > 5) c_noconv_STF_conversiontracks = 5;
    
    if (c_STF_piontracks > 5)       c_STF_piontracks = 5;
    if (c_STF_spurioustracks > 5)   c_STF_spurioustracks = 5;
    if (c_STF_conversiontracks > 5) c_STF_conversiontracks = 5;

    if (c_all_piontracks > 5)       c_all_piontracks = 5;
    if (c_all_spurioustracks > 5)   c_all_spurioustracks = 5;
    if (c_all_conversiontracks > 5) c_all_conversiontracks = 5;

    ++n_table_all_loose_1[in_truthProng][c_nProngs][c_all][c_all_piontracks][c_all_spurioustracks][c_all_conversiontracks];
    ++n_table_noconv_loose_1[in_truthProng][c_nProngs][c_noconv][c_noconv_piontracks][c_noconv_spurioustracks][c_noconv_conversiontracks];
    ++n_table_noconv_STF_loose_1[in_truthProng][c_nProngs][c_noconv_STF][c_noconv_STF_piontracks][c_noconv_STF_spurioustracks][c_noconv_STF_conversiontracks];
    ++n_table_STF_loose_1[in_truthProng][c_nProngs][c_STF][c_STF_piontracks][c_STF_spurioustracks][c_STF_conversiontracks];
    
  }
  if (isMedium) {
    int  c_noconv = 0,  c_noconv_STF=0, c_STF=0;
    int  c_noconv_piontracks=0, c_noconv_spurioustracks=0, c_noconv_conversiontracks=0;
    int  c_noconv_STF_piontracks=0, c_noconv_STF_spurioustracks=0, c_noconv_STF_conversiontracks=0;
    int  c_STF_piontracks=0, c_STF_spurioustracks=0, c_STF_conversiontracks=0;
    int  c_all = 0;
    int  c_all_piontracks=0, c_all_spurioustracks=0, c_all_conversiontracks=0;
    
    for (int i=0; i < in_nProngs; ++i) {
      ++c_all;
      if (track_result.at(i) == 0) ++c_all_piontracks;
      if (track_result.at(i) == 1) ++c_all_spurioustracks;
      if (track_result.at(i) == 2) ++c_all_conversiontracks;

      if (track_conversion_tagger_result.at(i) == 0) {
	++c_noconv;
	if (track_result.at(i) == 0) ++c_noconv_piontracks;
	if (track_result.at(i) == 1) ++c_noconv_spurioustracks;
	if (track_result.at(i) == 2) ++c_noconv_conversiontracks;
	
	if (track_STF_result.at(i) == 1) { 
	  ++c_noconv_STF;
	  if (track_result.at(i) == 0) ++c_noconv_STF_piontracks;
	  if (track_result.at(i) == 1) ++c_noconv_STF_spurioustracks;
	  if (track_result.at(i) == 2) ++c_noconv_STF_conversiontracks;
	}
      }
      if (track_STF_result.at(i) == 1) {
	++c_STF; 
	if (track_result.at(i) == 0) ++c_STF_piontracks;
	if (track_result.at(i) == 1) ++c_STF_spurioustracks;
	if (track_result.at(i) == 2) ++c_STF_conversiontracks;
      }
    }
    //
    if (c_noconv > 5)     c_noconv = 5;
    if (c_noconv_STF > 5) c_noconv_STF = 5;
    if (c_STF > 5)        c_STF = 5;
    int  c_nProngs = in_nProngs; if (c_nProngs > 5) c_nProngs = 5;
    //
    ++n_table_noconv_medium[in_truthProng][c_nProngs][c_noconv];
    ++n_table_noconv_STF_medium[in_truthProng][c_nProngs][c_noconv_STF];
    ++n_table_STF_medium[in_truthProng][c_nProngs][c_STF];
    
    if (c_noconv_piontracks > 5)       c_noconv_piontracks = 5;
    if (c_noconv_spurioustracks > 5)   c_noconv_spurioustracks = 5;
    if (c_noconv_conversiontracks > 5) c_noconv_conversiontracks = 5;
    
    if (c_noconv_STF_piontracks > 5)       c_noconv_STF_piontracks = 5;
    if (c_noconv_STF_spurioustracks > 5)   c_noconv_STF_spurioustracks = 5;
    if (c_noconv_STF_conversiontracks > 5) c_noconv_STF_conversiontracks = 5;
    
    if (c_STF_piontracks > 5)       c_STF_piontracks = 5;
    if (c_STF_spurioustracks > 5)   c_STF_spurioustracks = 5;
    if (c_STF_conversiontracks > 5) c_STF_conversiontracks = 5;

    if (c_all_piontracks > 5)       c_all_piontracks = 5;
    if (c_all_spurioustracks > 5)   c_all_spurioustracks = 5;
    if (c_all_conversiontracks > 5) c_all_conversiontracks = 5;

    ++n_table_all_medium_1[in_truthProng][c_nProngs][c_all][c_all_piontracks][c_all_spurioustracks][c_all_conversiontracks];   
    ++n_table_noconv_medium_1[in_truthProng][c_nProngs][c_noconv][c_noconv_piontracks][c_noconv_spurioustracks][c_noconv_conversiontracks];
    ++n_table_noconv_STF_medium_1[in_truthProng][c_nProngs][c_noconv_STF][c_noconv_STF_piontracks][c_noconv_STF_spurioustracks][c_noconv_STF_conversiontracks];
    ++n_table_STF_medium_1[in_truthProng][c_nProngs][c_STF][c_STF_piontracks][c_STF_spurioustracks][c_STF_conversiontracks];
    

  }
  if (isTight) {
    int  c_noconv = 0,  c_noconv_STF=0, c_STF=0;
    int  c_noconv_piontracks=0, c_noconv_spurioustracks=0, c_noconv_conversiontracks=0;
    int  c_noconv_STF_piontracks=0, c_noconv_STF_spurioustracks=0, c_noconv_STF_conversiontracks=0;
    int  c_STF_piontracks=0, c_STF_spurioustracks=0, c_STF_conversiontracks=0;
    int  c_all = 0;
    int  c_all_piontracks=0, c_all_spurioustracks=0, c_all_conversiontracks=0;
    
    for (int i=0; i < in_nProngs; ++i) {
      ++c_all;
      if (track_result.at(i) == 0) ++c_all_piontracks;
      if (track_result.at(i) == 1) ++c_all_spurioustracks;
      if (track_result.at(i) == 2) ++c_all_conversiontracks;

      if (track_conversion_tagger_result.at(i) == 0) {
	++c_noconv;
	if (track_result.at(i) == 0) ++c_noconv_piontracks;
	if (track_result.at(i) == 1) ++c_noconv_spurioustracks;
	if (track_result.at(i) == 2) ++c_noconv_conversiontracks;
	
	if (track_STF_result.at(i) == 1) { 
	  ++c_noconv_STF;
	  if (track_result.at(i) == 0) ++c_noconv_STF_piontracks;
	  if (track_result.at(i) == 1) ++c_noconv_STF_spurioustracks;
	  if (track_result.at(i) == 2) ++c_noconv_STF_conversiontracks;
	}
      }
      if (track_STF_result.at(i) == 1) {
	++c_STF; 
	if (track_result.at(i) == 0) ++c_STF_piontracks;
	if (track_result.at(i) == 1) ++c_STF_spurioustracks;
	if (track_result.at(i) == 2) ++c_STF_conversiontracks;
      }
    }
    //
    if (c_noconv > 5)     c_noconv = 5;
    if (c_noconv_STF > 5) c_noconv_STF = 5;
    if (c_STF > 5)        c_STF = 5;
    int  c_nProngs = in_nProngs; if (c_nProngs > 5) c_nProngs = 5;
    //
    ++n_table_noconv_tight[in_truthProng][c_nProngs][c_noconv];
    ++n_table_noconv_STF_tight[in_truthProng][c_nProngs][c_noconv_STF];
    ++n_table_STF_tight[in_truthProng][c_nProngs][c_STF];
    
    if (c_noconv_piontracks > 5)       c_noconv_piontracks = 5;
    if (c_noconv_spurioustracks > 5)   c_noconv_spurioustracks = 5;
    if (c_noconv_conversiontracks > 5) c_noconv_conversiontracks = 5;
    
    if (c_noconv_STF_piontracks > 5)       c_noconv_STF_piontracks = 5;
    if (c_noconv_STF_spurioustracks > 5)   c_noconv_STF_spurioustracks = 5;
    if (c_noconv_STF_conversiontracks > 5) c_noconv_STF_conversiontracks = 5;
    
    if (c_STF_piontracks > 5)       c_STF_piontracks = 5;
    if (c_STF_spurioustracks > 5)   c_STF_spurioustracks = 5;
    if (c_STF_conversiontracks > 5) c_STF_conversiontracks = 5;

    if (c_all_piontracks > 5)       c_all_piontracks = 5;
    if (c_all_spurioustracks > 5)   c_all_spurioustracks = 5;
    if (c_all_conversiontracks > 5) c_all_conversiontracks = 5;

    ++n_table_all_tight_1[in_truthProng][c_nProngs][c_all][c_all_piontracks][c_all_spurioustracks][c_all_conversiontracks];
    
    ++n_table_noconv_tight_1[in_truthProng][c_nProngs][c_noconv][c_noconv_piontracks][c_noconv_spurioustracks][c_noconv_conversiontracks];
    ++n_table_noconv_STF_tight_1[in_truthProng][c_nProngs][c_noconv_STF][c_noconv_STF_piontracks][c_noconv_STF_spurioustracks][c_noconv_STF_conversiontracks];
    ++n_table_STF_tight_1[in_truthProng][c_nProngs][c_STF][c_STF_piontracks][c_STF_spurioustracks][c_STF_conversiontracks];
  }

  ////////////////////////////////////////////////////////
  if (in_truthProng == 1) {
    if (in_nProngs == 0) {
      return;
    }
    else if (in_nProngs == 1) {
      // 1-track taus here
      int track_quality = track_result.at(0);
      if (in_nProngs_filter == 0) {
	++n_1p_migr_1t_0ft; ++n_1p_migr_1t_0ft_tq[track_quality]; 
	if (isLoose)  {++n_1p_migr_1t_0ft_loose; ++n_1p_migr_1t_0ft_tq_loose[track_quality]; }
	if (isMedium) {++n_1p_migr_1t_0ft_medium; ++n_1p_migr_1t_0ft_tq_medium[track_quality]; }
	if (isTight)  {++n_1p_migr_1t_0ft_tight; ++n_1p_migr_1t_0ft_tq_tight[track_quality]; }
      }
      else if (in_nProngs_filter == 1) {
	++n_1p_migr_1t_1ft;
	++n_1p_migr_1t_1ft_tq[track_quality]; ++n_1p_migr_1t_1ft_tq_[track_quality][in_nConvTracks]; 
	if (isLoose)  {++n_1p_migr_1t_1ft_loose;  ++n_1p_migr_1t_1ft_tq_loose[track_quality];  ++n_1p_migr_1t_1ft_tq_loose_[track_quality][in_nConvTracks]; }
	if (isMedium) {++n_1p_migr_1t_1ft_medium; ++n_1p_migr_1t_1ft_tq_medium[track_quality]; ++n_1p_migr_1t_1ft_tq_medium_[track_quality][in_nConvTracks];}
	if (isTight)  {++n_1p_migr_1t_1ft_tight;  ++n_1p_migr_1t_1ft_tq_tight[track_quality];  ++n_1p_migr_1t_1ft_tq_tight_[track_quality][in_nConvTracks]; }
      }
      ++n_1p_migr_1t_all;
      ++n_1p_migr_1t[track_quality][in_nProngs_filter][in_nConvTracks];
      if (isLoose)  { ++n_1p_migr_1t_loose[track_quality][in_nProngs_filter][in_nConvTracks];  }
      if (isMedium) { ++n_1p_migr_1t_medium[track_quality][in_nProngs_filter][in_nConvTracks]; }
      if (isTight)  { ++n_1p_migr_1t_tight[track_quality][in_nProngs_filter][in_nConvTracks];  }
      return;
    }
    else if (in_nProngs == 2) {
      int track_quality_1 = track_result.at(0);
      int track_quality_2 = track_result.at(1);
      int n_pion_tracks = int(track_quality_1==0) + int(track_quality_2==0);
      if (in_nProngs_filter == 0) {
	++n_1p_migr_2t_0ft; ++n_1p_migr_2t_0ft_tq[n_pion_tracks]; // number or cases with 0, 1, 2 true pion tracks
	if (isLoose)  {++n_1p_migr_2t_0ft_loose;  ++n_1p_migr_2t_0ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_2t_0ft_medium; ++n_1p_migr_2t_0ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_2t_0ft_tight;  ++n_1p_migr_2t_0ft_tq_tight[n_pion_tracks];}
	//return;
      }
      if (in_nProngs_filter == 1) {
	++n_1p_migr_2t_1ft; ++n_1p_migr_2t_1ft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_2t_1ft_loose;  ++n_1p_migr_2t_1ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_2t_1ft_medium; ++n_1p_migr_2t_1ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_2t_1ft_tight;  ++n_1p_migr_2t_1ft_tq_tight[n_pion_tracks];}
      }
      if (in_nProngs_filter == 2) {
	++n_1p_migr_2t_2ft; ++n_1p_migr_2t_2ft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_2t_2ft_loose;  ++n_1p_migr_2t_2ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_2t_2ft_medium; ++n_1p_migr_2t_2ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_2t_2ft_tight;  ++n_1p_migr_2t_2ft_tq_tight[n_pion_tracks];}
      }
      // fill in the monster[3][3][3]
      ++n_1p_migr_2t[track_quality_1][track_quality_2][in_nProngs_filter];
      if (isLoose)  {++n_1p_migr_2t_loose[track_quality_1][track_quality_2][in_nProngs_filter];}
      if (isMedium) {++n_1p_migr_2t_medium[track_quality_1][track_quality_2][in_nProngs_filter];}
      if (isTight)  {++n_1p_migr_2t_tight[track_quality_1][track_quality_2][in_nProngs_filter];}
      // now redo the name thing, but add the number of conversion tracks
      ++n_1p_migr_2t_[track_quality_1][track_quality_2][in_nProngs_filter][in_nConvTracks];
      if (isLoose)  {++n_1p_migr_2t_loose_[track_quality_1][track_quality_2][in_nProngs_filter][in_nConvTracks];}
      if (isMedium) {++n_1p_migr_2t_medium_[track_quality_1][track_quality_2][in_nProngs_filter][in_nConvTracks];}
      if (isTight)  {++n_1p_migr_2t_tight_[track_quality_1][track_quality_2][in_nProngs_filter][in_nConvTracks];}

      return;
    }
    else if (in_nProngs == 3) {
      int track_quality_1 = track_result.at(0);
      int track_quality_2 = track_result.at(1);
      int track_quality_3 = track_result.at(2);
      int n_pion_tracks = int(track_quality_1==0) + int(track_quality_2==0) + int(track_quality_3==0);
      if (in_nProngs_filter == 0) {
	++n_1p_migr_3t_0ft; ++n_1p_migr_3t_0ft_tq[n_pion_tracks]; 
	if (isLoose)  {++n_1p_migr_3t_0ft_loose;  ++n_1p_migr_3t_0ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_3t_0ft_medium; ++n_1p_migr_3t_0ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_3t_0ft_tight;  ++n_1p_migr_3t_0ft_tq_tight[n_pion_tracks];}
	return;}
      if (in_nProngs_filter == 1) {
	++n_1p_migr_3t_1ft; ++n_1p_migr_3t_1ft_tq[n_pion_tracks];  
	if (isLoose)  {++n_1p_migr_3t_1ft_loose;  ++n_1p_migr_3t_1ft_tq_loose[n_pion_tracks];  }
	if (isMedium) {++n_1p_migr_3t_1ft_medium; ++n_1p_migr_3t_1ft_tq_medium[n_pion_tracks];  }
	if (isTight)  {++n_1p_migr_3t_1ft_tight;  ++n_1p_migr_3t_1ft_tq_tight[n_pion_tracks];  }       
	return;}
      if (in_nProngs_filter == 2) {
	++n_1p_migr_3t_2ft; ++n_1p_migr_3t_2ft_tq[n_pion_tracks];  
	if (isLoose)  {++n_1p_migr_3t_2ft_loose;  ++n_1p_migr_3t_2ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_3t_2ft_medium; ++n_1p_migr_3t_2ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_3t_2ft_tight;  ++n_1p_migr_3t_2ft_tq_tight[n_pion_tracks];}
	return;}
      if (in_nProngs_filter == 3) {
	++n_1p_migr_3t_3ft; ++n_1p_migr_3t_3ft_tq[n_pion_tracks];  
	if (isLoose)  {++n_1p_migr_3t_3ft_loose;  ++n_1p_migr_3t_3ft_tq_loose[n_pion_tracks]; }
	if (isMedium) {++n_1p_migr_3t_3ft_medium; ++n_1p_migr_3t_3ft_tq_medium[n_pion_tracks]; }
	if (isTight)  {++n_1p_migr_3t_3ft_tight;  ++n_1p_migr_3t_3ft_tq_tight[n_pion_tracks]; }
	return;}
    }
    else {
      int n_pion_tracks = 0;
      for (int i=0; i<track_result.size(); ++i) {
	n_pion_tracks += int(track_result.at(0) == 0);
      }      
      if (n_pion_tracks >4) n_pion_tracks = 4;
      if (in_nProngs_filter == 0) {
	++n_1p_migr_Nt_0ft; ++n_1p_migr_Nt_0ft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_Nt_0ft_loose; ++n_1p_migr_Nt_0ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_Nt_0ft_medium; ++n_1p_migr_Nt_0ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_Nt_0ft_tight; ++n_1p_migr_Nt_0ft_tq_tight[n_pion_tracks];}
	return;}
      if (in_nProngs_filter == 1) {
	++n_1p_migr_Nt_1ft; ++n_1p_migr_Nt_1ft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_Nt_1ft_loose; ++n_1p_migr_Nt_1ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_Nt_1ft_medium; ++n_1p_migr_Nt_1ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_Nt_1ft_tight; ++n_1p_migr_Nt_1ft_tq_tight[n_pion_tracks];}	
	return;}
      if (in_nProngs_filter == 2) {
	++n_1p_migr_Nt_2ft; ++n_1p_migr_Nt_2ft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_Nt_2ft_loose; ++n_1p_migr_Nt_2ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_Nt_2ft_medium; ++n_1p_migr_Nt_2ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_Nt_2ft_tight; ++n_1p_migr_Nt_2ft_tq_tight[n_pion_tracks];}
	return;}
      if (in_nProngs_filter == 3) {
	++n_1p_migr_Nt_3ft; ++n_1p_migr_Nt_3ft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_Nt_3ft_loose; ++n_1p_migr_Nt_3ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_Nt_3ft_medium; ++n_1p_migr_Nt_3ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_Nt_3ft_tight; ++n_1p_migr_Nt_3ft_tq_tight[n_pion_tracks];}
	return;}
      if (in_nProngs_filter > 3)  {
	++n_1p_migr_Nt_Nft; ++n_1p_migr_Nt_Nft_tq[n_pion_tracks];
	if (isLoose)  {++n_1p_migr_Nt_Nft_loose; ++n_1p_migr_Nt_Nft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_1p_migr_Nt_Nft_medium; ++n_1p_migr_Nt_Nft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_1p_migr_Nt_Nft_tight; ++n_1p_migr_Nt_Nft_tq_tight[n_pion_tracks];}
	return;}
    }
  }
  ////////////////////////////////////////////////////////
  if (in_truthProng == 3) {
    if (in_nProngs == 0) {
      return;
    }
    else if (in_nProngs == 1) {
      int track_quality = track_result.at(0);
      if (in_nProngs_filter == 0) {
	++n_3p_migr_1t_0ft;++n_3p_migr_1t_0ft_tq[track_quality];
	if (isLoose)  {++n_3p_migr_1t_0ft_loose;++n_3p_migr_1t_0ft_tq_loose[track_quality];}
	if (isMedium) {++n_3p_migr_1t_0ft_medium;++n_3p_migr_1t_0ft_tq_medium[track_quality];}
	if (isTight)  {++n_3p_migr_1t_0ft_tight;++n_3p_migr_1t_0ft_tq_tight[track_quality];}
	return;}
      if (in_nProngs_filter == 1) {
	++n_3p_migr_1t_1ft;++n_3p_migr_1t_1ft_tq[track_quality];
	if (isLoose)  {++n_3p_migr_1t_1ft_loose;++n_3p_migr_1t_1ft_tq_loose[track_quality];}
	if (isMedium) {++n_3p_migr_1t_1ft_medium;++n_3p_migr_1t_1ft_tq_medium[track_quality];}
	if (isTight)  {++n_3p_migr_1t_1ft_tight;++n_3p_migr_1t_1ft_tq_tight[track_quality];}	
	return;}
    }
    else if (in_nProngs == 2) {
      int track_quality_1 = track_result.at(0);
      int track_quality_2 = track_result.at(1);
      int n_pion_tracks = int(track_quality_1==0) + int(track_quality_2==0);
      if (in_nProngs_filter == 0) {
	++n_3p_migr_2t_0ft; ++n_3p_migr_2t_0ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_2t_0ft_loose; ++n_3p_migr_2t_0ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_2t_0ft_medium; ++n_3p_migr_2t_0ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_2t_0ft_tight; ++n_3p_migr_2t_0ft_tq_tight[n_pion_tracks];}	
      }
      if (in_nProngs_filter == 1) {
	++n_3p_migr_2t_1ft; ++n_3p_migr_2t_1ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_2t_1ft_loose; ++n_3p_migr_2t_1ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_2t_1ft_medium; ++n_3p_migr_2t_1ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_2t_1ft_tight; ++n_3p_migr_2t_1ft_tq_tight[n_pion_tracks];}	
      }
      if (in_nProngs_filter == 2) {
	++n_3p_migr_2t_2ft; ++n_3p_migr_2t_2ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_2t_2ft_loose; ++n_3p_migr_2t_2ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_2t_2ft_medium; ++n_3p_migr_2t_2ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_2t_2ft_tight; ++n_3p_migr_2t_2ft_tq_tight[n_pion_tracks];}	
      }
      ++n_3p_migr_2t[track_quality_1][track_quality_2][in_nProngs_filter];
      if (isLoose)  {++n_3p_migr_2t_loose[track_quality_1][track_quality_2][in_nProngs_filter];}
      if (isMedium) {++n_3p_migr_2t_medium[track_quality_1][track_quality_2][in_nProngs_filter];}
      if (isTight)  {++n_3p_migr_2t_tight[track_quality_1][track_quality_2][in_nProngs_filter];}      
      return;
      
    }
    else if (in_nProngs == 3) {
      int track_quality_1 = track_result.at(0);
      int track_quality_2 = track_result.at(1);
      int track_quality_3 = track_result.at(2);
      int n_pion_tracks = int(track_quality_1==0) + int(track_quality_2==0) + int(track_quality_3==0);
      if (in_nProngs_filter == 0) {
	++n_3p_migr_3t_0ft; ++n_3p_migr_3t_0ft_tq[n_pion_tracks]; 
	if (isLoose)  {++n_3p_migr_3t_0ft_loose; ++n_3p_migr_3t_0ft_tq_loose[n_pion_tracks]; }
	if (isMedium) {++n_3p_migr_3t_0ft_medium; ++n_3p_migr_3t_0ft_tq_medium[n_pion_tracks]; }
	if (isTight)  {++n_3p_migr_3t_0ft_tight; ++n_3p_migr_3t_0ft_tq_tight[n_pion_tracks]; }
	return;}
      if (in_nProngs_filter == 1) {
	++n_3p_migr_3t_1ft; ++n_3p_migr_3t_1ft_tq[n_pion_tracks]; 
	if (isLoose)  {++n_3p_migr_3t_1ft_loose; ++n_3p_migr_3t_1ft_tq_loose[n_pion_tracks]; }
	if (isMedium) {++n_3p_migr_3t_1ft_medium; ++n_3p_migr_3t_1ft_tq_medium[n_pion_tracks]; }
	if (isTight)  {++n_3p_migr_3t_1ft_tight; ++n_3p_migr_3t_1ft_tq_tight[n_pion_tracks]; }	
	return;}
      if (in_nProngs_filter == 2) {
	++n_3p_migr_3t_2ft; ++n_3p_migr_3t_2ft_tq[n_pion_tracks]; 
	if (isLoose)  {++n_3p_migr_3t_2ft_loose; ++n_3p_migr_3t_2ft_tq_loose[n_pion_tracks]; }
	if (isMedium) {++n_3p_migr_3t_2ft_medium; ++n_3p_migr_3t_2ft_tq_medium[n_pion_tracks]; }
	if (isTight)  {++n_3p_migr_3t_2ft_tight; ++n_3p_migr_3t_2ft_tq_tight[n_pion_tracks]; }	
	return;}
      if (in_nProngs_filter == 3) {
	++n_3p_migr_3t_3ft; ++n_3p_migr_3t_3ft_tq[n_pion_tracks]; 
	if (isLoose)  {++n_3p_migr_3t_3ft_loose; ++n_3p_migr_3t_3ft_tq_loose[n_pion_tracks]; }
	if (isMedium) {++n_3p_migr_3t_3ft_medium; ++n_3p_migr_3t_3ft_tq_medium[n_pion_tracks]; }
	if (isTight)  {++n_3p_migr_3t_3ft_tight; ++n_3p_migr_3t_3ft_tq_tight[n_pion_tracks]; }	
	return;}
    }
    else {
      int n_pion_tracks = 0;
      for (int i=0; i<track_result.size(); ++i) {
	n_pion_tracks += int(track_result.at(i) == 0);
      }
      if (n_pion_tracks >4) n_pion_tracks = 4;
      if (in_nProngs_filter == 0) {
	++n_3p_migr_Nt_0ft; ++n_3p_migr_Nt_0ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_Nt_0ft_loose; ++n_3p_migr_Nt_0ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_Nt_0ft_medium; ++n_3p_migr_Nt_0ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_Nt_0ft_tight; ++n_3p_migr_Nt_0ft_tq_tight[n_pion_tracks];}	
	return;}
      if (in_nProngs_filter == 1) {
	++n_3p_migr_Nt_1ft; ++n_3p_migr_Nt_1ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_Nt_1ft_loose; ++n_3p_migr_Nt_1ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_Nt_1ft_medium; ++n_3p_migr_Nt_1ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_Nt_1ft_tight; ++n_3p_migr_Nt_1ft_tq_tight[n_pion_tracks];}		
	return;}
      if (in_nProngs_filter == 2) {
	++n_3p_migr_Nt_2ft; ++n_3p_migr_Nt_2ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_Nt_2ft_loose; ++n_3p_migr_Nt_2ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_Nt_2ft_medium; ++n_3p_migr_Nt_2ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_Nt_2ft_tight; ++n_3p_migr_Nt_2ft_tq_tight[n_pion_tracks];}		
	return;}
      if (in_nProngs_filter == 3) {
	++n_3p_migr_Nt_3ft; ++n_3p_migr_Nt_3ft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_Nt_3ft_loose; ++n_3p_migr_Nt_3ft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_Nt_3ft_medium; ++n_3p_migr_Nt_3ft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_Nt_3ft_tight; ++n_3p_migr_Nt_3ft_tq_tight[n_pion_tracks];}		
	return;}
      if (in_nProngs_filter >3  ) {
	++n_3p_migr_Nt_Nft; ++n_3p_migr_Nt_Nft_tq[n_pion_tracks];
	if (isLoose)  {++n_3p_migr_Nt_Nft_loose; ++n_3p_migr_Nt_Nft_tq_loose[n_pion_tracks];}
	if (isMedium) {++n_3p_migr_Nt_Nft_medium; ++n_3p_migr_Nt_Nft_tq_medium[n_pion_tracks];}
	if (isTight)  {++n_3p_migr_Nt_Nft_tight; ++n_3p_migr_Nt_Nft_tq_tight[n_pion_tracks];}		
	return;}
    }
  }
  
}

EL::StatusCode MyxAODAnalysis :: postExecute ()
{
  // Here you do everything that needs to be done after the main event
  // processing.  This is typically very rare, particularly in user
  // code.  It is mainly used in implementing the NTupleSvc.
  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: finalize ()
{
  // This method is the mirror image of initialize(), meaning it gets
  // called after the last event has been processed on the worker node
  // and allows you to finish up any objects you created in
  // initialize() before they are written to disk.  This is actually
  // fairly rare, since this happens separately for each worker node.
  // Most of the time you want to do your post-processing on the
  // submission node after all your histogram outputs have been
  // merged.  This is different from histFinalize() in that it only
  // gets called on worker nodes that processed input events.

  // Info("finalize()", " I have accessed  %i taus and select %i of them", n_taus_total, n_taus_selected);
  // Info("finalize()", " Truth-matched taus: %i (or %f in pc)", n_taus_truthmatched, 100.*n_taus_truthmatched/n_taus_selected);
  // Info("finalize()", " Truth-matched taus: %i (or %f in pc)", n_taus_truthmatched_1, 100.*n_taus_truthmatched_1/n_taus_selected);
  // Info("finalize()", " Total tracks: %i", n_tau_tracks);
  // Info("finalize()", " Total tracks: real/matched   %i (%f in pc)", n_tau_tracks_real_matched,  100.*n_tau_tracks_real_matched/n_tau_tracks);
  // Info("finalize()", " Total tracks: real/!matched  %i (%f in pc)", n_tau_tracks_real_notmatched, 100.*n_tau_tracks_real_notmatched/n_tau_tracks);
  // Info("finalize()", " Total tracks: spur/matched   %i (%f in pc)", n_tau_tracks_spur_matched, 100.*n_tau_tracks_spur_matched /n_tau_tracks);
  // Info("finalize()", " Total tracks: spur/!matched  %i (%f in pc)", n_tau_tracks_spur_notmatched, 100.*n_tau_tracks_spur_notmatched /n_tau_tracks);
  
  Info("finalize()", " I have accessed  %i taus; selected: %i truth-matched: %i eff: %f", 
       n_taus_total, n_taus_selected, n_taus_truthmatched, 100.*n_taus_truthmatched/double(n_taus_selected)); 
  Info("finalize()", " TM: 1-prong %i  3-prong %i", n_1p_true_true_taus, n_3p_true_true_taus);
  Info("finalize()", " TM: 1-prong %i  : 1-track %i  2-track %i  3-track: %i n-track: %i ; trackFilterProng 1: %i  2: %i  3: %i  >4: %i 0: %i", 
       n_1p_true_true_taus, n_1p_true_true_taus_reco1p, 
       n_1p_true_true_taus_reco2p, n_1p_true_true_taus_reco3p, n_1p_true_true_taus_recoNp, 
       n_1p_true_true_taus_trackFilterProngs_1, n_1p_true_true_taus_trackFilterProngs_2,
       n_1p_true_true_taus_trackFilterProngs_3, n_1p_true_true_taus_trackFilterProngs_4,
       n_1p_true_true_taus_trackFilterProngs_0        );
  Info("finalize()", " TM: 3-prong %i  : 1-track %i  2-track %i  3-track: %i n-track: %i ; trackFilterProng 1: %i 2: %i 3: %i >4: %i 0: %i", 
       n_3p_true_true_taus, n_3p_true_true_taus_reco1p, 
       n_3p_true_true_taus_reco2p, n_3p_true_true_taus_reco3p, n_3p_true_true_taus_recoNp, 
       n_3p_true_true_taus_trackFilterProngs_1, n_3p_true_true_taus_trackFilterProngs_2,
       n_3p_true_true_taus_trackFilterProngs_3, n_3p_true_true_taus_trackFilterProngs_4,
       n_3p_true_true_taus_trackFilterProngs_0);
  Info("finalize()", " TM: 1-prong  All tracks vs pion tracks vs conversion vs other vs not-hadronic : %7i :  %7i : %7i : %7i : %7i", n_1p_all_tracks,
       n_1p_true_pion_tracks, n_1p_true_spurious_conversion_tracks, n_1p_true_spurious_tracks-n_1p_true_spurious_conversion_tracks-n_1p_true_spurious_not_hadronic_tracks,
       n_1p_true_spurious_not_hadronic_tracks);
  Info("finalize()", " TM: 3-prong  All tracks vs pion tracks vs conversion vs other vs not-hadronic : %7i :  %7i : %7i : %7i : %7i", n_3p_all_tracks,
       n_3p_true_pion_tracks, n_3p_true_spurious_conversion_tracks, n_3p_true_spurious_tracks-n_3p_true_spurious_conversion_tracks-n_3p_true_spurious_not_hadronic_tracks,
       n_3p_true_spurious_not_hadronic_tracks);

  Info("finalize()", " TM: 1-prong  Correct track classication prob. pion tracks vs sp. conversion vs  sp. other vs not-hadronic: %7.5f : %7.5f :  %7.5f : %7.5f ", 
       n_1p_true_pion_tracks_passfilter/double(n_1p_true_pion_tracks), 
       n_1p_true_spurious_conversion_tracks_passfilter/double(n_1p_true_spurious_conversion_tracks), 
       (n_1p_true_spurious_tracks_passfilter-n_1p_true_spurious_conversion_tracks_passfilter-n_1p_true_spurious_not_hadronic_tracks_passfilter) / double(n_1p_true_spurious_tracks-n_1p_true_spurious_conversion_tracks-n_1p_true_spurious_not_hadronic_tracks),n_1p_true_spurious_not_hadronic_tracks_passfilter/double(n_1p_true_spurious_not_hadronic_tracks) );

  Info("finalize()", " TM: 3-prong  Correct track classication prob. pion tracks vs sp. conversion vs  sp. other vs not-hadronic: %7.5f : %7.5f : %7.5f : %7.5f ", 
       n_3p_true_pion_tracks_passfilter/double(n_3p_true_pion_tracks), 
       n_3p_true_spurious_conversion_tracks_passfilter/double(n_3p_true_spurious_conversion_tracks), 
       (n_3p_true_spurious_tracks_passfilter-n_3p_true_spurious_conversion_tracks_passfilter-n_3p_true_spurious_conversion_tracks_passfilter-n_3p_true_spurious_not_hadronic_tracks_passfilter) / double(n_3p_true_spurious_tracks-n_3p_true_spurious_conversion_tracks-n_3p_true_spurious_not_hadronic_tracks),n_3p_true_spurious_not_hadronic_tracks_passfilter/double(n_3p_true_spurious_not_hadronic_tracks) );
  //Info("finalize()", "test: %i   %i", n_3p_true_spurious_not_hadronic_tracks_passfilter, n_3p_true_spurious_not_hadronic_tracks);



  // migration study here:
  Info("finalize()", "Migration study:"); 
  Info("finalize()", "1-prong taus: %8i   0-track: %8i", n_1p_true_true_taus, n_1p_true_true_taus_reco0p); 
  Info("finalize()", "                         1-track: %8i  -> 0-ftr: %5i   1-ftr: %5i",
       n_1p_true_true_taus_reco1p, n_1p_migr_1t_0ft, n_1p_migr_1t_1ft); 
  Info("finalize()", "                         2-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i",
       n_1p_true_true_taus_reco2p, n_1p_migr_2t_0ft, n_1p_migr_2t_1ft, n_1p_migr_2t_2ft); 
  Info("finalize()", "                         3-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i",
       n_1p_true_true_taus_reco3p, n_1p_migr_3t_0ft, n_1p_migr_3t_1ft, n_1p_migr_3t_2ft, n_1p_migr_3t_3ft); 
  Info("finalize()", "                         N-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i   N-ftr: %5i",
       n_1p_true_true_taus_recoNp, n_1p_migr_Nt_0ft, n_1p_migr_Nt_1ft, n_1p_migr_Nt_2ft, n_1p_migr_Nt_3ft, n_1p_migr_Nt_Nft); 



  Info("finalize()", "3-prong taus: %8i   0-track: %8i", n_3p_true_true_taus, n_3p_true_true_taus_reco0p); 
  Info("finalize()", "                         1-track: %8i  -> 0-ftr: %5i   1-ftr: %5i",
       n_3p_true_true_taus_reco1p, n_3p_migr_1t_0ft, n_3p_migr_1t_1ft); 
  Info("finalize()", "                         2-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i",
       n_3p_true_true_taus_reco2p, n_3p_migr_2t_0ft, n_3p_migr_2t_1ft, n_3p_migr_2t_2ft); 
  Info("finalize()", "                         3-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i",
       n_3p_true_true_taus_reco3p, n_3p_migr_3t_0ft, n_3p_migr_3t_1ft, n_3p_migr_3t_2ft, n_3p_migr_3t_3ft); 
  Info("finalize()", "                         N-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i   N-ftr: %5i",
       n_3p_true_true_taus_recoNp, n_3p_migr_Nt_0ft, n_3p_migr_Nt_1ft, n_3p_migr_Nt_2ft, n_3p_migr_Nt_3ft, n_3p_migr_Nt_Nft); 

  Info("finalize()", "Migration study Statistics:");
  Info("finalize()", "rate 1-prong->0track:    %6.3f",double(n_1p_true_true_taus_reco0p)/double(n_1p_true_true_taus));
  Info("finalize()", "rate 1-prong->1track:    %6.3f",double(n_1p_true_true_taus_reco1p)/double(n_1p_true_true_taus));
  Info("finalize()", "rate 1-prong->(>1)track: %6.3f",double(n_1p_true_true_taus_reco2p+n_1p_true_true_taus_reco3p+n_1p_true_true_taus_recoNp)/double(n_1p_true_true_taus));
  Info("finalize()", "rate          1track->0ftrack:  %6.3f",double(n_1p_migr_1t_0ft)/double(n_1p_true_true_taus_reco1p));
  Info("finalize()", "rate          1track->1ftrack:  %6.3f",double(n_1p_migr_1t_1ft)/double(n_1p_true_true_taus_reco1p));
  Info("finalize()", "rate       (>1)track->1ftrack:  %6.3f",double(n_1p_migr_2t_1ft+n_1p_migr_3t_1ft+n_1p_migr_Nt_1ft)/double(n_1p_true_true_taus_reco2p+n_1p_true_true_taus_reco3p+n_1p_true_true_taus_recoNp));
  Info("finalize()", "Number comparison:  1-prong->1track:  %i ", n_1p_true_true_taus_reco1p);
  Info("finalize()", "Number comparison:  1-prong->1ftrack: %i (%i: %i,%i,%i,%i)", n_1p_true_true_taus_trackFilterProngs_1,  n_1p_migr_1t_1ft+n_1p_migr_2t_1ft+n_1p_migr_3t_1ft+n_1p_migr_Nt_1ft,
       n_1p_migr_1t_1ft, n_1p_migr_2t_1ft, n_1p_migr_3t_1ft, n_1p_migr_Nt_1ft);


  Info("finalize()", "rate 3-prong->0track:    %6.3f",double(n_3p_true_true_taus_reco0p)/double(n_3p_true_true_taus));
  Info("finalize()", "rate 3-prong->1track:    %6.3f",double(n_3p_true_true_taus_reco1p)/double(n_3p_true_true_taus));
  Info("finalize()", "rate 3-prong->2track:    %6.3f",double(n_3p_true_true_taus_reco2p)/double(n_3p_true_true_taus));
  Info("finalize()", "rate 3-prong->3track:    %6.3f",double(n_3p_true_true_taus_reco3p)/double(n_3p_true_true_taus));
  Info("finalize()", "rate 3-prong->(>3)track: %6.3f",double(n_3p_true_true_taus_recoNp)/double(n_3p_true_true_taus));
  Info("finalize()", "rate          3track->0ftrack:  %6.3f",double(n_3p_migr_3t_0ft)/double(n_3p_true_true_taus_reco3p));
  Info("finalize()", "rate          3track->1ftrack:  %6.3f",double(n_3p_migr_3t_1ft)/double(n_3p_true_true_taus_reco3p));
  Info("finalize()", "rate          3track->2ftrack:  %6.3f",double(n_3p_migr_3t_2ft)/double(n_3p_true_true_taus_reco3p));
  Info("finalize()", "rate          3track->3ftrack:  %6.3f",double(n_3p_migr_3t_3ft)/double(n_3p_true_true_taus_reco3p));
  Info("finalize()", "Number comparison:  3-prong->3track:  %i ", n_3p_true_true_taus_reco3p);
  Info("finalize()", "Number comparison:  3-prong->3ftrack: %i (%i: %i,%i)", n_3p_true_true_taus_trackFilterProngs_3,  n_3p_migr_3t_3ft+n_3p_migr_Nt_3ft, 
       n_3p_migr_3t_3ft, n_3p_migr_Nt_3ft);

  Info("finalize()", "Migration study: True pion tracks");
  
  Info("finalize()", "Migration study:"); 
  Info("finalize()", "1-prong taus: %8i   0-track: %8i", n_1p_true_true_taus, n_1p_true_true_taus_reco0p); 
  Info("finalize()", "                         1-track: %8i  -> 0-ftr: %5i   1-ftr: %5i",
       n_1p_true_true_taus_reco1p, n_1p_migr_1t_0ft, n_1p_migr_1t_1ft); 
  Info("finalize()", "  1 true pion track      1-track: %8i  -> 0-ftr: %5i   1-ftr: %5i",
       n_1p_migr_1t_0ft_tq[0]+n_1p_migr_1t_1ft_tq[0],  n_1p_migr_1t_0ft_tq[0], n_1p_migr_1t_1ft_tq[0]);
  Info("finalize()", "                         2-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i",
       n_1p_true_true_taus_reco2p, n_1p_migr_2t_0ft, n_1p_migr_2t_1ft, n_1p_migr_2t_2ft); 
  Info("finalize()", "  1 true pion track      2-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i",
       n_1p_migr_2t_0ft_tq[1]+n_1p_migr_2t_1ft_tq[1]+n_1p_migr_2t_2ft_tq[1], 
       n_1p_migr_2t_0ft_tq[1],n_1p_migr_2t_1ft_tq[1],n_1p_migr_2t_2ft_tq[1]);
  Info("finalize()", "                         3-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i",
       n_1p_true_true_taus_reco3p, n_1p_migr_3t_0ft, n_1p_migr_3t_1ft, n_1p_migr_3t_2ft, n_1p_migr_3t_3ft); 
  Info("finalize()", "  1 true pion track      3-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i",
       n_1p_migr_3t_0ft_tq[1]+n_1p_migr_3t_1ft_tq[1]+n_1p_migr_3t_2ft_tq[1]+n_1p_migr_3t_3ft_tq[1], 
       n_1p_migr_3t_0ft_tq[1],n_1p_migr_3t_1ft_tq[1],n_1p_migr_3t_2ft_tq[1],n_1p_migr_3t_3ft_tq[1]);
  Info("finalize()", "                         N-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i   N-ftr: %5i",
       n_1p_true_true_taus_recoNp, n_1p_migr_Nt_0ft, n_1p_migr_Nt_1ft, n_1p_migr_Nt_2ft, n_1p_migr_Nt_3ft, n_1p_migr_Nt_Nft); 

  Info("finalize()", "3-prong taus: %8i   0-track: %8i", n_3p_true_true_taus, n_3p_true_true_taus_reco0p); 
  Info("finalize()", "                         1-track: %8i  -> 0-ftr: %5i   1-ftr: %5i",
       n_3p_true_true_taus_reco1p, n_3p_migr_1t_0ft, n_3p_migr_1t_1ft); 
  Info("finalize()", "  1 true pion track      1-track: %8i  -> 0-ftr: %5i   1-ftr: %5i",
       n_3p_migr_1t_0ft_tq[0]+n_3p_migr_1t_1ft_tq[0],  n_3p_migr_1t_0ft_tq[0], n_3p_migr_1t_1ft_tq[0]);
  Info("finalize()", "                         2-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i",
       n_3p_true_true_taus_reco2p, n_3p_migr_2t_0ft, n_3p_migr_2t_1ft, n_3p_migr_2t_2ft); 
  Info("finalize()", "  2 true pion tracks     2-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i",
       n_3p_migr_2t_0ft_tq[2]+n_3p_migr_2t_1ft_tq[2]+n_3p_migr_2t_2ft_tq[2], 
       n_3p_migr_2t_0ft_tq[2],n_3p_migr_2t_1ft_tq[2],n_3p_migr_2t_2ft_tq[2]);
  Info("finalize()", "                         3-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i",
       n_3p_true_true_taus_reco3p, n_3p_migr_3t_0ft, n_3p_migr_3t_1ft, n_3p_migr_3t_2ft, n_3p_migr_3t_3ft); 
  Info("finalize()", "  3 true pion tracks     3-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i",
       n_3p_migr_3t_0ft_tq[3]+n_3p_migr_3t_1ft_tq[3]+n_3p_migr_3t_2ft_tq[3]+n_3p_migr_3t_3ft_tq[3], 
       n_3p_migr_3t_0ft_tq[3],n_3p_migr_3t_1ft_tq[3],n_3p_migr_3t_2ft_tq[3], n_3p_migr_3t_3ft_tq[3]);
  Info("finalize()", "                         N-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i   N-ftr: %5i",
       n_3p_true_true_taus_recoNp, n_3p_migr_Nt_0ft, n_3p_migr_Nt_1ft, n_3p_migr_Nt_2ft, n_3p_migr_Nt_3ft, n_3p_migr_Nt_Nft); 
  Info("finalize()", "  3 true pion tracks     N-track: %8i  -> 0-ftr: %5i   1-ftr: %5i   2-ftr: %5i   3-ftr: %5i   N-ftr: %5i",
       n_3p_migr_Nt_0ft_tq[3]+n_3p_migr_Nt_1ft_tq[3]+n_3p_migr_Nt_2ft_tq[3]+n_3p_migr_Nt_3ft_tq[3]+n_3p_migr_Nt_Nft_tq[3], 
       n_3p_migr_Nt_0ft_tq[3],n_3p_migr_Nt_1ft_tq[3],n_3p_migr_Nt_2ft_tq[3],n_3p_migr_Nt_3ft_tq[3],n_3p_migr_Nt_Nft_tq[3]);

  Info("finalize()", "Super-final table: all taus");
  Info("finalize()", "1 prong taus %i from which", n_1p_true_true_taus);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      1-pi-tr    1-ftrack   1-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco0p, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco1p, 
       n_1p_migr_1t_0ft_tq[0]+n_1p_migr_1t_1ft_tq[0], n_1p_migr_1t_1ft,  n_1p_migr_1t_1ft_tq[0]);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco2p, 
       n_1p_migr_2t_0ft_tq[1]+n_1p_migr_2t_1ft_tq[1]+n_1p_migr_2t_2ft_tq[1],
       n_1p_migr_2t_1ft,  n_1p_migr_2t_1ft_tq[1]);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco3p, 
       n_1p_migr_3t_0ft_tq[1]+n_1p_migr_3t_1ft_tq[1]+n_1p_migr_3t_2ft_tq[1]+n_1p_migr_3t_3ft_tq[1],
       n_1p_migr_3t_1ft,  n_1p_migr_3t_1ft_tq[1]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_recoNp, 
       n_1p_migr_Nt_0ft_tq[1]+n_1p_migr_Nt_1ft_tq[1]+n_1p_migr_Nt_2ft_tq[1]+n_1p_migr_Nt_3ft_tq[1]+n_1p_migr_Nt_Nft_tq[1],
       n_1p_migr_Nt_1ft,  n_1p_migr_Nt_1ft_tq[1]);

  Info("finalize()", "3 prong taus %i from which", n_3p_true_true_taus);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      3-pi-tr    3-ftrack   3-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco0p, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco1p, 0,0,0);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco2p, 0,0,0);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco3p, 
       n_3p_migr_3t_0ft_tq[3]+n_3p_migr_3t_1ft_tq[3]+n_3p_migr_3t_2ft_tq[3]+n_3p_migr_3t_3ft_tq[3],
       n_3p_migr_3t_3ft,  n_3p_migr_3t_3ft_tq[3]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_recoNp, 
       n_3p_migr_Nt_0ft_tq[3]+n_3p_migr_Nt_1ft_tq[3]+n_3p_migr_Nt_2ft_tq[3]+n_3p_migr_Nt_3ft_tq[3]+
       n_3p_migr_Nt_Nft_tq[3],
       n_3p_migr_Nt_3ft,  n_3p_migr_Nt_3ft_tq[3]);
  Info("finalize()", " ");
  Info("finalize()", " ");
  //////////////////////////////////////////////////////////////////////////////
  Info("finalize()", "Super-final table: loose taus");
  Info("finalize()", "1 prong taus %i from which", n_1p_true_true_taus_loose);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      1-pi-tr    1-ftrack   1-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco0p_loose, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco1p_loose, 
       n_1p_migr_1t_0ft_tq_loose[0]+n_1p_migr_1t_1ft_tq_loose[0], n_1p_migr_1t_1ft_loose,  n_1p_migr_1t_1ft_tq_loose[0]);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco2p_loose, 
       n_1p_migr_2t_0ft_tq_loose[1]+n_1p_migr_2t_1ft_tq_loose[1]+n_1p_migr_2t_2ft_tq_loose[1],
       n_1p_migr_2t_1ft_loose,  n_1p_migr_2t_1ft_tq_loose[1]);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco3p_loose, 
       n_1p_migr_3t_0ft_tq_loose[1]+n_1p_migr_3t_1ft_tq_loose[1]+n_1p_migr_3t_2ft_tq_loose[1]+n_1p_migr_3t_3ft_tq_loose[1],
       n_1p_migr_3t_1ft_loose,  n_1p_migr_3t_1ft_tq_loose[1]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_recoNp_loose, 
       n_1p_migr_Nt_0ft_tq_loose[1]+n_1p_migr_Nt_1ft_tq_loose[1]+n_1p_migr_Nt_2ft_tq_loose[1]+n_1p_migr_Nt_3ft_tq_loose[1]+n_1p_migr_Nt_Nft_tq_loose[1],
       n_1p_migr_Nt_1ft_loose,  n_1p_migr_Nt_1ft_tq_loose[1]);

  Info("finalize()", "3 prong taus %i from which", n_3p_true_true_taus_loose);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      3-pi-tr    3-ftrack   3-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco0p_loose, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco1p_loose, 0,0,0);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco2p_loose, 0,0,0);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco3p_loose, 
       n_3p_migr_3t_0ft_tq_loose[3]+n_3p_migr_3t_1ft_tq_loose[3]+n_3p_migr_3t_2ft_tq_loose[3]+n_3p_migr_3t_3ft_tq_loose[3],
       n_3p_migr_3t_3ft_loose,  n_3p_migr_3t_3ft_tq_loose[3]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_recoNp_loose, 
       n_3p_migr_Nt_0ft_tq_loose[3]+n_3p_migr_Nt_1ft_tq_loose[3]+n_3p_migr_Nt_2ft_tq_loose[3]+n_3p_migr_Nt_3ft_tq_loose[3]+
       n_3p_migr_Nt_Nft_tq_loose[3],
       n_3p_migr_Nt_3ft_loose,  n_3p_migr_Nt_3ft_tq_loose[3]);
  //////////////////////////////////////////////////////////////////////////////
  Info("finalize()", "Super-final table: medium taus");
  Info("finalize()", "1 prong taus %i from which", n_1p_true_true_taus_medium);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      1-pi-tr    1-ftrack   1-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco0p_medium, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco1p_medium, 
       n_1p_migr_1t_0ft_tq_medium[0]+n_1p_migr_1t_1ft_tq_medium[0], n_1p_migr_1t_1ft_medium,  n_1p_migr_1t_1ft_tq_medium[0]);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco2p_medium, 
       n_1p_migr_2t_0ft_tq_medium[1]+n_1p_migr_2t_1ft_tq_medium[1]+n_1p_migr_2t_2ft_tq_medium[1],
       n_1p_migr_2t_1ft_medium,  n_1p_migr_2t_1ft_tq_medium[1]);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco3p_medium, 
       n_1p_migr_3t_0ft_tq_medium[1]+n_1p_migr_3t_1ft_tq_medium[1]+n_1p_migr_3t_2ft_tq_medium[1]+n_1p_migr_3t_3ft_tq_medium[1],
       n_1p_migr_3t_1ft_medium,  n_1p_migr_3t_1ft_tq_medium[1]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_recoNp_medium, 
       n_1p_migr_Nt_0ft_tq_medium[1]+n_1p_migr_Nt_1ft_tq_medium[1]+n_1p_migr_Nt_2ft_tq_medium[1]+n_1p_migr_Nt_3ft_tq_medium[1]+n_1p_migr_Nt_Nft_tq_medium[1],
       n_1p_migr_Nt_1ft_medium,  n_1p_migr_Nt_1ft_tq_medium[1]);

  Info("finalize()", "3 prong taus %i from which", n_3p_true_true_taus_medium);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      3-pi-tr    3-ftrack   3-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco0p_medium, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco1p_medium, 0,0,0);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco2p_medium, 0,0,0);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco3p_medium, 
       n_3p_migr_3t_0ft_tq_medium[3]+n_3p_migr_3t_1ft_tq_medium[3]+n_3p_migr_3t_2ft_tq_medium[3]+n_3p_migr_3t_3ft_tq_medium[3],
       n_3p_migr_3t_3ft_medium,  n_3p_migr_3t_3ft_tq_medium[3]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_recoNp_medium, 
       n_3p_migr_Nt_0ft_tq_medium[3]+n_3p_migr_Nt_1ft_tq_medium[3]+n_3p_migr_Nt_2ft_tq_medium[3]+n_3p_migr_Nt_3ft_tq_medium[3]+
       n_3p_migr_Nt_Nft_tq_medium[3],
       n_3p_migr_Nt_3ft_medium,  n_3p_migr_Nt_3ft_tq_medium[3]);
  //////////////////////////////////////////////////////////////////////////////
  Info("finalize()", "Super-final table: tight taus");
  Info("finalize()", "1 prong taus %i from which", n_1p_true_true_taus_tight);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      1-pi-tr    1-ftrack   1-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco0p_tight, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco1p_tight, 
       n_1p_migr_1t_0ft_tq_tight[0]+n_1p_migr_1t_1ft_tq_tight[0], n_1p_migr_1t_1ft_tight,  n_1p_migr_1t_1ft_tq_tight[0]);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco2p_tight, 
       n_1p_migr_2t_0ft_tq_tight[1]+n_1p_migr_2t_1ft_tq_tight[1]+n_1p_migr_2t_2ft_tq_tight[1],
       n_1p_migr_2t_1ft_tight,  n_1p_migr_2t_1ft_tq_tight[1]);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_reco3p_tight, 
       n_1p_migr_3t_0ft_tq_tight[1]+n_1p_migr_3t_1ft_tq_tight[1]+n_1p_migr_3t_2ft_tq_tight[1]+n_1p_migr_3t_3ft_tq_tight[1],
       n_1p_migr_3t_1ft_tight,  n_1p_migr_3t_1ft_tq_tight[1]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_1p_true_true_taus_recoNp_tight, 
       n_1p_migr_Nt_0ft_tq_tight[1]+n_1p_migr_Nt_1ft_tq_tight[1]+n_1p_migr_Nt_2ft_tq_tight[1]+n_1p_migr_Nt_3ft_tq_tight[1]+n_1p_migr_Nt_Nft_tq_tight[1],
       n_1p_migr_Nt_1ft_tight,  n_1p_migr_Nt_1ft_tq_tight[1]);

  Info("finalize()", "3 prong taus %i from which", n_3p_true_true_taus_tight);
  Info("finalize()", "---------------------------------");
  Info("finalize()", "                reco      3-pi-tr    3-ftrack   3-pi-tr");
  Info("finalize()", "0-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco0p_tight, 0,0,0);
  Info("finalize()", "1-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco1p_tight, 0,0,0);
  Info("finalize()", "2-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco2p_tight, 0,0,0);
  Info("finalize()", "3-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_reco3p_tight, 
       n_3p_migr_3t_0ft_tq_tight[3]+n_3p_migr_3t_1ft_tq_tight[3]+n_3p_migr_3t_2ft_tq_tight[3]+n_3p_migr_3t_3ft_tq_tight[3],
       n_3p_migr_3t_3ft_tight,  n_3p_migr_3t_3ft_tq_tight[3]);
  Info("finalize()", "n-track:   %8i     %8i    %8i    %8i", n_3p_true_true_taus_recoNp_tight, 
       n_3p_migr_Nt_0ft_tq_tight[3]+n_3p_migr_Nt_1ft_tq_tight[3]+n_3p_migr_Nt_2ft_tq_tight[3]+n_3p_migr_Nt_3ft_tq_tight[3]+
       n_3p_migr_Nt_Nft_tq_tight[3],
       n_3p_migr_Nt_3ft_tight,  n_3p_migr_Nt_3ft_tq_tight[3]);
  //////////////////////////////////////////////////////////////////////////////


  Info("finalize()", "DEBUG: %i : %i : %i : %i : %i ",
       n_3p_migr_Nt_3ft_tq[0], n_3p_migr_Nt_3ft_tq[1], n_3p_migr_Nt_3ft_tq[2],
       n_3p_migr_Nt_3ft_tq[3], n_3p_migr_Nt_3ft_tq[4] );
  Info("finalize()", "DEBUG1: %i : %i : %i ", 
       n_1p_migr_2t_0ft_tq[1],n_1p_migr_2t_1ft_tq[1],n_1p_migr_2t_2ft_tq[1]);

  Info("finalize()", "Special check for 1-prong 2-track taus");
  Info("finalize()", "           pi-pi  pi-co pi-sp  sp-co co-co sp-sp");
  Info("finalize()", "0-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t[0][0][0],
       n_1p_migr_2t[2][0][0]+n_1p_migr_2t[0][2][0], n_1p_migr_2t[1][0][0]+n_1p_migr_2t[0][1][0],
       n_1p_migr_2t[1][2][0]+n_1p_migr_2t[2][1][0], n_1p_migr_2t[2][2][0]+n_1p_migr_2t[2][2][0], 
       n_1p_migr_2t[1][1][0]+n_1p_migr_2t[1][1][0]
       );
  Info("finalize()", "1-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t[0][0][1],
       n_1p_migr_2t[2][0][1]+n_1p_migr_2t[0][2][1], n_1p_migr_2t[1][0][1]+n_1p_migr_2t[0][1][1],
       n_1p_migr_2t[1][2][1]+n_1p_migr_2t[2][1][1], n_1p_migr_2t[2][2][1]+n_1p_migr_2t[2][2][1], 
       n_1p_migr_2t[1][1][1]+n_1p_migr_2t[1][1][1]
       );
  Info("finalize()", "2-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t[0][0][2],
       n_1p_migr_2t[2][0][2]+n_1p_migr_2t[0][2][2], n_1p_migr_2t[1][0][2]+n_1p_migr_2t[0][1][2],
       n_1p_migr_2t[1][2][2]+n_1p_migr_2t[2][1][2], n_1p_migr_2t[2][2][2]+n_1p_migr_2t[2][2][2], 
       n_1p_migr_2t[1][1][2]+n_1p_migr_2t[1][1][2]
       );
  Info("finalize()", "Additional study: count the conversion tagger tracks as well");
  Info("finalize()", "2-ft-0ct: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_[0][0][2][0],
       n_1p_migr_2t_[2][0][2][0]+n_1p_migr_2t_[0][2][2][0], n_1p_migr_2t_[1][0][2][0]+n_1p_migr_2t_[0][1][2][0],
       n_1p_migr_2t_[1][2][2][0]+n_1p_migr_2t_[2][1][2][0], n_1p_migr_2t_[2][2][2][0]+n_1p_migr_2t_[2][2][2][0], 
       n_1p_migr_2t_[1][1][2][0]+n_1p_migr_2t_[1][1][2][0]
       );
  Info("finalize()", "2-ft-1ct: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_[0][0][2][1],
       n_1p_migr_2t_[2][0][2][1]+n_1p_migr_2t_[0][2][2][1], n_1p_migr_2t_[1][0][2][1]+n_1p_migr_2t_[0][1][2][1],
       n_1p_migr_2t_[1][2][2][1]+n_1p_migr_2t_[2][1][2][1], n_1p_migr_2t_[2][2][2][1]+n_1p_migr_2t_[2][2][2][1], 
       n_1p_migr_2t_[1][1][2][1]+n_1p_migr_2t_[1][1][2][1]
       );
  Info("finalize()", "2-ft-2ct: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_[0][0][2][2],
       n_1p_migr_2t_[2][0][2][2]+n_1p_migr_2t_[0][2][2][2], n_1p_migr_2t_[1][0][2][2]+n_1p_migr_2t_[0][1][2][2],
       n_1p_migr_2t_[1][2][2][2]+n_1p_migr_2t_[2][1][2][2], n_1p_migr_2t_[2][2][2][2]+n_1p_migr_2t_[2][2][2][2], 
       n_1p_migr_2t_[1][1][2][2]+n_1p_migr_2t_[1][1][2][2]       
       );
  Info("finalize()", "1-filter-track, 1 reco track vs conversions: pion spurious conversion"    );
  Info("finalize()", "1-ft-0ct: %5i  %5i  %5i",        n_1p_migr_1t_1ft_tq_[0][0], n_1p_migr_1t_1ft_tq_[1][0], n_1p_migr_1t_1ft_tq_[2][0]);
  Info("finalize()", "1-ft-1ct: %5i  %5i  %5i",        n_1p_migr_1t_1ft_tq_[0][1], n_1p_migr_1t_1ft_tq_[1][1], n_1p_migr_1t_1ft_tq_[2][1]);
  // Info("finalize()", "DEBUG::: %5i  :  %5i  %5i  %5i", n_1p_migr_2t[1][0][2],  n_1p_migr_2t_[1][0][2][0], n_1p_migr_2t_[1][0][2][1], n_1p_migr_2t_[1][0][2][2]);
  // Info("finalize()", "DEBUG::: %5i  :  %5i  %5i  %5i", n_1p_migr_2t[0][1][2],  n_1p_migr_2t_[0][1][2][0], n_1p_migr_2t_[0][1][2][1], n_1p_migr_2t_[0][1][2][2]);

  // check what happens for loose taus
  Info("finalize()", "Special check for 1-prong 2-track taus : taus pass loose tau ID");
  Info("finalize()", "           pi-pi  pi-co pi-sp  sp-co co-co sp-sp");
  Info("finalize()", "0-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_loose[0][0][0],
       n_1p_migr_2t_loose[2][0][0]+n_1p_migr_2t_loose[0][2][0], n_1p_migr_2t_loose[1][0][0]+n_1p_migr_2t_loose[0][1][0],
       n_1p_migr_2t_loose[1][2][0]+n_1p_migr_2t_loose[2][1][0], n_1p_migr_2t_loose[2][2][0]+n_1p_migr_2t_loose[2][2][0], 
       n_1p_migr_2t_loose[1][1][0]+n_1p_migr_2t_loose[1][1][0]
       );
  Info("finalize()", "1-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_loose[0][0][1],
       n_1p_migr_2t_loose[2][0][1]+n_1p_migr_2t_loose[0][2][1], n_1p_migr_2t_loose[1][0][1]+n_1p_migr_2t_loose[0][1][1],
       n_1p_migr_2t_loose[1][2][1]+n_1p_migr_2t_loose[2][1][1], n_1p_migr_2t_loose[2][2][1]+n_1p_migr_2t_loose[2][2][1], 
       n_1p_migr_2t_loose[1][1][1]+n_1p_migr_2t_loose[1][1][1]
       );
  Info("finalize()", "2-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_loose[0][0][2],
       n_1p_migr_2t_loose[2][0][2]+n_1p_migr_2t_loose[0][2][2], n_1p_migr_2t_loose[1][0][2]+n_1p_migr_2t_loose[0][1][2],
       n_1p_migr_2t_loose[1][2][2]+n_1p_migr_2t_loose[2][1][2], n_1p_migr_2t_loose[2][2][2]+n_1p_migr_2t_loose[2][2][2], 
       n_1p_migr_2t_loose[1][1][2]+n_1p_migr_2t_loose[1][1][2]
       );
  Info("finalize()", "Additional study: count the conversion tagger tracks as well");
  Info("finalize()", "2-ft-0ct: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_loose_[0][0][2][0],
       n_1p_migr_2t_loose_[2][0][2][0]+n_1p_migr_2t_loose_[0][2][2][0], n_1p_migr_2t_loose_[1][0][2][0]+n_1p_migr_2t_loose_[0][1][2][0],
       n_1p_migr_2t_loose_[1][2][2][0]+n_1p_migr_2t_loose_[2][1][2][0], n_1p_migr_2t_loose_[2][2][2][0]+n_1p_migr_2t_loose_[2][2][2][0], 
       n_1p_migr_2t_loose_[1][1][2][0]+n_1p_migr_2t_loose_[1][1][2][0]
       );
  Info("finalize()", "2-ft-1ct: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_loose_[0][0][2][1],
       n_1p_migr_2t_loose_[2][0][2][1]+n_1p_migr_2t_loose_[0][2][2][1], n_1p_migr_2t_loose_[1][0][2][1]+n_1p_migr_2t_loose_[0][1][2][1],
       n_1p_migr_2t_loose_[1][2][2][1]+n_1p_migr_2t_loose_[2][1][2][1], n_1p_migr_2t_loose_[2][2][2][1]+n_1p_migr_2t_loose_[2][2][2][1], 
       n_1p_migr_2t_loose_[1][1][2][1]+n_1p_migr_2t_loose_[1][1][2][1]
       );
  Info("finalize()", "2-ft-2ct: %5i  %5i  %5i  %5i  %5i  %5i",
       n_1p_migr_2t_loose_[0][0][2][2],
       n_1p_migr_2t_loose_[2][0][2][2]+n_1p_migr_2t_loose_[0][2][2][2], n_1p_migr_2t_loose_[1][0][2][2]+n_1p_migr_2t_loose_[0][1][2][2],
       n_1p_migr_2t_loose_[1][2][2][2]+n_1p_migr_2t_loose_[2][1][2][2], n_1p_migr_2t_loose_[2][2][2][2]+n_1p_migr_2t_loose_[2][2][2][2], 
       n_1p_migr_2t_loose_[1][1][2][2]+n_1p_migr_2t_loose_[1][1][2][2]       
       );
  Info("finalize()", "1-filter-track, 1 reco track vs conversions: pion spurious conversion (loose)");
  Info("finalize()", "1-ft-0ct: %5i  %5i  %5i", n_1p_migr_1t_1ft_tq_loose_[0][0], n_1p_migr_1t_1ft_tq_loose_[1][0], n_1p_migr_1t_1ft_tq_loose_[2][0]);
  Info("finalize()", "1-ft-1ct: %5i  %5i  %5i", n_1p_migr_1t_1ft_tq_loose_[0][1], n_1p_migr_1t_1ft_tq_loose_[1][1], n_1p_migr_1t_1ft_tq_loose_[2][1]);
  Info("finalize()", "1-filter-track, 1 reco track vs conversions: pion spurious conversion (medium)");
  Info("finalize()", "1-ft-0ct: %5i  %5i  %5i", n_1p_migr_1t_1ft_tq_medium_[0][0], n_1p_migr_1t_1ft_tq_medium_[1][0], n_1p_migr_1t_1ft_tq_medium_[2][0]);
  Info("finalize()", "1-ft-1ct: %5i  %5i  %5i", n_1p_migr_1t_1ft_tq_medium_[0][1], n_1p_migr_1t_1ft_tq_medium_[1][1], n_1p_migr_1t_1ft_tq_medium_[2][1]);
  //

  // put it here since I need only these things for the time being
  // return EL::StatusCode::SUCCESS;

  Info("finalize()", "Special check for 3-prong 2-track taus");
  Info("finalize()", "           pi-pi  pi-co pi-sp  sp-co co-co sp-sp");
  Info("finalize()", "0-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_3p_migr_2t[0][0][0],
       n_3p_migr_2t[2][0][0]+n_3p_migr_2t[0][2][0], n_3p_migr_2t[1][0][0]+n_3p_migr_2t[0][1][0],
       n_3p_migr_2t[1][2][0]+n_3p_migr_2t[2][1][0], n_3p_migr_2t[2][2][0]+n_3p_migr_2t[2][2][0], 
       n_3p_migr_2t[1][1][0]+n_3p_migr_2t[1][1][0]
       );
  Info("finalize()", "1-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_3p_migr_2t[0][0][1],
       n_3p_migr_2t[2][0][1]+n_3p_migr_2t[0][2][1], n_3p_migr_2t[1][0][1]+n_3p_migr_2t[0][1][1],
       n_3p_migr_2t[1][2][1]+n_3p_migr_2t[2][1][1], n_3p_migr_2t[2][2][1]+n_3p_migr_2t[2][2][1], 
       n_3p_migr_2t[1][1][1]+n_3p_migr_2t[1][1][1]
       );
  Info("finalize()", "2-ftracks: %5i  %5i  %5i  %5i  %5i  %5i",
       n_3p_migr_2t[0][0][2],
       n_3p_migr_2t[2][0][2]+n_3p_migr_2t[0][2][2], n_3p_migr_2t[1][0][2]+n_3p_migr_2t[0][1][2],
       n_3p_migr_2t[1][2][2]+n_3p_migr_2t[2][1][2], n_3p_migr_2t[2][2][2]+n_3p_migr_2t[2][2][2], 
       n_3p_migr_2t[1][1][2]+n_3p_migr_2t[1][1][2]
       );


  // new conversion study here
  {
    int n_table_noconv_1x0 = 0, n_table_noconv_1x1 = 0,n_table_noconv_1x2 = 0,n_table_noconv_1x3 = 0, n_table_noconv_1xN = 0;  
    int n_table_noconv_STF_1x0 = 0, n_table_noconv_STF_1x1 = 0,n_table_noconv_STF_1x2 = 0,n_table_noconv_STF_1x3 = 0, n_table_noconv_STF_1xN = 0;  
    int n_table_STF_1x0 = 0, n_table_STF_1x1 = 0,n_table_STF_1x2 = 0,n_table_STF_1x3 = 0, n_table_STF_1xN = 0;  
    int n_table_noconv_1x1_pions = 0;
    int n_table_noconv_STF_1x1_pions = 0;
    int n_table_STF_1x1_pions = 0;
    int n_table_reco1_pions =0;
    
    int n_table_noconv_3x0 = 0, n_table_noconv_3x1 = 0,n_table_noconv_3x2 = 0,n_table_noconv_3x3 = 0, n_table_noconv_3xN = 0;  
    int n_table_noconv_STF_3x0 = 0, n_table_noconv_STF_3x1 = 0,n_table_noconv_STF_3x2 = 0,n_table_noconv_STF_3x3 = 0, n_table_noconv_STF_3xN = 0;  
    int n_table_STF_3x0 = 0, n_table_STF_3x1 = 0,n_table_STF_3x2 = 0,n_table_STF_3x3 = 0, n_table_STF_3xN = 0;  
    int n_table_noconv_3x3_pions = 0;
    int n_table_noconv_STF_3x3_pions = 0;
    int n_table_STF_3x3_pions = 0;
    int n_table_reco3_pions =0;

    int n_table_noconv_1x2x1_pions =0;
    int n_table_noconv_STF_1x2x1_pions =0;
    int n_table_STF_1x2x1_pions = 0;

    int n_table_noconv_3x2x1_pions =0;
    int n_table_noconv_STF_3x2x1_pions =0;
    int n_table_STF_3x2x1_pions = 0;
 
    for (int i=0; i< 6; ++i) { 
      
      n_table_noconv_1x0 += n_table_noconv[1][i][0]; n_table_noconv_STF_1x0 += n_table_noconv_STF[1][i][0];  n_table_STF_1x0 += n_table_STF[1][i][0];
      n_table_noconv_1x1 += n_table_noconv[1][i][1]; n_table_noconv_STF_1x1 += n_table_noconv_STF[1][i][1];  n_table_STF_1x1 += n_table_STF[1][i][1];
      n_table_noconv_1x2 += n_table_noconv[1][i][2]; n_table_noconv_STF_1x2 += n_table_noconv_STF[1][i][2];  n_table_STF_1x2 += n_table_STF[1][i][2];
      n_table_noconv_1x3 += n_table_noconv[1][i][3]; n_table_noconv_STF_1x3 += n_table_noconv_STF[1][i][3];  n_table_STF_1x3 += n_table_STF[1][i][3];
      n_table_noconv_1xN += n_table_noconv[1][i][4] + n_table_noconv[1][i][5]; 
      n_table_noconv_STF_1xN += n_table_noconv_STF[1][i][4] + n_table_noconv_STF[1][i][5]; 
      n_table_STF_1xN += n_table_STF[1][i][4] + n_table_STF[1][i][5]; 
      
      n_table_noconv_3x0 += n_table_noconv[3][i][0]; n_table_noconv_STF_3x0 += n_table_noconv_STF[3][i][0];  n_table_STF_3x0 += n_table_STF[3][i][0];
      n_table_noconv_3x1 += n_table_noconv[3][i][1]; n_table_noconv_STF_3x1 += n_table_noconv_STF[3][i][1];  n_table_STF_3x1 += n_table_STF[3][i][1];
      n_table_noconv_3x2 += n_table_noconv[3][i][2]; n_table_noconv_STF_3x2 += n_table_noconv_STF[3][i][2];  n_table_STF_3x2 += n_table_STF[3][i][2];
      n_table_noconv_3x3 += n_table_noconv[3][i][3]; n_table_noconv_STF_3x3 += n_table_noconv_STF[3][i][3];  n_table_STF_3x3 += n_table_STF[3][i][3];
      n_table_noconv_3xN += n_table_noconv[3][i][4] + n_table_noconv[3][i][5]; 
      n_table_noconv_STF_3xN += n_table_noconv_STF[3][i][4] + n_table_noconv_STF[3][i][5]; 
      n_table_STF_3xN += n_table_STF[3][i][4] + n_table_STF[3][i][5]; 

      for (int j=0; j< 6; ++j) {   
	n_table_reco1_pions += n_table_all_1[1][1][1][1][j][i];
	n_table_reco3_pions += n_table_all_1[3][3][3][3][j][i];

	n_table_noconv_1x2x1_pions += n_table_noconv_1[1][2][1][1][j][i];
	n_table_noconv_STF_1x2x1_pions += n_table_noconv_STF_1[1][2][1][1][j][i];
	n_table_STF_1x2x1_pions += n_table_STF_1[1][2][1][1][j][i];

	n_table_noconv_3x2x1_pions += n_table_noconv_1[3][2][1][3][j][i];
	n_table_noconv_STF_3x2x1_pions += n_table_noconv_STF_1[3][2][1][3][j][i];
	n_table_STF_3x2x1_pions += n_table_STF_1[3][2][1][3][j][i];


	for (int k=0; k< 6; ++k) { 
	  n_table_noconv_1x1_pions += n_table_noconv_1[1][i][1][1][j][k];
	  n_table_noconv_STF_1x1_pions += n_table_noconv_STF_1[1][i][1][1][j][k];
	  n_table_STF_1x1_pions += n_table_STF_1[1][i][1][1][j][k];
	  
	  n_table_noconv_3x3_pions += n_table_noconv_1[3][i][3][3][j][k]; // + 2*n_table_noconv_1[3][i][1][2][j][k]+3*n_table_noconv_1[3][i][1][3][j][k];
	  n_table_noconv_STF_3x3_pions += n_table_noconv_STF_1[3][i][3][3][j][k]; // +2*n_table_noconv_STF_1[3][i][1][2][j][k]+3*n_table_noconv_STF_1[3][i][1][3][j][k];
	  n_table_STF_3x3_pions += n_table_STF_1[3][i][3][3][j][k];
	}}
      
    }

    Info("finalize()", "Full chain study: STF + Conversion tagger");
    Info("finalize()", "1-prong taus: %8i",  n_1p_true_true_taus);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco0p, n_table_noconv_1x0, n_table_noconv_STF_1x0, n_table_STF_1x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco1p, n_table_noconv_1x1, n_table_noconv_STF_1x1, n_table_STF_1x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco2p, n_table_noconv_1x2, n_table_noconv_STF_1x2, n_table_STF_1x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco3p, n_table_noconv_1x3, n_table_noconv_STF_1x3, n_table_STF_1x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_1p_true_true_taus_recoNp, n_table_noconv_1xN, n_table_noconv_STF_1xN, n_table_STF_1xN);
    Info("finalize()", "Fake rates:   N=1  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco1_pions/double(n_1p_true_true_taus_reco1p), 
	 1-n_table_noconv_1x1_pions/double(n_table_noconv_1x1), 1-n_table_noconv_STF_1x1_pions/double(n_table_noconv_STF_1x1), 1-n_table_STF_1x1_pions/double(n_table_STF_1x1));
    Info("finalize()", "Efficiencies: N=1  %8.5f  %8.5f  %8.5f  %8.5f", n_1p_true_true_taus_reco1p/double(n_1p_true_true_taus), n_table_noconv_1x1/double(n_1p_true_true_taus), n_table_noconv_STF_1x1/double(n_1p_true_true_taus), n_table_STF_1x1/double(n_1p_true_true_taus));
    // special check: consider only 2-track taus
    Info("finalize()", "Special: only 1-prong 2-track taus exclusively used here: in total %8i taus", n_1p_true_true_taus_reco2p);
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", 0, n_table_noconv[1][2][0], n_table_noconv_STF[1][2][0], n_table_STF[1][2][0]);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", 0, n_table_noconv[1][2][1], n_table_noconv_STF[1][2][1], n_table_STF[1][2][1]);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco2p, n_table_noconv[1][2][2], n_table_noconv_STF[1][2][2], n_table_STF[1][2][2]);
    Info("finalize()", "FR:  %8.5f %8.5f %8.5f %8.5f", 0.,
	 1-n_table_noconv_1x2x1_pions/double(n_table_noconv[1][2][1]), 1-n_table_noconv_STF_1x2x1_pions/double(n_table_noconv_STF[1][2][1]), 1-n_table_STF_1x2x1_pions/double(n_table_STF[1][2][1]));
    Info("finalize()", "Eff: %8.5f %8.5f %8.5f %8.5f", 0., 
	 n_table_noconv[1][2][1]/double(n_1p_true_true_taus_reco2p), n_table_noconv_STF[1][2][1]/double(n_1p_true_true_taus_reco2p), n_table_STF[1][2][1]/double(n_1p_true_true_taus_reco2p));

    Info("finalize()", "3-prong taus: %8i",  n_3p_true_true_taus);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco0p, n_table_noconv_3x0, n_table_noconv_STF_3x0, n_table_STF_3x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco1p, n_table_noconv_3x1, n_table_noconv_STF_3x1, n_table_STF_3x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco2p, n_table_noconv_3x2, n_table_noconv_STF_3x2, n_table_STF_3x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco3p, n_table_noconv_3x3, n_table_noconv_STF_3x3, n_table_STF_3x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_3p_true_true_taus_recoNp, n_table_noconv_3xN, n_table_noconv_STF_3xN, n_table_STF_3xN);
    Info("finalize()", "Fake rates:   N=3  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco3_pions/double(n_3p_true_true_taus_reco3p), 
	 1-n_table_noconv_3x3_pions/double(n_table_noconv_3x3), 1-n_table_noconv_STF_3x3_pions/double(n_table_noconv_STF_3x3), 1-n_table_STF_3x3_pions/double(n_table_STF_3x3));
    Info("finalize()", "Efficiencies: N=3  %8.5f  %8.5f  %8.5f  %8.5f", n_3p_true_true_taus_reco3p/double(n_3p_true_true_taus), n_table_noconv_3x3/double(n_3p_true_true_taus), n_table_noconv_STF_3x3/double(n_3p_true_true_taus), n_table_STF_3x3/double(n_3p_true_true_taus));

    // special check: consider only 2-track taus
    Info("finalize()", "Special: only 3-prong 2-track taus exclusively used here: in total %8i taus", n_3p_true_true_taus_reco2p);
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", 0, n_table_noconv[3][2][0], n_table_noconv_STF[3][2][0], n_table_STF[3][2][0]);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", 0, n_table_noconv[3][2][1], n_table_noconv_STF[3][2][1], n_table_STF[3][2][1]);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco2p, n_table_noconv[3][2][2], n_table_noconv_STF[3][2][2], n_table_STF[3][2][2]);
    Info("finalize()", "FR:  %8.5f %8.5f %8.5f %8.5f", 0.,
	 1-n_table_noconv_3x2x1_pions/double(n_table_noconv[3][2][1]), 1-n_table_noconv_STF_3x2x1_pions/double(n_table_noconv_STF[3][2][1]), 1-n_table_STF_3x2x1_pions/double(n_table_STF[3][2][1]));
    Info("finalize()", "Eff: %8.5f %8.5f %8.5f %8.5f", 0., 
	 n_table_noconv[3][2][1]/double(n_3p_true_true_taus_reco2p), n_table_noconv_STF[3][2][1]/double(n_3p_true_true_taus_reco2p), n_table_STF[3][2][1]/double(n_3p_true_true_taus_reco2p));


  }


  // loose tau ID
  {
    int n_table_noconv_1x0 = 0, n_table_noconv_1x1 = 0,n_table_noconv_1x2 = 0,n_table_noconv_1x3 = 0, n_table_noconv_1xN = 0;  
    int n_table_noconv_STF_1x0 = 0, n_table_noconv_STF_1x1 = 0,n_table_noconv_STF_1x2 = 0,n_table_noconv_STF_1x3 = 0, n_table_noconv_STF_1xN = 0;  
    int n_table_STF_1x0 = 0, n_table_STF_1x1 = 0,n_table_STF_1x2 = 0,n_table_STF_1x3 = 0, n_table_STF_1xN = 0;  
    int n_table_noconv_1x1_pions = 0;
    int n_table_noconv_STF_1x1_pions = 0;
    int n_table_STF_1x1_pions = 0;
    int n_table_reco1_pions =0;
    
    int n_table_noconv_3x0 = 0, n_table_noconv_3x1 = 0,n_table_noconv_3x2 = 0,n_table_noconv_3x3 = 0, n_table_noconv_3xN = 0;  
    int n_table_noconv_STF_3x0 = 0, n_table_noconv_STF_3x1 = 0,n_table_noconv_STF_3x2 = 0,n_table_noconv_STF_3x3 = 0, n_table_noconv_STF_3xN = 0;  
    int n_table_STF_3x0 = 0, n_table_STF_3x1 = 0,n_table_STF_3x2 = 0,n_table_STF_3x3 = 0, n_table_STF_3xN = 0;  
    int n_table_noconv_3x3_pions = 0;
    int n_table_noconv_STF_3x3_pions = 0;
    int n_table_STF_3x3_pions = 0;
    int n_table_reco3_pions =0;

  

    for (int i=0; i< 6; ++i) { 
      
      n_table_noconv_1x0 += n_table_noconv_loose[1][i][0]; n_table_noconv_STF_1x0 += n_table_noconv_STF_loose[1][i][0];  n_table_STF_1x0 += n_table_STF_loose[1][i][0];
      n_table_noconv_1x1 += n_table_noconv_loose[1][i][1]; n_table_noconv_STF_1x1 += n_table_noconv_STF_loose[1][i][1];  n_table_STF_1x1 += n_table_STF_loose[1][i][1];
      n_table_noconv_1x2 += n_table_noconv_loose[1][i][2]; n_table_noconv_STF_1x2 += n_table_noconv_STF_loose[1][i][2];  n_table_STF_1x2 += n_table_STF_loose[1][i][2];
      n_table_noconv_1x3 += n_table_noconv_loose[1][i][3]; n_table_noconv_STF_1x3 += n_table_noconv_STF_loose[1][i][3];  n_table_STF_1x3 += n_table_STF_loose[1][i][3];
      n_table_noconv_1xN += n_table_noconv_loose[1][i][4] + n_table_noconv_loose[1][i][5]; 
      n_table_noconv_STF_1xN += n_table_noconv_STF_loose[1][i][4] + n_table_noconv_STF_loose[1][i][5]; 
      n_table_STF_1xN += n_table_STF_loose[1][i][4] + n_table_STF_loose[1][i][5]; 
      
      n_table_noconv_3x0 += n_table_noconv_loose[3][i][0]; n_table_noconv_STF_3x0 += n_table_noconv_STF_loose[3][i][0];  n_table_STF_3x0 += n_table_STF_loose[3][i][0];
      n_table_noconv_3x1 += n_table_noconv_loose[3][i][1]; n_table_noconv_STF_3x1 += n_table_noconv_STF_loose[3][i][1];  n_table_STF_3x1 += n_table_STF_loose[3][i][1];
      n_table_noconv_3x2 += n_table_noconv_loose[3][i][2]; n_table_noconv_STF_3x2 += n_table_noconv_STF_loose[3][i][2];  n_table_STF_3x2 += n_table_STF_loose[3][i][2];
      n_table_noconv_3x3 += n_table_noconv_loose[3][i][3]; n_table_noconv_STF_3x3 += n_table_noconv_STF_loose[3][i][3];  n_table_STF_3x3 += n_table_STF_loose[3][i][3];
      n_table_noconv_3xN += n_table_noconv_loose[3][i][4] + n_table_noconv_loose[3][i][5]; 
      n_table_noconv_STF_3xN += n_table_noconv_STF_loose[3][i][4] + n_table_noconv_STF_loose[3][i][5]; 
      n_table_STF_3xN += n_table_STF_loose[3][i][4] + n_table_STF_loose[3][i][5]; 

      for (int j=0; j< 6; ++j) {   
	n_table_reco1_pions += n_table_all_loose_1[1][1][1][1][j][i];
	n_table_reco3_pions += n_table_all_loose_1[3][3][3][3][j][i];      	
	for (int k=0; k< 6; ++k) { 
	  
	  n_table_noconv_1x1_pions += n_table_noconv_loose_1[1][i][1][1][j][k];
	  n_table_noconv_STF_1x1_pions += n_table_noconv_STF_loose_1[1][i][1][1][j][k];
	  n_table_STF_1x1_pions += n_table_STF_loose_1[1][i][1][1][j][k];
	  
	  n_table_noconv_3x3_pions += n_table_noconv_loose_1[3][i][3][3][j][k]; // + 2*n_table_noconv_1[3][i][1][2][j][k]+3*n_table_noconv_1[3][i][1][3][j][k];
	  n_table_noconv_STF_3x3_pions += n_table_noconv_STF_loose_1[3][i][3][3][j][k]; // +2*n_table_noconv_STF_1[3][i][1][2][j][k]+3*n_table_noconv_STF_1[3][i][1][3][j][k];
	  n_table_STF_3x3_pions += n_table_STF_loose_1[3][i][3][3][j][k];
	  
	}}
      
    }
    
    
    Info("finalize()", "Full chain study: STF + Conversion tagger: LOOSE TAU ID");
    Info("finalize()", "1-prong taus: %8i",  n_1p_true_true_taus_loose);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco0p_loose, n_table_noconv_1x0, n_table_noconv_STF_1x0, n_table_STF_1x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco1p_loose, n_table_noconv_1x1, n_table_noconv_STF_1x1, n_table_STF_1x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco2p_loose, n_table_noconv_1x2, n_table_noconv_STF_1x2, n_table_STF_1x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco3p_loose, n_table_noconv_1x3, n_table_noconv_STF_1x3, n_table_STF_1x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_1p_true_true_taus_recoNp_loose, n_table_noconv_1xN, n_table_noconv_STF_1xN, n_table_STF_1xN);
    Info("finalize()", "Fake rates:   N=1  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco1_pions/double(n_1p_true_true_taus_reco1p_loose), 
	 1-n_table_noconv_1x1_pions/double(n_table_noconv_1x1), 1-n_table_noconv_STF_1x1_pions/double(n_table_noconv_STF_1x1), 1-n_table_STF_1x1_pions/double(n_table_STF_1x1));
    Info("finalize()", "Efficiencies: N=1  %8.5f  %8.5f  %8.5f  %8.5f", n_1p_true_true_taus_reco1p_loose/double(n_1p_true_true_taus_loose), n_table_noconv_1x1/double(n_1p_true_true_taus_loose), n_table_noconv_STF_1x1/double(n_1p_true_true_taus_loose), n_table_STF_1x1/double(n_1p_true_true_taus_loose));
    
    
    Info("finalize()", "3-prong taus: %8i",  n_3p_true_true_taus_loose);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco0p_loose, n_table_noconv_3x0, n_table_noconv_STF_3x0, n_table_STF_3x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco1p_loose, n_table_noconv_3x1, n_table_noconv_STF_3x1, n_table_STF_3x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco2p_loose, n_table_noconv_3x2, n_table_noconv_STF_3x2, n_table_STF_3x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco3p_loose, n_table_noconv_3x3, n_table_noconv_STF_3x3, n_table_STF_3x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_3p_true_true_taus_recoNp_loose, n_table_noconv_3xN, n_table_noconv_STF_3xN, n_table_STF_3xN);
    Info("finalize()", "Fake rates:   N=3  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco3_pions/double(n_3p_true_true_taus_reco3p_loose), 
	 1-n_table_noconv_3x3_pions/double(n_table_noconv_3x3), 1-n_table_noconv_STF_3x3_pions/double(n_table_noconv_STF_3x3), 1-n_table_STF_3x3_pions/double(n_table_STF_3x3));
    Info("finalize()", "Efficiencies: N=3  %8.5f  %8.5f  %8.5f  %8.5f", n_3p_true_true_taus_reco3p_loose/double(n_3p_true_true_taus_loose), n_table_noconv_3x3/double(n_3p_true_true_taus_loose), n_table_noconv_STF_3x3/double(n_3p_true_true_taus_loose), n_table_STF_3x3/double(n_3p_true_true_taus_loose));
  }



  // medium tau ID
  {
    int n_table_noconv_1x0 = 0, n_table_noconv_1x1 = 0,n_table_noconv_1x2 = 0,n_table_noconv_1x3 = 0, n_table_noconv_1xN = 0;  
    int n_table_noconv_STF_1x0 = 0, n_table_noconv_STF_1x1 = 0,n_table_noconv_STF_1x2 = 0,n_table_noconv_STF_1x3 = 0, n_table_noconv_STF_1xN = 0;  
    int n_table_STF_1x0 = 0, n_table_STF_1x1 = 0,n_table_STF_1x2 = 0,n_table_STF_1x3 = 0, n_table_STF_1xN = 0;  
    int n_table_noconv_1x1_pions = 0;
    int n_table_noconv_STF_1x1_pions = 0;
    int n_table_STF_1x1_pions = 0;
    int n_table_reco1_pions =0;
    
    int n_table_noconv_3x0 = 0, n_table_noconv_3x1 = 0,n_table_noconv_3x2 = 0,n_table_noconv_3x3 = 0, n_table_noconv_3xN = 0;  
    int n_table_noconv_STF_3x0 = 0, n_table_noconv_STF_3x1 = 0,n_table_noconv_STF_3x2 = 0,n_table_noconv_STF_3x3 = 0, n_table_noconv_STF_3xN = 0;  
    int n_table_STF_3x0 = 0, n_table_STF_3x1 = 0,n_table_STF_3x2 = 0,n_table_STF_3x3 = 0, n_table_STF_3xN = 0;  
    int n_table_noconv_3x3_pions = 0;
    int n_table_noconv_STF_3x3_pions = 0;
    int n_table_STF_3x3_pions = 0;
    int n_table_reco3_pions =0;

  

    for (int i=0; i< 6; ++i) { 
      
      n_table_noconv_1x0 += n_table_noconv_medium[1][i][0]; n_table_noconv_STF_1x0 += n_table_noconv_STF_medium[1][i][0];  n_table_STF_1x0 += n_table_STF_medium[1][i][0];
      n_table_noconv_1x1 += n_table_noconv_medium[1][i][1]; n_table_noconv_STF_1x1 += n_table_noconv_STF_medium[1][i][1];  n_table_STF_1x1 += n_table_STF_medium[1][i][1];
      n_table_noconv_1x2 += n_table_noconv_medium[1][i][2]; n_table_noconv_STF_1x2 += n_table_noconv_STF_medium[1][i][2];  n_table_STF_1x2 += n_table_STF_medium[1][i][2];
      n_table_noconv_1x3 += n_table_noconv_medium[1][i][3]; n_table_noconv_STF_1x3 += n_table_noconv_STF_medium[1][i][3];  n_table_STF_1x3 += n_table_STF_medium[1][i][3];
      n_table_noconv_1xN += n_table_noconv_medium[1][i][4] + n_table_noconv_medium[1][i][5]; 
      n_table_noconv_STF_1xN += n_table_noconv_STF_medium[1][i][4] + n_table_noconv_STF_medium[1][i][5]; 
      n_table_STF_1xN += n_table_STF_medium[1][i][4] + n_table_STF_medium[1][i][5]; 
      
      n_table_noconv_3x0 += n_table_noconv_medium[3][i][0]; n_table_noconv_STF_3x0 += n_table_noconv_STF_medium[3][i][0];  n_table_STF_3x0 += n_table_STF_medium[3][i][0];
      n_table_noconv_3x1 += n_table_noconv_medium[3][i][1]; n_table_noconv_STF_3x1 += n_table_noconv_STF_medium[3][i][1];  n_table_STF_3x1 += n_table_STF_medium[3][i][1];
      n_table_noconv_3x2 += n_table_noconv_medium[3][i][2]; n_table_noconv_STF_3x2 += n_table_noconv_STF_medium[3][i][2];  n_table_STF_3x2 += n_table_STF_medium[3][i][2];
      n_table_noconv_3x3 += n_table_noconv_medium[3][i][3]; n_table_noconv_STF_3x3 += n_table_noconv_STF_medium[3][i][3];  n_table_STF_3x3 += n_table_STF_medium[3][i][3];
      n_table_noconv_3xN += n_table_noconv_medium[3][i][4] + n_table_noconv_medium[3][i][5]; 
      n_table_noconv_STF_3xN += n_table_noconv_STF_medium[3][i][4] + n_table_noconv_STF_medium[3][i][5]; 
      n_table_STF_3xN += n_table_STF_medium[3][i][4] + n_table_STF_medium[3][i][5]; 

      for (int j=0; j< 6; ++j) {   
	n_table_reco1_pions += n_table_all_medium_1[1][1][1][1][j][i];
	n_table_reco3_pions += n_table_all_medium_1[3][3][3][3][j][i];      	
	for (int k=0; k< 6; ++k) { 
	  n_table_noconv_1x1_pions += n_table_noconv_medium_1[1][i][1][1][j][k];
	  n_table_noconv_STF_1x1_pions += n_table_noconv_STF_medium_1[1][i][1][1][j][k];
	  n_table_STF_1x1_pions += n_table_STF_medium_1[1][i][1][1][j][k];
	  
	  n_table_noconv_3x3_pions += n_table_noconv_medium_1[3][i][3][3][j][k]; // + 2*n_table_noconv_1[3][i][1][2][j][k]+3*n_table_noconv_1[3][i][1][3][j][k];
	  n_table_noconv_STF_3x3_pions += n_table_noconv_STF_medium_1[3][i][3][3][j][k]; // +2*n_table_noconv_STF_1[3][i][1][2][j][k]+3*n_table_noconv_STF_1[3][i][1][3][j][k];
	  n_table_STF_3x3_pions += n_table_STF_medium_1[3][i][3][3][j][k];	  
	}}
      
    }
    
    
    Info("finalize()", "Full chain study: STF + Conversion tagger: MEDIUM TAU ID");
    Info("finalize()", "1-prong taus: %8i",  n_1p_true_true_taus_medium);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco0p_medium, n_table_noconv_1x0, n_table_noconv_STF_1x0, n_table_STF_1x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco1p_medium, n_table_noconv_1x1, n_table_noconv_STF_1x1, n_table_STF_1x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco2p_medium, n_table_noconv_1x2, n_table_noconv_STF_1x2, n_table_STF_1x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco3p_medium, n_table_noconv_1x3, n_table_noconv_STF_1x3, n_table_STF_1x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_1p_true_true_taus_recoNp_medium, n_table_noconv_1xN, n_table_noconv_STF_1xN, n_table_STF_1xN);
    Info("finalize()", "Fake rates:   N=1  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco1_pions/double(n_1p_true_true_taus_reco1p_medium), 
	 1-n_table_noconv_1x1_pions/double(n_table_noconv_1x1), 1-n_table_noconv_STF_1x1_pions/double(n_table_noconv_STF_1x1), 1-n_table_STF_1x1_pions/double(n_table_STF_1x1));
    Info("finalize()", "Efficiencies: N=1  %8.5f  %8.5f  %8.5f  %8.5f", n_1p_true_true_taus_reco1p_medium/double(n_1p_true_true_taus_medium), n_table_noconv_1x1/double(n_1p_true_true_taus_medium), n_table_noconv_STF_1x1/double(n_1p_true_true_taus_medium), n_table_STF_1x1/double(n_1p_true_true_taus_medium));
    
    
    Info("finalize()", "3-prong taus: %8i",  n_3p_true_true_taus_medium);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco0p_medium, n_table_noconv_3x0, n_table_noconv_STF_3x0, n_table_STF_3x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco1p_medium, n_table_noconv_3x1, n_table_noconv_STF_3x1, n_table_STF_3x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco2p_medium, n_table_noconv_3x2, n_table_noconv_STF_3x2, n_table_STF_3x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco3p_medium, n_table_noconv_3x3, n_table_noconv_STF_3x3, n_table_STF_3x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_3p_true_true_taus_recoNp_medium, n_table_noconv_3xN, n_table_noconv_STF_3xN, n_table_STF_3xN);
    Info("finalize()", "Fake rates:   N=3  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco3_pions/double(n_3p_true_true_taus_reco3p_medium), 
	 1-n_table_noconv_3x3_pions/double(n_table_noconv_3x3), 1-n_table_noconv_STF_3x3_pions/double(n_table_noconv_STF_3x3), 1-n_table_STF_3x3_pions/double(n_table_STF_3x3));
    Info("finalize()", "Efficiencies: N=3  %8.5f  %8.5f  %8.5f  %8.5f", n_3p_true_true_taus_reco3p_medium/double(n_3p_true_true_taus_medium), n_table_noconv_3x3/double(n_3p_true_true_taus_medium), n_table_noconv_STF_3x3/double(n_3p_true_true_taus_medium), n_table_STF_3x3/double(n_3p_true_true_taus_medium));
  }




  // tight tau ID
  {
    int n_table_noconv_1x0 = 0, n_table_noconv_1x1 = 0,n_table_noconv_1x2 = 0,n_table_noconv_1x3 = 0, n_table_noconv_1xN = 0;  
    int n_table_noconv_STF_1x0 = 0, n_table_noconv_STF_1x1 = 0,n_table_noconv_STF_1x2 = 0,n_table_noconv_STF_1x3 = 0, n_table_noconv_STF_1xN = 0;  
    int n_table_STF_1x0 = 0, n_table_STF_1x1 = 0,n_table_STF_1x2 = 0,n_table_STF_1x3 = 0, n_table_STF_1xN = 0;  
    int n_table_noconv_1x1_pions = 0;
    int n_table_noconv_STF_1x1_pions = 0;
    int n_table_STF_1x1_pions = 0;
    int n_table_reco1_pions =0;
    
    int n_table_noconv_3x0 = 0, n_table_noconv_3x1 = 0,n_table_noconv_3x2 = 0,n_table_noconv_3x3 = 0, n_table_noconv_3xN = 0;  
    int n_table_noconv_STF_3x0 = 0, n_table_noconv_STF_3x1 = 0,n_table_noconv_STF_3x2 = 0,n_table_noconv_STF_3x3 = 0, n_table_noconv_STF_3xN = 0;  
    int n_table_STF_3x0 = 0, n_table_STF_3x1 = 0,n_table_STF_3x2 = 0,n_table_STF_3x3 = 0, n_table_STF_3xN = 0;  
    int n_table_noconv_3x3_pions = 0;
    int n_table_noconv_STF_3x3_pions = 0;
    int n_table_STF_3x3_pions = 0;
    int n_table_reco3_pions =0;

  

    for (int i=0; i< 6; ++i) { 
      
      n_table_noconv_1x0 += n_table_noconv_tight[1][i][0]; n_table_noconv_STF_1x0 += n_table_noconv_STF_tight[1][i][0];  n_table_STF_1x0 += n_table_STF_tight[1][i][0];
      n_table_noconv_1x1 += n_table_noconv_tight[1][i][1]; n_table_noconv_STF_1x1 += n_table_noconv_STF_tight[1][i][1];  n_table_STF_1x1 += n_table_STF_tight[1][i][1];
      n_table_noconv_1x2 += n_table_noconv_tight[1][i][2]; n_table_noconv_STF_1x2 += n_table_noconv_STF_tight[1][i][2];  n_table_STF_1x2 += n_table_STF_tight[1][i][2];
      n_table_noconv_1x3 += n_table_noconv_tight[1][i][3]; n_table_noconv_STF_1x3 += n_table_noconv_STF_tight[1][i][3];  n_table_STF_1x3 += n_table_STF_tight[1][i][3];
      n_table_noconv_1xN += n_table_noconv_tight[1][i][4] + n_table_noconv_tight[1][i][5]; 
      n_table_noconv_STF_1xN += n_table_noconv_STF_tight[1][i][4] + n_table_noconv_STF_tight[1][i][5]; 
      n_table_STF_1xN += n_table_STF_tight[1][i][4] + n_table_STF_tight[1][i][5]; 
      
      n_table_noconv_3x0 += n_table_noconv_tight[3][i][0]; n_table_noconv_STF_3x0 += n_table_noconv_STF_tight[3][i][0];  n_table_STF_3x0 += n_table_STF_tight[3][i][0];
      n_table_noconv_3x1 += n_table_noconv_tight[3][i][1]; n_table_noconv_STF_3x1 += n_table_noconv_STF_tight[3][i][1];  n_table_STF_3x1 += n_table_STF_tight[3][i][1];
      n_table_noconv_3x2 += n_table_noconv_tight[3][i][2]; n_table_noconv_STF_3x2 += n_table_noconv_STF_tight[3][i][2];  n_table_STF_3x2 += n_table_STF_tight[3][i][2];
      n_table_noconv_3x3 += n_table_noconv_tight[3][i][3]; n_table_noconv_STF_3x3 += n_table_noconv_STF_tight[3][i][3];  n_table_STF_3x3 += n_table_STF_tight[3][i][3];
      n_table_noconv_3xN += n_table_noconv_tight[3][i][4] + n_table_noconv_tight[3][i][5]; 
      n_table_noconv_STF_3xN += n_table_noconv_STF_tight[3][i][4] + n_table_noconv_STF_tight[3][i][5]; 
      n_table_STF_3xN += n_table_STF_tight[3][i][4] + n_table_STF_tight[3][i][5]; 


      for (int j=0; j< 6; ++j) {   
	  n_table_reco1_pions += n_table_all_tight_1[1][1][1][1][j][i];      
	  n_table_reco3_pions += n_table_all_tight_1[3][3][3][3][j][i];
	for (int k=0; k< 6; ++k) { 
	  
	  n_table_noconv_1x1_pions += n_table_noconv_tight_1[1][i][1][1][j][k];
	  n_table_noconv_STF_1x1_pions += n_table_noconv_STF_tight_1[1][i][1][1][j][k];
	  n_table_STF_1x1_pions += n_table_STF_tight_1[1][i][1][1][j][k];
	  
	  n_table_noconv_3x3_pions += n_table_noconv_tight_1[3][i][3][3][j][k]; // + 2*n_table_noconv_1[3][i][1][2][j][k]+3*n_table_noconv_1[3][i][1][3][j][k];
	  n_table_noconv_STF_3x3_pions += n_table_noconv_STF_tight_1[3][i][3][3][j][k]; // +2*n_table_noconv_STF_1[3][i][1][2][j][k]+3*n_table_noconv_STF_1[3][i][1][3][j][k];
	  n_table_STF_3x3_pions += n_table_STF_tight_1[3][i][3][3][j][k];	  
	}}
      
    }
    
    
    Info("finalize()", "Full chain study: STF + Conversion tagger: TIGHT TAU ID");
    Info("finalize()", "1-prong taus: %8i",  n_1p_true_true_taus_tight);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco0p_tight, n_table_noconv_1x0, n_table_noconv_STF_1x0, n_table_STF_1x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco1p_tight, n_table_noconv_1x1, n_table_noconv_STF_1x1, n_table_STF_1x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco2p_tight, n_table_noconv_1x2, n_table_noconv_STF_1x2, n_table_STF_1x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_1p_true_true_taus_reco3p_tight, n_table_noconv_1x3, n_table_noconv_STF_1x3, n_table_STF_1x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_1p_true_true_taus_recoNp_tight, n_table_noconv_1xN, n_table_noconv_STF_1xN, n_table_STF_1xN);
    Info("finalize()", "Fake rates:   N=1  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco1_pions/double(n_1p_true_true_taus_reco1p_tight), 
	 1-n_table_noconv_1x1_pions/double(n_table_noconv_1x1), 1-n_table_noconv_STF_1x1_pions/double(n_table_noconv_STF_1x1), 1-n_table_STF_1x1_pions/double(n_table_STF_1x1));
    Info("finalize()", "Efficiencies: N=1  %8.5f  %8.5f  %8.5f  %8.5f", n_1p_true_true_taus_reco1p_tight/double(n_1p_true_true_taus_tight), n_table_noconv_1x1/double(n_1p_true_true_taus_tight), n_table_noconv_STF_1x1/double(n_1p_true_true_taus_tight), n_table_STF_1x1/double(n_1p_true_true_taus_tight));
    
    
    Info("finalize()", "3-prong taus: %8i",  n_3p_true_true_taus_tight);
    Info("finalize()", "      Reco    No-Conv-tracks    STF    STF(w/o conversion)");
    Info("finalize()", "N=0  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco0p_tight, n_table_noconv_3x0, n_table_noconv_STF_3x0, n_table_STF_3x0);
    Info("finalize()", "N=1  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco1p_tight, n_table_noconv_3x1, n_table_noconv_STF_3x1, n_table_STF_3x1);
    Info("finalize()", "N=2  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco2p_tight, n_table_noconv_3x2, n_table_noconv_STF_3x2, n_table_STF_3x2);
    Info("finalize()", "N=3  %8i  %8i  %8i  %8i", n_3p_true_true_taus_reco3p_tight, n_table_noconv_3x3, n_table_noconv_STF_3x3, n_table_STF_3x3);
    Info("finalize()", "N=n  %8i  %8i  %8i  %8i", n_3p_true_true_taus_recoNp_tight, n_table_noconv_3xN, n_table_noconv_STF_3xN, n_table_STF_3xN);
    Info("finalize()", "Fake rates:   N=3  %8.5f  %8.5f  %8.5f  %8.5f", 1-n_table_reco3_pions/double(n_3p_true_true_taus_reco3p_tight), 
	 1-n_table_noconv_3x3_pions/double(n_table_noconv_3x3), 1-n_table_noconv_STF_3x3_pions/double(n_table_noconv_STF_3x3), 1-n_table_STF_3x3_pions/double(n_table_STF_3x3));
    Info("finalize()", "Efficiencies: N=3  %8.5f  %8.5f  %8.5f  %8.5f", n_3p_true_true_taus_reco3p_tight/double(n_3p_true_true_taus_tight), n_table_noconv_3x3/double(n_3p_true_true_taus_tight), n_table_noconv_STF_3x3/double(n_3p_true_true_taus_tight), n_table_STF_3x3/double(n_3p_true_true_taus_tight));
  }





  int n_not_matched_2_c1 = n_not_matched_[2][0][1]+ n_not_matched_[2][1][1]+ n_not_matched_[2][2][1]+
    n_not_matched_[2][3][1]+ n_not_matched_[2][4][1]+ n_not_matched_[2][5][1];
  int n_not_matched_2_loose_c1  = n_not_matched_loose_[2][0][1]+ n_not_matched_loose_[2][1][1]+ n_not_matched_loose_[2][2][1]+
    n_not_matched_loose_[2][3][1]+ n_not_matched_loose_[2][4][1]+ n_not_matched_loose_[2][5][1];
  int n_not_matched_2_medium_c1 = n_not_matched_medium_[2][0][1]+ n_not_matched_medium_[2][1][1]+ n_not_matched_medium_[2][2][1]+
    n_not_matched_medium_[2][3][1]+ n_not_matched_medium_[2][4][1]+ n_not_matched_medium_[2][5][1];
  int n_not_matched_2_tight_c1  = n_not_matched_tight_[2][0][1]+ n_not_matched_tight_[2][1][1]+ n_not_matched_tight_[2][2][1]+
    n_not_matched_tight_[2][3][1]+ n_not_matched_tight_[2][4][1]+ n_not_matched_tight_[2][5][1];

  int n_not_matched_0 = n_not_matched[0][0]+ n_not_matched[0][1]+ n_not_matched[0][2]+
    n_not_matched[0][3]+ n_not_matched[0][4]+ n_not_matched[0][5];
  int n_not_matched_1 = n_not_matched[1][0]+ n_not_matched[1][1]+ n_not_matched[1][2]+
    n_not_matched[1][3]+ n_not_matched[1][4]+ n_not_matched[1][5];
  int n_not_matched_2 = n_not_matched[2][0]+ n_not_matched[2][1]+ n_not_matched[2][2]+
    n_not_matched[2][3]+ n_not_matched[2][4]+ n_not_matched[2][5];
  int n_not_matched_3 = n_not_matched[3][0]+ n_not_matched[3][1]+ n_not_matched[3][2]+
    n_not_matched[3][3]+ n_not_matched[3][4]+ n_not_matched[3][5];
  int n_not_matched_4 = n_not_matched[4][0]+ n_not_matched[4][1]+ n_not_matched[4][2]+
    n_not_matched[4][3]+ n_not_matched[4][4]+ n_not_matched[4][5];
  int n_not_matched_5 = n_not_matched[5][0]+ n_not_matched[5][1]+ n_not_matched[5][2]+
    n_not_matched[5][3]+ n_not_matched[5][4]+ n_not_matched[5][5];
  int n_not_matched_tot = n_not_matched_0 + n_not_matched_1 + n_not_matched_2 + 
    n_not_matched_3 + n_not_matched_4+n_not_matched_5;

  int n_not_matched_0_loose = n_not_matched_loose[0][0]+ n_not_matched_loose[0][1]+ n_not_matched_loose[0][2]+
    n_not_matched_loose[0][3]+ n_not_matched_loose[0][4]+ n_not_matched_loose[0][5];
  int n_not_matched_1_loose = n_not_matched_loose[1][0]+ n_not_matched_loose[1][1]+ n_not_matched_loose[1][2]+
    n_not_matched_loose[1][3]+ n_not_matched_loose[1][4]+ n_not_matched_loose[1][5];
  int n_not_matched_2_loose = n_not_matched_loose[2][0]+ n_not_matched_loose[2][1]+ n_not_matched_loose[2][2]+
    n_not_matched_loose[2][3]+ n_not_matched_loose[2][4]+ n_not_matched_loose[2][5];
  int n_not_matched_3_loose = n_not_matched_loose[3][0]+ n_not_matched_loose[3][1]+ n_not_matched_loose[3][2]+
    n_not_matched_loose[3][3]+ n_not_matched_loose[3][4]+ n_not_matched_loose[3][5];
  int n_not_matched_4_loose = n_not_matched_loose[4][0]+ n_not_matched_loose[4][1]+ n_not_matched_loose[4][2]+
    n_not_matched_loose[4][3]+ n_not_matched_loose[4][4]+ n_not_matched_loose[4][5];
  int n_not_matched_5_loose = n_not_matched_loose[5][0]+ n_not_matched_loose[5][1]+ n_not_matched_loose[5][2]+
    n_not_matched_loose[5][3]+ n_not_matched_loose[5][4]+ n_not_matched_loose[5][5];
  int n_not_matched_tot_loose = n_not_matched_0_loose + n_not_matched_1_loose + n_not_matched_2_loose + 
    n_not_matched_3_loose + n_not_matched_4_loose+n_not_matched_5_loose;

  int n_not_matched_0_medium = n_not_matched_medium[0][0]+ n_not_matched_medium[0][1]+ n_not_matched_medium[0][2]+
    n_not_matched_medium[0][3]+ n_not_matched_medium[0][4]+ n_not_matched_medium[0][5];
  int n_not_matched_1_medium = n_not_matched_medium[1][0]+ n_not_matched_medium[1][1]+ n_not_matched_medium[1][2]+
    n_not_matched_medium[1][3]+ n_not_matched_medium[1][4]+ n_not_matched_medium[1][5];
  int n_not_matched_2_medium = n_not_matched_medium[2][0]+ n_not_matched_medium[2][1]+ n_not_matched_medium[2][2]+
    n_not_matched_medium[2][3]+ n_not_matched_medium[2][4]+ n_not_matched_medium[2][5];
  int n_not_matched_3_medium = n_not_matched_medium[3][0]+ n_not_matched_medium[3][1]+ n_not_matched_medium[3][2]+
    n_not_matched_medium[3][3]+ n_not_matched_medium[3][4]+ n_not_matched_medium[3][5];
  int n_not_matched_4_medium = n_not_matched_medium[4][0]+ n_not_matched_medium[4][1]+ n_not_matched_medium[4][2]+
    n_not_matched_medium[4][3]+ n_not_matched_medium[4][4]+ n_not_matched_medium[4][5];
  int n_not_matched_5_medium = n_not_matched_medium[5][0]+ n_not_matched_medium[5][1]+ n_not_matched_medium[5][2]+
    n_not_matched_medium[5][3]+ n_not_matched_medium[5][4]+ n_not_matched_medium[5][5];
  int n_not_matched_tot_medium = n_not_matched_0_medium + n_not_matched_1_medium + n_not_matched_2_medium + 
    n_not_matched_3_medium + n_not_matched_4_medium+n_not_matched_5_medium;

  int n_not_matched_0_tight = n_not_matched_tight[0][0]+ n_not_matched_tight[0][1]+ n_not_matched_tight[0][2]+
    n_not_matched_tight[0][3]+ n_not_matched_tight[0][4]+ n_not_matched_tight[0][5];
  int n_not_matched_1_tight = n_not_matched_tight[1][0]+ n_not_matched_tight[1][1]+ n_not_matched_tight[1][2]+
    n_not_matched_tight[1][3]+ n_not_matched_tight[1][4]+ n_not_matched_tight[1][5];
  int n_not_matched_2_tight = n_not_matched_tight[2][0]+ n_not_matched_tight[2][1]+ n_not_matched_tight[2][2]+
    n_not_matched_tight[2][3]+ n_not_matched_tight[2][4]+ n_not_matched_tight[2][5];
  int n_not_matched_3_tight = n_not_matched_tight[3][0]+ n_not_matched_tight[3][1]+ n_not_matched_tight[3][2]+
    n_not_matched_tight[3][3]+ n_not_matched_tight[3][4]+ n_not_matched_tight[3][5];
  int n_not_matched_4_tight = n_not_matched_tight[4][0]+ n_not_matched_tight[4][1]+ n_not_matched_tight[4][2]+
    n_not_matched_tight[4][3]+ n_not_matched_tight[4][4]+ n_not_matched_tight[4][5];
  int n_not_matched_5_tight = n_not_matched_tight[5][0]+ n_not_matched_tight[5][1]+ n_not_matched_tight[5][2]+
    n_not_matched_tight[5][3]+ n_not_matched_tight[5][4]+ n_not_matched_tight[5][5];
  int n_not_matched_tot_tight = n_not_matched_0_tight + n_not_matched_1_tight + n_not_matched_2_tight + 
    n_not_matched_3_tight + n_not_matched_4_tight+n_not_matched_5_tight;


  Info("finalize()", "  ");
  Info("finalize()", "Study for non-matched: all taus");
  Info("finalize()", "-------------------------------");
  Info("finalize()", "Total fake taus collected: %7i", n_not_matched_tot);
  Info("finalize()", "tracks    total     0f     1f     2f     3f     4f     5f");
  //..................0-track:   5675      0      0      0      0      0
  Info("finalize()", "0-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_0,
       n_not_matched[0][0], n_not_matched[0][1], n_not_matched[0][2], 
       n_not_matched[0][3], n_not_matched[0][4], n_not_matched[0][5]);
  Info("finalize()", "1-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_1,
       n_not_matched[1][0], n_not_matched[1][1], n_not_matched[1][2], 
       n_not_matched[1][3], n_not_matched[1][4], n_not_matched[1][5]);       
  Info("finalize()", "2-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_2,
       n_not_matched[2][0], n_not_matched[2][1], n_not_matched[2][2], 
       n_not_matched[2][3], n_not_matched[2][4], n_not_matched[2][5]);       
  Info("finalize()", "3-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_3,
       n_not_matched[3][0], n_not_matched[3][1], n_not_matched[3][2], 
       n_not_matched[3][3], n_not_matched[3][4], n_not_matched[3][5]);       
  Info("finalize()", "4-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_4,
       n_not_matched[4][0], n_not_matched[4][1], n_not_matched[4][2], 
       n_not_matched[4][3], n_not_matched[4][4], n_not_matched[4][5]);       
  Info("finalize()", "n-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_5,
       n_not_matched[5][0], n_not_matched[5][1], n_not_matched[5][2], 
       n_not_matched[5][3], n_not_matched[5][4], n_not_matched[5][5]);      

  Info("finalize()", "Fake rates: x-track-to-1-track:  %6.4f", double(n_not_matched_1)/double(n_not_matched_tot));
  Info("finalize()", "Fake rates: x-track-to-3-track:  %6.4f", double(n_not_matched_3)/double(n_not_matched_tot));

  Info("finalize()", "Fake rates: x-track-to-1-ftrack: %6.4f", 
       double(n_not_matched[0][1]+n_not_matched[1][1]+n_not_matched[2][1]+n_not_matched[3][1]+
	      n_not_matched[4][1]+n_not_matched[5][1]) / double(n_not_matched_tot));
  Info("finalize()", "Fake rates: x-track-to-3-ftrack: %6.4f", 
       double(n_not_matched[0][3] + n_not_matched[1][3] + n_not_matched[2][3] + 
	      n_not_matched[3][3] + n_not_matched[4][3] + n_not_matched[5][3])/
       double(n_not_matched_tot));

  Info("finalize()", "Study for non-matched: loose taus");
  Info("finalize()", "-------------------------------");
  Info("finalize()", "Total fake taus collected: %7i", n_not_matched_tot_loose);
  Info("finalize()", "tracks    total     0f     1f     2f     3f     4f     5f");
  //..................0-track:   5675      0      0      0      0      0
  Info("finalize()", "0-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_0_loose,
       n_not_matched_loose[0][0], n_not_matched_loose[0][1], n_not_matched_loose[0][2], 
       n_not_matched_loose[0][3], n_not_matched_loose[0][4], n_not_matched_loose[0][5]);
  Info("finalize()", "1-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_1_loose,
       n_not_matched_loose[1][0], n_not_matched_loose[1][1], n_not_matched_loose[1][2], 
       n_not_matched_loose[1][3], n_not_matched_loose[1][4], n_not_matched_loose[1][5]);       
  Info("finalize()", "2-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_2_loose,
       n_not_matched_loose[2][0], n_not_matched_loose[2][1], n_not_matched_loose[2][2], 
       n_not_matched_loose[2][3], n_not_matched_loose[2][4], n_not_matched_loose[2][5]);       
  Info("finalize()", "3-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_3_loose,
       n_not_matched_loose[3][0], n_not_matched_loose[3][1], n_not_matched_loose[3][2], 
       n_not_matched_loose[3][3], n_not_matched_loose[3][4], n_not_matched_loose[3][5]);       
  Info("finalize()", "4-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_4_loose,
       n_not_matched_loose[4][0], n_not_matched_loose[4][1], n_not_matched_loose[4][2], 
       n_not_matched_loose[4][3], n_not_matched_loose[4][4], n_not_matched_loose[4][5]);       
  Info("finalize()", "n-track:  %5i  %5i  %5i  %5i  %5i  %5i  %5i", n_not_matched_5_loose,
       n_not_matched_loose[5][0], n_not_matched_loose[5][1], n_not_matched_loose[5][2], 
       n_not_matched_loose[5][3], n_not_matched_loose[5][4], n_not_matched_loose[5][5]);      

  Info("finalize()", "Fake rates: x-track-to-1-track:  %6.4f", double(n_not_matched_1_loose)/double(n_not_matched_tot_loose));
  Info("finalize()", "Fake rates: x-track-to-3-track:  %6.4f", double(n_not_matched_3_loose)/double(n_not_matched_tot_loose));

  Info("finalize()", "Fake rates: x-track-to-1-ftrack: %6.4f", 
       double(n_not_matched_loose[0][1]+n_not_matched_loose[1][1]+n_not_matched_loose[2][1]+n_not_matched_loose[3][1]+
	      n_not_matched_loose[4][1]+n_not_matched_loose[5][1]) / double(n_not_matched_tot_loose));
  Info("finalize()", "Fake rates: x-track-to-3-ftrack: %6.4f", 
       double(n_not_matched_loose[0][3] + n_not_matched_loose[1][3] + n_not_matched_loose[2][3] + 
	      n_not_matched_loose[3][3] + n_not_matched_loose[4][3] + n_not_matched_loose[5][3])/
       double(n_not_matched_tot_loose));
  Info("finalize()", "  ");
  Info("finalize()", "  ");
  Info("finalize()", "Conversion tagger on backgrounds");
  Info("finalize()", "NoID:   1/2ft  2ft-1ct: %5i %5i  %5i %6.3f",  
       n_not_matched_1,       n_not_matched_2, n_not_matched_2_c1,  double(n_not_matched_1+n_not_matched_2_c1)/double(n_not_matched_1));
  Info("finalize()", "loose:  1/2ft  2ft-1ct: %5i %5i  %5i %6.3f",  
       n_not_matched_1_loose, n_not_matched_2_loose,  n_not_matched_2_loose_c1,double(n_not_matched_1_loose+n_not_matched_2_loose_c1)/double(n_not_matched_1_loose));
  Info("finalize()", "medium: 1/2ft  2ft-1ct: %5i  %5i %5i %6.3f",  
       n_not_matched_1_medium,n_not_matched_2_medium, n_not_matched_2_medium_c1,double(n_not_matched_1_medium+n_not_matched_2_medium_c1)/double(n_not_matched_1_medium));
  Info("finalize()", "tight:  1/2ft  2ft-1ct: %5i  %5i %5i %6.3f",  
       n_not_matched_1_tight, n_not_matched_2_tight,  n_not_matched_2_tight_c1,double(n_not_matched_1_tight+n_not_matched_2_tight_c1)/double(n_not_matched_1_tight));

  //  std::cout << "I have finalized here" << std::endl;
  return EL::StatusCode::SUCCESS;
}



EL::StatusCode MyxAODAnalysis :: histFinalize ()
{
  // This method is the mirror image of histInitialize(), meaning it
  // gets called after the last event has been processed on the worker
  // node and allows you to finish up any objects you created in
  // histInitialize() before they are written to disk.  This is
  // actually fairly rare, since this happens separately for each
  // worker node.  Most of the time you want to do your
  // post-processing on the submission node after all your histogram
  // outputs have been merged.  This is different from finalize() in
  // that it gets called on all worker nodes regardless of whether
  // they processed input events.
  return EL::StatusCode::SUCCESS;
}



// additional methods for the implementation of the cone

int MyxAODAnalysis :: Compare4VectorWithList(TLorentzVector vec, std::vector<TLorentzVector> collection) {
  for (int i=0; i < (int) collection.size() ; ++i ) {
    if (Compare4Vectors(vec, collection[i])) return i;
  }
  return -1;
}

bool MyxAODAnalysis :: Compare4Vectors(TLorentzVector vec1, TLorentzVector vec2) {

  return fabs(vec1.Pt() - vec2.Pt()) < 0.001 && fabs(vec1.Eta() - vec2.Eta()) < 0.001   &&(vec1.DeltaPhi(vec2) < 0.001) ;

}

float MyxAODAnalysis :: ComputePi0Cone(int recProngs,TLorentzVector tau){
   float angle = -1;
   float atrue = 0, arec = 0;
   float p = tau.P(), eta = fabs(tau.Eta());   
   int npar = 4, npol = 9;
   float a[9][4];
   switch(recProngs){
      case 3:  //3 Prong Case
         a[0][0] = 0.0419208; a[1][0] = 0.0481497; a[2][0] = -0.0225545; a[3][0] = 0; a[4][0] = 0; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
         a[0][1] = -0.00568661; a[1][1] = -0.00336825; a[2][1] = 0.00172832; a[3][1] = 0; a[4][1] = 0; a[5][1] = 0; a[6][1] = 0; a[7][1] = 0; a[8][1] = 0; 
         a[0][2] = 0.00177496; a[1][2] = 0.00296773; a[2][2] = -0.00123081; a[3][2] = 0; a[4][2] = 0; a[5][2] = 0; a[6][2] = 0; a[7][2] = 0; a[8][2] = 0; 
         a[0][3] = 90.9262; a[1][3] = -89.7105; a[2][3] = 49.0447; a[3][3] = 0; a[4][3] = 0; a[5][3] = 0; a[6][3] = 0; a[7][3] = 0; a[8][3] = 0; 
         atrue = ComputeAngle(p,eta,a,npar,npol);
         a[0][0] = 0.187427; a[1][0] = -0.0816934; a[2][0] = 0.0116366; a[3][0] = 0; a[4][0] = 0; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
         a[0][1] = -0.00961135; a[1][1] = 0.0188071; a[2][1] = -0.0279819; a[3][1] = 0.0175981; a[4][1] = -0.00374356; a[5][1] = 0; a[6][1] = 0; a[7][1] = 0; a[8][1] = 0; 
         a[0][2] = 0.0139015; a[1][2] = -0.0572689; a[2][2] = 0.0897538; a[3][2] = -0.0543513; a[4][2] = 0.0110609; a[5][2] = 0; a[6][2] = 0; a[7][2] = 0; a[8][2] = 0; 
         a[0][3] = -57.066; a[1][3] = 731.569; a[2][3] = -2351.02; a[3][3] = 3576.75; a[4][3] = -2802.87; a[5][3] = 1081.43; a[6][3] = -161.098; a[7][3] = 0; a[8][3] = 0; 
         arec = ComputeAngle(p,eta,a,npar,npol);
         break;
      case 1: //1 Prong Case
         a[0][0] = 0.077467; a[1][0] = -0.0648352; a[2][0] = 0.15807; a[3][0] = -0.111211; a[4][0] = 0.0223358; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
         a[0][1] = -0.0212485; a[1][1] = 0.213133; a[2][1] = -1.10606; a[3][1] = 2.81065; a[4][1] = -3.95237; a[5][1] = 3.21507; a[6][1] = -1.50167; a[7][1] = 0.373201; a[8][1] = -0.0381986; 
         a[0][2] = 0.0180949; a[1][2] = -0.215859; a[2][2] = 1.06949; a[3][2] = -2.61577; a[4][2] = 3.56621; a[5][2] = -2.82425; a[6][2] = 1.28799; a[7][2] = -0.313272; a[8][2] = 0.0314451; 
         a[0][3] = 55.3658; a[1][3] = 83.3644; a[2][3] = -243.958; a[3][3] = 303.823; a[4][3] = -257.709; a[5][3] = 125.826; a[6][3] = -23.0882; a[7][3] = 0; a[8][3] = 0; 
         atrue = ComputeAngle(p,eta,a,npar,npol);
         a[0][0] = 0.0887773; a[1][0] = 0.183147; a[2][0] = -0.53342; a[3][0] = 0.511497; a[4][0] = -0.207361; a[5][0] = 0.0299467; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
         a[0][1] = 0.00529589; a[1][1] = -0.0931825; a[2][1] = 0.331541; a[3][1] = -0.501175; a[4][1] = 0.356803; a[5][1] = -0.118988; a[6][1] = 0.0150108; a[7][1] = 0; a[8][1] = 0; 
         a[0][2] = -0.0152482; a[1][2] = 0.203442; a[2][2] = -0.799957; a[3][2] = 1.29237; a[4][2] = -0.943621; a[5][2] = 0.315001; a[6][2] = -0.0392101; a[7][2] = 0; a[8][2] = 0; 
         a[0][3] = 46.0655; a[1][3] = -61.8671; a[2][3] = 278.08; a[3][3] = -385.329; a[4][3] = 199.816; a[5][3] = -34.0016; a[6][3] = 0; a[7][3] = 0; a[8][3] = 0; 
         arec = ComputeAngle(p,eta,a,npar,npol);
	 //	 std::cout << "DEBUG: " << atrue << " ,  " << arec <<  "  for tau eta: " << eta <<   std::endl;
         break; 
      default:
	std::cout << "ERROR!!!  Incorrect number of prongs!" << std::endl;
         return angle;
   }
   if (atrue > arec) angle = atrue;
   else angle = arec;
   return angle;
} //End ComputePi0Cone


float MyxAODAnalysis :: ComputeAngle(float p, float eta, float a[9][4], int npar, int npol, char eqn[]){
   char name[10];
   char poleqn[10];
   
   TF1* etacoeff[npar];
   TF1* pcone = new TF1("pcone",eqn); 
   for(int i=0;i<npar;i++){
      sprintf(name,"p%i",i);
      sprintf(poleqn,"pol%i",npol);
      etacoeff[i] = new TF1(name,poleqn);
      for(int j=0;j<npol;j++) etacoeff[i]->SetParameter(j,a[j][i]);
		pcone->SetParameter(i,etacoeff[i]->Eval(eta));
		delete etacoeff[i];
   }
   float angle = pcone->Eval(p);
   delete pcone;
   return angle;
}

float MyxAODAnalysis :: Compute1dim(float p, float a[10], int npar, char eqn[]){
   TF1* pcone = new TF1("pcone",eqn); 
   for(int i=0;i<npar;i++) pcone->SetParameter(i,a[i]);
   float angle = pcone->Eval(p);
   delete pcone;
   return angle;
}





bool MyxAODAnalysis ::  pass3prong(std::vector<TrackInfo> combination,TLorentzVector tau){

  //Step 1: calculate angles
  TrackPair lp, lm, sp, ls, ms, mp;
  
  lm.angle = fabs(combination[0].p4.Angle(combination[1].p4.Vect()));
  lm.mass = (combination[0].p4+combination[1].p4).M();
  lm.charge = combination[0].charge*combination[1].charge;
  ls.angle = fabs(combination[0].p4.Angle(combination[2].p4.Vect()));
  ls.mass = (combination[0].p4+combination[2].p4).M();
  ls.charge = combination[0].charge*combination[2].charge;
  ms.angle = fabs(combination[1].p4.Angle(combination[2].p4.Vect()));
  ms.mass = (combination[1].p4+combination[2].p4).M();
  ms.charge = combination[1].charge*combination[2].charge;
  
  lp = lm;
  if(ls.angle > lp.angle){
    mp = lp;
    lp = ls;
  }
  else mp = ls;
  if(ms.angle > lp.angle){
    sp = mp;
    mp = lp;
    lp = ms;
  }   
  else if(ms.angle > mp.angle){
    sp = mp;
    mp = ms;
  }
  else sp = ms;
  
  if (lp.angle < mp.angle) std::cout << "ERROR!!!! largest angle is smaller than medium angle!" << std::endl;
  if (lp.angle < sp.angle) std::cout << "ERROR!!!! largest angle is smaller than smallest angle!" << std::endl;
  if (mp.angle < sp.angle) std::cout << "ERROR!!!! medium angle is smaller than smallest angle!" << std::endl;
  
  //Step 3: calculate 99% angles
  float lp99 = 0, sp99 = 0, lm99 = 0, ls99 = 0;
  float p = tau.P(), eta = fabs(tau.Eta());
  
  float a[9][4];
  int npar = 4, npol = 3;
  
  a[0][0] = 0.179041; a[1][0] = -0.0531058; a[2][0] = 0; 
  a[0][1] = -0.0146875; a[1][1] = 0.00414247; a[2][1] = -0.000612045; 
  a[0][2] = 0.0188939; a[1][2] = -0.00452375; a[2][2] = 0.00120015; 
  a[0][3] = 58.3066; a[1][3] = -48.2594; a[2][3] = 26.8864; 
  lp99 = ComputeAngle(p,eta,a,npar,npol);
  a[0][0] = 0.0741985; a[1][0] = -0.0181941; a[2][0] = 0; 
  a[0][1] = -0.0149252; a[1][1] = 0.00512965; a[2][1] = -0.00125462; 
  a[0][2] = 0.00802004; a[1][2] = -0.00252272; a[2][2] = 0.000761022; 
  a[0][3] = 25.0145; a[1][3] = 0; a[2][3] = 0; 
  sp99 = ComputeAngle(p,eta,a,npar,npol);
  a[0][0] = 0.102084; a[1][0] = -0.0256446; a[2][0] = 0; 
  a[0][1] = -0.014259; a[1][1] = 0.00465467; a[2][1] = -0.00122856; 
  a[0][2] = 0.010552; a[1][2] = -0.00176856; a[2][2] = 0.000446776; 
  a[0][3] = 36.0848; a[1][3] = -16.1489; a[2][3] = 10.2994; 
  lm99 = ComputeAngle(p,eta,a,npar,npol);
  a[0][0] = 0.152783; a[1][0] = -0.0390978; a[2][0] = 0; 
  a[0][1] = -0.0139914; a[1][1] = 0.00352551; a[2][1] = -0.000624039; 
  a[0][2] = 0.0159925; a[1][2] = -0.00332104; a[2][2] = 0.00100568; 
  a[0][3] = 43.5804; a[1][3] = -18.681; a[2][3] = 6.29988; 
  ls99 = ComputeAngle(p,eta,a,npar,npol);

  std::cout << "filter pass3prong angles  lp vs lp99 " << lp.angle << " / " << lp99
	    << " sp vs sp99 " << sp.angle << " / " << sp99 
	    << " lm vs lm99 " << lm.angle << " / " << lm99 
	    << " ls vs ls99 " << ls.angle << " / " << ls99 << std::endl;

  //Step 4: compare angles and track masses, pass if all pass, fail otherwise
  if((lp.angle > lp99)||(sp.angle > sp99)||(lm.angle > lm99)||(ls.angle > ls99)) return false; //One or more of the angles has failed - not a three prong tau
  return true; //Track combination is a 3prong candidate!
} //End pass3prong (efficiency studies)

bool  MyxAODAnalysis :: pass2prong(std::vector<TrackInfo> pair,TLorentzVector tau){
   float angle = fabs(pair[0].p4.Angle(pair[1].p4.Vect()));
   int  charge = pair[0].charge*pair[1].charge;

   float lt99 = 0,mt99 = 0,st99 = 0, ct99 = 0, lp99 = 0, mp99 = 0, sp99 = 0, los99 = 0, sos99 = 0, ss99 = 0, lm99 = 0, ls99 = 0, ms99 = 0;
   float p = tau.P(), eta = fabs(tau.Eta());
   
   float a[9][4];
   int npar = 4, npol = 9;

   a[0][0] = 0.0584232; a[1][0] = -0.0177642; a[2][0] = 0; a[3][0] = 0; a[4][0] = 0; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
   a[0][1] = 0.0447435; a[1][1] = -0.659295; a[2][1] = 2.99202; a[3][1] = -6.10742; a[4][1] = 6.34017; a[5][1] = -3.49095; a[6][1] = 0.972228; a[7][1] = -0.107807; a[8][1] = 0; 
   a[0][2] = -0.249078; a[1][2] = 3.75779; a[2][2] = -18.9563; a[3][2] = 45.4474; a[4][2] = -59.333; a[5][2] = 44.722; a[6][2] = -19.4586; a[7][2] = 4.54039; a[8][2] = -0.4399; 
   a[0][3] = 124.481; a[1][3] = -1129.76; a[2][3] = 5198.92; a[3][3] = -10538.1; a[4][3] = 10741.4; a[5][3] = -5757; a[6][3] = 1548.86; a[7][3] = -164.644; a[8][3] = 0; 
   lt99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.057286; a[1][0] = -0.0168061; a[2][0] = 0; a[3][0] = 0; a[4][0] = 0; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
a[0][1] = 0.0640448; a[1][1] = -0.922493; a[2][1] = 4.10239; a[3][1] = -8.19704; a[4][1] = 8.35619; a[5][1] = -4.52961; a[6][1] = 1.24415; a[7][1] = -0.136244; a[8][1] = 0; 
a[0][2] = -0.222389; a[1][2] = 3.34829; a[2][2] = -16.8256; a[3][2] = 40.1156; a[4][2] = -52.0129; a[5][2] = 38.9152; a[6][2] = -16.8076; a[7][2] = 3.89426; a[8][2] = -0.374831; 
a[0][3] = 97.8443; a[1][3] = -804.025; a[2][3] = 3412.76; a[3][3] = -6058.05; a[4][3] = 5028.88; a[5][3] = -1940.87; a[6][3] = 281.19; a[7][3] = 0; a[8][3] = 0; 
   ct99 = ComputeAngle(p,eta,a,npar,npol);
   npol = 3;
a[0][0] = 0.0665222; a[1][0] = 0; a[2][0] = 0; 
a[0][1] = -0.018755; a[1][1] = 0.00258183; a[2][1] = 0; 
a[0][2] = 0.045607; a[1][2] = -0.0234824; a[2][2] = 0.00375319; 
a[0][3] = 43.8011; a[1][3] = -10.0462; a[2][3] = 0; 
   mt99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.156972; a[1][0] = -0.0333305; a[2][0] = 0; 
a[0][1] = -0.0231364; a[1][1] = 0.0120482; a[2][1] = -0.00289192; 
a[0][2] = 0.0490898; a[1][2] = -0.0273084; a[2][2] = 0.00547379; 
a[0][3] = 33.1651; a[1][3] = 0; a[2][3] = 0; 
   st99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.179041; a[1][0] = -0.0531058; a[2][0] = 0; 
a[0][1] = -0.0146875; a[1][1] = 0.00414247; a[2][1] = -0.000612045; 
a[0][2] = 0.0188939; a[1][2] = -0.00452375; a[2][2] = 0.00120015; 
a[0][3] = 58.3066; a[1][3] = -48.2594; a[2][3] = 26.8864; 
   lp99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.142962; a[1][0] = -0.0397119; a[2][0] = 0; 
a[0][1] = -0.014084; a[1][1] = 0.00437622; a[2][1] = -0.000992845; 
a[0][2] = 0.0145659; a[1][2] = -0.00270987; a[2][2] = 0.00079432; 
a[0][3] = 42.4831; a[1][3] = -25.893; a[2][3] = 13.6075; 
   mp99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.0741985; a[1][0] = -0.0181941; a[2][0] = 0; 
a[0][1] = -0.0149252; a[1][1] = 0.00512965; a[2][1] = -0.00125462; 
a[0][2] = 0.00802004; a[1][2] = -0.00252272; a[2][2] = 0.000761022; 
a[0][3] = 25.0145; a[1][3] = 0; a[2][3] = 0; 
   sp99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.177021; a[1][0] = -0.0800858; a[2][0] = 0.017266; 
a[0][1] = -0.0145132; a[1][1] = 0.00508756; a[2][1] = -0.00133994; 
a[0][2] = 0.0174059; a[1][2] = -0.00407948; a[2][2] = 0.00130897; 
a[0][3] = 59.5959; a[1][3] = -51.819; a[2][3] = 28.742; 
   los99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.126153; a[1][0] = -0.0504026; a[2][0] = 0.0100601; 
a[0][1] = -0.01373; a[1][1] = 0.0040825; a[2][1] = -0.00103933; 
a[0][2] = 0.0121626; a[1][2] = -0.00239224; a[2][2] = 0.000832398; 
a[0][3] = 43.6455; a[1][3] = -34.4061; a[2][3] = 17.558; 
   sos99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.159394; a[1][0] = -0.0461081; a[2][0] = 0; 
a[0][1] = -0.0148102; a[1][1] = 0.00429109; a[2][1] = -0.000670516; 
a[0][2] = 0.0167114; a[1][2] = -0.00539364; a[2][2] = 0.00175181; 
a[0][3] = 48.371; a[1][3] = -35.9336; a[2][3] = 19.3991; 
   ss99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.102084; a[1][0] = -0.0256446; a[2][0] = 0; 
a[0][1] = -0.014259; a[1][1] = 0.00465467; a[2][1] = -0.00122856; 
a[0][2] = 0.010552; a[1][2] = -0.00176856; a[2][2] = 0.000446776; 
a[0][3] = 36.0848; a[1][3] = -16.1489; a[2][3] = 10.2994; 
   lm99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.152783; a[1][0] = -0.0390978; a[2][0] = 0; 
a[0][1] = -0.0139914; a[1][1] = 0.00352551; a[2][1] = -0.000624039; 
a[0][2] = 0.0159925; a[1][2] = -0.00332104; a[2][2] = 0.00100568; 
a[0][3] = 43.5804; a[1][3] = -18.681; a[2][3] = 6.29988; 
   ls99 = ComputeAngle(p,eta,a,npar,npol);
a[0][0] = 0.160615; a[1][0] = -0.0284831; a[2][0] = -0.00879631; 
a[0][1] = -0.0140811; a[1][1] = 0.00344844; a[2][1] = -0.000421752; 
a[0][2] = 0.0173056; a[1][2] = -0.00371573; a[2][2] = 0.00112158; 
a[0][3] = 59.28; a[1][3] = -48.2821; a[2][3] = 26.3103; 
   ms99 = ComputeAngle(p,eta,a,npar,npol);
   
   if ((angle < lm99)&&((angle < lp99)||(angle < mp99)||(angle < sp99))){   
   	if((charge == -1)&&((angle < los99)||(angle < sos99))) return true;
   	else if((charge == 1)&&(angle < ss99)) return true;
   	else return false;
   }
   else return false;
} //End pass2prong

bool  MyxAODAnalysis :: pass1prong(TLorentzVector track,TLorentzVector tau){
   //Step 1: Compute Angle Between Track and Tau
   float angle = fabs(track.Angle(tau.Vect()));
   //Step 2: Compute 99% angle
   float p = tau.P(), eta = fabs(tau.Eta());
   
   int npar = 4, npol = 3;
   float a[3][4];
   
   a[0][0] = 0.120777; a[1][0] = -0.0261681; a[2][0] = 0;
   a[0][1] = -0.0307174; a[1][1] = 0.0170112; a[2][1] = -0.00381298;
   a[0][2] = 0.0662689; a[1][2] = -0.0402811; a[2][2] = 0.00760013;
   a[0][3] = 24.512; a[1][3] = 0; a[2][3] = 0;
   float angle99 = ComputeAngle(p,eta,a,npar,npol);

   //Step 3: compare angles and return decision
   if(angle > angle99) return false; //Track angle exceeds kinematic boundary
   else return true;
} //End pass1prong

float MyxAODAnalysis :: Compute99angle(TLorentzVector track,TLorentzVector tau) {
   float p = tau.P(), eta = fabs(tau.Eta());
   
   int npar = 4, npol = 3;
   float a[3][4];
   
   a[0][0] = 0.120777; a[1][0] = -0.0261681; a[2][0] = 0;
   a[0][1] = -0.0307174; a[1][1] = 0.0170112; a[2][1] = -0.00381298;
   a[0][2] = 0.0662689; a[1][2] = -0.0402811; a[2][2] = 0.00760013;
   a[0][3] = 24.512; a[1][3] = 0; a[2][3] = 0;
   return  ComputeAngle(p,eta,a,npar,npol);

}



void  MyxAODAnalysis :: ShrinkingConeD3PDAlg(TLorentzVector tau,std::vector<TLorentzVector>* inputtracks20, std::vector<int>* inputtracks20charge, std::vector<TLorentzVector>* inputtracks40, std::vector<int>* inputtracks40charge, std::vector<TLorentzVector>* outputtracksgood, std::vector<int>* outputtracksgoodcharge, std::vector<TLorentzVector>* outputtracksbad, std::vector<int>* outputtracksbadcharge, int& nProng, int& flag, float& pi0angle, TLorentzVector* barycenter){

   std::vector<TrackInfo> unsorted,tracks,SScombination;
   TrackInfo track;
   unsigned int tracknum = inputtracks20->size();
   unsigned int widetracknum = inputtracks40->size();
   for(unsigned int i=0;i<tracknum;i++){
      track.p4 = (*inputtracks20)[i];
      track.charge = (*inputtracks20charge)[i];
      if(track.p4.M() < 1e-3) std::cerr << "WARNING: Track Mass might be incorrectly set (to zero) - Please Check and Correct." << std::endl;
      unsorted.push_back(track);
   }
   while (unsorted.size() > 0){
      float trackP = unsorted[0].p4.P();
      int index = 0;
      for(unsigned int i=1;i<unsorted.size();i++){
         if(unsorted[i].p4.P() > trackP){
            index = i;
            trackP = unsorted[i].p4.P();
         }
      }
      tracks.push_back(unsorted[index]);
      tracks[tracks.size()-1].index = tracks.size()-1;
      unsorted.erase(unsorted.begin()+index);            
   }
//Step 2: Test 3 Prong Hypothesis
//Step 2a: Arrange combinations of tracks for testing
   
   bool test3prong = true, test2prong = true, test1prong = true;
   for(unsigned int i=0;i<widetracknum;i++){
     outputtracksbad->push_back((*inputtracks40)[i]);
     outputtracksbadcharge->push_back((*inputtracks40charge)[i]);
   }
   if(tracknum > 4){ //Anything with more than 4 tracks is a fake.
     flag = 0;
     test3prong = false;
     test2prong = false;
     test1prong = false;
   }
   if(tracknum < 3) test3prong = false; //Don't test 3 prong if fewer than 3 tracks
   if(tracknum < 2) test2prong = false; //Don't test 2 prong if fewer than 2 tracks
   if(tracknum < 1){
     flag = 0;
     test1prong = false; //Don't test 1 prong if no tracks within dR < 0.2 of tau
   }
   if(test3prong){
     //Test 3 Highest pT Tracks
     bool isSS = false;
     std::vector<TrackInfo> combination;
     int charge = 0; TLorentzVector threetrack;
     for(unsigned int i=0;i<3;i++){
       combination.push_back(tracks[i]); //Only Care about 3 Highest pT Tracks
       charge+=tracks[i].charge;
       threetrack+=tracks[i].p4;
     }
     if((tracknum == 3) && (abs(charge)!=1)) isSS = true; //Reject all same-sign combinations
     //Step 2b: Check kinematics of track combinations against shrinking cones and mass boundaries
     //         for(unsigned int i=0;i<combinations.size();i++){
     bool goodcombo = false;
     if(tracknum == 4){
       char eqn[] = "pol2";
       float a[] = {1.51673, -0.000150534, 2.64226e-06};
       float mass99 = Compute1dim(tau.P(),a,3,eqn);
       if((threetrack.M() < mass99)&&(pass3prong(combination,tau))){
	 goodcombo=true;
	 flag = 2;
       }
     }
     else if(pass3prong(combination, tau)){
       goodcombo=true;
       flag = 1;
     }
     else{
       goodcombo=false;
       if(tracknum == 4){
	 flag = 0;
	 test1prong=false;
	 test2prong=false;
       }
     }
     if(goodcombo){  //A Combination is found which passes 3prong hypothesis
       for(unsigned int i=0;i<combination.size();i++){
	 if (isSS) SScombination.push_back(combination[i]);
	 else{
	   outputtracksgood->push_back(combination[i].p4);
	   outputtracksgoodcharge->push_back(combination[i].charge);
	 }
       }
       nProng = 3;
       if(!isSS){
	 test1prong = false;
	 test2prong = false;
       }
       if(!test1prong){ //Fill Bad Track in the Case of 4 trk taus
	 if(tracknum == 4){
	   outputtracksbad->push_back(tracks[3].p4);
	   outputtracksbadcharge->push_back(tracks[3].charge);
	 }
       }
     }
   }//End 3 Prong Test Conditional
   if (test2prong){
     std::vector<TrackInfo> pair;
     for(unsigned int i=0;i<2;i++) pair.push_back(tracks[i]);
     if(pass2prong(pair,tau)){
       nProng = 2;
       for(unsigned int i=0;i<pair.size();i++){ //Fill Good Tracks
	 outputtracksgood->push_back(pair[i].p4);
	 outputtracksgoodcharge->push_back(pair[i].charge);
       }
       test1prong = false;
       if(tracknum == 3){
	 flag = 2;
	 outputtracksbad->push_back(tracks[2].p4); //Fill Bad Track in Case of 3 trk Taus
	 outputtracksbadcharge->push_back(tracks[2].charge);
       }
       else flag = 1; //Good 2 Prong if only 2 trks

     }
     else if(tracknum == 3){ //Flag as a fake 3 trk tau if 2 trk hypothesis doesn't pass
       flag = 0;
       if(SScombination.size()>0){
	 nProng = 3;
	 for(unsigned int i=0;i<SScombination.size();i++){
	   outputtracksgood->push_back(SScombination[i].p4);
	   outputtracksgoodcharge->push_back(SScombination[i].charge);
	 }
       }
       test1prong = false;
     }
     std::cout << "filter: for this particular tau with pT: " << tau.Pt() << " pass2prong: "
	       << pass2prong(pair,tau) << " nProng: " << nProng << " flag: " << flag <<      std::endl;
   }//End 2 Prong Test Conditional
   //Step 4: Check tracks that don't pass 2 prong hypothesis against 1 prong hypothesis
   if (test1prong){
     char eqn[] = "([0]*exp([1]*x))*pol6(2)+[9]";
     float a[10];
     a[0] = 0.079586;
     a[1] = -0.0289929;
     a[2] = 7.06684;
     a[3] = -0.158835;
     a[4] = 0.000607181;
     a[5] = 6.8445e-05;
     a[6] = -6.79205e-07;
     a[7] = 2.13158e-09;
     a[8] = -5.11643e-13;
     a[9] = 0.030376;
     float ratio10 = Compute1dim(tau.P(),a,10,eqn);
     bool goodcase = false;
     if(tracknum == 1) goodcase = true;
     if(tracknum == 2){
       if(tracks[1].p4.Pt()/tracks[0].p4.Pt() < ratio10) goodcase = true; //Test 2trk taus most likely to actually be 1pngs
     }
     if((pass1prong(tracks[0].p4,tau))&&(goodcase)){ //A track is found which passes 1prong hypothesis
       outputtracksgood->push_back(tracks[0].p4);
       outputtracksgoodcharge->push_back(tracks[0].charge);
       nProng = 1;
       if (tracknum == 2){
	 flag = 2;
	 outputtracksbad->push_back(tracks[1].p4); //Fill Bad Track in Case of 3 trk Taus
	 outputtracksbadcharge->push_back(tracks[1].charge);
       }
       else flag = 1;
     }
     else flag = 0; //Fake Tau
   }//End 1 Prong Test Conditional
   if(flag == 0){
     pi0angle = -99;      	
     if((SScombination.size()>0)&&(tracknum == 3)){
       nProng = 3;
       for(unsigned int i=0;i<SScombination.size();i++){
	 outputtracksgood->push_back(SScombination[0].p4);
	 outputtracksgoodcharge->push_back(SScombination[0].charge);
       }
     }
     else if(SScombination.size() == 0){
       for (unsigned int i=0;i<tracknum;i++){
	 outputtracksbad->push_back(tracks[i].p4);
	 outputtracksbadcharge->push_back(tracks[i].charge);
       }
       nProng = 0;
     }
   }
   //     cout << "Step 4 complete" << endl;
   //Step 5: If not a fake/2png, Compute Pi0 Cone and Barycenter
   if(flag != 0){
     int recProng = 0;
     if((nProng == 3)||(nProng == 2)) recProng = 3;
     if(nProng == 1) recProng = 1;
     for(unsigned int i = 0;i<outputtracksgood->size();i++) (*barycenter)+=(*outputtracksgood)[i];
     pi0angle = ComputePi0Cone(recProng,tau);
     if(pi0angle < 0) std::cout << "ERROR!!! 99% pi0angle < 0 - This means something is wrong with the parametrizations" << std::endl;
   }
   return;
}












//-----------------------------------------------------------------------------
// Main algorithm
//-----------------------------------------------------------------------------
void  MyxAODAnalysis :: TrackFilterAlg(TLorentzVector tau,
                    std::vector<TLorentzVector>* inputtracks20,
                    std::vector<int>* inputtracks20charge,
                    std::vector<TLorentzVector>* inputtracks40,
                    std::vector<int>* inputtracks40charge,
                    std::vector<TLorentzVector>* outputtracksgood,
                    std::vector<int>* outputtracksgoodcharge,
                    std::vector<TLorentzVector>* outputtracksbad,
                    std::vector<int>* outputtracksbadcharge,
                    int& nProng,
                    int& flag) {

   std::vector<TrackInfo> unsorted,tracks,SScombination;
   TrackInfo track;
   unsigned int tracknum = inputtracks20->size();
   unsigned int widetracknum = inputtracks40->size();
   for(unsigned int i=0;i<tracknum;i++){
      track.p4 = (*inputtracks20)[i];
      track.charge = (*inputtracks20charge)[i];
      unsorted.push_back(track);
   }
   while (unsorted.size() > 0){
      float trackP = unsorted[0].p4.P();
      int index = 0;
      for(unsigned int i=1;i<unsorted.size();i++){
         if(unsorted[i].p4.P() > trackP){
            index = i;
            trackP = unsorted[i].p4.P();
         }
      }
      tracks.push_back(unsorted[index]);
      tracks[tracks.size()-1].index = tracks.size()-1;
      unsorted.erase(unsorted.begin()+index);            
   }
//Step 2: Test 3 Prong Hypothesis
//Step 2a: Arrange combinations of tracks for testing
   
   bool test3prong = true, test2prong = true, test1prong = true;
   for(unsigned int i=0;i<widetracknum;i++){
   	outputtracksbad->push_back((*inputtracks40)[i]);
   	outputtracksbadcharge->push_back((*inputtracks40charge)[i]);
   }
   if(tracknum > 4){ //Anything with more than 4 tracks is a fake.
      flag = 0;
      test3prong = false;
      test2prong = false;
      test1prong = false;
   }
   if(tracknum < 3) test3prong = false; //Don't test 3 prong if fewer than 3 tracks
   if(tracknum < 2) test2prong = false; //Don't test 2 prong if fewer than 2 tracks
   if(tracknum < 1){
      flag = 0;
      test1prong = false; //Don't test 1 prong if no tracks within dR < 0.2 of tau
   }
   if(test3prong){
		//Test 3 Highest pT Tracks
      bool isSS = false;
      std::vector<TrackInfo> combination;
      int charge = 0; TLorentzVector threetrack;
      for(unsigned int i=0;i<3;i++){
      	combination.push_back(tracks[i]); //Only Care about 3 Highest pT Tracks
         charge+=tracks[i].charge;
         threetrack+=tracks[i].p4;
      }
      if((tracknum == 3) && (abs(charge)!=1)) isSS = true; //Reject all same-sign combinations
//Step 2b: Check kinematics of track combinations against shrinking cones and mass boundaries
//         for(unsigned int i=0;i<combinations.size();i++){
		bool goodcombo = false;
		if(tracknum == 4){
      	char eqn[] = "pol2";
   		float a[] = {1.51673, -0.000150534, 2.64226e-06};
			float mass99 = Compute1dim_1(tau.P(),a,3,eqn);
			if((threetrack.M() < mass99)&&(pass3prong_1(combination,tau))){
				goodcombo=true;
				flag = 2;
			}
         else flag = 0;
         test1prong=false;
         test2prong=false;
		}
      else if(pass3prong_1(combination, tau)){
         goodcombo=true;
         flag = 1;
      }
      if(goodcombo){  //A Combination is found which passes 3prong hypothesis
         for(unsigned int i=0;i<combination.size();i++){
            if (isSS) SScombination.push_back(combination[i]);
            outputtracksgood->push_back(combination[i].p4);
            outputtracksgoodcharge->push_back(combination[i].charge);
         }
         if(isSS) flag = 0;
         else flag = 1;
         nProng = 3;
         test1prong = false;
         test2prong = false;
         if(!test1prong){ //Fill Bad Track in the Case of 4 trk taus
            if(tracknum == 4){
            	outputtracksbad->push_back(tracks[3].p4);
            	outputtracksbadcharge->push_back(tracks[3].charge);
            }
         }
      }
   }//End 3 Prong Test Conditional
   if (test2prong){
      std::vector<TrackInfo> pair;
      for(unsigned int i=0;i<2;i++) pair.push_back(tracks[i]);
      if(pass2prong_1(pair,tau)){
      	nProng = 2;
         for(unsigned int i=0;i<pair.size();i++){ //Fill Good Tracks
            outputtracksgood->push_back(pair[i].p4);
            outputtracksgoodcharge->push_back(pair[i].charge);
         }
         test1prong = false;
         if(tracknum == 3){
            flag = 2;
         	outputtracksbad->push_back(tracks[2].p4); //Fill Bad Track in Case of 3 trk Taus
         	outputtracksbadcharge->push_back(tracks[2].charge);
         }
         else flag = 1; //Good 2 Prong if only 2 trks
      }
   }//End 2 Prong Test Conditional
//Step 4: Check tracks that don't pass 2 prong hypothesis against 1 prong hypothesis
     if (test1prong){
         char eqn[] = "([0]*exp([1]*x))*pol6(2)+[9]";
         float a[10];
         a[0] = 0.079586;
         a[1] = -0.0289929;
         a[2] = 7.06684;
         a[3] = -0.158835;
         a[4] = 0.000607181;
         a[5] = 6.8445e-05;
         a[6] = -6.79205e-07;
         a[7] = 2.13158e-09;
         a[8] = -5.11643e-13;
         a[9] = 0.030376;
         float ratio10 = Compute1dim(tau.P(),a,10,eqn);
         bool goodcase = false;
         if(tracknum == 1) goodcase = true;
         if(tracknum == 2){
            if(tracks[1].p4.Pt()/tracks[0].p4.Pt() < ratio10) goodcase = true; //Test 2trk taus most likely to actually be 1pngs
         }
         if((pass1prong_1(tracks[0].p4,tau))&&(goodcase)){ //A track is found which passes 1prong hypothesis
            outputtracksgood->push_back(tracks[0].p4);
            outputtracksgoodcharge->push_back(tracks[0].charge);
            nProng = 1;
            if (tracknum == 2){
               flag = 2;
            	outputtracksbad->push_back(tracks[1].p4); //Fill Bad Track in Case of 3 trk Taus
            	outputtracksbadcharge->push_back(tracks[1].charge);
            }
            else flag = 1;
         }
         else flag = 0; //Fake Tau
     }//End 1 Prong Test Conditional

     return;
}





/////////// copy the classes from the TauTrackFilterUtils

bool MyxAODAnalysis :: pass3prong_1(std::vector<TrackInfo> combination,TLorentzVector tau){

   //Step 1: calculate angles
   TrackPair lp, lm, sp, ls, ms, mp;
   
   lm.angle = fabs(combination[0].p4.Angle(combination[1].p4.Vect()));
   lm.mass = (combination[0].p4+combination[1].p4).M();
   lm.charge = combination[0].charge*combination[1].charge;
   ls.angle = fabs(combination[0].p4.Angle(combination[2].p4.Vect()));
   ls.mass = (combination[0].p4+combination[2].p4).M();
   ls.charge = combination[0].charge*combination[2].charge;
   ms.angle = fabs(combination[1].p4.Angle(combination[2].p4.Vect()));
   ms.mass = (combination[1].p4+combination[2].p4).M();
   ms.charge = combination[1].charge*combination[2].charge;

	lp = lm;
	if(ls.angle > lp.angle){
		mp = lp;
		lp = ls;
	}
	else mp = ls;
	if(ms.angle > lp.angle){
		sp = mp;
		mp = lp;
		lp = ms;
	}   
	else if(ms.angle > mp.angle){
		sp = mp;
		mp = ms;
	}
	else sp = ms;

   //if (lp.angle < mp.angle) ATH_MSG_WARNING("Largest angle is smaller than medium angle!");
   //if (lp.angle < sp.angle) ATH_MSG_WARNING("Largest angle is smaller than smallest angle!");
   //if (mp.angle < sp.angle) ATH_MSG_WARNING("Medium angle is smaller than smallest angle!");
   
   //Step 3: calculate 99% angles
   float lp99 = 0, sp99 = 0, lm99 = 0, ls99 = 0;
   float p = tau.P(), eta = fabs(tau.Eta());
   
   float a[9][4];
   int npar = 4, npol = 3;

a[0][0] = 0.179041; a[1][0] = -0.0531058; a[2][0] = 0; 
a[0][1] = -0.0146875; a[1][1] = 0.00414247; a[2][1] = -0.000612045; 
a[0][2] = 0.0188939; a[1][2] = -0.00452375; a[2][2] = 0.00120015; 
a[0][3] = 58.3066; a[1][3] = -48.2594; a[2][3] = 26.8864; 
   lp99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.0741985; a[1][0] = -0.0181941; a[2][0] = 0; 
a[0][1] = -0.0149252; a[1][1] = 0.00512965; a[2][1] = -0.00125462; 
a[0][2] = 0.00802004; a[1][2] = -0.00252272; a[2][2] = 0.000761022; 
a[0][3] = 25.0145; a[1][3] = 0; a[2][3] = 0; 
   sp99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.102084; a[1][0] = -0.0256446; a[2][0] = 0; 
a[0][1] = -0.014259; a[1][1] = 0.00465467; a[2][1] = -0.00122856; 
a[0][2] = 0.010552; a[1][2] = -0.00176856; a[2][2] = 0.000446776; 
a[0][3] = 36.0848; a[1][3] = -16.1489; a[2][3] = 10.2994; 
   lm99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.152783; a[1][0] = -0.0390978; a[2][0] = 0; 
a[0][1] = -0.0139914; a[1][1] = 0.00352551; a[2][1] = -0.000624039; 
a[0][2] = 0.0159925; a[1][2] = -0.00332104; a[2][2] = 0.00100568; 
a[0][3] = 43.5804; a[1][3] = -18.681; a[2][3] = 6.29988; 
   ls99 = ComputeAngle_1(p,eta,a,npar,npol);
	   
   //Step 4: compare angles and track masses, pass if all pass, fail otherwise
   if((lp.angle > lp99)||(sp.angle > sp99)||(lm.angle > lm99)||(ls.angle > ls99)) return false; //One or more of the angles has failed - not a three prong tau
   return true; //Track combination is a 3prong candidate!
} //End pass3prong (efficiency studies)

bool MyxAODAnalysis :: pass2prong_1(std::vector<TrackInfo> pair,TLorentzVector tau){
   float angle = fabs(pair[0].p4.Angle(pair[1].p4.Vect()));
   int  charge = pair[0].charge*pair[1].charge;

   // Used to have more vars, but some were unused.
   //float lt99 = 0, mt99 = 0, st99 = 0, ct99 = 0, lp99 = 0, mp99 = 0, sp99 = 0, los99 = 0, sos99 = 0, ss99 = 0, lm99 = 0, ls99 = 0, ms99 = 0;
   float lp99 = 0, mp99 = 0, sp99 = 0, los99 = 0, sos99 = 0, ss99 = 0, lm99 = 0;
   float p = tau.P(), eta = fabs(tau.Eta());
   
   float a[9][4];
   int npar = 4, npol = 9;

   a[0][0] = 0.0584232; a[1][0] = -0.0177642; a[2][0] = 0; a[3][0] = 0; a[4][0] = 0; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
   a[0][1] = 0.0447435; a[1][1] = -0.659295; a[2][1] = 2.99202; a[3][1] = -6.10742; a[4][1] = 6.34017; a[5][1] = -3.49095; a[6][1] = 0.972228; a[7][1] = -0.107807; a[8][1] = 0; 
   a[0][2] = -0.249078; a[1][2] = 3.75779; a[2][2] = -18.9563; a[3][2] = 45.4474; a[4][2] = -59.333; a[5][2] = 44.722; a[6][2] = -19.4586; a[7][2] = 4.54039; a[8][2] = -0.4399; 
   a[0][3] = 124.481; a[1][3] = -1129.76; a[2][3] = 5198.92; a[3][3] = -10538.1; a[4][3] = 10741.4; a[5][3] = -5757; a[6][3] = 1548.86; a[7][3] = -164.644; a[8][3] = 0; 
   //lt99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.057286; a[1][0] = -0.0168061; a[2][0] = 0; a[3][0] = 0; a[4][0] = 0; a[5][0] = 0; a[6][0] = 0; a[7][0] = 0; a[8][0] = 0; 
a[0][1] = 0.0640448; a[1][1] = -0.922493; a[2][1] = 4.10239; a[3][1] = -8.19704; a[4][1] = 8.35619; a[5][1] = -4.52961; a[6][1] = 1.24415; a[7][1] = -0.136244; a[8][1] = 0; 
a[0][2] = -0.222389; a[1][2] = 3.34829; a[2][2] = -16.8256; a[3][2] = 40.1156; a[4][2] = -52.0129; a[5][2] = 38.9152; a[6][2] = -16.8076; a[7][2] = 3.89426; a[8][2] = -0.374831; 
a[0][3] = 97.8443; a[1][3] = -804.025; a[2][3] = 3412.76; a[3][3] = -6058.05; a[4][3] = 5028.88; a[5][3] = -1940.87; a[6][3] = 281.19; a[7][3] = 0; a[8][3] = 0; 
   //ct99 = ComputeAngle_1(p,eta,a,npar,npol);
   npol = 3;
a[0][0] = 0.0665222; a[1][0] = 0; a[2][0] = 0; 
a[0][1] = -0.018755; a[1][1] = 0.00258183; a[2][1] = 0; 
a[0][2] = 0.045607; a[1][2] = -0.0234824; a[2][2] = 0.00375319; 
a[0][3] = 43.8011; a[1][3] = -10.0462; a[2][3] = 0; 
   //mt99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.156972; a[1][0] = -0.0333305; a[2][0] = 0; 
a[0][1] = -0.0231364; a[1][1] = 0.0120482; a[2][1] = -0.00289192; 
a[0][2] = 0.0490898; a[1][2] = -0.0273084; a[2][2] = 0.00547379; 
a[0][3] = 33.1651; a[1][3] = 0; a[2][3] = 0; 
   //st99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.179041; a[1][0] = -0.0531058; a[2][0] = 0; 
a[0][1] = -0.0146875; a[1][1] = 0.00414247; a[2][1] = -0.000612045; 
a[0][2] = 0.0188939; a[1][2] = -0.00452375; a[2][2] = 0.00120015; 
a[0][3] = 58.3066; a[1][3] = -48.2594; a[2][3] = 26.8864; 
   lp99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.142962; a[1][0] = -0.0397119; a[2][0] = 0; 
a[0][1] = -0.014084; a[1][1] = 0.00437622; a[2][1] = -0.000992845; 
a[0][2] = 0.0145659; a[1][2] = -0.00270987; a[2][2] = 0.00079432; 
a[0][3] = 42.4831; a[1][3] = -25.893; a[2][3] = 13.6075; 
   mp99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.0741985; a[1][0] = -0.0181941; a[2][0] = 0; 
a[0][1] = -0.0149252; a[1][1] = 0.00512965; a[2][1] = -0.00125462; 
a[0][2] = 0.00802004; a[1][2] = -0.00252272; a[2][2] = 0.000761022; 
a[0][3] = 25.0145; a[1][3] = 0; a[2][3] = 0; 
   sp99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.177021; a[1][0] = -0.0800858; a[2][0] = 0.017266; 
a[0][1] = -0.0145132; a[1][1] = 0.00508756; a[2][1] = -0.00133994; 
a[0][2] = 0.0174059; a[1][2] = -0.00407948; a[2][2] = 0.00130897; 
a[0][3] = 59.5959; a[1][3] = -51.819; a[2][3] = 28.742; 
   los99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.126153; a[1][0] = -0.0504026; a[2][0] = 0.0100601; 
a[0][1] = -0.01373; a[1][1] = 0.0040825; a[2][1] = -0.00103933; 
a[0][2] = 0.0121626; a[1][2] = -0.00239224; a[2][2] = 0.000832398; 
a[0][3] = 43.6455; a[1][3] = -34.4061; a[2][3] = 17.558; 
   sos99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.159394; a[1][0] = -0.0461081; a[2][0] = 0; 
a[0][1] = -0.0148102; a[1][1] = 0.00429109; a[2][1] = -0.000670516; 
a[0][2] = 0.0167114; a[1][2] = -0.00539364; a[2][2] = 0.00175181; 
a[0][3] = 48.371; a[1][3] = -35.9336; a[2][3] = 19.3991; 
   ss99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.102084; a[1][0] = -0.0256446; a[2][0] = 0; 
a[0][1] = -0.014259; a[1][1] = 0.00465467; a[2][1] = -0.00122856; 
a[0][2] = 0.010552; a[1][2] = -0.00176856; a[2][2] = 0.000446776; 
a[0][3] = 36.0848; a[1][3] = -16.1489; a[2][3] = 10.2994; 
   lm99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.152783; a[1][0] = -0.0390978; a[2][0] = 0; 
a[0][1] = -0.0139914; a[1][1] = 0.00352551; a[2][1] = -0.000624039; 
a[0][2] = 0.0159925; a[1][2] = -0.00332104; a[2][2] = 0.00100568; 
a[0][3] = 43.5804; a[1][3] = -18.681; a[2][3] = 6.29988; 
   //ls99 = ComputeAngle_1(p,eta,a,npar,npol);
a[0][0] = 0.160615; a[1][0] = -0.0284831; a[2][0] = -0.00879631; 
a[0][1] = -0.0140811; a[1][1] = 0.00344844; a[2][1] = -0.000421752; 
a[0][2] = 0.0173056; a[1][2] = -0.00371573; a[2][2] = 0.00112158; 
a[0][3] = 59.28; a[1][3] = -48.2821; a[2][3] = 26.3103; 
   //ms99 = ComputeAngle_1(p,eta,a,npar,npol);
   
   if ((angle < lm99)&&((angle < lp99)||(angle < mp99)||(angle < sp99))){   
   	if((charge == -1)&&((angle < los99)||(angle < sos99))) return true;
   	else if((charge == 1)&&(angle < ss99)) return true;
   	else return false;
   }
   else return false;
} //End pass2prong

bool MyxAODAnalysis :: pass1prong_1(TLorentzVector track,TLorentzVector tau){
   //Step 1: Compute Angle Between Track and Tau
   float angle = fabs(track.Angle(tau.Vect()));
   //Step 2: Compute 99% angle
   float p = tau.P(), eta = fabs(tau.Eta());
   
   int npar = 4, npol = 3;
   float a[3][4];
   
   a[0][0] = 0.120777; a[1][0] = -0.0261681; a[2][0] = 0;
   a[0][1] = -0.0307174; a[1][1] = 0.0170112; a[2][1] = -0.00381298;
   a[0][2] = 0.0662689; a[1][2] = -0.0402811; a[2][2] = 0.00760013;
   a[0][3] = 24.512; a[1][3] = 0; a[2][3] = 0;
   float angle99 = ComputeAngle_1(p,eta,a,npar,npol);

   //Step 3: compare angles and return decision
   if(angle > angle99) return false; //Track angle exceeds kinematic boundary
   else return true;
} //End pass1prong


float MyxAODAnalysis :: ComputeAngle_1(float p, float eta, float a[9][4], int npar, int npol, char eqn[]){
   char name[10];
   char poleqn[10];
   
   //TF1* etacoeff[npar]; //FIXME variable length array, use something like: = new TF1[npar];
   std::vector<TF1> etacoeff;
   TF1* pcone = new TF1("pcone",eqn); 
   for(int i=0;i<npar;i++){
      sprintf(name,"p%i",i);
      sprintf(poleqn,"pol%i",npol);
      etacoeff.push_back(TF1(name,poleqn));
      for(int j=0;j<npol;j++) etacoeff.at(i).SetParameter(j,a[j][i]);
		  pcone->SetParameter(i,etacoeff.at(i).Eval(eta));
   }
   float angle = pcone->Eval(p);
   delete pcone;
   return angle;
}

float MyxAODAnalysis :: Compute1dim_1(float p, float a[10], int npar, char eqn[]){
   TF1* pcone = new TF1("pcone",eqn); 
   for(int i=0;i<npar;i++) pcone->SetParameter(i,a[i]);
   float angle = pcone->Eval(p);
   delete pcone;
   return angle;
}


float MyxAODAnalysis :: ComputePi0Cone_1(int recProngs,TLorentzVector tau){
   float angle = -1;
   float atrue = 0, arec = 0;
   float p = tau.P(), eta = fabs(tau.Eta());   
   int npar = 4, npol = 9;
   float a[9][4];
   switch(recProngs){
      case 3:  //3 Prong Case
      	npol = 7;
         a[0][0] = 0.0457602; a[1][0] = 1.80062; a[2][0] = -6.82921; a[3][0] = 10.8605; a[4][0] = -8.52901; a[5][0] = 3.24106; a[6][0] = -0.473647;
         a[0][1] = -0.017874; a[1][1] = -0.0502181; a[2][1] = 0.162668; a[3][1] = -0.172266; a[4][1] = 0.0783324; a[5][1] = -0.013098; a[6][1] = 0;
         a[0][2] = 0.0266511; a[1][2] = -0.013319; a[2][2] = 0.00289217; a[3][2] = 0; a[4][2] = 0; a[5][2] = 0; a[6][2] = 0;
         a[0][3] = 237.828; a[1][3] = -2836.67; a[2][3] = 11074.1; a[3][3] = -18578.5; a[4][3] = 15086.9; a[5][3] = -5828.12; a[6][3] = 856.684;
         atrue = ComputeAngle(p,eta,a,npar,npol);
         npar = 3;
         npol = 5;
         a[0][0] = 0.178252; a[1][0] = 0.057474; a[2][0] = -0.256742; a[3][0] = 0.156772; a[4][0] = -0.0283407;
         a[0][1] = -0.00950538; a[1][1] = 0.00363589; a[2][1] = -0.00157984; a[3][1] = 0; a[4][1] = 0;
         a[0][2] = 0.0227538; a[1][2] = -0.0642722; a[2][2] = 0.121818; a[3][2] = -0.0679845; a[4][2] = 0.0115837;
         arec = ComputeAngle(p,eta,a,npar,npol,(char*)"[0]*exp([1]*x)+[2]");
         break;
      case 1: //1 Prong Case
         npol = 6;
         a[0][0] = 0.203158; a[1][0] = 0.269746; a[2][0] = -1.22961; a[3][0] = 1.41234; a[4][0] = -0.670384; a[5][0] = 0.114524;
         a[0][1] = -0.0300622; a[1][1] = -0.0115786; a[2][1] = 0.07541; a[3][1] = -0.0782728; a[4][1] = 0.0334031; a[5][1] = -0.0052381;
         a[0][2] = 0.0423083; a[1][2] = -0.0284378; a[2][2] = 0.0237394; a[3][2] = -0.0168315; a[4][2] = 0.0040657; a[5][2] = 0;
         a[0][3] = 45.0612; a[1][3] = -458.353; a[2][3] = 1521.8; a[3][3] = -1895.88; a[4][3] = 1000.72; a[5][3] = -187.091;
         atrue = ComputeAngle(p,eta,a,npar,npol);
         a[0][0] = 0.168639; a[1][0] = -0.325194; a[2][0] = 1.4594; a[3][0] = -3.20592; a[4][0] = 3.50676; a[5][0] = -2.0571; a[6][0] = 0.621729; a[7][0] = -0.0758951; a[8][0] = 0;
         a[0][1] = -0.0103477; a[1][1] = 0; a[2][1] = 0; a[3][1] = 0; a[4][1] = 0; a[5][1] = 0; a[6][1] = 0; a[7][1] = 0; a[8][1] = 0;
         a[0][2] = 0.0325721; a[1][2] = -0.0496515; a[2][2] = 0.0773747; a[3][2] = -0.0396844; a[4][2] = 0.00615314; a[5][2] = 0; a[6][2] = 0; a[7][2] = 0; a[8][2] = 0;
         arec = ComputeAngle(p,eta,a,npar,npol,(char*)"[0]*exp([1]*x)+[2]");
         break;
      default:
         //ATH_MSG_WARNING("Incorrect number of prongs!");
         return angle;
   }
   if (atrue > arec) angle = atrue;
   else angle = arec;
   return angle;
} //End ComputePi0Cone