Upadte from Taku
authorcbaumann <cbaumann@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jul 2012 12:35:21 +0000 (12:35 +0000)
committercbaumann <cbaumann@f7af4fe6-9843-0410-8265-dc069ae4e863>
Mon, 9 Jul 2012 12:35:21 +0000 (12:35 +0000)
PWGDQ/dielectron/AliAnalysisTaskMultiDielectronTG.cxx
PWGDQ/dielectron/AliAnalysisTaskMultiDielectronTG.h
PWGDQ/dielectron/AliDielectronPair.cxx
PWGDQ/dielectron/AliDielectronPair.h
PWGDQ/dielectron/AliDielectronVarManager.h
PWGDQ/dielectron/macrosJPSI/AddTask_ReducedTree.C

index 8eaeb8c..d5c5661 100644 (file)
@@ -98,6 +98,7 @@ AliAnalysisTaskMultiDielectronTG::AliAnalysisTaskMultiDielectronTG() :
   fVemtmp(0x0),
   fVeptmp(0x0),
   fdconvphiv(acos(-1.0)),
+  fdop(0),
   fbz(0),
   fdv0mixing(kTRUE)
 {
@@ -138,6 +139,7 @@ AliAnalysisTaskMultiDielectronTG::AliAnalysisTaskMultiDielectronTG(const char *n
   fVemtmp(0x0),
   fVeptmp(0x0),
   fdconvphiv(acos(-1.0)),
+  fdop(0),
   fbz(0),
   fdv0mixing(kTRUE)
 {
@@ -318,6 +320,13 @@ void AliAnalysisTaskMultiDielectronTG::UserCreateOutputObjects()
   fCutsMother->SetRequireTPCRefit(kTRUE);
 
 
+  AliInfo(Form("PairCutType = %d %d %d %d %d",
+              fRejectPairFlag[0],
+              fRejectPairFlag[1],
+              fRejectPairFlag[2],
+              fRejectPairFlag[3],
+              fRejectPairFlag[4]));
+
 }
 
 //_________________________________________________________________________________
@@ -369,12 +378,12 @@ void AliAnalysisTaskMultiDielectronTG::UserExec(Option_t *)
 
   //V0and
   if(fTriggerOnV0AND){
-  if(isESD){if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND))
-            return;}
-  if(isAOD){if(!((static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0ADecision() == AliVVZERO::kV0BB &&
-            (static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0CDecision() == AliVVZERO::kV0BB) )
+    if(isESD){if (!fTriggerAnalysis->IsOfflineTriggerFired(static_cast<AliESDEvent*>(InputEvent()), AliTriggerAnalysis::kV0AND))
             return;}
-   }
+    if(isAOD){if(!((static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0ADecision() == AliVVZERO::kV0BB &&
+                  (static_cast<AliAODEvent*>(InputEvent()))->GetVZEROData()->GetV0CDecision() == AliVVZERO::kV0BB) )
+       return;}
+  }
   
 
   fEventStat->Fill(kV0andEvents);
@@ -426,7 +435,7 @@ void AliAnalysisTaskMultiDielectronTG::UserExec(Option_t *)
   //   AliDielectron *die=0;
   Int_t idie=0;
   while ( (die=static_cast<AliDielectron*>(nextDie())) ){
-    //AliInfo(" **************** die->Process(InputEvent()) **************************");
+    //AliInfo(Form(" **************** die->Process(InputEvent()) : %d **************************", idie));
     die->SetDontClearArrays(kTRUE);
     die->Process(InputEvent());
     if (die->HasCandidates()){
@@ -485,6 +494,9 @@ void AliAnalysisTaskMultiDielectronTG::UserExec(Option_t *)
 
     CheckGhostPairs(fVeptmp);
     CheckGhostPairs(fVemtmp);
+    if(fRejectPairFlag[idie]==1 || fRejectPairFlag[idie]==2){
+      RejectPairs(fVeptmp, fVemtmp, idie);
+    }
     RandomizePool(fVeptmp, fVemtmp);    
     CalcPair(fVep, fVem, die, idie);
 
@@ -701,19 +713,19 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
 
   for(int i1=0; i1<(int)ve1.size(); i1++){
     for(int i2=0; i2<(int)ve2.size(); i2++){
-      FillPair(ve1[i1], ve2[i2], 0, die);  
+      FillPair(ve1[i1], ve2[i2], 0, die, idie);  
     }    
   }
 
   for(int i1=0; i1<(int)ve1.size(); i1++){
     for(int i2=i1+1; i2<(int)ve1.size(); i2++){
-      FillPair(ve1[i1], ve1[i2], 1, die);  
+      FillPair(ve1[i1], ve1[i2], 1, die, idie);  
     }    
   }
 
   for(int i1=0; i1<(int)ve2.size(); i1++){
     for(int i2=i1+1; i2<(int)ve2.size(); i2++){
-      FillPair(ve2[i1], ve2[i2], 2, die);  
+      FillPair(ve2[i1], ve2[i2], 2, die, idie );  
     }    
   }
 
@@ -747,7 +759,7 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
       }
       for(int i1=0; i1<(int)ve1.size(); i1++){
        for(int i2=0; i2<(int)fvem[ibuf][idie][izbin][icent][irp].size(); i2++){
-          FillPair(ve1[i1],fvem[ibuf][idie][izbin][icent][irp][i2], 3, die);
+          FillPair(ve1[i1],fvem[ibuf][idie][izbin][icent][irp][i2], 3, die, idie);
         }
       }
       ++nmixed;
@@ -755,7 +767,7 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
   }
   if(ve2.size()>0) {
     //
-    // Now mixed event for +- pairs
+    // Now mixed event for -+ pairs
     //
     nmixed = 0;
     for(int ibuf=0;(nmixed<fgkNMix);ibuf++) {
@@ -766,7 +778,7 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
       }
       for(int i1=0; i1<(int)ve2.size(); i1++){
         for(int i2=0; i2<(int)fvep[ibuf][idie][izbin][icent][irp].size(); i2++){
-          FillPair(ve2[i1],fvep[ibuf][idie][izbin][icent][irp][i2],4, die);
+         FillPair(fvep[ibuf][idie][izbin][icent][irp][i2],ve2[i1],4, die, idie);
         }
       }
       ++nmixed;
@@ -786,7 +798,7 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
       }
       for(int i1=0; i1<(int)ve1.size(); i1++){
         for(int i2=0;i2<(int)fvep[ibuf][idie][izbin][icent][irp].size(); i2++){
-          FillPair(ve1[i1],fvep[ibuf][idie][izbin][icent][irp][i2], 5, die);
+          FillPair(ve1[i1],fvep[ibuf][idie][izbin][icent][irp][i2], 5, die, idie);
         }
       }
       ++nmixed;
@@ -806,7 +818,7 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
       }
       for(int i1=0; i1<(int)ve2.size(); i1++){
         for(int i2=0; i2<(int)fvem[ibuf][idie][izbin][icent][irp].size(); i2++){
-          FillPair(ve2[i1],fvem[ibuf][idie][izbin][icent][irp][i2],6, die);
+          FillPair(ve2[i1],fvem[ibuf][idie][izbin][icent][irp][i2],6, die, idie);
         }
       }
       ++nmixed;
@@ -818,7 +830,7 @@ void AliAnalysisTaskMultiDielectronTG::CalcPair(vector<AliDielectronSingleTG*> v
 
 //_________________________________________________________________________________
 void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep, 
-                                               AliDielectronSingleTG *iem, int type, AliDielectron *die)
+                                               AliDielectronSingleTG *iem, int type, AliDielectron *die, Int_t idie)
 {                      
 
   //
@@ -848,6 +860,7 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
   double dv0etapair = -9999;
   double dv0rpair = -9999;
   double dpsipair =  -9999;
+  double dphivpair =  -9999;
 
   ////////////////////////////
   ///// calculate v0 ////////
@@ -881,8 +894,13 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
       AliInfo("Same Objects!!");
       return; 
     }
+
+    //const AliKFParticle &kfPairLeg1 = candidate.GetKFFirstDaughter();
+    //const AliKFParticle &kfPairLeg2 = candidate.GetKFSecondDaughter();
+    
     const AliKFParticle &kfPair = candidate.GetKFParticle();
-    dopeningangle = candidate.OpeningAngle();
+
+    /*
     dv0mass = candidate.M();
     dv0pxpair = candidate.Px();
     dv0pypair = candidate.Py();
@@ -893,11 +911,26 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
     dv0yvpair = candidate.Yv();
     dv0zvpair = candidate.Zv();
     dv0phipair = candidate.Phi();
-    // dv0theta_pair = candidate.Theta();
     dv0etapair = candidate.Eta();
+    */
+    dv0mass = kfPair.GetMass();
+    dv0pxpair = kfPair.GetPx();
+    dv0pypair = kfPair.GetPy();
+    dv0pzpair = kfPair.GetPz();
+    dv0ptpair = kfPair.GetPt();
+    dv0epair = kfPair.GetE();
+    dv0xvpair = kfPair.GetX();
+    dv0yvpair = kfPair.GetY();
+    dv0zvpair = kfPair.GetZ();
+    dv0phipair = kfPair.GetPhi();
+    dv0etapair = kfPair.GetEta();
     dv0rpair =  kfPair.GetR();
-    
+
+    dopeningangle = candidate.OpeningAngle();    
     dpsipair = candidate.PsiPair(fbz);
+    dphivpair = candidate.PhivPair(fbz);
+
+
   }
 
   Double_t values[AliDielectronVarManager::kNMaxValues];
@@ -910,7 +943,7 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
   Bool_t pairClass1=fHistos->GetHistogramList()->FindObject(className1.Data())!=0x0;
   Bool_t pairClass2=fHistos->GetHistogramList()->FindObject(className2.Data())!=0x0;
 
-  if (pairClass1 && PairTrackcut(dphiv)==true){
+  if (pairClass1 && PairTrackcut(dphiv, dcos, idie)==true){
     ///import pair variables to values!!
     values[AliDielectronVarManager::kPx] = dpxpair;
     values[AliDielectronVarManager::kPy] = dpypair;
@@ -924,13 +957,14 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
     values[AliDielectronVarManager::kEta] = detapair;
     values[AliDielectronVarManager::kM] = dmass;
     values[AliDielectronVarManager::kPsiPair] = dphiv;
+    values[AliDielectronVarManager::kPhivPair] = dphiv;
     values[AliDielectronVarManager::kPhi]  = dphipair;
     values[AliDielectronVarManager::kOpeningAngle]  = dcos;
     fHistos->FillClass(className1, AliDielectronVarManager::kNMaxValues, values);
   }
 
 
-  if (pairClass2 && PairTrackcut(dphiv)==true){
+  if (pairClass2 && PairTrackcut(dphiv, dopeningangle, idie)==true){
     values[AliDielectronVarManager::kPx] = dv0pxpair;
     values[AliDielectronVarManager::kPy] = dv0pypair;
     values[AliDielectronVarManager::kPz] = dv0pzpair;
@@ -943,6 +977,7 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
     values[AliDielectronVarManager::kEta] = dv0etapair;
     values[AliDielectronVarManager::kM] = dv0mass;
     values[AliDielectronVarManager::kPsiPair] = dpsipair;
+    values[AliDielectronVarManager::kPhivPair] = dphivpair;
     values[AliDielectronVarManager::kPhi]  = dv0phipair;
     values[AliDielectronVarManager::kOpeningAngle]  = dopeningangle;
     fHistos->FillClass(className2, AliDielectronVarManager::kNMaxValues, values);
@@ -953,7 +988,7 @@ void AliAnalysisTaskMultiDielectronTG::FillPair(AliDielectronSingleTG *iep,
 }
 
 //_________________________________________________________________________________
-bool AliAnalysisTaskMultiDielectronTG::PairTrackcut(double phiv)
+bool AliAnalysisTaskMultiDielectronTG::PairTrackcut(double phiv, double op, int idie)
 {
 
   //
@@ -963,11 +998,19 @@ bool AliAnalysisTaskMultiDielectronTG::PairTrackcut(double phiv)
 
   bool pairOK = true;
 
-  //var is phiv for the moment 
-  if(fbz>0 && phiv>fdconvphiv){
-    pairOK = false;
-  }else if(fbz<0 && phiv<acos(-1.0)-fdconvphiv){
-    pairOK = false;
+  if(fRejectPairFlag[idie] == 1 || fRejectPairFlag[idie] == 2 ||
+     fRejectPairFlag[idie] == 3 || fRejectPairFlag[idie] == 4 ){
+    if(fRejectPairFlag[idie] == 2 || fRejectPairFlag[idie] == 4 ){
+      if(fbz>0 && phiv>fdconvphiv){
+       pairOK = false;
+      }else if(fbz<0 && phiv<acos(-1.0)-fdconvphiv){
+       pairOK = false;
+      }
+    }else if(fRejectPairFlag[idie] == 1 || fRejectPairFlag[idie] == 3){
+      if(op<fdop){
+       pairOK = false;
+      }
+    }
   }
 
   return pairOK;
@@ -1091,3 +1134,113 @@ void AliAnalysisTaskMultiDielectronTG::ReshuffleBuffer(vector<AliDielectronSingl
   }
 
 }
+
+//_________________________________________________________________________________
+void AliAnalysisTaskMultiDielectronTG::RejectPairs(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2, Int_t idie){
+
+  ////////////////////////////////////
+  ///// to reject pairs from track arrays 
+  ///// conversions, ghost ..
+  ///////////////////////////////////
+  if(e1.size()>0 && e2.size()>0){
+    for(int i1=0; i1<(int)e1.size(); i1++){
+      for(int i2=0; i2<(int)e2.size(); i2++){
+       if(fRejectPairFlag[idie]==1){
+         Double_t cosine = GetOpeningAngle(e1[i1], e2[i2]);
+         if(cosine<fdop){
+           e1[i1]->SetConvFlag(0);
+           e2[i2]->SetConvFlag(0);
+         }
+       }else if(fRejectPairFlag[idie]==2){
+         Double_t phiv = GetPhiv(e1[i1], e2[i2]);
+         if(fbz>0 && phiv>fdconvphiv){
+           e1[i1]->SetConvFlag(0);
+           e2[i2]->SetConvFlag(0);
+         }else if(fbz<0 && phiv<acos(-1.0)-fdconvphiv){
+           e1[i1]->SetConvFlag(0);
+           e2[i2]->SetConvFlag(0);
+         }
+       }
+      }
+    }
+  }
+
+  if(e1.size()>0){
+    for(int i1=0; i1<(int)e1.size(); i1++){
+      for(int i2=i1+1; i2<(int)e1.size(); i2++){
+       if(fRejectPairFlag[idie]==1){
+         Double_t cosine = GetOpeningAngle(e1[i1], e1[i2]);
+         if(cosine<fdop){
+           e1[i1]->SetConvFlag(0);
+           e1[i2]->SetConvFlag(0);
+         }
+       }else if(fRejectPairFlag[idie]==2){
+         Double_t phiv = GetPhiv(e1[i1], e1[i2]);
+         if(fbz>0 && phiv>fdconvphiv){
+           e1[i1]->SetConvFlag(0);
+           e1[i2]->SetConvFlag(0);
+         }else if(fbz<0 && phiv<acos(-1.0)-fdconvphiv){
+           e1[i1]->SetConvFlag(0);
+           e1[i2]->SetConvFlag(0);
+         }
+       }
+      }
+    }
+  }
+
+  if(e2.size()>0){
+    for(int i1=0; i1<(int)e2.size(); i1++){
+      for(int i2=i1+1; i2<(int)e2.size(); i2++){
+       if(fRejectPairFlag[idie]==1){
+         Double_t cosine = GetOpeningAngle(e2[i1], e2[i2]);
+         if(cosine<fdop){
+           e2[i1]->SetConvFlag(0);
+           e2[i2]->SetConvFlag(0);
+         }
+       }else if(fRejectPairFlag[idie]==2){
+         Double_t phiv = GetPhiv(e2[i1], e2[i2]);
+         if(fbz>0 && phiv>fdconvphiv){
+           e2[i1]->SetConvFlag(0);
+           e2[i2]->SetConvFlag(0);
+         }else if(fbz<0 && phiv<acos(-1.0)-fdconvphiv){
+           e2[i1]->SetConvFlag(0);
+           e2[i2]->SetConvFlag(0);
+         }
+       }
+      }
+    }
+  }
+}
+
+
+//_________________________________________________________________________________
+Double_t AliAnalysisTaskMultiDielectronTG::GetOpeningAngle(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2){
+
+  //////////////////////
+  //////// calculate pairs and get opening angle 
+  //////////////////////
+
+  double dmass, dphiv, dpxpair, dpypair, dpzpair;
+  double dptpair, depair, dphipair, detapair, dcos, dpsi;
+
+  CalcVars(e1, e2, dmass, dphiv, dpxpair, dpypair, dpzpair, 
+            dptpair, depair, dphipair, detapair, dcos, dpsi);
+
+  return dcos;
+}
+
+//_________________________________________________________________________________
+Double_t AliAnalysisTaskMultiDielectronTG::GetPhiv(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2){
+
+  //////////////////////
+  //////// calculate pairs and get opening angle 
+  //////////////////////
+
+  double dmass, dphiv, dpxpair, dpypair, dpzpair;
+  double dptpair, depair, dphipair, detapair, dcos, dpsi;
+
+  CalcVars(e1, e2, dmass, dphiv, dpxpair, dpypair, dpzpair, 
+            dptpair, depair, dphipair, detapair, dcos, dpsi);
+
+  return dphiv;
+}
index 18ba6e1..4ee55cf 100644 (file)
@@ -156,11 +156,13 @@ public:
   void AddDielectron(AliDielectron * const die) { fListDielectron.Add(die); }
 
 
+  void RejectOP(double val){fdop = val;} ///To reject conversions
   void RejectConversion(double val){fdconvphiv = val;} ///To reject conversions
   void EnableV0mixing(Bool_t val){fdv0mixing = val;}   ///Enable V0 mixing  
   void CheckGhostPairs(vector<AliDielectronSingleTG*> e1); ///identify ghost pairs in like sign pais
-  void FillPair(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, int type, AliDielectron *die); /// Fill Pairs
-  bool PairTrackcut(double var1); /// Pair cuts
+  void RejectPairs(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2, Int_t idie); ///identify conversions for the rejection
+  void FillPair(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, int type, AliDielectron *die, Int_t idie); /// Fill Pairs
+  bool PairTrackcut(double var1, double var2, int idie); /// Pair cuts
   void CalcVars(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2, 
                 double &mass, double &phiv, double &px, double &py, double&pz,
                double &pt, double &e, double &phi, double &eta, double &cos, double &psi); /// Calcualate kinematic variables
@@ -168,6 +170,15 @@ public:
   void RandomizePool(vector<AliDielectronSingleTG*> e1, vector<AliDielectronSingleTG*> e2);         ///Randimize pairs
   void ReshuffleBuffer(vector<AliDielectronSingleTG*> ve, deque<AliDielectronSingleTG*> pool);  ///ReshuffleBuffer
 
+  Double_t GetPhiv(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2); /// calculate phiv
+  Double_t GetOpeningAngle(AliDielectronSingleTG* e1, AliDielectronSingleTG* e2); /// calculate opening angle 
+  void SetPairCuts(Int_t Types[20]){
+    for(int i=0;i<20;i++){
+      fRejectPairFlag[i] = Types[i];
+    }
+  }
+
+
 protected:
   enum {kAllEvents=0, kSelectedEvents, kV0andEvents, kFilteredEvents, kPileupEvents, kNbinsEvent};
   TList fListDielectron;             // List of dielectron framework instances
@@ -182,6 +193,10 @@ protected:
   Bool_t fTriggerOnV0AND;            // if to trigger on V0and
   Bool_t fRejectPileup;              // pileup rejection wanted
 
+  enum PairRejType { NoRej=0, RejPairOp, RejPairPv, CutPairOp, CutPairPv};
+  
+  Int_t fRejectPairFlag[20];
+
   ETriggerLogig fTriggerLogic;       // trigger logic: any or all bits need to be matching
   
   AliTriggerAnalysis *fTriggerAnalysis; //! trigger analysis class
@@ -208,6 +223,7 @@ protected:
   std::vector<AliDielectronSingleTG*>  fVemtmp;   /// template for electron lists
   std::vector<AliDielectronSingleTG*>  fVeptmp;   /// template for positron lists
   Double_t fdconvphiv;      /// PhiCut
+  Double_t fdop;      /// Opening angle Cut
   Double_t fbz;            /// Magnetic field
   Bool_t fdv0mixing;       /// Mixing using V0 
 
@@ -221,7 +237,7 @@ protected:
   static const int fgkNRPBIN=12;    ///Number of RPbin for mixed event 
   static const int fgkNZBIN=10;     ///Number of zbin for mixed event 
   static const int fgkNCENT=10;     ///Number of centrality for mixed event 
-  static const int fgkNDIE=10;      ///maximum number of cuts for AliDielectron
+  static const int fgkNDIE=20;      ///maximum number of cuts for AliDielectron
   int fibuf[fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN];    ///buffer occupation for mixed event
   std::vector<AliDielectronSingleTG*> fvep[fgkNBUF][fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN];   //// positron buffer for mixing
   std::vector<AliDielectronSingleTG*> fvem[fgkNBUF][fgkNDIE][fgkNZBIN][fgkNCENT][fgkNRPBIN];   //// electron buffer for mixing
index 486b426..4dec2d2 100644 (file)
@@ -443,3 +443,108 @@ Double_t AliDielectronPair::GetCosPointingAngle(const AliVVertex *primVtx) const
 //   Double_t psProperDecayLength = lxy*(TDatabasePDG::Instance()->GetParticle(443)->Mass())/Pt();
 //   return psProperDecayLength;
 // }
+
+
+//______________________________________________
+Double_t AliDielectronPair::PhivPair(Double_t MagField) const
+{
+  //Following idea to use opening of colinear pairs in magnetic field from e.g. PHENIX
+  //to ID conversions. Angle between ee plane and magnetic field is calculated.
+
+  //Define local buffer variables for leg properties                                                                                                               
+  Double_t px1=-9999.,py1=-9999.,pz1=-9999.;
+  Double_t px2=-9999.,py2=-9999.,pz2=-9999.;
+
+  if(MagField>0){
+    if(fD1.GetQ()>0){
+      px1 = fD1.GetPx();
+      py1 = fD1.GetPy();
+      pz1 = fD1.GetPz();
+
+      px2 = fD2.GetPx();
+      py2 = fD2.GetPy();
+      pz2 = fD2.GetPz();
+    }else{
+      px1 = fD2.GetPx();
+      py1 = fD2.GetPy();
+      pz1 = fD2.GetPz();
+
+      px2 = fD1.GetPx();
+      py2 = fD1.GetPy();
+      pz2 = fD1.GetPz();
+    }
+  }else{
+    if(fD1.GetQ()>0){
+      px1 = fD2.GetPx();
+      py1 = fD2.GetPy();
+      pz1 = fD2.GetPz();
+
+      px2 = fD1.GetPx();
+      py2 = fD1.GetPy();
+      pz2 = fD1.GetPz();
+    }else{
+      px1 = fD1.GetPx();
+      py1 = fD1.GetPy();
+      pz1 = fD1.GetPz();
+
+      px2 = fD2.GetPx();
+      py2 = fD2.GetPy();
+      pz2 = fD2.GetPz();
+    }
+  }    
+
+  Double_t px = px1+px2;
+  Double_t py = py1+py2;
+  Double_t pz = pz1+pz2;
+  Double_t dppair = TMath::Sqrt(px*px+py*py+pz*pz);
+
+  //unit vector of (pep+pem) 
+  Double_t pl = dppair;
+  Double_t ux = px/pl;
+  Double_t uy = py/pl;
+  Double_t uz = pz/pl;
+  Double_t ax = uy/TMath::Sqrt(ux*ux+uy*uy);
+  Double_t ay = -ux/TMath::Sqrt(ux*ux+uy*uy); 
+  
+  //momentum of e+ and e- in (ax,ay,az) axis. Note that az=0 by 
+  //definition. 
+  //Double_t ptep = iep->Px()*ax + iep->Py()*ay; 
+  //Double_t ptem = iem->Px()*ax + iem->Py()*ay; 
+  
+  Double_t pxep = px1;
+  Double_t pyep = py1;
+  Double_t pzep = pz1;
+  Double_t pxem = px2;
+  Double_t pyem = py2;
+  Double_t pzem = pz2;
+  
+  //vector product of pep X pem 
+  Double_t vpx = pyep*pzem - pzep*pyem; 
+  Double_t vpy = pzep*pxem - pxep*pzem; 
+  Double_t vpz = pxep*pyem - pyep*pxem; 
+  Double_t vp = sqrt(vpx*vpx+vpy*vpy+vpz*vpz); 
+  //Double_t thev = acos(vpz/vp); 
+  
+  //unit vector of pep X pem 
+  Double_t vx = vpx/vp; 
+  Double_t vy = vpy/vp; 
+  Double_t vz = vpz/vp; 
+
+  //The third axis defined by vector product (ux,uy,uz)X(vx,vy,vz) 
+  Double_t wx = uy*vz - uz*vy; 
+  Double_t wy = uz*vx - ux*vz; 
+  //Double_t wz = ux*vy - uy*vx; 
+  //Double_t wl = sqrt(wx*wx+wy*wy+wz*wz); 
+  // by construction, (wx,wy,wz) must be a unit vector. 
+  // measure angle between (wx,wy,wz) and (ax,ay,0). The angle between them 
+  // should be small if the pair is conversion 
+  //
+  Double_t cosPhiV = wx*ax + wy*ay; 
+  Double_t phiv = TMath::ACos(cosPhiV); 
+
+  return phiv;
+
+}
+
+
+
index bd8a31f..c78d082 100644 (file)
@@ -125,6 +125,7 @@ public:
                                               const Bool_t isHE, const Bool_t isTheta);
 
   Double_t PsiPair(Double_t MagField)const; //Angle cut w.r.t. to magnetic field
+  Double_t PhivPair(Double_t MagField)const; //Angle of ee plane w.r.t. to magnetic field
   Double_t GetCosPointingAngle(const AliVVertex *primVtx) const;
   // internal KF particle
   const AliKFParticle& GetKFParticle()       const { return fPair; }
index 7e29a14..0e46151 100644 (file)
@@ -188,6 +188,7 @@ public:
     kPhiCS,                  // phi in mother's rest frame in Collins-Soper picture
     kThetaSqCS,              // squared value of kThetaCS
     kPsiPair,                // phi in mother's rest frame in Collins-Soper picture
+    kPhivPair,                // angle between ee plane and the magnetic field (can be useful for conversion rejection)
     kCos2PhiCS,              // Cosine of 2*phi in mother's rest frame in the Collins-Soper picture
     kCosTilPhiCS,            // Sin(phi) +/- Cos(phi) in mother's rest frame in Collins-Soper picture; Sign is sign(Cos(phi))
     kDeltaPhiV0ArpH2,        // Delta phi of the pair with respect to the 2nd order harmonic reaction plane from V0-A
@@ -1072,6 +1073,7 @@ inline void AliDielectronVarManager::FillVarDielectronPair(const AliDielectronPa
   values[AliDielectronVarManager::kPairType]     = pair->GetType();
 
   values[AliDielectronVarManager::kPsiPair]      = fgEvent ? pair->PsiPair(fgEvent->GetMagneticField()) : -5;
+  values[AliDielectronVarManager::kPhivPair]      = fgEvent ? pair->PhivPair(fgEvent->GetMagneticField()) : -5;
   values[AliDielectronVarManager::kPseudoProperTime] = fgEvent ? kfPair.GetPseudoProperDecayTime(*(fgEvent->GetPrimaryVertex()), TDatabasePDG::Instance()->GetParticle(443)->Mass(), &errPseudoProperTime2 ) : -1e10;
   // values[AliDielectronVarManager::kPseudoProperTime] = fgEvent ? pair->GetPseudoProperTime(fgEvent->GetPrimaryVertex()): -1e10;
   values[AliDielectronVarManager::kPseudoProperTimeErr] = (errPseudoProperTime2 > 0) ? TMath::Sqrt(errPseudoProperTime2) : -1e10;
index fc81737..7bd6b23 100644 (file)
@@ -1,3 +1,4 @@
+
 //__________________________________________________________________________________________
 AliAnalysisTask *AddTask_ReducedTree(){
   //get the current analysis manager
@@ -47,7 +48,7 @@ AliAnalysisTask *AddTask_ReducedTree(){
     mgr->CreateContainer("qaHistos",
                          TList::Class(),
                          AliAnalysisManager::kOutputContainer,
-                         "dst_qaHistos.root");
+                         "dstTree.root");
 
   AliAnalysisDataContainer *cOutputHist2 =
     mgr->CreateContainer("dstTree",
@@ -55,11 +56,11 @@ AliAnalysisTask *AddTask_ReducedTree(){
                          AliAnalysisManager::kOutputContainer,
                          "dstTree.root");
   
-  AliAnalysisDataContainer *cOutputHist3 =
+  /*AliAnalysisDataContainer *cOutputHist3 =
     mgr->CreateContainer("friendTree",
                          TTree::Class(),
                          AliAnalysisManager::kOutputContainer,
-                         "dstTree_friend.root");
+                         "dstTree_friend.root");*/
   /*  cout << "output containers: " << endl
        << cOutputHist1 << endl
        << cOutputHist2 << endl
@@ -67,11 +68,11 @@ AliAnalysisTask *AddTask_ReducedTree(){
 
   mgr->ConnectInput(task,  0, mgr->GetCommonInputContainer());
   mgr->ConnectOutput(task, 0, coutput1 );
-  //mgr->ConnectOutput(task, 1, cOutputHist1);
-  //mgr->ConnectOutput(task, 2, cOutputHist2);
+  mgr->ConnectOutput(task, 1, cOutputHist1);
+  mgr->ConnectOutput(task, 2, cOutputHist2);
   //mgr->ConnectOutput(task, 3, cOutputHist3);
   //mgr->ConnectOutput(task, 2, cOutputHist3);
-  mgr->ConnectOutput(task, 1, cOutputHist2);
+  //mgr->ConnectOutput(task, 1, cOutputHist2);
   return task;
 }