[u/mrichter/AliRoot.git] / CORRFW / AliCFVGrid.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.                  *
 **************************************************************************/
//--------------------------------------------------------------------//
//                                                                    //
// AliCFVGrid Class                                                   //
// Just an interface to handle both AliCFGrid and AliCFGridSparse     //
// implementations                                                    //
//                                                                    //
// -- Author : S.Arcelli                                              //
//--------------------------------------------------------------------//
//
//
#include "AliCFVGrid.h"
#include "TMath.h"
#include <AliLog.h>

//____________________________________________________________________
ClassImp(AliCFVGrid)

//____________________________________________________________________
AliCFVGrid::AliCFVGrid() : 
  AliCFFrame(),
  fExclOffEntriesInProj(kTRUE),
  fSumW2(kFALSE)
{
  // default constructor
}
//____________________________________________________________________
AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title) : 
  AliCFFrame(name,title),
  fExclOffEntriesInProj(kTRUE),
  fSumW2(kFALSE)
{
  // default constructor
}

//____________________________________________________________________
AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :  
  AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
  fExclOffEntriesInProj(kTRUE),
  fSumW2(kFALSE)
{
  //
  // main constructor
  //

}

//____________________________________________________________________
AliCFVGrid::AliCFVGrid(const AliCFVGrid& c) : 
  AliCFFrame(c),
  fExclOffEntriesInProj(c.fExclOffEntriesInProj),
  fSumW2(c.fSumW2)
{
  //
  // copy constructor
  //
 ((AliCFVGrid &)c).Copy(*this);

}
//____________________________________________________________________
AliCFVGrid::~AliCFVGrid()
{
  //
  // destructor
  //
}

//____________________________________________________________________
AliCFVGrid &AliCFVGrid::operator=(const AliCFVGrid &c)
{
  //
  // assigment operator
  //
  if (this != &c)
    AliCFFrame::operator=(c);
  return *this;
} 

//____________________________________________________________________
void AliCFVGrid::Copy(TObject& c) const
{
  //
  // copy function
  //
  AliCFVGrid& target = (AliCFVGrid &) c;

  target.fSumW2=fSumW2;
}

//____________________________________________________________________
void AliCFVGrid::Scale(Int_t index, Double_t *fact)
{
  //
  //scale content of a certain cell by (positive) fact (with error)
  //
  if(GetElement(index)==0 || fact[0]==0)return;

  Double_t in[2], out[2];
  in[0]=GetElement(index);
  in[1]=GetElementError(index);
  GetScaledValues(fact,in,out);
  SetElement(index,out[0]);
  if(fSumW2)SetElementError(index,out[1]);
}
//____________________________________________________________________
void AliCFVGrid::Scale(Int_t *bin, Double_t *fact)
{
  //
  //scale content of a certain cell by (positive) fact (with error)
  //
  if(GetElement(bin)==0 || fact[0]==0)return;

  Double_t in[2], out[2];
  in[0]=GetElement(bin);
  in[1]=GetElementError(bin);
  GetScaledValues(fact,in,out);
  SetElement(bin,out[0]);
  if(fSumW2)SetElementError(bin,out[1]);
  
}
//____________________________________________________________________
void AliCFVGrid::Scale(Double_t *var, Double_t *fact) 
{
  //
  //scale content of a certain cell by (positive) fact (with error)
  //
  if(GetElement(var)==0 || fact[0]==0)return;

  Double_t in[2], out[2];
  in[0]=GetElement(var);
  in[1]=GetElementError(var);
  GetScaledValues(fact,in,out);
  SetElement(var,out[0]);
  if(fSumW2)SetElementError(var,out[1]);
  
}
//____________________________________________________________________
void AliCFVGrid::Scale( Double_t *fact) 
{
  //
  //scale contents of the whole grid by fact
  //

  for(Int_t iel=0;iel<fNDim;iel++){
    Scale(iel,fact);
  }
}

//____________________________________________________________________
Int_t AliCFVGrid::GetEmptyBins() const {
  //
  // Get empty bins 
  //
  Int_t val=0;
  for(Int_t i=0;i<fNDim;i++){
    if(GetElement(i)<=0)val++;     
  }
  return val;
} 
//_____________________________________________________________________
Int_t AliCFVGrid::GetEmptyBins( Double_t *varMin, Double_t* varMax ) const 
{
  //
  // Get empty bins in a range
  //

  Int_t *indexMin=new Int_t[fNVar];
  Int_t *indexMax=new Int_t[fNVar];

  //Find out the min and max bins

  for(Int_t i=0;i<fNVar;i++){
    Double_t xmin=varMin[i]; // the min values  
    Double_t xmax=varMax[i]; // the min values  
    Int_t nbins=fNVarBins[i]+1;
    Double_t *bins=new Double_t[nbins];
    for(Int_t ibin =0;ibin<nbins;ibin++){
     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
    }
    indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
    indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
    delete [] bins;
  }

  Int_t val=0;
  for(Int_t i=0;i<fNDim;i++){
    for (Int_t j=0;j<fNVar;j++)fIndex[j]=GetBinIndex(j,i);
    Bool_t isIn=kTRUE;
    for (Int_t j=0;j<fNVar;j++){
      if(!(fIndex[j]>=indexMin[j] && fIndex[j]<=indexMax[j]))isIn=kFALSE;   
    }
    if(isIn && GetElement(i)<=0)val++;     
  }
  AliInfo(Form(" the empty bins = %i ",val)); 

  delete [] indexMin;
  delete [] indexMax;
  return val;
} 
//____________________________________________________________________
Int_t AliCFVGrid::CheckStats(Double_t thr) const
{
  //
  // Count the cells below a certain threshold
  //
  Int_t ncellsLow=0;
  for(Int_t i=0;i<fNDim;i++){
    if(GetElement(i)<thr)ncellsLow++;
  }
  return ncellsLow;
}
//_____________________________________________________________________
Double_t AliCFVGrid::GetIntegral() const 
{
  //
  // Get full Integral
  //
  Double_t val=0;
  for(Int_t i=0;i<fNDim;i++){
    val+=GetElement(i);     
  }
  return val;  
} 
//_____________________________________________________________________
Double_t AliCFVGrid::GetIntegral(Int_t *binMin, Int_t* binMax ) const 
{
  //
  // Get Integral in a range of bin indeces (extremes included)
  //

  Double_t val=0;

  for(Int_t i=0;i<fNVar;i++){
    if(binMin[i]<1)binMin[i]=1;
    if(binMax[i]>fNVarBins[i])binMax[i]=fNVarBins[i];
    if((binMin[i]>binMax[i])){
      AliInfo(Form(" Bin indeces in variable %i in reverse order, please check!", i));
      return val;
    }
  }
  val=GetSum(0,binMin,binMax);

  return val;

} 
//_____________________________________________________________________
Double_t AliCFVGrid::GetIntegral(Double_t *varMin, Double_t* varMax ) const 
{
  //
  // Get Integral in a range (extremes included)
  //

  Int_t *indexMin=new Int_t[fNVar];
  Int_t *indexMax=new Int_t[fNVar];

  //Find out the min and max bins

  for(Int_t i=0;i<fNVar;i++){
    Double_t xmin=varMin[i]; // the min values  
    Double_t xmax=varMax[i]; // the min values  
    Int_t nbins=fNVarBins[i]+1;
    Double_t *bins=new Double_t[nbins];
    for(Int_t ibin =0;ibin<nbins;ibin++){
     bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
    }
    indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
    indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
    delete [] bins;
  }

  //move to the TH/THnSparse convention in N-dim bin numbering 
  for(Int_t i=0;i<fNVar;i++){
    indexMin[i]+=1;
    indexMax[i]+=1;
  }

  Double_t val=GetIntegral(indexMin,indexMax);

  delete [] indexMin;
  delete [] indexMax;

  return val;
} 

//_____________________________________________________________________
Double_t AliCFVGrid::GetSum(Int_t ivar, Int_t *binMin, Int_t* binMax) const 
{
  //
  // recursively add over nested loops.... 
  //
  static Double_t val;
  if(ivar==0)val=0.;
  for(Int_t ibin=binMin[ivar]-1;ibin<=binMax[ivar]-1;ibin++){
  //-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
    fIndex[ivar]=ibin;
    if(ivar<fNVar-1) {
      val=GetSum(ivar+1,binMin,binMax);
    }
    else {
      Int_t iel=GetBinIndex(fIndex);
      val+=GetElement(iel);
    }
  }

  return val;
}

//____________________________________________________________________
Long64_t AliCFVGrid::Merge(TCollection* list)
{
  // Merge a list of AliCF grids with this (needed for
  // PROOF). 
  // Returns the number of merged objects (including this).

  if (!list)
    return 0;
  
  if (list->IsEmpty())
    return 1;

  TIterator* iter = list->MakeIterator();
  TObject* obj;
  
  Int_t count = 0;
  while ((obj = iter->Next())) {
    AliCFVGrid* entry = dynamic_cast<AliCFVGrid*> (obj);
    if (entry == 0) 
      continue;
    this->Add(entry);
    count++;
  }

  return count+1;
}

//____________________________________________________________________
void AliCFVGrid::GetScaledValues(Double_t *fact, Double_t *in, Double_t *out) const{
  //
  // scale input *in and it error by (positive) fact (with error)
  // and erite it to *out
  //
    out[0]=in[0]*fact[0];
    out[1]=TMath::Sqrt(in[1]*in[1]/in[0]/in[0]
		       +fact[1]*fact[1]/fact[0]/fact[0])*out[0];
    
}
Commit	Line	Data
1e9dad92	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	// AliCFVGrid Class //
	18	// Just an interface to handle both AliCFGrid and AliCFGridSparse //
	19	// implementations //
	20	// //
	21	// -- Author : S.Arcelli //
	22	//--------------------------------------------------------------------//
	23	//
	24	//
	25	#include "AliCFVGrid.h"
	26	#include "TMath.h"
	27	#include <AliLog.h>
	28
	29	//____________________________________________________________________
	30	ClassImp(AliCFVGrid)
	31
	32	//____________________________________________________________________
	33	AliCFVGrid::AliCFVGrid() :
	34	AliCFFrame(),
318f64b1	35	fExclOffEntriesInProj(kTRUE),
1e9dad92	36	fSumW2(kFALSE)
	37	{
	38	// default constructor
	39	}
	40	//____________________________________________________________________
	41	AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title) :
	42	AliCFFrame(name,title),
318f64b1	43	fExclOffEntriesInProj(kTRUE),
1e9dad92	44	fSumW2(kFALSE)
	45	{
	46	// default constructor
	47	}
	48
	49	//____________________________________________________________________
	50	AliCFVGrid::AliCFVGrid(const Char_t* name, const Char_t* title, const Int_t nVarIn, const Int_t * nBinIn, const Double_t *binLimitsIn) :
	51	AliCFFrame(name,title,nVarIn,nBinIn,binLimitsIn),
318f64b1	52	fExclOffEntriesInProj(kTRUE),
1e9dad92	53	fSumW2(kFALSE)
	54	{
	55	//
	56	// main constructor
	57	//
	58
	59	}
	60
	61	//____________________________________________________________________
	62	AliCFVGrid::AliCFVGrid(const AliCFVGrid& c) :
	63	AliCFFrame(c),
318f64b1	64	fExclOffEntriesInProj(c.fExclOffEntriesInProj),
1e9dad92	65	fSumW2(c.fSumW2)
	66	{
	67	//
	68	// copy constructor
	69	//
	70	((AliCFVGrid &)c).Copy(*this);
	71
	72	}
	73	//____________________________________________________________________
	74	AliCFVGrid::~AliCFVGrid()
	75	{
	76	//
	77	// destructor
	78	//
	79	}
	80
	81	//____________________________________________________________________
	82	AliCFVGrid &AliCFVGrid::operator=(const AliCFVGrid &c)
	83	{
	84	//
	85	// assigment operator
	86	//
	87	if (this != &c)
	88	AliCFFrame::operator=(c);
	89	return *this;
	90	}
	91
	92	//____________________________________________________________________
	93	void AliCFVGrid::Copy(TObject& c) const
	94	{
	95	//
	96	// copy function
	97	//
	98	AliCFVGrid& target = (AliCFVGrid &) c;
	99
	100	target.fSumW2=fSumW2;
	101	}
	102
	103	//____________________________________________________________________
	104	void AliCFVGrid::Scale(Int_t index, Double_t *fact)
	105	{
	106	//
	107	//scale content of a certain cell by (positive) fact (with error)
	108	//
	109	if(GetElement(index)==0 \|\| fact[0]==0)return;
	110
	111	Double_t in[2], out[2];
	112	in[0]=GetElement(index);
	113	in[1]=GetElementError(index);
	114	GetScaledValues(fact,in,out);
	115	SetElement(index,out[0]);
	116	if(fSumW2)SetElementError(index,out[1]);
	117	}
	118	//____________________________________________________________________
	119	void AliCFVGrid::Scale(Int_t bin, Double_t fact)
	120	{
	121	//
	122	//scale content of a certain cell by (positive) fact (with error)
	123	//
	124	if(GetElement(bin)==0 \|\| fact[0]==0)return;
	125
	126	Double_t in[2], out[2];
	127	in[0]=GetElement(bin);
	128	in[1]=GetElementError(bin);
129	GetScaledValues(fact,in,out);
130	SetElement(bin,out[0]);
131	if(fSumW2)SetElementError(bin,out[1]);
132
133	}
134	//____________________________________________________________________
135	void AliCFVGrid::Scale(Double_t var, Double_t fact)
136	{
137	//
138	//scale content of a certain cell by (positive) fact (with error)
139	//
140	if(GetElement(var)==0 \|\| fact[0]==0)return;
141
142	Double_t in[2], out[2];
143	in[0]=GetElement(var);
144	in[1]=GetElementError(var);
145	GetScaledValues(fact,in,out);
146	SetElement(var,out[0]);
147	if(fSumW2)SetElementError(var,out[1]);
148
149	}
150	//____________________________________________________________________
151	void AliCFVGrid::Scale( Double_t *fact)
152	{
153	//
154	//scale contents of the whole grid by fact
155	//
156
157	for(Int_t iel=0;iel<fNDim;iel++){
158	Scale(iel,fact);
159	}
160	}
161
162	//____________________________________________________________________
163	Int_t AliCFVGrid::GetEmptyBins() const {
164	//
165	// Get empty bins
166	//
167	Int_t val=0;
168	for(Int_t i=0;i<fNDim;i++){
169	if(GetElement(i)<=0)val++;
170	}
171	return val;
172	}
173	//_____________________________________________________________________
174	Int_t AliCFVGrid::GetEmptyBins( Double_t varMin, Double_t varMax ) const
175	{
176	//
177	// Get empty bins in a range
178	//
179
180	Int_t *indexMin=new Int_t[fNVar];
181	Int_t *indexMax=new Int_t[fNVar];
182
183	//Find out the min and max bins
184
185	for(Int_t i=0;i<fNVar;i++){
186	Double_t xmin=varMin[i]; // the min values
187	Double_t xmax=varMax[i]; // the min values
188	Int_t nbins=fNVarBins[i]+1;
189	Double_t *bins=new Double_t[nbins];
190	for(Int_t ibin =0;ibin<nbins;ibin++){
191	bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
192	}
193	indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
194	indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
195	delete [] bins;
196	}
197
198	Int_t val=0;
199	for(Int_t i=0;i<fNDim;i++){
200	for (Int_t j=0;j<fNVar;j++)fIndex[j]=GetBinIndex(j,i);
201	Bool_t isIn=kTRUE;
202	for (Int_t j=0;j<fNVar;j++){
203	if(!(fIndex[j]>=indexMin[j] && fIndex[j]<=indexMax[j]))isIn=kFALSE;
204	}
205	if(isIn && GetElement(i)<=0)val++;
206	}
207	AliInfo(Form(" the empty bins = %i ",val));
208
209	delete [] indexMin;
210	delete [] indexMax;
211	return val;
212	}
213	//____________________________________________________________________
214	Int_t AliCFVGrid::CheckStats(Double_t thr) const
215	{
216	//
217	// Count the cells below a certain threshold
218	//
219	Int_t ncellsLow=0;
220	for(Int_t i=0;i<fNDim;i++){
221	if(GetElement(i)<thr)ncellsLow++;
222	}
223	return ncellsLow;
224	}
225	//_____________________________________________________________________
226	Double_t AliCFVGrid::GetIntegral() const
227	{
228	//
229	// Get full Integral
230	//
231	Double_t val=0;
232	for(Int_t i=0;i<fNDim;i++){
233	val+=GetElement(i);
234	}
235	return val;
236	}
237	//_____________________________________________________________________
238	Double_t AliCFVGrid::GetIntegral(Int_t binMin, Int_t binMax ) const
239	{
240	//
241	// Get Integral in a range of bin indeces (extremes included)
242	//
243
244	Double_t val=0;
245
246	for(Int_t i=0;i<fNVar;i++){
247	if(binMin[i]<1)binMin[i]=1;
248	if(binMax[i]>fNVarBins[i])binMax[i]=fNVarBins[i];
249	if((binMin[i]>binMax[i])){
250	AliInfo(Form(" Bin indeces in variable %i in reverse order, please check!", i));
251	return val;
252	}
253	}
254	val=GetSum(0,binMin,binMax);
255
256	return val;
257
258	}
259	//_____________________________________________________________________
260	Double_t AliCFVGrid::GetIntegral(Double_t varMin, Double_t varMax ) const
261	{
262	//
263	// Get Integral in a range (extremes included)
264	//
265
266	Int_t *indexMin=new Int_t[fNVar];
267	Int_t *indexMax=new Int_t[fNVar];
268
269	//Find out the min and max bins
270
271	for(Int_t i=0;i<fNVar;i++){
272	Double_t xmin=varMin[i]; // the min values
273	Double_t xmax=varMax[i]; // the min values
274	Int_t nbins=fNVarBins[i]+1;
275	Double_t *bins=new Double_t[nbins];
276	for(Int_t ibin =0;ibin<nbins;ibin++){
277	bins[ibin] = fVarBinLimits[ibin+fOffset[i]];
278	}
279	indexMin[i] = TMath::BinarySearch(nbins,bins,xmin);
280	indexMax[i] = TMath::BinarySearch(nbins,bins,xmax);
281	delete [] bins;
282	}
283
284	//move to the TH/THnSparse convention in N-dim bin numbering
285	for(Int_t i=0;i<fNVar;i++){
286	indexMin[i]+=1;
287	indexMax[i]+=1;
288	}
289
290	Double_t val=GetIntegral(indexMin,indexMax);
291
292	delete [] indexMin;
293	delete [] indexMax;
294
295	return val;
296	}
297
298	//_____________________________________________________________________
299	Double_t AliCFVGrid::GetSum(Int_t ivar, Int_t binMin, Int_t binMax) const
300	{
301	//
302	// recursively add over nested loops....
303	//
304	static Double_t val;
305	if(ivar==0)val=0.;
306	for(Int_t ibin=binMin[ivar]-1;ibin<=binMax[ivar]-1;ibin++){
307	//-1 is to move from TH/ThnSparse N-dim bin convention to one in AliCFFrame
308	fIndex[ivar]=ibin;
309	if(ivar<fNVar-1) {
310	val=GetSum(ivar+1,binMin,binMax);
311	}
312	else {
313	Int_t iel=GetBinIndex(fIndex);
314	val+=GetElement(iel);
315	}
316	}
317
318	return val;
319	}
320
321	//____________________________________________________________________
322	Long64_t AliCFVGrid::Merge(TCollection* list)
323	{
324	// Merge a list of AliCF grids with this (needed for
325	// PROOF).
326	// Returns the number of merged objects (including this).
327
328	if (!list)
329	return 0;
330
331	if (list->IsEmpty())
332	return 1;
333
334	TIterator* iter = list->MakeIterator();
335	TObject* obj;
336
337	Int_t count = 0;
338	while ((obj = iter->Next())) {
339	AliCFVGrid* entry = dynamic_cast<AliCFVGrid*> (obj);
340	if (entry == 0)
341	continue;
342	this->Add(entry);
343	count++;
344	}
345
346	return count+1;
347	}
348
349	//____________________________________________________________________
350	void AliCFVGrid::GetScaledValues(Double_t fact, Double_t in, Double_t *out) const{
351	//
352	// scale input *in and it error by (positive) fact (with error)
353	// and erite it to *out
354	//
355	out[0]=in[0]*fact[0];
356	out[1]=TMath::Sqrt(in[1]*in[1]/in[0]/in[0]
357	+fact[1]fact[1]/fact[0]/fact[0])out[0];
358
359	}