[u/mrichter/AliRoot.git] / HBTAN / AliHBTCorrectOSLCorrelFctn.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.                  *
 **************************************************************************/

/* $Id$ */

#include "AliHBTCorrectOSLCorrelFctn.h"
#include "AliLog.h"

//____________________
///////////////////////////////////////////////////////
//                                                   //
// AliHBTCorrectOSLCorrelFctn                        //
//                                                   //
// Class for calculating Q Invariant correlation     //
// taking to the account resolution of the           //
// detector and coulomb effects.                     //
//                                                   //
///////////////////////////////////////////////////////

#include <TH3.h>

#include <AliAODParticle.h>
#include <AliHBTPair.h>

AliHBTCorrectOSLCorrelFctn::AliHBTCorrectOSLCorrelFctn(const char* name, const char* title):
 AliHBTOnePairFctn3D(name,title),
 AliHBTCorrectedCorrelFctn(),
 fMeasCorrelFctn(0x0),
 fSmearedNumer(0x0),
 fSmearedDenom(0x0),
 fMeasNumer(0x0),
 fMeasDenom(0x0),
 fLambda(0.0),
 fROutSq(0.0),
 fRSideSq(0.0),
 fRLongSq(0.0)
{
//ctor
  fWriteNumAndDen = kTRUE;//change default behaviour
}
/******************************************************************/

AliHBTCorrectOSLCorrelFctn::AliHBTCorrectOSLCorrelFctn(const Char_t *name, const Char_t *title,
	         Int_t nXbins, Double_t maxXval, Double_t minXval, 
	         Int_t nYbins, Double_t maxYval, Double_t minYval, 
	         Int_t nZbins, Double_t maxZval, Double_t minZval):
 AliHBTOnePairFctn3D(name,title,nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval),
 AliHBTCorrectedCorrelFctn(),
 fMeasCorrelFctn(0x0),
 fSmearedNumer(0x0),
 fSmearedDenom(0x0),
 fMeasNumer(0x0),
 fMeasDenom(0x0),
 fLambda(0.0),
 fROutSq(0.0),
 fRSideSq(0.0),
 fRLongSq(0.0)
{
//ctor
  fWriteNumAndDen = kTRUE;//change default behaviour}
}

/******************************************************************/
AliHBTCorrectOSLCorrelFctn::AliHBTCorrectOSLCorrelFctn(const AliHBTCorrectOSLCorrelFctn& in):
 AliHBTOnePairFctn3D(in),
 AliHBTCorrectedCorrelFctn(),
 fMeasCorrelFctn(0x0),
 fSmearedNumer(0x0),
 fSmearedDenom(0x0),
 fMeasNumer(0x0),
 fMeasDenom(0x0),
 fLambda(0.0),
 fROutSq(0.0),
 fRSideSq(0.0),
 fRLongSq(0.0)
{
//cpy constructor
 in.Copy(*this);
}
/******************************************************************/

AliHBTCorrectOSLCorrelFctn::~AliHBTCorrectOSLCorrelFctn()
{
 //dtor
 delete fMeasCorrelFctn;
 delete fSmearedNumer;
 delete fSmearedDenom;
 delete fMeasNumer;
 delete fMeasDenom;
}
/******************************************************************/

void AliHBTCorrectOSLCorrelFctn::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
                    	     Int_t nybins, Float_t ymax, Float_t ymin,
		     Int_t nzbins, Float_t zmax, Float_t zmin)
{
//build histograms
  AliDebug(1,"Entered");
  
  AliHBTFunction3D::BuildHistos(nxbins,xmax,xmin,nybins,ymax,ymin,nzbins,zmax,zmin);
  
  TString numstr = fName + " Smeared Numerator";  //title and name of the numerator histogram
  TString denstr = fName + " Smeared Denominator";//title and name of the denominator histogram
  
  fSmearedNumer = new TH3F(numstr.Data(),numstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
  fSmearedDenom = new TH3F(denstr.Data(),denstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
  fSmearedNumer->Sumw2();
  fSmearedDenom->Sumw2();
  
  if (fMeasCorrelFctn == 0x0)
   { 
     numstr = fName + " Measured Numerator";  //title and name of the numerator histogram
     denstr = fName + " Measured Denominator";//title and name of the denominator histogram
    
     fMeasNumer = new TH3F(numstr.Data(),numstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
     fMeasDenom = new TH3F(denstr.Data(),denstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
     fMeasNumer->Sumw2();
     fMeasDenom->Sumw2();
   }

}
/******************************************************************/

void AliHBTCorrectOSLCorrelFctn::Init()
{
//Init
  AliHBTOnePairFctn3D::Init();
  Info("Init","");
  if ( (fSmearedNumer == 0x0) || (fSmearedDenom == 0x0) )
   {
     if (fNumerator == 0x0) Fatal("Init","Sth. goes wrong");
     Int_t nxbins = fNumerator->GetNbinsX();
     Float_t xmax = fNumerator->GetXaxis()->GetXmax();
     Float_t xmin = fNumerator->GetXaxis()->GetXmin();
     Int_t nybins = fNumerator->GetNbinsY();
     Float_t ymax = fNumerator->GetYaxis()->GetXmax();
     Float_t ymin = fNumerator->GetYaxis()->GetXmin();
     Int_t nzbins = fNumerator->GetNbinsZ();
     Float_t zmax = fNumerator->GetZaxis()->GetXmax();
     Float_t zmin = fNumerator->GetZaxis()->GetXmin();
     BuildHistos(nxbins,xmax,xmin, nybins,ymax,ymin, nzbins,zmax,zmin);
   }
   
  fSmearedNumer->Reset();
  fSmearedDenom->Reset();
  if (fMeasNumer) fMeasNumer->Reset();
  if (fMeasDenom) fMeasDenom->Reset();
}
/******************************************************************/

void AliHBTCorrectOSLCorrelFctn::SetInitialValues(Double_t lambda, Double_t rout, Double_t rside, Double_t rlong)
{
  //Sets assumed parameters
 fLambda = lambda;
 fROutSq = rout*rout;
 fRSideSq = rside*rside;
 fRLongSq = rlong*rlong;
}

/******************************************************************/

void AliHBTCorrectOSLCorrelFctn::ProcessSameEventParticles(AliHBTPair* pair)
{
 //Processes particles that originates from the same event
  
  return; //we already heave the measured in hand
 
 
  if (fMeasNumer == 0x0) return;
  pair = CheckPair(pair);
  if( pair == 0x0) return;
  fMeasNumer->Fill(pair->GetQInv());
}
/******************************************************************/

void AliHBTCorrectOSLCorrelFctn::ProcessDiffEventParticles(AliHBTPair* pair)
{
//Process different events 
  static AliAODParticle part1, part2;
  static AliHBTPair smearedpair(&part1,&part2);
  
  pair = CheckPair(pair);
  if( pair == 0x0) return;
  
  Double_t cc = GetCoulombCorrection(pair);

  Double_t qout,qside,qlong;
  GetValues(pair,qout,qside,qlong);

  //measured histogram -> if we are interested 
  //only if fMeasCorrelFctn is not specified by user

//  if (fMeasDenom) fMeasDenom->Fill(qout,qside,qlong,cc);

  Smear(pair,smearedpair);
  Double_t modelval = GetModelValue(qout,qside,qlong);  
  //Ideal histogram
  fNumerator->Fill(qout,qside,qlong,modelval*cc);
  fDenominator->Fill(qout,qside,qlong,cc);
  
  //Smeared histogram

  Double_t smearedqout,smearedqside,smearedqlong;
  
  GetValues(&smearedpair,smearedqout,smearedqside,smearedqlong);
  
  fSmearedNumer->Fill(smearedqout,smearedqside,smearedqlong,modelval);
  
  Double_t smearedcc = GetCoulombCorrection(&smearedpair);
  fSmearedDenom->Fill(smearedqout,smearedqside,smearedqlong,smearedcc);
  
}
/******************************************************************/

Int_t AliHBTCorrectOSLCorrelFctn::WriteFunction()
{
  //Writes the function
  Int_t retval = 0;
  retval += AliHBTFunction::WriteFunction();
  if (fSmearedNumer) retval += fSmearedNumer->Write();
  if (fSmearedDenom) retval += fSmearedDenom->Write();
  return retval;
}
/******************************************************************/

TH1* AliHBTCorrectOSLCorrelFctn::GetResult()
{
  //reuturns result histogram
   delete fRatio;
   fRatio = GetRatio(Scale());
   return fRatio;
}

void AliHBTCorrectOSLCorrelFctn::GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const 
{
    //calculates values of that function
  //qout qside and qlong
  
  x=pair->GetQOutLCMS(); 
  y=pair->GetQSideLCMS(); 
  z=pair->GetQLongLCMS();
  if (fAbs)
   {
     x = TMath::Abs(x);
     y = TMath::Abs(y);
     z = TMath::Abs(z);
   }

}
Commit	Line	Data
c7ffd78f	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	/* $Id$ */
	17
e09fa876	18	#include "AliHBTCorrectOSLCorrelFctn.h"
c7ffd78f	19	#include "AliLog.h"
c7ffd78f	20
e09fa876	21	//____________________
	22	///////////////////////////////////////////////////////
	23	// //
	24	// AliHBTCorrectOSLCorrelFctn //
	25	// //
	26	// Class for calculating Q Invariant correlation //
	27	// taking to the account resolution of the //
	28	// detector and coulomb effects. //
	29	// //
	30	///////////////////////////////////////////////////////
	31
62e1b4fe	32	#include <TH3.h>
	33
	34	#include <AliAODParticle.h>
	35	#include <AliHBTPair.h>
e09fa876	36
	37	AliHBTCorrectOSLCorrelFctn::AliHBTCorrectOSLCorrelFctn(const char* name, const char* title):
	38	AliHBTOnePairFctn3D(name,title),
62e1b4fe	39	AliHBTCorrectedCorrelFctn(),
e09fa876	40	fMeasCorrelFctn(0x0),
	41	fSmearedNumer(0x0),
	42	fSmearedDenom(0x0),
	43	fMeasNumer(0x0),
62e1b4fe	44	fMeasDenom(0x0),
	45	fLambda(0.0),
	46	fROutSq(0.0),
	47	fRSideSq(0.0),
	48	fRLongSq(0.0)
e09fa876	49	{
e09fa876	50	//ctor
62e1b4fe	51	fWriteNumAndDen = kTRUE;//change default behaviour
e09fa876	52	}
	53	/******************************************************************/
	54
62e1b4fe	55	AliHBTCorrectOSLCorrelFctn::AliHBTCorrectOSLCorrelFctn(const Char_t name, const Char_t title,
	56	Int_t nXbins, Double_t maxXval, Double_t minXval,
	57	Int_t nYbins, Double_t maxYval, Double_t minYval,
	58	Int_t nZbins, Double_t maxZval, Double_t minZval):
	59	AliHBTOnePairFctn3D(name,title,nXbins,maxXval,minXval,nYbins,maxYval,minYval,nZbins,maxZval,minZval),
	60	AliHBTCorrectedCorrelFctn(),
	61	fMeasCorrelFctn(0x0),
	62	fSmearedNumer(0x0),
	63	fSmearedDenom(0x0),
	64	fMeasNumer(0x0),
	65	fMeasDenom(0x0),
	66	fLambda(0.0),
	67	fROutSq(0.0),
	68	fRSideSq(0.0),
	69	fRLongSq(0.0)
	70	{
	71	//ctor
	72	fWriteNumAndDen = kTRUE;//change default behaviour}
	73	}
	74
	75	/******************************************************************/
e09fa876	76	AliHBTCorrectOSLCorrelFctn::AliHBTCorrectOSLCorrelFctn(const AliHBTCorrectOSLCorrelFctn& in):
e09fa876	77	AliHBTOnePairFctn3D(in),
62e1b4fe	78	AliHBTCorrectedCorrelFctn(),
e09fa876	79	fMeasCorrelFctn(0x0),
	80	fSmearedNumer(0x0),
	81	fSmearedDenom(0x0),
	82	fMeasNumer(0x0),
62e1b4fe	83	fMeasDenom(0x0),
	84	fLambda(0.0),
	85	fROutSq(0.0),
	86	fRSideSq(0.0),
	87	fRLongSq(0.0)
e09fa876	88	{
	89	//cpy constructor
	90	in.Copy(*this);
	91	}
	92	/******************************************************************/
	93
	94	AliHBTCorrectOSLCorrelFctn::~AliHBTCorrectOSLCorrelFctn()
	95	{
	96	//dtor
	97	delete fMeasCorrelFctn;
	98	delete fSmearedNumer;
	99	delete fSmearedDenom;
	100	delete fMeasNumer;
	101	delete fMeasDenom;
	102	}
62e1b4fe	103	/******************************************************************/
	104
	105	void AliHBTCorrectOSLCorrelFctn::BuildHistos(Int_t nxbins, Float_t xmax, Float_t xmin,
	106	Int_t nybins, Float_t ymax, Float_t ymin,
	107	Int_t nzbins, Float_t zmax, Float_t zmin)
	108	{
	109	//build histograms
c7ffd78f	110	AliDebug(1,"Entered");
62e1b4fe	111
	112	AliHBTFunction3D::BuildHistos(nxbins,xmax,xmin,nybins,ymax,ymin,nzbins,zmax,zmin);
	113
	114	TString numstr = fName + " Smeared Numerator"; //title and name of the numerator histogram
	115	TString denstr = fName + " Smeared Denominator";//title and name of the denominator histogram
	116
	117	fSmearedNumer = new TH3F(numstr.Data(),numstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
	118	fSmearedDenom = new TH3F(denstr.Data(),denstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
	119	fSmearedNumer->Sumw2();
	120	fSmearedDenom->Sumw2();
	121
	122	if (fMeasCorrelFctn == 0x0)
	123	{
	124	numstr = fName + " Measured Numerator"; //title and name of the numerator histogram
	125	denstr = fName + " Measured Denominator";//title and name of the denominator histogram
	126
	127	fMeasNumer = new TH3F(numstr.Data(),numstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
	128	fMeasDenom = new TH3F(denstr.Data(),denstr.Data(),nxbins,xmin,xmax,nybins,ymin,ymax,nzbins,zmin,zmax);
	129	fMeasNumer->Sumw2();
	130	fMeasDenom->Sumw2();
	131	}
	132
	133	}
	134	/******************************************************************/
	135
	136	void AliHBTCorrectOSLCorrelFctn::Init()
	137	{
	138	//Init
	139	AliHBTOnePairFctn3D::Init();
	140	Info("Init","");
	141	if ( (fSmearedNumer == 0x0) \|\| (fSmearedDenom == 0x0) )
	142	{
	143	if (fNumerator == 0x0) Fatal("Init","Sth. goes wrong");
	144	Int_t nxbins = fNumerator->GetNbinsX();
	145	Float_t xmax = fNumerator->GetXaxis()->GetXmax();
	146	Float_t xmin = fNumerator->GetXaxis()->GetXmin();
	147	Int_t nybins = fNumerator->GetNbinsY();
	148	Float_t ymax = fNumerator->GetYaxis()->GetXmax();
	149	Float_t ymin = fNumerator->GetYaxis()->GetXmin();
	150	Int_t nzbins = fNumerator->GetNbinsZ();
	151	Float_t zmax = fNumerator->GetZaxis()->GetXmax();
	152	Float_t zmin = fNumerator->GetZaxis()->GetXmin();
	153	BuildHistos(nxbins,xmax,xmin, nybins,ymax,ymin, nzbins,zmax,zmin);
	154	}
	155
	156	fSmearedNumer->Reset();
	157	fSmearedDenom->Reset();
	158	if (fMeasNumer) fMeasNumer->Reset();
	159	if (fMeasDenom) fMeasDenom->Reset();
	160	}
	161	/******************************************************************/
	162
	163	void AliHBTCorrectOSLCorrelFctn::SetInitialValues(Double_t lambda, Double_t rout, Double_t rside, Double_t rlong)
	164	{
	165	//Sets assumed parameters
	166	fLambda = lambda;
	167	fROutSq = rout*rout;
	168	fRSideSq = rside*rside;
	169	fRLongSq = rlong*rlong;
	170	}
	171
	172	/******************************************************************/
	173
	174	void AliHBTCorrectOSLCorrelFctn::ProcessSameEventParticles(AliHBTPair* pair)
175	{
176	//Processes particles that originates from the same event
177
178	return; //we already heave the measured in hand
179
180
181	if (fMeasNumer == 0x0) return;
182	pair = CheckPair(pair);
183	if( pair == 0x0) return;
184	fMeasNumer->Fill(pair->GetQInv());
185	}
186	/******************************************************************/
187
188	void AliHBTCorrectOSLCorrelFctn::ProcessDiffEventParticles(AliHBTPair* pair)
189	{
190	//Process different events
191	static AliAODParticle part1, part2;
192	static AliHBTPair smearedpair(&part1,&part2);
193
194	pair = CheckPair(pair);
195	if( pair == 0x0) return;
196
197	Double_t cc = GetCoulombCorrection(pair);
198
199	Double_t qout,qside,qlong;
200	GetValues(pair,qout,qside,qlong);
201
202	//measured histogram -> if we are interested
203	//only if fMeasCorrelFctn is not specified by user
204
205	// if (fMeasDenom) fMeasDenom->Fill(qout,qside,qlong,cc);
206
207	Smear(pair,smearedpair);
208	Double_t modelval = GetModelValue(qout,qside,qlong);
209	//Ideal histogram
210	fNumerator->Fill(qout,qside,qlong,modelval*cc);
211	fDenominator->Fill(qout,qside,qlong,cc);
212
213	//Smeared histogram
214
215	Double_t smearedqout,smearedqside,smearedqlong;
216
217	GetValues(&smearedpair,smearedqout,smearedqside,smearedqlong);
218
219	fSmearedNumer->Fill(smearedqout,smearedqside,smearedqlong,modelval);
220
221	Double_t smearedcc = GetCoulombCorrection(&smearedpair);
222	fSmearedDenom->Fill(smearedqout,smearedqside,smearedqlong,smearedcc);
223
224	}
225	/******************************************************************/
e09fa876	226
6f1c277c	227	Int_t AliHBTCorrectOSLCorrelFctn::WriteFunction()
62e1b4fe	228	{
6f1c277c	229	//Writes the function
	230	Int_t retval = 0;
	231	retval += AliHBTFunction::WriteFunction();
	232	if (fSmearedNumer) retval += fSmearedNumer->Write();
	233	if (fSmearedDenom) retval += fSmearedDenom->Write();
	234	return retval;
62e1b4fe	235	}
e09fa876	236	/******************************************************************/
62e1b4fe	237
	238	TH1* AliHBTCorrectOSLCorrelFctn::GetResult()
	239	{
	240	//reuturns result histogram
	241	delete fRatio;
	242	fRatio = GetRatio(Scale());
	243	return fRatio;
	244	}
	245
	246	void AliHBTCorrectOSLCorrelFctn::GetValues(AliHBTPair* pair, Double_t& x, Double_t& y, Double_t& z) const
	247	{
	248	//calculates values of that function
	249	//qout qside and qlong
	250
	251	x=pair->GetQOutLCMS();
	252	y=pair->GetQSideLCMS();
	253	z=pair->GetQLongLCMS();
	254	if (fAbs)
	255	{
	256	x = TMath::Abs(x);
	257	y = TMath::Abs(y);
	258	z = TMath::Abs(z);
	259	}
	260
	261	}