///////////////////////////////////////////////////////////////////////////////
//  use this module to define post-generation cuts
//  PrintLevel() = 11: print photons with delta(angle) < 0.5 degree
///////////////////////////////////////////////////////////////////////////////
//_____________________________________________________________________________
#include "TF1.h"
#include "Stntuple/loop/TStnAna.hh"
#include "Stntuple/obj/TStnNode.hh"
#include "Stntuple/obj/TStnEvent.hh"
#include "Stntuple/obj/TStnTau.hh"
#include "Stntuple/obj/TGenParticle.hh"

#include "TTauMcAnaModule.hh"

ClassImp(TTauMcAnaModule)
//_____________________________________________________________________________
TTauMcAnaModule::TTauMcAnaModule(const char* name, const char* title):
  TStnModule(name,title)
{
  fListOfLooseTaus      = new TClonesArray("TStnTau",10);
  fListOfLooseElectrons = new TObjArray(10);
  fListOfLooseMuons     = new TObjArray(10);

  fListOfTightTaus      = new TObjArray(10);
  fListOfTightElectrons = new TObjArray(10);
  fListOfTightMuons     = new TObjArray(10);

  fListOfPhotons   = new TObjArray(10);
  fListOfCharged   = new TObjArray(100);

  fMaxTightTauEta       = 1. ;
  fMinTightTauPt        = 25.;

  fMaxLooseTauEta       = 1.;
  fMinLooseTauPt        = 25.;

  fMaxTightEleEta       = 1.;
  fMinTightElePt        = 25.;

  fMaxLooseEleEta       = 1.;
  fMinLooseElePt        = 25.;

  fMaxTightMuoEta       = 0.6;
  fMinTightMuoPt        = 20.;

  fMaxLooseMuoEta       = 1.2;
  fMinLooseMuoPt        = 20.;
}

//_____________________________________________________________________________
TTauMcAnaModule::~TTauMcAnaModule() {
  fListOfLooseElectrons->Delete();
  delete fListOfLooseElectrons;
  fListOfLooseMuons->Delete();
  delete fListOfLooseMuons;
  fListOfLooseTaus->Delete();
  delete fListOfLooseTaus;

  fListOfTightElectrons->Delete();
  delete fListOfTightElectrons;
  fListOfTightMuons->Delete();
  delete fListOfTightMuons;
  fListOfTightTaus->Delete();
  delete fListOfTightTaus;


  fListOfPhotons->Clear();
  delete fListOfPhotons;
  fListOfCharged->Clear();
  delete fListOfCharged;
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookTauHistograms(TauHist_t&  Hist, 
					const char* Folder) 
{
  HBook1F(Hist.fTauPhotonAngle,"tau_photon_angle","Tau-Photon angle",
	  180,0,180);
  HBook1F(Hist.fTauTrackAngle,"tau_track_angle","Tau-Track angle",
	  180,0,180);

  HBook1F(Hist.fPt ,"pt"  ,"Tau Genp VisiblePt", 100,0,100,Folder);
  HBook1F(Hist.fEta,"eta" ,"Tau Eta"           , 100,-5,5,Folder);
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookMuonHistograms(MuonHist_t& Hist, 
					 const char* Folder) 
{
  HBook1F(Hist.fPt ,"pt" ,"Muon Genp Pt", 100,0,100,Folder);
  HBook1F(Hist.fEta,"eta","Muon Eta "   , 100,-5,5,Folder);
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookElectronHistograms(ElectronHist_t& Hist, 
					     const char*     Folder) {

  HBook1F(Hist.fPt ,"pt" ,"Electron Genp Pt", 100,0,100,Folder);
  HBook1F(Hist.fEta,"eta","Electron Eta "   , 100,-5,5,Folder);
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookEEHistograms(EEHist_t& Hist, const char* Folder) {

  HBook1F(Hist.fPt ,"pt" ,"EE Genp Pt", 100,0,100,Folder);
  HBook1F(Hist.fEta,"eta","EE  Eta "  , 100,-5,5,Folder);
  HBook1F(Hist.fMass,"mass","EE Mass"  , 100,0,200,Folder);
  HBook1F(Hist.fRapidity,"rapidity",Form("%s: EE Rapidity",Folder), 500,-2.5,2.5,Folder);
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookMuMuHistograms(MuMuHist_t& Hist, const char* Folder) {

  HBook1F(Hist.fPt ,"pt"  ,"MuMu Genp Pt", 100,0,100,Folder);
  HBook1F(Hist.fEta,"eta" ,"MuMu  Eta "  , 100,-5,5,Folder);
  HBook1F(Hist.fMass,"mass","MuMu Mass"   , 100,0,200,Folder);
  HBook1F(Hist.fRapidity,"rapidity",Form("%s: MuMu Rapidity",Folder),500,-2.5,2.5,Folder);
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookObspHistograms(ObspHist_t& Hist, const char* Folder) {
}

//_____________________________________________________________________________
void TTauMcAnaModule::BookGenpHistograms(GenpHist_t& Hist, 
					 const char* Folder) 
{
  HBook1F(Hist.fMet      ,"met"       ,"GENP-level MET"  , 100,0,100,Folder);

  HBook2F(Hist.fNLooseMuoVsNTightMuo[0],"muo_nl_vs_nt_0","muo_nl_vs_nt_0",
	  5,0,5,5,0,5,Folder);
  HBook2F(Hist.fNLooseMuoVsNTightMuo[1],"muo_nl_vs_nt_1","muo_nl_vs_nt_1",
	  5,0,5,5,0,5,Folder);
  HBook2F(Hist.fNLooseEleVsNTightEle[0],"ele_nl_vs_nt_0","ele_nl_vs_nt_1",
	  5,0,5,5,0,5,Folder);
  HBook2F(Hist.fNLooseEleVsNTightEle[1],"ele_nl_vs_nt_1","ele_nl_vs_nt_1",
	  5,0,5,5,0,5,Folder);
  HBook1F(Hist.fNTightTaus[0],"tau_nt_0","tau_nt_0",5,0,5,Folder);
  HBook1F(Hist.fNTightTaus[1],"tau_nt_1","tau_nt_1",5,0,5,Folder);
}


//_____________________________________________________________________________
void TTauMcAnaModule::BookHistograms() {
  //  char name [200];
  //  char title[200];

  TFolder* fol;
  TFolder* hist_folder;
  char     folder_name[200];
					// book histograms
  DeleteHistograms();
  hist_folder = (TFolder*) GetFolder()->FindObject("Hist");

  HBook1F(fHist.fRunNumber,"aaa_run_number","Run Number",100 ,0,100);
  HBook1F(fHist.fFilterResult,"aaa_filter_result","Filter Result",10 ,0,10);

  fol = (TFolder*) hist_folder->FindObject("obsp");
  if (! fol) fol = hist_folder->AddFolder("obsp","obsp");

  BookObspHistograms(fHist.fObsp,"Hist/obsp");

  fol = (TFolder*) hist_folder->FindObject("genp");
  if (! fol) fol = hist_folder->AddFolder("genp","genp");

  BookGenpHistograms(fHist.fGenp,"Hist/genp");

  for (int i=0; i<kNEleHistSets; i++) {
    sprintf(folder_name,"ele_%i",i);
    fol = (TFolder*) hist_folder->FindObject(folder_name);
    if (! fol) fol = hist_folder->AddFolder(folder_name,folder_name);
    BookElectronHistograms(fHist.fEle[i],Form("Hist/%s",folder_name));
  }

  for (int i=0; i<kNMuoHistSets; i++) {
    sprintf(folder_name,"muo_%i",i);
    fol = (TFolder*) hist_folder->FindObject(folder_name);
    if (! fol) fol = hist_folder->AddFolder(folder_name,folder_name);
    BookMuonHistograms(fHist.fMuo[i],Form("Hist/%s",folder_name));
  }

  for (int i=0; i<kNTauHistSets; i++) {
    sprintf(folder_name,"tau_%i",i);
    fol = (TFolder*) hist_folder->FindObject(folder_name);
    if (! fol) fol = hist_folder->AddFolder(folder_name,folder_name);
    BookTauHistograms(fHist.fTau[i],Form("Hist/%s",folder_name));
  }

  for (int i=0; i<kNEEHistSets; i++) {
    sprintf(folder_name,"ee_%i",i);
    fol = (TFolder*) hist_folder->FindObject(folder_name);
    if (! fol) fol = hist_folder->AddFolder(folder_name,folder_name);
    BookEEHistograms(fHist.fEE[i],Form("Hist/%s",folder_name));
  }

  for (int i=0; i<kNMuMuHistSets; i++) {
    sprintf(folder_name,"mumu_%i",i);
    fol = (TFolder*) hist_folder->FindObject(folder_name);
    if (! fol) fol = hist_folder->AddFolder(folder_name,folder_name);
    BookMuMuHistograms(fHist.fMuMu[i],Form("Hist/%s",folder_name));
  }
}


//_____________________________________________________________________________
int TTauMcAnaModule::BeginJob() {

  // register data blocks and book the histograms

  RegisterDataBlock("GenpBlock", "TGenpBlock", &fGenpBlock);
  RegisterDataBlock("ObspBlock", "TObspBlock", &fObspBlock);
  BookHistograms();

//-----------------------------------------------------------------------------
//  print initial values of parameters
//-----------------------------------------------------------------------------
  printf(" fMinTightElePt, fMaxTightEleEta  = %10.3f , %10.3f\n",
	 fMinTightElePt,fMaxTightEleEta);
  printf(" fMinLooseElePt, fMaxLooseEleEta  = %10.3f , %10.3f\n",
	 fMinLooseElePt,fMaxLooseEleEta);
  printf(" fMinTightMuoPt, fMaxTightMuoEta  = %10.3f , %10.3f\n",
	 fMinTightMuoPt,fMaxTightMuoEta);
  printf(" fMinLooseMuoPt, fMaxLooseMuoEta  = %10.3f , %10.3f\n",
	 fMinLooseMuoPt,fMaxLooseMuoEta);
  printf(" fMinTightTauPt, fMaxTightTauEta  = %10.3f , %10.3f\n",
	 fMinTightTauPt,fMaxTightTauEta);
  printf(" fMinLooseTauPt, fMaxLooseTauEta  = %10.3f , %10.3f\n",
	 fMinLooseTauPt,fMaxLooseTauEta);
  return 0;
}

//_____________________________________________________________________________
int TTauMcAnaModule::BeginRun() {
  // initialize run-dependent calibration constants
  return 0;
}


//_____________________________________________________________________________
Int_t TTauMcAnaModule::InitTau(TStnTau* Tau, TGenParticle* Par) {

  // clear some variables
  
  TGenParticle* d;
  TLorentzVector dmom;
  TVector3       tau_v3;
  TVector3       d_v3;

  int            i1, i2;
  double         angle, pt;
//-----------------------------------------------------------------------------
//  these are supposed to be FORTRAN (!) indices
//-----------------------------------------------------------------------------
  i1 = Par->GetFirstDaughter();
  i2 = i1+Par->GetNDaughters();

  tau_v3 = Tau->Momentum()->Vect();

  for (int i=i1; i<i2; i++) {
    d     = fGenpBlock->Particle(i);
    d->Momentum(dmom);
    d_v3  = dmom.Vect();
    angle = tau_v3.Angle(d_v3);

    if (d->IsPi0()) {
      Tau->IncrementNPi0();
    }

    if (d->GetNDaughters() <= 1) {
//-----------------------------------------------------------------------------
// count only final state particles, but keep in mind that pi0's can be counted
// for as non-stable ones
//-----------------------------------------------------------------------------
      if (! d->IsNeutrino() && (d->GetStatusCode() == 1)) {
//-----------------------------------------------------------------------------
// calculate momentum of all detectable daughters
//-----------------------------------------------------------------------------
	TLorentzVector* tmp = (TLorentzVector*) Tau->Momentum();
  	*tmp += dmom;
	Tau->AddCharge(d->Charge());
  	if ((d->Charge() != 0) && (dmom.Pt() > 1.)) {
  	  Tau->IncrementNTracks();
  	  *Tau->TrackMomentum() += dmom;
  	  pt = d->Pt();
  	  if (Tau->SeedTrackPt() < pt) {
  	    Tau->SetSeedTrackPt(pt);
  	  }
  	}
      }
      if      (d->IsElectron()) Tau->SetDecayMode(TStnTau::kElectronMode);
      else if (d->IsMuon()    ) Tau->SetDecayMode(TStnTau::kMuonMode);
    }
    else {
      InitTau(Tau,d);
    }
  }
  return 0;
}

//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillObspHistograms(ObspHist_t& Hist) {
  return 0;
}


//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillElectronHistograms(ElectronHist_t& Hist,
					      TGenParticle*   P    ) {

  double   pt, eta;

  pt  = P->Pt();
  eta = P->Eta();
  Hist.fPt ->Fill(pt);
  Hist.fEta->Fill(eta);

  return 0;
}

//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillMuonHistograms(MuonHist_t&     Hist,
					  TGenParticle*   P    ) 
{
  double   pt, eta;

  pt  = P->Pt();
  eta = P->Eta();
  Hist.fPt ->Fill(pt);
  Hist.fEta->Fill(eta);

  return 0;
}


//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillTauHistograms(TauHist_t&     Hist,
					 TStnTau*       Tau    ) 
{
  TVector3        tau_v3;
  TLorentzVector  *tau_mom;

  TLorentzVector  phot_mom;
  TVector3        phot_v3;

  TLorentzVector  trk_mom;
  TVector3        trk_v3;

  double          angle, pt, eta;

  int nph   = fListOfPhotons->GetEntriesFast();
  int nch   = fListOfCharged->GetEntriesFast();


  tau_mom  = (TLorentzVector*) Tau->Momentum();
  tau_v3 = tau_mom->Vect();

  pt  = tau_mom->Pt();
  eta = tau_mom->Eta();

  Hist.fPt ->Fill(pt);
  Hist.fEta->Fill(eta);

  for (int iph=0; iph<nph; iph++) {
    TGenParticle* phot = (TGenParticle*) fListOfPhotons->UncheckedAt(iph);
    phot->Momentum(phot_mom);
    phot_v3 = phot_mom.Vect();
    angle = tau_v3.Angle(phot_v3)*180./TMath::Pi();
    Hist.fTauPhotonAngle->Fill(angle);
    if ((PrintLevel() == 11) && (angle < 0.5)) {
      GetHeaderBlock()->Print(Form("tau photon angle = %10.3f",angle));
    }
  }

  for (int ich=0; ich<nch; ich++) {
    TGenParticle* trk = (TGenParticle*) fListOfCharged->UncheckedAt(ich);
    trk->Momentum(trk_mom);
    trk_v3 = trk_mom.Vect();
    angle = tau_v3.Angle(trk_v3)*180./TMath::Pi();
    Hist.fTauTrackAngle->Fill(angle);
    if ((PrintLevel() == 11) && (angle < 0.5)) {
      GetHeaderBlock()->Print(Form("tau track angle = %10.3f",angle));
    }
  }

  return 0;
}


//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillEEHistograms(EEHist_t&       Hist,
					TGenParticle*   E1,
					TGenParticle*   E2) {

  TLorentzVector Z;

  Z.SetXYZT(E1->Px()+E2->Px(),
	    E1->Py()+E2->Py(),
	    E1->Pz()+E2->Pz(),
	    E1->Energy()+E2->Energy());

  double   pt, eta, mass, rapidity;

  pt       = Z.Pt();
  eta      = Z.Eta();
  mass     = Z.M();
  rapidity = Z.Rapidity();

  Hist.fPt ->Fill (pt);
  Hist.fEta->Fill (eta);
  Hist.fMass->Fill(mass);
  Hist.fRapidity->Fill(rapidity);

  return 0;
}

//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillMuMuHistograms(MuMuHist_t&     Hist,
					  TGenParticle*   Mu1,
					  TGenParticle*   Mu2) {

  TLorentzVector Z;

  Z.SetXYZT(Mu1->Px()+Mu2->Px(),
	    Mu1->Py()+Mu2->Py(),
	    Mu1->Pz()+Mu2->Pz(),
	    Mu1->Energy()+Mu2->Energy());

  double   pt, eta, mass, rapidity;

  pt       = Z.Pt();
  eta      = Z.Eta();
  mass     = Z.M();
  rapidity = Z.Rapidity();

  Hist.fPt ->Fill (pt);
  Hist.fEta->Fill (eta);
  Hist.fMass->Fill(mass);
  Hist.fRapidity->Fill(rapidity);

  return 0;
}

//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillGenpHistograms(GenpHist_t& Hist) {
//-----------------------------------------------------------------------------
//  GENP-level missing Et
//-----------------------------------------------------------------------------
  double met_mod;

  met_mod = fGenpMet.Mod();
  Hist.fMet->Fill(met_mod);

  Hist.fNTightTaus[0]->Fill(fNTightTaus);

  Hist.fNLooseMuoVsNTightMuo[0]->Fill(fNTightMuons,fNLooseMuons,1);
  Hist.fNLooseEleVsNTightEle[0]->Fill(fNTightElectrons,fNLooseElectrons,1);


  if (met_mod > 20) {
    Hist.fNLooseMuoVsNTightMuo[1]->Fill(fNTightMuons,fNLooseMuons,1);
  }

  if (met_mod > 25) {
    Hist.fNLooseEleVsNTightEle[1]->Fill(fNTightElectrons,fNLooseElectrons,1);
    Hist.fNTightTaus[1]->Fill(fNTightTaus);
  }

  return 0;
}


//_____________________________________________________________________________
Int_t TTauMcAnaModule::FillHistograms(Hist_t& Hist) {

  double          met_mod;
//-----------------------------------------------------------------------------
//  GENP-level missing Et
//-----------------------------------------------------------------------------
  fGenpBlock->GetMissingEt(&fGenpMet);
  met_mod = fGenpMet.Mod();

  FillObspHistograms    (fHist.fObsp);
  FillGenpHistograms    (fHist.fGenp);

  for (int i=0; i<fNLooseElectrons; i++) {
    TGenParticle* ele = (TGenParticle*) fListOfLooseElectrons->UncheckedAt(i);
    FillElectronHistograms(fHist.fEle[0],ele);
    if (met_mod > 25) {
      FillElectronHistograms(fHist.fEle[2],ele);
    }
  }

  for (int i=0; i<fNLooseMuons; i++) {
    TGenParticle* muo = (TGenParticle*) fListOfLooseMuons->UncheckedAt(i);
    FillMuonHistograms    (fHist.fMuo[0],muo);
    if (TMath::Abs(muo->Eta()) < 0.6) {
      FillMuonHistograms(fHist.fMuo[1],muo);
      if (met_mod > 20) {
	FillMuonHistograms(fHist.fMuo[2],muo);
      }
    }
  }

  for (int i1=0; i1<fNLooseElectrons; i1++) {
    TGenParticle* e1 = (TGenParticle*) fListOfLooseElectrons->UncheckedAt(i1);
    int eflag1 = fTightEleFlag[i1];
    for (int i2=i1+1; i2<fNLooseElectrons; i2++) {
      TGenParticle* e2 = (TGenParticle*) fListOfLooseElectrons->UncheckedAt(i2);
      int eflag2 = fTightEleFlag[i2];
      if (eflag1+eflag2 > 0) {
				// one of the electrons is tight (trigger)

	FillEEHistograms(fHist.fEE[0],e1,e2);
      }
    }
  }

  for (int i1=0; i1<fNLooseMuons; i1++) {
    TGenParticle* m1 = (TGenParticle*) fListOfLooseMuons->UncheckedAt(i1);
    int muflag1 = fTightMuoFlag[i1];
    for (int i2=i1+1; i2<fNLooseMuons; i2++) {
      TGenParticle* m2 = (TGenParticle*) fListOfLooseMuons->UncheckedAt(i2);
      int muflag2 = fTightMuoFlag[i2];
      if (muflag1+muflag2 > 0) {
				// one of the muons is tight (trigger)

	FillMuMuHistograms(fHist.fMuMu[0],m1,m2);
      }
    }
  }

  for (int i=0; i<fNLooseTaus; i++) {
    TStnTau* tau = (TStnTau*) fListOfLooseTaus->UncheckedAt(i);
    FillTauHistograms    (fHist.fTau[0],tau);
    if (tau->Momentum()->Pt() > 25 ) {
      FillTauHistograms(fHist.fTau[1],tau);
      if (met_mod > 25) {
	FillTauHistograms(fHist.fTau[2],tau);
      }
    }
  }

  return 0;
}

//_____________________________________________________________________________
int TTauMcAnaModule::Event(int ientry) {
//-----------------------------------------------------------------------------
// in case of a TChain, ientry is the entry number in the current file
//-----------------------------------------------------------------------------
  TStnTau*      tau;
  TGenParticle* p;

  fNLooseTaus      = 0;
  fNLooseElectrons = 0;
  fNLooseMuons     = 0;

  fNTightTaus      = 0;
  fNTightElectrons = 0;
  fNTightMuons     = 0;

  fListOfLooseTaus->Clear();
  fListOfLooseElectrons->Clear();
  fListOfLooseMuons->Clear();

  fListOfTightTaus->Clear();
  fListOfTightElectrons->Clear();
  fListOfTightMuons->Clear();

  fListOfPhotons->Clear();
  fListOfCharged->Clear();

  fGenpBlock->GetEntry(ientry);
  fObspBlock->GetEntry(ientry);
//-----------------------------------------------------------------------------
//  find particles of interest
//-----------------------------------------------------------------------------
  int iele, imuo, itau;

  for (int i=0; i<fGenpBlock->NParticles(); i++) {
    p = fGenpBlock->Particle(i);
    if (p->IsTau() && (p->GetStatusCode() != 3) && (p->GetStatusCode() != 21)){
      tau = new ((*fListOfLooseTaus)[fNLooseTaus]) TStnTau(fNLooseTaus);
      fNLooseTaus++;
      InitTau(tau,p);
      if ((tau->Momentum()->Pt() > fMinTightTauPt) && 
	  (TMath::Abs(tau->Momentum()->Eta()) < fMaxTightTauEta)) {
	fNTightTaus++;
	fListOfTightTaus->Add(tau);
      }
    }
    else if (p->IsElectron() && 
            (p->GetStatusCode() != 3) && (p->GetStatusCode() != 21)) {

      if ((p->Pt() > fMinLooseElePt) && (TMath::Abs(p->Eta()) < fMaxLooseEleEta)) {
	fListOfLooseElectrons->Add(p);
	iele = fNLooseElectrons;
	fTightEleFlag[iele] = 0;
	fNLooseElectrons++;

	if ((p->Pt() > fMinTightElePt) && (TMath::Abs(p->Eta()) < fMaxTightEleEta)) {
	  fListOfTightElectrons->Add(p);
	  fTightEleFlag[iele] = 1;
	  fNTightElectrons++;
	}
      }
    }
    else if (p->IsMuon() &&
	     (p->GetStatusCode() != 3) && (p->GetStatusCode() != 21)) {

      if ( (p->Pt() > fMinLooseMuoPt) && (TMath::Abs(p->Eta()) < fMaxLooseMuoEta)) {
	imuo = fNLooseMuons;
	fListOfLooseMuons->Add(p);
	fTightMuoFlag[imuo] = 0;
	fNLooseMuons++;
      
	if (TMath::Abs(p->Eta()) < fMaxTightMuoEta) {
	  fListOfTightMuons->Add(p);
	  fTightMuoFlag[imuo] = 1;
	  fNTightMuons++;
	}
      }
    }
    else if (p->IsPhoton()) {
      if (p->Pt() > 1.) {
	fListOfPhotons->Add(p);
      }
    }
    else if ((p->GetStatusCode() == 1) && p->Charge()) {
      if (p->Pt() > 1) {
	fListOfCharged->Add(p);
      }
    }
  }


  FillHistograms(fHist);

//   int passed = (fNGoodParticles > 0);
//   SetPassed(passed);

  return 0;			       
}



//_____________________________________________________________________________
int TTauMcAnaModule::EndRun() {
  return 0;
}

//_____________________________________________________________________________
int TTauMcAnaModule::EndJob() {
  return 0;
}

//_____________________________________________________________________________
void TTauMcAnaModule::Print(Option_t* opt) const {
}