Merge branch 'feature-movesplit'

[u/mrichter/AliRoot.git] / PWGHF / hfe / AliHFEvarManager.cxx

diff --git a/PWGHF/hfe/AliHFEvarManager.cxx b/PWGHF/hfe/AliHFEvarManager.cxx
index a4a4d68a6fdbac856cf97fc920cae839765c8162..f23ffd9888d5f63fec71c615022b6e7f94acf95b 100644 (file)
--- a/PWGHF/hfe/AliHFEvarManager.cxx
+++ b/PWGHF/hfe/AliHFEvarManager.cxx
@@ -41,6 +41,7 @@
 
 #include "AliHFEcontainer.h"
 #include "AliHFEsignalCuts.h"
+#include "AliHFEtools.h"
 #include "AliHFEvarManager.h"
 
 ClassImp(AliHFEvarManager)
@@ -54,10 +55,10 @@ AliHFEvarManager::AliHFEvarManager():
   fContentMC(NULL),
   fWeightFactor(1.),
   fSignalTrack(kTRUE),
-       fWeighting(kFALSE),
+  fWeighting(kFALSE),
   fSignal(NULL),
-       fWeightFactors(NULL),
-       fWeightFactorsFunction(NULL)
+  fWeightFactors(NULL),
+  fWeightFactorsFunction(NULL)
 {
        //
        // Dummy constructor
@@ -73,10 +74,10 @@ AliHFEvarManager::AliHFEvarManager(const Char_t *name):
   fContentMC(NULL),
   fWeightFactor(1.),
   fSignalTrack(kTRUE),
-       fWeighting(kFALSE),
+  fWeighting(kFALSE),
   fSignal(NULL),
-       fWeightFactors(NULL),
-       fWeightFactorsFunction(NULL)
+  fWeightFactors(NULL),
+  fWeightFactorsFunction(NULL)
 {
        //
        // Default constructor
@@ -93,10 +94,10 @@ AliHFEvarManager::AliHFEvarManager(const AliHFEvarManager &ref):
   fContentMC(NULL),
   fWeightFactor(ref.fWeightFactor),
   fSignalTrack(ref.fSignalTrack),
-       fWeighting(ref.fWeighting),
+  fWeighting(ref.fWeighting),
   fSignal(NULL),
-       fWeightFactors(NULL),
-       fWeightFactorsFunction(NULL)
+  fWeightFactors(NULL),
+  fWeightFactorsFunction(NULL)
 {
   //
   // Copy Constructor
@@ -139,9 +140,9 @@ void AliHFEvarManager::Copy(TObject &o) const{
   target.fContentMC = new Double_t[sizeof(fContentMC)/sizeof(Double_t)];
   target.fWeightFactor = fWeightFactor;
   target.fSignalTrack = fSignalTrack;
-       target.fWeighting = fWeighting;
+  target.fWeighting = fWeighting;
   target.fSignal = fSignal;
-       target.fWeightFactors = fWeightFactors;
+  target.fWeightFactors = fWeightFactors;
   target.fWeightFactorsFunction = fWeightFactorsFunction; 
   target.SetOwner(kFALSE);
 }
@@ -164,7 +165,7 @@ void AliHFEvarManager::AddVariable(TString name){
   else if(!name.CompareTo("charge"))
     fVariables->AddLast(new AliHFEvariable("charge", "charge", kCharge, 2, -1.1, 1.1));
   else if(!name.CompareTo("source"))
-    fVariables->AddLast(new AliHFEvariable("source", "source", kSource, 5, 0, 5));
+    fVariables->AddLast(new AliHFEvariable("source", "source", kSource, 8, 0, 8));
   else if(!name.CompareTo("centrality"))
     fVariables->AddLast(new AliHFEvariable("centrality", "centrality", kCentrality, 11, 0.0, 11.0));
   else if(!name.CompareTo("species"))
@@ -319,12 +320,19 @@ Double_t AliHFEvarManager::GetValue(AliVParticle *track, UInt_t code, Float_t ce
     }
     case kSource:{
       if(fSignal){
+        value = static_cast<Int_t>(fSignal->GetSignalSource(track));
+        /*
              if(fSignal->IsCharmElectron(track)) value = 0;
              else if(fSignal->IsBeautyElectron(track)) value = 1;
              else if(fSignal->IsGammaElectron(track)) value = 2;
         else if(fSignal->IsNonHFElectron(track)) value = 3;
-             else value = 4;
+        else if(fSignal->IsJpsiElectron(track)) value = 4;
+        else if(fSignal->IsB2JpsiElectron(track)) value = 5;
+        else if(fSignal->IsKe3Electron(track)) value = 6;
+             else value = 7;
+        */
       }
+      AliDebug(2, Form("source: %f", value));
       break;
     }
     case kSpecies:  value = aprioriPID; break; 
@@ -452,8 +460,9 @@ AliHFEvarManager::AliHFEvariable::AliHFEvariable():
   , fNBins(0)
   , fMin(0)
   , fMax(0)
-  , fBinning(NULL)
+  , fBinning()
   , fIsLogarithmic(kFALSE)
+  , fUserDefinedBinning(kFALSE)
 {
   // 
   // Dummy constructor
@@ -467,14 +476,15 @@ AliHFEvarManager::AliHFEvariable::AliHFEvariable(const Char_t *name, const Char_
   , fNBins(nBins)
   , fMin(0.)
   , fMax(0.)
-  , fBinning(NULL)
+  , fBinning()
   , fIsLogarithmic(kFALSE)
+  , fUserDefinedBinning(kTRUE)
 {
   // 
   // Default constructor
   //
-  fBinning = new Double_t[nBins+1];
-  memcpy(fBinning, binning, sizeof(Double_t) * (nBins+1));
+  fBinning.Set(nBins+1);
+  memcpy(fBinning.GetArray(), binning, sizeof(Double_t) * (nBins+1));
 }
 
 //_______________________________________________
@@ -484,8 +494,9 @@ AliHFEvarManager::AliHFEvariable::AliHFEvariable(const Char_t *name, const Char_
   , fNBins(nBins)
   , fMin(min)
   , fMax(max)
-  , fBinning(NULL)
+  , fBinning()
   , fIsLogarithmic(isLogarithmic)
+  , fUserDefinedBinning(kFALSE)
 {
   // 
   // Default constructor
@@ -499,16 +510,13 @@ AliHFEvarManager::AliHFEvariable::AliHFEvariable(const AliHFEvarManager::AliHFEv
   , fNBins(ref.fNBins)
   , fMin(ref.fMin)
   , fMax(ref.fMax)
-  , fBinning(NULL)
+  , fBinning(ref.fBinning)
   , fIsLogarithmic(ref.fIsLogarithmic)
+  , fUserDefinedBinning(ref.fUserDefinedBinning)
 {
   // 
   // Copy constructor
   //
-  if(ref.fBinning){
-    fBinning = new Double_t[ref.fNBins + 1];
-    memcpy(fBinning, ref.fBinning, sizeof(Double_t) * (ref.fNBins + 1));
-  }
 }
 
 //_______________________________________________
@@ -519,15 +527,13 @@ AliHFEvarManager::AliHFEvariable& AliHFEvarManager::AliHFEvariable::operator=(co
   
   if(&ref != this){
     TNamed::operator=(ref);
+    fBinning = ref.fBinning;
     fCode = ref.fCode;
     fNBins = ref.fNBins;
     fMax = ref.fMax;
     fMin = ref.fMin;
-    if(ref.fBinning){
-      fBinning = new Double_t[ref.fNBins + 1];
-      memcpy(fBinning, ref.fBinning, sizeof(Double_t) * (ref.fNBins + 1));
-    } else fBinning = NULL;
     fIsLogarithmic = ref.fIsLogarithmic;
+    fUserDefinedBinning = ref.fUserDefinedBinning;
   }
   return *this;
 }
@@ -537,6 +543,21 @@ AliHFEvarManager::AliHFEvariable::~AliHFEvariable(){
   //
   // Destruktor
   //
-  if(fBinning) delete fBinning;
+}
+
+//_______________________________________________
+Double_t* AliHFEvarManager::AliHFEvariable::GetBinning() { 
+  if(fUserDefinedBinning) return fBinning.GetArray(); 
+
+  // No User defined Binning - create one and store in fBinning
+  if(fBinning.GetSize() != 0) return fBinning.GetArray();
+  else{
+    Double_t *binning;
+    if(fIsLogarithmic) binning = AliHFEtools::MakeLogarithmicBinning(fNBins, fMin, fMax);
+    else binning = AliHFEtools::MakeLogarithmicBinning(fNBins, fMin, fMax);
+    fBinning.Set(fNBins+1, binning);
+    delete []binning;
+    return fBinning.GetArray();
+  }
 }