[u/mrichter/AliRoot.git] / PWG / muondep / AliAnalysisMuMuSpectra.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.                  *
 **************************************************************************/


// AliAnalysisMuMuSpectra : a class to encapsulate results from MuMu analysis
//
// Spectra can be merged and converted into histograms
//
// author: L. Aphecetche (Subatech)
//

#include "AliAnalysisMuMuSpectra.h"

#include "AliLog.h"
#include "AliAnalysisMuMuBinning.h"
#include "AliAnalysisMuMuJpsiResult.h"
#include "Riostream.h"
#include "TH1.h"
#include "TH2.h"
#include "TList.h"
#include "TObjArray.h"

ClassImp(AliAnalysisMuMuSpectra)

//______________________________________________________________________________
AliAnalysisMuMuSpectra::AliAnalysisMuMuSpectra(const char* name, const char* title) :
TNamed(name,title),
fBinning(0x0),
fBins(0x0),
fWeight(1.0)
{
  // default ctor
}

//______________________________________________________________________________
AliAnalysisMuMuSpectra::AliAnalysisMuMuSpectra(const AliAnalysisMuMuSpectra& rhs)
: TNamed(rhs.GetName(),rhs.GetTitle()),
fBinning(0x0),
fBins(0x0),
fWeight(rhs.Weight())
{
  // copy ctor

  if ( rhs.fBinning )
  {
    fBinning = new AliAnalysisMuMuBinning(*rhs.fBinning);
  }

  TIter next(rhs.fBins);
  AliAnalysisMuMuResult* bin;
  
  while ( ( bin = static_cast<AliAnalysisMuMuResult*>(next()) ) )
  {
    if (!fBins)
    {
      fBins = new TObjArray;
      fBins->SetOwner(kTRUE);
    }
    fBins->Add(bin);
  }
  
  
}

//______________________________________________________________________________
AliAnalysisMuMuSpectra&
AliAnalysisMuMuSpectra::operator=(const AliAnalysisMuMuSpectra& rhs)
{
  // assignment operator
  
  if (this==&rhs) return *this;
  
  delete fBinning;
  fBinning = 0x0;
  delete fBins;
  fBins = 0x0;
  
  if ( rhs.fBinning )
  {
    fBinning = new AliAnalysisMuMuBinning(*rhs.fBinning);
  }
  
  TIter next(rhs.fBins);
  AliAnalysisMuMuResult* bin;
  
  while ( ( bin = static_cast<AliAnalysisMuMuResult*>(next()) ) )
  {
    if (!fBins)
    {
      fBins = new TObjArray;
      fBins->SetOwner(kTRUE);
    }
    fBins->Add(bin);
  }
  
  fWeight = rhs.Weight();
  
  return *this;
}

//______________________________________________________________________________
AliAnalysisMuMuSpectra::~AliAnalysisMuMuSpectra()
{
  // dtor
  delete fBinning;
  delete fBins;
}

//______________________________________________________________________________
Bool_t AliAnalysisMuMuSpectra::AdoptResult(const AliAnalysisMuMuBinning::Range& bin,
                                         AliAnalysisMuMuResult* result)
{
  // adopt (i.e. we are becoming the owner) a result for a given bin
  if ( !result )
  {
    AliError("Cannot adopt a null result");
    return kFALSE
    ;
  }
  if (!fBinning)
  {
    fBinning = new AliAnalysisMuMuBinning;
    fBins = new TObjArray;
    fBins->SetOwner(kTRUE);
  }
  fBinning->AddBin(bin); // Add a bin to the spectra
  
  Int_t sizeBeforeAdd = fBins->GetEntriesFast();
  fBins->Add(result); // Add the result to the recently added bin
  Int_t sizeAfterAdd = fBins->GetEntriesFast();
  if ( sizeBeforeAdd >= sizeAfterAdd )
  {
   AliError(Form("Error adopting result %s to spectra %s",result->GetName(),GetName()));
    return kFALSE;
  }
  else return kTRUE;
}

//______________________________________________________________________________
Bool_t AliAnalysisMuMuSpectra::Correct(const AliAnalysisMuMuSpectra& accEff, const char* particle, const char* subResultName)
{
  /// Correct this spectra by acceff one
  if (IsEmpty())
  {
    AliError("Cannot correct an empty spectra !");
    return kFALSE;
  }
  
  // check we have the same binning first
  AliAnalysisMuMuBinning* accEffBins = accEff.Binning();
  
  if ( !fBinning->IsEqual(accEffBins) )
  {
    AliError("Cannot correct with a spectra which does not have the same binning");
    return kFALSE;
  }
  
  TObjArray* particles = fBinning->CreateWhatArray();
  TObjArray* types = fBinning->CreateQuantityArray();
  
  // FIXME : cross-check what happens here with a binning containing
  // centralities, etc...
  
  if (particles->GetEntries()!=1 || types->GetEntries()!=1 )
  {
    delete particles;
    delete types;
    return kFALSE;
  }
  
  TObjArray* bins = accEff.BinContentArray();

  
  for ( Int_t i = 0; i < bins->GetEntries(); ++i )
  {
    AliAnalysisMuMuJpsiResult* thisResult = static_cast<AliAnalysisMuMuJpsiResult*>(fBins->At(i));
    AliAnalysisMuMuJpsiResult* accResult = static_cast<AliAnalysisMuMuJpsiResult*>(bins->At(i));
//    AliInfoClass(Form("i=%d",i ));
//    StdoutToAliInfoClass(thisResult->Print("full");
//                         std::cout << "----" << std::endl;
//                         accResult->Print("full"));
    
    thisResult->Correct(*accResult,particle,subResultName);
  }
  
  delete particles;
  delete types;
  return kTRUE;
}

//______________________________________________________________________________
AliAnalysisMuMuResult*
AliAnalysisMuMuSpectra::GetResultForBin(const AliAnalysisMuMuBinning::Range& bin) const
{
  /// Get result for a given bin
  /// Warning: this requires a loop on bins
  
  if ( IsEmpty() ) return 0x0;
  
  TObjArray* bins = fBinning->CreateBinObjArray();
  
  Int_t j(-1);
  
  StdoutToAliDebug(1,std::cout << "searching for "; bin.Print());
  
  for ( Int_t i = 0; i <= bins->GetLast() && j < 0 ; ++i )
  {
    AliAnalysisMuMuBinning::Range* b = static_cast<AliAnalysisMuMuBinning::Range*>(bins->At(i));

    StdoutToAliDebug(1,b->Print(););
    
    if ( bin == *b )
    {
      j = i;
    }
  }
  
  delete bins;
  
  if (j>=0)
  {
    return static_cast<AliAnalysisMuMuResult*>(fBins->At(j));
  }
  else
  {
    StdoutToAliDebug(1,std::cout << "Could not find result for bin:" << std::endl; bin.Print(););
  }
  return 0x0;
}

//______________________________________________________________________________
AliAnalysisMuMuResult*
AliAnalysisMuMuSpectra::GetResultForBin(const char* binName) const
{
  /// Get result for a given bin
  /// Warning: this requires a loop on bins
  
  if ( IsEmpty() ) return 0x0;
  
  TObjArray* bins = fBinning->CreateBinObjArray();
  
  Int_t j(-1);
  
  AliDebug(1,Form("searching for bin %s",binName));
  
  for ( Int_t i = 0; i <= bins->GetLast() && j < 0 ; ++i )
  {
    AliAnalysisMuMuBinning::Range* b = static_cast<AliAnalysisMuMuBinning::Range*>(bins->At(i));
    
    if ( b->AsString() == binName )
    {
      j = i;
    }
  }
  
  delete bins;
  
  if (j>=0)
  {
    return static_cast<AliAnalysisMuMuResult*>(fBins->At(j));
  }
  else
  {
    AliDebug(1,Form("Could not find result for bin %s",binName));
  }
  return 0x0;
}

//______________________________________________________________________________
Bool_t AliAnalysisMuMuSpectra::HasValue(const char* what) const
{
    // whether or not our result(s) has a given property
  if ( IsEmpty() ) return kFALSE;
  
  AliAnalysisMuMuResult* r = static_cast<AliAnalysisMuMuResult*>(fBins->First());
  
  return r->HasValue(what);
}

//______________________________________________________________________________
Bool_t AliAnalysisMuMuSpectra::IsEmpty() const
{
  // whether this spectra is empty or not
  return ( fBins==0x0 || fBins->GetEntries()<=0 );
}

//______________________________________________________________________________
Long64_t AliAnalysisMuMuSpectra::Merge(TCollection* list)
{
  /// Merge method
  
  // Merge a list of AliAnalysisMuMuSpectra objects with this
  // Returns the number of merged objects (including this).
  
  if (!list) return 0;
  
  if (list->IsEmpty()) return 1;
  
  TIter next(list);
  TObject* currObj;
  Int_t count(0);
  
  TList binningList;
  
  // for each bin must do a list of results, and merge that list
  
  TObjArray* bins = fBinning->CreateBinObjArray();
  TIter nextBin(bins);
  AliAnalysisMuMuBinning::Range* bin;

  Int_t i(0);
  
  while ( ( bin = static_cast<AliAnalysisMuMuBinning::Range*>(nextBin()) ) )
  {
    next.Reset();
    
    TList binList;
    
    while ( ( currObj = next() ) )
    {
      AliAnalysisMuMuSpectra* spectra = static_cast<AliAnalysisMuMuSpectra*>(currObj);

      if (i==0)
      {
        binningList.Add(spectra->Binning());
  
        if ( !fBinning->IsEqual(spectra->Binning()) || spectra->BinContentArray()->GetLast() != BinContentArray()->GetLast() )
        {
          AliError("Cannot merge spectra with different binning");
          continue;
        }
        ++count;
      }
      
      binList.Add(spectra->GetResultForBin(*bin));
    }
    
    ++i;
    
    AliAnalysisMuMuResult* r = static_cast<AliAnalysisMuMuResult*>(GetResultForBin(*bin));
    r->Merge(&binList);
    
  }

  delete bins;
  
  return count+1;
}

//_____________________________________________________________________________
TH1* AliAnalysisMuMuSpectra::Plot(const char* what, const char* subresult, Bool_t divideByBinWidth) const
{
  // Convert the spectra into an histogram
  
  TString swhat(what);
  TString swhatT(what);
  swhat.ToUpper();
  
  Double_t* bins = fBinning->CreateBinArray();
  Double_t* binsX = fBinning->CreateBinArrayX();
  Double_t* binsY = fBinning->CreateBinArrayY();
  
  Int_t nbinsX = fBinning->GetNBinsX();
  Int_t nbinsY = fBinning->GetNBinsY();
  
  TObjArray* binArray = fBinning->CreateBinObjArray();
  
  TH1* h(0x0);
  
  AliDebug(1,Form("nbins=%d nresults=%d",binArray->GetEntries(),fBins->GetEntries()));
  
  for ( Int_t j = 0; j < TMath::Min(binArray->GetEntries(),fBins->GetEntries()); ++j )
  {
    AliAnalysisMuMuJpsiResult* r = static_cast<AliAnalysisMuMuJpsiResult*>(fBins->At(j));
    
    if ( strlen(subresult) > 0 && r->SubResults() )
    {
      TString sub(subresult);
      r = static_cast<AliAnalysisMuMuJpsiResult*>(r->SubResult(sub.Data()));
      if (!r) continue;
    }
    
    const AliAnalysisMuMuBinning::Range& b = r->Bin();
    
    if ( b.Is2D() )
    {
      if (!h)
      {
        h = new TH2F(r->GetName(),r->GetName(),nbinsX,binsX,nbinsY,binsY);
        h->SetDirectory(0);
      }
      
      Double_t z = r->GetValue(swhatT.Data());
      Double_t zerr = r->GetErrorStat(swhatT.Data());
      
      if ( swhat.Contains("AccEff",TString::kIgnoreCase) )
      {
        if ( z < 0. || z > 5.)
        {
          z = -1.;
          zerr = 0.;
        }
      }
      
      if ( divideByBinWidth && b.WidthX()>0 )
      {
        z /= (b.WidthX()*b.WidthY());
        zerr /= (b.WidthX()*b.WidthY());
        
      }
      
      std::cout << b.AsString();
      r->PrintValue(swhat.Data(),"",z,zerr);
      
      Int_t x = j/nbinsY + 1;
      Int_t y = (j % nbinsY) + 1;
      
      std::cout << "x="  << x << ";" << "y=" << y << std::endl;
      
      h->SetBinContent(x,y,z);
      h->SetBinError(x,y,zerr);
      
    }

    else
    {
      if (!h)
      {
        h = new TH1F(r->GetName(),r->GetName(),binArray->GetEntries(),bins);
        h->SetDirectory(0);
      }
      
      Double_t y = r->GetValue(swhatT.Data());
      Double_t yerr = r->GetErrorStat(swhatT.Data());
      
      if ( divideByBinWidth && b.WidthX()>0 )
      {
        y /= (b.WidthX());
        yerr /= (b.WidthX());
      }
      
      if (!TMath::Finite(y)) y = 0.0;
      if (!TMath::Finite(yerr)) yerr = 0.0;
      
      std::cout << b.AsString();
      r->PrintValue(swhat.Data(),"",y,yerr);
      
      h->SetBinContent(j+1,y);
      h->SetBinError(j+1,yerr);
    }
  }
  
  delete binArray;
  delete[] binsX;
  delete[] binsY;
  delete[] bins;
  
  return h;
}


//______________________________________________________________________________
void AliAnalysisMuMuSpectra::Print(Option_t* opt) const
{
  // printout
  
  if (!IsEmpty())
  {
    TString sopt(opt);
    Int_t nmax = sopt.Atoi();
    if ( nmax <= 0 ) nmax = fBins->GetEntries();
    for ( Int_t i = 0; i < nmax; ++i )
    {
      AliAnalysisMuMuResult* r = static_cast<AliAnalysisMuMuResult*>(fBins->At(i));
      if (r) r->Print(opt);
    }
  }
}

//______________________________________________________________________________
void AliAnalysisMuMuSpectra::Scale(Double_t value)
{
  // scale all bins by value

  TIter next(fBins);
  AliAnalysisMuMuResult* r;

  while ( ( r = static_cast<AliAnalysisMuMuResult*>(next()) ) )
  {
    r->Scale(value);
  }
}

//______________________________________________________________________________
void AliAnalysisMuMuSpectra::SetWeight(Double_t w)
{
  // Set the weight of this spectra
  fWeight = w;
  TIter next(fBins);
  AliAnalysisMuMuResult* r;
  
  while ( ( r = static_cast<AliAnalysisMuMuResult*>(next()) ) )
  {
    r->SetWeight(Weight());
  }
}
Commit	Line	Data
1afce1ce	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
	17	// AliAnalysisMuMuSpectra : a class to encapsulate results from MuMu analysis
	18	//
	19	// Spectra can be merged and converted into histograms
	20	//
	21	// author: L. Aphecetche (Subatech)
	22	//
	23
a58729a5	24	#include "AliAnalysisMuMuSpectra.h"
	25
	26	#include "AliLog.h"
	27	#include "AliAnalysisMuMuBinning.h"
81190958	28	#include "AliAnalysisMuMuJpsiResult.h"
a58729a5	29	#include "Riostream.h"
a58729a5	30	#include "TH1.h"
cb690a12	31	#include "TH2.h"
a58729a5	32	#include "TList.h"
	33	#include "TObjArray.h"
	34
	35	ClassImp(AliAnalysisMuMuSpectra)
	36
	37	//______________________________________________________________________________
	38	AliAnalysisMuMuSpectra::AliAnalysisMuMuSpectra(const char* name, const char* title) :
	39	TNamed(name,title),
	40	fBinning(0x0),
81190958	41	fBins(0x0),
81190958	42	fWeight(1.0)
a58729a5	43	{
1afce1ce	44	// default ctor
	45	}
	46
	47	//______________________________________________________________________________
	48	AliAnalysisMuMuSpectra::AliAnalysisMuMuSpectra(const AliAnalysisMuMuSpectra& rhs)
	49	: TNamed(rhs.GetName(),rhs.GetTitle()),
	50	fBinning(0x0),
81190958	51	fBins(0x0),
81190958	52	fWeight(rhs.Weight())
1afce1ce	53	{
	54	// copy ctor
	55
	56	if ( rhs.fBinning )
	57	{
	58	fBinning = new AliAnalysisMuMuBinning(*rhs.fBinning);
	59	}
	60
	61	TIter next(rhs.fBins);
81190958	62	AliAnalysisMuMuResult* bin;
1afce1ce	63
81190958	64	while ( ( bin = static_cast<AliAnalysisMuMuResult*>(next()) ) )
1afce1ce	65	{
	66	if (!fBins)
	67	{
	68	fBins = new TObjArray;
	69	fBins->SetOwner(kTRUE);
	70	}
	71	fBins->Add(bin);
	72	}
81190958	73
81190958	74
1afce1ce	75	}
	76
	77	//______________________________________________________________________________
	78	AliAnalysisMuMuSpectra&
	79	AliAnalysisMuMuSpectra::operator=(const AliAnalysisMuMuSpectra& rhs)
	80	{
	81	// assignment operator
	82
	83	if (this==&rhs) return *this;
	84
	85	delete fBinning;
	86	fBinning = 0x0;
	87	delete fBins;
	88	fBins = 0x0;
	89
	90	if ( rhs.fBinning )
	91	{
	92	fBinning = new AliAnalysisMuMuBinning(*rhs.fBinning);
	93	}
	94
	95	TIter next(rhs.fBins);
81190958	96	AliAnalysisMuMuResult* bin;
a58729a5	97
81190958	98	while ( ( bin = static_cast<AliAnalysisMuMuResult*>(next()) ) )
1afce1ce	99	{
	100	if (!fBins)
	101	{
	102	fBins = new TObjArray;
	103	fBins->SetOwner(kTRUE);
	104	}
	105	fBins->Add(bin);
	106	}
	107
81190958	108	fWeight = rhs.Weight();
81190958	109
1afce1ce	110	return *this;
a58729a5	111	}
	112
	113	//______________________________________________________________________________
	114	AliAnalysisMuMuSpectra::~AliAnalysisMuMuSpectra()
	115	{
1afce1ce	116	// dtor
a58729a5	117	delete fBinning;
	118	delete fBins;
	119	}
	120
	121	//______________________________________________________________________________
cb690a12	122	Bool_t AliAnalysisMuMuSpectra::AdoptResult(const AliAnalysisMuMuBinning::Range& bin,
a58729a5	123	AliAnalysisMuMuResult* result)
a58729a5	124	{
1afce1ce	125	// adopt (i.e. we are becoming the owner) a result for a given bin
cb690a12	126	if ( !result )
	127	{
	128	AliError("Cannot adopt a null result");
	129	return kFALSE
	130	;
	131	}
a58729a5	132	if (!fBinning)
	133	{
	134	fBinning = new AliAnalysisMuMuBinning;
	135	fBins = new TObjArray;
	136	fBins->SetOwner(kTRUE);
	137	}
cb690a12	138	fBinning->AddBin(bin); // Add a bin to the spectra
	139
	140	Int_t sizeBeforeAdd = fBins->GetEntriesFast();
	141	fBins->Add(result); // Add the result to the recently added bin
	142	Int_t sizeAfterAdd = fBins->GetEntriesFast();
	143	if ( sizeBeforeAdd >= sizeAfterAdd )
	144	{
	145	AliError(Form("Error adopting result %s to spectra %s",result->GetName(),GetName()));
	146	return kFALSE;
	147	}
	148	else return kTRUE;
a58729a5	149	}
	150
	151	//______________________________________________________________________________
	152	Bool_t AliAnalysisMuMuSpectra::Correct(const AliAnalysisMuMuSpectra& accEff, const char* particle, const char* subResultName)
	153	{
	154	/// Correct this spectra by acceff one
	155	if (IsEmpty())
	156	{
	157	AliError("Cannot correct an empty spectra !");
	158	return kFALSE;
	159	}
	160
	161	// check we have the same binning first
	162	AliAnalysisMuMuBinning* accEffBins = accEff.Binning();
	163
	164	if ( !fBinning->IsEqual(accEffBins) )
	165	{
	166	AliError("Cannot correct with a spectra which does not have the same binning");
	167	return kFALSE;
	168	}
	169
5376e016 CP	170	TObjArray* particles = fBinning->CreateWhatArray();
5376e016 CP	171	TObjArray* types = fBinning->CreateQuantityArray();
a58729a5	172
cb690a12	173	// FIXME : cross-check what happens here with a binning containing
	174	// centralities, etc...
	175
a58729a5	176	if (particles->GetEntries()!=1 \|\| types->GetEntries()!=1 )
	177	{
	178	delete particles;
	179	delete types;
	180	return kFALSE;
	181	}
	182
81190958	183	TObjArray* bins = accEff.BinContentArray();
a58729a5	184
	185
	186	for ( Int_t i = 0; i < bins->GetEntries(); ++i )
	187	{
81190958	188	AliAnalysisMuMuJpsiResult* thisResult = static_cast<AliAnalysisMuMuJpsiResult*>(fBins->At(i));
81190958	189	AliAnalysisMuMuJpsiResult* accResult = static_cast<AliAnalysisMuMuJpsiResult*>(bins->At(i));
1afce1ce	190	// AliInfoClass(Form("i=%d",i ));
	191	// StdoutToAliInfoClass(thisResult->Print("full");
	192	// std::cout << "----" << std::endl;
	193	// accResult->Print("full"));
a58729a5	194
	195	thisResult->Correct(*accResult,particle,subResultName);
	196	}
	197
	198	delete particles;
	199	delete types;
	200	return kTRUE;
	201	}
	202
1afce1ce	203	//______________________________________________________________________________
	204	AliAnalysisMuMuResult*
	205	AliAnalysisMuMuSpectra::GetResultForBin(const AliAnalysisMuMuBinning::Range& bin) const
	206	{
	207	/// Get result for a given bin
	208	/// Warning: this requires a loop on bins
	209
	210	if ( IsEmpty() ) return 0x0;
	211
	212	TObjArray* bins = fBinning->CreateBinObjArray();
	213
	214	Int_t j(-1);
	215
	216	StdoutToAliDebug(1,std::cout << "searching for "; bin.Print());
	217
	218	for ( Int_t i = 0; i <= bins->GetLast() && j < 0 ; ++i )
	219	{
	220	AliAnalysisMuMuBinning::Range* b = static_cast<AliAnalysisMuMuBinning::Range*>(bins->At(i));
	221
	222	StdoutToAliDebug(1,b->Print(););
	223
	224	if ( bin == *b )
	225	{
	226	j = i;
	227	}
	228	}
	229
	230	delete bins;
	231
	232	if (j>=0)
	233	{
	234	return static_cast<AliAnalysisMuMuResult*>(fBins->At(j));
	235	}
	236	else
	237	{
	238	StdoutToAliDebug(1,std::cout << "Could not find result for bin:" << std::endl; bin.Print(););
	239	}
	240	return 0x0;
	241	}
	242
cb690a12	243	//______________________________________________________________________________
	244	AliAnalysisMuMuResult*
	245	AliAnalysisMuMuSpectra::GetResultForBin(const char* binName) const
	246	{
	247	/// Get result for a given bin
	248	/// Warning: this requires a loop on bins
	249
	250	if ( IsEmpty() ) return 0x0;
	251
	252	TObjArray* bins = fBinning->CreateBinObjArray();
	253
	254	Int_t j(-1);
	255
	256	AliDebug(1,Form("searching for bin %s",binName));
	257
	258	for ( Int_t i = 0; i <= bins->GetLast() && j < 0 ; ++i )
	259	{
	260	AliAnalysisMuMuBinning::Range* b = static_cast<AliAnalysisMuMuBinning::Range*>(bins->At(i));
	261
	262	if ( b->AsString() == binName )
	263	{
	264	j = i;
	265	}
	266	}
	267
	268	delete bins;
	269
	270	if (j>=0)
	271	{
	272	return static_cast<AliAnalysisMuMuResult*>(fBins->At(j));
	273	}
	274	else
	275	{
	276	AliDebug(1,Form("Could not find result for bin %s",binName));
	277	}
	278	return 0x0;
	279	}
	280
1afce1ce	281	//______________________________________________________________________________
	282	Bool_t AliAnalysisMuMuSpectra::HasValue(const char* what) const
	283	{
	284	// whether or not our result(s) has a given property
	285	if ( IsEmpty() ) return kFALSE;
	286
	287	AliAnalysisMuMuResult* r = static_cast<AliAnalysisMuMuResult*>(fBins->First());
	288
	289	return r->HasValue(what);
	290	}
	291
a58729a5	292	//______________________________________________________________________________
	293	Bool_t AliAnalysisMuMuSpectra::IsEmpty() const
	294	{
1afce1ce	295	// whether this spectra is empty or not
a58729a5	296	return ( fBins==0x0 \|\| fBins->GetEntries()<=0 );
	297	}
	298
	299	//______________________________________________________________________________
	300	Long64_t AliAnalysisMuMuSpectra::Merge(TCollection* list)
	301	{
	302	/// Merge method
	303
	304	// Merge a list of AliAnalysisMuMuSpectra objects with this
	305	// Returns the number of merged objects (including this).
	306
	307	if (!list) return 0;
	308
	309	if (list->IsEmpty()) return 1;
	310
	311	TIter next(list);
	312	TObject* currObj;
	313	Int_t count(0);
	314
	315	TList binningList;
	316
81190958	317	// for each bin must do a list of results, and merge that list
	318
	319	TObjArray* bins = fBinning->CreateBinObjArray();
	320	TIter nextBin(bins);
	321	AliAnalysisMuMuBinning::Range* bin;
	322
	323	Int_t i(0);
	324
	325	while ( ( bin = static_cast<AliAnalysisMuMuBinning::Range*>(nextBin()) ) )
a58729a5	326	{
	327	next.Reset();
	328
	329	TList binList;
	330
	331	while ( ( currObj = next() ) )
	332	{
81190958	333	AliAnalysisMuMuSpectra* spectra = static_cast<AliAnalysisMuMuSpectra*>(currObj);
81190958	334
a58729a5	335	if (i==0)
	336	{
	337	binningList.Add(spectra->Binning());
	338
81190958	339	if ( !fBinning->IsEqual(spectra->Binning()) \|\| spectra->BinContentArray()->GetLast() != BinContentArray()->GetLast() )
a58729a5	340	{
	341	AliError("Cannot merge spectra with different binning");
	342	continue;
	343	}
a58729a5	344	++count;
	345	}
	346
81190958	347	binList.Add(spectra->GetResultForBin(*bin));
a58729a5	348	}
a58729a5	349
81190958	350	++i;
	351
	352	AliAnalysisMuMuResult* r = static_cast<AliAnalysisMuMuResult>(GetResultForBin(bin));
a58729a5	353	r->Merge(&binList);
	354
	355	}
81190958	356
81190958	357	delete bins;
a58729a5	358
	359	return count+1;
	360	}
	361
	362	//_____________________________________________________________________________
1afce1ce	363	TH1* AliAnalysisMuMuSpectra::Plot(const char* what, const char* subresult, Bool_t divideByBinWidth) const
a58729a5	364	{
1afce1ce	365	// Convert the spectra into an histogram
1afce1ce	366
a58729a5	367	TString swhat(what);
cb690a12	368	TString swhatT(what);
a58729a5	369	swhat.ToUpper();
	370
	371	Double_t* bins = fBinning->CreateBinArray();
cb690a12	372	Double_t* binsX = fBinning->CreateBinArrayX();
	373	Double_t* binsY = fBinning->CreateBinArrayY();
	374
	375	Int_t nbinsX = fBinning->GetNBinsX();
	376	Int_t nbinsY = fBinning->GetNBinsY();
a58729a5	377
	378	TObjArray* binArray = fBinning->CreateBinObjArray();
	379
	380	TH1* h(0x0);
	381
1afce1ce	382	AliDebug(1,Form("nbins=%d nresults=%d",binArray->GetEntries(),fBins->GetEntries()));
a58729a5	383
	384	for ( Int_t j = 0; j < TMath::Min(binArray->GetEntries(),fBins->GetEntries()); ++j )
	385	{
81190958	386	AliAnalysisMuMuJpsiResult* r = static_cast<AliAnalysisMuMuJpsiResult*>(fBins->At(j));
a58729a5	387
1afce1ce	388	if ( strlen(subresult) > 0 && r->SubResults() )
a58729a5	389	{
a58729a5	390	TString sub(subresult);
81190958	391	r = static_cast<AliAnalysisMuMuJpsiResult*>(r->SubResult(sub.Data()));
a58729a5	392	if (!r) continue;
	393	}
	394
	395	const AliAnalysisMuMuBinning::Range& b = r->Bin();
	396
cb690a12	397	if ( b.Is2D() )
a58729a5	398	{
cb690a12	399	if (!h)
	400	{
	401	h = new TH2F(r->GetName(),r->GetName(),nbinsX,binsX,nbinsY,binsY);
	402	h->SetDirectory(0);
	403	}
	404
	405	Double_t z = r->GetValue(swhatT.Data());
	406	Double_t zerr = r->GetErrorStat(swhatT.Data());
	407
	408	if ( swhat.Contains("AccEff",TString::kIgnoreCase) )
	409	{
	410	if ( z < 0. \|\| z > 5.)
	411	{
	412	z = -1.;
	413	zerr = 0.;
	414	}
	415	}
	416
	417	if ( divideByBinWidth && b.WidthX()>0 )
	418	{
	419	z /= (b.WidthX()*b.WidthY());
	420	zerr /= (b.WidthX()*b.WidthY());
	421
	422	}
	423
	424	std::cout << b.AsString();
	425	r->PrintValue(swhat.Data(),"",z,zerr);
	426
	427	Int_t x = j/nbinsY + 1;
	428	Int_t y = (j % nbinsY) + 1;
	429
	430	std::cout << "x=" << x << ";" << "y=" << y << std::endl;
	431
	432	h->SetBinContent(x,y,z);
	433	h->SetBinError(x,y,zerr);
	434
a58729a5	435	}
cb690a12	436
cb690a12	437	else
a58729a5	438	{
cb690a12	439	if (!h)
	440	{
	441	h = new TH1F(r->GetName(),r->GetName(),binArray->GetEntries(),bins);
	442	h->SetDirectory(0);
	443	}
	444
	445	Double_t y = r->GetValue(swhatT.Data());
	446	Double_t yerr = r->GetErrorStat(swhatT.Data());
	447
	448	if ( divideByBinWidth && b.WidthX()>0 )
	449	{
	450	y /= (b.WidthX());
	451	yerr /= (b.WidthX());
	452	}
	453
	454	if (!TMath::Finite(y)) y = 0.0;
	455	if (!TMath::Finite(yerr)) yerr = 0.0;
	456
	457	std::cout << b.AsString();
	458	r->PrintValue(swhat.Data(),"",y,yerr);
	459
	460	h->SetBinContent(j+1,y);
	461	h->SetBinError(j+1,yerr);
a58729a5	462	}
a58729a5	463	}
	464
	465	delete binArray;
cb690a12	466	delete[] binsX;
cb690a12	467	delete[] binsY;
a58729a5	468	delete[] bins;
	469
	470	return h;
	471	}
	472
	473
	474	//______________________________________________________________________________
	475	void AliAnalysisMuMuSpectra::Print(Option_t* opt) const
	476	{
1afce1ce	477	// printout
1afce1ce	478
a58729a5	479	if (!IsEmpty())
	480	{
	481	TString sopt(opt);
a58729a5	482	Int_t nmax = sopt.Atoi();
	483	if ( nmax <= 0 ) nmax = fBins->GetEntries();
	484	for ( Int_t i = 0; i < nmax; ++i )
	485	{
1afce1ce	486	AliAnalysisMuMuResult* r = static_cast<AliAnalysisMuMuResult*>(fBins->At(i));
a58729a5	487	if (r) r->Print(opt);
a58729a5	488	}
a58729a5	489	}
a58729a5	490	}
81190958	491
	492	//______________________________________________________________________________
	493	void AliAnalysisMuMuSpectra::Scale(Double_t value)
	494	{
	495	// scale all bins by value
	496
	497	TIter next(fBins);
	498	AliAnalysisMuMuResult* r;
	499
	500	while ( ( r = static_cast<AliAnalysisMuMuResult*>(next()) ) )
	501	{
	502	r->Scale(value);
	503	}
	504	}
	505
	506	//______________________________________________________________________________
	507	void AliAnalysisMuMuSpectra::SetWeight(Double_t w)
	508	{
	509	// Set the weight of this spectra
	510	fWeight = w;
	511	TIter next(fBins);
	512	AliAnalysisMuMuResult* r;
	513
	514	while ( ( r = static_cast<AliAnalysisMuMuResult*>(next()) ) )
	515	{
	516	r->SetWeight(Weight());
	517	}
	518	}