ROOT logo
/**************************************************************************
 * Authors : Massimo Venaruzzo (massimo.venaruzzo@ts.infn.it)             *
 *      Enrico Fragiacomo (enrico.fragiacomo@ts.infn.it)             *
 * Contributors are mentioned in the code where appropriate.              *
 *                                                                        *
 * Permission to use, copy, modify and distribute this software and its   *
 * documentation strictly for non-commercial purposes is hereby granted   *
 * without fee, provided that the above copyright notice appears in all   *
 * copies and that both the copyright notice and this permission notice   *
 * appear in the supporting documentation. The authors make no claims     *
 * about the suitability of this software for any purpose. It is          *
 * provided "as is" without express or implied warranty.                  *
 **************************************************************************/

//-----------------------------------------------------------------
//                 AliAnalysisTaskSigma1385 class
//-----------------------------------------------------------------

class TTree;
class TParticle;
class TVector3;

#include "AliAnalysisManager.h"
#include <AliMCEventHandler.h>
#include <AliMCEvent.h>
#include <AliStack.h>

class AliESDVertex;
class AliESDv0;
class AliAODv0;

#include <iostream>

#include "TList.h"
#include "TH1.h"
#include "TNtuple.h"
#include "TGraph.h"
#include "TCanvas.h"
#include "TMath.h"
#include "TChain.h"
#include "AliLog.h"
#include "AliESDEvent.h"
#include "AliAODEvent.h"
#include "AliCascadeVertexer.h"
#include "AliESDcascade.h"
#include "AliAODcascade.h"
#include "AliAnalysisTaskSigma1385.h"
#include "AliESDtrackCuts.h"
#include "AliESDpid.h"
#include "AliTOFT0maker.h"
#include "AliTOFcalib.h"
#include "AliCDBManager.h"
#include "AliESDtrackCuts.h"

ClassImp(AliAnalysisTaskSigma1385)

//________________________________________________________________________
AliAnalysisTaskSigma1385::AliAnalysisTaskSigma1385()
   : AliAnalysisTaskSE(),
     
     //-------------------------------- For PID
     
     fisMC(0),
     fIsMC(fisMC),
     fCheckITS(kTRUE),
     fCheckTPC(kTRUE),
     fCheckTOF(kTRUE),
     fUseGlobal(kTRUE),
     fUseITSSA(kTRUE),
     fMaxITSband(3.0),
     fTPCpLimit(0.35),
     fTPCpar(),
     fMinTPCband(3.0),
     fMaxTPCband(5.0),
     fESDpid(0x0),
     fTOFmaker(0x0),
     fTOFcalib(0x0),
     fTOFcalibrateESD(!fisMC),
     fTOFcorrectTExp(kTRUE),
     fTOFuseT0(kTRUE),
     fTOFtuneMC(fisMC),
     fTOFresolution(100.0),
     fMinTOF(-2.5),
     fMaxTOF(3.5),
     fLastRun(-1),
     fOkTrack(),
     fAnalysisType("ESD"), fCollidingSystems(0), fDataType("REAL"), fListHistCascade(0), 
     fHistEventMultiplicity(0), fHistEventMultiplicityRAVS(0), 
     fNtuple1(0), fNtuple2(0), fNtuple3(0), fNtuple4(0)
 


     //--------------------------------

{
   // Dummy Constructor
   Int_t i;
   for (i = 0; i < 5; i++) fOkTrack[i] = kFALSE;
}

//________________________________________________________________________
AliAnalysisTaskSigma1385::AliAnalysisTaskSigma1385(const char *name)
   : AliAnalysisTaskSE(name),
       

     //-------------------------------- For PID

     fisMC(0),
     fIsMC(fisMC),
     fCheckITS(kTRUE),
     fCheckTPC(kTRUE),
     fCheckTOF(kTRUE),
     fUseGlobal(kTRUE),
     fUseITSSA(kTRUE),
     fMaxITSband(3.0),
     fTPCpLimit(0.35),
     fTPCpar(),
     fMinTPCband(3.0),
     fMaxTPCband(5.0),
     fESDpid(0x0),
     fTOFmaker(0x0),
     fTOFcalib(0x0),
     fTOFcalibrateESD(!fisMC),
     fTOFcorrectTExp(kTRUE),
     fTOFuseT0(kTRUE),
     fTOFtuneMC(fisMC),
     fTOFresolution(100.0),
     fMinTOF(-2.5),
     fMaxTOF(3.5),
     fLastRun(-1),
     fOkTrack(),
     fAnalysisType("ESD"), fCollidingSystems(0), fDataType("REAL"), fListHistCascade(0), 
     fHistEventMultiplicity(0), fHistEventMultiplicityRAVS(0), 
     fNtuple1(0), fNtuple2(0), fNtuple3(0), fNtuple4(0)

     //--------------------------------
{

   // Output slot #0 writes into a TList container (Cascade)
   DefineOutput(1, TList::Class());
   
   Int_t i;
   for (i = 0; i < 5; i++) fOkTrack[i] = kFALSE;
}

//________________________________________________________________________
void AliAnalysisTaskSigma1385::UserCreateOutputObjects()
{
   fListHistCascade = new TList();

   if (! fHistEventMultiplicity) {
      fHistEventMultiplicity   = new TH1F("fHistEventMultiplicity" , "Nb of Events" , 4, -1.0, 3.0);
      fListHistCascade->Add(fHistEventMultiplicity);
   }

   if (! fHistEventMultiplicityRAVS) {
      fHistEventMultiplicityRAVS   = new TH1F("fHistEventMultiplicityRAVS" , "Nb of Events Rejected After Vertex selection" , 4, -1.0, 3.0);
      fListHistCascade->Add(fHistEventMultiplicityRAVS);
   }

   if (! fNtuple1) {
      fNtuple1 = new TNtuple("fNtuple1", "Ntuple1", "TrkNmb");
      fNtuple1->SetDirectory(0);
      fListHistCascade->Add(fNtuple1);
   }

   if (! fNtuple2) {
      fNtuple2 = new TNtuple("fNtuple2", "Ntuple2", "s:dcal:lCosPoinAn:lDaugDCA:lambdap:lambdapt:lambdamass");
      fNtuple2->SetDirectory(0);
      fListHistCascade->Add(fNtuple2);
   }

   if (! fNtuple3) {
      fNtuple3 = new TNtuple("fNtuple3", "Ntuple3", "c:dcapi:ppi:ptpi:bachphi:bachtheta:okPiTPC:okPiTOF");
      fNtuple3->SetDirectory(0);
      fListHistCascade->Add(fNtuple3);
   }

   if (! fNtuple4) {
      fNtuple4 = new TNtuple("fNtuple4", "Ntuple4", "dca:mc:phi:theta:eta:y:pt:p:opang:invmass");
      fListHistCascade->Add(fNtuple4);
   }


}// end UserCreateOutputObjects


//________________________________________________________________________
void AliAnalysisTaskSigma1385::UserExec(Option_t *)
{

   // Main loop
   // Called for each event


   Info("AliAnalysisTaskSigma1385", "Starting UserExec");

   AliMCEventHandler* eventHandler;
   AliMCEvent* mcEvent = 0;

   if (fDataType == "SIM") {

      eventHandler = dynamic_cast<AliMCEventHandler*>(AliAnalysisManager::GetAnalysisManager()->GetMCtruthEventHandler());
      if (!eventHandler) {
         Printf("ERROR: Could not retrieve MC event handler");
         return;
      }

      mcEvent = eventHandler->MCEvent();
      if (!mcEvent) {
         Printf("ERROR: Could not retrieve MC event");
         return;
      }

   }

   AliStack* stack = 0;
   if (fDataType == "SIM") {stack = mcEvent->Stack(); fIsMC = 1; fisMC = 1;}

   AliESDEvent *lESDevent = 0x0;
   AliAODEvent *lAODevent = 0x0;


   // Connect to the InputEvent
   Int_t ncascades = -1;
   if (fAnalysisType == "ESD") {
      lESDevent = dynamic_cast<AliESDEvent*>(InputEvent());
      if (lESDevent) 
         ncascades = lESDevent->GetNumberOfCascades();
      else {
         Printf("ERROR: lESDevent not available \n");
         return;
      }
   } else if (fAnalysisType == "AOD") {
      lAODevent = dynamic_cast<AliAODEvent*>(InputEvent());
      if (lAODevent) 
         ncascades = lAODevent->GetNumberOfCascades();
      else {
         Printf("ERROR: lAODevent not available \n");
         return;
      }
   } else {
      Printf("Input type undefined \n");
      return;
   }


   //------------------------------for PID

   SetCheckITS(kTRUE);
   SetCheckTPC(kTRUE);
   SetCheckTOF(kTRUE);

// ----> set TPC range for PID and calibration
   SetTPCrange(5.0, 3.0);
   SetTPCpLimit(0.35);

   // ----> set ITS range for PID
   SetITSband(4.0);

   // ----> set TPC calibration
   if (fDataType == "SIM") SetTPCpar(2.15898 / 50.0, 1.75295E1, 3.40030E-9, 1.96178, 3.91720);
   else       SetTPCpar(1.41543 / 50.0, 2.63394E1, 5.0411E-11, 2.12543, 4.88663);

   // ----> set the TOF calibration depending on type of input (sim/data)
   SetTOFcorrectTExp(kTRUE);
   SetTOFuseT0(kTRUE);
   SetTOFresolution(100.0);
   if (fDataType == "SIM") {
      SetTOFcalibrateESD(kFALSE);
      SetTOFtuneMC(kTRUE);
   } else {

      SetTOFcalibrateESD(kTRUE);
      SetTOFtuneMC(kFALSE);
   }


   if (!fESDpid) {
      fESDpid = new AliESDpid;
      fESDpid->GetTPCResponse().SetBetheBlochParameters(fTPCpar[0], fTPCpar[1], fTPCpar[2], fTPCpar[3], fTPCpar[4]);
   }

   // initialize DB to current run
   if (!lESDevent) {
      Printf("ERROR: lESDevent not available \n");
      return;
   }
   Int_t run = lESDevent->GetRunNumber();
   if (run != fLastRun) {
      //cout << "Run = " << run << " -- LAST = " << fLastRun << endl;
      fLastRun = run;

      // setup TOF maker & calibration
      if (!fTOFcalib) fTOFcalib = new AliTOFcalib;
      fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
      if (!fTOFmaker) fTOFmaker = new AliTOFT0maker(fESDpid, fTOFcalib);
      fTOFmaker->SetTimeResolution(fTOFresolution);

      AliCDBManager *cdb = AliCDBManager::Instance();
      cdb->ClearCache(); // suggestion by Annalisa
      cdb->Clear();      // suggestion by Annalisa
      cdb->SetDefaultStorage("raw://");
      cdb->SetRun(run);
      fTOFcalib->SetCorrectTExp(fTOFcorrectTExp);
      fTOFcalib->Init();
   }

   // if required, calibrate the TOF t0 maker with current event
   if (fTOFcalibrateESD) fTOFcalib->CalibrateESD(lESDevent);
   if (fTOFtuneMC) fTOFmaker->TuneForMC(lESDevent);
   if (fTOFuseT0) {
      fTOFmaker->ComputeT0TOF(lESDevent);
      fTOFmaker->ApplyT0TOF(lESDevent);
      fESDpid->MakePID(lESDevent, kFALSE, 0.);
   }


   //--------------------------------------------------------


   fHistEventMultiplicity->Fill(1);

   //Some Quantities to characterize the event

   Double_t b = lESDevent->GetMagneticField();
   Int_t trackNumber = lESDevent->GetNumberOfTracks();


   //---------------------------
   // new part from AliCascadeVertexer (use vertexer for reconstructing Sigma(1385)
   //
   //const AliESDVertex *vtxT3D=lESDevent->GetPrimaryVertex();
   const AliESDVertex *vtxT3D = lESDevent->GetPrimaryVertexTracks();
   if (vtxT3D->GetNContributors() < 1) {
      // SPD vertex
      vtxT3D = lESDevent->GetPrimaryVertexSPD();
      if (vtxT3D->GetNContributors() < 1) {


         fHistEventMultiplicityRAVS->Fill(1);
         return;
      }


   }

   Double_t xPrimaryVertex = vtxT3D->GetX();
   Double_t yPrimaryVertex = vtxT3D->GetY();
   Double_t zPrimaryVertex = vtxT3D->GetZ();

   if (zPrimaryVertex > 10 || zPrimaryVertex < -10)  return;

   //-------------------------------------------------------
   // New Part about tracks global selection criteria
   //-------------------------------------------------------

   AliESDtrackCuts* esdTrackCuts = new AliESDtrackCuts("AliESDtrackCuts");

   esdTrackCuts->SetAcceptKinkDaughters(0); // 0 = kFalse
   esdTrackCuts->SetClusterRequirementITS(AliESDtrackCuts::kSPD, AliESDtrackCuts::kAny);
   esdTrackCuts->SetMaxChi2PerClusterTPC(4);
   esdTrackCuts->SetMinNClustersTPC(70);


   //-------------------------------------------------------
   // loops over V0s
   //stores relevant V0s in an array
   Int_t nV0 = (Int_t)lESDevent->GetNumberOfV0s();

   TObjArray vtcs(nV0);
   for (Int_t i = 0; i < nV0; i++) {
      AliESDv0 *v = lESDevent->GetV0(i);
      if (v->GetOnFlyStatus()) continue; // if kTRUE, then this V0 is recontructed

      vtcs.AddLast(v);
   }
   nV0 = vtcs.GetEntriesFast();

   //-------------------------------------------------------
   // loops over bachelor tracks
   // stores relevant tracks in another array

   Int_t nentr = (Int_t)lESDevent->GetNumberOfTracks();
   TArrayI trk(nentr); Int_t ntr = 0;

   for (Int_t i = 0; i < nentr; i++) {
      AliESDtrack *esdtr = lESDevent->GetTrack(i);

      if (!(esdtr->GetStatus() & AliESDtrack::kITSrefit)) continue;
      if (!(esdtr->GetStatus() & AliESDtrack::kTPCrefit)) continue;


      if (!(esdTrackCuts->AcceptTrack(esdtr))) continue;

      trk[ntr++] = i;
   }



   //-----------------------------------------------------
   // nested loops over V0s and bachelors
   Float_t massLambda = 1.11568;
   Int_t ncasc = 0;
   AliCascadeVertexer *cascvert = new AliCascadeVertexer();
   for (Int_t i = 0; i < nV0; i++) { //loop on V0s

      // Lambda
      AliESDv0 *v = (AliESDv0*)vtcs.UncheckedAt(i);
      Int_t strness = 0;
      Double_t lambdaMass = 0;
      Float_t lambdaP = 0;
      Float_t lambdaPt = 0;
      Float_t lambdaDCA = 0; // DCA between Lambda and Primary Vertex
      Double_t v0cospointangle = 0;
      Float_t v0daughtersDCA = 0;


      // Lambda quality cuts
      UInt_t lIdxPosXi    = (UInt_t) TMath::Abs(v->GetPindex());
      UInt_t lIdxNegXi    = (UInt_t) TMath::Abs(v->GetNindex());

      AliESDtrack *pTrackXi     = lESDevent->GetTrack(lIdxPosXi);
      AliESDtrack *nTrackXi     = lESDevent->GetTrack(lIdxNegXi);

      // Filter like-sign V0
      if ( (TMath::Abs(pTrackXi->GetSign()) - TMath::Abs(nTrackXi->GetSign()) ) < 0.1) continue;

      // WARNING: the following selections cannot be done for AOD yet...


      v->ChangeMassHypothesis(kLambda0); // the v0 must be Lambda


      if ((TMath::Abs(v->GetEffMass() - massLambda)) < 0.2) {

         if (!(pTrackXi->GetStatus() & AliESDtrack::kTPCrefit))  continue;
         if (!(nTrackXi->GetStatus() & AliESDtrack::kTPCrefit))  continue;


         if ((pTrackXi->GetTPCNcls()) < 70) continue;
         if ((nTrackXi->GetTPCNcls()) < 70) continue;

         strness = 1; lambdaMass = v->GetEffMass(); lambdaP = v->P(); lambdaPt = v->Pt(); lambdaDCA = v->GetD(xPrimaryVertex, yPrimaryVertex, zPrimaryVertex); v0cospointangle = v->GetV0CosineOfPointingAngle(); v0daughtersDCA = v->GetDcaV0Daughters();



      }


      v->ChangeMassHypothesis(kLambda0Bar); // the v0 must be Anti Lambda



      if ((TMath::Abs(v->GetEffMass() - massLambda)) < 0.2) {

         if (!(pTrackXi->GetStatus() & AliESDtrack::kTPCrefit))  continue;
         if (!(nTrackXi->GetStatus() & AliESDtrack::kTPCrefit))  continue;


         if ((pTrackXi->GetTPCNcls()) < 70) continue;
         if ((nTrackXi->GetTPCNcls()) < 70) continue;

         Int_t temp = strness + 1; strness = -1 * temp; lambdaMass = v->GetEffMass(); lambdaP = v->P(); lambdaPt = v->Pt(); lambdaDCA = v->GetD(xPrimaryVertex, yPrimaryVertex, zPrimaryVertex); v0cospointangle = v->GetV0CosineOfPointingAngle(); v0daughtersDCA = v->GetDcaV0Daughters();


      }

      if (strness == 0) continue;


      for (Int_t j = 0; j < ntr; j++) { //loop on tracks

         // Pion bachelor
         Int_t bidx = trk[j];
         Int_t bachTPCcls = 0;


         if ((bidx == v->GetIndex(0)) || (bidx == v->GetIndex(1))) continue; // bach and V0's daughter's must be different!

         AliESDtrack *btrk = lESDevent->GetTrack(bidx);

         if (!(btrk->GetStatus() & AliESDtrack::kTPCrefit)) continue;

         if ((bachTPCcls = btrk->GetTPCNcls()) < 70) continue;

         //Bool_t *IsOkTrack = IsSelected(btrk); //for Alberto's PID

         //Bool_t *okTrack = new Bool_t[5];

         //for (Int_t k = 0; k < 5; k++) okTrack[k] = IsOkTrack[k];
         
         IsSelected(btrk);


         Int_t bachCharge = btrk->Charge();
         Float_t pionDCA = TMath::Abs(btrk->GetD(xPrimaryVertex, yPrimaryVertex, b)); // DCA between Bachelor and Primary Vertex

         Double_t bachphi = btrk->Phi();
         Double_t bachtheta = btrk->Theta();
         Double_t bachmass = 0.13957;
         Double_t bachp = btrk->GetP();
         Double_t bachpt = btrk->Pt();


         // Distance between Lambda and Pion bachelor
         AliESDv0 v0(*v), *pv0 = &v0;
         AliExternalTrackParam bt(*btrk), *pbt = &bt;
         Double_t dca = cascvert->PropagateToDCA(pv0, pbt, b); // distance bwn V0 and bach (in cm)
         if (dca > 10.0) continue;  // Note: was 0.1! Enlarged->further filter in second pass analysis


         AliESDcascade cascade(*pv0, *pbt, bidx); //constucts a sigma1385 candidate
         AliESDcascade *xi = &cascade;


         UInt_t lBachIdx   = (UInt_t) TMath::Abs(xi->GetBindex());
         AliESDtrack *bachTrackXi   = lESDevent->GetTrack(lBachIdx);



         Short_t mcTrue=0;
         if (fDataType == "SIM") {

            Int_t pLabel    = TMath::Abs(pTrackXi->GetLabel());
            Int_t nLabel    = TMath::Abs(nTrackXi->GetLabel());
            Int_t bachLabel = TMath::Abs(bachTrackXi->GetLabel());

            Int_t motherpLabel = stack->Particle(pLabel)->GetFirstMother();
            Int_t mothernLabel = stack->Particle(nLabel)->GetFirstMother();
            Int_t motherbachLabel = stack->Particle(bachLabel)->GetFirstMother();


            //cout<< "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
            //cout<< "plabel " << pLabel << " nlabel " << nLabel << " mother p " << motherpLabel << " mother n " << mothernLabel << " bachlabel " << bachLabel << " mother bach " << motherbachLabel << endl;
            //cout<< "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;

            if (motherpLabel > -1 && mothernLabel > -1) {
               TParticle *plambda = stack->Particle(motherpLabel);
               Int_t grandmother = plambda->GetFirstMother();

               motherpLabel = TMath::Abs(motherpLabel);
               mothernLabel = TMath::Abs(mothernLabel);
               //motherbachLabel = TMath::Abs(motherbachLabel);

               //cout<< "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
               //cout<< "plabel " << pLabel << " nlabel " << nLabel << " mother p " << motherpLabel << " mother n " << mothernLabel << " mother lambda " << grandmother << " bachlabel " << bachLabel << " mother bach " << motherbachLabel << endl;
               //cout<< "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;

               if (motherbachLabel > -1) {


                  //cout<< "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;
                  //cout<< "mother lambda " << grandmother << " mother bach " << motherbachLabel << " PDG Code "<< stack->Particle(grandmother)->GetPdgCode() << endl;
                  //cout<< "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"<<endl;

                  if ((motherpLabel == mothernLabel) && (grandmother == motherbachLabel) &&
                      ((TMath::Abs(stack->Particle(grandmother)->GetPdgCode()) == 3114) ||
                       (TMath::Abs(stack->Particle(grandmother)->GetPdgCode()) == 3224))) mcTrue = 1;
		       
		  if( (motherpLabel == mothernLabel) && (grandmother == motherbachLabel) &&
			 (TMath::Abs(stack->Particle(grandmother)->GetPdgCode())==3312) ) mcTrue = 2;

               }

            }

         }

         Double_t lBachMomX       = 0., lBachMomY  = 0., lBachMomZ   = 0.;
         Double_t lPMom[3] = {0., 0., 0.,};
         Double_t lNMom[3] = {0., 0., 0.,};
         Float_t lLambdaMomX       = 0., lLambdaMomY  = 0., lLambdaMomZ   = 0.;
         xi->GetBPxPyPz(lBachMomX,  lBachMomY,  lBachMomZ);
         xi->GetPPxPyPz(lPMom[0],  lPMom[1],  lPMom[2]);
         xi->GetNPxPyPz(lNMom[0],  lNMom[1],  lNMom[2]);
         lLambdaMomX = lPMom[0] + lNMom[0];
         lLambdaMomY = lPMom[1] + lNMom[1];
         lLambdaMomZ = lPMom[2] + lNMom[2];

         Float_t  lRapXi    = xi->RapXi();
         Float_t  lEta      = xi->Eta();
         Float_t  lTheta    = xi->Theta();
         Float_t  lPhi      = xi->Phi();
         Float_t  lPt       = xi->Pt();
         Float_t   lP     = xi->P();

         // Support variables for invariant mass calculation
         TLorentzVector lambda, pion, sigma;
         Double_t eLambda = TMath::Sqrt(lLambdaMomX * lLambdaMomX + lLambdaMomY * lLambdaMomY + lLambdaMomZ * lLambdaMomZ + lambdaMass * lambdaMass);
         Double_t ePion = TMath::Sqrt(lBachMomX * lBachMomX + lBachMomY * lBachMomY + lBachMomZ * lBachMomZ + bachmass * bachmass) ;

         lambda.SetPxPyPzE(lLambdaMomX, lLambdaMomY, lLambdaMomZ, eLambda);
         pion.SetPxPyPzE(lBachMomX, lBachMomY, lBachMomZ, ePion);

         sigma = lambda + pion;

         Double_t openingangle, invmass = 0;

         openingangle = TMath::ACos((lBachMomX * lLambdaMomX + lBachMomY * lLambdaMomY + lBachMomZ * lLambdaMomZ) / ((TMath::Sqrt(lBachMomX * lBachMomX + lBachMomY * lBachMomY + lBachMomZ * lBachMomZ)) * (TMath::Sqrt(lLambdaMomX * lLambdaMomX + lLambdaMomY * lLambdaMomY +
                                    lLambdaMomZ * lLambdaMomZ))));

         invmass = sigma.M();


         fNtuple1->Fill(trackNumber);
         fNtuple2->Fill((1.*strness), lambdaDCA, v0cospointangle, v0daughtersDCA , lambdaP, lambdaPt, lambdaMass);
         //fNtuple3->Fill((1.*bachCharge), pionDCA, bachp, bachpt, bachphi, bachtheta, okTrack[1], okTrack[2]);
         fNtuple3->Fill((1.*bachCharge), pionDCA, bachp, bachpt, bachphi, bachtheta, fOkTrack[1], fOkTrack[2]);
         fNtuple4->Fill(dca, (1.*mcTrue), lPhi, lTheta, lEta, lRapXi, lPt, lP, openingangle, invmass);

         ncasc++;

         //delete IsOkTrack;
         //delete okTrack;


      } // end loop tracks
   } // end loop V0s

   Info("AliAnalysisTaskSigma1385", "Number of reconstructed Sigma(1385): %d", ncasc);


   // Post output data.
   PostData(1, fListHistCascade);

}

//________________________________________________________________________

//Bool_t *AliAnalysisTaskSigma1385::IsSelected(AliESDtrack *track)
void AliAnalysisTaskSigma1385::IsSelected(AliESDtrack *track)
{
//
//
   //Bool_t okTrack[5];

   //for (Int_t i = 0; i < 5; i++) okTrack[i] = kFALSE;
   for (Int_t i = 0; i < 5; i++) fOkTrack[i] = kFALSE;


   AliITSPIDResponse itsrsp(fIsMC);


   ULong_t  status;
   Int_t    k, nITS;
   Double_t times[10], tpcNSigma, tpcMaxNSigma, itsSignal, itsNSigma, mom, tofTime, tofSigma, tofRef, tofRel;
   Bool_t   okTOF = kFALSE;
   Bool_t   okTPC = kFALSE;
   Bool_t   okITS = kFALSE;
   Bool_t   isTPC = kFALSE;
   Bool_t   isITSSA = kFALSE;
   Bool_t   isTOF = kFALSE;
   UChar_t  itsCluMap;

   // get commonly used variables
   status  = (ULong_t)track->GetStatus();
   mom     = track->P();
   isTPC   = ((status & AliESDtrack::kTPCin)  != 0);
   isITSSA = ((!isTPC) && (track->IsOn(AliESDtrack::kITSrefit)) && (!track->IsOn(AliESDtrack::kITSpureSA))); //(!isTPC && (status & AliESDtrack::kITSrefit) != 0 && (status & AliESDtrack::kITSpureSA) == 0 && (status & AliESDtrack::kITSpid) != 0);
   isTOF   = (((status & AliESDtrack::kTOFout) != 0) && ((status & AliESDtrack::kTIME) != 0) /* && mom > TMath::Max(b1, b2)*/);


   // check if the track type matches what is required
   if (!isTPC && !isITSSA) {
      AliDebug(AliLog::kDebug + 2, "Track is not either a TPC track or a ITS standalone. Rejected");
      //return okTrack;
      return;

   } else if (isTPC && !fUseGlobal) {
      AliDebug(AliLog::kDebug + 2, "Global tracks not used. Rejected");
      //return okTrack;
      return;

   } else if (isITSSA && !fUseITSSA) {
      AliDebug(AliLog::kDebug + 2, "ITS standalone not used. Rejected");
      //return okTrack;
      return;
   }

   // does a preliminary check on TOF values, if necessary
   // then, if the reference time or TOF signal are meaningless
   // even if the 'isTOF' flag is true, switch it to false
   if (isTOF) {
      track->GetIntegratedTimes(times);
      tofTime  = (Double_t)track->GetTOFsignal();
      tofSigma = fTOFmaker->GetExpectedSigma(mom, times[AliPID::kPion], AliPID::ParticleMass(AliPID::kPion));
      tofRef   = times[AliPID::kPion];
      if (tofRef <= 0.0 && tofSigma <= 0.0) isTOF = kFALSE;
   }



   // check TPC dE/dx
   if (isTPC) { // this branch is entered by all global tracks
      // check TPC dE/dx:
      if (fCheckTPC) {
         tpcNSigma = TMath::Abs(fESDpid->NumberOfSigmasTPC(track, AliPID::kPion));
         if (track->GetInnerParam()->P() > fTPCpLimit) tpcMaxNSigma = fMinTPCband; else tpcMaxNSigma = fMaxTPCband;
         okTPC = (tpcNSigma <= tpcMaxNSigma);
         AliDebug(AliLog::kDebug + 2, Form("TPC nsigma = %f -- max = %f -- cut %s", tpcNSigma, tpcMaxNSigma, (okTPC ? "passed" : "failed")));
      } else {
         // if TPC is not checked, it is as if all tracks do pass the cut
         okTPC = kTRUE;
         AliDebug(AliLog::kDebug + 2, "TPC not checked, track accepted");
      }

      // check TOF (only if flags are OK)
      if (fCheckTOF) {
         if (isTOF) {
            // TOF can be checked only when track is matched there
            track->GetIntegratedTimes(times);
            tofTime  = (Double_t)track->GetTOFsignal();
            tofSigma = fTOFmaker->GetExpectedSigma(mom, times[AliPID::kPion], AliPID::ParticleMass(AliPID::kPion));
            tofRef   = times[AliPID::kPion];

            tofRel   = (tofTime - tofRef) / tofSigma;
            okTOF    = ((tofRel >= fMinTOF) && (tofRel <= fMaxTOF));
            AliDebug(AliLog::kDebug + 2, Form("TOF nsigma = %f -- range = %f %f -- cut %s", tofRel, fMinTOF, fMaxTOF, (okTOF ? "passed" : "failed")));
         } else {
            // if TOF is not matched, the answer depends on TPC:
            // - if TPC is required, track is checked only there and TOF simply ignored
            // - if TPC is not required, track is rejected when TOF does not match it, if TOF check is required
            if (fCheckTPC) okTOF = kTRUE; else okTOF = kFALSE;
         }
      } else {
         okTOF = kTRUE;
      }

   } else if (isITSSA) { // this branch is entered by all ITS standalone tracks
      // check dE/dx only if this is required, otherwise ITS standalone are just added but not checked for PID
      if (fCheckITS) {
         itsSignal = track->GetITSsignal();
         itsCluMap = track->GetITSClusterMap();
         nITS      = 0;
         for (k = 2; k < 6; k++) if (itsCluMap & (1 << k)) ++nITS;
         //if (nITS < 3) return kFALSE;
         //itsNSigma = itsrsp.GetNumberOfSigmas(mom, itsSignal, AliPID::kPion, nITS, kTRUE);
         //okITS = ((TMath::Abs(itsNSigma)) <= fMaxITSband);
         if (nITS < 3) 
            okITS = kFALSE;
         else {
            itsNSigma = itsrsp.GetNumberOfSigmas(mom, itsSignal, AliPID::kPion, nITS, kTRUE);
            okITS = ((TMath::Abs(itsNSigma)) <= fMaxITSband);
            AliDebug(AliLog::kDebug + 2, Form("ITS nsigma = %f -- max = %f -- cut %s", itsNSigma, fMaxITSband, (okITS ? "passed" : "failed")));
         }
      } else {
         okITS = kTRUE;
      }
   } else {
      // if we are here, the track is surely bad
      okITS = kFALSE;
      okTPC = kFALSE;
      okTOF = kFALSE;
   }


   //okTrack[0] = okITS;
   //okTrack[1] = okTPC;
   //okTrack[2] = okTOF;
   //okTrack[3] = isTPC;
   //okTrack[4] = isITSSA;
   
   fOkTrack[0] = okITS;
   fOkTrack[1] = okTPC;
   fOkTrack[2] = okTOF;
   fOkTrack[3] = isTPC;
   fOkTrack[4] = isITSSA;

   //cout<<"##########################################"<<endl;
   //cout<<"isITSSA "<<isITSSA<< " isTPC "<<isTPC<<endl;
   //cout<<"##########################################"<<endl;


   //return okTrack;
}











//________________________________________________________________________
void AliAnalysisTaskSigma1385::Terminate(Option_t *)
{
   // Draw result to the screen
   // Called once at the end of the query
}



 AliAnalysisTaskSigma1385.cxx:1
 AliAnalysisTaskSigma1385.cxx:2
 AliAnalysisTaskSigma1385.cxx:3
 AliAnalysisTaskSigma1385.cxx:4
 AliAnalysisTaskSigma1385.cxx:5
 AliAnalysisTaskSigma1385.cxx:6
 AliAnalysisTaskSigma1385.cxx:7
 AliAnalysisTaskSigma1385.cxx:8
 AliAnalysisTaskSigma1385.cxx:9
 AliAnalysisTaskSigma1385.cxx:10
 AliAnalysisTaskSigma1385.cxx:11
 AliAnalysisTaskSigma1385.cxx:12
 AliAnalysisTaskSigma1385.cxx:13
 AliAnalysisTaskSigma1385.cxx:14
 AliAnalysisTaskSigma1385.cxx:15
 AliAnalysisTaskSigma1385.cxx:16
 AliAnalysisTaskSigma1385.cxx:17
 AliAnalysisTaskSigma1385.cxx:18
 AliAnalysisTaskSigma1385.cxx:19
 AliAnalysisTaskSigma1385.cxx:20
 AliAnalysisTaskSigma1385.cxx:21
 AliAnalysisTaskSigma1385.cxx:22
 AliAnalysisTaskSigma1385.cxx:23
 AliAnalysisTaskSigma1385.cxx:24
 AliAnalysisTaskSigma1385.cxx:25
 AliAnalysisTaskSigma1385.cxx:26
 AliAnalysisTaskSigma1385.cxx:27
 AliAnalysisTaskSigma1385.cxx:28
 AliAnalysisTaskSigma1385.cxx:29
 AliAnalysisTaskSigma1385.cxx:30
 AliAnalysisTaskSigma1385.cxx:31
 AliAnalysisTaskSigma1385.cxx:32
 AliAnalysisTaskSigma1385.cxx:33
 AliAnalysisTaskSigma1385.cxx:34
 AliAnalysisTaskSigma1385.cxx:35
 AliAnalysisTaskSigma1385.cxx:36
 AliAnalysisTaskSigma1385.cxx:37
 AliAnalysisTaskSigma1385.cxx:38
 AliAnalysisTaskSigma1385.cxx:39
 AliAnalysisTaskSigma1385.cxx:40
 AliAnalysisTaskSigma1385.cxx:41
 AliAnalysisTaskSigma1385.cxx:42
 AliAnalysisTaskSigma1385.cxx:43
 AliAnalysisTaskSigma1385.cxx:44
 AliAnalysisTaskSigma1385.cxx:45
 AliAnalysisTaskSigma1385.cxx:46
 AliAnalysisTaskSigma1385.cxx:47
 AliAnalysisTaskSigma1385.cxx:48
 AliAnalysisTaskSigma1385.cxx:49
 AliAnalysisTaskSigma1385.cxx:50
 AliAnalysisTaskSigma1385.cxx:51
 AliAnalysisTaskSigma1385.cxx:52
 AliAnalysisTaskSigma1385.cxx:53
 AliAnalysisTaskSigma1385.cxx:54
 AliAnalysisTaskSigma1385.cxx:55
 AliAnalysisTaskSigma1385.cxx:56
 AliAnalysisTaskSigma1385.cxx:57
 AliAnalysisTaskSigma1385.cxx:58
 AliAnalysisTaskSigma1385.cxx:59
 AliAnalysisTaskSigma1385.cxx:60
 AliAnalysisTaskSigma1385.cxx:61
 AliAnalysisTaskSigma1385.cxx:62
 AliAnalysisTaskSigma1385.cxx:63
 AliAnalysisTaskSigma1385.cxx:64
 AliAnalysisTaskSigma1385.cxx:65
 AliAnalysisTaskSigma1385.cxx:66
 AliAnalysisTaskSigma1385.cxx:67
 AliAnalysisTaskSigma1385.cxx:68
 AliAnalysisTaskSigma1385.cxx:69
 AliAnalysisTaskSigma1385.cxx:70
 AliAnalysisTaskSigma1385.cxx:71
 AliAnalysisTaskSigma1385.cxx:72
 AliAnalysisTaskSigma1385.cxx:73
 AliAnalysisTaskSigma1385.cxx:74
 AliAnalysisTaskSigma1385.cxx:75
 AliAnalysisTaskSigma1385.cxx:76
 AliAnalysisTaskSigma1385.cxx:77
 AliAnalysisTaskSigma1385.cxx:78
 AliAnalysisTaskSigma1385.cxx:79
 AliAnalysisTaskSigma1385.cxx:80
 AliAnalysisTaskSigma1385.cxx:81
 AliAnalysisTaskSigma1385.cxx:82
 AliAnalysisTaskSigma1385.cxx:83
 AliAnalysisTaskSigma1385.cxx:84
 AliAnalysisTaskSigma1385.cxx:85
 AliAnalysisTaskSigma1385.cxx:86
 AliAnalysisTaskSigma1385.cxx:87
 AliAnalysisTaskSigma1385.cxx:88
 AliAnalysisTaskSigma1385.cxx:89
 AliAnalysisTaskSigma1385.cxx:90
 AliAnalysisTaskSigma1385.cxx:91
 AliAnalysisTaskSigma1385.cxx:92
 AliAnalysisTaskSigma1385.cxx:93
 AliAnalysisTaskSigma1385.cxx:94
 AliAnalysisTaskSigma1385.cxx:95
 AliAnalysisTaskSigma1385.cxx:96
 AliAnalysisTaskSigma1385.cxx:97
 AliAnalysisTaskSigma1385.cxx:98
 AliAnalysisTaskSigma1385.cxx:99
 AliAnalysisTaskSigma1385.cxx:100
 AliAnalysisTaskSigma1385.cxx:101
 AliAnalysisTaskSigma1385.cxx:102
 AliAnalysisTaskSigma1385.cxx:103
 AliAnalysisTaskSigma1385.cxx:104
 AliAnalysisTaskSigma1385.cxx:105
 AliAnalysisTaskSigma1385.cxx:106
 AliAnalysisTaskSigma1385.cxx:107
 AliAnalysisTaskSigma1385.cxx:108
 AliAnalysisTaskSigma1385.cxx:109
 AliAnalysisTaskSigma1385.cxx:110
 AliAnalysisTaskSigma1385.cxx:111
 AliAnalysisTaskSigma1385.cxx:112
 AliAnalysisTaskSigma1385.cxx:113
 AliAnalysisTaskSigma1385.cxx:114
 AliAnalysisTaskSigma1385.cxx:115
 AliAnalysisTaskSigma1385.cxx:116
 AliAnalysisTaskSigma1385.cxx:117
 AliAnalysisTaskSigma1385.cxx:118
 AliAnalysisTaskSigma1385.cxx:119
 AliAnalysisTaskSigma1385.cxx:120
 AliAnalysisTaskSigma1385.cxx:121
 AliAnalysisTaskSigma1385.cxx:122
 AliAnalysisTaskSigma1385.cxx:123
 AliAnalysisTaskSigma1385.cxx:124
 AliAnalysisTaskSigma1385.cxx:125
 AliAnalysisTaskSigma1385.cxx:126
 AliAnalysisTaskSigma1385.cxx:127
 AliAnalysisTaskSigma1385.cxx:128
 AliAnalysisTaskSigma1385.cxx:129
 AliAnalysisTaskSigma1385.cxx:130
 AliAnalysisTaskSigma1385.cxx:131
 AliAnalysisTaskSigma1385.cxx:132
 AliAnalysisTaskSigma1385.cxx:133
 AliAnalysisTaskSigma1385.cxx:134
 AliAnalysisTaskSigma1385.cxx:135
 AliAnalysisTaskSigma1385.cxx:136
 AliAnalysisTaskSigma1385.cxx:137
 AliAnalysisTaskSigma1385.cxx:138
 AliAnalysisTaskSigma1385.cxx:139
 AliAnalysisTaskSigma1385.cxx:140
 AliAnalysisTaskSigma1385.cxx:141
 AliAnalysisTaskSigma1385.cxx:142
 AliAnalysisTaskSigma1385.cxx:143
 AliAnalysisTaskSigma1385.cxx:144
 AliAnalysisTaskSigma1385.cxx:145
 AliAnalysisTaskSigma1385.cxx:146
 AliAnalysisTaskSigma1385.cxx:147
 AliAnalysisTaskSigma1385.cxx:148
 AliAnalysisTaskSigma1385.cxx:149
 AliAnalysisTaskSigma1385.cxx:150
 AliAnalysisTaskSigma1385.cxx:151
 AliAnalysisTaskSigma1385.cxx:152
 AliAnalysisTaskSigma1385.cxx:153
 AliAnalysisTaskSigma1385.cxx:154
 AliAnalysisTaskSigma1385.cxx:155
 AliAnalysisTaskSigma1385.cxx:156
 AliAnalysisTaskSigma1385.cxx:157
 AliAnalysisTaskSigma1385.cxx:158
 AliAnalysisTaskSigma1385.cxx:159
 AliAnalysisTaskSigma1385.cxx:160
 AliAnalysisTaskSigma1385.cxx:161
 AliAnalysisTaskSigma1385.cxx:162
 AliAnalysisTaskSigma1385.cxx:163
 AliAnalysisTaskSigma1385.cxx:164
 AliAnalysisTaskSigma1385.cxx:165
 AliAnalysisTaskSigma1385.cxx:166
 AliAnalysisTaskSigma1385.cxx:167
 AliAnalysisTaskSigma1385.cxx:168
 AliAnalysisTaskSigma1385.cxx:169
 AliAnalysisTaskSigma1385.cxx:170
 AliAnalysisTaskSigma1385.cxx:171
 AliAnalysisTaskSigma1385.cxx:172
 AliAnalysisTaskSigma1385.cxx:173
 AliAnalysisTaskSigma1385.cxx:174
 AliAnalysisTaskSigma1385.cxx:175
 AliAnalysisTaskSigma1385.cxx:176
 AliAnalysisTaskSigma1385.cxx:177
 AliAnalysisTaskSigma1385.cxx:178
 AliAnalysisTaskSigma1385.cxx:179
 AliAnalysisTaskSigma1385.cxx:180
 AliAnalysisTaskSigma1385.cxx:181
 AliAnalysisTaskSigma1385.cxx:182
 AliAnalysisTaskSigma1385.cxx:183
 AliAnalysisTaskSigma1385.cxx:184
 AliAnalysisTaskSigma1385.cxx:185
 AliAnalysisTaskSigma1385.cxx:186
 AliAnalysisTaskSigma1385.cxx:187
 AliAnalysisTaskSigma1385.cxx:188
 AliAnalysisTaskSigma1385.cxx:189
 AliAnalysisTaskSigma1385.cxx:190
 AliAnalysisTaskSigma1385.cxx:191
 AliAnalysisTaskSigma1385.cxx:192
 AliAnalysisTaskSigma1385.cxx:193
 AliAnalysisTaskSigma1385.cxx:194
 AliAnalysisTaskSigma1385.cxx:195
 AliAnalysisTaskSigma1385.cxx:196
 AliAnalysisTaskSigma1385.cxx:197
 AliAnalysisTaskSigma1385.cxx:198
 AliAnalysisTaskSigma1385.cxx:199
 AliAnalysisTaskSigma1385.cxx:200
 AliAnalysisTaskSigma1385.cxx:201
 AliAnalysisTaskSigma1385.cxx:202
 AliAnalysisTaskSigma1385.cxx:203
 AliAnalysisTaskSigma1385.cxx:204
 AliAnalysisTaskSigma1385.cxx:205
 AliAnalysisTaskSigma1385.cxx:206
 AliAnalysisTaskSigma1385.cxx:207
 AliAnalysisTaskSigma1385.cxx:208
 AliAnalysisTaskSigma1385.cxx:209
 AliAnalysisTaskSigma1385.cxx:210
 AliAnalysisTaskSigma1385.cxx:211
 AliAnalysisTaskSigma1385.cxx:212
 AliAnalysisTaskSigma1385.cxx:213
 AliAnalysisTaskSigma1385.cxx:214
 AliAnalysisTaskSigma1385.cxx:215
 AliAnalysisTaskSigma1385.cxx:216
 AliAnalysisTaskSigma1385.cxx:217
 AliAnalysisTaskSigma1385.cxx:218
 AliAnalysisTaskSigma1385.cxx:219
 AliAnalysisTaskSigma1385.cxx:220
 AliAnalysisTaskSigma1385.cxx:221
 AliAnalysisTaskSigma1385.cxx:222
 AliAnalysisTaskSigma1385.cxx:223
 AliAnalysisTaskSigma1385.cxx:224
 AliAnalysisTaskSigma1385.cxx:225
 AliAnalysisTaskSigma1385.cxx:226
 AliAnalysisTaskSigma1385.cxx:227
 AliAnalysisTaskSigma1385.cxx:228
 AliAnalysisTaskSigma1385.cxx:229
 AliAnalysisTaskSigma1385.cxx:230
 AliAnalysisTaskSigma1385.cxx:231
 AliAnalysisTaskSigma1385.cxx:232
 AliAnalysisTaskSigma1385.cxx:233
 AliAnalysisTaskSigma1385.cxx:234
 AliAnalysisTaskSigma1385.cxx:235
 AliAnalysisTaskSigma1385.cxx:236
 AliAnalysisTaskSigma1385.cxx:237
 AliAnalysisTaskSigma1385.cxx:238
 AliAnalysisTaskSigma1385.cxx:239
 AliAnalysisTaskSigma1385.cxx:240
 AliAnalysisTaskSigma1385.cxx:241
 AliAnalysisTaskSigma1385.cxx:242
 AliAnalysisTaskSigma1385.cxx:243
 AliAnalysisTaskSigma1385.cxx:244
 AliAnalysisTaskSigma1385.cxx:245
 AliAnalysisTaskSigma1385.cxx:246
 AliAnalysisTaskSigma1385.cxx:247
 AliAnalysisTaskSigma1385.cxx:248
 AliAnalysisTaskSigma1385.cxx:249
 AliAnalysisTaskSigma1385.cxx:250
 AliAnalysisTaskSigma1385.cxx:251
 AliAnalysisTaskSigma1385.cxx:252
 AliAnalysisTaskSigma1385.cxx:253
 AliAnalysisTaskSigma1385.cxx:254
 AliAnalysisTaskSigma1385.cxx:255
 AliAnalysisTaskSigma1385.cxx:256
 AliAnalysisTaskSigma1385.cxx:257
 AliAnalysisTaskSigma1385.cxx:258
 AliAnalysisTaskSigma1385.cxx:259
 AliAnalysisTaskSigma1385.cxx:260
 AliAnalysisTaskSigma1385.cxx:261
 AliAnalysisTaskSigma1385.cxx:262
 AliAnalysisTaskSigma1385.cxx:263
 AliAnalysisTaskSigma1385.cxx:264
 AliAnalysisTaskSigma1385.cxx:265
 AliAnalysisTaskSigma1385.cxx:266
 AliAnalysisTaskSigma1385.cxx:267
 AliAnalysisTaskSigma1385.cxx:268
 AliAnalysisTaskSigma1385.cxx:269
 AliAnalysisTaskSigma1385.cxx:270
 AliAnalysisTaskSigma1385.cxx:271
 AliAnalysisTaskSigma1385.cxx:272
 AliAnalysisTaskSigma1385.cxx:273
 AliAnalysisTaskSigma1385.cxx:274
 AliAnalysisTaskSigma1385.cxx:275
 AliAnalysisTaskSigma1385.cxx:276
 AliAnalysisTaskSigma1385.cxx:277
 AliAnalysisTaskSigma1385.cxx:278
 AliAnalysisTaskSigma1385.cxx:279
 AliAnalysisTaskSigma1385.cxx:280
 AliAnalysisTaskSigma1385.cxx:281
 AliAnalysisTaskSigma1385.cxx:282
 AliAnalysisTaskSigma1385.cxx:283
 AliAnalysisTaskSigma1385.cxx:284
 AliAnalysisTaskSigma1385.cxx:285
 AliAnalysisTaskSigma1385.cxx:286
 AliAnalysisTaskSigma1385.cxx:287
 AliAnalysisTaskSigma1385.cxx:288
 AliAnalysisTaskSigma1385.cxx:289
 AliAnalysisTaskSigma1385.cxx:290
 AliAnalysisTaskSigma1385.cxx:291
 AliAnalysisTaskSigma1385.cxx:292
 AliAnalysisTaskSigma1385.cxx:293
 AliAnalysisTaskSigma1385.cxx:294
 AliAnalysisTaskSigma1385.cxx:295
 AliAnalysisTaskSigma1385.cxx:296
 AliAnalysisTaskSigma1385.cxx:297
 AliAnalysisTaskSigma1385.cxx:298
 AliAnalysisTaskSigma1385.cxx:299
 AliAnalysisTaskSigma1385.cxx:300
 AliAnalysisTaskSigma1385.cxx:301
 AliAnalysisTaskSigma1385.cxx:302
 AliAnalysisTaskSigma1385.cxx:303
 AliAnalysisTaskSigma1385.cxx:304
 AliAnalysisTaskSigma1385.cxx:305
 AliAnalysisTaskSigma1385.cxx:306
 AliAnalysisTaskSigma1385.cxx:307
 AliAnalysisTaskSigma1385.cxx:308
 AliAnalysisTaskSigma1385.cxx:309
 AliAnalysisTaskSigma1385.cxx:310
 AliAnalysisTaskSigma1385.cxx:311
 AliAnalysisTaskSigma1385.cxx:312
 AliAnalysisTaskSigma1385.cxx:313
 AliAnalysisTaskSigma1385.cxx:314
 AliAnalysisTaskSigma1385.cxx:315
 AliAnalysisTaskSigma1385.cxx:316
 AliAnalysisTaskSigma1385.cxx:317
 AliAnalysisTaskSigma1385.cxx:318
 AliAnalysisTaskSigma1385.cxx:319
 AliAnalysisTaskSigma1385.cxx:320
 AliAnalysisTaskSigma1385.cxx:321
 AliAnalysisTaskSigma1385.cxx:322
 AliAnalysisTaskSigma1385.cxx:323
 AliAnalysisTaskSigma1385.cxx:324
 AliAnalysisTaskSigma1385.cxx:325
 AliAnalysisTaskSigma1385.cxx:326
 AliAnalysisTaskSigma1385.cxx:327
 AliAnalysisTaskSigma1385.cxx:328
 AliAnalysisTaskSigma1385.cxx:329
 AliAnalysisTaskSigma1385.cxx:330
 AliAnalysisTaskSigma1385.cxx:331
 AliAnalysisTaskSigma1385.cxx:332
 AliAnalysisTaskSigma1385.cxx:333
 AliAnalysisTaskSigma1385.cxx:334
 AliAnalysisTaskSigma1385.cxx:335
 AliAnalysisTaskSigma1385.cxx:336
 AliAnalysisTaskSigma1385.cxx:337
 AliAnalysisTaskSigma1385.cxx:338
 AliAnalysisTaskSigma1385.cxx:339
 AliAnalysisTaskSigma1385.cxx:340
 AliAnalysisTaskSigma1385.cxx:341
 AliAnalysisTaskSigma1385.cxx:342
 AliAnalysisTaskSigma1385.cxx:343
 AliAnalysisTaskSigma1385.cxx:344
 AliAnalysisTaskSigma1385.cxx:345
 AliAnalysisTaskSigma1385.cxx:346
 AliAnalysisTaskSigma1385.cxx:347
 AliAnalysisTaskSigma1385.cxx:348
 AliAnalysisTaskSigma1385.cxx:349
 AliAnalysisTaskSigma1385.cxx:350
 AliAnalysisTaskSigma1385.cxx:351
 AliAnalysisTaskSigma1385.cxx:352
 AliAnalysisTaskSigma1385.cxx:353
 AliAnalysisTaskSigma1385.cxx:354
 AliAnalysisTaskSigma1385.cxx:355
 AliAnalysisTaskSigma1385.cxx:356
 AliAnalysisTaskSigma1385.cxx:357
 AliAnalysisTaskSigma1385.cxx:358
 AliAnalysisTaskSigma1385.cxx:359
 AliAnalysisTaskSigma1385.cxx:360
 AliAnalysisTaskSigma1385.cxx:361
 AliAnalysisTaskSigma1385.cxx:362
 AliAnalysisTaskSigma1385.cxx:363
 AliAnalysisTaskSigma1385.cxx:364
 AliAnalysisTaskSigma1385.cxx:365
 AliAnalysisTaskSigma1385.cxx:366
 AliAnalysisTaskSigma1385.cxx:367
 AliAnalysisTaskSigma1385.cxx:368
 AliAnalysisTaskSigma1385.cxx:369
 AliAnalysisTaskSigma1385.cxx:370
 AliAnalysisTaskSigma1385.cxx:371
 AliAnalysisTaskSigma1385.cxx:372
 AliAnalysisTaskSigma1385.cxx:373
 AliAnalysisTaskSigma1385.cxx:374
 AliAnalysisTaskSigma1385.cxx:375
 AliAnalysisTaskSigma1385.cxx:376
 AliAnalysisTaskSigma1385.cxx:377
 AliAnalysisTaskSigma1385.cxx:378
 AliAnalysisTaskSigma1385.cxx:379
 AliAnalysisTaskSigma1385.cxx:380
 AliAnalysisTaskSigma1385.cxx:381
 AliAnalysisTaskSigma1385.cxx:382
 AliAnalysisTaskSigma1385.cxx:383
 AliAnalysisTaskSigma1385.cxx:384
 AliAnalysisTaskSigma1385.cxx:385
 AliAnalysisTaskSigma1385.cxx:386
 AliAnalysisTaskSigma1385.cxx:387
 AliAnalysisTaskSigma1385.cxx:388
 AliAnalysisTaskSigma1385.cxx:389
 AliAnalysisTaskSigma1385.cxx:390
 AliAnalysisTaskSigma1385.cxx:391
 AliAnalysisTaskSigma1385.cxx:392
 AliAnalysisTaskSigma1385.cxx:393
 AliAnalysisTaskSigma1385.cxx:394
 AliAnalysisTaskSigma1385.cxx:395
 AliAnalysisTaskSigma1385.cxx:396
 AliAnalysisTaskSigma1385.cxx:397
 AliAnalysisTaskSigma1385.cxx:398
 AliAnalysisTaskSigma1385.cxx:399
 AliAnalysisTaskSigma1385.cxx:400
 AliAnalysisTaskSigma1385.cxx:401
 AliAnalysisTaskSigma1385.cxx:402
 AliAnalysisTaskSigma1385.cxx:403
 AliAnalysisTaskSigma1385.cxx:404
 AliAnalysisTaskSigma1385.cxx:405
 AliAnalysisTaskSigma1385.cxx:406
 AliAnalysisTaskSigma1385.cxx:407
 AliAnalysisTaskSigma1385.cxx:408
 AliAnalysisTaskSigma1385.cxx:409
 AliAnalysisTaskSigma1385.cxx:410
 AliAnalysisTaskSigma1385.cxx:411
 AliAnalysisTaskSigma1385.cxx:412
 AliAnalysisTaskSigma1385.cxx:413
 AliAnalysisTaskSigma1385.cxx:414
 AliAnalysisTaskSigma1385.cxx:415
 AliAnalysisTaskSigma1385.cxx:416
 AliAnalysisTaskSigma1385.cxx:417
 AliAnalysisTaskSigma1385.cxx:418
 AliAnalysisTaskSigma1385.cxx:419
 AliAnalysisTaskSigma1385.cxx:420
 AliAnalysisTaskSigma1385.cxx:421
 AliAnalysisTaskSigma1385.cxx:422
 AliAnalysisTaskSigma1385.cxx:423
 AliAnalysisTaskSigma1385.cxx:424
 AliAnalysisTaskSigma1385.cxx:425
 AliAnalysisTaskSigma1385.cxx:426
 AliAnalysisTaskSigma1385.cxx:427
 AliAnalysisTaskSigma1385.cxx:428
 AliAnalysisTaskSigma1385.cxx:429
 AliAnalysisTaskSigma1385.cxx:430
 AliAnalysisTaskSigma1385.cxx:431
 AliAnalysisTaskSigma1385.cxx:432
 AliAnalysisTaskSigma1385.cxx:433
 AliAnalysisTaskSigma1385.cxx:434
 AliAnalysisTaskSigma1385.cxx:435
 AliAnalysisTaskSigma1385.cxx:436
 AliAnalysisTaskSigma1385.cxx:437
 AliAnalysisTaskSigma1385.cxx:438
 AliAnalysisTaskSigma1385.cxx:439
 AliAnalysisTaskSigma1385.cxx:440
 AliAnalysisTaskSigma1385.cxx:441
 AliAnalysisTaskSigma1385.cxx:442
 AliAnalysisTaskSigma1385.cxx:443
 AliAnalysisTaskSigma1385.cxx:444
 AliAnalysisTaskSigma1385.cxx:445
 AliAnalysisTaskSigma1385.cxx:446
 AliAnalysisTaskSigma1385.cxx:447
 AliAnalysisTaskSigma1385.cxx:448
 AliAnalysisTaskSigma1385.cxx:449
 AliAnalysisTaskSigma1385.cxx:450
 AliAnalysisTaskSigma1385.cxx:451
 AliAnalysisTaskSigma1385.cxx:452
 AliAnalysisTaskSigma1385.cxx:453
 AliAnalysisTaskSigma1385.cxx:454
 AliAnalysisTaskSigma1385.cxx:455
 AliAnalysisTaskSigma1385.cxx:456
 AliAnalysisTaskSigma1385.cxx:457
 AliAnalysisTaskSigma1385.cxx:458
 AliAnalysisTaskSigma1385.cxx:459
 AliAnalysisTaskSigma1385.cxx:460
 AliAnalysisTaskSigma1385.cxx:461
 AliAnalysisTaskSigma1385.cxx:462
 AliAnalysisTaskSigma1385.cxx:463
 AliAnalysisTaskSigma1385.cxx:464
 AliAnalysisTaskSigma1385.cxx:465
 AliAnalysisTaskSigma1385.cxx:466
 AliAnalysisTaskSigma1385.cxx:467
 AliAnalysisTaskSigma1385.cxx:468
 AliAnalysisTaskSigma1385.cxx:469
 AliAnalysisTaskSigma1385.cxx:470
 AliAnalysisTaskSigma1385.cxx:471
 AliAnalysisTaskSigma1385.cxx:472
 AliAnalysisTaskSigma1385.cxx:473
 AliAnalysisTaskSigma1385.cxx:474
 AliAnalysisTaskSigma1385.cxx:475
 AliAnalysisTaskSigma1385.cxx:476
 AliAnalysisTaskSigma1385.cxx:477
 AliAnalysisTaskSigma1385.cxx:478
 AliAnalysisTaskSigma1385.cxx:479
 AliAnalysisTaskSigma1385.cxx:480
 AliAnalysisTaskSigma1385.cxx:481
 AliAnalysisTaskSigma1385.cxx:482
 AliAnalysisTaskSigma1385.cxx:483
 AliAnalysisTaskSigma1385.cxx:484
 AliAnalysisTaskSigma1385.cxx:485
 AliAnalysisTaskSigma1385.cxx:486
 AliAnalysisTaskSigma1385.cxx:487
 AliAnalysisTaskSigma1385.cxx:488
 AliAnalysisTaskSigma1385.cxx:489
 AliAnalysisTaskSigma1385.cxx:490
 AliAnalysisTaskSigma1385.cxx:491
 AliAnalysisTaskSigma1385.cxx:492
 AliAnalysisTaskSigma1385.cxx:493
 AliAnalysisTaskSigma1385.cxx:494
 AliAnalysisTaskSigma1385.cxx:495
 AliAnalysisTaskSigma1385.cxx:496
 AliAnalysisTaskSigma1385.cxx:497
 AliAnalysisTaskSigma1385.cxx:498
 AliAnalysisTaskSigma1385.cxx:499
 AliAnalysisTaskSigma1385.cxx:500
 AliAnalysisTaskSigma1385.cxx:501
 AliAnalysisTaskSigma1385.cxx:502
 AliAnalysisTaskSigma1385.cxx:503
 AliAnalysisTaskSigma1385.cxx:504
 AliAnalysisTaskSigma1385.cxx:505
 AliAnalysisTaskSigma1385.cxx:506
 AliAnalysisTaskSigma1385.cxx:507
 AliAnalysisTaskSigma1385.cxx:508
 AliAnalysisTaskSigma1385.cxx:509
 AliAnalysisTaskSigma1385.cxx:510
 AliAnalysisTaskSigma1385.cxx:511
 AliAnalysisTaskSigma1385.cxx:512
 AliAnalysisTaskSigma1385.cxx:513
 AliAnalysisTaskSigma1385.cxx:514
 AliAnalysisTaskSigma1385.cxx:515
 AliAnalysisTaskSigma1385.cxx:516
 AliAnalysisTaskSigma1385.cxx:517
 AliAnalysisTaskSigma1385.cxx:518
 AliAnalysisTaskSigma1385.cxx:519
 AliAnalysisTaskSigma1385.cxx:520
 AliAnalysisTaskSigma1385.cxx:521
 AliAnalysisTaskSigma1385.cxx:522
 AliAnalysisTaskSigma1385.cxx:523
 AliAnalysisTaskSigma1385.cxx:524
 AliAnalysisTaskSigma1385.cxx:525
 AliAnalysisTaskSigma1385.cxx:526
 AliAnalysisTaskSigma1385.cxx:527
 AliAnalysisTaskSigma1385.cxx:528
 AliAnalysisTaskSigma1385.cxx:529
 AliAnalysisTaskSigma1385.cxx:530
 AliAnalysisTaskSigma1385.cxx:531
 AliAnalysisTaskSigma1385.cxx:532
 AliAnalysisTaskSigma1385.cxx:533
 AliAnalysisTaskSigma1385.cxx:534
 AliAnalysisTaskSigma1385.cxx:535
 AliAnalysisTaskSigma1385.cxx:536
 AliAnalysisTaskSigma1385.cxx:537
 AliAnalysisTaskSigma1385.cxx:538
 AliAnalysisTaskSigma1385.cxx:539
 AliAnalysisTaskSigma1385.cxx:540
 AliAnalysisTaskSigma1385.cxx:541
 AliAnalysisTaskSigma1385.cxx:542
 AliAnalysisTaskSigma1385.cxx:543
 AliAnalysisTaskSigma1385.cxx:544
 AliAnalysisTaskSigma1385.cxx:545
 AliAnalysisTaskSigma1385.cxx:546
 AliAnalysisTaskSigma1385.cxx:547
 AliAnalysisTaskSigma1385.cxx:548
 AliAnalysisTaskSigma1385.cxx:549
 AliAnalysisTaskSigma1385.cxx:550
 AliAnalysisTaskSigma1385.cxx:551
 AliAnalysisTaskSigma1385.cxx:552
 AliAnalysisTaskSigma1385.cxx:553
 AliAnalysisTaskSigma1385.cxx:554
 AliAnalysisTaskSigma1385.cxx:555
 AliAnalysisTaskSigma1385.cxx:556
 AliAnalysisTaskSigma1385.cxx:557
 AliAnalysisTaskSigma1385.cxx:558
 AliAnalysisTaskSigma1385.cxx:559
 AliAnalysisTaskSigma1385.cxx:560
 AliAnalysisTaskSigma1385.cxx:561
 AliAnalysisTaskSigma1385.cxx:562
 AliAnalysisTaskSigma1385.cxx:563
 AliAnalysisTaskSigma1385.cxx:564
 AliAnalysisTaskSigma1385.cxx:565
 AliAnalysisTaskSigma1385.cxx:566
 AliAnalysisTaskSigma1385.cxx:567
 AliAnalysisTaskSigma1385.cxx:568
 AliAnalysisTaskSigma1385.cxx:569
 AliAnalysisTaskSigma1385.cxx:570
 AliAnalysisTaskSigma1385.cxx:571
 AliAnalysisTaskSigma1385.cxx:572
 AliAnalysisTaskSigma1385.cxx:573
 AliAnalysisTaskSigma1385.cxx:574
 AliAnalysisTaskSigma1385.cxx:575
 AliAnalysisTaskSigma1385.cxx:576
 AliAnalysisTaskSigma1385.cxx:577
 AliAnalysisTaskSigma1385.cxx:578
 AliAnalysisTaskSigma1385.cxx:579
 AliAnalysisTaskSigma1385.cxx:580
 AliAnalysisTaskSigma1385.cxx:581
 AliAnalysisTaskSigma1385.cxx:582
 AliAnalysisTaskSigma1385.cxx:583
 AliAnalysisTaskSigma1385.cxx:584
 AliAnalysisTaskSigma1385.cxx:585
 AliAnalysisTaskSigma1385.cxx:586
 AliAnalysisTaskSigma1385.cxx:587
 AliAnalysisTaskSigma1385.cxx:588
 AliAnalysisTaskSigma1385.cxx:589
 AliAnalysisTaskSigma1385.cxx:590
 AliAnalysisTaskSigma1385.cxx:591
 AliAnalysisTaskSigma1385.cxx:592
 AliAnalysisTaskSigma1385.cxx:593
 AliAnalysisTaskSigma1385.cxx:594
 AliAnalysisTaskSigma1385.cxx:595
 AliAnalysisTaskSigma1385.cxx:596
 AliAnalysisTaskSigma1385.cxx:597
 AliAnalysisTaskSigma1385.cxx:598
 AliAnalysisTaskSigma1385.cxx:599
 AliAnalysisTaskSigma1385.cxx:600
 AliAnalysisTaskSigma1385.cxx:601
 AliAnalysisTaskSigma1385.cxx:602
 AliAnalysisTaskSigma1385.cxx:603
 AliAnalysisTaskSigma1385.cxx:604
 AliAnalysisTaskSigma1385.cxx:605
 AliAnalysisTaskSigma1385.cxx:606
 AliAnalysisTaskSigma1385.cxx:607
 AliAnalysisTaskSigma1385.cxx:608
 AliAnalysisTaskSigma1385.cxx:609
 AliAnalysisTaskSigma1385.cxx:610
 AliAnalysisTaskSigma1385.cxx:611
 AliAnalysisTaskSigma1385.cxx:612
 AliAnalysisTaskSigma1385.cxx:613
 AliAnalysisTaskSigma1385.cxx:614
 AliAnalysisTaskSigma1385.cxx:615
 AliAnalysisTaskSigma1385.cxx:616
 AliAnalysisTaskSigma1385.cxx:617
 AliAnalysisTaskSigma1385.cxx:618
 AliAnalysisTaskSigma1385.cxx:619
 AliAnalysisTaskSigma1385.cxx:620
 AliAnalysisTaskSigma1385.cxx:621
 AliAnalysisTaskSigma1385.cxx:622
 AliAnalysisTaskSigma1385.cxx:623
 AliAnalysisTaskSigma1385.cxx:624
 AliAnalysisTaskSigma1385.cxx:625
 AliAnalysisTaskSigma1385.cxx:626
 AliAnalysisTaskSigma1385.cxx:627
 AliAnalysisTaskSigma1385.cxx:628
 AliAnalysisTaskSigma1385.cxx:629
 AliAnalysisTaskSigma1385.cxx:630
 AliAnalysisTaskSigma1385.cxx:631
 AliAnalysisTaskSigma1385.cxx:632
 AliAnalysisTaskSigma1385.cxx:633
 AliAnalysisTaskSigma1385.cxx:634
 AliAnalysisTaskSigma1385.cxx:635
 AliAnalysisTaskSigma1385.cxx:636
 AliAnalysisTaskSigma1385.cxx:637
 AliAnalysisTaskSigma1385.cxx:638
 AliAnalysisTaskSigma1385.cxx:639
 AliAnalysisTaskSigma1385.cxx:640
 AliAnalysisTaskSigma1385.cxx:641
 AliAnalysisTaskSigma1385.cxx:642
 AliAnalysisTaskSigma1385.cxx:643
 AliAnalysisTaskSigma1385.cxx:644
 AliAnalysisTaskSigma1385.cxx:645
 AliAnalysisTaskSigma1385.cxx:646
 AliAnalysisTaskSigma1385.cxx:647
 AliAnalysisTaskSigma1385.cxx:648
 AliAnalysisTaskSigma1385.cxx:649
 AliAnalysisTaskSigma1385.cxx:650
 AliAnalysisTaskSigma1385.cxx:651
 AliAnalysisTaskSigma1385.cxx:652
 AliAnalysisTaskSigma1385.cxx:653
 AliAnalysisTaskSigma1385.cxx:654
 AliAnalysisTaskSigma1385.cxx:655
 AliAnalysisTaskSigma1385.cxx:656
 AliAnalysisTaskSigma1385.cxx:657
 AliAnalysisTaskSigma1385.cxx:658
 AliAnalysisTaskSigma1385.cxx:659
 AliAnalysisTaskSigma1385.cxx:660
 AliAnalysisTaskSigma1385.cxx:661
 AliAnalysisTaskSigma1385.cxx:662
 AliAnalysisTaskSigma1385.cxx:663
 AliAnalysisTaskSigma1385.cxx:664
 AliAnalysisTaskSigma1385.cxx:665
 AliAnalysisTaskSigma1385.cxx:666
 AliAnalysisTaskSigma1385.cxx:667
 AliAnalysisTaskSigma1385.cxx:668
 AliAnalysisTaskSigma1385.cxx:669
 AliAnalysisTaskSigma1385.cxx:670
 AliAnalysisTaskSigma1385.cxx:671
 AliAnalysisTaskSigma1385.cxx:672
 AliAnalysisTaskSigma1385.cxx:673
 AliAnalysisTaskSigma1385.cxx:674
 AliAnalysisTaskSigma1385.cxx:675
 AliAnalysisTaskSigma1385.cxx:676
 AliAnalysisTaskSigma1385.cxx:677
 AliAnalysisTaskSigma1385.cxx:678
 AliAnalysisTaskSigma1385.cxx:679
 AliAnalysisTaskSigma1385.cxx:680
 AliAnalysisTaskSigma1385.cxx:681
 AliAnalysisTaskSigma1385.cxx:682
 AliAnalysisTaskSigma1385.cxx:683
 AliAnalysisTaskSigma1385.cxx:684
 AliAnalysisTaskSigma1385.cxx:685
 AliAnalysisTaskSigma1385.cxx:686
 AliAnalysisTaskSigma1385.cxx:687
 AliAnalysisTaskSigma1385.cxx:688
 AliAnalysisTaskSigma1385.cxx:689
 AliAnalysisTaskSigma1385.cxx:690
 AliAnalysisTaskSigma1385.cxx:691
 AliAnalysisTaskSigma1385.cxx:692
 AliAnalysisTaskSigma1385.cxx:693
 AliAnalysisTaskSigma1385.cxx:694
 AliAnalysisTaskSigma1385.cxx:695
 AliAnalysisTaskSigma1385.cxx:696
 AliAnalysisTaskSigma1385.cxx:697
 AliAnalysisTaskSigma1385.cxx:698
 AliAnalysisTaskSigma1385.cxx:699
 AliAnalysisTaskSigma1385.cxx:700
 AliAnalysisTaskSigma1385.cxx:701
 AliAnalysisTaskSigma1385.cxx:702
 AliAnalysisTaskSigma1385.cxx:703
 AliAnalysisTaskSigma1385.cxx:704
 AliAnalysisTaskSigma1385.cxx:705
 AliAnalysisTaskSigma1385.cxx:706
 AliAnalysisTaskSigma1385.cxx:707
 AliAnalysisTaskSigma1385.cxx:708
 AliAnalysisTaskSigma1385.cxx:709
 AliAnalysisTaskSigma1385.cxx:710
 AliAnalysisTaskSigma1385.cxx:711
 AliAnalysisTaskSigma1385.cxx:712
 AliAnalysisTaskSigma1385.cxx:713
 AliAnalysisTaskSigma1385.cxx:714
 AliAnalysisTaskSigma1385.cxx:715
 AliAnalysisTaskSigma1385.cxx:716
 AliAnalysisTaskSigma1385.cxx:717
 AliAnalysisTaskSigma1385.cxx:718
 AliAnalysisTaskSigma1385.cxx:719
 AliAnalysisTaskSigma1385.cxx:720
 AliAnalysisTaskSigma1385.cxx:721
 AliAnalysisTaskSigma1385.cxx:722
 AliAnalysisTaskSigma1385.cxx:723
 AliAnalysisTaskSigma1385.cxx:724
 AliAnalysisTaskSigma1385.cxx:725
 AliAnalysisTaskSigma1385.cxx:726
 AliAnalysisTaskSigma1385.cxx:727
 AliAnalysisTaskSigma1385.cxx:728
 AliAnalysisTaskSigma1385.cxx:729
 AliAnalysisTaskSigma1385.cxx:730
 AliAnalysisTaskSigma1385.cxx:731
 AliAnalysisTaskSigma1385.cxx:732
 AliAnalysisTaskSigma1385.cxx:733
 AliAnalysisTaskSigma1385.cxx:734
 AliAnalysisTaskSigma1385.cxx:735
 AliAnalysisTaskSigma1385.cxx:736
 AliAnalysisTaskSigma1385.cxx:737
 AliAnalysisTaskSigma1385.cxx:738
 AliAnalysisTaskSigma1385.cxx:739
 AliAnalysisTaskSigma1385.cxx:740
 AliAnalysisTaskSigma1385.cxx:741
 AliAnalysisTaskSigma1385.cxx:742
 AliAnalysisTaskSigma1385.cxx:743
 AliAnalysisTaskSigma1385.cxx:744
 AliAnalysisTaskSigma1385.cxx:745
 AliAnalysisTaskSigma1385.cxx:746
 AliAnalysisTaskSigma1385.cxx:747
 AliAnalysisTaskSigma1385.cxx:748
 AliAnalysisTaskSigma1385.cxx:749
 AliAnalysisTaskSigma1385.cxx:750
 AliAnalysisTaskSigma1385.cxx:751
 AliAnalysisTaskSigma1385.cxx:752
 AliAnalysisTaskSigma1385.cxx:753
 AliAnalysisTaskSigma1385.cxx:754
 AliAnalysisTaskSigma1385.cxx:755
 AliAnalysisTaskSigma1385.cxx:756
 AliAnalysisTaskSigma1385.cxx:757
 AliAnalysisTaskSigma1385.cxx:758
 AliAnalysisTaskSigma1385.cxx:759
 AliAnalysisTaskSigma1385.cxx:760
 AliAnalysisTaskSigma1385.cxx:761
 AliAnalysisTaskSigma1385.cxx:762
 AliAnalysisTaskSigma1385.cxx:763
 AliAnalysisTaskSigma1385.cxx:764
 AliAnalysisTaskSigma1385.cxx:765
 AliAnalysisTaskSigma1385.cxx:766
 AliAnalysisTaskSigma1385.cxx:767
 AliAnalysisTaskSigma1385.cxx:768
 AliAnalysisTaskSigma1385.cxx:769
 AliAnalysisTaskSigma1385.cxx:770
 AliAnalysisTaskSigma1385.cxx:771
 AliAnalysisTaskSigma1385.cxx:772
 AliAnalysisTaskSigma1385.cxx:773
 AliAnalysisTaskSigma1385.cxx:774
 AliAnalysisTaskSigma1385.cxx:775
 AliAnalysisTaskSigma1385.cxx:776
 AliAnalysisTaskSigma1385.cxx:777
 AliAnalysisTaskSigma1385.cxx:778
 AliAnalysisTaskSigma1385.cxx:779
 AliAnalysisTaskSigma1385.cxx:780
 AliAnalysisTaskSigma1385.cxx:781
 AliAnalysisTaskSigma1385.cxx:782
 AliAnalysisTaskSigma1385.cxx:783
 AliAnalysisTaskSigma1385.cxx:784
 AliAnalysisTaskSigma1385.cxx:785
 AliAnalysisTaskSigma1385.cxx:786
 AliAnalysisTaskSigma1385.cxx:787
 AliAnalysisTaskSigma1385.cxx:788
 AliAnalysisTaskSigma1385.cxx:789
 AliAnalysisTaskSigma1385.cxx:790
 AliAnalysisTaskSigma1385.cxx:791
 AliAnalysisTaskSigma1385.cxx:792
 AliAnalysisTaskSigma1385.cxx:793
 AliAnalysisTaskSigma1385.cxx:794
 AliAnalysisTaskSigma1385.cxx:795
 AliAnalysisTaskSigma1385.cxx:796