////////////////////////////////////////////////////////////////////////
//                                                                    // 
//Elisabetta 15/08/2013                                               //
// starting macro                                                     //
//Analysis: p pbar ---> Ds1+ Ds-                                      //
//Ds1 = Ds(2460)+                                                     //
//where: Ds1(2460) ---> D*s+ pi0, D*s+ to Ds+(--->K+ K- pi+) gamma    //
//                                                                    //
//                                                                    //
//                                                                    //
////////////////////////////////////////////////////////////////////////
class RhoCandList;
class RhoCandidate;
class PndAnaPidSelector;
class PndAnaPidCombiner;
class PndAnalysis;
#include <iostream>
using std::cout;
using std::endl;


// *** routine to only keep PID matched candidates in list
int SelectTruePid(PndAnalysis *ana, RhoCandList &l)
{
	int removed = 0;
	
	for (int ii=l.GetLength()-1;ii>=0;--ii)
	{
		if ( !(ana->McTruthMatch(l[ii])) )
		{
			l.Remove(l[ii]);
			removed++;
		}
	}
	
	return removed;
}


void tut_anaDs2460Dstarpi0_simple(int nevts)
{
	// *** some variables
	int i=0,j=0, k=0, l=0;
	
	TString OutFile="output.root";  
					
	// *** the files coming from the simulation
	TString inPidFile = "pid_complete.root";    // this file contains the PndPidCandidates and McTruth
	TString inParFile = "simparams.root";
	
	gStyle->SetOptFit(1011);
	gROOT->Macro("$VMCWORKDIR/gconfig/rootlogon.C");
	
	FairLogger::GetLogger()->SetLogToFile(kFALSE);
	
	// *** initialization
	FairRunAna* fRun = new FairRunAna();
	FairRuntimeDb* rtdb = fRun->GetRuntimeDb();
	fRun->SetInputFile(inPidFile);
	
	TString anaParFile = gSystem->Getenv("VMCWORKDIR");
	anaParFile +=  "/macro/params/all.par";
	FairParAsciiFileIo* parIo1 = new FairParAsciiFileIo();
	parIo1->open(anaParFile.Data(),"in");
        

	FairParRootFileIo* parIO = new FairParRootFileIo();
	parIO->open(inParFile);
	rtdb->setFirstInput(parIO);
	rtdb->setSecondInput(parIo1);
	rtdb->setOutput(parIO);  
	

	fRun->SetOutputFile(OutFile);
	fRun->Init(); 

	// *** create an output file for all histograms
	TFile *out = TFile::Open("output_anaDs2460Dstarpi0.root","RECREATE");
		
	// *** create some histograms

	TH1F *pi0_ftm = new TH1F("pi0_ftm","#pi0 mass (full truth match)",100,0.,0.6);
	TH1F *pi0_Mom_ftm = new TH1F("pi0_Mom_ftm","#pi0 mass (full truth match)",100,0.,3.);
	TH1F *Dsp_Mom_ftm = new TH1F("Dsp_Mom_ftm","#pi0 mass (full truth match)",100,0.,3.);
	TH1F *Dsm_Mom_ftm = new TH1F("Dsm_Mom_ftm","#pi0 mass (full truth match)",100,0.,3.);
	TH1F *Dstar_Mom_ftm = new TH1F("Dsp_Mom_ftm","#pi0 mass (full truth match)",100,0.,3.);
	TH1F *D2460_Mom_ftm = new TH1F("Dsp_Mom_ftm","#pi0 mass (full truth match)",100,0.,3.);

	//pi0 plots: all and ftm
	TH1F *pi0_all = new TH1F("pi0_all","#pi0 mass (all)",100,0.,0.6);
	TH1F *pi0_px_diff_ftm  = new TH1F("pi0_px_diff_ftm","#pi0 px ",100,-0.5,0.5);
	TH1F *pi0_py_diff_ftm  = new TH1F("pi0_py_diff_ftm","#pi0 py ",100,-0.5,0.5);
	TH1F *pi0_pz_diff_ftm  = new TH1F("pi0_pz_diff_ftm","#pi0 pz ",100,-0.5,0.5);
	TH1F *pi0_E_diff_ftm  = new TH1F("pi0_E_diff_ftm","#pi0 pz ",100,-0.5,0.5);
	TH1F *pi0_mass_diff_ftm  = new TH1F("pi0_mass_diff_ftm","#pi0 mass resolution ",100,-0.25,0.25);
	TH1F *pi0_px_ftm  = new TH1F("pi0_px_ftm","#pi0 px ",100,-1.5,1.5);
	TH1F *pi0_py_ftm  = new TH1F("pi0_py_ftm","#pi0 py ",100,-1.5,1.5);
	TH1F *pi0_pz_ftm  = new TH1F("pi0_pz_ftm","#pi0 pz ",100,-1.5,1.5);
	TH1F *pi0_E_ftm  = new TH1F("pi0_E_ftm","#pi0 E ",100,0,10);
	TH1F *pi0_ftm = new TH1F("pi0_ftm","#pi0 mass (full truth match)",100,0.,0.6);

	//Ds*+ plots: all and ftm
	TH1F *Dstar_all = new TH1F("Dstar_all","Ds*+ mass (all)",100,0.,5.);
	TH1F *Dstar_px_diff_ftm  = new TH1F("Dstar_px_diff_ftm","Ds*+ px ",100,-0.5,0.5);
	TH1F *Dstar_py_diff_ftm  = new TH1F("Dstar_py_diff_ftm","Ds*+ py ",100,-0.5,0.5);
	TH1F *Dstar_pz_diff_ftm  = new TH1F("Dstar_pz_diff_ftm","Ds*+ pz ",100,-0.5,0.5);
	TH1F *Dstar_E_diff_ftm  = new TH1F("Dstar_E_diff_ftm","Ds*+ pz ",100,-0.5,0.5);
	TH1F *Dstar_mass_diff_ftm  = new TH1F("Dstar_mass_diff_ftm","Ds*+ mass resolution ",100,-0.25,0.25);
	TH1F *Dstar_px_ftm  = new TH1F("Dstar_px_ftm","Ds*+ px ",100,-1.5,1.5);
	TH1F *Dstar_py_ftm  = new TH1F("Dstar_py_ftm","Ds*+ py ",100,-1.5,1.5);
	TH1F *Dstar_pz_ftm  = new TH1F("Dstar_pz_ftm","Ds*+ pz ",100,-1,9);
	TH1F *Dstar_E_ftm  = new TH1F("Dstar_E_ftm","Ds*+ E ",100,0,10);
	TH1F *Dstar_ftm = new TH1F("Dstar_ftm","Ds*+ mass (full truth match)",100,0.,5.);


	//Ds plots: all and ftm
	TH1F *Dsp_all  = new TH1F("Dsp_all","Ds+ mass (all)",100,0.,5.);
	TH1F *Dsp_px_ftm  = new TH1F("Dsp_px_ftm","Ds+ px ",100,-1.5,1.5);
	TH1F *Dsp_py_ftm  = new TH1F("Dsp_py_ftm","Ds+ py ",100,-1.5,1.5);
	TH1F *Dsp_pz_ftm  = new TH1F("Dsp_pz_ftm","Ds+ pz ",100,-1,9);
	TH1F *Dsp_E_ftm  = new TH1F("Dsp_E_ftm","Ds+ E ",100,0,10);
	TH1F *Dsp_ftm  = new TH1F("Dsp_ftm","Ds+ mass (full truth match)",100,0.,5.);
	TH1F *Dsp_mass_diff_ftm  = new TH1F("Dsp_mass_diff_ftm","Ds+ E ",100,-0.2,0.2);
	TH1F *Dsp_px_diff_ftm  = new TH1F("Dsp_px_diff_ftm","Ds+ px ",100,-0.5,0.5);
	TH1F *Dsp_py_diff_ftm  = new TH1F("Dsp_py_diff_ftm","Ds+ py ",100,-0.5,0.5);
	TH1F *Dsp_pz_diff_ftm  = new TH1F("Dsp_pz_diff_ftm","Ds+ pz ",100,-0.5,0.5);
	TH1F *Dsp_E_diff_ftm  = new TH1F("Dsp_E_ftm","Ds+ E ",100,-0.5,0.5);

	TH1F *Dsm_all  = new TH1F("Dsm_all","Ds- mass (all)",100,0.,5.);
	TH1F *Dsm_px_ftm  = new TH1F("Dsm_px_ftm","Ds- px ",100,-1.5,1.5);
	TH1F *Dsm_py_ftm  = new TH1F("Dsm_py_ftm","Ds- py ",100,-1.5,1.5);
	TH1F *Dsm_pz_ftm  = new TH1F("Dsm_pz_ftm","Ds- pz ",100,-1,9);
	TH1F *Dsm_E_ftm  = new TH1F("Dsm_E_ftm","Ds- E ",100,0,10);
	TH1F *Dsm_ftm  = new TH1F("Dsm_ftm","Ds- mass (full truth match)",100,0,5.);
	TH1F *Dsm_mass_diff_ftm  = new TH1F("Dsm_mass_diff_ftm","Ds- E ",100,-0.2,0.2);
	TH1F *Dsm_px_diff_ftm  = new TH1F("Dsm_px_diff_ftm","Ds- px ",100,-0.5,0.5);
	TH1F *Dsm_py_diff_ftm  = new TH1F("Dsm_py_diff_ftm","Ds- py ",100,-0.5,0.5);
	TH1F *Dsm_pz_diff_ftm  = new TH1F("Dsm_pz_diff_ftm","Ds- pz ",100,-0.5,0.5);
	TH1F *Dsm_E_diff_ftm  = new TH1F("Dsm_E_ftm","Ds- E ",100,-0.5,0.5);


	
	//Ds2460 plots: all and ftm
	TH1F *D2460_all  = new TH1F("D2460_all","Ds'1^{+} mass (all)",100,0.,5.);
	TH1F *D2460_px_ftm  = new TH1F("D2460_px_ftm","Ds'1+ px ",100,-1.5,1.5);
	TH1F *D2460_py_ftm  = new TH1F("D2460_py_ftm","Ds'1+ py ",100,-1.5,1.5);
	TH1F *D2460_pz_ftm  = new TH1F("D2460_pz_ftm","Ds'1+ pz ",100,-1,9);
	TH1F *D2460_E_ftm  = new TH1F("D2460_E_ftm","Ds'1+ E ",100,0,10);
	TH1F *D2460_mass_diff_ftm  = new TH1F("D2460_mass_diff_ftm","Ds'1+ mass resolution (full truth match)",100,-0.2,0.2);
	TH1F *D2460_ftm  = new TH1F("D2460_ftm","Ds'1+ mass (full truth match)",100,0.,4.);
	TH1F *D2460_px_diff_ftm  = new TH1F("D2460_px_diff_ftm","Ds'1+ px resolution",100,-0.5,0.5);
	TH1F *D2460_py_diff_ftm  = new TH1F("D2460_py_diff_ftm","Ds'1+ py resolution",100,-0.5,0.5);
	TH1F *D2460_pz_diff_ftm  = new TH1F("D2460_pz_diff_ftm","Ds'1+ pz resolution",100,-0.5,0.5);
	TH1F *D2460_E_diff_ftm  = new TH1F("D2460_E_diff_ftm","Ds'1+ E resolution",100,-0.5,0.5);
	TH1F *D2460_diff_mcf  = new TH1F("D2460_diff_mcf","Ds'1+ mass resolution",100,-0.5,0.5);


	TH1F *hpmpx_m  = new TH1F("hpmpx_m","#pi- px, daughter of Ds- ",100,-3,3);
	TH1F *hpmpy_m  = new TH1F("hpmpy_m","#pi- py, daughter of Ds- ",100,-3,3);
	TH1F *hpmpz_m = new TH1F("hpmpz_m","#pi- pz, daughter of Ds- ",100,-1,9);
	TH1F *hpmE_m = new TH1F("hpmE_m","#pi- E, daughter of Ds- ",100,0,10);

	TH1F *hkmpx_m  = new TH1F("hkmpx_m","K- px, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkmpy_m  = new TH1F("hkmpy_m","K- py, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkmpz_m = new TH1F("hkmpz_m","K- pz, daughter of Ds- ",100,-1,9);
	TH1F *hkmE_m = new TH1F("hkmE_m","K- E, daughter of Ds- ",100,0,10);
	
	TH1F *hkppx_m  = new TH1F("hkppx_m","K+ px, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkppy_m  = new TH1F("hkppy_m","K+ py, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkppz_m = new TH1F("hkppz_m","K+ pz, daughter of Ds- ",100,-1,9);
	TH1F *hkpE_m = new TH1F("hkpE_m","K+ E, daughter of Ds- ",100,0,10);

	TH1F *h12_m  = new TH1F("h12_m","Ds-: K+ K- invariant mass",100,0.5,3);
	TH1F *h13_m  = new TH1F("h13_m","Ds-: K+ pi+ invariant mass",100,0.5,3);
	TH1F *h23_m  = new TH1F("h23_m","Ds-: K- pi+ invariant mass",100,0.5,3);
	

	//

		
	TH1F *hpmpx_p  = new TH1F("hpmpx_p","#pi- px, daughter of Ds- ",100,-3,3);
	TH1F *hpmpy_p  = new TH1F("hpmpy_p","#pi- py, daughter of Ds- ",100,-3,3);
	TH1F *hpmpz_p = new TH1F("hpmpz_p","#pi- pz, daughter of Ds- ",100,-1,9);
	TH1F *hpmE_p = new TH1F("hpmE_p","#pi- E, daughter of Ds- ",100,0,10);

	TH1F *hkmpx_p  = new TH1F("hkmpx_p","K- px, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkmpy_p  = new TH1F("hkmpy_p","K- py, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkmpz_p = new TH1F("hkmpz_p","K- pz, daughter of Ds- ",100,-1,9);
	TH1F *hkmE_p = new TH1F("hkmE_p","K- E, daughter of Ds- ",100,0,10);
	
	TH1F *hkppx_p  = new TH1F("hkppx_p","K+ px, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkppy_p  = new TH1F("hkppy_p","K+ py, daughter of Ds- ",100,-1.5,1.5);
	TH1F *hkppz_p = new TH1F("hkppz_p","K+ pz, daughter of Ds- ",100,-1,9);
	TH1F *hkpE_p = new TH1F("hkpE_p","K+ E, daughter of Ds- ",100,0,10);

	TH1F *h12_p  = new TH1F("h12_p","Ds+: K+ K- invariant mass",100,0.5,3);
	TH1F *h13_p  = new TH1F("h13_p","Ds+: K+ pi+ invariant mass",100,0.5,3);
	TH1F *h23_p  = new TH1F("h23_p","Ds+: K- pi+ invariant mass",100,0.5,3);
	
	TH1F *h12_m  = new TH1F("h12_m","Ds-: K+ K- invariant mass",100,0.5,3);
	TH1F *h13_m  = new TH1F("h13_m","Ds-: K+ pi- invariant mass",100,0.5,3);
	TH1F *h23_m  = new TH1F("h23_m","Ds-: K- pi- invariant mass",100,0.5,3);


	
	TH1F *Dsp_nm = new TH1F("Dsp_nm","Ds+ mass (no truth match)",100,0,5.);
	TH1F *Dsm_nm = new TH1F("Dsm_nm","Ds- mass (no truth match)",100,0,5.);
	TH1F *pi0_nm = new TH1F("pi0_nm","#pi0 mass (no truth match)",100,0,0.6);
	TH1F *Dstar_nm = new TH1F("Dstarstar_nm","Ds*+ mass (no truth match)",100,0,5.);
	TH1F *D2460_nm  = new TH1F("D2460_nm","Ds'1+ mass (no truth match)",100,0,5.);
		

	//fitters


	TH1F *Dsm_vtx_z   = new TH1F("Dsm_vtx_z",  "Ds- Z",100,-0.5,0.5);
	TH1F *Dsp_vtx_z   = new TH1F("Dsp_vtx_z",  "Ds+ Z",100,-0.5,0.5);
	TH1F *pi0_vtx_z   = new TH1F("pi0_vtx_z",  "#pi0 Z",100,-0.5,0.5);
	TH1F *Dstar_vtx_z   = new TH1F("Dstar_vtx_z",  "Ds*+ Z",100,-0.5,0.5);
	TH1F *D2460_vtx_z   = new TH1F("D2460_vtx_z",  "D'1s+: Z",100,-0.5,0.5);

	TH2F *hDalitzm12m13_m = new TH2F("hDalitzm12m13_m","m12 vs m13",30,0,8.5,30,0,8.5);
	TH2F *hDalitzm12m23_m = new TH2F("hDalitzm12m23_m","m12 vs m23",30,0,8.5,30,0,8.5);
	TH2F *hDalitzm13m23_m = new TH2F("hDalitzm13m23_m","m13 vs m23",30,0,8.5,30,0,8.5);
	TH2F *hDalitzm12m13_p = new TH2F("hDalitzm12m13_p","m12 vs m13",30,0,8.5,30,0,8.5);
	TH2F *hDalitzm12m23_p = new TH2F("hDalitzm12m23_p","m12 vs m23",30,0,8.5,30,0,8.5);
	TH2F *hDalitzm13m23_p = new TH2F("hDalitzm13m23_p","m13 vs m23",30,0,8.5,30,0,8.5);
	

	//
	// Now the analysis stuff comes...
	//
	
	
	// *** the data reader object
	PndAnalysis* theAnalysis = new PndAnalysis();
	if (nevts==0) nevts= theAnalysis->GetEntries();
	
	// *** RhoCandLists for the analysis
	RhoCandList kplus, kminus, piplus, piminus, Dstar, Dsplist, Dsmlist, Ds2460, gammas, pi0list;
	
	// *** Mass selector for the jpsi cands

	RhoMassParticleSelector *DsMassSel=new RhoMassParticleSelector("D_s-",1.9686,0.5);
	RhoMassParticleSelector *DstarMassSel=new RhoMassParticleSelector("D_s*+", 2.1124,0.5);
	RhoMassParticleSelector *Ds2460MassSel=new RhoMassParticleSelector("D_s1+",2.457,0.5);
	RhoMassParticleSelector *DsMassSelPrefit=new RhoMassParticleSelector("D_s-",1.9686,0.9);
	RhoMassParticleSelector *DsMassSelPid=new RhoMassParticleSelector("D_s-",1.9686,1.0);
	RhoMassParticleSelector *Pi0MassSel=new RhoMassParticleSelector("pi0",0.134976,0.3);

	// *** the lorentz vector of the initial Ds1+ + Ds- system
	TLorentzVector ini(0., 0.,9.58784,10.5719);
	Double_t kppx, kppy, kppz, kpE;
	Double_t kmpx, kmpy, kmpz, kmE;
	Double_t pmpx, pmpy, pmpz, pmE;
	Double_t m12, m23, m13, m2P12, m2P13, m2P23;
	
	// ***
	// the event loop
	// ***
	while (theAnalysis->GetEvent() && i++<nevts)
	{
		if ((i%10)==0) cout<<"evt " << i << endl;
				
		// *** Select with no PID info ('All'); type and mass are set 		
		theAnalysis->FillList(kplus,  "KaonAllPlus");
		theAnalysis->FillList(kminus, "KaonAllMinus");
		theAnalysis->FillList(piplus,  "PionAllPlus");
		theAnalysis->FillList(piminus, "PionAllMinus");
		theAnalysis->FillList(gammas, "Neutral");


		Dsplist.Cleanup();
		Dsmlist.Cleanup();
		// *** combinatorics for Ds-/+ to K+ K- pi-
		Dsplist.Combine(kminus,kplus,piplus);
	       	Dsmlist.Combine(kplus,kminus,piminus);

		pi0list.Cleanup();
		// *** combinatorics for pi0 to gg
		pi0list.Combine(gammas,gammas);
		
		Dstar.Cleanup();
		// *** combinatorics for Ds*+ to Ds+ gamma
		Dstar.Combine(Dsplist,gammas);
		
		Ds2460.Cleanup();
		// *** combinatorics for Ds1+ to Ds* K+
		Ds2460.Combine(Dstar,pi0list);

		// ***
		// *** do the TRUTH MATCH for pi0
		// ***
		
		pi0list.SetType(111);
		gammas.SetType(22);
				
		for (j=0;j<pi0list.GetLength();++j) 
		{
			pi0_all->Fill( pi0list[j]->M() );

			if (theAnalysis->McTruthMatch(pi0list[j]))
			{ 
				pi0_ftm->Fill( pi0list[j]->M() );
				pi0_px_ftm->Fill(pi0list[j]->Px());
				pi0_py_ftm->Fill( pi0list[j]->Py());
				pi0_pz_ftm->Fill( pi0list[j]->Pz());
				pi0_E_ftm->Fill( pi0list[j]->E());
			 	pi0_mass_diff_ftm->Fill( pi0list[j]->GetMcTruth()->M() - pi0list[j]->M() );
				pi0_px_diff_ftm->Fill(pi0list[j]->GetMcTruth()->Px()- pi0list[j]->Px());
				pi0_py_diff_ftm->Fill( pi0list[j]->GetMcTruth()->Py()-pi0list[j]->Py());
				pi0_pz_diff_ftm->Fill( pi0list[j]->GetMcTruth()->Pz()-pi0list[j]->Pz());
				pi0_E_diff_ftm->Fill( pi0list[j]->GetMcTruth()->E() - pi0list[j]->E());
				pi0_Mom_ftm->Fill( pi0list[j]->P());
			}
			//			else 
			//	pi0_nm->Fill( pi0list[j]->M() );
			//	}
		}
		
		// *** do the TRUTH MATCH for Ds-
		// ***
		
		Dsmlist.SetType(-431);
				
		for (j=0;j<Dsmlist.GetLength();++j) 
		{
			Dsm_all->Fill( Dsmlist[j]->M() );
			
			if (theAnalysis->McTruthMatch(Dsmlist[j]))
			{ 
				Dsm_ftm->Fill( Dsmlist[j]->M() );
			 	Dsm_mass_diff_ftm->Fill( Dsmlist[j]->GetMcTruth()->M() - Dsmlist[j]->M() );
				Dsm_px_ftm->Fill( Dsmlist[j]->Px());
				Dsm_py_ftm->Fill( Dsmlist[j]->Py());
				Dsm_pz_ftm->Fill( Dsmlist[j]->Pz());
				Dsm_E_ftm->Fill( Dsmlist[j]->E());
				Dsm_Mom_ftm->Fill( Dsmlist[j]->P());
				Dsm_px_diff_ftm->Fill(Dsmlist[j]->GetMcTruth()->Px() -  Dsmlist[j]->Px());
				Dsm_py_diff_ftm->Fill(Dsmlist[j]->GetMcTruth()->Py() -  Dsmlist[j]->Py());
				Dsm_pz_diff_ftm->Fill(Dsmlist[j]->GetMcTruth()->Pz() -  Dsmlist[j]->Pz());
				Dsm_E_diff_ftm->Fill(Dsmlist[j]->GetMcTruth()->E() -  Dsmlist[j]->E());

				RhoCandidate *kpluscand = Dsmlist[j]->Daughter(0);
				RhoCandidate *kminuscand = Dsmlist[j]->Daughter(1);
				RhoCandidate *piminuscand = Dsmlist[j]->Daughter(2);

				TLorentzVector m1(kppx, kppy, kppz, kpE); 
				TLorentzVector m2(kmpx, kmpy, kmpz, kmE); 
				TLorentzVector m3(pmpx, pmpy, pmpz, pmE);
				kppx = kpluscand->Px();
				kppy = kpluscand->Py();
				kppz = kpluscand->Pz();
				kpE = kpluscand->E();
				kmpx = kminuscand->Px();
				kmpy = kminuscand->Py();
				kmpz = kminuscand->Pz();
				kmE = kminuscand->E();
				pmpx = piminuscand->Px();
				pmpy = piminuscand->Py();
				pmpz = piminuscand->Pz();
				pmE = piminuscand->E();

				m12 = (m1+m2).M();
				m13 = (m1+m3).M();
				m23 = (m2+m3).M();

				m2P12 = m12*m12;
				m2P13 = m13*m13;
				m2P23 = m23*m23;

				h12_m->Fill(m12);
				h13_m->Fill(m13);
				h23_m->Fill(m23);

				hDalitzm12m13_m->Fill(m2P12,m2P13);
				hDalitzm12m23_m->Fill(m2P12,m2P23);
				hDalitzm13m23_m->Fill(m2P13,m2P23);
				
				hpmpx_m->Fill(pmpx);
				hpmpy_m->Fill(pmpy);
				hpmpz_m->Fill(pmpz);
				hpmE_m->Fill(pmE);
				
				hkmpx_m->Fill(kmpx);
				hkmpy_m->Fill(kmpy);
				hkmpz_m->Fill(kmpz);
				hkmE_m->Fill(kmE);
				
				hkppx_m->Fill(kppx);
				hkppy_m->Fill(kppy);
				hkppz_m->Fill(kppz);
				hkpE_m->Fill(kpE);
			
			}
			//	else 
			//			Dsm_nm->Fill( Dsmlist[j]->M() );
		}

		// *** do the TRUTH MATCH for Ds+
		// ***
		
		Dsplist.SetType(431);
				
		for (j=0;j<Dsplist.GetLength();++j) 
		{
			Dsp_all->Fill( Dsplist[j]->M() );
			
			if (theAnalysis->McTruthMatch(Dsplist[j]))
			{ 
				Dsp_ftm->Fill( Dsplist[j]->M() );
			 	Dsp_mass_diff_ftm->Fill( Dsplist[j]->GetMcTruth()->M() - Dsplist[j]->M() );
				Dsp_px_ftm->Fill( Dsplist[j]->Px());
				Dsp_py_ftm->Fill( Dsplist[j]->Py());
				Dsp_pz_ftm->Fill( Dsplist[j]->Pz());
				Dsp_E_ftm->Fill( Dsplist[j]->E());
				Dsp_Mom_ftm->Fill( Dsplist[j]->P());
				Dsp_px_diff_ftm->Fill(Dsplist[j]->GetMcTruth()->Px() -  Dsplist[j]->Px());
				Dsp_py_diff_ftm->Fill(Dsplist[j]->GetMcTruth()->Py() -  Dsplist[j]->Py());
				Dsp_pz_diff_ftm->Fill(Dsplist[j]->GetMcTruth()->Pz() -  Dsplist[j]->Pz());
				Dsp_E_diff_ftm->Fill(Dsplist[j]->GetMcTruth()->E() -  Dsplist[j]->E());

				RhoCandidate *kpluscand = Dsplist[j]->Daughter(0);
				RhoCandidate *kminuscand = Dsplist[j]->Daughter(1);
				RhoCandidate *pipluscand = Dsplist[j]->Daughter(2);

				TLorentzVector m1(kppx, kppy, kppz, kpE); 
				TLorentzVector m2(kmpx, kmpy, kmpz, kmE); 
				TLorentzVector m3(pmpx, pmpy, pmpz, pmE);
				kppx = kpluscand->Px();
				kppy = kpluscand->Py();
				kppz = kpluscand->Pz();
				kpE = kpluscand->E();
				kmpx = kminuscand->Px();
				kmpy = kminuscand->Py();
				kmpz = kminuscand->Pz();
				kmE = kminuscand->E();
				pmpx = pipluscand->Px();
				pmpy = pipluscand->Py();
				pmpz = pipluscand->Pz();
				pmE = pipluscand->E();

				m12 = (m1+m2).M();
				m13 = (m1+m3).M();
				m23 = (m2+m3).M();

				m2P12 = m12*m12;
				m2P13 = m13*m13;
				m2P23 = m23*m23;

				h12_p->Fill(m12);
				h13_p->Fill(m13);
				h23_p->Fill(m23);

				hDalitzm12m13_p->Fill(m2P12,m2P13);
				hDalitzm12m23_p->Fill(m2P12,m2P23);
				hDalitzm13m23_p->Fill(m2P13,m2P23);
				
				hpmpx_p->Fill(pmpx);
				hpmpy_p->Fill(pmpy);
				hpmpz_p->Fill(pmpz);
				hpmE_p->Fill(pmE);
				
				hkmpx_p->Fill(kmpx);
				hkmpy_p->Fill(kmpy);
				hkmpz_p->Fill(kmpz);
				hkmE_p->Fill(kmE);
				
				hkppx_p->Fill(kppx);
				hkppy_p->Fill(kppy);
				hkppz_p->Fill(kppz);
				hkpE_p->Fill(kpE);
			
			}
			//		else 
			//	Dsp_nm->Fill( Dsplist[j]->M() );
		}



			
		// ***
		// *** do the TRUTH MATCH for Ds*+
		// ***

		
		Dstar.SetType(433);
		pi0list.SetType(111);
		gammas.SetType(22);
				
		for (j=0;j<Dstar.GetLength();++j) 
		{
			Dstar_all->Fill( Dstar[j]->M() );

			if (theAnalysis->McTruthMatch(Dstar[j]))
			{ 
				Dstar_ftm->Fill( Dstar[j]->M() );
			 	Dstar_mass_diff_ftm->Fill( Dstar[j]->GetMcTruth()->M() - Dstar[j]->M() );
				Dstar_px_ftm->Fill( Dstar[j]->Px());
				Dstar_py_ftm->Fill( Dstar[j]->Py());
				Dstar_pz_ftm->Fill( Dstar[j]->Pz());
				Dstar_E_ftm->Fill( Dstar[j]->E());
				Dstar_Mom_ftm->Fill( Dstar[j]->P());
				Dstar_px_diff_ftm->Fill( Dstar[j]->GetMcTruth()->Px() - Dstar[j]->Px());
				Dstar_py_diff_ftm->Fill( Dstar[j]->GetMcTruth()->Py() - Dstar[j]->Py());
				Dstar_pz_diff_ftm->Fill( Dstar[j]->GetMcTruth()->Pz() - Dstar[j]->Pz());
				Dstar_E_diff_ftm->Fill( Dstar[j]->GetMcTruth()->E() - Dstar[j]->E());
				
			}
			//	else 
			//	Dstar_nm->Fill( Dstar[j]->M() );
		}
	// ***

		
		// ***
		// *** do the TRUTH MATCH for Ds'1+
		// ***
		
		Ds2460.SetType(10433);
		//cout<<Ds2460.PdgCode()<<endl;
						
		for (j=0;j<Ds2460.GetLength();++j) 
		{
			D2460_all->Fill( Ds2460[j]->M() );
			
			if (theAnalysis->McTruthMatch(Ds2460[j]))
			{ 
				D2460_ftm->Fill( Ds2460[j]->M() );
				D2460_mass_diff_ftm->Fill( Ds2460[j]->GetMcTruth()->M() - Ds2460[j]->M() );
				D2460_px_ftm->Fill( Ds2460[j]->Px());
				D2460_py_ftm->Fill( Ds2460[j]->Py());
				D2460_pz_ftm->Fill( Ds2460[j]->Pz());
				D2460_E_ftm->Fill( Ds2460[j]->E());
				D2460_Mom_ftm->Fill( Ds2460[j]->P());
				D2460_px_diff_ftm->Fill( Ds2460[j]->GetMcTruth()->Px() - Ds2460[j]->Px());
				D2460_py_diff_ftm->Fill( Ds2460[j]->GetMcTruth()->Py() - Ds2460[j]->Py());
				D2460_pz_diff_ftm->Fill( Ds2460[j]->GetMcTruth()->Pz() - Ds2460[j]->Pz());
				D2460_E_diff_ftm->Fill( Ds2460[j]->GetMcTruth()->E() - Ds2460[j]->E());	
				//	hvpos->Fill(Ds2460[j]->Pos()->X(),Ds2460[j]->Pos()->Y());
			
			}
			//	else 
			//	D2460_nm->Fill( Ds2460[j]->M() );
		}
		

		Dsmlist.Select(DsMassSelPid);
		Dsplist.Select(DsMassSelPid);
		Dstar.Select(DstarMassSel);
		pi0list.Select(Pi0MassSel);
	
		// ***
		// *** TRUE PID combinatorics
		// ***

	}
	// *** write out all the histos
	out->cd();
	
	D2460_all->Write();
	Dsm_all->Write();
	Dsp_all->Write();
	Dstar_all->Write();
	pi0_all->Write();

	D2460_ftm->Write();
	Dsp_ftm->Write();
	Dsm_ftm->Write();
	pi0_ftm->Write();

	pi0_vtx_z->Write();
	Dsp_vtx_z->Write();
	Dsm_vtx_z->Write();
	Dstar_vtx_z->Write();
	D2460_vtx_z->Write();
	
	D2460_px_ftm->Write();
	D2460_py_ftm->Write();
	D2460_pz_ftm->Write();
	D2460_E_ftm->Write();
	D2460_px_diff_ftm->Write();
	D2460_py_diff_ftm->Write();
	D2460_pz_diff_ftm->Write();
	D2460_E_diff_ftm->Write();
	D2460_mass_diff_ftm->Write();

	pi0_px_ftm->Write();
	pi0_py_ftm->Write();
	pi0_pz_ftm->Write();
	pi0_E_ftm->Write();
	pi0_px_diff_ftm->Write();
	pi0_py_diff_ftm->Write();
	pi0_pz_diff_ftm->Write();
	pi0_E_diff_ftm->Write();
	pi0_mass_diff_ftm->Write();
	
	
	Dstar_px_ftm->Write();
	Dstar_py_ftm->Write();
	Dstar_pz_ftm->Write();
	Dstar_E_ftm->Write();
	Dstar_px_diff_ftm->Write();
	Dstar_py_diff_ftm->Write();
	Dstar_pz_diff_ftm->Write();
	Dstar_E_diff_ftm->Write();
	Dstar_mass_diff_ftm->Write();
	
	Dsm_px_ftm->Write();
	Dsm_py_ftm->Write();
	Dsm_pz_ftm->Write();
	Dsm_E_ftm->Write();
	Dsm_px_diff_ftm->Write();
	Dsm_py_diff_ftm->Write();
	Dsm_pz_diff_ftm->Write();
	Dsm_E_diff_ftm->Write();
	Dsm_mass_diff_ftm->Write();
	Dsp_px_ftm->Write();
	Dsp_py_ftm->Write();
	Dsp_pz_ftm->Write();
	Dsp_E_ftm->Write();
	Dsp_px_diff_ftm->Write();
	Dsp_py_diff_ftm->Write();
	Dsp_pz_diff_ftm->Write();
	Dsp_E_diff_ftm->Write();
	Dsp_mass_diff_ftm->Write();


	hkmpx_m->Write();
	hkmpy_m->Write();
	hkmpz_m->Write();
	hkmE_m->Write();
	hkppx_m->Write();
	hkppy_m->Write();
	hkppz_m->Write();
	hkpE_m->Write();
	hpmpx_m->Write();
	hpmpy_m->Write();
	hpmpz_m->Write();
	hpmE_m->Write();

	hkmpx_p->Write();
	hkmpy_p->Write();
	hkmpz_p->Write();
	hkmE_p->Write();
	hkppx_p->Write();
	hkppy_p->Write();
	hkppz_p->Write();
	hkpE_p->Write();
	hpmpx_p->Write();
	hpmpy_p->Write();
	hpmpz_p->Write();
	hpmE_p->Write();

	h12_m->Write();
	h13_m->Write();
	h23_m->Write();

	h12_p->Write();
	h13_p->Write();
	h23_p->Write();

	hDalitzm12m13_m->Write();
	hDalitzm12m23_m->Write();
	hDalitzm13m23_m->Write();

	hDalitzm12m13_p->Write();
	hDalitzm12m23_p->Write();
	hDalitzm13m23_p->Write();


	out->Save();

}
