#include "AliRunLoader.h"
#include "AliITSReconstructor.h"
#include "AliITSRecPoint.h"
+#include "AliESDEvent.h"
+#include "AliESDVertex.h"
//____________________________________________________________________
+
+using std::ofstream;
+using std::ios;
+using std::ifstream;
ClassImp(AliITSTrackleterSPDEff)
fZetaWindowL1(0),
fOnlyOneTrackletPerC1(0),
fUpdateOncePerEventPlaneEff(0),
+fMinContVtx(0),
fChipUpdatedInEvent(0),
fPlaneEffSPD(0),
+fPlaneEffBkg(0),
fReflectClusterAroundZAxisForLayer0(kFALSE),
fReflectClusterAroundZAxisForLayer1(kFALSE),
+fLightBkgStudyInParallel(kFALSE),
fMC(0),
fUseOnlyPrimaryForPred(0),
fUseOnlySecondaryForPred(0),
{
// default constructor
// from AliITSMultReconstructor
+ Init();
+}
+//______________________________________________________________________
+void AliITSTrackleterSPDEff::Init() {
SetPhiWindowL2();
SetZetaWindowL2();
SetOnlyOneTrackletPerC2();
if (GetHistOn()) BookHistos();
fPlaneEffSPD = new AliITSPlaneEffSPD();
+ SetLightBkgStudyInParallel();
}
//______________________________________________________________________
AliITSTrackleterSPDEff::AliITSTrackleterSPDEff(const AliITSTrackleterSPDEff &mr) :
fZetaWindowL1(mr.fZetaWindowL1),
fOnlyOneTrackletPerC1(mr.fOnlyOneTrackletPerC1),
fUpdateOncePerEventPlaneEff(mr.fUpdateOncePerEventPlaneEff),
+fMinContVtx(mr.fMinContVtx),
fChipUpdatedInEvent(mr.fChipUpdatedInEvent),
fPlaneEffSPD(mr.fPlaneEffSPD),
+fPlaneEffBkg(mr.fPlaneEffBkg),
fReflectClusterAroundZAxisForLayer0(mr.fReflectClusterAroundZAxisForLayer0),
fReflectClusterAroundZAxisForLayer1(mr.fReflectClusterAroundZAxisForLayer1),
+fLightBkgStudyInParallel(mr.fLightBkgStudyInParallel),
fMC(mr.fMC),
fUseOnlyPrimaryForPred(mr.fUseOnlyPrimaryForPred),
fUseOnlySecondaryForPred(mr.fUseOnlySecondaryForPred),
// delete PlaneEff
delete fPlaneEffSPD;
+ fPlaneEffSPD=0;
+ if(fPlaneEffBkg) {
+ delete fPlaneEffBkg;
+ fPlaneEffBkg=0;
+
+ }
}
//____________________________________________________________________
void
-//AliITSTrackleterSPDEff::Reconstruct(TTree* clusterTree, Float_t* vtx, Float_t*, AliStack *pStack, TTree *tRef) {
-AliITSTrackleterSPDEff::Reconstruct(AliStack *pStack, TTree *tRef) {
+AliITSTrackleterSPDEff::Reconstruct(AliStack *pStack, TTree *tRef, Bool_t lbkg) {
//
// - you have to take care of the following, before of using Reconstruct
// 1) call LoadClusters(TTree* cl) that finds the position of the clusters (in global coord)
// - Check if there is a cluster near that point
//
// reset counters
+ if(lbkg && !GetLightBkgStudyInParallel()) {
+ AliError("You asked for lightBackground in the Reconstruction without proper call to SetLightBkgStudyInParallel(1)");
+ return;
+ }
+ AliITSPlaneEffSPD *pe;
+ if(lbkg) {
+ pe=fPlaneEffBkg;
+ } else {
+ pe=fPlaneEffSPD;
+ }
fNTracklets = 0;
// retrieve the vertex position
Float_t vtx[3];
vtx[1]=(Float_t)GetY();
vtx[2]=(Float_t)GetZ();
// to study residual background (i.e. contribution from TT' to measured efficiency)
- if(fReflectClusterAroundZAxisForLayer0) ReflectClusterAroundZAxisForLayer(0);
- if(fReflectClusterAroundZAxisForLayer1) ReflectClusterAroundZAxisForLayer(1);
+ if(fReflectClusterAroundZAxisForLayer0 && !lbkg) ReflectClusterAroundZAxisForLayer(0);
+ if(fReflectClusterAroundZAxisForLayer1 && !lbkg) ReflectClusterAroundZAxisForLayer(1);
//
- if(fMC && !pStack) {AliError("You asked for MC infos but AliStack not properly loaded"); return;}
- if(fMC && !tRef) {AliError("You asked for MC infos but TrackRef Tree not properly loaded"); return;}
+ if(fMC && !pStack && !lbkg) {AliError("You asked for MC infos but AliStack not properly loaded"); return;}
+ if(fMC && !tRef && !lbkg) {AliError("You asked for MC infos but TrackRef Tree not properly loaded"); return;}
Bool_t found;
Int_t nfTraPred1=0; Int_t ntTraPred1=0;
Int_t nfTraPred2=0; Int_t ntTraPred2=0;
fChipPredOnLay2[iC1] = key;
fAssociationFlag1[iC1] = kFALSE;
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
Float_t eta=fClustersLay1[iC1][0];
eta= TMath::Tan(eta/2.);
eta=-TMath::Log(eta);
found=FindChip(key, 0, vtx, fClustersLay2[iC2][0],fClustersLay2[iC2][1]);
if (!found) {
- AliWarning(Form("Reconstruct: cannot find chip prediction on inner layer for cluster %d on the outer layer",iC2));
+ AliDebug(1,Form("Reconstruct: cannot find chip prediction on inner layer for cluster %d on the outer layer",iC2));
key=999999;
}
nfTraPred1+=(Int_t)found; // this for debugging purpose
fChipPredOnLay1[iC2] = key;
fAssociationFlag[iC2] = kFALSE;
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
Float_t eta=fClustersLay2[iC2][0];
eta= TMath::Tan(eta/2.);
eta=-TMath::Log(eta);
// in any case, if MC has been required, store statistics of primaries and secondaries
Bool_t primary=kFALSE; Bool_t secondary=kFALSE; // it is better to have both since chip might not be found
- if (fMC) {
+ if (fMC && !lbkg) {
Int_t lab1=(Int_t)fClustersLay1[iC1][3];
Int_t lab2=(Int_t)fClustersLay1[iC1][4];
Int_t lab3=(Int_t)fClustersLay1[iC1][5];
// do it always as a function of the chip number used to built the prediction
found=FindChip(key,0,vtx,fClustersLay1[iC1][0],fClustersLay1[iC1][1],fClustersLay1[iC1][2]);
- if (!found) {AliWarning(
+ if (!found) {AliDebug(1,
Form("Reconstruct MC: cannot find chip on inner layer for cluster %d",iC1)); }
else {
if((lab1 != -2 && PrimaryTrackChecker(lab1,pStack) ) ||
Float_t r2 = fClustersLay2[iC2][2]/TMath::Cos(fClustersLay2[iC2][0]);
Float_t dZeta = TMath::Cos(fClustersLay1[iC1][0])*r2 - fClustersLay2[iC2][2];
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
fhClustersDPhiAll->Fill(dPhi);
fhClustersDThetaAll->Fill(dTheta);
fhClustersDZetaAll->Fill(dZeta);
if (distmin<100) { // This means that a cluster in layer 2 was found that matches with iC1
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
fhClustersDPhiAcc->Fill(dPhimin);
fhClustersDThetaAcc->Fill(dThetamin);
fhClustersDZetaAcc->Fill(dZetamin);
fTracklets[fNTracklets][3] = -2;
}
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
Float_t eta=fTracklets[fNTracklets][0];
eta= TMath::Tan(eta/2.);
eta=-TMath::Log(eta);
// Check that this cluster is still in the same chip (here you pass also Zvtx for better computation)
found=FindChip(key,1,vtx,fClustersLay2[iC2WithBestDist][0],fClustersLay2[iC2WithBestDist][1],fClustersLay2[iC2WithBestDist][2]);
if(!found){
- AliWarning(
+ AliDebug(1,
Form("Reconstruct: cannot find chip on outer layer for cluster %d",iC2WithBestDist));
key=999999;
}
nfClu2+=(Int_t)found; // this for debugging purpose
ntClu2++; // to check efficiency of the method FindChip
if(key<1200) { // the Chip has been found
- if(fMC) { // this part only for MC
+ if(fMC && !lbkg) { // this part only for MC
// Int_t labc1=(Int_t)fClustersLay2[iC2WithBestDist][3];
// Int_t labc2=(Int_t)fClustersLay2[iC2WithBestDist][4];
// Int_t labc3=(Int_t)fClustersLay2[iC2WithBestDist][5];
if (key==fChipPredOnLay2[iC1]) { // this control seems too loose: has to be checked !
// OK, success
- fPlaneEffSPD->UpDatePlaneEff(kTRUE,key); // success
+ pe->UpDatePlaneEff(kTRUE,key); // success
fChipUpdatedInEvent[key]=kTRUE;
- if(fMC) {
+ if(fMC && !lbkg) {
if(primary) fSuccessP[key]++;
if(secondary) fSuccessS[key]++;
}
}
else {
- fPlaneEffSPD->UpDatePlaneEff(kTRUE,key); // this should not be a failure
+ pe->UpDatePlaneEff(kTRUE,key); // this should not be a failure
fChipUpdatedInEvent[key]=kTRUE; // (might be in the tracking tollerance)
- if(fMC) {
+ if(fMC && !lbkg) {
if(primary) fSuccessP[key]++;
if(secondary) fSuccessS[key]++;
}
} // if any cluster found --> increment statistics by 1 failure (provided you have chip prediction)
else if (fChipPredOnLay2[iC1]<1200) {
- fPlaneEffSPD->UpDatePlaneEff(kFALSE,fChipPredOnLay2[iC1]);
+ pe->UpDatePlaneEff(kFALSE,fChipPredOnLay2[iC1]);
fChipUpdatedInEvent[fChipPredOnLay2[iC1]]=kTRUE;
- if(fMC) {
+ if(fMC && !lbkg) {
if(primary) fFailureP[fChipPredOnLay2[iC1]]++;
if(secondary) fFailureS[fChipPredOnLay2[iC1]]++;
}
// in any case, if MC has been required, store statistics of primaries and secondaries
Bool_t primary=kFALSE; Bool_t secondary=kFALSE;
- if (fMC) {
+ if (fMC && !lbkg) {
Int_t lab1=(Int_t)fClustersLay2[iC2][3];
Int_t lab2=(Int_t)fClustersLay2[iC2][4];
Int_t lab3=(Int_t)fClustersLay2[iC2][5];
// do it always as a function of the chip number used to built the prediction
found=FindChip(key,1,vtx,fClustersLay2[iC2][0],fClustersLay2[iC2][1],fClustersLay2[iC2][2]);
- if (!found) {AliWarning(
+ if (!found) {AliDebug(1,
Form("Reconstruct MC: cannot find chip on outer layer for cluster %d",iC2)); }
else {
if((lab1 != -2 && PrimaryTrackChecker(lab1,pStack) ) ||
Float_t dZeta = TMath::Cos(fClustersLay2[iC2][0])*r1 - fClustersLay1[iC1][2];
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
fhClustersDPhiInterpAll->Fill(dPhi);
fhClustersDThetaInterpAll->Fill(dTheta);
fhClustersDZetaInterpAll->Fill(dZeta);
if (distmin<100) { // This means that a cluster in layer 1 was found that matches with iC2
- if (fHistOn) {
+ if (fHistOn && !lbkg) {
fhClustersDPhiInterpAcc->Fill(dPhimin);
fhClustersDThetaInterpAcc->Fill(dThetamin);
fhClustersDZetaInterpAcc->Fill(dZetamin);
// Check that this cluster is still in the same chip (here you pass also Zvtx for better computation)
found=FindChip(key,0,vtx,fClustersLay1[iC1WithBestDist][0],fClustersLay1[iC1WithBestDist][1],fClustersLay1[iC1WithBestDist][2]);
if(!found){
- AliWarning(
+ AliDebug(1,
Form("Reconstruct: cannot find chip on inner layer for cluster %d",iC1WithBestDist));
key=999999;
}
nfClu1+=(Int_t)found; // this for debugging purpose
ntClu1++; // to check efficiency of the method FindChip
if(key<1200) {
- if(fMC) { // this part only for MC
+ if(fMC && !lbkg) { // this part only for MC
// Int_t labc1=(Int_t)fClustersLay1[iC1WithBestDist][3];
// Int_t labc2=(Int_t)fClustersLay1[iC1WithBestDist][4];
// Int_t labc3=(Int_t)fClustersLay1[iC1WithBestDist][5];
if (key==fChipPredOnLay1[iC2]) { // this control seems too loose: has to be checked !
// OK, success
- fPlaneEffSPD->UpDatePlaneEff(kTRUE,key); // success
+ pe->UpDatePlaneEff(kTRUE,key); // success
fChipUpdatedInEvent[key]=kTRUE;
- if(fMC) {
+ if(fMC && !lbkg) {
if(primary) fSuccessP[key]++;
if(secondary) fSuccessS[key]++;
}
} else {
- fPlaneEffSPD->UpDatePlaneEff(kTRUE,key); // this should not be a failure
+ pe->UpDatePlaneEff(kTRUE,key); // this should not be a failure
fChipUpdatedInEvent[key]=kTRUE; // (might be in the tracking tollerance)
- if(fMC) {
+ if(fMC && !lbkg) {
if(primary) fSuccessP[key]++;
if(secondary) fSuccessS[key]++;
}
} // if no cluster found --> increment statistics by 1 failure (provided you have chip prediction)
else if (fChipPredOnLay1[iC2]<1200) {
- fPlaneEffSPD->UpDatePlaneEff(kFALSE,fChipPredOnLay1[iC2]);
+ pe->UpDatePlaneEff(kFALSE,fChipPredOnLay1[iC2]);
fChipUpdatedInEvent[fChipPredOnLay1[iC2]]=kTRUE;
- if(fMC) {
+ if(fMC && !lbkg) {
if(primary) fFailureP[fChipPredOnLay1[iC2]]++;
if(secondary) fFailureS[fChipPredOnLay1[iC2]]++;
}
AliDebug(1,Form(("Eff. of method FindChip for Cluster on lay 2 = %d / %d"),nfClu2,ntClu2));
}
//____________________________________________________________________
-Bool_t AliITSTrackleterSPDEff::FindChip(UInt_t &key, Int_t layer, Float_t* vtx,
+Bool_t AliITSTrackleterSPDEff::FindChip(UInt_t &key, Int_t layer,const Float_t* vtx,
Float_t thetaVtx, Float_t phiVtx, Float_t zVtx) {
//
// Input: a) layer number in the range [0,1]
Double_t zAbs,phiAbs; // those are the polar coordinate, in the Absolute ALICE Reference
// of the intersection of the tracklet with the pixel layer.
if (TMath::Abs(zVtx)<100) zAbs=zVtx + vtx[2]; // this is fine only for the cluster, not for the track prediction
- else zAbs=r/TMath::Tan(thetaVtx) + vtx[2]; // this is the only way to do for the tracklet prediction
+ else {
+ if(TMath::Abs(thetaVtx)<1E-6) return kFALSE;
+ zAbs=r/TMath::Tan(thetaVtx) + vtx[2]; // this is the only way to do for the tracklet prediction
+ }
AliDebug(1,Form("FindChip: vtx[0] = %f, vtx[1] = %f, vtx[2] = %f",vtx[0],vtx[1],vtx[2]));
Double_t vtxy[2]={vtx[0],vtx[1]};
if (vtxy[0]*vtxy[1]+vtxy[1]*vtxy[1]>0) { // this method holds only for displaced vertices
return kTRUE;
}
//___________________________________________________________
-Bool_t AliITSTrackleterSPDEff::SetAngleRange02Pi(Double_t &angle) {
+Bool_t AliITSTrackleterSPDEff::SetAngleRange02Pi(Double_t &angle) const {
//
// simple method to reduce all angles (in rad)
// in range [0,2pi[
Int_t nret=0;
TParticle* dau = 0;
- Int_t nDau = 0;
+ // Int_t nDau = 0;
Int_t pdgDau;
Int_t firstDau = part->GetFirstDaughter(); // if no daugther stored then no way to understand i
// its real fate ! But you have to take it !
if (firstDau > 0) { // if it has daugther(s) try to infer if it is "detectable" as a tracklet
Int_t lastDau = part->GetLastDaughter();
- nDau = lastDau - firstDau + 1;
+ // nDau = lastDau - firstDau + 1;
Double_t distMax=0.;
Int_t jmax=0;
for(Int_t j=firstDau; j<=lastDau; j++) {
// none.
*os << fPhiWindowL1 <<" "<< fZetaWindowL1 << " " << fPhiWindowL2 <<" "<< fZetaWindowL2
<< " " << fOnlyOneTrackletPerC1 << " " << fOnlyOneTrackletPerC2
- << " " << fUpdateOncePerEventPlaneEff << " " << fReflectClusterAroundZAxisForLayer0
+ << " " << fUpdateOncePerEventPlaneEff << " " << fMinContVtx
+ << " " << fReflectClusterAroundZAxisForLayer0
<< " " << fReflectClusterAroundZAxisForLayer1;
*os << " " << fMC;
if(!fMC) {AliInfo("Writing only cuts, no MC info"); return;}
Bool_t tmp= fMC;
*is >> fPhiWindowL1 >> fZetaWindowL1 >> fPhiWindowL2 >> fZetaWindowL2
>> fOnlyOneTrackletPerC1 >> fOnlyOneTrackletPerC2
- >> fUpdateOncePerEventPlaneEff >> fReflectClusterAroundZAxisForLayer0
+ >> fUpdateOncePerEventPlaneEff >> fMinContVtx
+ >> fReflectClusterAroundZAxisForLayer0
>> fReflectClusterAroundZAxisForLayer1;
//if(!fMC) {AliInfo("Reading only cuts, no MC info available");return;}
*is >> fMC;
}
else {
TFile* mcfile = TFile::Open(filename, "RECREATE");
- TH1F* cuts = new TH1F("cuts", "list of cuts", 10, 0, 10); // TH1I containing cuts
+ TH1F* cuts = new TH1F("cuts", "list of cuts", 11, 0, 11); // TH1I containing cuts
cuts->SetBinContent(1,fPhiWindowL1);
cuts->SetBinContent(2,fZetaWindowL1);
cuts->SetBinContent(3,fPhiWindowL2);
cuts->SetBinContent(5,fOnlyOneTrackletPerC1);
cuts->SetBinContent(6,fOnlyOneTrackletPerC2);
cuts->SetBinContent(7,fUpdateOncePerEventPlaneEff);
- cuts->SetBinContent(8,fReflectClusterAroundZAxisForLayer0);
- cuts->SetBinContent(9,fReflectClusterAroundZAxisForLayer1);
- cuts->SetBinContent(10,fMC);
+ cuts->SetBinContent(8,fMinContVtx);
+ cuts->SetBinContent(9,fReflectClusterAroundZAxisForLayer0);
+ cuts->SetBinContent(10,fReflectClusterAroundZAxisForLayer1);
+ cuts->SetBinContent(11,fMC);
cuts->Write();
delete cuts;
if(!fMC) {AliInfo("Writing only cuts, no MC info");}
fOnlyOneTrackletPerC1=(Bool_t)cuts->GetBinContent(5);
fOnlyOneTrackletPerC2=(Bool_t)cuts->GetBinContent(6);
fUpdateOncePerEventPlaneEff=(Bool_t)cuts->GetBinContent(7);
- fReflectClusterAroundZAxisForLayer0=(Bool_t)cuts->GetBinContent(8);
- fReflectClusterAroundZAxisForLayer1=(Bool_t)cuts->GetBinContent(9);
- fMC=(Bool_t)cuts->GetBinContent(10);
+ fMinContVtx=(Int_t)cuts->GetBinContent(8);
+ fReflectClusterAroundZAxisForLayer0=(Bool_t)cuts->GetBinContent(9);
+ fReflectClusterAroundZAxisForLayer1=(Bool_t)cuts->GetBinContent(10);
+ fMC=(Bool_t)cuts->GetBinContent(11);
if(!fMC) {AliInfo("Reading only cuts, no MC info"); if(tmp) SetMC(kFALSE); }
else { // only if file with MC predictions
if(!tmp) {AliInfo("Calling SetMC() to read this file wtih MC info"); SetMC();}
}
//_______________________________________________________________
Bool_t AliITSTrackleterSPDEff::IsReconstructableAt(Int_t layer,Int_t iC,Int_t ipart,
- Float_t* vtx, AliStack *stack, TTree *ref) {
+ const Float_t* vtx, const AliStack *stack, TTree *ref) {
// This (private) method can be used only for MC events, where both AliStack and the TrackReference
// are available.
// It is used to asses whether a tracklet prediction is reconstructable or not at the other layer
// Input:
-// - Int_t layer (either 0 or 1): layer which you want to chech if the tracklete can be
+// - Int_t layer (either 0 or 1): layer which you want to check if the tracklete can be
// reconstructed at
// - Int_t iC : cluster index used to build the tracklet prediction
// if layer=0 ==> iC=iC2 ; elseif layer=1 ==> iC=iC1
return;
}
//____________________________________________________________________________
-Int_t AliITSTrackleterSPDEff::Clusters2Tracks(AliESDEvent *){
+Int_t AliITSTrackleterSPDEff::Clusters2Tracks(AliESDEvent *esd){
// This method is used to find the tracklets.
// It is called from AliReconstruction
// The vertex is supposed to be associated to the Tracker (i.e. to this) already
// In case Monte Carlo is required, the appropriate linking to Stack and TrackRef is attempted
//
Int_t rc=1;
+ // apply cuts on the vertex quality
+ const AliESDVertex *vertex = esd->GetVertex();
+ if(vertex->GetNContributors()<fMinContVtx) return 0;
+ //
AliRunLoader* runLoader = AliRunLoader::Instance();
if (!runLoader) {
Error("Clusters2Tracks", "no run loader found");
tRefTree= runLoader->TreeTR();
}
Reconstruct(pStack,tRefTree);
+
+ if (GetLightBkgStudyInParallel()) {
+ AliStack *dummy1=0x0; TTree *dummy2=0x0;
+ ReflectClusterAroundZAxisForLayer(1);
+ Reconstruct(dummy1,dummy2,kTRUE);
+ }
return 0;
}
//____________________________________________________________________________
Int_t rc=0;
if(GetMC()) SavePredictionMC("TrackletsMCpred.root");
if(GetHistOn()) rc=(Int_t)WriteHistosToFile();
+ if(GetLightBkgStudyInParallel()) {
+ TString name="AliITSPlaneEffSPDtrackletBkg.root";
+ TFile* pefile = TFile::Open(name, "RECREATE");
+ rc*=fPlaneEffBkg->Write();
+ pefile->Close();
+ }
return rc;
}
//____________________________________________________________________
}
AliDebug(1,Form("(clusters in layer 1 : %d, layer 2: %d)",fNClustersLay1,fNClustersLay2));
}
-
+//_________________________________________________________________________
+void
+AliITSTrackleterSPDEff::SetLightBkgStudyInParallel(Bool_t b) {
+// This method:
+// - set Bool_t fLightBackgroundStudyInParallel = b
+// a) if you set this kTRUE, then the estimation of the
+// SPD efficiency is done as usual for data, but in
+// parallel a light (i.e. without control histograms, etc.)
+// evaluation of combinatorial background is performed
+// with the usual ReflectClusterAroundZAxisForLayer method.
+// b) if you set this kFALSE, then you would not have a second
+// container for PlaneEfficiency statistics to be used for background
+// (fPlaneEffBkg=0). If you want to have a full evaluation of the
+// background (with all control histograms and additional data
+// members referring to the background) then you have to call the
+// method SetReflectClusterAroundZAxisForLayer(kTRUE) esplicitily
+ fLightBkgStudyInParallel=b;
+ if(fLightBkgStudyInParallel) {
+ if(!fPlaneEffBkg) fPlaneEffBkg = new AliITSPlaneEffSPD();
+ }
+ else {
+ delete fPlaneEffBkg;
+ fPlaneEffBkg=0;
+ }
+}
+//______________________________________________________________
+void AliITSTrackleterSPDEff::SetReflectClusterAroundZAxisForLayer(Int_t ilayer,Bool_t b){
+//
+// method to study residual background:
+// Input b= KTRUE --> reflect the clusters
+// ilayer (either 0 or 1) --> which SPD layers should be reflected
+//
+ if(b) {AliInfo(Form("All clusters on layer %d will be rotated by 180 deg around z",ilayer));
+ SetLightBkgStudyInParallel(kFALSE);}
+ if(ilayer==0) fReflectClusterAroundZAxisForLayer0=b; // a rotation by 180degree around the Z axis
+ else if(ilayer==1) fReflectClusterAroundZAxisForLayer1=b; // (x->-x; y->-y) to all RecPoints on a
+ else AliInfo("Nothing done: input argument (ilayer) either 0 or 1"); // given layer is applied. In such a way
+ }
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff