#include <TClass.h>
#include <TH3.h>
#include <TF3.h>
#include <TMath.h>
#include <THnSparse.h>
#include <TString.h>
#include "AliCFContainer.h"
#include "AliLog.h"
#include "AliVParticle.h"
#include "AliHFEcontainer.h"
#include "AliHFEsignalCuts.h"
#include "AliHFEtools.h"
#include "AliHFEvarManager.h"
ClassImp(AliHFEvarManager)
ClassImp(AliHFEvarManager::AliHFEvariable);
AliHFEvarManager::AliHFEvarManager():
TNamed(),
fVariables(NULL),
fContent(NULL),
fContentMC(NULL),
fWeightFactor(1.),
fSignalTrack(kTRUE),
fWeighting(kFALSE),
fSignal(NULL),
fWeightFactors(NULL),
fWeightFactorsFunction(NULL)
{
SetOwner();
}
AliHFEvarManager::AliHFEvarManager(const Char_t *name):
TNamed(name, ""),
fVariables(NULL),
fContent(NULL),
fContentMC(NULL),
fWeightFactor(1.),
fSignalTrack(kTRUE),
fWeighting(kFALSE),
fSignal(NULL),
fWeightFactors(NULL),
fWeightFactorsFunction(NULL)
{
fVariables = new TObjArray;
SetOwner();
}
AliHFEvarManager::AliHFEvarManager(const AliHFEvarManager &ref):
TNamed(ref),
fVariables(NULL),
fContent(NULL),
fContentMC(NULL),
fWeightFactor(ref.fWeightFactor),
fSignalTrack(ref.fSignalTrack),
fWeighting(ref.fWeighting),
fSignal(NULL),
fWeightFactors(NULL),
fWeightFactorsFunction(NULL)
{
ref.Copy(*this);
}
AliHFEvarManager &AliHFEvarManager::operator=(const AliHFEvarManager &ref){
if(&ref != this){
this->~AliHFEvarManager();
ref.Copy(*this);
}
return *this;
}
AliHFEvarManager::~AliHFEvarManager(){
if(IsOwner()){
if(fVariables) delete fVariables;
}
if(fContent) delete[] fContent;
if(fContentMC) delete[] fContentMC;
}
void AliHFEvarManager::Copy(TObject &o) const{
AliHFEvarManager &target = dynamic_cast<AliHFEvarManager &>(o);
target.fVariables = fVariables;
target.fContent = new Double_t[sizeof(fContent)/sizeof(Double_t)];
target.fContentMC = new Double_t[sizeof(fContentMC)/sizeof(Double_t)];
target.fWeightFactor = fWeightFactor;
target.fSignalTrack = fSignalTrack;
target.fWeighting = fWeighting;
target.fSignal = fSignal;
target.fWeightFactors = fWeightFactors;
target.fWeightFactorsFunction = fWeightFactorsFunction;
target.SetOwner(kFALSE);
}
void AliHFEvarManager::AddVariable(TString name){
AliDebug(1, Form("Var Name: %s", name.Data()));
if(!name.CompareTo("pt"))
fVariables->AddLast(new AliHFEvariable("pt", "pt", kPt, 44, 0.1, 20, kTRUE));
else if(!name.CompareTo("eta"))
fVariables->AddLast(new AliHFEvariable("eta", "eta", kEta, 8, -0.8, 0.8));
else if(!name.CompareTo("phi"))
fVariables->AddLast(new AliHFEvariable("phi", "phi", kPhi, 18, -0, 2*TMath::Pi()));
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, 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"))
fVariables->AddLast(new AliHFEvariable("species", "species", kSpecies, 6, -1, 5));
}
void AliHFEvarManager::AddVariable(TString name, Int_t nBins, Double_t min, Double_t max, Bool_t isLogarithmic){
AliDebug(1, Form("Var Name: %s", name.Data()));
UInt_t varcode = 1000;
if(!name.CompareTo("pt")){
varcode = kPt;
} else if(!name.CompareTo("eta")){
varcode = kEta;
} else if(!name.CompareTo("phi")){
varcode = kPhi;
} else if(!name.CompareTo("charge")){
varcode = kCharge;
} else if(!name.CompareTo("source")){
varcode = kSource;
} else if(!name.CompareTo("species")){
varcode = kSpecies;
} else if(!name.CompareTo("centrality")) {
varcode = kCentrality;
} else {
AliError("Variable not defined or not supposed to have a user-defined binning.");
}
if(varcode < 1000) fVariables->AddLast(new AliHFEvariable(name.Data(), name.Data(), varcode, nBins, min, max, isLogarithmic));
}
void AliHFEvarManager::AddVariable(TString name, Int_t nBins, const Double_t *binning){
AliDebug(1, Form("Var Name: %s", name.Data()));
UInt_t varcode = 1000;
if(!name.CompareTo("pt")){
varcode = kPt;
} else if(!name.CompareTo("eta")){
varcode = kEta;
} else if(!name.CompareTo("phi")){
varcode = kPhi;
} else if(!name.CompareTo("centrality")) {
varcode = kCentrality;
} else {
AliError("Variable not defined or not supposed to have a user-defined binning.");
}
if(varcode < 1000) fVariables->AddLast(new AliHFEvariable(name.Data(), name.Data(), varcode, nBins, binning));
}
Bool_t AliHFEvarManager::IsVariableDefined(TString name){
AliDebug(1, Form("Var Name: %s", name.Data()));
AliHFEvariable *u = (AliHFEvariable *) fVariables->FindObject((const char*)name);
if(u) return kTRUE;
else return kFALSE;
}
void AliHFEvarManager::DefineVariables(AliHFEcontainer *cont){
Int_t nVars = fVariables->GetEntriesFast();
cont->SetNumberOfVariables(nVars);
TIter vars(fVariables);
AliHFEvariable *var;
Int_t counter = 0;
while((var = dynamic_cast<AliHFEvariable *>(vars()))){
cont->SetVariableName(counter, var->GetName());
if(var->IsLogarithmic())
cont->MakeLogarithmicBinning(counter, var->GetNumberOfBins(), var->GetMinimum(), var->GetMaximum());
else if(var->HasUserDefinedBinning())
cont->MakeUserDefinedBinning(counter, var->GetNumberOfBins(), var->GetBinning());
else
cont->MakeLinearBinning(counter, var->GetNumberOfBins(), var->GetMinimum(), var->GetMaximum());
counter++;
}
fContent = new Double_t[nVars];
memset(fContent, 0, sizeof(Double_t) * nVars);
fContentMC = new Double_t[nVars];
memset(fContentMC, 0, sizeof(Double_t) * nVars);
}
void AliHFEvarManager::NewTrack(AliVParticle *recTrack, AliVParticle *mcTrack, Float_t centrality, Int_t aprioriPID, Bool_t signal){
AliDebug(1, "Filling new Track");
fSignalTrack = signal;
FillArray(recTrack, fContent, centrality, aprioriPID);
if(mcTrack) FillArray(mcTrack, fContentMC, centrality, aprioriPID);
if(fWeighting){
Int_t indexpt = -1, indexeta = -1, indexphi = -1, counter = 0;
AliHFEvariable *var = NULL;
TIter vars(fVariables);
while((var = dynamic_cast<AliHFEvariable *>(vars()))){
switch(var->GetVarCode()){
case kPt: indexpt = counter; break;
case kEta: indexeta = counter; break;
case kPhi: indexphi = counter; break;
};
if(indexpt >= 0 && indexeta >= 0 && indexphi >= 0)
break;
counter++;
}
if(indexpt >= 0 && indexeta >= 0 && indexphi >= 0)
fWeightFactor = FindWeight(fContent[indexpt], fContent[indexeta], fContent[indexphi]);
}
}
Double_t AliHFEvarManager::GetValue(AliVParticle *track, UInt_t code, Float_t centrality, Int_t aprioriPID) const {
if(!track) return 0.;
Double_t value = 0.;
switch(code){
case kPt: value = track->Pt(); break;
case kEta: value = track->Eta(); break;
case kPhi: value = track->Phi(); break;
case kCharge:{
value = track->Charge();
if(TString(track->IsA()->GetName()).Contains("MC")) value /= 3;
break;
}
case kSource:{
if(fSignal){
value = static_cast<Int_t>(fSignal->GetSignalSource(track));
}
AliDebug(2, Form("source: %f", value));
break;
}
case kSpecies: value = aprioriPID; break;
case kCentrality: value = centrality; break;
};
return value;
}
void AliHFEvarManager::FillArray(AliVParticle *track, Double_t* container, Float_t centrality, Int_t aprioriPID) const{
TIter vars(fVariables);
AliHFEvariable *var = NULL;
Int_t counter = 0;
while((var = dynamic_cast<AliHFEvariable *>(vars())))
container[counter++] = GetValue(track , var->GetVarCode(), centrality, aprioriPID);
}
void AliHFEvarManager::FillContainer(AliCFContainer *cont, Int_t step, Bool_t useMC) const{
Double_t *content = fContent;
if(useMC) content = fContentMC;
cont->Fill(content, step, fWeightFactor);
}
void AliHFEvarManager::FillContainer(const AliHFEcontainer *const cont, const Char_t *contname, UInt_t step, Bool_t useMC, Double_t externalWeight) const {
Double_t *content = fContent;
if(useMC) content = fContentMC;
cont->FillCFContainer(contname, step, content, fWeightFactor * externalWeight);
}
void AliHFEvarManager::FillContainerStepname(const AliHFEcontainer *const cont, const Char_t *contname, const Char_t *step, Bool_t useMC, Double_t externalWeight) const {
Double_t *content = fContent;
if(useMC) content = fContentMC;
cont->FillCFContainerStepname(contname, step, content, fWeightFactor * externalWeight);
}
void AliHFEvarManager::FillCorrelationMatrix(THnSparseF *matrix) const {
Int_t nVars = fVariables->GetEntriesFast();
Double_t *content = new Double_t[2*nVars];
memcpy(&content[0], fContent, sizeof(Double_t) * nVars);
memcpy(&content[nVars], fContentMC, sizeof(Double_t) * nVars);
matrix->Fill(content, fWeightFactor);
delete[] content;
}
void AliHFEvarManager::SetWeightFactors(TH3F *weightFactors){
fWeighting = kTRUE;
fWeightFactors = weightFactors;
}
void AliHFEvarManager::SetWeightFactorsFunction(TF3 *weightFactorsFunction){
fWeighting = kTRUE;
fWeightFactorsFunction = weightFactorsFunction;
}
Double_t AliHFEvarManager::FindWeight(Double_t pt, Double_t eta, Double_t phi) const {
Double_t weight = 1.0;
if(fWeightFactors) {
TAxis *ptaxis = fWeightFactors->GetXaxis();
TAxis *etaaxis = fWeightFactors->GetYaxis();
TAxis *phiaxis = fWeightFactors->GetZaxis();
Int_t ptbin = ptaxis->FindBin(pt);
Int_t etabin = etaaxis->FindBin(eta);
Int_t phibin = phiaxis->FindBin(phi);
weight = fWeightFactors->GetBinContent(ptbin,etabin,phibin);
}
else if(fWeightFactorsFunction) {
weight = fWeightFactorsFunction->Eval(pt,eta,phi);
}
AliDebug(2, Form("pt %f, eta %f, phi %f, weight %f",pt,eta,phi,weight));
return weight;
}
AliHFEvarManager::AliHFEvariable::AliHFEvariable():
TNamed()
, fCode(0)
, fNBins(0)
, fMin(0)
, fMax(0)
, fBinning()
, fIsLogarithmic(kFALSE)
, fUserDefinedBinning(kFALSE)
{
}
AliHFEvarManager::AliHFEvariable::AliHFEvariable(const Char_t *name, const Char_t *title, UInt_t code, UInt_t nBins, const Double_t *binning):
TNamed(name, title)
, fCode(code)
, fNBins(nBins)
, fMin(0.)
, fMax(0.)
, fBinning()
, fIsLogarithmic(kFALSE)
, fUserDefinedBinning(kTRUE)
{
fBinning.Set(nBins+1);
memcpy(fBinning.GetArray(), binning, sizeof(Double_t) * (nBins+1));
}
AliHFEvarManager::AliHFEvariable::AliHFEvariable(const Char_t *name, const Char_t *title, UInt_t code, UInt_t nBins, Double_t min, Double_t max, Bool_t isLogarithmic):
TNamed(name, title)
, fCode(code)
, fNBins(nBins)
, fMin(min)
, fMax(max)
, fBinning()
, fIsLogarithmic(isLogarithmic)
, fUserDefinedBinning(kFALSE)
{
}
AliHFEvarManager::AliHFEvariable::AliHFEvariable(const AliHFEvarManager::AliHFEvariable &ref):
TNamed(ref)
, fCode(ref.fCode)
, fNBins(ref.fNBins)
, fMin(ref.fMin)
, fMax(ref.fMax)
, fBinning(ref.fBinning)
, fIsLogarithmic(ref.fIsLogarithmic)
, fUserDefinedBinning(ref.fUserDefinedBinning)
{
}
AliHFEvarManager::AliHFEvariable& AliHFEvarManager::AliHFEvariable::operator=(const AliHFEvarManager::AliHFEvariable &ref){
if(&ref != this){
TNamed::operator=(ref);
fBinning = ref.fBinning;
fCode = ref.fCode;
fNBins = ref.fNBins;
fMax = ref.fMax;
fMin = ref.fMin;
fIsLogarithmic = ref.fIsLogarithmic;
fUserDefinedBinning = ref.fUserDefinedBinning;
}
return *this;
}
AliHFEvarManager::AliHFEvariable::~AliHFEvariable(){
}
Double_t* AliHFEvarManager::AliHFEvariable::GetBinning() {
if(fUserDefinedBinning) return fBinning.GetArray();
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();
}
}