[u/mrichter/AliRoot.git] / PWGCF / FEMTOSCOPY / AliFemto / AliFemtoCutMonitorV0.cxx

////////////////////////////////////////////////////////////////////////////////
//                                                                            //
// AliFemtoCutMonitorV0                                                       //
//                                                                            //
////////////////////////////////////////////////////////////////////////////////
#include "AliFemtoCutMonitorV0.h"
#include <TH1D.h>
#include <TH2D.h>
#include <TH3D.h>
#include <TList.h>
#include "AliFemtoModelHiddenInfo.h"

AliFemtoCutMonitorV0::AliFemtoCutMonitorV0():
  fLambdaMass(0),
  fAntiLambdaMass(0),
  fK0ShortMass(0),
  fDcaDaughters(0),
  fDcaV0ToPrimVertex(0),
  fDcaPosToPrimVertex(0),
  fDcaNegToPrimVertex(0),
  fCosPointingAngle(0),
  fDecayLength(0),
  fEtaV0(0),
  fPtV0(0),
  fPtPosDaughter(0),
  fPtNegDaughter(0),
  fdEdxPosDaughter(0),
  fdEdxNegDaughter(0),
  fTOFtimePosDaughter(0),
  fTOFtimeNegDaughter(0),
  fnsigmaPosL(0),
  fnsigmaNegL(0),
  fnsigmaPosAL(0),
  fnsigmaNegAL(0)
{
  // Default constructor
  fLambdaMass = new TH1F("LambdaMass", "Mass Assuming Lambda Hypothesis", 10000, 0, 5);
  fAntiLambdaMass = new TH1F("AntiLambdaMass", "Mass Assuming AntiLambda Hypothesis", 10000, 0, 5);
  fK0ShortMass= new TH1F("K0ShortMass", "Mass Assuming K0 short Hypothesis", 500, 0, 5);
  fDcaDaughters = new TH1F("DcaDaughters", "DCA Daughters", 500, 0, 2);
  fDcaV0ToPrimVertex = new TH1F("DcaV0ToPrimVertex", "DCA V0 to primary vertex", 500, 0, 3);
  fDcaPosToPrimVertex = new TH1F("DcaNegToPrimVertex", "DCA V0 to primary vertex", 500, 0, 3);
  fDcaNegToPrimVertex = new TH1F("DcaNegToPrimVertex", "DCA V0 to primary vertex", 500, 0, 3);
  fCosPointingAngle = new TH1F("CosPointingAngle","Cosinus Pointing Angle",500,0,1);
  fDecayLength = new TH1F("DecayLength","V0 Decay Length",100,0,100);
  fEtaV0 = new TH1F("EtaV0", "|Eta| distribution of V0s", 500, 0.0, 8.);
  fPtV0 = new TH1F("PtV0", "Pt distribution of V0s", 500, 0.0, 8.);
  fPtPosDaughter = new TH1F("PtPosDaughter", "Pt distribution of positive daughters", 500, 0.0, 5.);
  fPtNegDaughter = new TH1F("PtNegDaughter", "Pt distribution of negative daughters", 500, 0.0, 5.);

  fdEdxPosDaughter = new TH2D("dEdxPosDaughter","dEdx of positive daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
  fdEdxNegDaughter = new TH2D("dEdxNegDaughter","dEdx of negative daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
  fTOFtimePosDaughter = new TH2D("TOFtimePosDaughter","TOF time of positive daughters",100,0.,1.1,100,0.,3.0);
  fTOFtimeNegDaughter = new TH2D("TOFtimeNegDaughter","TOF time of negative daughters",100,0.,1.1,100,0.,3.0);

  fnsigmaPosL = new TH1D("fnsigmaPosL","Number of sigmas of positive Lambda daughters",200,-8,8);
  fnsigmaNegL = new TH1D("fnsigmaNegL","Number of sigmas of negative Lambda daughters",200,-8,8);
  fnsigmaPosAL = new TH1D("fnsigmaPosAL","Number of sigmas of positive AntiLambda daughters",200,-8,8);
  fnsigmaNegAL = new TH1D("fnsigmaNegAL","Number of sigmas of negative AntiLambda daughters",200,-8,8);

  fLambdaMass->Sumw2();
  fAntiLambdaMass->Sumw2();
  fK0ShortMass->Sumw2();
  fDcaDaughters->Sumw2();
  fDcaV0ToPrimVertex->Sumw2();
  fDcaPosToPrimVertex->Sumw2();
  fDcaNegToPrimVertex->Sumw2();
  fCosPointingAngle->Sumw2();
  fDecayLength->Sumw2();
  fEtaV0->Sumw2();
  fPtPosDaughter->Sumw2();
  fPtNegDaughter->Sumw2();
  fdEdxPosDaughter->Sumw2();
  fdEdxNegDaughter->Sumw2();
  fTOFtimePosDaughter->Sumw2();
  fTOFtimeNegDaughter->Sumw2();
  fnsigmaPosL->Sumw2();
  fnsigmaNegL->Sumw2();
  fnsigmaPosAL->Sumw2();
  fnsigmaNegAL->Sumw2();
}

AliFemtoCutMonitorV0::AliFemtoCutMonitorV0(const char *aName):
  AliFemtoCutMonitor(),
  fLambdaMass(0),
  fAntiLambdaMass(0),
  fK0ShortMass(0),
  fDcaDaughters(0),
  fDcaV0ToPrimVertex(0),
  fDcaPosToPrimVertex(0),
  fDcaNegToPrimVertex(0),
  fCosPointingAngle(0),
  fDecayLength(0),
  fEtaV0(0),
  fPtV0(0),
  fPtPosDaughter(0),
  fPtNegDaughter(0),
  fdEdxPosDaughter(0),
  fdEdxNegDaughter(0),
  fTOFtimePosDaughter(0),
  fTOFtimeNegDaughter(0),
  fnsigmaPosL(0),
  fnsigmaNegL(0),
  fnsigmaPosAL(0),
  fnsigmaNegAL(0)
{
  // Normal constructor
  char name[200];
  snprintf(name, 200, "LambdaMass%s", aName);
  fLambdaMass = new TH1F(name, "Mass Assuming Lambda Hypothesis", 10000, 0, 5);
  snprintf(name, 200, "AntiLambdaMass%s", aName);
  fAntiLambdaMass = new TH1F(name, "Mass Assuming AntiLambda Hypothesis", 10000, 0, 5);
  snprintf(name, 200, "K0ShortMass%s", aName);
  fK0ShortMass = new TH1F(name, "Mass Assuming K0 short Hypothesis", 500, 0, 5);
  snprintf(name, 200, "DcaDaughters%s", aName);
  fDcaDaughters = new TH1F(name, "DCA Daughters", 500, 0, 2);
  snprintf(name, 200, "DcaV0ToPrimVertex%s", aName);
  fDcaV0ToPrimVertex = new TH1F(name, "DCA V0 to primary vertex", 500, 0, 3);
  snprintf(name, 200, "DcaPosToPrimVertex%s", aName);
  fDcaPosToPrimVertex = new TH1F(name, "DCA pos. daughter V0 to primary vertex", 500, 0, 3);
  snprintf(name, 200, "DcaPosToPrimVertex%s", aName);
  fDcaNegToPrimVertex = new TH1F(name, "DCA neg. daughter V0 to primary vertex", 500, 0, 3);
  snprintf(name, 200, "CosPointingAngle%s", aName);
  fCosPointingAngle = new TH1F(name,"Cosinus Pointing Angle",500,0,1);
  snprintf(name, 200, "DecayLength%s", aName);
  fDecayLength = new TH1F(name,"Decay Length",100,0,100);
  snprintf(name, 200, "EtaV0%s", aName);
  fEtaV0 = new TH1F(name, "|Eta| distribution of V0s", 500, 0.0, 1.);
  snprintf(name, 200, "PtV0%s", aName);
  fPtV0 = new TH1F(name, "Pt distribution of V0s", 500, 0.0, 8.);
  snprintf(name, 200, "fPtPosDaughter%s", aName);
  fPtPosDaughter = new TH1F(name, "Pt distribution of positive daughters", 500, 0.0, 5.);
  snprintf(name, 200, "fPtNegDaughter%s", aName);
  fPtNegDaughter = new TH1F(name, "Pt distribution of negative daughters", 500, 0.0, 5.);
  snprintf(name, 200, "fdEdxPosDaughter%s", aName);
  fdEdxPosDaughter = new TH2D(name,"dEdx of positive daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
  snprintf(name, 200, "fdEdxNegDaughter%s", aName);
  fdEdxNegDaughter = new TH2D(name,"dEdx of negative daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
  snprintf(name, 200, "fTOFtimePosDaughter%s", aName);
  fTOFtimePosDaughter = new TH2D(name,"TOF time of positive daughters",190, 0.1, 2.0, 400, -4000.0, 4000.0);
  snprintf(name, 200, " fTOFtimeNegDaughter%s", aName);
  fTOFtimeNegDaughter = new TH2D(name,"TOF time of negative daughters",190, 0.1, 2.0, 400, -4000.0, 4000.0);
  snprintf(name, 200, " fnsigmaPosL%s", aName);
  fnsigmaPosL = new TH1D(name,"Number of sigmas of positive Lambda daughters",200,-10,10);
  snprintf(name, 200, " fnsigmaNegL%s", aName);
  fnsigmaNegL = new TH1D(name,"Number of sigmas of negative Lambda daughters",200,-10,10);
  snprintf(name, 200, " fnsigmaPosAL%s", aName);
  fnsigmaPosAL = new TH1D(name,"Number of sigmas of positive AntiLambda daughters",200,-10,10);
  snprintf(name, 200, " fnsigmaNegAL%s", aName);
  fnsigmaNegAL = new TH1D(name,"Number of sigmas of negative AntiLambda daughters",200,-10,10);

  fLambdaMass->Sumw2();
  fAntiLambdaMass->Sumw2();
  fK0ShortMass->Sumw2();
  fDcaDaughters->Sumw2();
  fDcaV0ToPrimVertex->Sumw2();
  fDcaPosToPrimVertex->Sumw2();
  fDcaNegToPrimVertex->Sumw2();
  fCosPointingAngle->Sumw2();
  fDecayLength->Sumw2();
  fEtaV0->Sumw2();
  fPtPosDaughter->Sumw2();
  fPtNegDaughter->Sumw2();
  fdEdxPosDaughter->Sumw2();
  fdEdxNegDaughter->Sumw2();
  fTOFtimePosDaughter->Sumw2();
  fTOFtimeNegDaughter->Sumw2();
  fnsigmaPosL->Sumw2();
  fnsigmaNegL->Sumw2();
  fnsigmaPosAL->Sumw2();
  fnsigmaNegAL->Sumw2();
}

AliFemtoCutMonitorV0::AliFemtoCutMonitorV0(const AliFemtoCutMonitorV0 &aCut):
  AliFemtoCutMonitor(),
  fLambdaMass(0),
  fAntiLambdaMass(0),
  fK0ShortMass(0),
  fDcaDaughters(0),
  fDcaV0ToPrimVertex(0),
  fDcaPosToPrimVertex(0),
  fDcaNegToPrimVertex(0),
  fCosPointingAngle(0),
  fDecayLength(0),
  fEtaV0(0),
  fPtV0(0),
  fPtPosDaughter(0),
  fPtNegDaughter(0),
  fdEdxPosDaughter(0),
  fdEdxNegDaughter(0),
  fTOFtimePosDaughter(0),
  fTOFtimeNegDaughter(0),
  fnsigmaPosL(0),
  fnsigmaNegL(0),
  fnsigmaPosAL(0),
  fnsigmaNegAL(0)
{
  // copy constructor
  if (fLambdaMass) delete fLambdaMass;
  fLambdaMass = new TH1F(*aCut.fLambdaMass);
  if (fAntiLambdaMass) delete fAntiLambdaMass;
  fAntiLambdaMass = new TH1F(*aCut.fAntiLambdaMass);
  if (fK0ShortMass) delete fK0ShortMass;
  fK0ShortMass = new TH1F(*aCut.fK0ShortMass);
  if (fDcaDaughters) delete fDcaDaughters;
  fDcaDaughters = new TH1F(*aCut.fDcaDaughters);
  if (fDcaV0ToPrimVertex) delete fDcaV0ToPrimVertex;
  fDcaV0ToPrimVertex = new TH1F(*aCut.fDcaV0ToPrimVertex);
  if (fDcaPosToPrimVertex) delete fDcaPosToPrimVertex;
  fDcaPosToPrimVertex = new TH1F(*aCut.fDcaPosToPrimVertex);
  if (fDcaNegToPrimVertex) delete fDcaNegToPrimVertex;
  fDcaNegToPrimVertex = new TH1F(*aCut.fDcaNegToPrimVertex);
  if(fCosPointingAngle) delete fCosPointingAngle;
  fCosPointingAngle = new TH1F(*aCut.fCosPointingAngle);
  if(fDecayLength) delete fDecayLength;
  fDecayLength = new TH1F(*aCut.fDecayLength);
  if(fEtaV0) delete fEtaV0;
  fEtaV0 = new TH1F(*aCut.fEtaV0);
  if(fPtV0) delete fPtV0;
  fPtV0 = new TH1F(*aCut.fPtV0);
  if(fPtPosDaughter) delete fPtPosDaughter;
  fPtPosDaughter = new TH1F(*aCut.fPtPosDaughter);
  if(fPtNegDaughter) delete fPtNegDaughter;
  fPtNegDaughter = new TH1F(*aCut.fPtNegDaughter);
  if(fdEdxPosDaughter) delete fdEdxPosDaughter;
  fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
  if(fdEdxNegDaughter) delete fdEdxNegDaughter;
  fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
  if(fTOFtimePosDaughter) delete fTOFtimePosDaughter;
  fTOFtimePosDaughter = new TH2D(*aCut.fTOFtimePosDaughter);
  if(fTOFtimeNegDaughter) delete fTOFtimeNegDaughter;
  fTOFtimeNegDaughter = new TH2D(*aCut.fTOFtimeNegDaughter);
  if(fnsigmaPosL) delete fnsigmaPosL;
  fnsigmaPosL = new TH1D(*aCut.fnsigmaPosL);
  if(fnsigmaNegL) delete fnsigmaNegL;
  fnsigmaNegL = new TH1D(*aCut.fnsigmaNegL);
  if(fnsigmaPosAL) delete fnsigmaPosAL;
  fnsigmaPosAL = new TH1D(*aCut.fnsigmaPosAL);
  if(fnsigmaNegAL) delete fnsigmaNegAL;
  fnsigmaNegAL = new TH1D(*aCut.fnsigmaNegAL);

  fLambdaMass->Sumw2();
  fAntiLambdaMass->Sumw2();
  fK0ShortMass->Sumw2();
  fDcaDaughters->Sumw2();
  fDcaV0ToPrimVertex->Sumw2();
  fDcaPosToPrimVertex->Sumw2();
  fDcaNegToPrimVertex->Sumw2();
  fCosPointingAngle->Sumw2();
  fDecayLength->Sumw2();
  fEtaV0->Sumw2();
  fPtPosDaughter->Sumw2();
  fPtNegDaughter->Sumw2();
  fdEdxPosDaughter->Sumw2();
  fdEdxNegDaughter->Sumw2();
  fTOFtimePosDaughter->Sumw2();
  fTOFtimeNegDaughter->Sumw2();
  fnsigmaPosL->Sumw2();
  fnsigmaNegL->Sumw2();
  fnsigmaPosAL->Sumw2();
  fnsigmaNegAL->Sumw2();
}

AliFemtoCutMonitorV0::~AliFemtoCutMonitorV0()
{
  // Destructor
  delete fLambdaMass;
  delete fAntiLambdaMass;
  delete fK0ShortMass;
  delete fDcaDaughters;
  delete fDcaV0ToPrimVertex;
  delete fDcaPosToPrimVertex;
  delete fDcaNegToPrimVertex;
  delete fCosPointingAngle;
  delete fDecayLength;
  delete fEtaV0;
  delete fPtV0;
  delete fPtPosDaughter;
  delete fPtNegDaughter;
  delete fdEdxPosDaughter;
  delete fdEdxNegDaughter;
  delete fTOFtimePosDaughter;
  delete fTOFtimeNegDaughter;
  delete fnsigmaPosL;
  delete fnsigmaNegL;
  delete fnsigmaPosAL;
  delete fnsigmaNegAL;
}

AliFemtoCutMonitorV0& AliFemtoCutMonitorV0::operator=(const AliFemtoCutMonitorV0& aCut)
{
  // assignment operator
  if (this == &aCut)
    return *this;

  if (fLambdaMass) delete fLambdaMass;
  fLambdaMass = new TH1F(*aCut.fLambdaMass);
  if (fAntiLambdaMass) delete fAntiLambdaMass;
  fAntiLambdaMass = new TH1F(*aCut.fAntiLambdaMass);
  if (fK0ShortMass) delete fK0ShortMass;
  fK0ShortMass = new TH1F(*aCut.fK0ShortMass);
  if (fDcaDaughters) delete fDcaDaughters;
  fDcaDaughters = new TH1F(*aCut.fDcaDaughters);
  if (fDcaV0ToPrimVertex) delete fDcaV0ToPrimVertex;
  fDcaV0ToPrimVertex = new TH1F(*aCut.fDcaV0ToPrimVertex);
  if (fDcaPosToPrimVertex) delete fDcaPosToPrimVertex;
  fDcaPosToPrimVertex = new TH1F(*aCut.fDcaPosToPrimVertex);
  if (fDcaNegToPrimVertex) delete fDcaNegToPrimVertex;
  fDcaNegToPrimVertex = new TH1F(*aCut.fDcaNegToPrimVertex);
  if(fCosPointingAngle) delete fCosPointingAngle;
  fCosPointingAngle = new TH1F(*aCut.fCosPointingAngle);
  if(fDecayLength) delete fDecayLength;
  fDecayLength = new TH1F(*aCut.fDecayLength);
  if(fEtaV0) delete fEtaV0;
  fEtaV0 = new TH1F(*aCut.fEtaV0);
  if(fPtV0) delete fPtV0;
  fPtV0 = new TH1F(*aCut.fPtV0);
  if(fPtPosDaughter) delete fPtPosDaughter;
  fPtPosDaughter = new TH1F(*aCut.fPtPosDaughter);
  if(fPtNegDaughter) delete fPtNegDaughter;
  fPtNegDaughter = new TH1F(*aCut.fPtNegDaughter);
  if(fdEdxPosDaughter) delete fdEdxPosDaughter;
  fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
  if(fdEdxNegDaughter) delete fdEdxNegDaughter;
  fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
  if(fTOFtimePosDaughter) delete fTOFtimePosDaughter;
  fTOFtimePosDaughter = new TH2D(*aCut.fTOFtimePosDaughter);
  if(fTOFtimeNegDaughter) delete fTOFtimeNegDaughter;
  fTOFtimeNegDaughter = new TH2D(*aCut.fTOFtimeNegDaughter);
  if(fnsigmaPosL) delete fnsigmaPosL;
  fnsigmaPosL = new TH1D(*aCut.fnsigmaPosL);
  if(fnsigmaNegL) delete fnsigmaNegL;
  fnsigmaNegL = new TH1D(*aCut.fnsigmaNegL);
  if(fnsigmaPosAL) delete fnsigmaPosAL;
  fnsigmaPosAL = new TH1D(*aCut.fnsigmaPosAL);
  if(fnsigmaNegAL) delete fnsigmaNegAL;
  fnsigmaNegAL = new TH1D(*aCut.fnsigmaNegAL);

  fLambdaMass->Sumw2();
  fAntiLambdaMass->Sumw2();
  fK0ShortMass->Sumw2();
  fDcaDaughters->Sumw2();
  fDcaV0ToPrimVertex->Sumw2();
  fDcaPosToPrimVertex->Sumw2();
  fDcaNegToPrimVertex->Sumw2();
  fCosPointingAngle->Sumw2();
  fDecayLength->Sumw2();
  fEtaV0->Sumw2();
  fPtPosDaughter->Sumw2();
  fPtNegDaughter->Sumw2();
  fdEdxPosDaughter->Sumw2();
  fdEdxNegDaughter->Sumw2();
  fTOFtimePosDaughter->Sumw2();
  fTOFtimeNegDaughter->Sumw2();
  fnsigmaPosL->Sumw2();
  fnsigmaNegL->Sumw2();
  fnsigmaPosAL->Sumw2();
  fnsigmaNegAL->Sumw2();

  return *this;
}

AliFemtoString AliFemtoCutMonitorV0::Report(){
  // Prepare report from the execution
  string stemp = "*** AliFemtoCutMonitorV0 report";
  AliFemtoString returnThis = stemp;
  return returnThis;
}

void AliFemtoCutMonitorV0::Fill(const AliFemtoV0* aV0)
{
  // Fill momentum resolution histograms for the particle
  fLambdaMass->Fill(aV0->MassLambda());
  fAntiLambdaMass->Fill(aV0->MassAntiLambda());
  fK0ShortMass->Fill(aV0->MassK0Short());
  fDcaDaughters->Fill(aV0->DcaV0Daughters());
  fDcaV0ToPrimVertex->Fill(aV0->DcaV0ToPrimVertex());
  fDcaPosToPrimVertex->Fill(aV0->DcaPosToPrimVertex());
  fDcaNegToPrimVertex->Fill(aV0->DcaNegToPrimVertex());
  fCosPointingAngle->Fill(aV0->CosPointingAngle());
  fDecayLength->Fill(aV0->DecayLengthV0());
  fEtaV0->Fill(aV0->EtaV0());
  fPtV0->Fill(aV0->PtV0());
  fPtPosDaughter->Fill(aV0->PtPos());
  fPtNegDaughter->Fill(aV0->PtNeg());
  fdEdxPosDaughter->Fill(aV0->GetTPCMomentumPos(),aV0->DedxPos());
  fdEdxNegDaughter->Fill(aV0->GetTPCMomentumNeg(),aV0->DedxNeg());

  fTOFtimePosDaughter->Fill(aV0->PtPos(),aV0->TOFProtonTimePos()); //true only for lambdas
  fTOFtimeNegDaughter->Fill(aV0->PtNeg(),aV0->TOFPionTimeNeg());

  fnsigmaPosL->Fill(aV0->PosNSigmaTPCP());
  fnsigmaNegL->Fill(aV0->NegNSigmaTPCPi());
  fnsigmaNegAL->Fill(aV0->NegNSigmaTPCP());
  fnsigmaPosAL->Fill(aV0->PosNSigmaTPCPi());
}

void AliFemtoCutMonitorV0::Write()
{
  // Write out the relevant histograms
  fLambdaMass->Write();
  fAntiLambdaMass->Write();
  fK0ShortMass->Write();
  fDcaDaughters->Write();
  fDcaV0ToPrimVertex->Write();
  fDcaPosToPrimVertex->Write();
  fDcaNegToPrimVertex->Write();
  fCosPointingAngle->Write();
  fDecayLength->Write();
  fEtaV0->Write();
  fPtV0->Write();
  fPtPosDaughter->Write();
  fPtNegDaughter->Write();
  fdEdxPosDaughter->Write();
  fdEdxNegDaughter->Write();
  fTOFtimePosDaughter->Write();
  fTOFtimeNegDaughter->Write();
  fnsigmaPosL->Write();
  fnsigmaNegL->Write();
  fnsigmaPosAL->Write();
  fnsigmaNegAL->Write();
}

TList *AliFemtoCutMonitorV0::GetOutputList()
{
  // Get the list of histograms to write
  TList *tOutputList = new TList();
  tOutputList->Add(fLambdaMass);
  tOutputList->Add(fAntiLambdaMass);
  tOutputList->Add(fK0ShortMass);
  tOutputList->Add(fDcaDaughters);
  tOutputList->Add(fDcaV0ToPrimVertex);
  tOutputList->Add(fDcaPosToPrimVertex);
  tOutputList->Add(fDcaNegToPrimVertex);
  tOutputList->Add(fCosPointingAngle);
  tOutputList->Add(fDecayLength);
  tOutputList->Add(fEtaV0);
  tOutputList->Add(fPtV0);
  tOutputList->Add(fPtPosDaughter);
  tOutputList->Add(fPtNegDaughter);
  tOutputList->Add(fdEdxPosDaughter);
  tOutputList->Add(fdEdxNegDaughter);
  tOutputList->Add(fTOFtimePosDaughter);
  tOutputList->Add(fTOFtimeNegDaughter);
  tOutputList->Add(fnsigmaPosL);
  tOutputList->Add(fnsigmaNegL);
  tOutputList->Add(fnsigmaPosAL);
  tOutputList->Add(fnsigmaNegAL);

  return tOutputList;
}
Commit	Line	Data
973a91f8	1	////////////////////////////////////////////////////////////////////////////////
	2	// //
	3	// AliFemtoCutMonitorV0 //
	4	// //
	5	////////////////////////////////////////////////////////////////////////////////
	6	#include "AliFemtoCutMonitorV0.h"
	7	#include <TH1D.h>
	8	#include <TH2D.h>
	9	#include <TH3D.h>
	10	#include <TList.h>
	11	#include "AliFemtoModelHiddenInfo.h"
	12
	13	AliFemtoCutMonitorV0::AliFemtoCutMonitorV0():
	14	fLambdaMass(0),
	15	fAntiLambdaMass(0),
	16	fK0ShortMass(0),
868faa19	17	fDcaDaughters(0),
973a91f8	18	fDcaV0ToPrimVertex(0),
868faa19	19	fDcaPosToPrimVertex(0),
868faa19	20	fDcaNegToPrimVertex(0),
973a91f8	21	fCosPointingAngle(0),
868faa19	22	fDecayLength(0),
973a91f8	23	fEtaV0(0),
	24	fPtV0(0),
	25	fPtPosDaughter(0),
ce7b3d98	26	fPtNegDaughter(0),
	27	fdEdxPosDaughter(0),
	28	fdEdxNegDaughter(0),
	29	fTOFtimePosDaughter(0),
	30	fTOFtimeNegDaughter(0),
	31	fnsigmaPosL(0),
	32	fnsigmaNegL(0),
	33	fnsigmaPosAL(0),
	34	fnsigmaNegAL(0)
973a91f8	35	{
	36	// Default constructor
	37	fLambdaMass = new TH1F("LambdaMass", "Mass Assuming Lambda Hypothesis", 10000, 0, 5);
	38	fAntiLambdaMass = new TH1F("AntiLambdaMass", "Mass Assuming AntiLambda Hypothesis", 10000, 0, 5);
	39	fK0ShortMass= new TH1F("K0ShortMass", "Mass Assuming K0 short Hypothesis", 500, 0, 5);
	40	fDcaDaughters = new TH1F("DcaDaughters", "DCA Daughters", 500, 0, 2);
	41	fDcaV0ToPrimVertex = new TH1F("DcaV0ToPrimVertex", "DCA V0 to primary vertex", 500, 0, 3);
868faa19	42	fDcaPosToPrimVertex = new TH1F("DcaNegToPrimVertex", "DCA V0 to primary vertex", 500, 0, 3);
868faa19	43	fDcaNegToPrimVertex = new TH1F("DcaNegToPrimVertex", "DCA V0 to primary vertex", 500, 0, 3);
973a91f8	44	fCosPointingAngle = new TH1F("CosPointingAngle","Cosinus Pointing Angle",500,0,1);
868faa19	45	fDecayLength = new TH1F("DecayLength","V0 Decay Length",100,0,100);
973a91f8	46	fEtaV0 = new TH1F("EtaV0", "\|Eta\| distribution of V0s", 500, 0.0, 8.);
	47	fPtV0 = new TH1F("PtV0", "Pt distribution of V0s", 500, 0.0, 8.);
	48	fPtPosDaughter = new TH1F("PtPosDaughter", "Pt distribution of positive daughters", 500, 0.0, 5.);
	49	fPtNegDaughter = new TH1F("PtNegDaughter", "Pt distribution of negative daughters", 500, 0.0, 5.);
	50
ce7b3d98	51	fdEdxPosDaughter = new TH2D("dEdxPosDaughter","dEdx of positive daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
	52	fdEdxNegDaughter = new TH2D("dEdxNegDaughter","dEdx of negative daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
	53	fTOFtimePosDaughter = new TH2D("TOFtimePosDaughter","TOF time of positive daughters",100,0.,1.1,100,0.,3.0);
	54	fTOFtimeNegDaughter = new TH2D("TOFtimeNegDaughter","TOF time of negative daughters",100,0.,1.1,100,0.,3.0);
	55
	56	fnsigmaPosL = new TH1D("fnsigmaPosL","Number of sigmas of positive Lambda daughters",200,-8,8);
	57	fnsigmaNegL = new TH1D("fnsigmaNegL","Number of sigmas of negative Lambda daughters",200,-8,8);
	58	fnsigmaPosAL = new TH1D("fnsigmaPosAL","Number of sigmas of positive AntiLambda daughters",200,-8,8);
	59	fnsigmaNegAL = new TH1D("fnsigmaNegAL","Number of sigmas of negative AntiLambda daughters",200,-8,8);
973a91f8	60
	61	fLambdaMass->Sumw2();
	62	fAntiLambdaMass->Sumw2();
	63	fK0ShortMass->Sumw2();
	64	fDcaDaughters->Sumw2();
	65	fDcaV0ToPrimVertex->Sumw2();
868faa19	66	fDcaPosToPrimVertex->Sumw2();
868faa19	67	fDcaNegToPrimVertex->Sumw2();
973a91f8	68	fCosPointingAngle->Sumw2();
868faa19	69	fDecayLength->Sumw2();
973a91f8	70	fEtaV0->Sumw2();
	71	fPtPosDaughter->Sumw2();
	72	fPtNegDaughter->Sumw2();
ce7b3d98	73	fdEdxPosDaughter->Sumw2();
	74	fdEdxNegDaughter->Sumw2();
	75	fTOFtimePosDaughter->Sumw2();
	76	fTOFtimeNegDaughter->Sumw2();
	77	fnsigmaPosL->Sumw2();
	78	fnsigmaNegL->Sumw2();
	79	fnsigmaPosAL->Sumw2();
	80	fnsigmaNegAL->Sumw2();
973a91f8	81	}
	82
	83	AliFemtoCutMonitorV0::AliFemtoCutMonitorV0(const char *aName):
	84	AliFemtoCutMonitor(),
	85	fLambdaMass(0),
	86	fAntiLambdaMass(0),
	87	fK0ShortMass(0),
868faa19	88	fDcaDaughters(0),
973a91f8	89	fDcaV0ToPrimVertex(0),
868faa19	90	fDcaPosToPrimVertex(0),
868faa19	91	fDcaNegToPrimVertex(0),
973a91f8	92	fCosPointingAngle(0),
868faa19	93	fDecayLength(0),
973a91f8	94	fEtaV0(0),
	95	fPtV0(0),
	96	fPtPosDaughter(0),
ce7b3d98	97	fPtNegDaughter(0),
	98	fdEdxPosDaughter(0),
	99	fdEdxNegDaughter(0),
	100	fTOFtimePosDaughter(0),
	101	fTOFtimeNegDaughter(0),
	102	fnsigmaPosL(0),
	103	fnsigmaNegL(0),
	104	fnsigmaPosAL(0),
	105	fnsigmaNegAL(0)
973a91f8	106	{
	107	// Normal constructor
	108	char name[200];
	109	snprintf(name, 200, "LambdaMass%s", aName);
	110	fLambdaMass = new TH1F(name, "Mass Assuming Lambda Hypothesis", 10000, 0, 5);
	111	snprintf(name, 200, "AntiLambdaMass%s", aName);
	112	fAntiLambdaMass = new TH1F(name, "Mass Assuming AntiLambda Hypothesis", 10000, 0, 5);
	113	snprintf(name, 200, "K0ShortMass%s", aName);
	114	fK0ShortMass = new TH1F(name, "Mass Assuming K0 short Hypothesis", 500, 0, 5);
	115	snprintf(name, 200, "DcaDaughters%s", aName);
	116	fDcaDaughters = new TH1F(name, "DCA Daughters", 500, 0, 2);
	117	snprintf(name, 200, "DcaV0ToPrimVertex%s", aName);
	118	fDcaV0ToPrimVertex = new TH1F(name, "DCA V0 to primary vertex", 500, 0, 3);
868faa19	119	snprintf(name, 200, "DcaPosToPrimVertex%s", aName);
	120	fDcaPosToPrimVertex = new TH1F(name, "DCA pos. daughter V0 to primary vertex", 500, 0, 3);
	121	snprintf(name, 200, "DcaPosToPrimVertex%s", aName);
	122	fDcaNegToPrimVertex = new TH1F(name, "DCA neg. daughter V0 to primary vertex", 500, 0, 3);
973a91f8	123	snprintf(name, 200, "CosPointingAngle%s", aName);
973a91f8	124	fCosPointingAngle = new TH1F(name,"Cosinus Pointing Angle",500,0,1);
868faa19	125	snprintf(name, 200, "DecayLength%s", aName);
868faa19	126	fDecayLength = new TH1F(name,"Decay Length",100,0,100);
973a91f8	127	snprintf(name, 200, "EtaV0%s", aName);
868faa19	128	fEtaV0 = new TH1F(name, "\|Eta\| distribution of V0s", 500, 0.0, 1.);
973a91f8	129	snprintf(name, 200, "PtV0%s", aName);
868faa19	130	fPtV0 = new TH1F(name, "Pt distribution of V0s", 500, 0.0, 8.);
973a91f8	131	snprintf(name, 200, "fPtPosDaughter%s", aName);
	132	fPtPosDaughter = new TH1F(name, "Pt distribution of positive daughters", 500, 0.0, 5.);
	133	snprintf(name, 200, "fPtNegDaughter%s", aName);
	134	fPtNegDaughter = new TH1F(name, "Pt distribution of negative daughters", 500, 0.0, 5.);
ce7b3d98	135	snprintf(name, 200, "fdEdxPosDaughter%s", aName);
	136	fdEdxPosDaughter = new TH2D(name,"dEdx of positive daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
	137	snprintf(name, 200, "fdEdxNegDaughter%s", aName);
	138	fdEdxNegDaughter = new TH2D(name,"dEdx of negative daughters",200, 0.1, 4.0, 250, 0.0, 500.0);
	139	snprintf(name, 200, "fTOFtimePosDaughter%s", aName);
	140	fTOFtimePosDaughter = new TH2D(name,"TOF time of positive daughters",190, 0.1, 2.0, 400, -4000.0, 4000.0);
	141	snprintf(name, 200, " fTOFtimeNegDaughter%s", aName);
	142	fTOFtimeNegDaughter = new TH2D(name,"TOF time of negative daughters",190, 0.1, 2.0, 400, -4000.0, 4000.0);
	143	snprintf(name, 200, " fnsigmaPosL%s", aName);
	144	fnsigmaPosL = new TH1D(name,"Number of sigmas of positive Lambda daughters",200,-10,10);
	145	snprintf(name, 200, " fnsigmaNegL%s", aName);
	146	fnsigmaNegL = new TH1D(name,"Number of sigmas of negative Lambda daughters",200,-10,10);
	147	snprintf(name, 200, " fnsigmaPosAL%s", aName);
	148	fnsigmaPosAL = new TH1D(name,"Number of sigmas of positive AntiLambda daughters",200,-10,10);
	149	snprintf(name, 200, " fnsigmaNegAL%s", aName);
	150	fnsigmaNegAL = new TH1D(name,"Number of sigmas of negative AntiLambda daughters",200,-10,10);
973a91f8	151
	152	fLambdaMass->Sumw2();
	153	fAntiLambdaMass->Sumw2();
	154	fK0ShortMass->Sumw2();
	155	fDcaDaughters->Sumw2();
	156	fDcaV0ToPrimVertex->Sumw2();
868faa19	157	fDcaPosToPrimVertex->Sumw2();
868faa19	158	fDcaNegToPrimVertex->Sumw2();
973a91f8	159	fCosPointingAngle->Sumw2();
868faa19	160	fDecayLength->Sumw2();
973a91f8	161	fEtaV0->Sumw2();
	162	fPtPosDaughter->Sumw2();
	163	fPtNegDaughter->Sumw2();
ce7b3d98	164	fdEdxPosDaughter->Sumw2();
	165	fdEdxNegDaughter->Sumw2();
	166	fTOFtimePosDaughter->Sumw2();
	167	fTOFtimeNegDaughter->Sumw2();
	168	fnsigmaPosL->Sumw2();
	169	fnsigmaNegL->Sumw2();
	170	fnsigmaPosAL->Sumw2();
	171	fnsigmaNegAL->Sumw2();
973a91f8	172	}
	173
	174	AliFemtoCutMonitorV0::AliFemtoCutMonitorV0(const AliFemtoCutMonitorV0 &aCut):
	175	AliFemtoCutMonitor(),
	176	fLambdaMass(0),
	177	fAntiLambdaMass(0),
	178	fK0ShortMass(0),
868faa19	179	fDcaDaughters(0),
973a91f8	180	fDcaV0ToPrimVertex(0),
868faa19	181	fDcaPosToPrimVertex(0),
868faa19	182	fDcaNegToPrimVertex(0),
973a91f8	183	fCosPointingAngle(0),
868faa19	184	fDecayLength(0),
973a91f8	185	fEtaV0(0),
	186	fPtV0(0),
	187	fPtPosDaughter(0),
ce7b3d98	188	fPtNegDaughter(0),
	189	fdEdxPosDaughter(0),
	190	fdEdxNegDaughter(0),
	191	fTOFtimePosDaughter(0),
	192	fTOFtimeNegDaughter(0),
	193	fnsigmaPosL(0),
	194	fnsigmaNegL(0),
	195	fnsigmaPosAL(0),
	196	fnsigmaNegAL(0)
973a91f8	197	{
	198	// copy constructor
	199	if (fLambdaMass) delete fLambdaMass;
	200	fLambdaMass = new TH1F(*aCut.fLambdaMass);
	201	if (fAntiLambdaMass) delete fAntiLambdaMass;
	202	fAntiLambdaMass = new TH1F(*aCut.fAntiLambdaMass);
	203	if (fK0ShortMass) delete fK0ShortMass;
	204	fK0ShortMass = new TH1F(*aCut.fK0ShortMass);
	205	if (fDcaDaughters) delete fDcaDaughters;
	206	fDcaDaughters = new TH1F(*aCut.fDcaDaughters);
	207	if (fDcaV0ToPrimVertex) delete fDcaV0ToPrimVertex;
	208	fDcaV0ToPrimVertex = new TH1F(*aCut.fDcaV0ToPrimVertex);
868faa19	209	if (fDcaPosToPrimVertex) delete fDcaPosToPrimVertex;
	210	fDcaPosToPrimVertex = new TH1F(*aCut.fDcaPosToPrimVertex);
	211	if (fDcaNegToPrimVertex) delete fDcaNegToPrimVertex;
	212	fDcaNegToPrimVertex = new TH1F(*aCut.fDcaNegToPrimVertex);
973a91f8	213	if(fCosPointingAngle) delete fCosPointingAngle;
973a91f8	214	fCosPointingAngle = new TH1F(*aCut.fCosPointingAngle);
868faa19	215	if(fDecayLength) delete fDecayLength;
868faa19	216	fDecayLength = new TH1F(*aCut.fDecayLength);
973a91f8	217	if(fEtaV0) delete fEtaV0;
	218	fEtaV0 = new TH1F(*aCut.fEtaV0);
	219	if(fPtV0) delete fPtV0;
	220	fPtV0 = new TH1F(*aCut.fPtV0);
	221	if(fPtPosDaughter) delete fPtPosDaughter;
	222	fPtPosDaughter = new TH1F(*aCut.fPtPosDaughter);
	223	if(fPtNegDaughter) delete fPtNegDaughter;
	224	fPtNegDaughter = new TH1F(*aCut.fPtNegDaughter);
ce7b3d98	225	if(fdEdxPosDaughter) delete fdEdxPosDaughter;
	226	fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
	227	if(fdEdxNegDaughter) delete fdEdxNegDaughter;
	228	fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
	229	if(fTOFtimePosDaughter) delete fTOFtimePosDaughter;
	230	fTOFtimePosDaughter = new TH2D(*aCut.fTOFtimePosDaughter);
	231	if(fTOFtimeNegDaughter) delete fTOFtimeNegDaughter;
	232	fTOFtimeNegDaughter = new TH2D(*aCut.fTOFtimeNegDaughter);
	233	if(fnsigmaPosL) delete fnsigmaPosL;
	234	fnsigmaPosL = new TH1D(*aCut.fnsigmaPosL);
	235	if(fnsigmaNegL) delete fnsigmaNegL;
	236	fnsigmaNegL = new TH1D(*aCut.fnsigmaNegL);
	237	if(fnsigmaPosAL) delete fnsigmaPosAL;
	238	fnsigmaPosAL = new TH1D(*aCut.fnsigmaPosAL);
	239	if(fnsigmaNegAL) delete fnsigmaNegAL;
	240	fnsigmaNegAL = new TH1D(*aCut.fnsigmaNegAL);
973a91f8	241
	242	fLambdaMass->Sumw2();
	243	fAntiLambdaMass->Sumw2();
	244	fK0ShortMass->Sumw2();
	245	fDcaDaughters->Sumw2();
	246	fDcaV0ToPrimVertex->Sumw2();
868faa19	247	fDcaPosToPrimVertex->Sumw2();
868faa19	248	fDcaNegToPrimVertex->Sumw2();
973a91f8	249	fCosPointingAngle->Sumw2();
868faa19	250	fDecayLength->Sumw2();
973a91f8	251	fEtaV0->Sumw2();
	252	fPtPosDaughter->Sumw2();
	253	fPtNegDaughter->Sumw2();
ce7b3d98	254	fdEdxPosDaughter->Sumw2();
	255	fdEdxNegDaughter->Sumw2();
	256	fTOFtimePosDaughter->Sumw2();
	257	fTOFtimeNegDaughter->Sumw2();
	258	fnsigmaPosL->Sumw2();
	259	fnsigmaNegL->Sumw2();
	260	fnsigmaPosAL->Sumw2();
	261	fnsigmaNegAL->Sumw2();
973a91f8	262	}
	263
	264	AliFemtoCutMonitorV0::~AliFemtoCutMonitorV0()
	265	{
	266	// Destructor
	267	delete fLambdaMass;
	268	delete fAntiLambdaMass;
	269	delete fK0ShortMass;
868faa19	270	delete fDcaDaughters;
973a91f8	271	delete fDcaV0ToPrimVertex;
868faa19	272	delete fDcaPosToPrimVertex;
868faa19	273	delete fDcaNegToPrimVertex;
973a91f8	274	delete fCosPointingAngle;
868faa19	275	delete fDecayLength;
973a91f8	276	delete fEtaV0;
	277	delete fPtV0;
	278	delete fPtPosDaughter;
	279	delete fPtNegDaughter;
ce7b3d98	280	delete fdEdxPosDaughter;
	281	delete fdEdxNegDaughter;
	282	delete fTOFtimePosDaughter;
	283	delete fTOFtimeNegDaughter;
	284	delete fnsigmaPosL;
	285	delete fnsigmaNegL;
	286	delete fnsigmaPosAL;
	287	delete fnsigmaNegAL;
973a91f8	288	}
	289
	290	AliFemtoCutMonitorV0& AliFemtoCutMonitorV0::operator=(const AliFemtoCutMonitorV0& aCut)
	291	{
	292	// assignment operator
868faa19	293	if (this == &aCut)
973a91f8	294	return *this;
	295
	296	if (fLambdaMass) delete fLambdaMass;
	297	fLambdaMass = new TH1F(*aCut.fLambdaMass);
	298	if (fAntiLambdaMass) delete fAntiLambdaMass;
	299	fAntiLambdaMass = new TH1F(*aCut.fAntiLambdaMass);
	300	if (fK0ShortMass) delete fK0ShortMass;
	301	fK0ShortMass = new TH1F(*aCut.fK0ShortMass);
	302	if (fDcaDaughters) delete fDcaDaughters;
	303	fDcaDaughters = new TH1F(*aCut.fDcaDaughters);
	304	if (fDcaV0ToPrimVertex) delete fDcaV0ToPrimVertex;
	305	fDcaV0ToPrimVertex = new TH1F(*aCut.fDcaV0ToPrimVertex);
868faa19	306	if (fDcaPosToPrimVertex) delete fDcaPosToPrimVertex;
	307	fDcaPosToPrimVertex = new TH1F(*aCut.fDcaPosToPrimVertex);
	308	if (fDcaNegToPrimVertex) delete fDcaNegToPrimVertex;
	309	fDcaNegToPrimVertex = new TH1F(*aCut.fDcaNegToPrimVertex);
973a91f8	310	if(fCosPointingAngle) delete fCosPointingAngle;
973a91f8	311	fCosPointingAngle = new TH1F(*aCut.fCosPointingAngle);
868faa19	312	if(fDecayLength) delete fDecayLength;
868faa19	313	fDecayLength = new TH1F(*aCut.fDecayLength);
973a91f8	314	if(fEtaV0) delete fEtaV0;
	315	fEtaV0 = new TH1F(*aCut.fEtaV0);
	316	if(fPtV0) delete fPtV0;
	317	fPtV0 = new TH1F(*aCut.fPtV0);
	318	if(fPtPosDaughter) delete fPtPosDaughter;
	319	fPtPosDaughter = new TH1F(*aCut.fPtPosDaughter);
	320	if(fPtNegDaughter) delete fPtNegDaughter;
	321	fPtNegDaughter = new TH1F(*aCut.fPtNegDaughter);
ce7b3d98	322	if(fdEdxPosDaughter) delete fdEdxPosDaughter;
	323	fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
	324	if(fdEdxNegDaughter) delete fdEdxNegDaughter;
	325	fdEdxNegDaughter = new TH2D(*aCut.fdEdxNegDaughter);
	326	if(fTOFtimePosDaughter) delete fTOFtimePosDaughter;
	327	fTOFtimePosDaughter = new TH2D(*aCut.fTOFtimePosDaughter);
	328	if(fTOFtimeNegDaughter) delete fTOFtimeNegDaughter;
	329	fTOFtimeNegDaughter = new TH2D(*aCut.fTOFtimeNegDaughter);
	330	if(fnsigmaPosL) delete fnsigmaPosL;
	331	fnsigmaPosL = new TH1D(*aCut.fnsigmaPosL);
	332	if(fnsigmaNegL) delete fnsigmaNegL;
	333	fnsigmaNegL = new TH1D(*aCut.fnsigmaNegL);
	334	if(fnsigmaPosAL) delete fnsigmaPosAL;
	335	fnsigmaPosAL = new TH1D(*aCut.fnsigmaPosAL);
	336	if(fnsigmaNegAL) delete fnsigmaNegAL;
	337	fnsigmaNegAL = new TH1D(*aCut.fnsigmaNegAL);
973a91f8	338
	339	fLambdaMass->Sumw2();
	340	fAntiLambdaMass->Sumw2();
	341	fK0ShortMass->Sumw2();
	342	fDcaDaughters->Sumw2();
	343	fDcaV0ToPrimVertex->Sumw2();
868faa19	344	fDcaPosToPrimVertex->Sumw2();
868faa19	345	fDcaNegToPrimVertex->Sumw2();
973a91f8	346	fCosPointingAngle->Sumw2();
868faa19	347	fDecayLength->Sumw2();
973a91f8	348	fEtaV0->Sumw2();
	349	fPtPosDaughter->Sumw2();
	350	fPtNegDaughter->Sumw2();
ce7b3d98	351	fdEdxPosDaughter->Sumw2();
	352	fdEdxNegDaughter->Sumw2();
	353	fTOFtimePosDaughter->Sumw2();
	354	fTOFtimeNegDaughter->Sumw2();
	355	fnsigmaPosL->Sumw2();
	356	fnsigmaNegL->Sumw2();
	357	fnsigmaPosAL->Sumw2();
	358	fnsigmaNegAL->Sumw2();
973a91f8	359
	360	return *this;
	361	}
	362
868faa19	363	AliFemtoString AliFemtoCutMonitorV0::Report(){
973a91f8	364	// Prepare report from the execution
868faa19	365	string stemp = "*** AliFemtoCutMonitorV0 report";
973a91f8	366	AliFemtoString returnThis = stemp;
868faa19	367	return returnThis;
973a91f8	368	}
	369
	370	void AliFemtoCutMonitorV0::Fill(const AliFemtoV0* aV0)
	371	{
	372	// Fill momentum resolution histograms for the particle
	373	fLambdaMass->Fill(aV0->MassLambda());
	374	fAntiLambdaMass->Fill(aV0->MassAntiLambda());
	375	fK0ShortMass->Fill(aV0->MassK0Short());
868faa19	376	fDcaDaughters->Fill(aV0->DcaV0Daughters());
973a91f8	377	fDcaV0ToPrimVertex->Fill(aV0->DcaV0ToPrimVertex());
868faa19	378	fDcaPosToPrimVertex->Fill(aV0->DcaPosToPrimVertex());
868faa19	379	fDcaNegToPrimVertex->Fill(aV0->DcaNegToPrimVertex());
973a91f8	380	fCosPointingAngle->Fill(aV0->CosPointingAngle());
868faa19	381	fDecayLength->Fill(aV0->DecayLengthV0());
973a91f8	382	fEtaV0->Fill(aV0->EtaV0());
	383	fPtV0->Fill(aV0->PtV0());
	384	fPtPosDaughter->Fill(aV0->PtPos());
	385	fPtNegDaughter->Fill(aV0->PtNeg());
ce7b3d98	386	fdEdxPosDaughter->Fill(aV0->GetTPCMomentumPos(),aV0->DedxPos());
	387	fdEdxNegDaughter->Fill(aV0->GetTPCMomentumNeg(),aV0->DedxNeg());
	388
	389	fTOFtimePosDaughter->Fill(aV0->PtPos(),aV0->TOFProtonTimePos()); //true only for lambdas
	390	fTOFtimeNegDaughter->Fill(aV0->PtNeg(),aV0->TOFPionTimeNeg());
868faa19	391
ce7b3d98	392	fnsigmaPosL->Fill(aV0->PosNSigmaTPCP());
	393	fnsigmaNegL->Fill(aV0->NegNSigmaTPCPi());
	394	fnsigmaNegAL->Fill(aV0->NegNSigmaTPCP());
	395	fnsigmaPosAL->Fill(aV0->PosNSigmaTPCPi());
973a91f8	396	}
	397
	398	void AliFemtoCutMonitorV0::Write()
	399	{
	400	// Write out the relevant histograms
	401	fLambdaMass->Write();
	402	fAntiLambdaMass->Write();
	403	fK0ShortMass->Write();
	404	fDcaDaughters->Write();
	405	fDcaV0ToPrimVertex->Write();
868faa19	406	fDcaPosToPrimVertex->Write();
868faa19	407	fDcaNegToPrimVertex->Write();
973a91f8	408	fCosPointingAngle->Write();
868faa19	409	fDecayLength->Write();
973a91f8	410	fEtaV0->Write();
	411	fPtV0->Write();
	412	fPtPosDaughter->Write();
	413	fPtNegDaughter->Write();
ce7b3d98	414	fdEdxPosDaughter->Write();
	415	fdEdxNegDaughter->Write();
	416	fTOFtimePosDaughter->Write();
	417	fTOFtimeNegDaughter->Write();
	418	fnsigmaPosL->Write();
	419	fnsigmaNegL->Write();
	420	fnsigmaPosAL->Write();
	421	fnsigmaNegAL->Write();
973a91f8	422	}
	423
	424	TList *AliFemtoCutMonitorV0::GetOutputList()
	425	{
	426	// Get the list of histograms to write
	427	TList *tOutputList = new TList();
	428	tOutputList->Add(fLambdaMass);
	429	tOutputList->Add(fAntiLambdaMass);
	430	tOutputList->Add(fK0ShortMass);
	431	tOutputList->Add(fDcaDaughters);
	432	tOutputList->Add(fDcaV0ToPrimVertex);
868faa19	433	tOutputList->Add(fDcaPosToPrimVertex);
868faa19	434	tOutputList->Add(fDcaNegToPrimVertex);
973a91f8	435	tOutputList->Add(fCosPointingAngle);
868faa19	436	tOutputList->Add(fDecayLength);
973a91f8	437	tOutputList->Add(fEtaV0);
	438	tOutputList->Add(fPtV0);
	439	tOutputList->Add(fPtPosDaughter);
	440	tOutputList->Add(fPtNegDaughter);
ce7b3d98	441	tOutputList->Add(fdEdxPosDaughter);
	442	tOutputList->Add(fdEdxNegDaughter);
	443	tOutputList->Add(fTOFtimePosDaughter);
	444	tOutputList->Add(fTOFtimeNegDaughter);
	445	tOutputList->Add(fnsigmaPosL);
	446	tOutputList->Add(fnsigmaNegL);
	447	tOutputList->Add(fnsigmaPosAL);
	448	tOutputList->Add(fnsigmaNegAL);
973a91f8	449
	450	return tOutputList;
	451	}