#include <TParticle.h>
#include <TParticlePDG.h>
#include <TH1F.h>
-#include <TH1F.h>
#include <TH2F.h>
+#include <TH3F.h>
+#include <THnSparse.h>
#include <TTree.h>
#include "TROOT.h"
#include <TDatabasePDG.h>
#include "AliAnalysisTaskSELc2V0bachelor.h"
#include "AliNormalizationCounter.h"
#include "AliAODPidHF.h"
-#include "AliPIDResponse.h"
-#include "AliTOFPIDResponse.h"
#include "AliInputEventHandler.h"
#include "AliESDtrackCuts.h"
#include "AliNeutralTrackParam.h"
fOutputAll(0),
fOutputPIDBach(0),
fCEvents(0),
- fPIDResponse(0),
fIsK0SAnalysis(kFALSE),
fCounter(0),
fAnalCuts(0),
fCandidateVariables(),
fVtx1(0),
fBzkG(0),
- fAdditionalChecks(kFALSE)
+ fAdditionalChecks(kFALSE),
+ fTrackRotation(kFALSE),
+ fOutputPIDBachTR(0),
+ fMinAngleForRot(5*TMath::Pi()/6),
+ fMaxAngleForRot(7*TMath::Pi()/6),
+ fMinMass(0),
+ fMaxMass(0),
+ fNRotations(9)
{
//
// Default ctor
//
+
+ Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
+ fMinMass=mLcPDG-0.250;
+ fMaxMass=mLcPDG+0.250;
+
}
//___________________________________________________________________________
AliAnalysisTaskSELc2V0bachelor::AliAnalysisTaskSELc2V0bachelor(const Char_t* name,
AliRDHFCutsLctoV0* analCuts, Bool_t useOnTheFly,
- Bool_t writeVariableTree, Bool_t additionalChecks) :
+ Bool_t writeVariableTree, Bool_t additionalChecks, Bool_t trackRotation) :
AliAnalysisTaskSE(name),
fUseMCInfo(kFALSE),
fOutput(0),
fOutputAll(0),
fOutputPIDBach(0),
fCEvents(0),
- fPIDResponse(0),
fIsK0SAnalysis(kFALSE),
fCounter(0),
fAnalCuts(analCuts),
fCandidateVariables(),
fVtx1(0),
fBzkG(0),
- fAdditionalChecks(additionalChecks)
+ fAdditionalChecks(additionalChecks),
+ fTrackRotation(trackRotation),
+ fOutputPIDBachTR(0),
+ fMinAngleForRot(5*TMath::Pi()/6),
+ fMaxAngleForRot(7*TMath::Pi()/6),
+ fMinMass(0),
+ fMaxMass(0),
+ fNRotations(9)
{
//
// Constructor. Initialization of Inputs and Outputs
//
Info("AliAnalysisTaskSELc2V0bachelor","Calling Constructor");
+ Double_t mLcPDG = TDatabasePDG::Instance()->GetParticle(4122)->Mass();
+ fMinMass=mLcPDG-0.250;
+ fMaxMass=mLcPDG+0.250;
+
DefineOutput(1,TList::Class()); //conters
DefineOutput(2,AliNormalizationCounter::Class());
DefineOutput(3,AliRDHFCutsLctoV0::Class());
if (!writeVariableTree) {
DefineOutput(4,TList::Class()); //All Entries output
DefineOutput(5,TList::Class()); //3sigma PID output
+ if (trackRotation) {
+ DefineOutput(6,TList::Class()); //All Entries output
+ }
} else {
// Output slot #4 keeps a tree of the candidate variables after track selection
DefineOutput(4,TTree::Class()); //My private output
fOutputPIDBach = 0;
}
- if (fPIDResponse) {
- delete fPIDResponse;
- }
-
if (fCounter) {
delete fCounter;
fCounter = 0;
fVariablesTree = 0;
}
+ if (fOutputPIDBachTR) {
+ delete fOutputPIDBachTR;
+ fOutputPIDBachTR = 0;
+ }
+
}
//_________________________________________________
void AliAnalysisTaskSELc2V0bachelor::Init() {
return;
}
fCEvents->Fill(5); // in case of MC events
+
+ Double_t zMCVertex = mcHeader->GetVtxZ();
+ if (TMath::Abs(zMCVertex) > fAnalCuts->GetMaxVtxZ()) {
+ AliDebug(2,Form("Event rejected: abs(zVtxMC)=%f > fAnalCuts->GetMaxVtxZ()=%f",zMCVertex,fAnalCuts->GetMaxVtxZ()));
+ return;
+ } else {
+ fCEvents->Fill(17); // in case of MC events
+ }
}
fCounter->StoreEvent(aodEvent,fAnalCuts,fUseMCInfo); // it is very important that it stays BEFORE any other event selection
if (!fWriteVariableTree) {
PostData(4,fOutputAll);
PostData(5,fOutputPIDBach);
+ if (fTrackRotation)
+ PostData(6,fOutputPIDBachTR);
} else {
PostData(4,fVariablesTree);
}
AliError("fOutputPIDBach not available");
return;
}
+
+ if (fTrackRotation) {
+ fOutputPIDBachTR = dynamic_cast<TList*> (GetOutputData(6));
+ if (!fOutputPIDBachTR) {
+ AliError("fOutputPIDBachTR not available");
+ return;
+ }
+ }
+
}
return;
void AliAnalysisTaskSELc2V0bachelor::UserCreateOutputObjects() {
// output
AliInfo(Form("CreateOutputObjects of task %s\n", GetName()));
-
- AliAnalysisManager *man=AliAnalysisManager::GetAnalysisManager();
- AliInputEventHandler* inputHandler = (AliInputEventHandler*) (man->GetInputEventHandler());
- fPIDResponse = inputHandler->GetPIDResponse();
-
- if (fAnalCuts->GetIsUsePID()){
- fAnalCuts->GetPidHF()->SetPidResponse(fPIDResponse);
- fAnalCuts->GetPidV0pos()->SetPidResponse(fPIDResponse);
- fAnalCuts->GetPidV0neg()->SetPidResponse(fPIDResponse);
- fAnalCuts->GetPidHF()->SetOldPid(kFALSE);
- fAnalCuts->GetPidV0pos()->SetOldPid(kFALSE);
- fAnalCuts->GetPidV0neg()->SetOldPid(kFALSE);
- }
fOutput = new TList();
fOutput->SetOwner();
fOutputPIDBach->SetOwner();
fOutputPIDBach->SetName("listPIDBach");
+ if (fTrackRotation) {
+ fOutputPIDBachTR = new TList();
+ fOutputPIDBachTR->SetOwner();
+ fOutputPIDBachTR->SetName("listPIDBachTR");
+ }
+
DefineAnalysisHistograms(); // define analysis histograms
PostData(4,fOutputAll);
PostData(5,fOutputPIDBach);
+
+ if (fTrackRotation)
+ PostData(6,fOutputPIDBachTR);
+
}
else {
DefineTreeVariables();
continue;
}
+ Bool_t unsetvtx=kFALSE;
+ if (!lcK0Spr->GetOwnPrimaryVtx()) {
+ lcK0Spr->SetOwnPrimaryVtx(fVtx1);
+ unsetvtx=kTRUE;
+ }
+
if (!lcK0Spr->GetSecondaryVtx()) {
AliInfo("No secondary vertex"); // it will be done in AliRDHFCutsLctoV0::IsSelected
continue;
AliAODTrack * v0Pos = dynamic_cast<AliAODTrack*>(lcK0Spr->Getv0PositiveTrack());
AliAODTrack * v0Neg = dynamic_cast<AliAODTrack*>(lcK0Spr->Getv0NegativeTrack());
- if (!v0Neg || !v0Neg) {
+ if (!v0Neg || !v0Pos) {
AliDebug(2,Form("V0 by cascade %d has no V0positive of V0negative object",iLctopK0S)); // it will be done in AliRDHFCutsLctoV0::IsSelected
continue;
}
isLc = 1;
}
} else {
- AliDebug(2,Form("No candidate (cascade number %d -total cascade number = %d -)", iLctopK0S,nCascades));
+ AliDebug(2,Form("No MC candidate (cascade number %d -total cascade number = %d -)", iLctopK0S,nCascades));
pdgCode=-1;
}
}
FillLc2pK0Sspectrum(lcK0Spr, isLc,
nSelectedAnal, cutsAnal,
mcArray);
+
+ if (unsetvtx) lcK0Spr->UnsetOwnPrimaryVtx();
+
}
AliDebug(2, Form("Found %d Reco particles that are Lc!!", nSelectedAnal));
Bool_t isInCascadeWindow = (((cutsAnal->IsSelectedSingleCut(part,AliRDHFCuts::kCandidate,0))&(AliRDHFCutsLctoV0::kLcToK0Spr))==(AliRDHFCutsLctoV0::kLcToK0Spr)); // cut on Lc->p+K0S invMass
cutsAnal->SetUsePID(areCutsUsingPID);
- //if ( !( !onFlyV0 || (onFlyV0 && fUseOnTheFlyV0) ) ) return;
if ( onFlyV0 && !fUseOnTheFlyV0 ) return;
if (fAdditionalChecks) CheckCandidatesAtDifferentLevels(part,cutsAnal);
- if ( !( ( (cutsAnal->IsSelected(part,AliRDHFCuts::kTracks))&(AliRDHFCutsLctoV0::kLcToK0Spr)) == (AliRDHFCutsLctoV0::kLcToK0Spr) ) ) return;
+ // track rotation
+ if (fTrackRotation) {
+ if (onFlyV0) {
+ TrackRotation(cutsAnal,part,"");
+ }
+ else {
+ TrackRotation(cutsAnal,part,"Offline");
+ }
+ if (fUseMCInfo) {
+ if (isLc==1) {
+ if (onFlyV0) {
+ TrackRotation(cutsAnal,part,"Sgn");
+ }
+ else {
+ TrackRotation(cutsAnal,part,"OfflineSgn");
+ }
+ }// sgn
+ else { // bkg
+ if (onFlyV0) {
+ TrackRotation(cutsAnal,part,"Bkg");
+ }
+ else {
+ TrackRotation(cutsAnal,part,"OfflineBkg");
+ }
+ }
+ } // if fUseMCInfo
+ } // if fTrackRotation
+
+
+
if ( !(cutsAnal->IsInFiducialAcceptance(part->Pt(),part->Y(4122))) ) return;
+ if ( !( ( (cutsAnal->IsSelected(part,AliRDHFCuts::kTracks))&(AliRDHFCutsLctoV0::kLcToK0Spr)) == (AliRDHFCutsLctoV0::kLcToK0Spr) ) ) return;
+
if ( ( ( (cutsAnal->IsSelected(part,AliRDHFCuts::kAll))&(AliRDHFCutsLctoV0::kLcToK0Spr)) == (AliRDHFCutsLctoV0::kLcToK0Spr) ) ) nSelectedAnal++;
// Fill candidate variable Tree (track selection, V0 invMass selection)
Double_t nSigmaTOFka=-999.;
cutsAnal->GetPidHF()->GetnSigmaTOF(bachelor,3,nSigmaTOFka);
- //if (onFlyV0 && fUseOnTheFlyV0) {
if (onFlyV0) {
-
- if (isCandidateSelectedCuts)
+ if (isCandidateSelectedCuts) {
FillAnalysisHistograms(part,isBachelorID,"");
-
+ }
}
- //else if (!onFlyV0) {
else {
-
if (isCandidateSelectedCuts) {
-
fillthis="histoprotonBachSigmaVspTOF";
((TH2F*)(fOutput->FindObject(fillthis)))->Fill(momBach,nSigmaTOFpr);
fillthis="histoprotonBachSigmaVspTPC";
((TH2F*)(fOutput->FindObject(fillthis)))->Fill(momBach,nSigmaTPCpr);
-
FillAnalysisHistograms(part,isBachelorID,"Offline");
-
}
-
}
-
-
if (fUseMCInfo) {
if (isLc==1) {
- //if (onFlyV0 && fUseOnTheFlyV0) {
if (onFlyV0) {
-
- if (isCandidateSelectedCuts)
+ if (isCandidateSelectedCuts) {
FillAnalysisHistograms(part,isBachelorID,"Sgn");
-
+ }
}
- //else if (!onFlyV0) {
else {
-
if (isCandidateSelectedCuts) {
-
fillthis="histoprotonBachSigmaVspTOFsgn";
((TH2F*)(fOutput->FindObject(fillthis)))->Fill(momBach,nSigmaTOFpr);
fillthis="histoprotonBachSigmaVspTPCsgn";
((TH2F*)(fOutput->FindObject(fillthis)))->Fill(momBach,nSigmaTPCpr);
-
FillAnalysisHistograms(part,isBachelorID,"OfflineSgn");
-
}
-
}
-
}// sgn
else { // bkg
- //if (onFlyV0 && fUseOnTheFlyV0) {
if (onFlyV0) {
-
- if (isCandidateSelectedCuts)
+ if (isCandidateSelectedCuts) {
FillAnalysisHistograms(part,isBachelorID,"Bkg");
-
+ }
}
- //else if (!onFlyV0) {
else {
-
if (isCandidateSelectedCuts) {
-
fillthis="histoprotonBachSigmaVspTOFbkg";
((TH2F*)(fOutput->FindObject(fillthis)))->Fill(momBach,nSigmaTOFpr);
fillthis="histoprotonBachSigmaVspTPCbkg";
((TH2F*)(fOutput->FindObject(fillthis)))->Fill(momBach,nSigmaTPCpr);
-
FillAnalysisHistograms(part,isBachelorID,"OfflineBkg");
}
-
}
-
}
} // if fUseMCInfo
-
+
return;
}
fOutputPIDBach->Add(pidBachdcatoPVvspK0S);
fOutputPIDBach->Add(pidBachcosV0PAwrtPVvspK0S);
+ if (fTrackRotation){
+ TH2F* pidBachTRspectrumLcMassByK0S = (TH2F*)spectrumLcMassByK0S->Clone();
+ fOutputPIDBachTR->Add(pidBachTRspectrumLcMassByK0S);
+ }
+
}
// V0 invariant masses (offline)
fOutputPIDBach->Add(pidBachdcatoPVvspK0SOffline);
fOutputPIDBach->Add(pidBachcosPAwrtPVvspK0SOffline);
+ if (fTrackRotation) {
+ TH2F* pidBachTRspectrumLcMassOfflineByK0S = (TH2F*)spectrumLcMassOfflineByK0S->Clone();
+ fOutputPIDBachTR->Add(pidBachTRspectrumLcMassOfflineByK0S);
+ }
+
if (fUseMCInfo) {
if (fUseOnTheFlyV0) {
TH2F* spectrumK0SMassBkg = new TH2F(nameBkg.Data(), "K^{0}_{S} - bkg: invariant mass VS p_{T} - MC; m_{inv}(#pi^{+}#pi^{-}) [GeV/c^{2}]; p_{T}(K^{0}_{S}) [GeV/c]; Entries",
1000,mK0SPDG-0.050,mK0SPDG+0.050,175,0.,35.);
- TH2F* allspectrumK0SMassSgn = (TH2F*)spectrumK0SMassSgn->Clone();
- TH2F* allspectrumK0SMassBkg = (TH2F*) spectrumK0SMassBkg->Clone();
- TH2F* pidBachspectrumK0SMassSgn = (TH2F*)spectrumK0SMassSgn->Clone();
- TH2F* pidBachspectrumK0SMassBkg = (TH2F*) spectrumK0SMassBkg->Clone();
- fOutputAll->Add(allspectrumK0SMassSgn);
- fOutputAll->Add(allspectrumK0SMassBkg);
- fOutputPIDBach->Add(pidBachspectrumK0SMassSgn);
- fOutputPIDBach->Add(pidBachspectrumK0SMassBkg);
-
-
nameSgn="histLcMassByK0SSgn";
nameBkg="histLcMassByK0SBkg";
TH2F* spectrumLcMassByK0SSgn = new TH2F(nameSgn.Data(), "#Lambda_{c} - sgn: invariant mass (by K^{0}_{S}) vs p_{T} - MC; m_{inv}(p-K^{0}_{S}) [GeV/c^{2}]; p_{T}",
1000,mLcPDG-0.250,mLcPDG+0.250,175,0.,35.);
TH2F* spectrumLcMassByK0SBkg = new TH2F(nameBkg.Data(), "#Lambda_{c} - bkg: invariant mass (by K^{0}_{S}) vs p_{T} - MC; m_{inv}(p-K^{0}_{S}) [GeV/c^{2}]; p_{T}",
1000,mLcPDG-0.250,mLcPDG+0.250,175,0.,35.);
-
- TH2F* allspectrumLcMassByK0SSgn = (TH2F*)spectrumLcMassByK0SSgn->Clone();
- TH2F* allspectrumLcMassByK0SBkg = (TH2F*) spectrumLcMassByK0SBkg->Clone();
- TH2F* pidBachspectrumLcMassByK0SSgn = (TH2F*)spectrumLcMassByK0SSgn->Clone();
- TH2F* pidBachspectrumLcMassByK0SBkg = (TH2F*) spectrumLcMassByK0SBkg->Clone();
- fOutputAll->Add(allspectrumLcMassByK0SSgn);
- fOutputAll->Add(allspectrumLcMassByK0SBkg);
- fOutputPIDBach->Add(pidBachspectrumLcMassByK0SSgn);
- fOutputPIDBach->Add(pidBachspectrumLcMassByK0SBkg);
-
nameSgn="histpK0SvspSgn";
nameBkg="histpK0SvspBkg";
TH2F* momentumDistributionK0SvspSgn= new TH2F(nameSgn.Data(),"#Lambda_{c} - sgn: K^{0}_{S} vs p Total Momentum Distribution - MC; p_{p}; p_{K^{0}_{S}}",
175,0.,35.,175,0.,35.);
TH2F* momentumDistributionK0SvspBkg= new TH2F(nameBkg.Data(),"#Lambda_{c} - bkg: K^{0}_{S} vs p Total Momentum Distribution - MC; p_{p}; p_{K^{0}_{S}}",
175,0.,35.,175,0.,35.);
-
- TH2F* allmomentumDistributionK0SvspSgn= (TH2F*)momentumDistributionK0SvspSgn->Clone();
- TH2F* allmomentumDistributionK0SvspBkg= (TH2F*)momentumDistributionK0SvspBkg->Clone();
- TH2F* pidBachmomentumDistributionK0SvspSgn= (TH2F*)momentumDistributionK0SvspSgn->Clone();
- TH2F* pidBachmomentumDistributionK0SvspBkg= (TH2F*)momentumDistributionK0SvspBkg->Clone();
- fOutputAll->Add(allmomentumDistributionK0SvspSgn);
- fOutputAll->Add(allmomentumDistributionK0SvspBkg);
- fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspSgn);
- fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspBkg);
-
-
// armenteros-podolanski plots K0S
nameSgn="histArmPodK0SSgn";
nameBkg="histArmPodK0SBkg";
200,-1.,1.,300,0.,0.3);
TH2F* armenterosPodK0SBkg = new TH2F(nameBkg.Data(),"K^{0}_{S} Armenteros-Podolanski distribution (bkg); #frac{p_{L}^{+}-p_{L}^{-}}{p_{L}^{+}+p_{L}^{-}}; p_{T}^{+} [GeV/c]",
200,-1.,1.,300,0.,0.3);
-
- TH2F* allArmenterosPodK0SSgn = (TH2F*)armenterosPodK0SSgn->Clone();
- TH2F* allArmenterosPodK0SBkg = (TH2F*)armenterosPodK0SBkg->Clone();
- TH2F* pidBachArmenterosPodK0SSgn = (TH2F*)armenterosPodK0SSgn->Clone();
- TH2F* pidBachArmenterosPodK0SBkg = (TH2F*)armenterosPodK0SBkg->Clone();
-
- fOutputAll->Add(allArmenterosPodK0SSgn);
- fOutputAll->Add(allArmenterosPodK0SBkg);
- fOutputPIDBach->Add(pidBachArmenterosPodK0SSgn);
- fOutputPIDBach->Add(pidBachArmenterosPodK0SBkg);
-
-
nameSgn="histDCAtoPVvspK0SSgn";
nameBkg="histDCAtoPVvspK0SBkg";
TH2F *dcatoPVvspK0SSgn=new TH2F(nameSgn.Data(),"K^{0}_{S} - sgn: DCA to Primary Vertex vs K^{0}_{S} invariant mass (sgn); p(K^{0}_{S}) [GeV/c]; DCA to Primary Vertex [n#sigmas]; Entries",175,0.,35.,50,0.,5.);
TH2F *dcatoPVvspK0SBkg=new TH2F(nameBkg.Data(),"K^{0}_{S} - bkg: DCA to Primary Vertex vs K^{0}_{S} invariant mass (bkg); p(K^{0}_{S}) [GeV/c]; DCA to Primary Vertex [n#sigmas]; Entries",175,0.,35.,50,0.,5.);
+ TH2F* allspectrumK0SMassSgn = (TH2F*)spectrumK0SMassSgn->Clone();
+ TH2F* allspectrumK0SMassBkg = (TH2F*) spectrumK0SMassBkg->Clone();
+ TH2F* allspectrumLcMassByK0SSgn = (TH2F*)spectrumLcMassByK0SSgn->Clone();
+ TH2F* allspectrumLcMassByK0SBkg = (TH2F*) spectrumLcMassByK0SBkg->Clone();
+ TH2F* allmomentumDistributionK0SvspSgn= (TH2F*)momentumDistributionK0SvspSgn->Clone();
+ TH2F* allmomentumDistributionK0SvspBkg= (TH2F*)momentumDistributionK0SvspBkg->Clone();
+ TH2F* allArmenterosPodK0SSgn = (TH2F*)armenterosPodK0SSgn->Clone();
+ TH2F* allArmenterosPodK0SBkg = (TH2F*)armenterosPodK0SBkg->Clone();
TH2F* alldcatoPVvspK0SSgn= (TH2F*)dcatoPVvspK0SSgn->Clone();
TH2F* alldcatoPVvspK0SBkg= (TH2F*)dcatoPVvspK0SBkg->Clone();
+
+ TH2F* pidBachspectrumK0SMassSgn = (TH2F*)spectrumK0SMassSgn->Clone();
+ TH2F* pidBachspectrumK0SMassBkg = (TH2F*) spectrumK0SMassBkg->Clone();
+ TH2F* pidBachspectrumLcMassByK0SSgn = (TH2F*)spectrumLcMassByK0SSgn->Clone();
+ TH2F* pidBachspectrumLcMassByK0SBkg = (TH2F*) spectrumLcMassByK0SBkg->Clone();
+ TH2F* pidBachmomentumDistributionK0SvspSgn= (TH2F*)momentumDistributionK0SvspSgn->Clone();
+ TH2F* pidBachmomentumDistributionK0SvspBkg= (TH2F*)momentumDistributionK0SvspBkg->Clone();
+ TH2F* pidBachArmenterosPodK0SSgn = (TH2F*)armenterosPodK0SSgn->Clone();
+ TH2F* pidBachArmenterosPodK0SBkg = (TH2F*)armenterosPodK0SBkg->Clone();
TH2F* pidBachdcatoPVvspK0SSgn= (TH2F*)dcatoPVvspK0SSgn->Clone();
TH2F* pidBachdcatoPVvspK0SBkg= (TH2F*)dcatoPVvspK0SBkg->Clone();
+ fOutputAll->Add(allspectrumK0SMassSgn);
+ fOutputAll->Add(allspectrumK0SMassBkg);
+ fOutputAll->Add(allspectrumLcMassByK0SSgn);
+ fOutputAll->Add(allspectrumLcMassByK0SBkg);
+ fOutputAll->Add(allmomentumDistributionK0SvspSgn);
+ fOutputAll->Add(allmomentumDistributionK0SvspBkg);
+ fOutputAll->Add(allArmenterosPodK0SSgn);
+ fOutputAll->Add(allArmenterosPodK0SBkg);
fOutputAll->Add(alldcatoPVvspK0SSgn);
- fOutputPIDBach->Add(pidBachdcatoPVvspK0SSgn);
fOutputAll->Add(alldcatoPVvspK0SBkg);
+
+ fOutputPIDBach->Add(pidBachspectrumK0SMassSgn);
+ fOutputPIDBach->Add(pidBachspectrumK0SMassBkg);
+ fOutputPIDBach->Add(pidBachspectrumLcMassByK0SSgn);
+ fOutputPIDBach->Add(pidBachspectrumLcMassByK0SBkg);
+ fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspSgn);
+ fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspBkg);
+ fOutputPIDBach->Add(pidBachArmenterosPodK0SSgn);
+ fOutputPIDBach->Add(pidBachArmenterosPodK0SBkg);
+ fOutputPIDBach->Add(pidBachdcatoPVvspK0SSgn);
fOutputPIDBach->Add(pidBachdcatoPVvspK0SBkg);
+ if (fTrackRotation) {
+ TH2F* pidBachTRspectrumLcMassByK0SSgn = (TH2F*)spectrumLcMassByK0SSgn->Clone();
+ TH2F* pidBachTRspectrumLcMassByK0SBkg = (TH2F*) spectrumLcMassByK0SBkg->Clone();
+ fOutputPIDBachTR->Add(pidBachTRspectrumLcMassByK0SSgn);
+ fOutputPIDBachTR->Add(pidBachTRspectrumLcMassByK0SBkg);
+ }
+
}
TH2F* spectrumK0SMassOfflineBkg = new TH2F(nameBkg.Data(), "K^{0}_{S} - bkg: invariant mass VS p_{T} - MC; m_{inv}(#pi^{+}-#pi^{-}) [GeV/c^{2}]; p_{T}(K^{0}_{S}) [GeV/c]; Entries",
1000,mK0SPDG-0.050,mK0SPDG+0.050,175,0.,35.);
- TH2F* allspectrumK0SMassOfflineSgn = (TH2F*)spectrumK0SMassOfflineSgn->Clone();
- TH2F* allspectrumK0SMassOfflineBkg = (TH2F*) spectrumK0SMassOfflineBkg->Clone();
- fOutputAll->Add(allspectrumK0SMassOfflineSgn);
- fOutputAll->Add(allspectrumK0SMassOfflineBkg);
-
-
- TH2F* pidBachspectrumK0SMassOfflineSgn = (TH2F*)spectrumK0SMassOfflineSgn->Clone();
- TH2F* pidBachspectrumK0SMassOfflineBkg = (TH2F*) spectrumK0SMassOfflineBkg->Clone();
- fOutputPIDBach->Add(pidBachspectrumK0SMassOfflineSgn);
- fOutputPIDBach->Add(pidBachspectrumK0SMassOfflineBkg);
-
-
nameSgn="histLcMassByK0SOfflineSgn";
nameBkg="histLcMassByK0SOfflineBkg";
TH2F* spectrumLcMassOfflineByK0SSgn = new TH2F(nameSgn.Data(), "#Lambda_{c} - sgn: invariant mass (by K^{0}_{S}) vs p_{T} - MC; M(#Lambda_{c}) [GeV/c^{2}]; p_{T}",
1000,mLcPDG-0.250,mLcPDG+0.250,175,0.,35.);
TH2F* spectrumLcMassOfflineByK0SBkg = new TH2F(nameBkg.Data(), "#Lambda_{c} - bkg: invariant mass (by K^{0}_{S}) vs p_{T} - MC; M(#Lambda_{c}) [GeV/c^{2}]; p_{T}",
1000,mLcPDG-0.250,mLcPDG+0.250,175,0.,35.);
-
-
- TH2F* allspectrumLcMassOfflineByK0SSgn = (TH2F*)spectrumLcMassOfflineByK0SSgn->Clone();
- TH2F* allspectrumLcMassOfflineByK0SBkg = (TH2F*) spectrumLcMassOfflineByK0SBkg->Clone();
- TH2F* pidBachspectrumLcMassOfflineByK0SSgn = (TH2F*)spectrumLcMassOfflineByK0SSgn->Clone();
- TH2F* pidBachspectrumLcMassOfflineByK0SBkg = (TH2F*) spectrumLcMassOfflineByK0SBkg->Clone();
- fOutputAll->Add(allspectrumLcMassOfflineByK0SSgn);
- fOutputAll->Add(allspectrumLcMassOfflineByK0SBkg);
- fOutputPIDBach->Add(pidBachspectrumLcMassOfflineByK0SSgn);
- fOutputPIDBach->Add(pidBachspectrumLcMassOfflineByK0SBkg);
-
-
nameSgn="histpK0SvspOfflineSgn";
nameBkg="histpK0SvspOfflineBkg";
TH2F* momentumDistributionK0SvspOfflineSgn= new TH2F(nameSgn.Data(),"#Lambda_{c} - sgn: K^{0}_{S} vs p Total Momentum Distribution - Offline - MC; p_{p}; p_{K^{0}_{S}}",
175,0.,35.,175,0.,35.);
TH2F* momentumDistributionK0SvspOfflineBkg= new TH2F(nameBkg.Data(),"#Lambda_{c} - bkg: K^{0}_{S} vs p Total Momentum Distribution - Offline - MC; p_{p}; p_{K^{0}_{S}}",
175,0.,35.,175,0.,35.);
-
-
- TH2F* allmomentumDistributionK0SvspOfflineSgn= (TH2F*)momentumDistributionK0SvspOfflineSgn->Clone();
- TH2F* allmomentumDistributionK0SvspOfflineBkg= (TH2F*)momentumDistributionK0SvspOfflineBkg->Clone();
- TH2F* pidBachmomentumDistributionK0SvspOfflineSgn= (TH2F*)momentumDistributionK0SvspOfflineSgn->Clone();
- TH2F* pidBachmomentumDistributionK0SvspOfflineBkg= (TH2F*)momentumDistributionK0SvspOfflineBkg->Clone();
- fOutputAll->Add(allmomentumDistributionK0SvspOfflineSgn);
- fOutputAll->Add(allmomentumDistributionK0SvspOfflineBkg);
- fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspOfflineSgn);
- fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspOfflineBkg);
-
-
-
-
-
// armenteros-podolanski plots K0S (offline)
nameSgn="histArmPodK0SOfflineSgn";
nameBkg="histArmPodK0SOfflineBkg";
200,-1.,1.,300,0.,0.3);
TH2F* armenterosPodK0SOffBkg = new TH2F(nameBkg.Data(),"K^{0}_{S} Armenteros-Podolanski distribution (bkg) -offline-; #frac{p_{L}^{+}-p_{L}^{-}}{p_{L}^{+}+p_{L}^{-}}; p_{T}^{+} [GeV/c]",
200,-1.,1.,300,0.,0.3);
-
-
- TH2F* allArmenterosPodK0SOffSgn = (TH2F*)armenterosPodK0SOffSgn->Clone();
- TH2F* allArmenterosPodK0SOffBkg = (TH2F*)armenterosPodK0SOffBkg->Clone();
- TH2F* pidBachArmenterosPodK0SOffSgn = (TH2F*)armenterosPodK0SOffSgn->Clone();
- TH2F* pidBachArmenterosPodK0SOffBkg = (TH2F*)armenterosPodK0SOffBkg->Clone();
-
-
- fOutputAll->Add(allArmenterosPodK0SOffSgn);
- fOutputAll->Add(allArmenterosPodK0SOffBkg);
- fOutputPIDBach->Add(pidBachArmenterosPodK0SOffSgn);
- fOutputPIDBach->Add(pidBachArmenterosPodK0SOffBkg);
-
-
nameSgn="histDCAtoPVvspK0SOfflineSgn";
nameBkg="histDCAtoPVvspK0SOfflineBkg";
TH2F *dcatoPVvspK0SOfflineSgn=new TH2F(nameSgn.Data(),"K^{0}_{S} -offline - (sgn): DCA to Primary Vertex vs K^{0}_{S} invariant mass; p(K^{0}_{S}) [GeV/c]; DCA to Primary Vertex [n#sigmas]; Entries",
175,0.,35.,50,0.,5.);
TH2F *dcatoPVvspK0SOfflineBkg=new TH2F(nameBkg.Data(),"K^{0}_{S} -offline - (bkg): DCA to Primary Vertex vs K^{0}_{S} invariant mass; p(K^{0}_{S}) [GeV/c]; DCA to Primary Vertex [n#sigmas]; Entries",
175,0.,35.,50,0.,5.);
-
+
+ TH2F* allspectrumK0SMassOfflineSgn = (TH2F*)spectrumK0SMassOfflineSgn->Clone();
+ TH2F* allspectrumK0SMassOfflineBkg = (TH2F*) spectrumK0SMassOfflineBkg->Clone();
+ TH2F* allspectrumLcMassOfflineByK0SSgn = (TH2F*)spectrumLcMassOfflineByK0SSgn->Clone();
+ TH2F* allspectrumLcMassOfflineByK0SBkg = (TH2F*) spectrumLcMassOfflineByK0SBkg->Clone();
+ TH2F* allmomentumDistributionK0SvspOfflineSgn= (TH2F*)momentumDistributionK0SvspOfflineSgn->Clone();
+ TH2F* allmomentumDistributionK0SvspOfflineBkg= (TH2F*)momentumDistributionK0SvspOfflineBkg->Clone();
+ TH2F* allArmenterosPodK0SOffSgn = (TH2F*)armenterosPodK0SOffSgn->Clone();
+ TH2F* allArmenterosPodK0SOffBkg = (TH2F*)armenterosPodK0SOffBkg->Clone();
TH2F* alldcatoPVvspK0SOfflineSgn= (TH2F*)dcatoPVvspK0SOfflineSgn->Clone();
- TH2F* pidBachdcatoPVvspK0SOfflineSgn= (TH2F*)dcatoPVvspK0SOfflineSgn->Clone();
TH2F* alldcatoPVvspK0SOfflineBkg= (TH2F*)dcatoPVvspK0SOfflineBkg->Clone();
- TH2F* pidBachdcatoPVvspK0SOfflineBkg= (TH2F*)dcatoPVvspK0SOfflineBkg->Clone();
-
+ TH2F* pidBachspectrumLcMassOfflineByK0SSgn = (TH2F*)spectrumLcMassOfflineByK0SSgn->Clone();
+ TH2F* pidBachspectrumLcMassOfflineByK0SBkg = (TH2F*) spectrumLcMassOfflineByK0SBkg->Clone();
+ TH2F* pidBachspectrumK0SMassOfflineSgn = (TH2F*)spectrumK0SMassOfflineSgn->Clone();
+ TH2F* pidBachspectrumK0SMassOfflineBkg = (TH2F*) spectrumK0SMassOfflineBkg->Clone();
+ TH2F* pidBachmomentumDistributionK0SvspOfflineSgn= (TH2F*)momentumDistributionK0SvspOfflineSgn->Clone();
+ TH2F* pidBachmomentumDistributionK0SvspOfflineBkg= (TH2F*)momentumDistributionK0SvspOfflineBkg->Clone();
+ TH2F* pidBachArmenterosPodK0SOffSgn = (TH2F*)armenterosPodK0SOffSgn->Clone();
+ TH2F* pidBachArmenterosPodK0SOffBkg = (TH2F*)armenterosPodK0SOffBkg->Clone();
+ TH2F* pidBachdcatoPVvspK0SOfflineSgn= (TH2F*)dcatoPVvspK0SOfflineSgn->Clone();
+ TH2F* pidBachdcatoPVvspK0SOfflineBkg= (TH2F*)dcatoPVvspK0SOfflineBkg->Clone();
+ fOutputAll->Add(allspectrumK0SMassOfflineSgn);
+ fOutputAll->Add(allspectrumK0SMassOfflineBkg);
+ fOutputAll->Add(allspectrumLcMassOfflineByK0SSgn);
+ fOutputAll->Add(allspectrumLcMassOfflineByK0SBkg);
+ fOutputAll->Add(allmomentumDistributionK0SvspOfflineSgn);
+ fOutputAll->Add(allmomentumDistributionK0SvspOfflineBkg);
+ fOutputAll->Add(allArmenterosPodK0SOffSgn);
+ fOutputAll->Add(allArmenterosPodK0SOffBkg);
fOutputAll->Add(alldcatoPVvspK0SOfflineSgn);
- fOutputPIDBach->Add(pidBachdcatoPVvspK0SOfflineSgn);
fOutputAll->Add(alldcatoPVvspK0SOfflineBkg);
+
+ fOutputPIDBach->Add(pidBachspectrumK0SMassOfflineSgn);
+ fOutputPIDBach->Add(pidBachspectrumK0SMassOfflineBkg);
+ fOutputPIDBach->Add(pidBachspectrumLcMassOfflineByK0SSgn);
+ fOutputPIDBach->Add(pidBachspectrumLcMassOfflineByK0SBkg);
+ fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspOfflineSgn);
+ fOutputPIDBach->Add(pidBachmomentumDistributionK0SvspOfflineBkg);
+ fOutputPIDBach->Add(pidBachArmenterosPodK0SOffSgn);
+ fOutputPIDBach->Add(pidBachArmenterosPodK0SOffBkg);
+ fOutputPIDBach->Add(pidBachdcatoPVvspK0SOfflineSgn);
fOutputPIDBach->Add(pidBachdcatoPVvspK0SOfflineBkg);
+ if (fTrackRotation) {
+ TH2F* pidBachTRspectrumLcMassOfflineByK0SSgn = (TH2F*)spectrumLcMassOfflineByK0SSgn->Clone();
+ TH2F* pidBachTRspectrumLcMassOfflineByK0SBkg = (TH2F*) spectrumLcMassOfflineByK0SBkg->Clone();
+ fOutputPIDBachTR->Add(pidBachTRspectrumLcMassOfflineByK0SSgn);
+ fOutputPIDBachTR->Add(pidBachTRspectrumLcMassOfflineByK0SBkg);
+ }
+
+ }
+
+
+ if (fTrackRotation) {
+
+ TH1F *hNormRotated=new TH1F("hNormRotated","",11,-0.5,10.5);
+ TH1F *hNormRotatedOffline=new TH1F("hNormRotatedOffline","",11,-0.5,10.5);
+ TH1F *hNormRotatedSgn=new TH1F("hNormRotatedSgn","",11,-0.5,10.5);
+ TH1F *hNormRotatedOfflineSgn=new TH1F("hNormRotatedOfflineSgn","",11,-0.5,10.5);
+ TH1F *hNormRotatedBkg=new TH1F("hNormRotatedBkg","",11,-0.5,10.5);
+ TH1F *hNormRotatedOfflineBkg=new TH1F("hNormRotatedOfflineBkg","",11,-0.5,10.5);
+ hNormRotated->Sumw2();
+ hNormRotatedOffline->Sumw2();
+ hNormRotatedSgn->Sumw2();
+ hNormRotatedOfflineSgn->Sumw2();
+ hNormRotatedBkg->Sumw2();
+ hNormRotatedOfflineBkg->Sumw2();
+ hNormRotated->SetMinimum(0);
+ hNormRotatedOffline->SetMinimum(0);
+ hNormRotatedSgn->SetMinimum(0);
+ hNormRotatedOfflineSgn->SetMinimum(0);
+ hNormRotatedBkg->SetMinimum(0);
+ hNormRotatedOfflineBkg->SetMinimum(0);
+
+ fOutputPIDBachTR->Add(hNormRotated);
+ fOutputPIDBachTR->Add(hNormRotatedOffline);
+ fOutputPIDBachTR->Add(hNormRotatedSgn);
+ fOutputPIDBachTR->Add(hNormRotatedOfflineSgn);
+ fOutputPIDBachTR->Add(hNormRotatedBkg);
+ fOutputPIDBachTR->Add(hNormRotatedOfflineBkg);
+
+ Int_t nMassBins=fMaxMass*1000.-fMinMass*1000.;
+ Double_t maxm=fMinMass+nMassBins*0.001;
+ TH3F *hMassVsPtVsY=new TH3F("hMassVsPtVsY","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYOffline=new TH3F("hMassVsPtVsYOffline","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYSgn=new TH3F("hMassVsPtVsYSgn","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYOfflineSgn=new TH3F("hMassVsPtVsYOfflineSgn","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYBkg=new TH3F("hMassVsPtVsYBkg","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYOfflineBkg=new TH3F("hMassVsPtVsYOfflineBkg","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+
+ hMassVsPtVsY->Sumw2();
+ hMassVsPtVsYOffline->Sumw2();
+ hMassVsPtVsYSgn->Sumw2();
+ hMassVsPtVsYOfflineSgn->Sumw2();
+ hMassVsPtVsYBkg->Sumw2();
+ hMassVsPtVsYOfflineBkg->Sumw2();
+ hMassVsPtVsY->SetMinimum(0);
+ hMassVsPtVsYOffline->SetMinimum(0);
+ hMassVsPtVsYSgn->SetMinimum(0);
+ hMassVsPtVsYOfflineSgn->SetMinimum(0);
+ hMassVsPtVsYBkg->SetMinimum(0);
+ hMassVsPtVsYOfflineBkg->SetMinimum(0);
+
+ fOutputPIDBachTR->Add(hMassVsPtVsY);
+ fOutputPIDBachTR->Add(hMassVsPtVsYOffline);
+ fOutputPIDBachTR->Add(hMassVsPtVsYSgn);
+ fOutputPIDBachTR->Add(hMassVsPtVsYOfflineSgn);
+ fOutputPIDBachTR->Add(hMassVsPtVsYBkg);
+ fOutputPIDBachTR->Add(hMassVsPtVsYOfflineBkg);
+
+ TH3F *hMassVsPtVsYRot=new TH3F("hMassVsPtVsYRot","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYRotOffline=new TH3F("hMassVsPtVsYRotOffline","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYRotSgn=new TH3F("hMassVsPtVsYRotSgn","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYRotOfflineSgn=new TH3F("hMassVsPtVsYRotOfflineSgn","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYRotBkg=new TH3F("hMassVsPtVsYRotBkg","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+ TH3F *hMassVsPtVsYRotOfflineBkg=new TH3F("hMassVsPtVsYRotOfflineBkg","",nMassBins,fMinMass,maxm,20,0.,10.,20,-1.,1.);
+
+ hMassVsPtVsYRot->Sumw2();
+ hMassVsPtVsYRotOffline->Sumw2();
+ hMassVsPtVsYRotSgn->Sumw2();
+ hMassVsPtVsYRotOfflineSgn->Sumw2();
+ hMassVsPtVsYRotBkg->Sumw2();
+ hMassVsPtVsYRotOfflineBkg->Sumw2();
+ hMassVsPtVsYRot->SetMinimum(0);
+ hMassVsPtVsYRotOffline->SetMinimum(0);
+ hMassVsPtVsYRotSgn->SetMinimum(0);
+ hMassVsPtVsYRotOfflineSgn->SetMinimum(0);
+ hMassVsPtVsYRotBkg->SetMinimum(0);
+ hMassVsPtVsYRotOfflineBkg->SetMinimum(0);
+
+ fOutputPIDBachTR->Add(hMassVsPtVsYRot);
+ fOutputPIDBachTR->Add(hMassVsPtVsYRotOffline);
+ fOutputPIDBachTR->Add(hMassVsPtVsYRotSgn);
+ fOutputPIDBachTR->Add(hMassVsPtVsYRotOfflineSgn);
+ fOutputPIDBachTR->Add(hMassVsPtVsYRotBkg);
+ fOutputPIDBachTR->Add(hMassVsPtVsYRotOfflineBkg);
+
+
+ TH1F *hDeltaMass=new TH1F("hDeltaMass","",100,-0.4,0.4);
+ TH1F *hDeltaMassOffline=new TH1F("hDeltaMassOffline","",100,-0.4,0.4);
+ TH1F *hDeltaMassSgn=new TH1F("hDeltaMassSgn","",100,-0.4,0.4);
+ TH1F *hDeltaMassOfflineSgn=new TH1F("hDeltaMassOfflineSgn","",100,-0.4,0.4);
+ TH1F *hDeltaMassBkg=new TH1F("hDeltaMassBkg","",100,-0.4,0.4);
+ TH1F *hDeltaMassOfflineBkg=new TH1F("hDeltaMassOfflineBkg","",100,-0.4,0.4);
+ hDeltaMass->Sumw2();
+ hDeltaMassOffline->Sumw2();
+ hDeltaMassSgn->Sumw2();
+ hDeltaMassOfflineSgn->Sumw2();
+ hDeltaMassBkg->Sumw2();
+ hDeltaMassOfflineBkg->Sumw2();
+
+ hDeltaMass->SetMinimum(0);
+ hDeltaMassOffline->SetMinimum(0);
+ hDeltaMassSgn->SetMinimum(0);
+ hDeltaMassOfflineSgn->SetMinimum(0);
+ hDeltaMassBkg->SetMinimum(0);
+ hDeltaMassOfflineBkg->SetMinimum(0);
+
+ fOutputPIDBachTR->Add(hDeltaMass);
+ fOutputPIDBachTR->Add(hDeltaMassOffline);
+ fOutputPIDBachTR->Add(hDeltaMassSgn);
+ fOutputPIDBachTR->Add(hDeltaMassOfflineSgn);
+ fOutputPIDBachTR->Add(hDeltaMassBkg);
+ fOutputPIDBachTR->Add(hDeltaMassOfflineBkg);
+
+ /*
+ Int_t binSparseDMassRot[5]={nMassBins,100,24,40,20};
+ Double_t edgeLowSparseDMassRot[5]={fMinMass,-0.4,0.,-4.,0};
+ Double_t edgeHighSparseDMassRot[5]={maxm,0.4,12.,4.,3.14};
+ THnSparse *hDeltaMassFullAnalysis=new THnSparseF("hDeltaMassFullAnalysis","hDeltaMassFullAnalysis;inv mass (GeV/c);#Delta inv mass (GeV/c) ; p_{T}^{#Lambda_{c}} (GeV/c); #Delta p_{T} (GeV/c); daughter angle (2prongs) (rad);",5,binSparseDMassRot,edgeLowSparseDMassRot,edgeHighSparseDMassRot);
+ THnSparse *hDeltaMassFullAnalysisOffline=new THnSparseF("fDeltaMassFullAnalysisOffline","hDeltaMassFullAnalysisOffline;inv mass (GeV/c);#Delta inv mass (GeV/c) ; p_{T}^{#Lambda_{c}} (GeV/c); #Delta p_{T} (GeV/c); daughter angle (2prongs) (rad);",5,binSparseDMassRot,edgeLowSparseDMassRot,edgeHighSparseDMassRot);
+
+ THnSparse *hDeltaMassFullAnalysisSgn=new THnSparseF("hDeltaMassFullAnalysisSgn","hDeltaMassFullAnalysisSgn;inv mass (GeV/c);#Delta inv mass (GeV/c) ; p_{T}^{#Lambda_{c}} (GeV/c); #Delta p_{T} (GeV/c); daughter angle (2prongs) (rad);",5,binSparseDMassRot,edgeLowSparseDMassRot,edgeHighSparseDMassRot);
+ THnSparse *hDeltaMassFullAnalysisOfflineSgn=new THnSparseF("fDeltaMassFullAnalysisOfflineSgn","hDeltaMassFullAnalysisOfflineSgn;inv mass (GeV/c);#Delta inv mass (GeV/c) ; p_{T}^{#Lambda_{c}} (GeV/c); #Delta p_{T} (GeV/c); daughter angle (2prongs) (rad);",5,binSparseDMassRot,edgeLowSparseDMassRot,edgeHighSparseDMassRot);
+
+ THnSparse *hDeltaMassFullAnalysisBkg=new THnSparseF("hDeltaMassFullAnalysisBkg","hDeltaMassFullAnalysisBkg;inv mass (GeV/c);#Delta inv mass (GeV/c) ; p_{T}^{#Lambda_{c}} (GeV/c); #Delta p_{T} (GeV/c); daughter angle (2prongs) (rad);",5,binSparseDMassRot,edgeLowSparseDMassRot,edgeHighSparseDMassRot);
+ THnSparse *hDeltaMassFullAnalysisOfflineBkg=new THnSparseF("fDeltaMassFullAnalysisOfflineBkg","hDeltaMassFullAnalysisOfflineBkg;inv mass (GeV/c);#Delta inv mass (GeV/c) ; p_{T}^{#Lambda_{c}} (GeV/c); #Delta p_{T} (GeV/c); daughter angle (2prongs) (rad);",5,binSparseDMassRot,edgeLowSparseDMassRot,edgeHighSparseDMassRot);
+
+ fOutputPIDBachTR->Add(hDeltaMassFullAnalysis);
+ fOutputPIDBachTR->Add(hDeltaMassFullAnalysisOffline);
+ fOutputPIDBachTR->Add(hDeltaMassFullAnalysisSgn);
+ fOutputPIDBachTR->Add(hDeltaMassFullAnalysisOfflineSgn);
+ fOutputPIDBachTR->Add(hDeltaMassFullAnalysisBkg);
+ fOutputPIDBachTR->Add(hDeltaMassFullAnalysisOfflineBkg);
+ */
}
return;
Int_t isDp2K0Spi=0, isDs2K0SK=0;
Int_t mcLabel2 = -1;
Int_t mcLabel3 = -1;
+ Int_t isKstar12K0Spi=0, isKstar22K0Spi=0;
+ Int_t mcLabel4 = -1;
+ Int_t mcLabel5 = -1;
+ Double_t ptCandByMC = 0.;//fmcPartCandidate->Pt();
+ Double_t yCandByMC = 0.;//fmcPartCandidate->Y() ;
if (fUseMCInfo) {
+ if (isLc) {
+ Int_t pdgCand0 = 4122;
+ Int_t pdgDgLctoV0bachelor0[2]={2212,310};
+ Int_t pdgDgV0toDaughters0[2]={211,211};
+ Int_t mcLabelLc2pK0S = part->MatchToMC(pdgCand0,pdgDgLctoV0bachelor0[1],pdgDgLctoV0bachelor0,pdgDgV0toDaughters0,mcArray,kTRUE);
+ AliAODMCParticle *lambdaCpartMC = (AliAODMCParticle*)mcArray->At(mcLabelLc2pK0S);
+ if (lambdaCpartMC) {
+ ptCandByMC = lambdaCpartMC->Pt();
+ yCandByMC = lambdaCpartMC->Y() ;
+ }
+ }
+
Int_t pdgCand = 4122;
Int_t pdgDgLctoV0bachelor[2]={211,3122};
Int_t pdgDgV0toDaughters[2]={2212,211};
if (mcLabel!=-1) {
if (bachelor->Charge()==-1) isLc2LBarpi=1;
if (bachelor->Charge()==+1) isLc2Lpi=1;
+ AliAODMCParticle *lambdaCpartMC = (AliAODMCParticle*)mcArray->At(mcLabel);
+ if (lambdaCpartMC) {
+ ptCandByMC = lambdaCpartMC->Pt();
+ yCandByMC = lambdaCpartMC->Y() ;
+ }
}
Int_t pdgCand2 = 411; // D+ -> pi+ K0S
pdgDgV0toDaughters[1]=211;
mcLabel2 = part->MatchToMC(pdgCand2,pdgDgCand2[1],pdgDgCand2,pdgDgV0toDaughters,mcArray,kTRUE);
mcLabel3 = part->MatchToMC(pdgCand3,pdgDgCand3[1],pdgDgCand3,pdgDgV0toDaughters,mcArray,kTRUE);
- if (mcLabel2!=-1) isDp2K0Spi=1;
- if (mcLabel3!=-1) isDs2K0SK=1;
+ if (mcLabel2!=-1) {
+ isDp2K0Spi=1;
+ AliAODMCParticle *lambdaCpartMC = (AliAODMCParticle*)mcArray->At(mcLabel2);
+ if (lambdaCpartMC) {
+ ptCandByMC = lambdaCpartMC->Pt();
+ yCandByMC = lambdaCpartMC->Y() ;
+ }
+ }
+ if (mcLabel3!=-1) {
+ isDs2K0SK=1;
+ AliAODMCParticle *lambdaCpartMC = (AliAODMCParticle*)mcArray->At(mcLabel3);
+ if (lambdaCpartMC) {
+ ptCandByMC = lambdaCpartMC->Pt();
+ yCandByMC = lambdaCpartMC->Y() ;
+ }
+ }
+
+ Int_t pdgCand4 = 313; // K*(892)+ -> pi+ K0S
+ Int_t pdgCand5 = 325; // K*(1430)+ -> pi+ K0S
+ Int_t pdgDgCand4[2]={211,310};
+ Int_t pdgDgCand5[2]={211,310};
+ pdgDgV0toDaughters[0]=211;
+ pdgDgV0toDaughters[1]=211;
+ mcLabel4 = part->MatchToMC(pdgCand4,pdgDgCand4[1],pdgDgCand4,pdgDgV0toDaughters,mcArray,kTRUE);
+ mcLabel5 = part->MatchToMC(pdgCand5,pdgDgCand5[1],pdgDgCand5,pdgDgV0toDaughters,mcArray,kTRUE);
+ if (mcLabel4!=-1) {
+ isKstar12K0Spi=1;
+ AliAODMCParticle *lambdaCpartMC = (AliAODMCParticle*)mcArray->At(mcLabel4);
+ if (lambdaCpartMC) {
+ ptCandByMC = lambdaCpartMC->Pt();
+ yCandByMC = lambdaCpartMC->Y() ;
+ }
+ }
+ if (mcLabel5!=-1) {
+ isKstar22K0Spi=1;
+ AliAODMCParticle *lambdaCpartMC = (AliAODMCParticle*)mcArray->At(mcLabel5);
+ if (lambdaCpartMC) {
+ ptCandByMC = lambdaCpartMC->Pt();
+ yCandByMC = lambdaCpartMC->Y() ;
+ }
+ }
}
- Int_t isLcByMC = isLc+isLc2LBarpi*2+isLc2Lpi*4+isDp2K0Spi*8+isDs2K0SK*16;
+ Int_t isLcByMC = isLc+isLc2LBarpi*2+isLc2Lpi*4+isDp2K0Spi*8+isDs2K0SK*16+isKstar12K0Spi*32+isKstar22K0Spi*64;
+
+ Bool_t isMCparticleInFiducialAcceptance = kTRUE;
+ if (isLc || isLc2LBarpi || isLc2Lpi || isDp2K0Spi || isDs2K0SK || isKstar12K0Spi || isKstar22K0Spi) {
+ isMCparticleInFiducialAcceptance = cutsAnal->IsInFiducialAcceptance(ptCandByMC,yCandByMC);
+ }
Int_t isK0S = 0;
Int_t isLambda = 0;
cutsAnal->SetUsePID(areCutsUsingPID);
*/
- fCandidateVariables[ 0] = fUseMCInfo+isLcByMC; // 0: real data; 1: bkg; 2: Lc->K0S+p; 3: Lc->LambdaBar+pbar; 5: Lc->Lambda+p
+ fCandidateVariables[ 0] = fUseMCInfo+isLcByMC; // 0: real data; 1: bkg; 2: Lc->K0S+p; 3: Lc->LambdaBar+pbar; 5: Lc->Lambda+p; 9: D+->K0S+pi; 17: Ds+->K0S+K; 33: K*+->K0S+pi; 65: K*+->K0S+K
fCandidateVariables[ 1] = fUseMCInfo+isV0ByMC; // 0: real data; 1: bkg; 2: K0S->pi+pi; 3: LambdaBar->pbar+pi+; 5: Lambda->p+pi-
fCandidateVariables[ 2] = isBachelorSelected;
fCandidateVariables[ 3] = areV0daughtersSelected;
AliAODMCParticle *partLc = dynamic_cast<AliAODMCParticle*>(mcArray->At(mcLabel3));
AliAODMCParticle *partLcDaug0 = dynamic_cast<AliAODMCParticle*>(mcArray->At(partLc->GetDaughter(0)));
xLcMC=partLcDaug0->Xv(), yLcMC=partLcDaug0->Yv(), zLcMC=partLcDaug0->Zv();
+ } else if (isKstar12K0Spi) {
+ AliAODMCParticle *partLc = dynamic_cast<AliAODMCParticle*>(mcArray->At(mcLabel4));
+ AliAODMCParticle *partLcDaug0 = dynamic_cast<AliAODMCParticle*>(mcArray->At(partLc->GetDaughter(0)));
+ xLcMC=partLcDaug0->Xv(), yLcMC=partLcDaug0->Yv(), zLcMC=partLcDaug0->Zv();
+ } else if (isKstar22K0Spi) {
+ AliAODMCParticle *partLc = dynamic_cast<AliAODMCParticle*>(mcArray->At(mcLabel5));
+ AliAODMCParticle *partLcDaug0 = dynamic_cast<AliAODMCParticle*>(mcArray->At(partLc->GetDaughter(0)));
+ xLcMC=partLcDaug0->Xv(), yLcMC=partLcDaug0->Yv(), zLcMC=partLcDaug0->Zv();
}
fCandidateVariables[55]=dcaForLc;
fCandidateVariables[56]=part->GetSecVtxX();
fCandidateVariables[77]=v0part->Y(310);
fCandidateVariables[78]=pzVtxBachelor;
fCandidateVariables[79]=v0part->Pz();
+ fCandidateVariables[80]=bachelor->Charge();
+ fCandidateVariables[81]=isMCparticleInFiducialAcceptance;
+ if (fUseMCInfo) {
+ fCandidateVariables[82]=0;
+ if (bachelor->GetLabel()!=-1) {
+ AliAODMCParticle *partBachelor = dynamic_cast<AliAODMCParticle*>(mcArray->At(TMath::Abs(bachelor->GetLabel())));
+ if(partBachelor) fCandidateVariables[82]=partBachelor->GetPdgCode();
+ }
+ } else {
+ fCandidateVariables[82]=-1;
+ }
+ fCandidateVariables[83] = part->InvMass2Prongs(0,1,211,310); // Kstar( 892)+ -> pi+K0S
+ fCandidateVariables[84] = part->InvMass2Prongs(0,1,321,310); // Kstar(1430)+ -> pi+K0S
+
+ fCandidateVariables[85]=0;
+ fCandidateVariables[86]=0;
+ fCandidateVariables[87]=0;
+ fCandidateVariables[88]=0;
+ if (fUseMCInfo) {
+ if (v0pos->GetLabel()!=-1 &&
+ v0neg->GetLabel()!=-1) {
+ const Int_t ndg=2;
+ Int_t dgLabels[ndg]={TMath::Abs(v0pos->GetLabel()),
+ TMath::Abs(v0neg->GetLabel())};
+ Int_t ndgCk=0;
+ Int_t *pdgDg=0;
+ Int_t absLabelMother=-1;
+ Int_t nDauCand=-1;
+ fCandidateVariables[88]=SearchForCommonMother(mcArray,
+ dgLabels,ndg,ndgCk,pdgDg,absLabelMother,nDauCand);
+ }
+ if (bachelor->GetLabel()!=-1 &&
+ v0pos->GetLabel()!=-1 &&
+ v0neg->GetLabel()!=-1) {
+ const Int_t ndg=3;
+ Int_t dgLabels[ndg]={TMath::Abs(bachelor->GetLabel()),
+ TMath::Abs(v0pos->GetLabel()),
+ TMath::Abs(v0neg->GetLabel())};
+ Int_t ndgCk=0;
+ Int_t *pdgDg=0;
+ Int_t absLabelMother=-1;
+ Int_t nDauCand=-1;
+ fCandidateVariables[85]=SearchForCommonMother(mcArray,
+ dgLabels,ndg,ndgCk,pdgDg,absLabelMother,nDauCand);
+ AliAODMCParticle *part1 = dynamic_cast<AliAODMCParticle*>(mcArray->At(TMath::Abs(v0pos->GetLabel())));
+ AliAODMCParticle *part2 = dynamic_cast<AliAODMCParticle*>(mcArray->At(TMath::Abs(v0neg->GetLabel())));
+ if(part1) fCandidateVariables[86]=part1->GetPdgCode();
+ if(part2) fCandidateVariables[87]=part2->GetPdgCode();
+ }
+ }
+
+ AliAnalysisManager *mgr = AliAnalysisManager::GetAnalysisManager();
+ AliInputEventHandler *inputHandler=(AliInputEventHandler*)mgr->GetInputEventHandler();
+ AliPIDResponse *pidResponse=inputHandler->GetPIDResponse();
+ fCandidateVariables[89]=pidResponse->GetTOFResponse().GetStartTimeMask(bachelor->P());
//fCandidateVariables[65] = bachelor->Px();
//fCandidateVariables[66] = bachelor->Py();
const char* nameoutput = GetOutputSlot(4)->GetContainer()->GetName();
fVariablesTree = new TTree(nameoutput,"Candidates variables tree");
- Int_t nVar = 80;
+ Int_t nVar = 90;
fCandidateVariables = new Float_t [nVar];
TString * fCandidateVariableNames = new TString[nVar];
fCandidateVariableNames[ 0]="isLcByMC";
fCandidateVariableNames[77]="yV0";
fCandidateVariableNames[78]="pzVtxBachelorGood";
fCandidateVariableNames[79]="pzVtxV0";
+ fCandidateVariableNames[80]="bachelorCharge";
+ fCandidateVariableNames[81]="isMCparticleInFiducialAcceptance";
+ fCandidateVariableNames[82]="pdgBachelor"; // pdg MC bachelor
+ fCandidateVariableNames[83]="massKstar12K0Spi"; // Kstar( 892)+ -> pi+ K0S
+ fCandidateVariableNames[84]="massKstar22K0Spi"; // Kstar(1430)+ -> pi+ K0S
+ fCandidateVariableNames[85]="pdgCandidate"; // pdg MC candidate recovered via new method
+ fCandidateVariableNames[86]="pdgV0pos"; // pdg MC V0 positive
+ fCandidateVariableNames[87]="pdgV0neg"; // pdg MC V0 negative
+ fCandidateVariableNames[88]="pdgV0Candidate"; // pdg MC V0candidate recovered via new method
+ fCandidateVariableNames[89]="startTimeMask"; // start time mask
//fCandidateVariableNames[65]="bachelorPx";
//fCandidateVariableNames[66]="bachelorPy";
// This is to define general histograms
//
- fCEvents = new TH1F("fCEvents","conter",17,0,17);
+ fCEvents = new TH1F("fCEvents","conter",18,0,18);
fCEvents->SetStats(kTRUE);
fCEvents->GetXaxis()->SetBinLabel(1,"X1");
fCEvents->GetXaxis()->SetBinLabel(2,"Analyzed events");
fCEvents->GetXaxis()->SetBinLabel(15,Form("zVtx<=%2.0fcm",fAnalCuts->GetMaxVtxZ()));
fCEvents->GetXaxis()->SetBinLabel(16,"!IsEventSelected");
fCEvents->GetXaxis()->SetBinLabel(17,"triggerMask!=kAnyINT || triggerClass!=CINT1");
+ fCEvents->GetXaxis()->SetBinLabel(18,Form("zVtxMC<=%2.0fcm",fAnalCuts->GetMaxVtxZ()));
//fCEvents->GetXaxis()->SetTitle("");
fCEvents->GetYaxis()->SetTitle("counts");
Double_t dcaV0ptp = v0part->GetDCA();
Double_t invmassK0S = v0part->MassK0Short();
- fillthis="histK0SMass"+appendthis;
- cout << fillthis << endl;
- ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(invmassK0S,ptK0S);
- if (isBachelorID) ((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(invmassK0S,ptK0S);
+ fillthis="histK0SMass"+appendthis;
+ // cout << fillthis << endl;
+ ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(invmassK0S,ptK0S);
+ if (isBachelorID) ((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(invmassK0S,ptK0S);
- fillthis="histpK0Svsp"+appendthis;
- cout << fillthis << endl;
- ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(momBach,momK0S);
- if (isBachelorID) ((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(momBach,momK0S);
+ fillthis="histpK0Svsp"+appendthis;
+ // cout << fillthis << endl;
+ ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(momBach,momK0S);
+ if (isBachelorID) ((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(momBach,momK0S);
- fillthis="histDCAtoPVvspK0S"+appendthis;
- cout << fillthis << endl;
- ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(momK0S,dcaV0ptp);
- if (isBachelorID) ((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(momK0S,dcaV0ptp);
+ fillthis="histDCAtoPVvspK0S"+appendthis;
+ // cout << fillthis << endl;
+ ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(momK0S,dcaV0ptp);
+ if (isBachelorID) ((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(momK0S,dcaV0ptp);
- fillthis="histArmPodK0S"+appendthis;
- cout << fillthis << endl;
- FillArmPodDistribution(v0part,fillthis,fOutputAll);
- if (isBachelorID) FillArmPodDistribution(v0part,fillthis,fOutputPIDBach);
+ fillthis="histArmPodK0S"+appendthis;
+ // cout << fillthis << endl;
+ FillArmPodDistribution(v0part,fillthis,fOutputAll);
+ if (isBachelorID) FillArmPodDistribution(v0part,fillthis,fOutputPIDBach);
- fillthis="histLcMassByK0S"+appendthis;
- cout << fillthis << endl;
- ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(invmassLc,lambdacpt);
- if (isBachelorID)((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(invmassLc,lambdacpt);
+ fillthis="histLcMassByK0S"+appendthis;
+ // cout << fillthis << endl;
+ ((TH2F*)(fOutputAll->FindObject(fillthis)))->Fill(invmassLc,lambdacpt);
+ if (isBachelorID)((TH2F*)(fOutputPIDBach->FindObject(fillthis)))->Fill(invmassLc,lambdacpt);
- return;
+ return;
}
//---------------------------
Double_t AliAnalysisTaskSELc2V0bachelor::PropagateToDCA(AliAODv0 *v, AliAODTrack *bachelor, Double_t b,
return a00*Det(a11,a12,a21,a22)-a01*Det(a10,a12,a20,a22)+a02*Det(a10,a11,a20,a21);
}
+//----------------------------------------------------------------------------
+Int_t AliAnalysisTaskSELc2V0bachelor::MatchToMClabelC(AliAODRecoCascadeHF *candidate,
+ TClonesArray *mcArray)
+{
+ //
+ // Check if this candidate is matched to a MC signal Lc -> p K0S + X
+ // If no, return -1
+ // If yes, return label (>=0) of the AliAODMCParticle
+ //
+
+ AliAODv0 *theV0 = dynamic_cast<AliAODv0*>(candidate->Getv0()); // the V0
+ AliVTrack *trk = dynamic_cast<AliVTrack*>(candidate->GetBachelor()); // the bachelor
+ if (!trk || !theV0) return -1;
+
+ if (trk->GetLabel()==-1) return -1;
+ Int_t bachLabels = TMath::Abs(trk->GetLabel());
+ AliAODMCParticle*bachelorMC = dynamic_cast<AliAODMCParticle*>(mcArray->At(bachLabels));
+ if (!bachelorMC) return -1;
+ if (TMath::Abs(bachelorMC->GetPdgCode())!=2212) return -1;
+ Int_t indexMotherBach = bachelorMC->GetMother();
+ if (indexMotherBach==-1) return -1;
+
+ Int_t pdgDg2prong[2] = {211,211};
+ Int_t lab2Prong = theV0->MatchToMC(310,mcArray,2,pdgDg2prong); // the V0
+ if(lab2Prong<0) return -1;
+ AliAODMCParticle*partK0S = dynamic_cast<AliAODMCParticle*>(mcArray->At(lab2Prong));
+ if (!partK0S) return -1;
+ Int_t indexMotherK0S = partK0S->GetMother();
+ if (indexMotherK0S==-1) return -1;
+ AliAODMCParticle*partK0 = dynamic_cast<AliAODMCParticle*>(mcArray->At(indexMotherK0S));
+ if (!partK0) return -1;
+ Int_t indexMotherK0 = partK0->GetMother();
+ if (indexMotherK0==-1) return -1;
+
+ if (indexMotherBach!=indexMotherK0) return -1; // p e K0S sono fratelli
+
+ AliAODMCParticle*partLc = dynamic_cast<AliAODMCParticle*>(mcArray->At(indexMotherK0));
+ if (!partLc) return -1;
+ Int_t ndg2 = partLc->GetDaughter(1)-partLc->GetDaughter(0)+1;
+ if (ndg2==2) return -1;
+
+ TString stringaCheck = Form(">>>>>>>> %d -> ",partLc->GetPdgCode());
+ for(Int_t ii=0; ii<ndg2; ii++) {
+ AliAODMCParticle* partDau=(AliAODMCParticle*)(mcArray->At(partLc->GetDaughter(0)+ii));
+ stringaCheck.Append(Form(" %d",partDau->GetPdgCode()));
+ }
+ //printf("%s \n",stringaCheck.Data());
+
+ return indexMotherBach;
+
+}
+//--------------------------------------------------------------------------
+Int_t AliAnalysisTaskSELc2V0bachelor::SearchForCommonMother(TClonesArray *mcArray,
+ Int_t dgLabels[10],Int_t ndg,
+ Int_t &ndgCk, Int_t *pdgDg, Int_t &absLabelMother, Int_t &nDauCand) const
+{
+ //
+ // Check if this candidate is matched to a MC signal
+ // If no, return 0
+ // If yes, return pdgCode of particle
+ //
+
+ Int_t lab=-1,labMother=-1,pdgMother=0;
+ AliAODMCParticle *part=0;
+ AliAODMCParticle *mother=0;
+
+ // loop on daughter labels
+ TArrayI **labelMother = new TArrayI*[ndg];
+ for(Int_t i=0; i<ndg; i++) labelMother[i] = new TArrayI(0);
+ for(Int_t i=0; i<ndg; i++) {
+ lab = TMath::Abs(dgLabels[i]);
+ if(lab<0) {
+ AliDebug(2,Form("daughter with negative label %d",lab));
+ return 0;
+ }
+ part = (AliAODMCParticle*)mcArray->At(lab);
+ if(!part) {
+ AliDebug(2,"no MC particle");
+ return 0;
+ }
+
+ mother = part;
+ while(mother->GetMother()>=0) {
+ labMother=mother->GetMother();
+ mother = (AliAODMCParticle*)mcArray->At(labMother);
+ if(!mother) {
+ AliDebug(2,"no MC mother particle");
+ break;
+ }
+ pdgMother = TMath::Abs(mother->GetPdgCode());
+ if (pdgMother<10 || (pdgMother>18 && pdgMother<111)) {
+ break;
+ }
+ labelMother[i]->Set(labelMother[i]->GetSize()+1);
+ labelMother[i]->AddAt(labMother,labelMother[i]->GetSize()-1);
+ }
+
+ } // end loop on daughters
+
+
+ TString stringaCheck;
+ for(Int_t i=0; i<ndg; i++) {
+ AliAODMCParticle*part0 = (AliAODMCParticle*)mcArray->At(TMath::Abs(dgLabels[i]));
+ stringaCheck.Append(Form("part[%d]->GetLabel()=%d(%d) | ",i,dgLabels[i],part0->GetPdgCode()));
+ stringaCheck.Append(Form("labelMother[%d] = ",i));
+ for (Int_t jj=0;jj<labelMother[i]->GetSize(); jj++)
+ stringaCheck.Append(Form("%d, ",labelMother[i]->At(jj)));
+ }
+ printf("%s \n",stringaCheck.Data());
+ Int_t pdgToBeReturned=0;
+
+ TString stringaCheck2;
+ ndgCk=ndg;
+ pdgDg = new Int_t[ndgCk];
+ for (Int_t index=1; index<ndg; index++) {
+ Bool_t found=kFALSE;
+ for (Int_t jj=0;jj<labelMother[index]->GetSize(); jj++) {
+ for (Int_t ii=0;ii<labelMother[0]->GetSize(); ii++) {
+ if (labelMother[0]->At(ii)==labelMother[index]->At(jj) &&
+ labelMother[0]->At(ii)!=0 && labelMother[0]->At(ii)!=1 && !found) {
+ mother = (AliAODMCParticle*)mcArray->At(labelMother[0]->At(ii));
+ pdgToBeReturned=mother->GetPdgCode();
+ absLabelMother=labelMother[0]->At(ii);
+ AliDebug(2,Form("FOUND label for the mother of this candidate: %d (PDG=%d)\n",labelMother[0]->At(ii),pdgToBeReturned));
+ //mother->Print();
+ nDauCand=mother->GetNDaughters();
+ found = kTRUE;
+ AliAODMCParticle *partMC = (AliAODMCParticle*)mcArray->At(dgLabels[0]);
+ pdgDg[0]=partMC->GetPdgCode();
+ partMC = (AliAODMCParticle*)mcArray->At(dgLabels[index]);
+ pdgDg[index]=partMC->GetPdgCode();
+ if (index==1) stringaCheck2.Append(Form("found daughters -> %d(%d)",dgLabels[0],pdgDg[0]));
+ stringaCheck2.Append(Form(" %d(%d)",dgLabels[index],pdgDg[index]));
+ break;
+ }
+ }
+ if (found) break;
+ }
+ }
+ stringaCheck2.Prepend(Form("Ecco quanto trovato: %d(%d) with %d daughters; ",absLabelMother,pdgToBeReturned,nDauCand));
+ printf("%s \n",stringaCheck2.Data());
+
+ delete [] labelMother;
+
+ return pdgToBeReturned;
+
+}
+
+void AliAnalysisTaskSELc2V0bachelor::TrackRotation(AliRDHFCutsLctoV0 * cuts, AliAODRecoCascadeHF *part, TString appendthis)
+{
+
+ AliAODRecoCascadeHF *partCopy = new AliAODRecoCascadeHF(*part);
+
+ Double_t px[2]={partCopy->PxProng(0),partCopy->PxProng(1)};
+ Double_t py[2]={partCopy->PyProng(0),partCopy->PyProng(1)};
+ Double_t pz[2]={partCopy->PzProng(0),partCopy->PzProng(1)};
+
+ Double_t pt = partCopy->Pt();
+ Int_t pdgD=4122;
+ UInt_t pdgLc2pK0S[2]={2212,310};
+ Double_t minv2 = partCopy->InvMass2(2,pdgLc2pK0S);
+ Double_t mass=TMath::Sqrt(minv2);
+ Double_t rapid = partCopy->Y(pdgD);
+
+ TString fillthis="hMassVsPtVsY"+appendthis;
+ if ( ( ( (cuts->IsSelected(part,AliRDHFCuts::kAll))&(AliRDHFCutsLctoV0::kLcToK0Spr)) == (AliRDHFCutsLctoV0::kLcToK0Spr) ) ) {
+ ((TH3F*)(fOutputPIDBachTR->FindObject(fillthis)))->Fill(mass,pt,rapid);
+ }
+
+ Int_t nRotated=0;
+ Double_t massRot=0;// calculated later only if candidate is acceptable
+ // Double_t angleProngXY=TMath::ACos((px[0]*px[1]+py[0]*py[1])/TMath::Sqrt((px[0]*px[0]+py[0]*py[0])*(px[1]*px[1]+py[1]*py[1])));
+ // Double_t ptOrig=pt;
+ Double_t rotStep=(fMaxAngleForRot-fMinAngleForRot)/(fNRotations-1); // -1 is to ensure that the last rotation is done with angle=fMaxAngleForRot
+
+ for(Int_t irot=0; irot<fNRotations; irot++){
+ Double_t phirot=fMinAngleForRot+rotStep*irot;
+ Double_t tmpx=px[0];
+ Double_t tmpy=py[0];
+ px[0]=tmpx*TMath::Cos(phirot)-tmpy*TMath::Sin(phirot);
+ py[0]=tmpx*TMath::Sin(phirot)+tmpy*TMath::Cos(phirot);
+ partCopy->SetPxPyPzProngs(2,px,py,pz);
+ pt = partCopy->Pt();
+ minv2 = partCopy->InvMass2(2,pdgLc2pK0S);
+ massRot=TMath::Sqrt(minv2);
+ rapid = partCopy->Y(pdgD);
+ //if(minv2>fMinMass*fMinMass && minv2<fMaxMass*fMaxMass){
+ if ( ( ( (cuts->IsSelected(partCopy,AliRDHFCuts::kAll))&(AliRDHFCutsLctoV0::kLcToK0Spr)) == (AliRDHFCutsLctoV0::kLcToK0Spr) ) ) {
+
+ fillthis="histLcMassByK0S"+appendthis;
+ ((TH2F*)(fOutputPIDBachTR->FindObject(fillthis)))->Fill(massRot,pt);
+
+ fillthis="hMassVsPtVsYRot"+appendthis;
+ ((TH3F*)(fOutputPIDBachTR->FindObject(fillthis)))->Fill(mass,pt,rapid);
+ fillthis="hDeltaMass"+appendthis;
+ ((TH1F*)(fOutputPIDBachTR->FindObject(fillthis)))->Fill(massRot-mass);
+ //if(fFullAnalysis){
+ //Double_t pointRot[5]={mass,massRot-mass,ptOrig,pt-ptOrig,angleProngXY};
+ //fillthis="hDeltaMassFullAnalysis"+appendthis;
+ //((THnSparse*)(fOutputPIDBachTR->FindObject(fillthis)))->Fill(pointRot);
+ //}
+ nRotated++;
+ //}
+ }
+ px[0]=tmpx;
+ py[0]=tmpy;
+ }
+ fillthis="hNormRotated"+appendthis;
+ ((TH1F*)(fOutputPIDBachTR->FindObject(fillthis)))->Fill(nRotated);
+
+ delete partCopy;
+
+ return;
+
+}
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff