#include <iostream>
#include <TAxis.h>
#include <TClass.h>
#include <TCollection.h>
#include <THashList.h>
#include <THnSparse.h>
#include <TList.h>
#include <TObjArray.h>
#include <TObjString.h>
#include <TString.h>
#include "AliCFContainer.h"
#include "AliCFGridSparse.h"
#include "AliHFEcontainer.h"
#include "AliHFEtools.h"
ClassImp(AliHFEcontainer)
ClassImp(AliHFEcontainer::AliHFEvarInfo)
AliHFEcontainer::AliHFEcontainer():
TNamed("HFEcontainer", ""),
fContainers(NULL),
fCorrelationMatrices(NULL),
fVariables(NULL),
fNVars(0),
fNEvents(0)
{
}
AliHFEcontainer::AliHFEcontainer(const Char_t *name):
TNamed(name, ""),
fContainers(NULL),
fCorrelationMatrices(NULL),
fVariables(NULL),
fNVars(0),
fNEvents(0)
{
fContainers = new THashList();
fContainers->SetOwner();
}
AliHFEcontainer::AliHFEcontainer(const Char_t *name, UInt_t nVar):
TNamed(name, ""),
fContainers(NULL),
fCorrelationMatrices(NULL),
fVariables(NULL),
fNVars(0),
fNEvents(0)
{
fContainers = new THashList();
fContainers->SetOwner();
SetNumberOfVariables(nVar);
}
AliHFEcontainer::AliHFEcontainer(const AliHFEcontainer &ref):
TNamed(ref),
fContainers(NULL),
fCorrelationMatrices(NULL),
fVariables(NULL),
fNVars(ref.fNVars),
fNEvents(ref.fNEvents)
{
if(fNVars){
fVariables = new TObjArray(fNVars);
AliHFEvarInfo *vtmp = NULL;
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
vtmp = static_cast<AliHFEvarInfo *>(ref.fVariables->UncheckedAt(ivar));
fVariables->AddAt(new AliHFEvarInfo(*vtmp), ivar);
}
}
fContainers = new THashList;
fContainers->SetOwner();
AliCFContainer *ctmp = NULL;
for(Int_t ien = 0; ien < ref.fContainers->GetEntries(); ien++){
ctmp = static_cast<AliCFContainer *>(ref.fContainers->At(ien));
CreateContainer(ctmp->GetName(), ctmp->GetTitle(), ctmp->GetNStep());
}
if(ref.fCorrelationMatrices){
THnSparseF *htmp = NULL;
fCorrelationMatrices = new THashList;
fCorrelationMatrices->SetOwner();
for(Int_t ien = 0; ien < ref.fCorrelationMatrices->GetEntries(); ien++){
htmp = static_cast<THnSparseF *>(ref.fCorrelationMatrices->At(ien));
CreateCorrelationMatrix(htmp->GetName(), htmp->GetTitle());
}
}
}
AliHFEcontainer &AliHFEcontainer::operator=(const AliHFEcontainer &ref){
if(this == &ref) return *this;
this->~AliHFEcontainer();
TNamed::operator=(ref);
fContainers = new THashList();
fCorrelationMatrices = NULL;
fNVars = ref.fNVars;
if(fNVars){
fVariables = new TObjArray(fNVars);
AliHFEvarInfo *vtmp = NULL;
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
vtmp = static_cast<AliHFEvarInfo *>(ref.fVariables->UncheckedAt(ivar));
fVariables->AddAt(new AliHFEvarInfo(*vtmp), ivar);
}
} else {
fVariables = NULL;
return *this;
}
fContainers = new THashList();
AliCFContainer *ctmp = NULL;
for(Int_t ien = 0; ien < ref.fContainers->GetEntries(); ien++){
ctmp = static_cast<AliCFContainer *>(ref.fContainers->At(ien));
fContainers->Add(new AliCFContainer(*ctmp));
}
if(ref.fCorrelationMatrices){
THnSparseF *htmp = NULL;
fCorrelationMatrices = new THashList;
fCorrelationMatrices->SetOwner();
for(Int_t ien = 0; ien < ref.fCorrelationMatrices->GetEntries(); ien++){
htmp = static_cast<THnSparseF *>(ref.fCorrelationMatrices->At(ien));
CreateCorrelationMatrix(htmp->GetName(), htmp->GetTitle());
}
}
return *this;
}
AliHFEcontainer::~AliHFEcontainer(){
delete fContainers;
if(fCorrelationMatrices) delete fCorrelationMatrices;
if(fVariables){
fVariables->Delete();
delete fVariables;
}
}
Long64_t AliHFEcontainer::Merge(TCollection *coll){
if(!coll)
return 0;
if(coll->IsEmpty())
return 1;
TIter iter(coll);
TObject *o = NULL;
Long64_t count = 0;
while((o = iter())){
AliHFEcontainer *cont = dynamic_cast<AliHFEcontainer *>(o);
if(!cont) continue;
TList containers;
containers.Add(cont->fContainers);
fContainers->Merge(&containers);
if(fCorrelationMatrices && cont->fCorrelationMatrices){
containers.Clear();
containers.Add(cont->fCorrelationMatrices);
fCorrelationMatrices->Merge(&containers);
}
fNEvents += cont->GetNumberOfEvents();
count++;
}
return count + 1;
}
void AliHFEcontainer::SetNumberOfVariables(UInt_t nVar){
if(fNVars) return;
fNVars = nVar;
fVariables = new TObjArray(nVar);
for(UInt_t ivar = 0; ivar < nVar; ivar++)
fVariables->AddAt(new AliHFEvarInfo, ivar);
}
void AliHFEcontainer::CreateContainer(const Char_t *name, const Char_t *title, UInt_t nStep){
if(fContainers->FindObject(name)){
AliError(Form("Container %s already exists. Cannot replace it!", name));
return;
}
Int_t *nBins = new Int_t[fNVars];
AliHFEvarInfo *var = NULL;
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
nBins[ivar] = var ? var->GetNumberOfBins() : 0;
}
AliCFContainer *cont = new AliCFContainer(name, title, nStep, fNVars, nBins);
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
if(var){
cont->SetBinLimits(ivar, var->GetBinning());
cont->SetVarTitle(ivar, var->GetVarName()->Data());
}
}
delete[] nBins;
fContainers->Add(cont);
AliInfo(Form("Container %s created with %d cut steps", name, nStep));
}
void AliHFEcontainer::CreateCorrelationMatrix(const Char_t *name, const Char_t *title){
if(!fCorrelationMatrices){
fCorrelationMatrices = new THashList;
fCorrelationMatrices->SetName("fCorrelationMatrices");
fCorrelationMatrices->SetOwner();
}
Int_t *nBins = new Int_t[2*fNVars];
AliHFEvarInfo *var = NULL;
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
if(var){
nBins[ivar] = var->GetNumberOfBins();
nBins[ivar+fNVars] = var->GetNumberOfBins();
}
}
THnSparseF * hTmp = new THnSparseF(name, title, 2*fNVars, nBins);
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
if(var){
hTmp->SetBinEdges(ivar,var->GetBinning());
hTmp->GetAxis(ivar)->SetTitle(var->GetVarName()->Data());
hTmp->GetAxis(ivar + fNVars)->SetTitle(Form("%s_{MC}", var->GetVarName()->Data()));
hTmp->SetBinEdges(ivar+fNVars,var->GetBinning());
}
}
hTmp->Sumw2();
fCorrelationMatrices->AddLast(hTmp);
}
AliCFContainer *AliHFEcontainer::GetCFContainer(const Char_t *name) const{
return dynamic_cast<AliCFContainer *>(fContainers->FindObject(name));
}
THnSparseF *AliHFEcontainer::GetCorrelationMatrix(const Char_t *name) const{
if(fCorrelationMatrices) return dynamic_cast<THnSparseF *>(fCorrelationMatrices->FindObject(name));
else return 0x0;
}
void AliHFEcontainer::FillCFContainer(const Char_t *name, UInt_t step, const Double_t * const content, Double_t weight) const {
AliCFContainer *cont = GetCFContainer(name);
if(!cont) return;
cont->Fill(content, step, weight);
}
void AliHFEcontainer::FillCFContainerStepname(const Char_t *name, const Char_t *steptitle, const Double_t * const content, Double_t weight)const{
AliCFContainer *cont = GetCFContainer(name);
if(!cont) return;
Int_t mystep = -1;
for(Int_t istep = 0; istep < cont->GetNStep(); istep++){
TString tstept = cont->GetStepTitle(istep);
if(!tstept.CompareTo(steptitle)){
mystep = istep;
break;
}
}
if(mystep < 0){
AliDebug(1, Form("Step %s not found in container %s", steptitle, name));
return;
}
AliDebug(1, Form("Filling step %s(%d) for container %s", steptitle, mystep, name));
cont->Fill(content, mystep, weight);
}
AliCFContainer *AliHFEcontainer::MakeMergedCFContainer(const Char_t *name, const Char_t *title, const Char_t* contnames) const {
TObjArray *containers = TString(contnames).Tokenize(":");
Int_t nStepMerged = 0;
AliCFContainer *ctemp = NULL;
TObjString *cname = NULL;
for(Int_t icont = 0; icont < containers->GetEntries(); icont++){
cname = dynamic_cast<TObjString *>(containers->At(icont));
ctemp = dynamic_cast<AliCFContainer *>(fContainers->FindObject(cname->String().Data()));
if(!ctemp){
AliWarning(Form("Container %s not found. It will be unprocessed", cname->String().Data()));
continue;
}
nStepMerged += ctemp->GetNStep();
}
AliInfo("Please Ignore the messgae comming from AliCFContainer!");
Int_t *dummyBinning = new Int_t[fNVars];
for(UInt_t ibin = 0; ibin < fNVars; ibin++) dummyBinning[ibin] = 1;
AliCFContainer *cmerged = new AliCFContainer(name, title, nStepMerged, fNVars, dummyBinning);
delete[] dummyBinning;
AliInfo("Filling new container");
Int_t cstep = 0;
for(Int_t icont = 0; icont < containers->GetEntries(); icont++){
cname = dynamic_cast<TObjString *>(containers->At(icont));
ctemp = dynamic_cast<AliCFContainer *>(fContainers->FindObject(cname->String().Data()));
if(!ctemp) continue;
for(Int_t istep = 0; istep < ctemp->GetNStep(); istep++)
cmerged->SetGrid(cstep++, new AliCFGridSparse(*ctemp->GetGrid(istep)));
}
delete containers;
return cmerged;
}
void AliHFEcontainer::SetStepTitle(const Char_t *contname, const Char_t *steptitle, UInt_t step){
AliCFContainer *cont = GetCFContainer(contname);
if(!cont) return;
if(step >= static_cast<UInt_t>(cont->GetNStep())) return;
cont->SetStepTitle(step, steptitle);
}
void AliHFEcontainer::MakeLinearBinning(UInt_t var, UInt_t nBins, Double_t begin, Double_t end){
AliHFEvarInfo *myvar = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(var));
if(myvar) myvar->SetBinning(nBins, AliHFEtools::MakeLinearBinning(nBins, begin, end));
}
void AliHFEcontainer::MakeLogarithmicBinning(UInt_t var, UInt_t nBins, Double_t begin, Double_t end){
AliHFEvarInfo *myvar = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(var));
if(myvar) myvar->SetBinning(nBins, AliHFEtools::MakeLogarithmicBinning(nBins, begin, end));
}
void AliHFEcontainer::MakeUserDefinedBinning(UInt_t var, UInt_t nBins, const Double_t *binning){
AliHFEvarInfo *myvar = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(var));
if(myvar) myvar->SetBinning(nBins, binning);
}
void AliHFEcontainer::SetVariableName(UInt_t var, const Char_t *varname){
AliHFEvarInfo *myvar = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(var));
if(myvar) myvar->SetVarName(varname);
}
Int_t AliHFEcontainer::GetNumberOfCFContainers() const{
return fContainers->GetEntries();
}
void AliHFEcontainer::Sumw2(const char *contname) const {
AliCFContainer *cont = GetCFContainer(contname);
if(cont){
for(Int_t istep = 0; istep < cont->GetNStep(); istep++)
cont->GetGrid(istep)->SumW2();
}
}
void AliHFEcontainer::Print(const Option_t *)const{
std::cout << "Container status: " << std::endl;
std::cout << "=====================================================\n";
std::cout << "Number of variables: " << fNVars << std::endl;
if(fNVars){
UInt_t nVars = fVariables ? fVariables->GetEntriesFast() : 0;
if(nVars != fNVars)
std::cout << "Inconsistency in number of Variables [" << fNVars << "|" << nVars << "]" << std::endl;
AliHFEvarInfo *var = NULL;
if(fVariables){
for(UInt_t ivar = 0; ivar < fNVars; ivar++){
var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
if(var)
std::cout << "Variable " << ivar << ": Name: " << var->GetVarName()->Data() << ", Number of Bins: " << var->GetNumberOfBins() << std::endl;
}
}
}
std::cout << std::endl;
if(fContainers){
std::cout << "Containers[" << fContainers->GetEntries() << "]: "<< std::endl;
std::cout << "=====================================================\n";
for(Int_t icont = 0; icont < fContainers->GetEntries(); icont++){
AliCFContainer *c = dynamic_cast<AliCFContainer *>(fContainers->At(icont));
if(c){
std::cout << "Name: " << c->GetName() << ", Title: " << c->GetTitle() << std::endl;
for(Int_t istep = 0; istep < c->GetNStep(); istep++)
std::cout << "Step " << istep << ": Title " << c->GetStepTitle(istep) << std::endl;
}
std::cout << "------------------------------------------------------\n";
}
}
std::cout << "Number of Events: " << fNEvents << std::endl;
}
AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo():
TObject(),
fVarName(NULL),
fBinning(NULL)
{
fBinning = new TArrayD;
fVarName = new TString;
}
AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo(const Char_t *name):
TObject(),
fVarName(NULL),
fBinning(NULL)
{
fBinning = new TArrayD;
fVarName = new TString(name);
}
AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo(const AliHFEvarInfo &ref):
TObject(ref),
fVarName(NULL),
fBinning(NULL)
{
fVarName = new TString(*(ref.fVarName));
fBinning = new TArrayD(*(ref.fBinning));
}
AliHFEcontainer::AliHFEvarInfo &AliHFEcontainer::AliHFEvarInfo::operator=(const AliHFEvarInfo &ref){
TObject::operator=(ref);
*fVarName = *(ref.fVarName);
*fBinning = *(ref.fBinning);
return *this;
}
AliHFEcontainer::AliHFEvarInfo::~AliHFEvarInfo(){
delete fVarName;
delete fBinning;
}
void AliHFEcontainer::AliHFEvarInfo::SetVarName(const Char_t *name){
*fVarName = name;
}
void AliHFEcontainer::AliHFEvarInfo::SetBinning(UInt_t nBins, const Double_t *content){
fBinning->Set(nBins + 1, content);
}