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

/**************************************************************************
* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
*                                                                        *
* Author: The ALICE Off-line Project.                                    *
* Contributors are mentioned in the code where appropriate.              *
*                                                                        *
* Permission to use, copy, modify and distribute this software and its   *
* documentation strictly for non-commercial purposes is hereby granted   *
* without fee, provided that the above copyright notice appears in all   *
* copies and that both the copyright notice and this permission notice   *
* appear in the supporting documentation. The authors make no claims     *
* about the suitability of this software for any purpose. It is          *
* provided "as is" without express or implied warranty.                  *
**************************************************************************/
//
// HFE correction framework container
// Contains many single containers
// Extra fuctionality like appending added
//
// Author:
//   Markus Fasel <M.Fasel@gsi.de>
//
#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)
{
  //
  // Default constructor
  //
}

//__________________________________________________________________
AliHFEcontainer::AliHFEcontainer(const Char_t *name):
  TNamed(name, ""),
  fContainers(NULL),
  fCorrelationMatrices(NULL),
  fVariables(NULL),
  fNVars(0),
  fNEvents(0)
{
  //
  // Default constructor
  //
  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)
{
  //
  // Constructor
  // Setting Number of Variables too
  //
  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)
{
  //
  // Copy constructor
  // creates a new object with new (empty) containers
  //
  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());
  }
  // Copy also correlation matrices
  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){
  //
  // Assignment operator
  // Cleanup old object, create a new one with new containers inside
  //
  if(this == &ref) return *this;
  this->~AliHFEcontainer(); // cleanup old object before creating the new onwe
  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 {
    // No varible defined, do not try to copy anything
    fVariables = NULL;
    return *this;
  }

  // Reference contains content, try copying also the containers and the correlation matrices
  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));
  }
  // Copy also correlation matrices
  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(){
  //
  // Destructor
  //
  delete fContainers;
  if(fCorrelationMatrices) delete fCorrelationMatrices;
  if(fVariables){
    fVariables->Delete();
    delete fVariables;
  }
}

//__________________________________________________________________
Long64_t AliHFEcontainer::Merge(TCollection *coll){
  //
  // Merge Container
  //
  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;

    // Merge the two TObjArrays
    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){
  //
  // Define the number of variables 
  // Initialize containers for the variable informations
  //
  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){
  //
  // Create a new Correction Framework Container and store it 
  //
  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){
  //
  // Create Correlation Matrix
  //
  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)->Set(var->GetNumberOfBins(), var->GetBinning());
      hTmp->GetAxis(ivar)->SetTitle(var->GetVarName()->Data());
      //hTmp->GetAxis(ivar + fNVars)->Set(var->GetNumberOfBins(), var->GetBinning());
      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{
  //
  // Find a given container 
  //
  return dynamic_cast<AliCFContainer *>(fContainers->FindObject(name));
}

//__________________________________________________________________
THnSparseF *AliHFEcontainer::GetCorrelationMatrix(const Char_t *name) const{
  //
  // Find Correlation Matrix
  //
  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 {
  //
  // Fill container
  //
  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{
  //
  // Fill container
  //
  AliCFContainer *cont = GetCFContainer(name);
  if(!cont) return;
  // find the matching step title
  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){
    // step not found
    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 {
  //
  // Merge CF Container out of several containers 
  // Container names are separated by :
  // returns a new object which has to be taken care of by the user
  //

  TObjArray *containers = TString(contnames).Tokenize(":");
  // we first need the size of the container to be merged
  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;
  // Fill container with content
  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)));
  }
  return cmerged;
}

//__________________________________________________________________
void AliHFEcontainer::SetStepTitle(const Char_t *contname, const Char_t *steptitle, UInt_t step){
  //
  // Set title for given analysis step in container with name contname
  //
  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){
  //
  // Set Linear binning for the given container
  //
  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){
  //
  // Set Logarithmic binning for the given container
  //
  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){
  //
  // Set User defined 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){
  //
  // Variable name
  // 
  AliHFEvarInfo *myvar = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(var));
  if(myvar) myvar->SetVarName(varname);
}

//__________________________________________________________________
Int_t AliHFEcontainer::GetNumberOfCFContainers() const{
  //
  // Get the number of entries
  //
  return fContainers->GetEntries();
}

//__________________________________________________________________
void AliHFEcontainer::Sumw2(const char *contname) const {
  // 
  // Set sums of weights for all steps of a given container
  //
  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{
  //
  // Print Container Status
  //
  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;

  // Print CF Containers:
  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;
}

//------------------------------------ Content of class AliHFEvarInfo -----------------------------------
//__________________________________________________________________
AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo():
  TObject(),
  fVarName(NULL),
  fBinning(NULL)
{
  // Default constructor
  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)
{
  //
  // Constructor
  //
  fVarName = new TString(*(ref.fVarName));
  fBinning = new TArrayD(*(ref.fBinning));
}

//__________________________________________________________________
AliHFEcontainer::AliHFEvarInfo &AliHFEcontainer::AliHFEvarInfo::operator=(const AliHFEvarInfo &ref){
  //
  // Assignment operator
  //
  TObject::operator=(ref);
  *fVarName = *(ref.fVarName);
  *fBinning = *(ref.fBinning);
  return *this;
}

//__________________________________________________________________
AliHFEcontainer::AliHFEvarInfo::~AliHFEvarInfo(){
  //
  // Destructor
  //
  delete fVarName;
  delete fBinning;
}

//__________________________________________________________________
void AliHFEcontainer::AliHFEvarInfo::SetVarName(const Char_t *name){
  //
  // Setter for var name
  //
  *fVarName = name;
}

//__________________________________________________________________
void AliHFEcontainer::AliHFEvarInfo::SetBinning(UInt_t nBins, const Double_t *content){
  // Setter for binning
  //
  fBinning->Set(nBins + 1, content);
}
Commit	Line	Data
70da6c5a	1	/**************************************************************************
	2	* Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
	3	* *
	4	* Author: The ALICE Off-line Project. *
	5	* Contributors are mentioned in the code where appropriate. *
	6	* *
	7	* Permission to use, copy, modify and distribute this software and its *
	8	* documentation strictly for non-commercial purposes is hereby granted *
	9	* without fee, provided that the above copyright notice appears in all *
	10	* copies and that both the copyright notice and this permission notice *
	11	* appear in the supporting documentation. The authors make no claims *
	12	* about the suitability of this software for any purpose. It is *
	13	* provided "as is" without express or implied warranty. *
	14	**************************************************************************/
	15	//
	16	// HFE correction framework container
	17	// Contains many single containers
	18	// Extra fuctionality like appending added
	19	//
	20	// Author:
	21	// Markus Fasel <M.Fasel@gsi.de>
	22	//
	23	#include <iostream>
	24	#include <TAxis.h>
	25	#include <TClass.h>
	26	#include <TCollection.h>
	27	#include <THashList.h>
67fe7bd0	28	#include <THnSparse.h>
70da6c5a	29	#include <TList.h>
	30	#include <TObjArray.h>
	31	#include <TObjString.h>
	32	#include <TString.h>
	33
	34	#include "AliCFContainer.h"
aa1417ee	35	#include "AliCFGridSparse.h"
70da6c5a	36	#include "AliHFEcontainer.h"
	37	#include "AliHFEtools.h"
	38
	39	ClassImp(AliHFEcontainer)
	40	ClassImp(AliHFEcontainer::AliHFEvarInfo)
	41
	42	//__________________________________________________________________
	43	AliHFEcontainer::AliHFEcontainer():
	44	TNamed("HFEcontainer", ""),
	45	fContainers(NULL),
67fe7bd0	46	fCorrelationMatrices(NULL),
70da6c5a	47	fVariables(NULL),
	48	fNVars(0),
	49	fNEvents(0)
	50	{
	51	//
	52	// Default constructor
	53	//
70da6c5a	54	}
	55
	56	//__________________________________________________________________
	57	AliHFEcontainer::AliHFEcontainer(const Char_t *name):
	58	TNamed(name, ""),
	59	fContainers(NULL),
67fe7bd0	60	fCorrelationMatrices(NULL),
70da6c5a	61	fVariables(NULL),
	62	fNVars(0),
	63	fNEvents(0)
	64	{
	65	//
	66	// Default constructor
	67	//
	68	fContainers = new THashList();
3a72645a	69	fContainers->SetOwner();
70da6c5a	70	}
	71
	72	//__________________________________________________________________
	73	AliHFEcontainer::AliHFEcontainer(const Char_t *name, UInt_t nVar):
	74	TNamed(name, ""),
	75	fContainers(NULL),
67fe7bd0	76	fCorrelationMatrices(NULL),
70da6c5a	77	fVariables(NULL),
	78	fNVars(0),
	79	fNEvents(0)
	80	{
	81	//
	82	// Constructor
	83	// Setting Number of Variables too
	84	//
	85	fContainers = new THashList();
3a72645a	86	fContainers->SetOwner();
70da6c5a	87	SetNumberOfVariables(nVar);
	88	}
	89
	90	//__________________________________________________________________
	91	AliHFEcontainer::AliHFEcontainer(const AliHFEcontainer &ref):
	92	TNamed(ref),
	93	fContainers(NULL),
67fe7bd0	94	fCorrelationMatrices(NULL),
70da6c5a	95	fVariables(NULL),
	96	fNVars(ref.fNVars),
	97	fNEvents(ref.fNEvents)
	98	{
	99	//
	100	// Copy constructor
67fe7bd0	101	// creates a new object with new (empty) containers
70da6c5a	102	//
70da6c5a	103	if(fNVars){
70da6c5a	104	fVariables = new TObjArray(fNVars);
bf892a6a	105	AliHFEvarInfo *vtmp = NULL;
bf892a6a	106	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
215ffe88	107	vtmp = static_cast<AliHFEvarInfo *>(ref.fVariables->UncheckedAt(ivar));
215ffe88	108	fVariables->AddAt(new AliHFEvarInfo(*vtmp), ivar);
bf892a6a	109	}
70da6c5a	110	}
67fe7bd0	111	fContainers = new THashList;
3a72645a	112	fContainers->SetOwner();
67fe7bd0	113	AliCFContainer *ctmp = NULL;
67fe7bd0	114	for(Int_t ien = 0; ien < ref.fContainers->GetEntries(); ien++){
215ffe88	115	ctmp = static_cast<AliCFContainer *>(ref.fContainers->At(ien));
215ffe88	116	CreateContainer(ctmp->GetName(), ctmp->GetTitle(), ctmp->GetNStep());
67fe7bd0	117	}
	118	// Copy also correlation matrices
	119	if(ref.fCorrelationMatrices){
	120	THnSparseF *htmp = NULL;
	121	fCorrelationMatrices = new THashList;
3a72645a	122	fCorrelationMatrices->SetOwner();
67fe7bd0	123	for(Int_t ien = 0; ien < ref.fCorrelationMatrices->GetEntries(); ien++){
215ffe88	124	htmp = static_cast<THnSparseF *>(ref.fCorrelationMatrices->At(ien));
215ffe88	125	CreateCorrelationMatrix(htmp->GetName(), htmp->GetTitle());
67fe7bd0	126	}
67fe7bd0	127	}
70da6c5a	128	}
	129
	130	//__________________________________________________________________
	131	AliHFEcontainer &AliHFEcontainer::operator=(const AliHFEcontainer &ref){
	132	//
	133	// Assignment operator
	134	// Cleanup old object, create a new one with new containers inside
	135	//
aa1417ee	136	if(this == &ref) return *this;
70da6c5a	137	this->~AliHFEcontainer(); // cleanup old object before creating the new onwe
	138	TNamed::operator=(ref);
	139	fContainers = new THashList();
e3ae862b	140	fCorrelationMatrices = NULL;
70da6c5a	141	fNVars = ref.fNVars;
70da6c5a	142	if(fNVars){
70da6c5a	143	fVariables = new TObjArray(fNVars);
bf892a6a	144	AliHFEvarInfo *vtmp = NULL;
bf892a6a	145	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
215ffe88	146	vtmp = static_cast<AliHFEvarInfo *>(ref.fVariables->UncheckedAt(ivar));
215ffe88	147	fVariables->AddAt(new AliHFEvarInfo(*vtmp), ivar);
bf892a6a	148	}
70da6c5a	149	} else {
e3ae862b	150	// No varible defined, do not try to copy anything
70da6c5a	151	fVariables = NULL;
e3ae862b	152	return *this;
	153	}
	154
	155	// Reference contains content, try copying also the containers and the correlation matrices
	156	fContainers = new THashList();
	157	AliCFContainer *ctmp = NULL;
	158	for(Int_t ien = 0; ien < ref.fContainers->GetEntries(); ien++){
215ffe88	159	ctmp = static_cast<AliCFContainer *>(ref.fContainers->At(ien));
215ffe88	160	fContainers->Add(new AliCFContainer(*ctmp));
70da6c5a	161	}
3a72645a	162	// Copy also correlation matrices
	163	if(ref.fCorrelationMatrices){
	164	THnSparseF *htmp = NULL;
	165	fCorrelationMatrices = new THashList;
	166	fCorrelationMatrices->SetOwner();
	167	for(Int_t ien = 0; ien < ref.fCorrelationMatrices->GetEntries(); ien++){
215ffe88	168	htmp = static_cast<THnSparseF *>(ref.fCorrelationMatrices->At(ien));
215ffe88	169	CreateCorrelationMatrix(htmp->GetName(), htmp->GetTitle());
3a72645a	170	}
3a72645a	171	}
70da6c5a	172	return *this;
	173	}
	174
	175	//__________________________________________________________________
	176	AliHFEcontainer::~AliHFEcontainer(){
	177	//
	178	// Destructor
	179	//
70da6c5a	180	delete fContainers;
3a72645a	181	if(fCorrelationMatrices) delete fCorrelationMatrices;
70da6c5a	182	if(fVariables){
	183	fVariables->Delete();
	184	delete fVariables;
	185	}
	186	}
	187
	188	//__________________________________________________________________
	189	Long64_t AliHFEcontainer::Merge(TCollection *coll){
	190	//
	191	// Merge Container
	192	//
	193	if(!coll)
	194	return 0;
	195	if(coll->IsEmpty())
	196	return 1;
	197
8c1c76e9	198	TIter iter(coll);
70da6c5a	199	TObject *o = NULL;
70da6c5a	200	Long64_t count = 0;
8c1c76e9	201	while((o = iter())){
70da6c5a	202	AliHFEcontainer cont = dynamic_cast<AliHFEcontainer >(o);
	203	if(!cont) continue;
	204
	205	// Merge the two TObjArrays
	206	TList containers;
	207	containers.Add(cont->fContainers);
	208	fContainers->Merge(&containers);
	209
67fe7bd0	210	if(fCorrelationMatrices && cont->fCorrelationMatrices){
	211	containers.Clear();
	212	containers.Add(cont->fCorrelationMatrices);
	213	fCorrelationMatrices->Merge(&containers);
	214	}
	215
70da6c5a	216	fNEvents += cont->GetNumberOfEvents();
	217	count++;
	218	}
	219	return count + 1;
	220	}
	221
	222	//__________________________________________________________________
	223	void AliHFEcontainer::SetNumberOfVariables(UInt_t nVar){
	224	//
	225	// Define the number of variables
	226	// Initialize containers for the variable informations
	227	//
	228	if(fNVars) return;
	229
	230	fNVars = nVar;
	231	fVariables = new TObjArray(nVar);
	232	for(UInt_t ivar = 0; ivar < nVar; ivar++)
	233	fVariables->AddAt(new AliHFEvarInfo, ivar);
	234	}
	235
	236	//__________________________________________________________________
	237	void AliHFEcontainer::CreateContainer(const Char_t name, const Char_t title, UInt_t nStep){
	238	//
	239	// Create a new Correction Framework Container and store it
	240	//
	241	if(fContainers->FindObject(name)){
	242	AliError(Form("Container %s already exists. Cannot replace it!", name));
	243	return;
	244	}
	245
	246	Int_t *nBins = new Int_t[fNVars];
70da6c5a	247	AliHFEvarInfo *var = NULL;
bf892a6a	248	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
	249	var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
	250	nBins[ivar] = var ? var->GetNumberOfBins() : 0;
	251	}
70da6c5a	252	AliCFContainer *cont = new AliCFContainer(name, title, nStep, fNVars, nBins);
	253	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
	254	var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
bf892a6a	255	if(var){
	256	cont->SetBinLimits(ivar, var->GetBinning());
	257	cont->SetVarTitle(ivar, var->GetVarName()->Data());
	258	}
70da6c5a	259	}
	260	delete[] nBins;
	261	fContainers->Add(cont);
	262	AliInfo(Form("Container %s created with %d cut steps", name, nStep));
	263	}
	264
	265	//__________________________________________________________________
67fe7bd0	266	void AliHFEcontainer::CreateCorrelationMatrix(const Char_t name, const Char_t title){
	267	//
	268	// Create Correlation Matrix
	269	//
	270	if(!fCorrelationMatrices){
	271	fCorrelationMatrices = new THashList;
	272	fCorrelationMatrices->SetName("fCorrelationMatrices");
3a72645a	273	fCorrelationMatrices->SetOwner();
67fe7bd0	274	}
	275
	276	Int_t nBins = new Int_t[2fNVars];
67fe7bd0	277	AliHFEvarInfo *var = NULL;
	278	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
	279	var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
bf892a6a	280	if(var){
	281	nBins[ivar] = var->GetNumberOfBins();
	282	nBins[ivar+fNVars] = var->GetNumberOfBins();
	283	}
67fe7bd0	284	}
67fe7bd0	285
3a72645a	286	THnSparseF * hTmp = new THnSparseF(name, title, 2*fNVars, nBins);
67fe7bd0	287	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
67fe7bd0	288	var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
bf892a6a	289	if(var){
	290	hTmp->SetBinEdges(ivar,var->GetBinning());
	291	//hTmp->GetAxis(ivar)->Set(var->GetNumberOfBins(), var->GetBinning());
	292	hTmp->GetAxis(ivar)->SetTitle(var->GetVarName()->Data());
	293	//hTmp->GetAxis(ivar + fNVars)->Set(var->GetNumberOfBins(), var->GetBinning());
	294	hTmp->GetAxis(ivar + fNVars)->SetTitle(Form("%s_{MC}", var->GetVarName()->Data()));
	295	hTmp->SetBinEdges(ivar+fNVars,var->GetBinning());
	296	}
67fe7bd0	297	}
	298	hTmp->Sumw2();
	299	fCorrelationMatrices->AddLast(hTmp);
	300	}
	301
	302	//__________________________________________________________________
	303	AliCFContainer AliHFEcontainer::GetCFContainer(const Char_t name) const{
70da6c5a	304	//
	305	// Find a given container
	306	//
	307	return dynamic_cast<AliCFContainer *>(fContainers->FindObject(name));
	308	}
	309
67fe7bd0	310	//__________________________________________________________________
	311	THnSparseF AliHFEcontainer::GetCorrelationMatrix(const Char_t name) const{
	312	//
	313	// Find Correlation Matrix
	314	//
6555e2ad	315	if(fCorrelationMatrices) return dynamic_cast<THnSparseF *>(fCorrelationMatrices->FindObject(name));
	316	else return 0x0;
	317
67fe7bd0	318	}
67fe7bd0	319
70da6c5a	320	//__________________________________________________________________
c2690925	321	void AliHFEcontainer::FillCFContainer(const Char_t name, UInt_t step, const Double_t const content, Double_t weight) const {
70da6c5a	322	//
	323	// Fill container
	324	//
	325	AliCFContainer *cont = GetCFContainer(name);
	326	if(!cont) return;
3a72645a	327	cont->Fill(content, step, weight);
	328	}
	329
	330	//__________________________________________________________________
c2690925	331	void AliHFEcontainer::FillCFContainerStepname(const Char_t name, const Char_t steptitle, const Double_t * const content, Double_t weight)const{
3a72645a	332	//
	333	// Fill container
	334	//
	335	AliCFContainer *cont = GetCFContainer(name);
	336	if(!cont) return;
	337	// find the matching step title
	338	Int_t mystep = -1;
	339	for(Int_t istep = 0; istep < cont->GetNStep(); istep++){
	340	TString tstept = cont->GetStepTitle(istep);
	341	if(!tstept.CompareTo(steptitle)){
	342	mystep = istep;
	343	break;
	344	}
	345	}
	346	if(mystep < 0){
	347	// step not found
	348	AliDebug(1, Form("Step %s not found in container %s", steptitle, name));
	349	return;
	350	}
	351	AliDebug(1, Form("Filling step %s(%d) for container %s", steptitle, mystep, name));
	352	cont->Fill(content, mystep, weight);
70da6c5a	353	}
	354
	355	//__________________________________________________________________
6555e2ad	356	AliCFContainer AliHFEcontainer::MakeMergedCFContainer(const Char_t name, const Char_t title, const Char_t contnames) const {
70da6c5a	357	//
	358	// Merge CF Container out of several containers
	359	// Container names are separated by :
	360	// returns a new object which has to be taken care of by the user
	361	//
	362
	363	TObjArray *containers = TString(contnames).Tokenize(":");
	364	// we first need the size of the container to be merged
	365	Int_t nStepMerged = 0;
	366	AliCFContainer *ctemp = NULL;
	367	TObjString *cname = NULL;
	368	for(Int_t icont = 0; icont < containers->GetEntries(); icont++){
	369	cname = dynamic_cast<TObjString *>(containers->At(icont));
	370	ctemp = dynamic_cast<AliCFContainer *>(fContainers->FindObject(cname->String().Data()));
	371	if(!ctemp){
	372	AliWarning(Form("Container %s not found. It will be unprocessed", cname->String().Data()));
	373	continue;
	374	}
	375	nStepMerged += ctemp->GetNStep();
	376	}
	377	AliInfo("Please Ignore the messgae comming from AliCFContainer!");
	378	Int_t *dummyBinning = new Int_t[fNVars];
	379	for(UInt_t ibin = 0; ibin < fNVars; ibin++) dummyBinning[ibin] = 1;
	380	AliCFContainer *cmerged = new AliCFContainer(name, title, nStepMerged, fNVars, dummyBinning);
bf892a6a	381	delete[] dummyBinning;
70da6c5a	382	// Fill container with content
	383	AliInfo("Filling new container");
	384	Int_t cstep = 0;
	385	for(Int_t icont = 0; icont < containers->GetEntries(); icont++){
	386	cname = dynamic_cast<TObjString *>(containers->At(icont));
	387	ctemp = dynamic_cast<AliCFContainer *>(fContainers->FindObject(cname->String().Data()));
	388	if(!ctemp) continue;
	389	for(Int_t istep = 0; istep < ctemp->GetNStep(); istep++)
	390	cmerged->SetGrid(cstep++, new AliCFGridSparse(*ctemp->GetGrid(istep)));
	391	}
	392	return cmerged;
	393	}
3a72645a	394
	395	//__________________________________________________________________
	396	void AliHFEcontainer::SetStepTitle(const Char_t contname, const Char_t steptitle, UInt_t step){
	397	//
	398	// Set title for given analysis step in container with name contname
	399	//
	400	AliCFContainer *cont = GetCFContainer(contname);
	401	if(!cont) return;
	402	if(step >= static_cast<UInt_t>(cont->GetNStep())) return;
	403	cont->SetStepTitle(step, steptitle);
	404	}
	405
70da6c5a	406	//__________________________________________________________________
	407	void AliHFEcontainer::MakeLinearBinning(UInt_t var, UInt_t nBins, Double_t begin, Double_t end){
	408	//
	409	// Set Linear binning for the given container
	410	//
bf892a6a	411	AliHFEvarInfo myvar = dynamic_cast<AliHFEvarInfo >(fVariables->UncheckedAt(var));
bf892a6a	412	if(myvar) myvar->SetBinning(nBins, AliHFEtools::MakeLinearBinning(nBins, begin, end));
70da6c5a	413	}
	414
	415	//__________________________________________________________________
	416	void AliHFEcontainer::MakeLogarithmicBinning(UInt_t var, UInt_t nBins, Double_t begin, Double_t end){
	417	//
	418	// Set Logarithmic binning for the given container
	419	//
bf892a6a	420	AliHFEvarInfo myvar = dynamic_cast<AliHFEvarInfo >(fVariables->UncheckedAt(var));
bf892a6a	421	if(myvar) myvar->SetBinning(nBins, AliHFEtools::MakeLogarithmicBinning(nBins, begin, end));
70da6c5a	422	}
70da6c5a	423
8c1c76e9	424	//__________________________________________________________________
	425	void AliHFEcontainer::MakeUserDefinedBinning(UInt_t var, UInt_t nBins, const Double_t *binning){
	426	//
	427	// Set User defined binning
	428	//
	429	AliHFEvarInfo myvar = dynamic_cast<AliHFEvarInfo >(fVariables->UncheckedAt(var));
	430	if(myvar) myvar->SetBinning(nBins, binning);
	431	}
	432
70da6c5a	433	//__________________________________________________________________
	434	void AliHFEcontainer::SetVariableName(UInt_t var, const Char_t *varname){
	435	//
	436	// Variable name
	437	//
bf892a6a	438	AliHFEvarInfo myvar = dynamic_cast<AliHFEvarInfo >(fVariables->UncheckedAt(var));
bf892a6a	439	if(myvar) myvar->SetVarName(varname);
70da6c5a	440	}
	441
	442	//__________________________________________________________________
	443	Int_t AliHFEcontainer::GetNumberOfCFContainers() const{
	444	//
	445	// Get the number of entries
	446	//
	447	return fContainers->GetEntries();
	448	}
	449
aa1417ee	450	//__________________________________________________________________
	451	void AliHFEcontainer::Sumw2(const char *contname) const {
	452	//
	453	// Set sums of weights for all steps of a given container
	454	//
	455	AliCFContainer *cont = GetCFContainer(contname);
	456	if(cont){
	457	for(Int_t istep = 0; istep < cont->GetNStep(); istep++)
	458	cont->GetGrid(istep)->SumW2();
	459	}
	460	}
	461
70da6c5a	462	//__________________________________________________________________
	463	void AliHFEcontainer::Print(const Option_t *)const{
	464	//
	465	// Print Container Status
	466	//
	467	std::cout << "Container status: " << std::endl;
	468	std::cout << "=====================================================\n";
	469	std::cout << "Number of variables: " << fNVars << std::endl;
	470	if(fNVars){
	471	UInt_t nVars = fVariables ? fVariables->GetEntriesFast() : 0;
	472	if(nVars != fNVars)
	473	std::cout << "Inconsistency in number of Variables [" << fNVars << "\|" << nVars << "]" << std::endl;
	474	AliHFEvarInfo *var = NULL;
bf892a6a	475	if(fVariables){
	476	for(UInt_t ivar = 0; ivar < fNVars; ivar++){
	477	var = dynamic_cast<AliHFEvarInfo *>(fVariables->UncheckedAt(ivar));
	478	if(var)
	479	std::cout << "Variable " << ivar << ": Name: " << var->GetVarName()->Data() << ", Number of Bins: " << var->GetNumberOfBins() << std::endl;
	480	}
70da6c5a	481	}
	482	}
	483	std::cout << std::endl;
	484
	485	// Print CF Containers:
bf892a6a	486	if(fContainers){
	487	std::cout << "Containers[" << fContainers->GetEntries() << "]: "<< std::endl;
	488	std::cout << "=====================================================\n";
	489	for(Int_t icont = 0; icont < fContainers->GetEntries(); icont++){
	490	AliCFContainer c = dynamic_cast<AliCFContainer >(fContainers->At(icont));
	491	if(c){
	492	std::cout << "Name: " << c->GetName() << ", Title: " << c->GetTitle() << std::endl;
	493	for(Int_t istep = 0; istep < c->GetNStep(); istep++)
	494	std::cout << "Step " << istep << ": Title " << c->GetStepTitle(istep) << std::endl;
	495	}
	496	std::cout << "------------------------------------------------------\n";
	497	}
70da6c5a	498	}
	499	std::cout << "Number of Events: " << fNEvents << std::endl;
	500	}
	501
	502	//------------------------------------ Content of class AliHFEvarInfo -----------------------------------
	503	//__________________________________________________________________
	504	AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo():
	505	TObject(),
	506	fVarName(NULL),
	507	fBinning(NULL)
	508	{
	509	// Default constructor
	510	fBinning = new TArrayD;
	511	fVarName = new TString;
	512	}
	513
	514	//__________________________________________________________________
	515	AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo(const Char_t *name):
	516	TObject(),
	517	fVarName(NULL),
	518	fBinning(NULL)
	519	{
	520	fBinning = new TArrayD;
	521	fVarName = new TString(name);
	522	}
	523
	524	//__________________________________________________________________
	525	AliHFEcontainer::AliHFEvarInfo::AliHFEvarInfo(const AliHFEvarInfo &ref):
	526	TObject(ref),
	527	fVarName(NULL),
	528	fBinning(NULL)
	529	{
	530	//
	531	// Constructor
	532	//
	533	fVarName = new TString(*(ref.fVarName));
	534	fBinning = new TArrayD(*(ref.fBinning));
	535	}
	536
	537	//__________________________________________________________________
	538	AliHFEcontainer::AliHFEvarInfo &AliHFEcontainer::AliHFEvarInfo::operator=(const AliHFEvarInfo &ref){
	539	//
	540	// Assignment operator
	541	//
	542	TObject::operator=(ref);
	543	fVarName = (ref.fVarName);
	544	fBinning = (ref.fBinning);
	545	return *this;
	546	}
	547
	548	//__________________________________________________________________
	549	AliHFEcontainer::AliHFEvarInfo::~AliHFEvarInfo(){
	550	//
	551	// Destructor
	552	//
	553	delete fVarName;
	554	delete fBinning;
	555	}
	556
	557	//__________________________________________________________________
	558	void AliHFEcontainer::AliHFEvarInfo::SetVarName(const Char_t *name){
	559	//
	560	// Setter for var name
	561	//
562	*fVarName = name;
563	}
564
565	//__________________________________________________________________
8c1c76e9	566	void AliHFEcontainer::AliHFEvarInfo::SetBinning(UInt_t nBins, const Double_t *content){
70da6c5a	567	// Setter for binning
	568	//
	569	fBinning->Set(nBins + 1, content);
	570	}
	571