[u/mrichter/AliRoot.git] / PWG / muon / AliAnalysisMuMuGlobal.cxx

#include "AliAnalysisMuMuGlobal.h"

/**
 * \ingroup pwg-muon-mumu
 *
 * \class AliAnalysisMuMuGlobal
 *
 * Very simple histogramming analysis for global event properties, like vertex, bunch-crossing,
 * background, etc...
 *
 * Warning : not really ready for prime-time
 *
 */

#include "TH1.h"
#include "AliVVertex.h"
#include "AliVEvent.h"
#include "AliAODEvent.h"
#include "AliAnalysisMuonUtility.h"
#include "AliAODTZERO.h"
#include "AliESDEvent.h"
#include "AliAnalysisMuMuBinning.h"
#include <set>
#include "AliMergeableCollection.h"
#include "AliAnalysisMuonUtility.h"
#include "AliESDUtils.h"

ClassImp(AliAnalysisMuMuGlobal)

//_____________________________________________________________________________
AliAnalysisMuMuGlobal::AliAnalysisMuMuGlobal() : AliAnalysisMuMuBase()
{
  /// ctor
}

//_____________________________________________________________________________
Bool_t AliAnalysisMuMuGlobal::SelectAnyTriggerClass(const TString& firedTriggerClasses, TString& acceptedTriggerClasses) const
{
  if ( firedTriggerClasses.Length()>0)
  {
    acceptedTriggerClasses = "NOTRIGGERSELECTION";
    return kTRUE;
  }
  return kFALSE;
}

//_____________________________________________________________________________
void AliAnalysisMuMuGlobal::FillHistosForEvent(const char* eventSelection,
                                               const char* triggerClassName,
                                               const char* centrality)
{
  // Fill event-wise histograms
  
  if (!IsHistogramDisabled("BCX"))
  {
    Histo(eventSelection,triggerClassName,centrality,"BCX")->Fill(1.0*Event()->GetBunchCrossNumber());
  }
  if (!IsHistogramDisabled("Nevents"))
  {
    Histo(eventSelection,triggerClassName,centrality,"Nevents")->Fill(1.0);
  }
  
  if (!IsHistogramDisabled("EventsWOL0inputs"))
  {
    UInt_t l0 = AliAnalysisMuonUtility::GetL0TriggerInputs(Event());
    
    if ( l0 == 0 ) Histo(eventSelection,triggerClassName,centrality,"EventsWOL0inputs")->Fill(1.);
  }
  
  const AliVVertex* vertex = Event()->GetPrimaryVertex();
  const AliVVertex* vertexFromSPD = AliAnalysisMuonUtility::GetVertexSPD(Event());
  
  if ( vertex )
  {
    if ( vertex->GetNContributors() > 0 )
    {
      if (!IsHistogramDisabled("Xvertex"))
      {
        Histo(eventSelection,triggerClassName,centrality,"Xvertex")->Fill(vertex->GetX());
      }
      if (!IsHistogramDisabled("Yvertex"))
      {
        Histo(eventSelection,triggerClassName,centrality,"Yvertex")->Fill(vertex->GetY());
      }
      if (!IsHistogramDisabled("Zvertex"))
      {
        Histo(eventSelection,triggerClassName,centrality,"Zvertex")->Fill(vertex->GetZ());
      }
      if ( vertexFromSPD )
      {
        if (!IsHistogramDisabled("ZvertexMinusZvertexSPD"))
        {
          Histo(eventSelection,triggerClassName,centrality,"ZvertexMinusZvertexSPD")->Fill(vertexFromSPD->GetZ()-vertex->GetZ());
        }
        if (!IsHistogramDisabled("SPDXvertex"))
        {
          Histo(eventSelection,triggerClassName,centrality,"SPDXvertex")->Fill(vertexFromSPD->GetX());
        }
        if (!IsHistogramDisabled("SPDYvertex"))
        {
          Histo(eventSelection,triggerClassName,centrality,"SPDYvertex")->Fill(vertexFromSPD->GetY());
        }
        if (!IsHistogramDisabled("SPDZvertex"))
        {
          Histo(eventSelection,triggerClassName,centrality,"SPDZvertex")->Fill(vertexFromSPD->GetZ());
        }
        if (!IsHistogramDisabled("SPDZvertexNContributors"))
        {
          Histo(eventSelection,triggerClassName,centrality,"SPDZvertexNContributors")->Fill(vertexFromSPD->GetNContributors());
        }
        if (!IsHistogramDisabled("ZvertexMinusSPDZvertexNContributors"))
        {
          Histo(eventSelection,triggerClassName,centrality,"ZvertexMinusSPDZvertexNContributors")->Fill(vertexFromSPD->GetNContributors(),vertex->GetZ() - vertexFromSPD->GetZ());
        }
        if (!IsHistogramDisabled("SPDZvertexResolutionNContributors"))
        {
          Double_t cov[6]={0};
          static_cast<const AliAODVertex*>(vertexFromSPD)->GetCovarianceMatrix(cov);
          
          Histo(eventSelection,triggerClassName,centrality,"SPDZvertexResolutionNContributors")->Fill(vertexFromSPD->GetNContributors(),TMath::Sqrt(cov[5]));
        }

      }
      if (!IsHistogramDisabled("VertexType"))
      {
        Histo(eventSelection,triggerClassName,centrality,"VertexType")->Fill(vertex->GetTitle(),1.0);
      }
      if (!IsHistogramDisabled("VertexClass"))
      {
        Histo(eventSelection,triggerClassName,centrality,"VertexClass")->Fill(static_cast<const AliAODVertex*>(vertex)->GetType(),1.0);
      }
    }
    if (!IsHistogramDisabled("ZvertexNContributors"))
    {
      Histo(eventSelection,triggerClassName,centrality,"ZvertexNContributors")->Fill(vertex->GetNContributors());
    }
  }
  
  if ( AliAnalysisMuonUtility::IsAODEvent(Event()) )
  {
    const AliAODTZERO* tzero = static_cast<const AliAODEvent*>(Event())->GetTZEROData();
    
    if (tzero && !IsHistogramDisabled("T0Zvertex"))
    {
      Histo(eventSelection,triggerClassName,centrality,"T0Zvertex")->Fill(tzero->GetT0VertexRaw());
    }
  }
  else
  {
    const AliESDTZERO* tzero = static_cast<const AliESDEvent*>(Event())->GetESDTZERO();
    
    if (tzero && !IsHistogramDisabled("T0Zvertex"))
    {
      Histo(eventSelection,triggerClassName,centrality,"T0Zvertex")->Fill(tzero->GetT0zVertex());
    }
  }
  
  AliVVZERO* vzero = Event()->GetVZEROData();
  
  if (vzero)
  {
    Float_t v0a = vzero->GetV0ATime();
    Float_t v0c = vzero->GetV0CTime();
    
    Float_t x = v0a-v0c;
    Float_t y = v0a+v0c;
    
    if( vertexFromSPD )
    {
      Float_t multV0A = vzero->GetMTotV0A();
      Float_t multV0C = vzero->GetMTotV0C();
      Float_t multV0 = multV0A + multV0C; //Corrected V0 tot mult?
      
      Float_t v0aMult = AliESDUtils::GetCorrV0A(multV0A,vertexFromSPD->GetZ());
      Float_t v0cMult = AliESDUtils::GetCorrV0C(multV0C,vertexFromSPD->GetZ());
    
      if (!IsHistogramDisabled("V0AMult"))
      {
        Histo(eventSelection,triggerClassName,centrality,"V0AMult")->Fill(v0aMult);
      }
      if (!IsHistogramDisabled("V0CMult"))
      {
        Histo(eventSelection,triggerClassName,centrality,"V0CMult")->Fill(v0cMult);
      }
      if (!IsHistogramDisabled("V0Mult"))
      {
        Histo(eventSelection,triggerClassName,centrality,"V0Mult")->Fill(multV0);
      }
    }
    
    
    if (!IsHistogramDisabled("V02D"))
    {
      Histo(eventSelection,triggerClassName,centrality,"V02D")->Fill(x,y);
    }
    
    Bool_t background,pileup,satellite;
    
    Bool_t tzero = AliAnalysisMuonUtility::EAGetTZEROFlags(Event(),background,pileup,satellite);
    
    if (tzero)
    {
      if ( background )
      {
        if (!IsHistogramDisabled("V02DwT0BG"))
        {
          Histo(eventSelection,triggerClassName,centrality,"V02DwT0BG")->Fill(x,y);
        }
      }
      
      if ( pileup )
      {
        if (!IsHistogramDisabled("V02DwT0PU"))
        {
          Histo(eventSelection,triggerClassName,centrality,"V02DwT0PU")->Fill(x,y);
        }
        
        if ( !IsHistogramDisabled("PileUpEstimators") )
        {
          Histo(eventSelection,triggerClassName,centrality,"PileUpEstimators")->Fill("TZERO",1.0);
        }
      }
      
      if ( satellite )
      {
        if (!IsHistogramDisabled("V02DwT0SAT"))
        {
          Histo(eventSelection,triggerClassName,centrality,"V02DwT0SAT")->Fill(x,y);
        }
      }
      
      if ( !background && !pileup && !satellite )
      {
        if (!IsHistogramDisabled("V02DwT0BB"))
        {
          Histo(eventSelection,triggerClassName,centrality,"V02DwT0BB")->Fill(x,y);
        }
      }
    }
  }
  
  //  /* FIXME : how to properly get multiplicity from AOD and ESD consistently ?
  //   is is doable at all ?
  
  TH1* hpileup = Histo(eventSelection,triggerClassName,centrality,"PileUpEstimators");
  
  
  //  virtual Bool_t  IsPileupFromSPD(Int_t minContributors=3, Double_t minZdist=0.8, Double_t nSigmaZdist=3., Double_t nSigmaDiamXY=2., Double_t nSigmaDiamZ=5.) const;
  
  const Double_t nSigmaZdist=3.0;
  const Double_t nSigmaDiamXY=2.0;
  const Double_t nSigmaDiamZ=5.0;
  
  for ( Int_t minContributors = 3; minContributors <= 6; ++minContributors )
  {
    for ( double minZdist = 0.6; minZdist <= 0.8; minZdist += 0.2 )
    {
      if ( Event()->IsPileupFromSPD(minContributors,minZdist,nSigmaZdist,nSigmaDiamXY,nSigmaDiamZ) )
      {
        hpileup->Fill(Form("SPD:n%dd%d",minContributors,static_cast<Int_t>(10*minZdist)),1);
      }
    }
  }
  
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuGlobal::FillHistosForMCEvent(const char* eventSelection,
                                                 const char* triggerClassName,
                                                 const char* centrality)
{
  // Fill MCEvent-wise histograms
  
  Double_t Zvertex = AliAnalysisMuonUtility::GetMCVertexZ(Event(),MCEvent());
  
  if (!IsHistogramDisabled("Zvertex"))
  {
    MCHisto(eventSelection,triggerClassName,centrality,"Zvertex")->Fill(Zvertex);
  }

  if (!IsHistogramDisabled("RecZvertexVsMCZvertex"))
  {
    const AliVVertex* vertex = Event()->GetPrimaryVertex();
    if  (vertex && vertex->GetNContributors()>0)
    {
      MCHisto(eventSelection,triggerClassName,centrality,"RecZvertexVsMCZvertex")->Fill(Zvertex,vertex->GetZ());
    }
    
    const AliVVertex* vertexFromSPD = AliAnalysisMuonUtility::GetVertexSPD(Event());
    if  (vertexFromSPD && vertexFromSPD->GetNContributors()>0)
    {
      MCHisto(eventSelection,triggerClassName,centrality,"RecSPDZvertexVsMCZvertex")->Fill(Zvertex,vertexFromSPD->GetZ());
      MCHisto(eventSelection,triggerClassName,centrality,"NofEvWSPDZvertexVsMCZvertex")->Fill(Zvertex,1);
    }
    else MCHisto(eventSelection,triggerClassName,centrality,"NofEvWOSPDZvertexVsMCZvertex")->Fill(Zvertex,1);
  }
  
}

//_____________________________________________________________________________
void AliAnalysisMuMuGlobal::DefineHistogramCollection(const char* eventSelection,
                                                      const char* triggerClassName,
                                                      const char* centrality)
{
  /// Actually create the histograms for phyics/triggerClassName
  
//  AliInfo(Form("%s %s %s %d",eventSelection,triggerClassName,centrality,hasMC));
  
  if (HistogramCollection()->Histo(Form("/%s/%s/%s/Zvertex",eventSelection,triggerClassName,centrality)))
  {
    return;
  }

  Double_t xmin = -40;
  Double_t xmax = +40;
  Int_t nbins = GetNbins(xmin,xmax,0.5);
  
  CreateEventHistos(kHistoForData | kHistoForMCInput,eventSelection,triggerClassName,centrality,"Zvertex","z vertex",nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDZvertex","SPD z vertex",nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"T0Zvertex","T0 zvertex",nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
                    "RecZvertexVsMCZvertex","Reconstructed vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax,nbins,xmin,xmax);
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
                    "RecSPDZvertexVsMCZvertex","Reconstructed SPD vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax,nbins,xmin,xmax);
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
                    "NofEvWSPDZvertexVsMCZvertex","Number of events with SPD vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax);
  CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
                    "NofEvWOSPDZvertexVsMCZvertex","Number of events with SPD vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax);
  

  xmin = -5;
  xmax = 5;
  nbins = GetNbins(xmin,xmax,0.01);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"ZvertexMinusZvertexSPD","Primary vertex z - SPD vertex",nbins,xmin,xmax);
  
  xmin = -1;
  xmax = 50;
  nbins = GetNbins(xmin,xmax,1);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"ZvertexNContributors","z vertex vs nof contributors",nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDZvertexNContributors","SPD z vertex vs nof contributors",nbins,xmin,xmax);
  
  Double_t ymin = -10;
  Double_t ymax = 10;
  Int_t nbinsy = GetNbins(ymin,ymax,0.01);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"ZvertexMinusSPDZvertexNContributors","Primary vertex z - SPD vertex vs nof contributors",nbins,xmin,xmax,nbinsy,ymin,ymax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDZvertexResolutionNContributors","SPD vertex resolution vs nof contributors",nbins,xmin,xmax,nbinsy,ymin,ymax);
  
  xmin = -2;
  xmax = 2;
  nbins = GetNbins(xmin,xmax,0.01);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Xvertex","x vertex",nbins,xmin,xmax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Yvertex","y vertex",nbins,xmin,xmax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDXvertex","SPD x vertex",nbins,xmin,xmax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDYvertex","SPD y vertex",nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Nevents","number of events",2,-0.5,1.5);
   CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"EventsWOL0inputs","number of events w/o L0 inputs",2,-0.5,1.5);
  
  CreateEventHistos(kHistoForMCInput | kHistoForData,eventSelection,triggerClassName,centrality,
                    "VertexType","Type of vertexer used",10,0,10);
  
  CreateEventHistos(kHistoForMCInput | kHistoForData,eventSelection,triggerClassName,centrality,
                    "VertexClass","Type of vertex used",10,0,10);


  xmin = 0;
  xmax = 3564;
  nbins = GetNbins(xmin,xmax,1.0);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"BCX","bunch-crossing ids",nbins,xmin-0.5,xmax-0.5);
  
  
  xmin = -30;
  xmax = +30;
  nbins = GetNbins(xmin,xmax,0.1);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02D","V0C+V0A versus V0A-V0C;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0BB","V0C+V0A versus V0A-V0C with T0 BB;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0BG","V0C+V0A versus V0A-V0C with T0 background flag on;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0PU","V0C+V0A versus V0A-V0C with T0 pile up flag on;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0SAT","V0C+V0A versus V0A-V0C with T0 satellite flag on;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
  
  xmin = 0;
  xmax = 600;
  nbins = GetNbins(xmin,xmax,1);
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0AMult","V0A multiplicity;V0A mult;N_{events}",nbins,xmin,xmax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0CMult","V0C multiplicity;V0C mult;N_{events}",nbins,xmin,xmax);
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0Mult","V0 multiplicity;V0 mult;N_{events}",nbins,xmin,xmax);
  
  if ( !IsHistogramDisabled("Centrality") )
  {
    TObjArray* centralities = Binning()->CreateBinObjArray("centrality");
    TIter next(centralities);
    AliAnalysisMuMuBinning::Range* r;
    std::set<std::string> estimators;
    
    while ( ( r = static_cast<AliAnalysisMuMuBinning::Range*>(next())) )
    {
      estimators.insert(r->Quantity().Data());
    }
    
    std::set<std::string>::const_iterator it;
    
    for ( it = estimators.begin(); it != estimators.end(); ++it )
    {
      TH1* h = new TH1F("Centrality","Centrality",12,-10,110);
      HistogramCollection()->Adopt(Form("/%s/%s/%s",eventSelection,triggerClassName,it->c_str()),h);
    }
    
    delete centralities;
  }
  
  CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"PileUpEstimators","pile up estimators",10,0,10);
}
Commit	Line	Data
5376e016 CP	1	#include "AliAnalysisMuMuGlobal.h"
	2
	3	/**
	4	* \ingroup pwg-muon-mumu
	5	*
	6	* \class AliAnalysisMuMuGlobal
	7	*
	8	* Very simple histogramming analysis for global event properties, like vertex, bunch-crossing,
	9	* background, etc...
	10	*
	11	* Warning : not really ready for prime-time
	12	*
	13	*/
	14
	15	#include "TH1.h"
	16	#include "AliVVertex.h"
	17	#include "AliVEvent.h"
	18	#include "AliAODEvent.h"
	19	#include "AliAnalysisMuonUtility.h"
	20	#include "AliAODTZERO.h"
	21	#include "AliESDEvent.h"
	22	#include "AliAnalysisMuMuBinning.h"
	23	#include <set>
	24	#include "AliMergeableCollection.h"
	25	#include "AliAnalysisMuonUtility.h"
16560e8e	26	#include "AliESDUtils.h"
5376e016 CP	27
	28	ClassImp(AliAnalysisMuMuGlobal)
	29
	30	//_____________________________________________________________________________
	31	AliAnalysisMuMuGlobal::AliAnalysisMuMuGlobal() : AliAnalysisMuMuBase()
	32	{
	33	/// ctor
	34	}
	35
	36	//_____________________________________________________________________________
16560e8e	37	Bool_t AliAnalysisMuMuGlobal::SelectAnyTriggerClass(const TString& firedTriggerClasses, TString& acceptedTriggerClasses) const
5376e016	38	{
16560e8e	39	if ( firedTriggerClasses.Length()>0)
5376e016	40	{
16560e8e	41	acceptedTriggerClasses = "NOTRIGGERSELECTION";
16560e8e	42	return kTRUE;
5376e016	43	}
16560e8e	44	return kFALSE;
5376e016 CP	45	}
5376e016 CP	46
5376e016 CP	47	//_____________________________________________________________________________
	48	void AliAnalysisMuMuGlobal::FillHistosForEvent(const char* eventSelection,
	49	const char* triggerClassName,
	50	const char* centrality)
	51	{
	52	// Fill event-wise histograms
	53
	54	if (!IsHistogramDisabled("BCX"))
	55	{
	56	Histo(eventSelection,triggerClassName,centrality,"BCX")->Fill(1.0*Event()->GetBunchCrossNumber());
	57	}
	58	if (!IsHistogramDisabled("Nevents"))
	59	{
	60	Histo(eventSelection,triggerClassName,centrality,"Nevents")->Fill(1.0);
	61	}
	62
16560e8e	63	if (!IsHistogramDisabled("EventsWOL0inputs"))
	64	{
	65	UInt_t l0 = AliAnalysisMuonUtility::GetL0TriggerInputs(Event());
	66
	67	if ( l0 == 0 ) Histo(eventSelection,triggerClassName,centrality,"EventsWOL0inputs")->Fill(1.);
	68	}
	69
5376e016 CP	70	const AliVVertex* vertex = Event()->GetPrimaryVertex();
	71	const AliVVertex* vertexFromSPD = AliAnalysisMuonUtility::GetVertexSPD(Event());
	72
16560e8e	73	if ( vertex )
5376e016 CP	74	{
	75	if ( vertex->GetNContributors() > 0 )
	76	{
	77	if (!IsHistogramDisabled("Xvertex"))
	78	{
	79	Histo(eventSelection,triggerClassName,centrality,"Xvertex")->Fill(vertex->GetX());
	80	}
	81	if (!IsHistogramDisabled("Yvertex"))
	82	{
	83	Histo(eventSelection,triggerClassName,centrality,"Yvertex")->Fill(vertex->GetY());
	84	}
	85	if (!IsHistogramDisabled("Zvertex"))
	86	{
	87	Histo(eventSelection,triggerClassName,centrality,"Zvertex")->Fill(vertex->GetZ());
	88	}
16560e8e	89	if ( vertexFromSPD )
5376e016	90	{
16560e8e	91	if (!IsHistogramDisabled("ZvertexMinusZvertexSPD"))
	92	{
	93	Histo(eventSelection,triggerClassName,centrality,"ZvertexMinusZvertexSPD")->Fill(vertexFromSPD->GetZ()-vertex->GetZ());
	94	}
	95	if (!IsHistogramDisabled("SPDXvertex"))
	96	{
	97	Histo(eventSelection,triggerClassName,centrality,"SPDXvertex")->Fill(vertexFromSPD->GetX());
	98	}
	99	if (!IsHistogramDisabled("SPDYvertex"))
	100	{
	101	Histo(eventSelection,triggerClassName,centrality,"SPDYvertex")->Fill(vertexFromSPD->GetY());
	102	}
	103	if (!IsHistogramDisabled("SPDZvertex"))
	104	{
	105	Histo(eventSelection,triggerClassName,centrality,"SPDZvertex")->Fill(vertexFromSPD->GetZ());
	106	}
	107	if (!IsHistogramDisabled("SPDZvertexNContributors"))
	108	{
	109	Histo(eventSelection,triggerClassName,centrality,"SPDZvertexNContributors")->Fill(vertexFromSPD->GetNContributors());
	110	}
	111	if (!IsHistogramDisabled("ZvertexMinusSPDZvertexNContributors"))
	112	{
	113	Histo(eventSelection,triggerClassName,centrality,"ZvertexMinusSPDZvertexNContributors")->Fill(vertexFromSPD->GetNContributors(),vertex->GetZ() - vertexFromSPD->GetZ());
	114	}
	115	if (!IsHistogramDisabled("SPDZvertexResolutionNContributors"))
	116	{
	117	Double_t cov[6]={0};
	118	static_cast<const AliAODVertex*>(vertexFromSPD)->GetCovarianceMatrix(cov);
	119
	120	Histo(eventSelection,triggerClassName,centrality,"SPDZvertexResolutionNContributors")->Fill(vertexFromSPD->GetNContributors(),TMath::Sqrt(cov[5]));
	121	}
	122
5376e016 CP	123	}
	124	if (!IsHistogramDisabled("VertexType"))
	125	{
	126	Histo(eventSelection,triggerClassName,centrality,"VertexType")->Fill(vertex->GetTitle(),1.0);
	127	}
16560e8e	128	if (!IsHistogramDisabled("VertexClass"))
	129	{
	130	Histo(eventSelection,triggerClassName,centrality,"VertexClass")->Fill(static_cast<const AliAODVertex*>(vertex)->GetType(),1.0);
	131	}
5376e016 CP	132	}
	133	if (!IsHistogramDisabled("ZvertexNContributors"))
	134	{
	135	Histo(eventSelection,triggerClassName,centrality,"ZvertexNContributors")->Fill(vertex->GetNContributors());
	136	}
	137	}
	138
	139	if ( AliAnalysisMuonUtility::IsAODEvent(Event()) )
	140	{
	141	const AliAODTZERO* tzero = static_cast<const AliAODEvent*>(Event())->GetTZEROData();
	142
	143	if (tzero && !IsHistogramDisabled("T0Zvertex"))
	144	{
	145	Histo(eventSelection,triggerClassName,centrality,"T0Zvertex")->Fill(tzero->GetT0VertexRaw());
	146	}
	147	}
	148	else
	149	{
	150	const AliESDTZERO* tzero = static_cast<const AliESDEvent*>(Event())->GetESDTZERO();
	151
	152	if (tzero && !IsHistogramDisabled("T0Zvertex"))
	153	{
	154	Histo(eventSelection,triggerClassName,centrality,"T0Zvertex")->Fill(tzero->GetT0zVertex());
	155	}
	156	}
	157
	158	AliVVZERO* vzero = Event()->GetVZEROData();
	159
	160	if (vzero)
	161	{
	162	Float_t v0a = vzero->GetV0ATime();
	163	Float_t v0c = vzero->GetV0CTime();
	164
	165	Float_t x = v0a-v0c;
	166	Float_t y = v0a+v0c;
	167
16560e8e	168	if( vertexFromSPD )
5376e016	169	{
16560e8e	170	Float_t multV0A = vzero->GetMTotV0A();
	171	Float_t multV0C = vzero->GetMTotV0C();
	172	Float_t multV0 = multV0A + multV0C; //Corrected V0 tot mult?
	173
	174	Float_t v0aMult = AliESDUtils::GetCorrV0A(multV0A,vertexFromSPD->GetZ());
	175	Float_t v0cMult = AliESDUtils::GetCorrV0C(multV0C,vertexFromSPD->GetZ());
	176
	177	if (!IsHistogramDisabled("V0AMult"))
	178	{
	179	Histo(eventSelection,triggerClassName,centrality,"V0AMult")->Fill(v0aMult);
	180	}
	181	if (!IsHistogramDisabled("V0CMult"))
	182	{
	183	Histo(eventSelection,triggerClassName,centrality,"V0CMult")->Fill(v0cMult);
	184	}
	185	if (!IsHistogramDisabled("V0Mult"))
	186	{
	187	Histo(eventSelection,triggerClassName,centrality,"V0Mult")->Fill(multV0);
	188	}
5376e016	189	}
16560e8e	190
16560e8e	191
5376e016 CP	192	if (!IsHistogramDisabled("V02D"))
	193	{
	194	Histo(eventSelection,triggerClassName,centrality,"V02D")->Fill(x,y);
	195	}
	196
	197	Bool_t background,pileup,satellite;
	198
	199	Bool_t tzero = AliAnalysisMuonUtility::EAGetTZEROFlags(Event(),background,pileup,satellite);
	200
	201	if (tzero)
	202	{
	203	if ( background )
	204	{
	205	if (!IsHistogramDisabled("V02DwT0BG"))
	206	{
	207	Histo(eventSelection,triggerClassName,centrality,"V02DwT0BG")->Fill(x,y);
	208	}
	209	}
	210
	211	if ( pileup )
	212	{
	213	if (!IsHistogramDisabled("V02DwT0PU"))
	214	{
	215	Histo(eventSelection,triggerClassName,centrality,"V02DwT0PU")->Fill(x,y);
	216	}
	217
	218	if ( !IsHistogramDisabled("PileUpEstimators") )
	219	{
	220	Histo(eventSelection,triggerClassName,centrality,"PileUpEstimators")->Fill("TZERO",1.0);
	221	}
	222	}
	223
	224	if ( satellite )
	225	{
	226	if (!IsHistogramDisabled("V02DwT0SAT"))
	227	{
	228	Histo(eventSelection,triggerClassName,centrality,"V02DwT0SAT")->Fill(x,y);
	229	}
	230	}
	231
	232	if ( !background && !pileup && !satellite )
	233	{
	234	if (!IsHistogramDisabled("V02DwT0BB"))
	235	{
	236	Histo(eventSelection,triggerClassName,centrality,"V02DwT0BB")->Fill(x,y);
	237	}
	238	}
	239	}
	240	}
	241
	242	// /* FIXME : how to properly get multiplicity from AOD and ESD consistently ?
	243	// is is doable at all ?
	244
	245	TH1* hpileup = Histo(eventSelection,triggerClassName,centrality,"PileUpEstimators");
	246
	247
	248	// virtual Bool_t IsPileupFromSPD(Int_t minContributors=3, Double_t minZdist=0.8, Double_t nSigmaZdist=3., Double_t nSigmaDiamXY=2., Double_t nSigmaDiamZ=5.) const;
	249
	250	const Double_t nSigmaZdist=3.0;
	251	const Double_t nSigmaDiamXY=2.0;
	252	const Double_t nSigmaDiamZ=5.0;
	253
	254	for ( Int_t minContributors = 3; minContributors <= 6; ++minContributors )
	255	{
256	for ( double minZdist = 0.6; minZdist <= 0.8; minZdist += 0.2 )
257	{
258	if ( Event()->IsPileupFromSPD(minContributors,minZdist,nSigmaZdist,nSigmaDiamXY,nSigmaDiamZ) )
259	{
260	hpileup->Fill(Form("SPD:n%dd%d",minContributors,static_cast<Int_t>(10*minZdist)),1);
261	}
262	}
263	}
264
265
266	}
267
268	//_____________________________________________________________________________
269	void AliAnalysisMuMuGlobal::FillHistosForMCEvent(const char* eventSelection,
270	const char* triggerClassName,
271	const char* centrality)
272	{
273	// Fill MCEvent-wise histograms
274
275	Double_t Zvertex = AliAnalysisMuonUtility::GetMCVertexZ(Event(),MCEvent());
276
277	if (!IsHistogramDisabled("Zvertex"))
278	{
279	MCHisto(eventSelection,triggerClassName,centrality,"Zvertex")->Fill(Zvertex);
280	}
281
282	if (!IsHistogramDisabled("RecZvertexVsMCZvertex"))
283	{
284	const AliVVertex* vertex = Event()->GetPrimaryVertex();
285	if (vertex && vertex->GetNContributors()>0)
286	{
287	MCHisto(eventSelection,triggerClassName,centrality,"RecZvertexVsMCZvertex")->Fill(Zvertex,vertex->GetZ());
288	}
16560e8e	289
	290	const AliVVertex* vertexFromSPD = AliAnalysisMuonUtility::GetVertexSPD(Event());
	291	if (vertexFromSPD && vertexFromSPD->GetNContributors()>0)
	292	{
	293	MCHisto(eventSelection,triggerClassName,centrality,"RecSPDZvertexVsMCZvertex")->Fill(Zvertex,vertexFromSPD->GetZ());
	294	MCHisto(eventSelection,triggerClassName,centrality,"NofEvWSPDZvertexVsMCZvertex")->Fill(Zvertex,1);
	295	}
	296	else MCHisto(eventSelection,triggerClassName,centrality,"NofEvWOSPDZvertexVsMCZvertex")->Fill(Zvertex,1);
5376e016 CP	297	}
	298
	299	}
	300
	301	//_____________________________________________________________________________
16560e8e	302	void AliAnalysisMuMuGlobal::DefineHistogramCollection(const char* eventSelection,
	303	const char* triggerClassName,
	304	const char* centrality)
5376e016	305	{
16560e8e	306	/// Actually create the histograms for phyics/triggerClassName
	307
	308	// AliInfo(Form("%s %s %s %d",eventSelection,triggerClassName,centrality,hasMC));
	309
	310	if (HistogramCollection()->Histo(Form("/%s/%s/%s/Zvertex",eventSelection,triggerClassName,centrality)))
5376e016	311	{
16560e8e	312	return;
5376e016	313	}
16560e8e	314
	315	Double_t xmin = -40;
	316	Double_t xmax = +40;
	317	Int_t nbins = GetNbins(xmin,xmax,0.5);
	318
	319	CreateEventHistos(kHistoForData \| kHistoForMCInput,eventSelection,triggerClassName,centrality,"Zvertex","z vertex",nbins,xmin,xmax);
	320
	321	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDZvertex","SPD z vertex",nbins,xmin,xmax);
	322
	323	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"T0Zvertex","T0 zvertex",nbins,xmin,xmax);
	324
	325	CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
	326	"RecZvertexVsMCZvertex","Reconstructed vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax,nbins,xmin,xmax);
	327	CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
	328	"RecSPDZvertexVsMCZvertex","Reconstructed SPD vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax,nbins,xmin,xmax);
	329	CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
	330	"NofEvWSPDZvertexVsMCZvertex","Number of events with SPD vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax);
	331	CreateEventHistos(kHistoForMCInput,eventSelection,triggerClassName,centrality,
	332	"NofEvWOSPDZvertexVsMCZvertex","Number of events with SPD vertex (w/ Ncontrib>=1) vs MC vertex",nbins,xmin,xmax);
	333
	334
	335	xmin = -5;
	336	xmax = 5;
	337	nbins = GetNbins(xmin,xmax,0.01);
	338
	339	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"ZvertexMinusZvertexSPD","Primary vertex z - SPD vertex",nbins,xmin,xmax);
	340
	341	xmin = -1;
	342	xmax = 50;
	343	nbins = GetNbins(xmin,xmax,1);
	344
	345	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"ZvertexNContributors","z vertex vs nof contributors",nbins,xmin,xmax);
	346
	347	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDZvertexNContributors","SPD z vertex vs nof contributors",nbins,xmin,xmax);
	348
	349	Double_t ymin = -10;
	350	Double_t ymax = 10;
	351	Int_t nbinsy = GetNbins(ymin,ymax,0.01);
	352
	353	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"ZvertexMinusSPDZvertexNContributors","Primary vertex z - SPD vertex vs nof contributors",nbins,xmin,xmax,nbinsy,ymin,ymax);
	354
	355	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDZvertexResolutionNContributors","SPD vertex resolution vs nof contributors",nbins,xmin,xmax,nbinsy,ymin,ymax);
	356
	357	xmin = -2;
	358	xmax = 2;
	359	nbins = GetNbins(xmin,xmax,0.01);
	360
	361	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Xvertex","x vertex",nbins,xmin,xmax);
	362	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Yvertex","y vertex",nbins,xmin,xmax);
	363	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDXvertex","SPD x vertex",nbins,xmin,xmax);
	364	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"SPDYvertex","SPD y vertex",nbins,xmin,xmax);
	365
	366	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"Nevents","number of events",2,-0.5,1.5);
	367	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"EventsWOL0inputs","number of events w/o L0 inputs",2,-0.5,1.5);
	368
	369	CreateEventHistos(kHistoForMCInput \| kHistoForData,eventSelection,triggerClassName,centrality,
	370	"VertexType","Type of vertexer used",10,0,10);
	371
	372	CreateEventHistos(kHistoForMCInput \| kHistoForData,eventSelection,triggerClassName,centrality,
	373	"VertexClass","Type of vertex used",10,0,10);
	374
	375
	376	xmin = 0;
	377	xmax = 3564;
378	nbins = GetNbins(xmin,xmax,1.0);
379
380	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"BCX","bunch-crossing ids",nbins,xmin-0.5,xmax-0.5);
381
382
383	xmin = -30;
384	xmax = +30;
385	nbins = GetNbins(xmin,xmax,0.1);
386
387	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02D","V0C+V0A versus V0A-V0C;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
388
389	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0BB","V0C+V0A versus V0A-V0C with T0 BB;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
390
391	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0BG","V0C+V0A versus V0A-V0C with T0 background flag on;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
392
393	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0PU","V0C+V0A versus V0A-V0C with T0 pile up flag on;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
394
395	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V02DwT0SAT","V0C+V0A versus V0A-V0C with T0 satellite flag on;Time V0A - V0C (ns);Time V0A+V0C (ns)",nbins,xmin,xmax,nbins,xmin,xmax);
396
397	xmin = 0;
398	xmax = 600;
399	nbins = GetNbins(xmin,xmax,1);
400
401	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0AMult","V0A multiplicity;V0A mult;N_{events}",nbins,xmin,xmax);
402	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0CMult","V0C multiplicity;V0C mult;N_{events}",nbins,xmin,xmax);
403	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"V0Mult","V0 multiplicity;V0 mult;N_{events}",nbins,xmin,xmax);
404
405	if ( !IsHistogramDisabled("Centrality") )
406	{
407	TObjArray* centralities = Binning()->CreateBinObjArray("centrality");
408	TIter next(centralities);
409	AliAnalysisMuMuBinning::Range* r;
410	std::set<std::string> estimators;
411
412	while ( ( r = static_cast<AliAnalysisMuMuBinning::Range*>(next())) )
413	{
414	estimators.insert(r->Quantity().Data());
415	}
416
417	std::set<std::string>::const_iterator it;
418
419	for ( it = estimators.begin(); it != estimators.end(); ++it )
420	{
421	TH1* h = new TH1F("Centrality","Centrality",12,-10,110);
422	HistogramCollection()->Adopt(Form("/%s/%s/%s",eventSelection,triggerClassName,it->c_str()),h);
423	}
424
425	delete centralities;
426	}
427
428	CreateEventHistos(kHistoForData,eventSelection,triggerClassName,centrality,"PileUpEstimators","pile up estimators",10,0,10);
5376e016 CP	429	}
5376e016 CP	430