// -------------------------------------------------------------------------
// -----                 PndAnaLambdaLambdaBar source file             -----
// -----                  Created 18/07/08  by S.Esch              -----
// -------------------------------------------------------------------------
// libc includes
#include <iostream>

// Root includes
#include "TROOT.h"
#include "TClonesArray.h"
#include "TVector3.h"
#include "TLorentzVector.h"

// framework includes
#include "FairRootManager.h"
#include "FairRun.h"
#include "FairRuntimeDb.h"
#include "FairHit.h"
#include "FairMultiLinkedData.h"
#include "FairEventHeader.h"
#include "PndAnaLambdaLambdaBar.h"

#include "PndSdsMCPoint.h"
#include "PndSdsHit.h"
#include "PndGemHit.h"
#include "PndSttHit.h"
#include "PndMCEntry.h"
#include "PndMCTrack.h"
#include "PndGemMCPoint.h"
#include "PndTrackCand.h"

#include "PndDetectorList.h"
#include <iomanip>

// -----   Default constructor   -------------------------------------------
PndAnaLambdaLambdaBar::PndAnaLambdaLambdaBar()
	: FairTask("Creates PndMC test"),fInputBranchName(" "),fInputBranchNamePreFit(" "), fInputBranchNamePostFit(" "),fPreFitCalculations(kTRUE),fPostFitCalculations(kTRUE), fNumberOfMVDHits(3), fNumberOfTotalHits(9)
{
}
// -------------------------------------------------------------------------

// -----   Destructor   ----------------------------------------------------
PndAnaLambdaLambdaBar::~PndAnaLambdaLambdaBar()
{
}

// -----   Public method Init   --------------------------------------------
InitStatus PndAnaLambdaLambdaBar::Init()
{
	eventcounter=0;

  FairRootManager* ioman = FairRootManager::Instance();
  	if (!ioman) {
  		std::cout << "-E- PndAnaLambdaLambdaBar::Init: "
  				<< "RootManager not instantiated!" << std::endl;
  		return kFATAL;
  	}

  	fMCMatch 					= 	(PndMCMatch*)ioman->GetObject("MCMatch");
    if ( ! fMCMatch ) {
      std::cout << "-W-  PndAnaLambdaLambdaBar::Init: No MCMatch array! Needed for MC Truth" << std::endl;
      return kERROR;
    }

  	fEventHeader 				= 	(TClonesArray*)ioman->GetObject("EventHeader.");
    if ( ! fEventHeader  ) {
      std::cout << "-W-  PndAnaLambdaLambdaBar::Init: No EventHeader array! Needed for EventNumber" << std::endl;
      return kERROR;
    }

    if(fInputBranchNamePreFit==" ")
    {
    	std::cout << "-W-  PndAnaLambdaLambdaBar::Init: No InputBranchNamePreFit Set - No prefit analysis." << std::endl;
    	fPreFitCalculations=kFALSE;
    }
    else
    {
    	fTrackPreFit = (TClonesArray*)ioman->GetObject(fInputBranchNamePreFit);
    	if(!fTrackPreFit)
    	{
        	std::cout << "-E-  PndAnaLambdaLambdaBar::Init: No Input Branch PreFit Found! BranchName: "<< fInputBranchNamePreFit << std::endl;
        	return kFATAL;
    	}
    }


    if(fInputBranchNamePostFit== " ")
    {
    	std::cout << "-W-  PndAnaLambdaLambdaBar::Init: No InputBranchNamePostFit Set - No postfit analysis." << std::endl;
    	fPostFitCalculations=kFALSE;
    }
    else
    {
    	fTrackPostFit = (TClonesArray*)ioman->GetObject(fInputBranchNamePostFit);
    	if(!fTrackPostFit)
    	{
        	std::cout << "-E-  PndAnaLambdaLambdaBar::Init: No Input Branch PostFit Found! BranchName: "<< fInputBranchNamePostFit << std::endl;
        	return kFATAL;
    	}
    }

    if(fInputBranchName== " ")
    {
    	std::cout << "-E-  PndAnaLambdaLambdaBar::Init: No InputBranchName Set" << std::endl;
    	return kERROR;
    }
    else
    {
    	fTrack 						=   (TClonesArray*)ioman->GetObject(fInputBranchName);
    	if(!fTrack)
    	{
        	std::cout << "-E-  PndAnaLambdaLambdaBar::Init: No Input Branch Found! BranchName: "<< fInputBranchName << std::endl;
        	return kFATAL;
    	}
    }
  	fStripHit 					= 	(TClonesArray*)ioman->GetObject("MVDHitsStrip");
  	fPixelHit 					= 	(TClonesArray*)ioman->GetObject("MVDHitsPixel");
  	fMCPoint 					= 	(TClonesArray*)ioman->GetObject("MVDPoint");
  	fMCTrack 					= 	(TClonesArray*)ioman->GetObject("MCTrack");
  	fSTTHit 					= 	(TClonesArray*)ioman->GetObject("STTHit");
  	fGEMHit						= 	(TClonesArray*)ioman->GetObject("GEMHit");
  	fGEMPoint					=	(TClonesArray*)ioman->GetObject("GEMPoint");
  	fFTSHit						=	(TClonesArray*)ioman->GetObject("FTSHit");

    fKalmanFitComparisonPosition= new TH2F("fKalmanFitComparisonPosition","fKalmanFitComparisonPosition",250,0,250,250,0,250);
    fKalmanFitComparisonMomentum= new TH2F("fKalmanFitComparisonMomentum","fKalmanFitComparisonMomentum",60,0,6,60,0,6);
    fKalmanFitComparisonPositionPosFlag= new TH2F("fKalmanFitComparisonPositionPosFlag","fKalmanFitComparisonPositionPosFlag",250,0,250,250,0,250);
    fKalmanFitComparisonMomentumPosFlag= new TH2F("fKalmanFitComparisonMomentumPosFlag","fKalmanFitComparisonMomentumPosFlag",60,0,6,60,0,6);

  	fMVDHitsPerTrackProton 		= 	new TH1I("fMVDHitsPerTrackProton_"+fInputBranchName,"# MVD Hits/Track p w/o #Lambda Disc"+fInputBranchName+"; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackAntiproton 	= 	new TH1I("fMVDHitsPerTrackAntiproton_"+fInputBranchName,"# MVD Hits/Track #bar{p} w/o #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackPionplus 	= 	new TH1I("fMVDHitsPerTrackPionplus_"+fInputBranchName,"# MVD Hits/Track #pi^{+} w/o #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackPionminus 	= 	new TH1I("fMVDHitsPerTrackPionminus_"+fInputBranchName,"# MVD Hits/Track #pi^{-} w/o #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackTotal		= 	new TH1I("fMVDHitsPerTrackTotal_"+fInputBranchName,"# MVD Hits/Track all particles w/o #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);

  	fMVDHitsPerTrackProtonWithLambda 		= 	new TH1I("fMVDHitsPerTrackProtonWithLambda_"+fInputBranchName,"# MVD Hits/Track for p w #Lambda Disc; MVD Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackAntiprotonWithLambda 	= 	new TH1I("fMVDHitsPerTrackAntiprotonWithLambda_"+fInputBranchName,"# MVD Hits/Track #bar{p} w #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackPionplusWithLambda 		= 	new TH1I("fMVDHitsPerTrackPionplusWithLambda_"+fInputBranchName,"# MVD Hits/Track #pi^{+} w #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
  	fMVDHitsPerTrackPionminusWithLambda 	= 	new TH1I("fMVDHitsPerTrackPionminusWithLambda_"+fInputBranchName,"# MVD Hits/Track #pi^{-} w #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);
   	fMVDHitsPerTrackTotalWithLambda 		= 	new TH1I("fMVDHitsPerTrackTotalWithLambda_"+fInputBranchName,"# MVD Hits/Track all particles w #Lambda Disc; MVD Reco Hits per Track; # Tracks", 12,-0.5,11.5);

    fSTTHitsPerTrackProton 		= 	new TH1I("fSTTHitsPerTrackProton_"+fInputBranchName,"# STT Hits per Track for p; STT Digi Hits per Track; # Tracks", 45,-0.5,44.5);
    fSTTHitsPerTrackAntiproton 	= 	new TH1I("fSTTHitsPerTrackAntiproton_"+fInputBranchName,"# STT Hits per Track for #bar{p}; STT Digi Hits per Track; # Tracks", 45,-0.5,44.5);
    fSTTHitsPerTrackPionplus 	= 	new TH1I("fSTTHitsPerTrackPionplus_"+fInputBranchName,"# STT Hits per Track for #pi^{+}; STT Digi Hits per Track; # Tracks", 45,-0.5,44.5);
    fSTTHitsPerTrackPionminus 	= 	new TH1I("fSTTHitsPerTrackPionminus_"+fInputBranchName,"# STT Hits per Track for #pi^{-}; STT Digi Hits per Track; # Tracks", 45,-0.5,44.5);
    fSTTHitsPerTrackTotal		=   new TH1I("fSTTHitsPerTrackTotal_"+fInputBranchName,"# STT Hits per Track for all particles; STT Digi Hits per Track; # Tracks", 45,-0.5,44.5);

	fGEMHitsPerTrackProton 		= 	new TH1I("fGEMHitsPerTrackProton_"+fInputBranchName,"# GEM Hits per Track for p; GEM Hits per Track; # Tracks", 25,-0.5,24.5);
	fGEMHitsPerTrackAntiproton 	= 	new TH1I("fGEMHitsPerTrackAntiproton_"+fInputBranchName,"# GEM Hits per Track for #bar{p}; GEM Hits per Track; # Tracks", 25,-0.5,24.5);
	fGEMHitsPerTrackPionplus 	= 	new TH1I("fGEMHitsPerTrackPionplus_"+fInputBranchName,"# GEM Hits per Track for #pi^{+}; GEM Hits per Track; # Tracks", 25,-0.5,24.5);
	fGEMHitsPerTrackPionminus 	= 	new TH1I("fGEMHitsPerTrackPionminus_"+fInputBranchName,"# GEM Hits per Track for #pi^{-}; GEM Hits per Track; # Tracks",25,-0.5,24.5);
	fGEMHitsPerTrackTotal		= 	new TH1I("fGEMHitsPerTrackTotal_"+fInputBranchName,"# GEM Hits per Track for all particles; GEM Hits per Track; # Tracks", 25,-0.5,24.5);

    fTotalHitsPerTrackProton 	= 	new TH1I("fTotalHitsPerTrackProton_"+fInputBranchName,"# Total Hits (MVD+STT+GEM) per Track for p ; Hits per Track; # Tracks", 45,-0.5,44.5);
    fTotalHitsPerTrackAntiproton= 	new TH1I("fTotalHitsPerTrackAntiproton_"+fInputBranchName,"# Total Hits (MVD+STT+GEM) per Track for #bar{p} ; Hits per Track; # Tracks", 45,-0.5,44.5);
    fTotalHitsPerTrackPionplus 	= 	new TH1I("fTotalHitsPerTrackPionplus_"+fInputBranchName,"# Total Hits (MVD+STT+GEM) per Track for #pi^{+} ; Hits per Track; # Tracks", 45,-0.5,44.5);
    fTotalHitsPerTrackPionminus = 	new TH1I("fTotalHitsPerTrackPionminus_"+fInputBranchName,"# Total Hits (MVD+STT+GEM) per Track for #pi^{-} ; Hits per Track; # Tracks", 45,-0.5,44.5);

    fTotalHitsPerTrackAll = new TH1I("fTotalHitsPerTrackAll"+fInputBranchName,"# Total Hits (MVD+STT+GEM) per Track (w/o LD); Hits per Track; # Tracks", 45,-0.5,44.5);

    fTracksPerEventMVD = new TH1I("fTrackPerEventMVD_"+fInputBranchName,"fTracksPerEventMVD; # Tracks/Event; #Events", 6,-0.5,5.5);
    fTracksPerEventMVDWithLambda = new TH1I("fTrackPerEventMVDWithLambda_"+fInputBranchName,"fTracksPerEventMVDWithLambda; # Tracks/Event; #Events", 6,-0.5,5.5);

    fPtResolutionProton 	= new TH1F("fPtResolutionProton_"+fInputBranchName,"Pt Resolution Proton; Pt Track - Pt MC Truth [GeV/c]", 201,-1,1);
    fPtResolutionAntiproton = new TH1F("fPtResolutionAntiproton_"+fInputBranchName,"Pt Resolution Antiproton; Pt Track - Pt MC Truth [GeV/c]", 201,-1,1);
    fPtResolutionPionplus 	= new TH1F("fPtResolutionPionplus_"+fInputBranchName,"Pt Resolution Pionplus; Pt Track - Pt MC Truth [GeV/c]", 201,-1,1);
    fPtResolutionPionminus 	= new TH1F("fPtResolutionPionminus_"+fInputBranchName,"Pt Resolution Pionminus; Pt Track - Pt MC Truth [GeV/c]", 201,-1,1);

    fPzResolutionProton		= new TH1F("fPzResolutionProton_"+fInputBranchName,"Pz Resolution Proton; Pz Track - Pz MC Truth [GeV/c]", 201,-1,1);
    fPzResolutionAntiproton = new TH1F("fPzResolutionAntiproton_"+fInputBranchName,"Pz Resolution Antiproton; Pz Track - Pz MC Truth [GeV/c]", 201,-1,1);
    fPzResolutionPionplus	= new TH1F("fPzResolutionPionplus_"+fInputBranchName,"Pz Resolution Pionplus; Pz Track - Pz MC Truth [GeV/c]", 201,-1,1);
    fPzResolutionPionminus	= new TH1F("fPzResolutionPionminus_"+fInputBranchName,"Pz Resolution Pionminus; Pz Track - Pz MC Truth [GeV/c]", 201,-1,1);

    fPtRelativeResolutionProton 	= new TH1F("fPtRelativeResolutionProton_"+fInputBranchName,"Pt Relative Resolution Proton; (Pt Track - Pt MC Truth)/Pt Track [GeV/c]", 201,-1,1);
    fPtRelativeResolutionAntiproton = new TH1F("fPtRelativeResolutionAntiproton_"+fInputBranchName,"Pt Relative Resolution Antiproton; (Pt Track - Pt MC Truth)/Pt Track [GeV/c]", 201,-1,1);
    fPtRelativeResolutionPionplus 	= new TH1F("fPtRelativeResolutionPionplus_"+fInputBranchName,"Pt Relative Resolution Pionplus; (Pt Track - Pt MC Truth)/Pt Track [GeV/c]", 201,-1,1);
    fPtRelativeResolutionPionminus 	= new TH1F("fPtRelativeResolutionPionminus_"+fInputBranchName,"Pt Relative Resolution Pionminus; (Pt Track - Pt MC Truth)/Pt Track [GeV/c]", 201,-1,1);

    fPzRelativeResolutionProton		= new TH1F("fPzRelativeResolutionProton_"+fInputBranchName,"Pz Relative Resolution Proton; (Pz Track - Pz MC Truth)/Pz Track [GeV/c]", 201,-1,1);
    fPzRelativeResolutionAntiproton = new TH1F("fPzRelativeResolutionAntiproton_"+fInputBranchName,"Pz Relative Resolution Antiproton; (Pz Track - Pz MC Truth)/Pz Track [GeV/c]", 201,-1,1);
    fPzRelativeResolutionPionplus	= new TH1F("fPzRelativeResolutionPionplus_"+fInputBranchName,"Pz Relative Resolution Pionplus; (Pz Track - Pz MC Truth)/Pz Track [GeV/c]", 201,-1,1);
    fPzRelativeResolutionPionminus	= new TH1F("fPzRelativeResolutionPionminus_"+fInputBranchName,"Pz Relative Resolution Pionminus; (Pz Track - Pz MC Truth)/Pz Track [GeV/c]", 201,-1,1);

    fPzResolution2DProton   	= new TH2F("fPzResolution2DProton_"+fInputBranchName,"Pz Resolution 2D Proton; reco Pz Proton [GeV/c] ; MC Truth Pz Proton [GeV/c]",600,0,6,600,0,6);
    fPzResolution2DAntiproton	= new TH2F("fPzResolution2DAntiproton_"+fInputBranchName,"Pz Resolution 2D Antiproton; reco Pz Antiproton [GeV/c] ; MC Truth Pz Antiproton [GeV/c]",600,0,6,600,0,6);
    fPzResolution2DPionminus	= new TH2F("fPzResolution2DPionminus_"+fInputBranchName,"Pz Resolution 2D Pionminus; reco Pz Pionminus [GeV/c] ; MC Truth Pz Pionminus [GeV/c]",600,0,6,600,0,6);
    fPzResolution2DPionplus		= new TH2F("fPzResolution2DPionplus_"+fInputBranchName,"Pz Resolution 2D Pionplus; reco Pz Pionplus [GeV/c] ; MC Truth Pz Pionplus [GeV/c]",600,0,6,600,0,6);

    fPtResolution2DProton   	= new TH2F("fPtResolution2DProton_"+fInputBranchName,"Pt Resolution 2D Proton; reco Pt Proton [GeV/c] ; MC Truth Pt Proton [GeV/c]",100,0,1,100,0,1);
    fPtResolution2DAntiproton	= new TH2F("fPtResolution2DAntiproton_"+fInputBranchName,"Pt Resolution 2D Antiproton; reco Pt Antiproton [GeV/c] ; MC Truth Pt Antiproton [GeV/c]",100,0,1,100,0,1);
    fPtResolution2DPionminus	= new TH2F("fPtResolution2DPionminus_"+fInputBranchName,"Pt Resolution 2D Pionminus; reco Pt Pionminus [GeV/c] ; MC Truth Pt Pionminus [GeV/c]",100,0,1,100,0,1);
    fPtResolution2DPionplus		= new TH2F("fPtResolution2DPionplus_"+fInputBranchName,"Pt Resolution 2D Pionplus; reco Pt Pionplus [GeV/c] ; MC Truth Pt Pionplus [GeV/c]",100,0,1,100,0,1);

    fMVDSTTGEM3DTotal 		= new TH3I("fMVDSTTGEM3DTotal_"+fInputBranchName,"fMVDSTTGEM3DTotal; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DProton 		= new TH3I("fMVDSTTGEM3DProton_"+fInputBranchName,"fMVDSTTGEM3DProton; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DAntiproton 	= new TH3I("fMVDSTTGEM3DAntiproton_"+fInputBranchName,"fMVDSTTGEM3DAntiproton; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DPionplus 	= new TH3I("fMVDSTTGEM3DPionplus_"+fInputBranchName,"fMVDSTTGEM3DPionplus; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DPionminus 	= new TH3I("fMVDSTTGEM3DPionminus_"+fInputBranchName,"fMVDSTTGEM3DPionminus; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);

    fMVDSTTGEM3DTotal_wLambda 		= new TH3I("fMVDSTTGEM3DTotal_wLambda_"+fInputBranchName,"fMVDSTTGEM3DTotal_wLambda; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DProton_wLambda 		= new TH3I("fMVDSTTGEM3DProton_wLambda_"+fInputBranchName,"fMVDSTTGEM3DProton_wLambda; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DAntiproton_wLambda 	= new TH3I("fMVDSTTGEM3DAntiproton_wLambda_"+fInputBranchName,"fMVDSTTGEM3DAntiproton_wLambda; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DPionplus_wLambda 	= new TH3I("fMVDSTTGEM3DPionplus_wLambda_"+fInputBranchName,"fMVDSTTGEM3DPionplus_wLambda; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);
    fMVDSTTGEM3DPionminus_wLambda 	= new TH3I("fMVDSTTGEM3DPionminus_wLambda_"+fInputBranchName,"fMVDSTTGEM3DPionminus_wLambda; # MVD Hits/Track; # STT Hits/Track; # GEM Hits/Track",20,-0.5,19.5,100,-0.5,99.5, 50,-0.5,49.5);

    fPionplusMomentaSTTHits 	= new TH2F("fPionplusMomentaSTTHits_"+fInputBranchName,"Pionplus momenta vs STT Hits; Mag(p) [GeV/c]; # STT Hits/Track",100,0,0.4,100,0,100);
    fPionminusMomentaSTTHits 	= new TH2F("fPionminusMomentaSTTHits_"+fInputBranchName,"Pionminus momenta vs STT Hits; Mag(p) [GeV/c]; # STT Hits/Track",100,0,0.4,100,0,100);

    fNumberOfTracksPerEvent 			= new TH1F("fNumberOfTracksPerEvent_"+fInputBranchName, "Number of Tracks per Event "+fInputBranchName , 6,-0.5,5.5);
    fNumberOfTracksPerEventCutCriteria 	= new TH1F("fNumberOfTracksPerEventCutCriteria_"+fInputBranchName, "Number of Tracks per Event (fullfill CutCriteria) "+fInputBranchName , 6,-0.5,5.5);
    fNumberOfTracksPerEventCutCriteriaWithLambda 	= new TH1F("fNumberOfTracksPerEventCutCriteriaWithLambda_"+fInputBranchName, "Number of Tracks per Event (fullfill CutCriteria with #Lambda) "+fInputBranchName , 6,-0.5,5.5);

    fHitAnalysis 			= new TH2I("fHitAnalysis_"+fInputBranchName,"Hits/Track Analysis",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisProton 		= new TH2I("fHitAnalysisProton_"+fInputBranchName,"Hits/Track Analysis Proton ",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisAntiproton 	= new TH2I("fHitAnalysisAntiproton_"+fInputBranchName,"Hits/Track Analysis Antiproton",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionplus 	= new TH2I("fHitAnalysisPionplus_"+fInputBranchName,"Hits/Track Analysis Pionplus",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionminus 	= new TH2I("fHitAnalysisPionminus_"+fInputBranchName,"Hits/Track Analysis Pionminus",18,-0.5,17.5,90,-0.5,89.5);

    fHitAnalysis_Selected 			= new TH2I("fHitAnalysis_Selection_"+fInputBranchName,"Hits/Track Analysis Selected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisProton_Selected 	= new TH2I("fHitAnalysisProton_Selection_"+fInputBranchName,"Hits/Track Analysis Proton Selected ",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisAntiproton_Selected = new TH2I("fHitAnalysisAntiproton_Selection_"+fInputBranchName,"Hits/Track Analysis Antiproton Selected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionplus_Selected 	= new TH2I("fHitAnalysisPionplus_Selection_"+fInputBranchName,"Hits/Track Analysis Pionplus Selected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionminus_Selected 	= new TH2I("fHitAnalysisPionminus_Selection_"+fInputBranchName,"Hits/Track Analysis Pionminus Selected",18,-0.5,17.5,90,-0.5,89.5);

    fHitAnalysis_Rejected 			= new TH2I("fHitAnalysis_Rejected_"+fInputBranchName,"Hits/Track Analysis Rejected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisProton_Rejected 	= new TH2I("fHitAnalysisProton_Rejected_"+fInputBranchName,"Hits/Track Analysis Proton Rejected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisAntiproton_Rejected = new TH2I("fHitAnalysisAntiproton_Rejected_"+fInputBranchName,"Hits/Track Analysis Antiproton Rejected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionplus_Rejected 	= new TH2I("fHitAnalysisPionplus_Rejected_"+fInputBranchName,"Hits/Track Analysis Pionplus Rejected",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionminus_Rejected 	= new TH2I("fHitAnalysisPionminus_Rejected_"+fInputBranchName,"Hits/Track Analysis Pionminus Rejected",18,-0.5,17.5,90,-0.5,89.5);

    fHitAnalysisTracksPerEvent 			= new TH1I("fHitAnalysisTracksPerEvent_"+fInputBranchName, "Hit Analysis Tracks/Event total", 6, -0.5,5.5);
    fHitAnalysisTracksPerEvent_Selected = new TH1I("fHitAnalysisTracksPerEvent_Selected_"+fInputBranchName, "Hit Analysis Tracks/Event total Selected", 6, -0.5,5.5);

    fHitAnalysisTracksPerEvent2D 			= new TH2I("fHitAnalysisTracksPerEvent2D_"+fInputBranchName, "Hit Analysis Tracks/Event total 2D", 6,-0.5,5.5,16,-0.5,15.5);
    fHitAnalysisTracksPerEvent2D_Selected 	= new TH2I("fHitAnalysisTracksPerEvent2D_Selected_"+fInputBranchName, "Hit Analysis Tracks/Event total 2D", 6,-0.5,5.5,16,-0.5,15.5);

    fHitAnalysis_Lambda 			= new TH2I("fHitAnalysis_Lambda_"+fInputBranchName,"Hits/Track Analysis w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisProton_Lambda 		= new TH2I("fHitAnalysisProton_Lambda_"+fInputBranchName,"Hits/Track Analysis Proton w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisAntiproton_Lambda 	= new TH2I("fHitAnalysisAntiproton_Lambda_"+fInputBranchName,"Hits/Track Analysis Antiproton w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionplus_Lambda 	= new TH2I("fHitAnalysisPionplus_Lambda_"+fInputBranchName,"Hits/Track Analysis Pionplus w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionminus_Lambda 	= new TH2I("fHitAnalysisPionminus_Lambda_"+fInputBranchName,"Hits/Track Analysis Pionminus w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);

    fHitAnalysis_Selected_Lambda 			= new TH2I("fHitAnalysis_Selection_Lambda_"+fInputBranchName,"Hits/Track Analysis Selected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisProton_Selected_Lambda 		= new TH2I("fHitAnalysisProton_Selection_Lambda_"+fInputBranchName,"Hits/Track Analysis Proton Selected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisAntiproton_Selected_Lambda	= new TH2I("fHitAnalysisAntiproton_Selection_Lambda_"+fInputBranchName,"Hits/Track Analysis Antiproton Selected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionplus_Selected_Lambda 	= new TH2I("fHitAnalysisPionplus_Selection_Lambda_"+fInputBranchName,"Hits/Track Analysis Pionplus Selected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionminus_Selected_Lambda 	= new TH2I("fHitAnalysisPionminus_Selection_Lambda_"+fInputBranchName,"Hits/Track Analysis Pionminus Selected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);

    fHitAnalysis_Rejected_Lambda 			= new TH2I("fHitAnalysis_Rejected_Lambda_"+fInputBranchName,"Hits/Track Analysis Rejected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisProton_Rejected_Lambda 		= new TH2I("fHitAnalysisProton_Rejected_Lambda_"+fInputBranchName,"Hits/Track Analysis Proton Rejected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisAntiproton_Rejected_Lambda 	= new TH2I("fHitAnalysisAntiproton_Rejected_Lambda_"+fInputBranchName,"Hits/Track Analysis Antiproton Rejected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionplus_Rejected_Lambda 	= new TH2I("fHitAnalysisPionplus_Rejected_Lambda_"+fInputBranchName,"Hits/Track Analysis Pionplus Rejected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);
    fHitAnalysisPionminus_Rejected_Lambda 	= new TH2I("fHitAnalysisPionminus_Rejected_Lambda_"+fInputBranchName,"Hits/Track Analysis Pionminus Rejected w #Lambda Disk",18,-0.5,17.5,90,-0.5,89.5);

    fHitAnalysisTracksPerEvent_Lambda 			= new TH1I("fHitAnalysisTracksPerEvent_Lambda_"+fInputBranchName, "Hit Analysis Tracks/Event total w #Lambda Disk; Tracks/Event", 6, -0.5,5.5);
    fHitAnalysisTracksPerEvent_Selected_Lambda 	= new TH1I("fHitAnalysisTracksPerEvent_Selected_Lambda_"+fInputBranchName, "Hit Analysis Tracks/Event total Selected w #Lambda Disk; Tracks/Event", 6, -0.5,5.5);

    fHitAnalysisTracksPerEvent2D_Lambda 			= new TH2I("fHitAnalysisTracksPerEvent2D_Lambda_"+fInputBranchName, "Hit Analysis Tracks/Event total 2D w #Lambda Disk; Tracks/Event", 6,-0.5,5.5,16,-0.5,15.5);
    fHitAnalysisTracksPerEvent2D_Selected_Lambda 	= new TH2I("fHitAnalysisTracksPerEvent2D_Selected_Lambda_"+fInputBranchName, "Hit Analysis Tracks/Event total 2D w #Lambda Disk; Tracks/Event ", 6,-0.5,5.5,16,-0.5,15.5);

    std::cout << "-I- PndAnaLambdaLambdaBar::Init: Initialization successfull for branch "<< fInputBranchName << std::endl;

  return kSUCCESS;
}

// -----   Public method Exec   --------------------------------------------
void PndAnaLambdaLambdaBar::Exec(Option_t* opt)
{
	if(fVerbose>0)
	{
		std::cout << "============= Begin PndAnaLambdaLambdaBar::Exec for Event "<< eventcounter << std::endl;
	}

int mvdpixelproton 		= 0;
int mvdpixelantiproton 	= 0;
int mvdpixelpionplus 	= 0;
int mvdpixelpionminus 	= 0;

int mvdstripproton 		= 0;
int mvdstripantiproton 	= 0;
int mvdstrippionplus 	= 0;
int mvdstrippionminus 	= 0;

int mvdstriplambdaproton 		= 0;
int mvdstriplambdaantiproton 	= 0;
int mvdstriplambdapionplus 		= 0;
int mvdstriplambdapionminus 	= 0;

int sttproton        	= 0;
int sttantiproton   	= 0 ;
int sttpionminus    	= 0 ;
int sttpionplus     	= 0 ;

int gemproton 		= 0;
int gemantiproton 	= 0;
int gempionplus 	= 0;
int gempionminus 	= 0;

int trackspereventver1 				= 0;
int trackspereventver2 				= 0;
int trackspereventwithlambdaver1 	= 0;
int trackspereventwithlambdaver2 	= 0;

int ftsproton		= 0;
int ftsantiproton 	= 0;
int ftspionplus		= 0;
int ftspionminus	= 0;

int protontrack=0;
int antiprotontrack=0;
int pionplustrack=0;
int pionminustrack=0;
int protontracklambda=0;
int antiprotontracklambda=0;
int pionplustracklambda=0;
int pionminustracklambda=0;

int mvdprotontrack=0;
int mvdantiprotontrack=0;
int mvdpionplustrack=0;
int mvdpionminustrack=0;
int mvdprotontracklambda=0;
int mvdantiprotontracklambda=0;
int mvdpionplustracklambda=0;
int mvdpionminustracklambda=0;

int minimumamountofhitsmvd=3;

FairRootManager* ioman = FairRootManager::Instance();
PndMCTrack* myTrackVertex;
PndTrackCand* myIdealTrackCand;
PndTrack* myTrack;
PndMCResult myResult = fMCMatch->GetMCInfo(fInputBranchName, "MCTrack");
if(fVerbose>1){myResult.Print();}

fNumberOfTracksPerEvent->GetXaxis()->SetBinLabel(2,"Proton");
fNumberOfTracksPerEvent->GetXaxis()->SetBinLabel(3,"Antiproton");
fNumberOfTracksPerEvent->GetXaxis()->SetBinLabel(4,"Pionplus");
fNumberOfTracksPerEvent->GetXaxis()->SetBinLabel(5,"Pionminus");

	PndTrackCand fTrackCand;
	for(int z=0; z<fTrack->GetEntries();z++)
	{
	if(myResult.GetEntry(z).GetNLinks()>1)
	{
		std::cout << "GetNLinks >1 !!!!!!" << std::endl;
		continue;
	}
	myTrackVertex=(PndMCTrack*)fMCTrack->At(myResult.GetEntry(z).GetLink(0).GetIndex());
	myTrack=(PndTrack*)fTrack->At(z);
	fTrackCand=(PndTrackCand)myTrack->GetTrackCand();
	FairMultiLinkedData GEMlinks = fTrackCand.GetLinksWithType(ioman->GetBranchId("GEMHit"));  // Get all Links to GEM Hits which belong to the IdealTrack
	FairMultiLinkedData MVDStriplinks = fTrackCand.GetLinksWithType(ioman->GetBranchId("MVDHitsStrip"));
	FairTrackParP myFirstParam = myTrack->GetParamFirst();
	TVector3 myMomentum = myFirstParam.GetMomentum();

	if(myTrackVertex->GetPdgCode()==2212 && myTrackVertex->GetMotherID()== -1)
	{
		MVDStripCounter(MVDStriplinks, mvdstripproton, mvdstriplambdaproton);

		gemproton = GEMCounter(GEMlinks);
		mvdpixelproton = fTrackCand.GetNHitsDet(ioman->GetBranchId("MVDHitsPixel"));
		sttproton = fTrackCand.GetNHitsDet(ioman->GetBranchId("STTHit"));
		ftsproton = fTrackCand.GetNHitsDet(ioman->GetBranchId("FTSHit"));

		if(mvdpixelproton!=0 || sttproton!=0 || ftsproton!=0 || gemproton!=0 || mvdstripproton !=0) {protontrack=1;}
		if(mvdpixelproton!=0 || sttproton!=0 || ftsproton!=0 || gemproton!=0 || mvdstripproton !=0 || mvdstriplambdaproton!=0) {protontracklambda=1;}
		if((mvdpixelproton+mvdstripproton)>=minimumamountofhitsmvd) {mvdprotontrack=1;}
		if((mvdpixelproton+mvdstripproton+mvdstriplambdaproton)>=minimumamountofhitsmvd) {mvdprotontracklambda=1;}

		fNumberOfTracksPerEvent->Fill(1);
		if(CutCriteria(ftsproton,sttproton,gemproton,mvdpixelproton+mvdstripproton))
		{
			fPtResolutionProton->Fill(myMomentum.Pt()-myTrackVertex->GetMomentum().Pt());
			fPzResolutionProton->Fill(myMomentum.Pz()-myTrackVertex->GetMomentum().Pz());
			fPtRelativeResolutionProton->Fill((myMomentum.Pt()-myTrackVertex->GetMomentum().Pt())/myMomentum.Pt());
			fPzRelativeResolutionProton->Fill((myMomentum.Pz()-myTrackVertex->GetMomentum().Pz())/myMomentum.Pz());
			fPzResolution2DProton->Fill(myMomentum.Pz(),myTrackVertex->GetMomentum().Pz());
			fPtResolution2DProton->Fill(myMomentum.Pt(),myTrackVertex->GetMomentum().Pt());
			fNumberOfTracksPerEventCutCriteria->Fill(1);
		}
		if(CutCriteria(ftsproton,sttproton,gemproton,mvdpixelproton+mvdstripproton+mvdstriplambdaproton))
		{
			fNumberOfTracksPerEventCutCriteriaWithLambda->Fill(1);
		}

	}
	else if(myTrackVertex->GetPdgCode()==-2212 && myTrackVertex->GetMotherID()== -1)
	{
		mvdpixelantiproton = fTrackCand.GetNHitsDet(ioman->GetBranchId("MVDHitsPixel"));
		sttantiproton = fTrackCand.GetNHitsDet(ioman->GetBranchId("STTHit")) ;
		gemantiproton = GEMCounter(GEMlinks);
		ftsantiproton = fTrackCand.GetNHitsDet(ioman->GetBranchId("FTSHit"));

		MVDStripCounter(MVDStriplinks, mvdstripantiproton, mvdstriplambdaantiproton);

		if((mvdpixelantiproton+mvdstripantiproton)>=minimumamountofhitsmvd) {mvdantiprotontrack=1;}
		if((mvdpixelantiproton+mvdstripantiproton+mvdstripantiproton)>=minimumamountofhitsmvd) {mvdantiprotontracklambda=1;}
		if(mvdpixelantiproton!=0 || sttantiproton!=0 || gemantiproton!=0 || ftsantiproton!=0 || mvdstripantiproton !=0) {antiprotontrack=1;}
		if(mvdpixelantiproton!=0 || sttantiproton!=0 || gemantiproton!=0 || ftsantiproton!=0 || mvdstripantiproton !=0 || mvdstriplambdaantiproton!=0) {antiprotontracklambda=1;}

		fNumberOfTracksPerEvent->Fill(2);
		if(CutCriteria(ftsantiproton,sttantiproton,gemantiproton,mvdpixelantiproton+mvdstripantiproton))
				{
				fPtResolutionAntiproton->Fill(myMomentum.Pt()-myTrackVertex->GetMomentum().Pt());
				fPzResolutionAntiproton->Fill(myMomentum.Pz()-myTrackVertex->GetMomentum().Pz());
				fPtRelativeResolutionAntiproton->Fill((myMomentum.Pt()-myTrackVertex->GetMomentum().Pt()/myMomentum.Pt()));
				fPzRelativeResolutionAntiproton->Fill((myMomentum.Pz()-myTrackVertex->GetMomentum().Pz()/myMomentum.Pz()));
			    fPzResolution2DAntiproton->Fill(myMomentum.Pz(),myTrackVertex->GetMomentum().Pz());
			    fPtResolution2DAntiproton->Fill(myMomentum.Pt(),myTrackVertex->GetMomentum().Pt());
				fNumberOfTracksPerEventCutCriteria->Fill(2);
				}
		if(CutCriteria(ftsantiproton,sttantiproton,gemantiproton,mvdpixelantiproton+mvdstripantiproton+mvdstriplambdaantiproton))
				{
				fNumberOfTracksPerEventCutCriteriaWithLambda->Fill(2);
				}

	}
	else if(myTrackVertex->GetPdgCode()==211 && myTrackVertex->GetMotherID()== -1)
	{
		mvdpixelpionplus = fTrackCand.GetNHitsDet(ioman->GetBranchId("MVDHitsPixel")) ;
		sttpionplus = fTrackCand.GetNHitsDet(ioman->GetBranchId("STTHit"));
		ftspionplus = fTrackCand.GetNHitsDet(ioman->GetBranchId("FTSHit"));
		MVDStripCounter(MVDStriplinks, mvdstrippionplus, mvdstriplambdapionplus);
		gempionplus = GEMCounter(GEMlinks);

		if(mvdpixelpionplus!=0 || sttpionplus!=0 || gempionplus!=0 || ftspionplus!=0 || mvdstrippionplus !=0) {pionplustrack=1;}
		if(mvdpixelpionplus!=0 || sttpionplus!=0 || gempionplus!=0 || ftspionplus!=0 || mvdstrippionplus !=0 || mvdstriplambdapionplus!=0) {pionplustracklambda=1;}
		if((mvdpixelpionplus+mvdstrippionplus)>=minimumamountofhitsmvd) {mvdpionplustrack=1;}
		if((mvdpixelpionplus+mvdstrippionplus+mvdstriplambdapionplus)>=minimumamountofhitsmvd) {mvdpionplustracklambda=1;}

		fNumberOfTracksPerEvent->Fill(3);
		if(CutCriteria(ftspionplus,sttpionplus,gempionplus,mvdpixelpionplus+mvdstrippionplus))
		{
			fPtResolutionPionplus->Fill(myMomentum.Pt()-myTrackVertex->GetMomentum().Pt());
			fPzResolutionPionplus->Fill(myMomentum.Pz()-myTrackVertex->GetMomentum().Pz());
			fPtRelativeResolutionPionplus->Fill((myMomentum.Pt()-myTrackVertex->GetMomentum().Pt())/myMomentum.Pt());
			fPzRelativeResolutionPionplus->Fill((myMomentum.Pz()-myTrackVertex->GetMomentum().Pz())/myMomentum.Pz());
			fPzResolution2DPionplus->Fill(myMomentum.Pz(),myTrackVertex->GetMomentum().Pz());
			fPtResolution2DPionplus->Fill(myMomentum.Pt(),myTrackVertex->GetMomentum().Pt());
			fNumberOfTracksPerEventCutCriteria->Fill(3);
		}
		if(CutCriteria(ftspionplus,sttpionplus,gempionplus,mvdpixelpionplus+mvdstrippionplus+mvdstriplambdapionplus))
		{
			fNumberOfTracksPerEventCutCriteriaWithLambda->Fill(3);
		}
	}
	else if(myTrackVertex->GetPdgCode()==-211 && myTrackVertex->GetMotherID()== -1)
	{
		mvdpixelpionminus = fTrackCand.GetNHitsDet(ioman->GetBranchId("MVDHitsPixel"));
		sttpionminus = fTrackCand.GetNHitsDet(ioman->GetBranchId("STTHit"));
		gempionminus = GEMCounter(GEMlinks);
		ftspionminus = fTrackCand.GetNHitsDet(ioman->GetBranchId("FTSHit"));

		MVDStripCounter(MVDStriplinks, mvdstrippionminus, mvdstriplambdapionminus);

		if(mvdpixelpionminus!=0 || sttpionminus!=0 || gempionminus!=0 || ftspionminus!=0 || mvdstrippionminus !=0) {pionminustrack=1;}
		if(mvdpixelpionminus!=0 || sttpionminus!=0 || gempionminus!=0 || ftspionminus!=0 || mvdstrippionminus !=0 || mvdstriplambdapionminus!=0) {pionminustracklambda=1;}
		if((mvdpixelpionminus+mvdstrippionminus)>=minimumamountofhitsmvd) {mvdpionminustrack=1;}
		if((mvdpixelpionminus+mvdstrippionminus+mvdstriplambdapionminus)>=minimumamountofhitsmvd) {mvdpionminustracklambda=1;}

		fNumberOfTracksPerEvent->Fill(4);
		if(CutCriteria(ftspionminus,sttpionminus,gempionminus,mvdpixelpionminus+mvdstrippionminus))
		{
			fPtResolutionPionminus->Fill(myMomentum.Pt()-myTrackVertex->GetMomentum().Pt());
			fPzResolutionPionminus->Fill(myMomentum.Pz()-myTrackVertex->GetMomentum().Pz());
			fPtRelativeResolutionPionminus->Fill((myMomentum.Pt()-myTrackVertex->GetMomentum().Pt())/myMomentum.Pt());
			fPzRelativeResolutionPionminus->Fill((myMomentum.Pz()-myTrackVertex->GetMomentum().Pz())/myMomentum.Pz());
			fPzResolution2DPionminus->Fill(myMomentum.Pz(),myTrackVertex->GetMomentum().Pz());
			fPtResolution2DPionminus->Fill(myMomentum.Pt(),myTrackVertex->GetMomentum().Pt());
			fNumberOfTracksPerEventCutCriteria->Fill(4);
		}
		if(CutCriteria(ftspionminus,sttpionminus,gempionminus,mvdpixelpionminus+mvdstrippionminus+mvdstriplambdapionminus))
		{
			fNumberOfTracksPerEventCutCriteriaWithLambda->Fill(4);
		}
	}

	}


	std::cout <<"protontracklambda "		<< protontracklambda 		<<  " mvdpixelproton " 		<< mvdpixelproton 		<< "mvdstriplambdaproton "<< mvdstriplambdaproton << " mvdstripproton " << mvdstripproton << " sttproton " << sttproton << " ftsproton " << ftsproton << " gemproton " << gemproton << std::endl;
	std::cout <<"antiprotontracklambda "	<< antiprotontracklambda 	<<  " mvdpixelantiproton " 	<< mvdpixelantiproton 	<< "mvdstriplambdaantiproton "<< mvdstriplambdaantiproton<<" mvdstripantiproton " << mvdstripantiproton << " sttantiproton " << sttantiproton << " ftsantiproton " << ftsantiproton << " gemantiproton " << gemantiproton << std::endl;
	std::cout <<"pionplustracklambda "	<< pionplustracklambda 	<<  " mvdpixelpionplus " 	<< mvdpixelpionplus 	<< "mvdstriplambdapionplus "<< mvdstriplambdapionplus<<" mvdstrippionplus " << mvdstrippionplus << " sttpionplus " << sttpionplus << " ftspionplus " << ftspionplus << " gempionplus " << gempionplus << std::endl;
	std::cout <<"pionminustracklambda "	<< pionminustracklambda	<<  " mvdpixelpionminus " 	<< mvdpixelpionminus 	<< "mvdstriplambdapionminus "<<mvdstriplambdapionminus <<" mvdstrippionminus " << mvdstrippionminus << " sttpionminus " << sttpionminus << " ftspionminus " << ftspionminus << " gempionminus " << gempionminus <<std::endl;

SetHitAnalysisAxis(fHitAnalysis);
SetHitAnalysisAxis(fHitAnalysisProton);
SetHitAnalysisAxis(fHitAnalysisAntiproton);
SetHitAnalysisAxis(fHitAnalysisPionminus);
SetHitAnalysisAxis(fHitAnalysisPionplus);

SetHitAnalysisAxis(fHitAnalysis_Selected);
SetHitAnalysisAxis(fHitAnalysisProton_Selected);
SetHitAnalysisAxis(fHitAnalysisAntiproton_Selected);
SetHitAnalysisAxis(fHitAnalysisPionminus_Selected);
SetHitAnalysisAxis(fHitAnalysisPionplus_Selected);

SetHitAnalysisAxis(fHitAnalysis_Rejected);
SetHitAnalysisAxis(fHitAnalysisProton_Rejected);
SetHitAnalysisAxis(fHitAnalysisAntiproton_Rejected);
SetHitAnalysisAxis(fHitAnalysisPionminus_Rejected);
SetHitAnalysisAxis(fHitAnalysisPionplus_Rejected);

SetHitAnalysisEventAxis(fHitAnalysisTracksPerEvent2D);
SetHitAnalysisEventAxis(fHitAnalysisTracksPerEvent2D_Selected);

SetHitAnalysisAxis(fHitAnalysis_Lambda);
SetHitAnalysisAxis(fHitAnalysisProton_Lambda);
SetHitAnalysisAxis(fHitAnalysisAntiproton_Lambda);
SetHitAnalysisAxis(fHitAnalysisPionminus_Lambda);
SetHitAnalysisAxis(fHitAnalysisPionplus_Lambda);

SetHitAnalysisAxis(fHitAnalysis_Selected_Lambda);
SetHitAnalysisAxis(fHitAnalysisProton_Selected_Lambda);
SetHitAnalysisAxis(fHitAnalysisAntiproton_Selected_Lambda);
SetHitAnalysisAxis(fHitAnalysisPionminus_Selected_Lambda);
SetHitAnalysisAxis(fHitAnalysisPionplus_Selected_Lambda);

SetHitAnalysisAxis(fHitAnalysis_Rejected_Lambda);
SetHitAnalysisAxis(fHitAnalysisProton_Rejected_Lambda);
SetHitAnalysisAxis(fHitAnalysisAntiproton_Rejected_Lambda);
SetHitAnalysisAxis(fHitAnalysisPionminus_Rejected_Lambda);
SetHitAnalysisAxis(fHitAnalysisPionplus_Rejected_Lambda);

SetHitAnalysisEventAxis(fHitAnalysisTracksPerEvent2D_Lambda);
SetHitAnalysisEventAxis(fHitAnalysisTracksPerEvent2D_Selected_Lambda);


int protonselectedtrack=0;
int antiprotonselectedtrack=0;
int pionplusselectedtrack=0;
int pionminusselectedtrack=0;

int protonselectedtrack_lambda=0;
int antiprotonselectedtrack_lambda=0;
int pionplusselectedtrack_lambda=0;
int pionminusselectedtrack_lambda=0;

protonselectedtrack 	=protonselectedtrack		+FillAnalysisHistoSingleDetectors(fHitAnalysisProton, 		fHitAnalysis, 	fHitAnalysisProton_Selected, 		fHitAnalysis_Selected,fHitAnalysisProton_Rejected,		fHitAnalysis_Rejected, 	ftsproton, 		sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton);
antiprotonselectedtrack	=antiprotonselectedtrack	+FillAnalysisHistoSingleDetectors(fHitAnalysisAntiproton, 	fHitAnalysis,	fHitAnalysisAntiproton_Selected, 	fHitAnalysis_Selected,fHitAnalysisAntiproton_Rejected,	fHitAnalysis_Rejected,	ftsantiproton, 	sttantiproton, 	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton);
pionminusselectedtrack	=pionminusselectedtrack		+FillAnalysisHistoSingleDetectors(fHitAnalysisPionminus, 	fHitAnalysis,	fHitAnalysisPionminus_Selected, 	fHitAnalysis_Selected,fHitAnalysisPionminus_Rejected,	fHitAnalysis_Rejected,	ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus);
pionplusselectedtrack	=pionplusselectedtrack		+FillAnalysisHistoSingleDetectors(fHitAnalysisPionplus, 	fHitAnalysis,	fHitAnalysisPionplus_Selected, 		fHitAnalysis_Selected,fHitAnalysisPionplus_Rejected,	fHitAnalysis_Rejected,	ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus);

protonselectedtrack 	=protonselectedtrack		+FillAnalysisHistoDoubleDetectors(fHitAnalysisProton, 		fHitAnalysis,	fHitAnalysisProton_Selected, 		fHitAnalysis_Selected,fHitAnalysisProton_Rejected,		fHitAnalysis_Rejected,	ftsproton, 		sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton);
antiprotonselectedtrack	=antiprotonselectedtrack	+FillAnalysisHistoDoubleDetectors(fHitAnalysisAntiproton, 	fHitAnalysis,	fHitAnalysisAntiproton_Selected, 	fHitAnalysis_Selected,fHitAnalysisAntiproton_Rejected,	fHitAnalysis_Rejected,	ftsantiproton, 	sttantiproton, 	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton);
pionminusselectedtrack	=pionminusselectedtrack		+FillAnalysisHistoDoubleDetectors(fHitAnalysisPionminus, 	fHitAnalysis,	fHitAnalysisPionminus_Selected, 	fHitAnalysis_Selected,fHitAnalysisPionminus_Rejected,	fHitAnalysis_Rejected,	ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus);
pionplusselectedtrack	=pionplusselectedtrack		+FillAnalysisHistoDoubleDetectors(fHitAnalysisPionplus, 	fHitAnalysis,	fHitAnalysisPionplus_Selected, 		fHitAnalysis_Selected,fHitAnalysisPionplus_Rejected,	fHitAnalysis_Rejected,	ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus);

protonselectedtrack 	=protonselectedtrack		+FillAnalysisHistoTripleDetectors(fHitAnalysisProton, 		fHitAnalysis,	fHitAnalysisProton_Selected, 		fHitAnalysis_Selected,fHitAnalysisProton_Rejected,		fHitAnalysis_Rejected,	ftsproton, 		sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton);
antiprotonselectedtrack	=antiprotonselectedtrack	+FillAnalysisHistoTripleDetectors(fHitAnalysisAntiproton, 	fHitAnalysis,	fHitAnalysisAntiproton_Selected, 	fHitAnalysis_Selected,fHitAnalysisAntiproton_Rejected,	fHitAnalysis_Rejected,	ftsantiproton, 	sttantiproton, 	gemantiproton,	mvdpixelantiproton	+mvdstripantiproton);
pionminusselectedtrack	=pionminusselectedtrack		+FillAnalysisHistoTripleDetectors(fHitAnalysisPionminus, 	fHitAnalysis,	fHitAnalysisPionminus_Selected, 	fHitAnalysis_Selected,fHitAnalysisPionminus_Rejected,	fHitAnalysis_Rejected,	ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus);
pionplusselectedtrack	=pionplusselectedtrack		+FillAnalysisHistoTripleDetectors(fHitAnalysisPionplus, 	fHitAnalysis,	fHitAnalysisPionplus_Selected, 		fHitAnalysis_Selected,fHitAnalysisPionplus_Rejected,	fHitAnalysis_Rejected,	ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus);

protonselectedtrack 	=protonselectedtrack		+FillAnalysisHistoQuatroDetectors(fHitAnalysisProton, 		fHitAnalysis,	fHitAnalysisProton_Selected, 		fHitAnalysis_Selected,fHitAnalysisProton_Rejected,		fHitAnalysis_Rejected,	ftsproton, 		sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton);
antiprotonselectedtrack	=antiprotonselectedtrack	+FillAnalysisHistoQuatroDetectors(fHitAnalysisAntiproton, 	fHitAnalysis,	fHitAnalysisAntiproton_Selected, 	fHitAnalysis_Selected,fHitAnalysisAntiproton_Rejected,	fHitAnalysis_Rejected,	ftsantiproton, 	sttantiproton, 	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton);
pionminusselectedtrack	=pionminusselectedtrack		+FillAnalysisHistoQuatroDetectors(fHitAnalysisPionminus, 	fHitAnalysis,	fHitAnalysisPionminus_Selected, 	fHitAnalysis_Selected,fHitAnalysisPionminus_Rejected,	fHitAnalysis_Rejected,	ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus);
pionplusselectedtrack	=pionplusselectedtrack		+FillAnalysisHistoQuatroDetectors(fHitAnalysisPionplus, 	fHitAnalysis,	fHitAnalysisPionplus_Selected, 		fHitAnalysis_Selected,fHitAnalysisPionplus_Rejected,	fHitAnalysis_Rejected,	ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus);


protonselectedtrack_lambda 		=protonselectedtrack_lambda			+FillAnalysisHistoSingleDetectors(fHitAnalysisProton_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisProton_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisProton_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftsproton, 	sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton		+mvdstriplambdaproton);
antiprotonselectedtrack_lambda	=antiprotonselectedtrack_lambda		+FillAnalysisHistoSingleDetectors(fHitAnalysisAntiproton_Lambda,fHitAnalysis_Lambda,fHitAnalysisAntiproton_Selected_Lambda, fHitAnalysis_Selected_Lambda,fHitAnalysisAntiproton_Rejected_Lambda,fHitAnalysis_Rejected_Lambda,ftsantiproton, sttantiproton,	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton	+mvdstriplambdaantiproton);
pionminusselectedtrack_lambda	=pionminusselectedtrack_lambda		+FillAnalysisHistoSingleDetectors(fHitAnalysisPionminus_Lambda, fHitAnalysis_Lambda,fHitAnalysisPionminus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionminus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionminus,	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus	+mvdstriplambdapionminus);
pionplusselectedtrack_lambda	=pionplusselectedtrack_lambda		+FillAnalysisHistoSingleDetectors(fHitAnalysisPionplus_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisPionplus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionplus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus	+mvdstriplambdapionplus);

protonselectedtrack_lambda 		=protonselectedtrack_lambda			+FillAnalysisHistoDoubleDetectors(fHitAnalysisProton_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisProton_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisProton_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftsproton, 	sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton		+mvdstriplambdaproton);
antiprotonselectedtrack_lambda	=antiprotonselectedtrack_lambda		+FillAnalysisHistoDoubleDetectors(fHitAnalysisAntiproton_Lambda,fHitAnalysis_Lambda,fHitAnalysisAntiproton_Selected_Lambda, fHitAnalysis_Selected_Lambda,fHitAnalysisAntiproton_Rejected_Lambda,fHitAnalysis_Rejected_Lambda,ftsantiproton, sttantiproton, 	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton	+mvdstriplambdaantiproton);
pionminusselectedtrack_lambda	=pionminusselectedtrack_lambda		+FillAnalysisHistoDoubleDetectors(fHitAnalysisPionminus_Lambda, fHitAnalysis_Lambda,fHitAnalysisPionminus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionminus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus	+mvdstriplambdapionminus);
pionplusselectedtrack_lambda	=pionplusselectedtrack_lambda		+FillAnalysisHistoDoubleDetectors(fHitAnalysisPionplus_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisPionplus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionplus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus	+mvdstriplambdapionplus);

protonselectedtrack_lambda 		=protonselectedtrack_lambda			+FillAnalysisHistoTripleDetectors(fHitAnalysisProton_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisProton_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisProton_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftsproton, 	sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton		+mvdstriplambdaproton);
antiprotonselectedtrack_lambda	=antiprotonselectedtrack_lambda		+FillAnalysisHistoTripleDetectors(fHitAnalysisAntiproton_Lambda,fHitAnalysis_Lambda,fHitAnalysisAntiproton_Selected_Lambda, fHitAnalysis_Selected_Lambda,fHitAnalysisAntiproton_Rejected_Lambda,fHitAnalysis_Rejected_Lambda,ftsantiproton, sttantiproton, 	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton	+mvdstriplambdaantiproton);
pionminusselectedtrack_lambda	=pionminusselectedtrack_lambda		+FillAnalysisHistoTripleDetectors(fHitAnalysisPionminus_Lambda, fHitAnalysis_Lambda,fHitAnalysisPionminus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionminus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus	+mvdstriplambdapionminus);
pionplusselectedtrack_lambda	=pionplusselectedtrack_lambda		+FillAnalysisHistoTripleDetectors(fHitAnalysisPionplus_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisPionplus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionplus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus	+mvdstriplambdapionplus);

protonselectedtrack_lambda 		=protonselectedtrack_lambda			+FillAnalysisHistoQuatroDetectors(fHitAnalysisProton_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisProton_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisProton_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftsproton, 	sttproton, 		gemproton, 		mvdpixelproton		+mvdstripproton		+mvdstriplambdaproton);
antiprotonselectedtrack_lambda	=antiprotonselectedtrack_lambda		+FillAnalysisHistoQuatroDetectors(fHitAnalysisAntiproton_Lambda,fHitAnalysis_Lambda,fHitAnalysisAntiproton_Selected_Lambda, fHitAnalysis_Selected_Lambda,fHitAnalysisAntiproton_Rejected_Lambda,fHitAnalysis_Rejected_Lambda,ftsantiproton, sttantiproton, 	gemantiproton, 	mvdpixelantiproton	+mvdstripantiproton	+mvdstriplambdaantiproton);
pionminusselectedtrack_lambda	=pionminusselectedtrack_lambda		+FillAnalysisHistoQuatroDetectors(fHitAnalysisPionminus_Lambda, fHitAnalysis_Lambda,fHitAnalysisPionminus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionminus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionminus, 	sttpionminus, 	gempionminus, 	mvdpixelpionminus	+mvdstrippionminus	+mvdstriplambdapionminus);
pionplusselectedtrack_lambda	=pionplusselectedtrack_lambda		+FillAnalysisHistoQuatroDetectors(fHitAnalysisPionplus_Lambda, 	fHitAnalysis_Lambda,fHitAnalysisPionplus_Selected_Lambda, 	fHitAnalysis_Selected_Lambda,fHitAnalysisPionplus_Rejected_Lambda,	fHitAnalysis_Rejected_Lambda,ftspionplus, 	sttpionplus, 	gempionplus, 	mvdpixelpionplus	+mvdstrippionplus	+mvdstriplambdapionplus);


FillAnalysisTracksPerEventSingleTrack(protontrack,antiprotontrack, pionminustrack,pionplustrack, fHitAnalysisTracksPerEvent2D); // Histo contains all tracks with have at least 1 hit in MVD/STT/GEM/FTS
FillAnalysisTracksPerEventSingleTrack(protonselectedtrack, antiprotonselectedtrack,pionminusselectedtrack,pionplusselectedtrack,fHitAnalysisTracksPerEvent2D_Selected);

FillAnalysisTracksPerEventSingleTrack(protontracklambda,antiprotontracklambda, pionminustracklambda,pionplustracklambda, fHitAnalysisTracksPerEvent2D_Lambda); // Histo contains all tracks with have at least 1 hit in MVD/STT/GEM/FTS
FillAnalysisTracksPerEventSingleTrack(protonselectedtrack_lambda, antiprotonselectedtrack_lambda,pionminusselectedtrack_lambda,pionplusselectedtrack_lambda,fHitAnalysisTracksPerEvent2D_Selected_Lambda);

fHitAnalysisTracksPerEvent_Lambda->Fill(protontracklambda+antiprotontracklambda+pionplustracklambda+pionminustracklambda);
fHitAnalysisTracksPerEvent_Selected_Lambda->Fill(protonselectedtrack_lambda+antiprotonselectedtrack_lambda+pionminusselectedtrack_lambda+pionplusselectedtrack_lambda);

fHitAnalysisTracksPerEvent->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack);
fHitAnalysisTracksPerEvent_Selected->Fill(protonselectedtrack+antiprotonselectedtrack+pionminusselectedtrack+pionplusselectedtrack);

fMVDSTTGEM3DTotal->Fill(mvdpixelproton+mvdstripproton,sttproton,gemproton);   //MVD -STT- Gem
fMVDSTTGEM3DTotal->Fill(mvdpixelantiproton+mvdstripantiproton,sttantiproton,gemantiproton);
fMVDSTTGEM3DTotal->Fill(mvdpixelpionplus+mvdstrippionplus,sttpionplus,gempionplus);
fMVDSTTGEM3DTotal->Fill(mvdpixelpionminus+mvdstrippionminus,sttpionminus,gempionminus);

fMVDSTTGEM3DProton->Fill(mvdpixelproton+mvdstripproton,sttproton,gemproton);
fMVDSTTGEM3DAntiproton->Fill(mvdpixelantiproton+mvdstripantiproton,sttantiproton,gemantiproton);
fMVDSTTGEM3DPionplus->Fill(mvdpixelpionplus+mvdstrippionplus,sttpionplus,gempionplus);
fMVDSTTGEM3DPionminus->Fill(mvdpixelpionminus+mvdstrippionminus,sttpionminus,gempionminus);

fMVDSTTGEM3DTotal_wLambda->Fill(mvdpixelproton+mvdstripproton+mvdstriplambdaproton,sttproton,gemproton);   //MVD -STT- Gem
fMVDSTTGEM3DTotal_wLambda->Fill(mvdpixelantiproton+mvdstripantiproton+mvdstriplambdaantiproton,sttantiproton,gemantiproton);
fMVDSTTGEM3DTotal_wLambda->Fill(mvdpixelpionplus+mvdstrippionplus+mvdstriplambdapionplus,sttpionplus,gempionplus);
fMVDSTTGEM3DTotal_wLambda->Fill(mvdpixelpionminus+mvdstrippionminus+mvdstriplambdapionminus,sttpionminus,gempionminus);

fMVDSTTGEM3DProton_wLambda->Fill(mvdpixelproton+mvdstripproton+mvdstriplambdaproton,sttproton,gemproton);
fMVDSTTGEM3DAntiproton_wLambda->Fill(mvdpixelantiproton+mvdstripantiproton+mvdstriplambdaantiproton,sttantiproton,gemantiproton);
fMVDSTTGEM3DPionplus_wLambda->Fill(mvdpixelpionplus+mvdstrippionplus+mvdstriplambdapionplus,sttpionplus,gempionplus);
fMVDSTTGEM3DPionminus_wLambda->Fill(mvdpixelpionminus+mvdstrippionminus+mvdstriplambdapionminus,sttpionminus,gempionminus);

fMVDHitsPerTrackAntiproton->Fill(mvdpixelantiproton+mvdstripantiproton);
fSTTHitsPerTrackAntiproton->Fill(sttantiproton);
fGEMHitsPerTrackAntiproton->Fill(gemantiproton);
fTotalHitsPerTrackAntiproton->Fill(mvdpixelantiproton+mvdstripantiproton+sttantiproton+gemantiproton);
fTotalHitsPerTrackAll->Fill(mvdpixelantiproton+mvdstripantiproton+sttantiproton+gemantiproton);

fMVDHitsPerTrackProtonWithLambda->Fill(mvdpixelproton+mvdstripproton+mvdstriplambdaproton);
fMVDHitsPerTrackAntiprotonWithLambda->Fill(mvdpixelantiproton+mvdstripantiproton+mvdstriplambdaantiproton);
fMVDHitsPerTrackPionplusWithLambda->Fill(mvdpixelpionplus+mvdstrippionplus+mvdstriplambdapionplus);
fMVDHitsPerTrackPionminusWithLambda->Fill(mvdpixelpionminus+mvdstrippionminus+mvdstriplambdapionminus);

fMVDHitsPerTrackProton->Fill(mvdpixelproton+mvdstripproton);
fSTTHitsPerTrackProton->Fill(sttproton);
fGEMHitsPerTrackProton->Fill(gemproton);
fTotalHitsPerTrackProton->Fill(mvdpixelproton+mvdstripproton+sttproton+gemproton);
fTotalHitsPerTrackAll->Fill(mvdpixelproton+mvdstripproton+sttproton+gemproton);

fMVDHitsPerTrackPionminus->Fill(mvdpixelpionminus+mvdstrippionminus);
fSTTHitsPerTrackPionminus->Fill(sttpionminus);
fGEMHitsPerTrackPionminus->Fill(gempionminus);
fTotalHitsPerTrackPionminus->Fill(mvdpixelpionminus+mvdstrippionminus+sttpionminus+gempionminus);
fTotalHitsPerTrackAll->Fill(mvdpixelpionminus+mvdstrippionminus+sttpionminus+gempionminus);

fMVDHitsPerTrackPionplus->Fill(mvdpixelpionplus+mvdstrippionplus);
fSTTHitsPerTrackPionplus->Fill(sttpionplus);
fGEMHitsPerTrackPionplus->Fill(gempionplus);
fTotalHitsPerTrackPionplus->Fill(mvdpixelpionplus+mvdstrippionplus+sttpionplus+gempionplus);
fTotalHitsPerTrackAll->Fill(mvdpixelpionplus+mvdstrippionplus+sttpionplus+gempionplus);

fMVDHitsPerTrackTotal->Fill(mvdpixelproton+mvdstripproton);
fMVDHitsPerTrackTotal->Fill(mvdpixelantiproton+mvdstripantiproton);
fMVDHitsPerTrackTotal->Fill(mvdpixelpionminus+mvdstrippionminus);
fMVDHitsPerTrackTotal->Fill(mvdpixelpionplus+mvdstrippionplus);

fGEMHitsPerTrackTotal->Fill(gemproton);
fGEMHitsPerTrackTotal->Fill(gemantiproton);
fGEMHitsPerTrackTotal->Fill(gempionminus);
fGEMHitsPerTrackTotal->Fill(gempionplus);

fSTTHitsPerTrackTotal->Fill(sttantiproton);
fSTTHitsPerTrackTotal->Fill(sttproton);
fSTTHitsPerTrackTotal->Fill(sttpionplus);
fSTTHitsPerTrackTotal->Fill(sttpionminus);

fMVDHitsPerTrackTotalWithLambda->Fill(mvdpixelproton+mvdstripproton+mvdstriplambdaproton);
fMVDHitsPerTrackTotalWithLambda->Fill(mvdpixelantiproton+mvdstripantiproton+mvdstriplambdaantiproton);
fMVDHitsPerTrackTotalWithLambda->Fill(mvdpixelpionplus+mvdstrippionplus+mvdstriplambdapionplus);
fMVDHitsPerTrackTotalWithLambda->Fill(mvdpixelpionminus+mvdstrippionminus+mvdstriplambdapionminus);

fTracksPerEventMVD->Fill(mvdprotontrack+mvdantiprotontrack+mvdpionminustrack+mvdpionplustrack);
fTracksPerEventMVDWithLambda->Fill(mvdprotontracklambda+mvdantiprotontracklambda+mvdpionminustracklambda+mvdpionplustracklambda);

if(fPreFitCalculations&&fPostFitCalculations)
{
	for(int z=0; z< fTrackPostFit->GetEntries(); z++)
	{
		PndTrack* trackpostfit=(PndTrack*)fTrackPostFit->At(z);
		PndTrack* trackprefit= (PndTrack*)fTrackPreFit->At(trackpostfit->GetLink(0).GetIndex());
		fKalmanFitComparisonPosition->Fill(trackprefit->GetParamFirst().GetPosition().Mag(),trackpostfit->GetParamFirst().GetPosition().Mag());
		fKalmanFitComparisonMomentum->Fill(trackprefit->GetParamFirst().GetMomentum().Mag(),trackpostfit->GetParamFirst().GetMomentum().Mag());

//		if()
//		{
//
//		}

		if(trackpostfit->GetFlag()>0)
		{
			fKalmanFitComparisonPositionPosFlag->Fill(trackprefit->GetParamFirst().GetPosition().Mag(),trackpostfit->GetParamFirst().GetPosition().Mag());
			fKalmanFitComparisonMomentumPosFlag->Fill(trackprefit->GetParamFirst().GetMomentum().Mag(),trackpostfit->GetParamFirst().GetMomentum().Mag());
		}

	}
}


	if(fVerbose>0)
	{
		std::cout << "============= End PndAnaLambdaLambdaBar::Exec for Event "<< eventcounter << std::endl;
	}
	eventcounter++;
}

void PndAnaLambdaLambdaBar::Finish()
{

    gDirectory->mkdir(fInputBranchName);
    gDirectory->cd(fInputBranchName);

    gDirectory->mkdir("MVDHitsPerTrack");
    gDirectory->cd("MVDHitsPerTrack");

		fMVDHitsPerTrackProton->Write();
		fMVDHitsPerTrackAntiproton->Write();
		fMVDHitsPerTrackPionplus->Write();
		fMVDHitsPerTrackPionminus->Write();
		fMVDHitsPerTrackTotal->Write();

		fMVDHitsPerTrackProtonWithLambda->Write();
		fMVDHitsPerTrackAntiprotonWithLambda->Write();
		fMVDHitsPerTrackPionplusWithLambda->Write();
		fMVDHitsPerTrackPionminusWithLambda->Write();
		fMVDHitsPerTrackTotalWithLambda->Write();

		gDirectory->cd("../");
		gDirectory->mkdir("STTHitsPerTrack");
		gDirectory->cd("STTHitsPerTrack");

		fSTTHitsPerTrackProton->Write();
		fSTTHitsPerTrackAntiproton->Write();
		fSTTHitsPerTrackPionplus->Write();
		fSTTHitsPerTrackPionminus->Write();
		fSTTHitsPerTrackTotal->Write();

		gDirectory->cd("../");
		gDirectory->mkdir("GEMHitsPerTrack");
		gDirectory->cd("GEMHitsPerTrack");

		fGEMHitsPerTrackProton->Write();
		fGEMHitsPerTrackAntiproton->Write();
		fGEMHitsPerTrackPionplus->Write();
		fGEMHitsPerTrackPionminus->Write();
		fGEMHitsPerTrackTotal->Write();

		gDirectory->cd("../");
		gDirectory->mkdir("TotalHitsPerTrack");
		gDirectory->cd("TotalHitsPerTrack");

		fTotalHitsPerTrackProton->Write();
		fTotalHitsPerTrackAntiproton->Write();
		fTotalHitsPerTrackPionplus->Write();
		fTotalHitsPerTrackPionminus->Write();
	  	fTotalHitsPerTrackAll->Write();

		gDirectory->cd("../");

	  	fTracksPerEventMVD->Write();
	  	fTracksPerEventMVDWithLambda->Write();

	    fMVDSTTGEM3DTotal->Write();
	    fMVDSTTGEM3DProton->Write();
	    fMVDSTTGEM3DAntiproton->Write();
	    fMVDSTTGEM3DPionplus->Write();
	    fMVDSTTGEM3DPionminus->Write();

	    fMVDSTTGEM3DTotal_wLambda->Write();
	    fMVDSTTGEM3DProton_wLambda->Write();
	    fMVDSTTGEM3DAntiproton_wLambda->Write();
	    fMVDSTTGEM3DPionplus_wLambda->Write();
	    fMVDSTTGEM3DPionminus_wLambda->Write();

	    fPionplusMomentaSTTHits->Write();
	    fPionminusMomentaSTTHits->Write();

		//gDirectory->cd("../");
		gDirectory->mkdir("MomentumResolution");
		gDirectory->cd("MomentumResolution");

	  	fPtResolutionProton->Write();
	  	fPtResolutionAntiproton->Write();
	  	fPtResolutionPionplus->Write();
	  	fPtResolutionPionminus->Write();

	  	fPzResolutionProton->Write();
	  	fPzResolutionAntiproton->Write();
	  	fPzResolutionPionplus->Write();
	  	fPzResolutionPionminus->Write();

	  	fPtRelativeResolutionProton->Write();
	  	fPtRelativeResolutionAntiproton->Write();
	  	fPtRelativeResolutionPionplus->Write();
	  	fPtRelativeResolutionPionminus->Write();

	  	fPzRelativeResolutionProton->Write();
	  	fPzRelativeResolutionAntiproton->Write();
	  	fPzRelativeResolutionPionplus->Write();
	  	fPzRelativeResolutionPionminus->Write();

	    fPzResolution2DProton->Write();
	    fPzResolution2DAntiproton->Write();
	    fPzResolution2DPionminus->Write();
	    fPzResolution2DPionplus->Write();

	    fPtResolution2DProton->Write();
	    fPtResolution2DAntiproton->Write();
	    fPtResolution2DPionminus->Write();
		fPtResolution2DPionplus->Write();

		gDirectory->cd("../");

	    fNumberOfTracksPerEvent->Write();
	    fNumberOfTracksPerEventCutCriteria->Write();
	    fNumberOfTracksPerEventCutCriteriaWithLambda->Write();

		//gDirectory->cd("../");
		gDirectory->mkdir("HitAnalysis");
		gDirectory->cd("HitAnalysis");

	    fHitAnalysis->Write();
	    fHitAnalysisProton->Write();
	    fHitAnalysisAntiproton->Write();
	    fHitAnalysisPionplus->Write();
	    fHitAnalysisPionminus->Write();

	    fHitAnalysisAntiproton_Selected->Write();
	    fHitAnalysisProton_Selected->Write();
	    fHitAnalysisPionminus_Selected->Write();
	    fHitAnalysisPionplus_Selected->Write();
	    fHitAnalysis_Selected->Write();

	    fHitAnalysisAntiproton_Rejected->Write();
	    fHitAnalysisProton_Rejected->Write();
	    fHitAnalysisPionminus_Rejected->Write();
	    fHitAnalysisPionplus_Rejected->Write();
	    fHitAnalysis_Rejected->Write();

	    fHitAnalysis_Lambda->Write();
	    fHitAnalysisProton_Lambda->Write();
	    fHitAnalysisAntiproton_Lambda->Write();
	    fHitAnalysisPionplus_Lambda->Write();
	    fHitAnalysisPionminus_Lambda->Write();

	    fHitAnalysisAntiproton_Selected_Lambda->Write();
	    fHitAnalysisProton_Selected_Lambda->Write();
	    fHitAnalysisPionminus_Selected_Lambda->Write();
	    fHitAnalysisPionplus_Selected_Lambda->Write();
	    fHitAnalysis_Selected_Lambda->Write();

	    fHitAnalysisAntiproton_Rejected_Lambda->Write();
	    fHitAnalysisProton_Rejected_Lambda->Write();
	    fHitAnalysisPionminus_Rejected_Lambda->Write();
	    fHitAnalysisPionplus_Rejected_Lambda->Write();
	    fHitAnalysis_Rejected_Lambda->Write();

	    fHitAnalysisTracksPerEvent->Write();
	    fHitAnalysisTracksPerEvent_Selected->Write();

	    fHitAnalysisTracksPerEvent2D->Write();
	    fHitAnalysisTracksPerEvent2D_Selected->Write();

	    fHitAnalysisTracksPerEvent_Lambda->Write();
	    fHitAnalysisTracksPerEvent_Selected_Lambda->Write();

	    fHitAnalysisTracksPerEvent2D_Lambda->Write();
	    fHitAnalysisTracksPerEvent2D_Selected_Lambda->Write();

		gDirectory->cd("../");
		gDirectory->mkdir("Other");
		gDirectory->cd("Other");


	    fKalmanFitComparisonPosition->Write();
	    fKalmanFitComparisonMomentum->Write();
	    fKalmanFitComparisonPositionPosFlag->Write();
	    fKalmanFitComparisonMomentumPosFlag->Write();

	    gDirectory->cd("/");
}

// -------------------------------------------------------------------------
void PndAnaLambdaLambdaBar::SetParContainers()
{
	  fGeoH = PndGeoHandling::Instance();
	  fGeoH->SetParContainers();
}

bool PndAnaLambdaLambdaBar::CutCriteria(int fts, int stt, int gem, int mvd)
{
	if (mvd>fNumberOfMVDHits || fts+stt+gem+mvd >fNumberOfTotalHits)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void PndAnaLambdaLambdaBar::FillAnalysisTracksPerEventSingleTrack(int protontrack, int antiprotontrack, int pionminustrack, int pionplustrack, TH2I* histo)
{
	histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,0);

	if(protontrack==0 && antiprotontrack==1 && pionminustrack==1 && pionplustrack==1 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,1);
	}
	else if(protontrack==1 && antiprotontrack==0 && pionminustrack==1 && pionplustrack==1  )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,2);
	}
	else if(protontrack==1 && antiprotontrack==1 && pionminustrack==0 && pionplustrack==1 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,3);
	}
	else if(protontrack==1 && antiprotontrack==1 && pionminustrack==1 && pionplustrack==0 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,4);
	}

	else if(protontrack==1 && antiprotontrack==1 && pionminustrack==0 && pionplustrack==0 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,5);
	}
	else if(protontrack==1 && antiprotontrack==0 && pionminustrack==1 && pionplustrack==0 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,6);
	}
	else if(protontrack==0 && antiprotontrack==1 && pionminustrack==1 && pionplustrack==0 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,7);
	}
	else if(protontrack==1 && antiprotontrack==0 && pionminustrack==0 && pionplustrack==1 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,8);
	}
	else if(protontrack==0 && antiprotontrack==1 && pionminustrack==0 && pionplustrack==1 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,9);
	}
	else if(protontrack==0 && antiprotontrack==0 && pionminustrack==1 && pionplustrack==1 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,10);
	}

	else if(protontrack==1 && antiprotontrack==0 && pionminustrack==0 && pionplustrack==0 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,11);
	}
	else if(protontrack==0 && antiprotontrack==1 && pionminustrack==0 && pionplustrack==0  )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,12);
	}
	else if(protontrack==0 && antiprotontrack==0 && pionminustrack==1 && pionplustrack==0 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,13);
	}
	else if(protontrack==0 && antiprotontrack==0 && pionminustrack==0 && pionplustrack==1 )
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,14);
	}
	else if(protontrack==0 && antiprotontrack==0 && pionminustrack==0 && pionplustrack==0)
	{
		histo->Fill(protontrack+antiprotontrack+pionplustrack+pionminustrack,15);
	}
}

void PndAnaLambdaLambdaBar::SetHitAnalysisEventAxis(TH1* histo)
{
	histo->GetYaxis()->SetBinLabel(1,"Vertical Sum");
	histo->GetYaxis()->SetBinLabel(2,"p mis.");
	histo->GetYaxis()->SetBinLabel(3,"pbar mis.");
	histo->GetYaxis()->SetBinLabel(4,"#pi- mis.");
	histo->GetYaxis()->SetBinLabel(5,"#pi+ mis.");
	histo->GetYaxis()->SetBinLabel(6,"#pi- #pi+ mis.");
	histo->GetYaxis()->SetBinLabel(7,"pbar #pi+ mis.");
	histo->GetYaxis()->SetBinLabel(8,"p #pi+ mis.");
	histo->GetYaxis()->SetBinLabel(9,"pbar #pi- mis.");
	histo->GetYaxis()->SetBinLabel(10,"p #pi- mis.");
	histo->GetYaxis()->SetBinLabel(11,"p pbar mis.");
	histo->GetYaxis()->SetBinLabel(12,"just p");
	histo->GetYaxis()->SetBinLabel(13,"just antip");
	histo->GetYaxis()->SetBinLabel(14,"just #pi-");
	histo->GetYaxis()->SetBinLabel(15,"just #pi+");
	histo->GetYaxis()->SetBinLabel(16,"no track");
}

void PndAnaLambdaLambdaBar::SetHitAnalysisAxis(TH1* histo)
{
	histo->GetXaxis()->SetBinLabel(3,"MVD");
	histo->GetXaxis()->SetBinLabel(4,"STT");
	histo->GetXaxis()->SetBinLabel(5,"GEM");
	histo->GetXaxis()->SetBinLabel(6,"FTS");
	histo->GetXaxis()->SetBinLabel(7,"MVD+STT");
	histo->GetXaxis()->SetBinLabel(8,"MVD+GEM");
	histo->GetXaxis()->SetBinLabel(9,"MVD+FTS");
	histo->GetXaxis()->SetBinLabel(10,"STT+GEM");
	histo->GetXaxis()->SetBinLabel(11,"STT+FTS");
	histo->GetXaxis()->SetBinLabel(12,"GEM+FTS");
	histo->GetXaxis()->SetBinLabel(13,"MVD+STT+GEM");
	histo->GetXaxis()->SetBinLabel(14,"MVD+STT+FTS");
	histo->GetXaxis()->SetBinLabel(15,"MVD+GEM+FTS");
	histo->GetXaxis()->SetBinLabel(16,"STT+GEM+FTS");
	histo->GetXaxis()->SetBinLabel(17,"all");
}

int PndAnaLambdaLambdaBar::FillAnalysisHistoSingleDetectors(TH2I* SingleParticleHisto, TH2I* TotalHisto, TH2I* SingleParticleSelected, TH2I* TotalSelected, TH2I* SingleParticleRejected, TH2I* TotalRejected, int fts, int stt, int gem, int mvd)
{
//	std::cout << "single " << " stt " << stt << " mvd "  << mvd << " fts " << fts << " gem " << gem;

	if(fts==0 && stt==0 && gem==0 && (mvd)!=0)
	{
		TotalHisto->Fill(2,mvd);
		SingleParticleHisto->Fill(2,mvd);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(2,mvd);
			TotalSelected->Fill(2,mvd);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(2,mvd);
			TotalRejected->Fill(2,mvd);
			return 0;
		}
	}
	else if(fts==0 && stt!=0 && gem==0 && (mvd)==0)
	{
		TotalHisto->Fill(3,stt);
		SingleParticleHisto->Fill(3,stt);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(3,stt);
			TotalSelected->Fill(3,stt);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(3,stt);
			TotalRejected->Fill(3,stt);
			return 0;
		}
	}
	else if(fts==0 && stt==0 && gem!=0 && (mvd)==0)
	{
		TotalHisto->Fill(4,gem);
		SingleParticleHisto->Fill(4,gem);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(4,gem);
			TotalSelected->Fill(4,gem);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(4,gem);
			TotalRejected->Fill(4,gem);
			return 0;
		}
	}
	else if(fts!=0 && stt==0 && gem==0 && (mvd)==0)
	{
		TotalHisto->Fill(5,fts);
		SingleParticleHisto->Fill(5,fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(5,fts);
			TotalSelected->Fill(5,fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(5,fts);
			TotalRejected->Fill(5,fts);
			return 0;
		}
	}

//std::cout << "end" << std::endl;
return 0;

}

int PndAnaLambdaLambdaBar::FillAnalysisHistoDoubleDetectors(TH2I* SingleParticleHisto, TH2I* TotalHisto,  TH2I* SingleParticleSelected, TH2I* TotalSelected, TH2I* SingleParticleRejected, TH2I* TotalRejected,int fts, int stt, int gem, int mvd)
{
	//std::cout << "double " << " stt " << stt << " mvd "  << mvd << " fts " << fts << " gem " << gem;

	if(fts==0 && stt!=0 && gem==0 && (mvd)!=0)
	{
		TotalHisto->Fill(6,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(6,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(6,mvd+stt+gem+fts);
			TotalSelected->Fill(6,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(6,mvd+stt+gem+fts);
			TotalRejected->Fill(6,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts==0 && stt==0 && gem!=0 && (mvd)!=0)
	{
		TotalHisto->Fill(7,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(7,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(7,mvd+stt+gem+fts);
			TotalSelected->Fill(7,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(7,mvd+stt+gem+fts);
			TotalRejected->Fill(7,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts!=0 && stt==0 && gem==0 && (mvd)!=0)
	{
		TotalHisto->Fill(8,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(8,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(8,mvd+stt+gem+fts);
			TotalSelected->Fill(8,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(8,mvd+stt+gem+fts);
			TotalRejected->Fill(8,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts==0 && stt!=0 && gem!=0 && (mvd)==0)
	{
		TotalHisto->Fill(9,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(9,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(9,mvd+stt+gem+fts);
			TotalSelected->Fill(9,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(9,mvd+stt+gem+fts);
			TotalRejected->Fill(9,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts!=0 && stt!=0 && gem==0 && (mvd)==0)
	{
		TotalHisto->Fill(10,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(10,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(10,mvd+stt+gem+fts);
			TotalSelected->Fill(10,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(10,mvd+stt+gem+fts);
			TotalRejected->Fill(10,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts!=0 && stt==0 && gem!=0 && (mvd)==0)
	{
		TotalHisto->Fill(11,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(11,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(11,mvd+stt+gem+fts);
			TotalSelected->Fill(11,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(11,mvd+stt+gem+fts);
			TotalRejected->Fill(11,mvd+stt+gem+fts);
			return 0;
		}
	}
//	std::cout << "end" << std::endl;
	return 0;
}

int PndAnaLambdaLambdaBar::FillAnalysisHistoTripleDetectors(TH2I* SingleParticleHisto, TH2I* TotalHisto, TH2I* SingleParticleSelected, TH2I* TotalSelected, TH2I* SingleParticleRejected, TH2I* TotalRejected, int fts, int stt, int gem, int mvd)
{
//	std::cout << "triple  " << " stt " << stt << " mvd "  << mvd << " fts " << fts << " gem " << gem;

	if(fts==0 && stt!=0 && gem!=0 && (mvd)!=0)
	{
		TotalHisto->Fill(12,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(12,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(12,mvd+stt+gem+fts);
			TotalSelected->Fill(12,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(12,mvd+stt+gem+fts);
			TotalRejected->Fill(12,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts!=0 && stt!=0 && gem==0 && (mvd)!=0)
	{
		TotalHisto->Fill(13,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(13,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(13,mvd+stt+gem+fts);
			TotalSelected->Fill(13,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(13,mvd+stt+gem+fts);
			TotalRejected->Fill(13,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts!=0 && stt==0 && gem!=0 && (mvd)!=0)
	{
		TotalHisto->Fill(14,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(14,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(14,mvd+stt+gem+fts);
			TotalSelected->Fill(14,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(14,mvd+stt+gem+fts);
			TotalRejected->Fill(14,mvd+stt+gem+fts);
			return 0;
		}
	}
	else if(fts!=0 && stt!=0 && gem!=0 && (mvd)==0)
	{
		TotalHisto->Fill(15,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(15,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(15,mvd+stt+gem+fts);
			TotalSelected->Fill(15,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(15,mvd+stt+gem+fts);
			TotalRejected->Fill(15,mvd+stt+gem+fts);
			return 0;
		}
	}
//	std::cout << "end" << std::endl;
	return 0;
}

int PndAnaLambdaLambdaBar::FillAnalysisHistoQuatroDetectors(TH2I* SingleParticleHisto, TH2I* TotalHisto, TH2I* SingleParticleSelected, TH2I* TotalSelected, TH2I* SingleParticleRejected, TH2I* TotalRejected, int fts, int stt, int gem, int mvd)
{
	//std::cout << "quatro " << " stt " << stt << " mvd "  << mvd << " fts " << fts << " gem " << gem;
	if(fts!=0 && stt!=0 && gem!=0 && (mvd)!=0)
	{
		TotalHisto->Fill(16,mvd+stt+gem+fts);
		SingleParticleHisto->Fill(16,mvd+stt+gem+fts);
		if(CutCriteria(fts,stt,gem,mvd)==true)
		{
			SingleParticleSelected->Fill(16,mvd+stt+gem+fts);
			TotalSelected->Fill(16,mvd+stt+gem+fts);
			return 1;
		}
		else
		{
			SingleParticleRejected->Fill(16,mvd+stt+gem+fts);
			TotalRejected->Fill(16,mvd+stt+gem+fts);
			return 0;
		}
	}
//	std::cout << "end" << std::endl;
	return 0;
}

void PndAnaLambdaLambdaBar::MVDStripCounter(FairMultiLinkedData MVDStriplinks, int &mvdstrip, int &mvdstriplambda)
{
	for(int h=0;h < MVDStriplinks.GetNLinks();h++) 			// Loop over all MVD Strip hits to count the hits from the Lambda Disks
	{
		PndSdsHit* myStripHit = (PndSdsHit*)fStripHit->At(MVDStriplinks.GetLink(h).GetIndex());
		if(fGeoH->GetPath(myStripHit->GetSensorID()).Contains("LambdaDisk") || fGeoH->GetPath(myStripHit->GetSensorID()).Contains("AddDisk") )
		{
			//std::cout <<"fGeoH->GetPath(myStripHit->GetSensorID())" <<  fGeoH->GetPath(myStripHit->GetSensorID())  << std::endl;
			mvdstriplambda++;}
		else
		{
			mvdstrip++;
			//std::cout <<"fGeoH->GetPath(myStripHit->GetSensorID())" <<  fGeoH->GetPath(myStripHit->GetSensorID())  << std::endl;
		}
	}
}

int PndAnaLambdaLambdaBar::GEMCounter(FairMultiLinkedData GEMlinks)
{
	int gemcounter=0;
	for(int i=0;i<GEMlinks.GetNLinks();i++)
	{
		//if(GEMlinks.GetLink(i).GetWeight()==2)
		//{
			gemcounter++;
		//}
	}
	return gemcounter;
}


ClassImp(PndAnaLambdaLambdaBar);