#if !defined(__CINT__) || defined(__MAKECINT__)
#include "Riostream.h"
#include <stdio.h>
#include "TSystem.h"
#include "TMath.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TProfile.h"
#include "TStyle.h"
#include "TF1.h"
#include "TTree.h"
#include "TChain.h"
#include "TFile.h"
#include "TNtuple.h"
#include "TCanvas.h"
#include "TMinuit.h"
#include "TSpectrum.h"
#include "TString.h"
#include "TLegend.h"
#include "TLine.h"
#include "TText.h"
#include "TROOT.h"
#include "TList.h"
#include "TPolyMarker.h"
#include "StBichsel/Bichsel.h"
#include "BetheBloch.h"
#include "TDirIter.h"
#include "TTreeIter.h"
#else
class TSystem;
class TMath;
class TH1;
class TH2;
class TH3;
class TProfile;
class TStyle;
class TF1;
class TTree;
class TChain;
class TFile;
class TNtuple;
class TCanvas;
class TMinuit;
class TSpectrum;
class TString;
class TLegend;
class TLine;
class TText;
class TROOT;
class TList;
class TPolyMarker;
class Bichsel;
class BetheBloch;
class TDirIter;
class TTreeIter;
#endif
TChain *chain = 0;

//________________________________________________________________________________
void myMiniMcReaderLD0s(const char* listName="1kPureD0minimc.list") {  // root.exe 'MiniMcPlots.C+("*minimc.root")'
	Int_t NFiles = 0;
	ifstream inFile;
	Int_t NumD0Daughters = 0;
	Int_t NumKm = 0;
	Int_t NumPip = 0;
	Int_t NumD0 = 0;

	inFile.open(listName);
	FILE *readMe = fopen("READMEminimc.txt","w");{  //create file with the layout for data stored in text file
		fprintf(readMe,"The data stored in each row corresponds to data for the parent and daughter particles for one event. \n");
		fprintf(readMe,"fileIdMc \t mEventId \t mRunId \t mVertexX \t mVertexY \t mVertexZ \t PtDMc \t PxDMc \t PyDMc \t PzDMc \t EtaDMc \t PhiDMc \t GeantK \t StopRK \t KeyK \t RecoKeyK \t PtKPr \t PxKPr \t PyKPr \t PzKPr \t EtaKPr \t PhiKPr \t DCAKPr \t DCAxyKPr \t DCAzKPr \t PtKGl \t PxKGl \t PyKGl \t PzKGl \t EtaKGl \t PhiKGl \t DCAKGl \t DCAxyKGl \t DCAzKGl \t GeantPi \t StopRPi \t KeyPi \t RecoKeyPi \t PtPiPr \t PxPiPr \t PyPiPr \t PzPiPr \t EtaPiPr \t PhiPiPr \t DCAPiPr \t DCAxyPiPr \t DCAzPiPr \t PtPiGl \t PxPiGl \t PyPiGl \t PzPiGl \t EtaPiGl \t PhiPiGl \t DCAPiGl \t DCAxyPiGl \t DCAzPiGl \n");
		fprintf(readMe,"You can use the data in miniMcKeys.txt to find the same event in GEANT, and in the analysis code muKPi.C. \n");
	}
	fclose(readMe);
	cout << "***** READMEminimc.txt written *****" << endl << endl;
	FILE *miniMcKeys = fopen("miniMcKeysD0s.txt","w");{
		while (NFiles < 1) {
			TTreeIter iter("StMiniMcTree");
			TString t;
			Int_t fileIdIntMiniMc = 0;
			inFile >> t;
			cout << "NFiles = " << NFiles << " t = " << t << endl;
			TString fileIdMiniMc(t);
			fileIdMiniMc.ReplaceAll("/star/institutions/ksu/fisyak/D0B/rcf1272_","");
			fileIdMiniMc.ReplaceAll("/star/institutions/ksu/fisyak/D0_mixC/rcf1272_","");
			fileIdMiniMc.ReplaceAll("_400evts_37.minimc.root","");
			fileIdMiniMc.ReplaceAll("_400evts_37_mix.minimc.root","");
			fileIdMiniMc.ReplaceAll("LD0sgoodDev_100evts_","");
			fileIdMiniMc.ReplaceAll("minimc.root","");
			fileIdIntMiniMc = atoi(fileIdMiniMc);
			cout << "fileIdMiniMc = " << fileIdMiniMc << endl;
			cout << "fileIdIntMiniMc = " << fileIdIntMiniMc << endl;
			if(!inFile.good()) break;
			iter.Reset();
			iter.AddFile(t);
			NFiles++;
			
			const Int_t                           &mEventId = iter("mEventId");
			const Int_t                             &mRunId = iter("mRunId");
//			const Int_t                        &mOriginMult = iter("mOriginMult");
//			const Int_t                       &mCentralMult = iter("mCentralMult");
//			const Int_t                        &mCentrality = iter("mCentrality");
//			const Int_t     &mNUncorrectedNegativePrimaries = iter("mNUncorrectedNegativePrimaries");
//			const Int_t             &mNUncorrectedPrimaries = iter("mNUncorrectedPrimaries");
//			const Int_t        &mNFtpcWUncorrectedPrimaries = iter("mNFtpcWUncorrectedPrimaries");
//			const Int_t        &mNFtpcEUncorrectedPrimaries = iter("mNFtpcEUncorrectedPrimaries");
//			const Int_t                            &mMcMult = iter("mMcMult");
//			const Int_t                            &mNMcNch = iter("mNMcNch");
//			const Int_t                       &mNMcFtpcWNch = iter("mNMcFtpcWNch");
//			const Int_t                       &mNMcFtpcENch = iter("mNMcFtpcENch");
//			const Int_t                         &mNMcHminus = iter("mNMcHminus");
//			const Int_t                         &mNMcGlobal = iter("mNMcGlobal");
//			const Int_t                   &mNMcGoodGlobal20 = iter("mNMcGoodGlobal20");
//			const Int_t                         &mNRcGlobal = iter("mNRcGlobal");
//			const Int_t                   &mNRcGoodGlobal20 = iter("mNRcGoodGlobal20");
			const Float_t                           &mVertexX = iter("mVertexX");
			const Float_t                           &mVertexY = iter("mVertexY");
			const Float_t                           &mVertexZ = iter("mVertexZ");
	//		const Float_t                         &mMcVertexX = iter("mMcVertexX");
	//		const Float_t                         &mMcVertexY = iter("mMcVertexY");
	//		const Float_t                         &mMcVertexZ = iter("mMcVertexZ");
//			const Float_t                          &mMagField = iter("mMagField");
	//		const Float_t                &mCenterOfMassEnergy = iter("mCenterOfMassEnergy");
//			const Float_t                    &mBackgroundRate = iter("mBackgroundRate");
//			const Short_t                &mBeamMassNumberEast = iter("mBeamMassNumberEast");
//			const Short_t                &mBeamMassNumberWest = iter("mBeamMassNumberWest");
//			const Float_t                               &mCtb = iter("mCtb");
//			const Float_t                              &mZdcE = iter("mZdcE");
//			const Float_t                              &mZdcW = iter("mZdcW");
			const Int_t                          &mNMcTrack = iter("mNMcTrack");
	//		const Int_t                      &mNMatchedPair = iter("mNMatchedPair");
//			const Int_t                       &mNMergedPair = iter("mNMergedPair");
//			const Int_t                        &mNSplitPair = iter("mNSplitPair");
//			const Int_t                        &mNGhostPair = iter("mNGhostPair");
//			const Int_t                       &mNContamPair = iter("mNContamPair");
//			const Int_t                      &mNMatGlobPair = iter("mNMatGlobPair");
			const Int_t                         &mMcTracks_ = iter("mMcTracks_");
  //yf		const Char_t                *&mMcTracks_mIsValid = iter("mMcTracks.mIsValid");   //[mMcTracks_]
			const Float_t                   *&mMcTracks_mPtMc = iter("mMcTracks.mPtMc");
			const Float_t                   *&mMcTracks_mPzMc = iter("mMcTracks.mPzMc");
			const Float_t                  *&mMcTracks_mEtaMc = iter("mMcTracks.mEtaMc");
			const Float_t                  *&mMcTracks_mPhiMc = iter("mMcTracks.mPhiMc");
	//		const Short_t                 *&mMcTracks_mNHitMc = iter("mMcTracks.mNHitMc");
//			const Short_t              *&mMcTracks_mNSvtHitMc = iter("mMcTracks.mNSvtHitMc");
//			const Short_t              *&mMcTracks_mNSsdHitMc = iter("mMcTracks.mNSsdHitMc");
//			const Short_t             *&mMcTracks_mNFtpcHitMc = iter("mMcTracks.mNFtpcHitMc");
			const Short_t                *&mMcTracks_mGeantId = iter("mMcTracks.mGeantId");
//			const Short_t               *&mMcTracks_mChargeMc = iter("mMcTracks.mChargeMc");
			const Float_t                  *&mMcTracks_mStopR = iter("mMcTracks.mStopR");
	//		const Short_t                    *&mMcTracks_mKey = iter("mMcTracks.mKey");
//			const Short_t               *&mMcTracks_mNAssocGl = iter("mMcTracks.mNAssocGl");
//			const Short_t               *&mMcTracks_mNAssocPr = iter("mMcTracks.mNAssocPr");
  //yf		const Short_t         *&mMcTracks_mIsPrimary = iter("mMcTracks.mIsPrimary");   //[mMcTracks_]
			const Int_t                     &mMatchedPairs_ = iter("mMatchedPairs_");
//			const Short_t         *&mMatchedPairs_mNCommonHit = iter("mMatchedPairs.mNCommonHit");
//			const Short_t       *&mMatchedPairs_mIsBestContam = iter("mMatchedPairs.mIsBestContam");
			const Short_t        *&mMatchedPairs_mDominatrack = iter("mMatchedPairs.mDominatrack");
//			const Short_t     *&mMatchedPairs_mDominCommonHit = iter("mMatchedPairs.mDominCommonHit");
//			const Float_t         *&mMatchedPairs_mAvgQuality = iter("mMatchedPairs.mAvgQuality");
			const Char_t          *&mMatchedPairs_mIsValid = iter("mMatchedPairs.mIsValid");   //[mMatchedPairs_]
	//		const Float_t               *&mMatchedPairs_mPtMc = iter("mMatchedPairs.mPtMc");
	//		const Float_t               *&mMatchedPairs_mPzMc = iter("mMatchedPairs.mPzMc");
	//		const Float_t              *&mMatchedPairs_mEtaMc = iter("mMatchedPairs.mEtaMc");
	//		const Float_t              *&mMatchedPairs_mPhiMc = iter("mMatchedPairs.mPhiMc");
	//		const Short_t             *&mMatchedPairs_mNHitMc = iter("mMatchedPairs.mNHitMc");
//			const Short_t          *&mMatchedPairs_mNSvtHitMc = iter("mMatchedPairs.mNSvtHitMc");
//			const Short_t          *&mMatchedPairs_mNSsdHitMc = iter("mMatchedPairs.mNSsdHitMc");
//			const Short_t         *&mMatchedPairs_mNFtpcHitMc = iter("mMatchedPairs.mNFtpcHitMc");
			const Short_t            *&mMatchedPairs_mGeantId = iter("mMatchedPairs.mGeantId");
			const Short_t           *&mMatchedPairs_mChargeMc = iter("mMatchedPairs.mChargeMc");
			const Float_t              *&mMatchedPairs_mStopR = iter("mMatchedPairs.mStopR");
			const Short_t                *&mMatchedPairs_mKey = iter("mMatchedPairs.mKey");
			const Short_t			*&mMatchedPairs_mParentKey = iter("mMatchedPairs.mParentKey");
			const Short_t			*&mMatchedPairs_mParentGeantId = iter("mMatchedPairs.mParentGeantId");
	//		const Short_t           *&mMatchedPairs_mNAssocGl = iter("mMatchedPairs.mNAssocGl");
	//		const Short_t           *&mMatchedPairs_mNAssocPr = iter("mMatchedPairs.mNAssocPr");
			const Float_t               *&mMatchedPairs_mPtPr = iter("mMatchedPairs.mPtPr");
			const Char_t          *&mMatchedPairs_mIsValidGl = iter("mMatchedPairs.mIsValidGl");   //[mMatchedPairs_]
  //yf		const Short_t         *&mMatchedPairs_mIsPrimary = iter("mMatchedPairs.mIsPrimary");
			const Float_t               *&mMatchedPairs_mPzPr = iter("mMatchedPairs.mPzPr");
			const Float_t              *&mMatchedPairs_mEtaPr = iter("mMatchedPairs.mEtaPr");
			const Float_t              *&mMatchedPairs_mPhiPr = iter("mMatchedPairs.mPhiPr");
			const Float_t              *&mMatchedPairs_mDcaPr = iter("mMatchedPairs.mDcaPr");
			const Float_t            *&mMatchedPairs_mDcaXYPr = iter("mMatchedPairs.mDcaXYPr");
			const Float_t             *&mMatchedPairs_mDcaZPr = iter("mMatchedPairs.mDcaZPr");
//			const Float_t             *&mMatchedPairs_mCurvPr = iter("mMatchedPairs.mCurvPr");
//			const Float_t             *&mMatchedPairs_mTanLPr = iter("mMatchedPairs.mTanLPr");
  //		Float_t           **&mMatchedPairs_mErrP    = iter("mMatchedPairs.mErrP[5]");
//			const Float_t             *&mMatchedPairs_mChi2Pr = iter("mMatchedPairs.mChi2Pr");
			const Short_t               *&mMatchedPairs_mFlag = iter("mMatchedPairs.mFlag");
//			const Float_t               *&mMatchedPairs_mDedx = iter("mMatchedPairs.mDedx");
			const Float_t               *&mMatchedPairs_mPtGl = iter("mMatchedPairs.mPtGl");
			const Float_t               *&mMatchedPairs_mPzGl = iter("mMatchedPairs.mPzGl");
			const Float_t              *&mMatchedPairs_mEtaGl = iter("mMatchedPairs.mEtaGl");
			const Float_t              *&mMatchedPairs_mPhiGl = iter("mMatchedPairs.mPhiGl");
			const Float_t              *&mMatchedPairs_mDcaGl = iter("mMatchedPairs.mDcaGl");
			const Float_t            *&mMatchedPairs_mDcaXYGl = iter("mMatchedPairs.mDcaXYGl");
			const Float_t             *&mMatchedPairs_mDcaZGl = iter("mMatchedPairs.mDcaZGl");
//			const Float_t             *&mMatchedPairs_mCurvGl = iter("mMatchedPairs.mCurvGl");
//			const Float_t             *&mMatchedPairs_mTanLGl = iter("mMatchedPairs.mTanLGl");
  //		Float_t           **&mMatchedPairs_mErrG    = iter("mMatchedPairs.mErrG[5]");
//			const Float_t            *&mMatchedPairs_mPidPion = iter("mMatchedPairs.mPidPion");
//			const Float_t          *&mMatchedPairs_mPidProton = iter("mMatchedPairs.mPidProton");
//			const Float_t            *&mMatchedPairs_mPidKaon = iter("mMatchedPairs.mPidKaon");
//			const Float_t        *&mMatchedPairs_mPidElectron = iter("mMatchedPairs.mPidElectron");
//			const Float_t             *&mMatchedPairs_mFirstZ = iter("mMatchedPairs.mFirstZ");
//			const Float_t              *&mMatchedPairs_mLastZ = iter("mMatchedPairs.mLastZ");
//			const Short_t        *&mMatchedPairs_mFirstPadrow = iter("mMatchedPairs.mFirstPadrow");
//			const Short_t         *&mMatchedPairs_mLastPadrow = iter("mMatchedPairs.mLastPadrow");
//			const Short_t     *&mMatchedPairs_mFirstFitPadrow = iter("mMatchedPairs.mFirstFitPadrow");
//			const Short_t      *&mMatchedPairs_mLastFitPadrow = iter("mMatchedPairs.mLastFitPadrow");
//			const Short_t        *&mMatchedPairs_mFirstSector = iter("mMatchedPairs.mFirstSector");
//			const Short_t         *&mMatchedPairs_mLastSector = iter("mMatchedPairs.mLastSector");
			const Short_t			*&mMatchedPairs_mRecoKey = iter("mMatchedPairs.mRecoKey");
			//const Short_t             *&mMatchedPairs_mFitPts = iter("mMatchedPairs.mFitPts");
//			const Short_t             *&mMatchedPairs_mFitSvt = iter("mMatchedPairs.mFitSvt");
//			const Short_t             *&mMatchedPairs_mFitSsd = iter("mMatchedPairs.mFitSsd");
//			const Short_t            *&mMatchedPairs_mFitFtpc = iter("mMatchedPairs.mFitFtpc");
//			const Short_t            *&mMatchedPairs_mDedxPts = iter("mMatchedPairs.mDedxPts");
//			const Short_t             *&mMatchedPairs_mAllPts = iter("mMatchedPairs.mAllPts");
//			const Short_t             *&mMatchedPairs_mCharge = iter("mMatchedPairs.mCharge");
//			const Short_t           *&mMatchedPairs_mNAssocMc = iter("mMatchedPairs.mNAssocMc");
//			const Short_t          *&mMatchedPairs_mNPossible = iter("mMatchedPairs.mNPossible");
			const Char_t          *&mMatchedPairs_mIsValidPr = iter("mMatchedPairs.mIsValidPr");
			
			Bool_t K;
			Bool_t Pi;
			Bool_t KPi;
			
			while (iter.Next()){
				Int_t k;
				K = 0;
				Pi = 0;
				KPi = 0;
				Float_t StopRDMc = -777;
				Float_t PtDMc = -777;
				Float_t PxDMc = -777;
				Float_t PyDMc = -777;
				Float_t PzDMc = -777;
				Float_t EtaDMc = -777;
				Float_t PhiDMc = -777;
				Int_t EventIdK = -777;
				Int_t EventIdPi = 777;
				Int_t RunIdK = -777;
				Int_t RunIdPi = -777;
				Int_t GeantK = -777;
				Int_t ParentK = -777;
				Int_t KeyK = -777;
				Float_t StopRK = -777;
				Int_t RecoKeyK = -777;
				Float_t PtKPr = -777;
				Float_t PxKPr = -777;
				Float_t PyKPr = -777;
				Float_t PzKPr = -777;
				Float_t EtaKPr = -777;
				Float_t PhiKPr = -777;
				Float_t DCAKPr = -777;
				Float_t DCAxyKPr = -777;
				Float_t DCAzKPr = -777;
				Float_t PtKGl = -777;
				Float_t PxKGl = -777;
				Float_t PyKGl = -777;
				Float_t PzKGl = -777;
				Float_t EtaKGl = -777;
				Float_t PhiKGl = -777;
				Float_t DCAKGl = -777;
				Float_t DCAxyKGl = -777;
				Float_t DCAzKGl = -777;
				Int_t GeantPi = -777;
				Int_t ParentPi = -777;
				Int_t KeyPi = -777;
				Float_t StopRPi = -777;
				Int_t RecoKeyPi = -777;
				Float_t PtPiPr = -777;
				Float_t PxPiPr = -777;
				Float_t PyPiPr = -777;
				Float_t PzPiPr = -777;
				Float_t EtaPiPr = -777;
				Float_t PhiPiPr = -777;
				Float_t DCAPiPr = -777;
				Float_t DCAxyPiPr = -777;
				Float_t DCAzPiPr = -777;
				Float_t PtPiGl = -777;
				Float_t PxPiGl = -777;
				Float_t PyPiGl = -777;
				Float_t PzPiGl = -777;
				Float_t EtaPiGl = -777;
				Float_t PhiPiGl = -777;
				Float_t DCAPiGl = -777;
				Float_t DCAxyPiGl = -777;
				Float_t DCAzPiGl = -777;
				
				//if(NumFiles > 5) break;
				//cout << "VertexX = " << mVertexX << " VertexY = " << mVertexY << " VertexZ = " << mVertexZ << " Event Id = " << mEventId << endl;
				
				if(mMatchedPairs_ >= 2){
					cout << "mEventId = " << mEventId << " mMatchedPairs_ = " << mMatchedPairs_ << endl;
					for (Int_t j = 0; j < mMatchedPairs_; j++){

						/*if(mEventId == 41){
							//cout << "mMatchedPairs_ = " << mMatchedPairs_ << endl;
							if(mMatchedPairs_mGeantId[j] == 12 
							&& mMatchedPairs_mParentGeantId[j] == 37){
								cout << "PtKPr = " << mMatchedPairs_mPtPr[j] << " PzKPr = " << mMatchedPairs_mPzPr[j] << endl << endl;
							}
							
							if(mMatchedPairs_mGeantId[j] == 8 
							&& mMatchedPairs_mParentGeantId[j] == 37){
								cout << "PtPiPr = " << mMatchedPairs_mPtPr[j] << " PzPiPr = " << mMatchedPairs_mPzPr[j] << endl << endl;
							}
						}*/
					
						//cout << "GeantId = " << mMatchedPairs_mGeantId[j] << endl;
						//cout << "mFlag = " << mMatchedPairs_mFlag[j] << endl;
			
						if (mMatchedPairs_mGeantId[j] == 12 
						 && mMatchedPairs_mParentGeantId[j] == 37
						 && mMatchedPairs_mPtPr[j] != 0.0
						 && mMatchedPairs_mPzPr[j] != 0.0
						 /*&& mMatchedPairs_mFlag > 0*/){
							NumKm++;
							EventIdK = mEventId;
							RunIdK = mRunId;
							GeantK = mMatchedPairs_mGeantId[j];
							ParentK = mMatchedPairs_mParentKey[j];
							KeyK = mMatchedPairs_mKey[j];
							StopRK = mMatchedPairs_mStopR[j];
							RecoKeyK = mMatchedPairs_mRecoKey[j];
							
							PtKPr = mMatchedPairs_mPtPr[j];
							PtKGl = mMatchedPairs_mPtGl[j];
							PzKPr = mMatchedPairs_mPzPr[j];
							PzKGl = mMatchedPairs_mPzGl[j];
							EtaKPr = mMatchedPairs_mEtaPr[j];
							EtaKGl = mMatchedPairs_mEtaGl[j];
							PhiKPr = mMatchedPairs_mPhiPr[j];
							PhiKGl = mMatchedPairs_mPhiGl[j];
							PxKPr = PtKPr*TMath::Cos(PhiKPr);
							PxKGl = PtKGl*TMath::Cos(PhiKGl);
							PyKPr = PtKPr*TMath::Sin(PhiKPr);
							PyKGl = PtKGl*TMath::Sin(PhiKGl);
							DCAKPr = mMatchedPairs_mDcaPr[j];
							DCAKGl = mMatchedPairs_mDcaGl[j];
							DCAxyKPr = mMatchedPairs_mDcaXYPr[j];
							DCAxyKGl = mMatchedPairs_mDcaXYGl[j];
							DCAzKPr = mMatchedPairs_mDcaZPr[j];
							DCAzKGl = mMatchedPairs_mDcaZGl[j];
			
							K = 1;
						}
						if (mMatchedPairs_mGeantId[j] == 8
						 && mMatchedPairs_mParentGeantId[j] == 37
						 && mMatchedPairs_mPtPr[j] != 0.0
						 && mMatchedPairs_mPzPr[j] != 0.0
						 /*&& mMatchedPairs_mFlag > 0*/){
							NumPip++;
							EventIdPi = mEventId;
							RunIdPi = mRunId;
							GeantPi = mMatchedPairs_mGeantId[j];
							ParentPi = mMatchedPairs_mParentKey[j];
							KeyPi = mMatchedPairs_mKey[j];
							StopRPi = mMatchedPairs_mStopR[j];
							RecoKeyPi = mMatchedPairs_mRecoKey[j];
		
							PtPiPr = mMatchedPairs_mPtPr[j];
							PtPiGl = mMatchedPairs_mPtGl[j];
							PzPiPr = mMatchedPairs_mPzPr[j];
							PzPiGl = mMatchedPairs_mPzGl[j];
							EtaPiPr = mMatchedPairs_mEtaPr[j];
							EtaPiGl = mMatchedPairs_mEtaGl[j];
							PhiPiPr = mMatchedPairs_mPhiPr[j];
							PhiPiGl = mMatchedPairs_mPhiGl[j];
							PxPiPr = PtPiPr*TMath::Cos(PhiPiPr);
							PxPiGl = PtPiGl*TMath::Cos(PhiPiGl);
							PyPiPr = PtPiPr*TMath::Sin(PhiPiPr);
							PyPiGl = PtPiGl*TMath::Sin(PhiPiGl);
							DCAPiPr = mMatchedPairs_mDcaPr[j];
							DCAPiGl = mMatchedPairs_mDcaGl[j];
							DCAxyPiPr = mMatchedPairs_mDcaXYPr[j];
							DCAxyPiGl = mMatchedPairs_mDcaXYGl[j];
							DCAzPiPr = mMatchedPairs_mDcaZPr[j];
							DCAzPiGl = mMatchedPairs_mDcaZGl[j];
					
							Pi = 1;
						}
						if(EventIdK == EventIdPi && RunIdK == RunIdPi && EventIdK >= 0 && EventIdPi >= 0 && ParentK == ParentPi){
							if(K && Pi) KPi = 1;
						}
						
						if (KPi){
							NumD0++;
							cout << "VertexX = " << mVertexX << " VertexY = " << mVertexY << " VertexZ = " << mVertexZ << " Event Id = " << mEventId << endl;
							cout << "EventId = " << mEventId << ", RunId = " << mRunId << endl;
							cout << "GeantId = " << GeantK << ", ParentKey = " << ParentK << ", Key = " << KeyK << endl;
							cout << "StopR = " << StopRK << endl;
							cout << "RecoKey K = " << RecoKeyK << endl << endl;
			
							cout << "EventId = " << mEventId << ", RunId = " << mRunId << endl;
							cout << "GeantId = " << GeantPi << ", ParentKey = " << ParentPi << ", Key = " << KeyPi << endl;
							cout << "StopR = " << StopRPi << endl;
							cout << "RecoKey K = " << RecoKeyPi << endl << endl;
								
							cout << "*******	Found good D0, so far there are " << NumD0 << " D0s" << endl;
							cout << "So far there are " << NumD0Daughters << " D0 daughters found " << NumKm << " are K- and " << NumPip << " are Pi+" << endl;
							cout << "EventId = " << mEventId << ", RunId = " << mRunId << endl << endl << endl;
							
							StopRDMc = mMcTracks_mStopR[ParentK];
							PtDMc = mMcTracks_mPtMc[ParentK];
							PzDMc = mMcTracks_mPzMc[ParentK];
							PhiDMc = mMcTracks_mPhiMc[ParentK];
							EtaDMc = mMcTracks_mEtaMc[ParentK];
							PxDMc = PtDMc*TMath::Cos(PhiDMc);
							PyDMc = PtDMc*TMath::Sin(PhiDMc);
							
							fprintf(miniMcKeys,"%i \t %i \t %i \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %i \t %.3f \t %i \t %i \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3e \t %.3e \t %.3e \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3e \t %.3e \t %.3e \t %i \t %.3f \t %.i \t %.i \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3f \t %.3e \t %.3e \t %.3e \t %.3f \t %.3f \t %.3f \t %.3f\t %.3f \t %.3f \t %.3e \t %.3e \t %.3e \t \n",
									fileIdIntMiniMc,mEventId,mRunId,mVertexX,mVertexY,mVertexZ,
											StopRDMc,PtDMc,PxDMc,PyDMc,PzDMc,EtaDMc,PhiDMc,
									GeantK,StopRK,KeyK,RecoKeyK,PtKPr,PxKPr,PyKPr,PzKPr,EtaKPr,PhiKPr,DCAKPr,DCAxyKPr,DCAzKPr,
											PtKGl,PxKGl,PyKGl,PzKGl,EtaKGl,PhiKGl,DCAKGl,DCAxyKGl,DCAzKGl,
									GeantPi,StopRPi,KeyPi,RecoKeyPi,PtPiPr,PxPiPr,PyPiPr,PzPiPr,EtaPiPr,PhiPiPr,DCAPiPr,DCAxyPiPr,DCAzPiPr,
											PtPiGl,PxPiGl,PyPiGl,PzPiGl,EtaPiGl,PhiPiGl,DCAPiGl,DCAxyPiGl,DCAzPiGl);
							
							K = 0;
							Pi = 0;
							KPi = 0;
						}
					}
					cout << endl << endl;
					//if (mEventId > 20) break;
		
				}
			}
		}
	}
	fclose(miniMcKeys);
	cout << "***** miniMcKeys.txt written *****" << endl;
	inFile.close();
}