+/**************************************************************************
+ * 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 "AliGenHBTosl.h"
+#include "AliLog.h"
+
//__________________________________________________________
/////////////////////////////////////////////////////////////
// //
// //
////////////////////////////////////////////////////////////
-#include <Riostream.h>
#include <TCanvas.h>
#include "AliGenGeVSim.h"
#include "AliGenHIJINGpara.h"
+
/***********************************************************/
+using std::cout;
+using std::endl;
+using std::ofstream;
+using std::ios;
ClassImp(AliGenHBTosl)
AliGenHBTosl::AliGenHBTosl():
fQBackground(0x0),
fQSecondSignal(0x0),
fQSecondBackground(0x0),
- fQRange(0.15),
+ fQRange(0.06),
fQNBins(60),
fGenerator(0x0),
+ fStackBuffer(0),
fBufferSize(5),
- fNBinsToScale(Int_t(fQNBins*0.2)),
+ fNBinsToScale(Int_t(fQNBins*0.1)),
fDebug(0),
- fMaxIterations(300),
+ fSignalShapeCreated(0),
+ fMaxIterations(1000),
fMaxChiSquereChange(0.01),
fMaxChiSquerePerNDF(1.5),
fQRadius(8.0),
fSamplePhiMin(-0.01),
fSamplePhiMax(TMath::TwoPi()+0.01),
fSignalRegion(0.0),
- fMinFill(300)
+ fMinFill(1000),
+ fSwapped(0),
+ fLogFile(0x0)
{
//default constructor
}
fQBackground(0x0),
fQSecondSignal(0x0),
fQSecondBackground(0x0),
- fQRange(0.15),
+ fQRange(0.06),
fQNBins(60),
fGenerator(0x0),
+ fStackBuffer(0),
fBufferSize(5),
- fNBinsToScale(Int_t(fQNBins*0.2)),
+ fNBinsToScale(Int_t(fQNBins*0.1)),
fDebug(0),
fSignalShapeCreated(kFALSE),
- fMaxIterations(300),
+ fMaxIterations(1000),
fMaxChiSquereChange(0.01),
fMaxChiSquerePerNDF(1.5),
fQRadius(8.0),
fSamplePhiMin(-0.01),
fSamplePhiMax(TMath::TwoPi()+0.01),
fSignalRegion(0.0),
- fMinFill(300)
+ fMinFill(1000),
+ fSwapped(0),
+ fLogFile(0x0)
{
//default constructor
}
+
+AliGenHBTosl::AliGenHBTosl(const AliGenHBTosl & hbt):
+ AliGenerator(-1),
+ fQCoarseBackground(0x0),
+ fQCoarseSignal(0x0),
+ fQSignal(0x0),
+ fQBackground(0x0),
+ fQSecondSignal(0x0),
+ fQSecondBackground(0x0),
+ fQRange(0.06),
+ fQNBins(60),
+ fGenerator(0x0),
+ fStackBuffer(0),
+ fBufferSize(5),
+ fNBinsToScale(Int_t(fQNBins*0.1)),
+ fDebug(0),
+ fSignalShapeCreated(kFALSE),
+ fMaxIterations(1000),
+ fMaxChiSquereChange(0.01),
+ fMaxChiSquerePerNDF(1.5),
+ fQRadius(8.0),
+ fPID(kPiPlus),
+ fSamplePhiMin(-0.01),
+ fSamplePhiMax(TMath::TwoPi()+0.01),
+ fSignalRegion(0.0),
+ fMinFill(1000),
+ fSwapped(0),
+ fLogFile(0x0)
+{
+// Copy constructor
+ hbt.Copy(*this);
+}
/***********************************************************/
AliGenHBTosl::~AliGenHBTosl()
delete fGenerator;
delete fQSecondSignal;
delete fQSecondBackground;
-
+ delete fLogFile;
}
+/***********************************************************/
void AliGenHBTosl::Init()
{
*/
fGenerator->SetOrigin(fOrigin[0],fOrigin[1],fOrigin[2]);
- static const Double_t degtoradcf = 180./TMath::Pi();
+ static const Double_t kDegToRadCF = 180./TMath::Pi();
fGenerator->SetMomentumRange(fPtMin,fPtMax);
- fGenerator->SetPhiRange(degtoradcf*fPhiMin,degtoradcf*fPhiMax);
+ fGenerator->SetPhiRange(kDegToRadCF*fPhiMin,kDegToRadCF*fPhiMax);
fGenerator->SetYRange(fYMin,fYMax);
- fGenerator->SetThetaRange(degtoradcf*fThetaMin,degtoradcf*fThetaMax);
+ fGenerator->SetThetaRange(kDegToRadCF*fThetaMin,kDegToRadCF*fThetaMax);
fGenerator->Init();
}
- fQCoarseBackground = new TH3D("fQCoarseBackground","",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
- fQCoarseSignal = new TH3D("fQCoarseSignal","fQCoarseSignal",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
+// fQCoarseBackground = new TH3D("fQCoarseBackground","",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
+// fQCoarseSignal = new TH3D("fQCoarseSignal","fQCoarseSignal",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
+// fQCoarseBackground->Sumw2();
+// fQCoarseSignal->Sumw2();
+
fQSignal = new TH3D("fQSignal1","fQSignal",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
fQBackground = new TH3D("fQBackground1","fQBackground",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
fQSecondSignal = new TH3D("fQSignal2","fQSignal",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
fQSecondBackground = new TH3D("fQBackground2","fQBackground",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
- fQCoarseBackground->Sumw2();
- fQCoarseSignal->Sumw2();
fQSignal->Sumw2();
fQBackground->Sumw2();
fQSecondSignal->Sumw2();
fQSecondBackground->Sumw2();
+
+ fLogFile = new ofstream("BadEvent",ios::out);
+
}
/***********************************************************/
void AliGenHBTosl::Generate()
{
//the main method
- Info("Generate","Attempts to generate %d particles.",fNpart);
+
+ ofstream& logfile = *fLogFile;
+ logfile<<"Generate"<<"Attempts to generate "<<fNpart<<" particles.";
+
+
if (fStackBuffer == 0x0) fStackBuffer = new TList();
//Here is initialization level
if (fSignalShapeCreated == kFALSE)
fQCoarseBackground = cb;
}
else
- {
+ {
+ fQCoarseBackground = new TH3D("fQCoarseBackground","",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
+ fQCoarseBackground->Sumw2();
+
FillCoarse(); //create coarse background - just to know the spectrum
}
+
+ fQCoarseSignal = new TH3D("fQCoarseSignal","fQCoarseSignal",fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange, fQNBins,-fQRange,fQRange);
+ fQCoarseSignal->Sumw2();
FillCoarseSignal();//create first coarse signal by brutal multplication coarse background and required function shape
}
}
fGenerator->Generate();
- Int_t j = 0, ntr = 0;
+ Int_t ntr = 0;
if ( genstack->GetNtrack() < fNpart/2)
{
Warning("Generate","************************************************************");
}
TH3D* work = new TH3D("work","work",fQNBins,-fQRange,fQRange,fQNBins,-fQRange,fQRange,fQNBins,-fQRange,fQRange);
-
+ work->SetDirectory(0x0);
+ work->Sumw2();
Double_t*** chiarray = new Double_t** [fQNBins+1];
Double_t*** sigarray = new Double_t** [fQNBins+1];
}
}
}
-
- printf("\n");
+
+ char msg[1000];
+ logfile<<endl;
+ snprintf(msg,1000, "\n");
Int_t middlebin = fQNBins/2;
+
+ for (Int_t k = middlebin-5; k < middlebin+5; k++)
+ {
+ Double_t tx = work->GetXaxis()->GetBinCenter(30);
+ Double_t ty = work->GetYaxis()->GetBinCenter(30);
+ Double_t tz = work->GetZaxis()->GetBinCenter(k);
+ snprintf(msg,1000, "% 6.5f ",GetQOutQSideQLongCorrTheorValue(tx,ty,tz));
+ logfile<<msg;
+ }
+ logfile<<endl;
+
for (Int_t k = middlebin-5; k < middlebin+5; k++)
{
- printf("% 6.5f ",work->GetBinContent(1,1,k));
+ snprintf(msg,1000, "% 6.5f ",work->GetBinContent(30,30,k));
+ logfile<<msg;
}
- printf("\n");
+ logfile<<endl;
for (Int_t k = middlebin-5; k < middlebin+5; k++)
{
- printf("% 6.5f ",chiarray[1][1][k]);
+ snprintf(msg, 1000, "% 6.5f ",chiarray[30][30][k]);
+ logfile<<msg;
}
- printf("\n");
+ logfile<<endl;
TParticle particle(fPID,0,-1,-1,-1,-1,0.0,0.0,0.0,0.0,0.0,0.0,0.0,0.0);
TParticle* second = &particle;
}
}
}
- qlong = work->GetZaxis()->GetBinCenter(zmax);
- qside = work->GetYaxis()->GetBinCenter(ymax);
- qout = work->GetXaxis()->GetBinCenter(xmax);
+ Double_t qlongc = work->GetZaxis()->GetBinCenter(zmax);
+ Double_t qsidec = work->GetYaxis()->GetBinCenter(ymax);
+ Double_t qoutc = work->GetXaxis()->GetBinCenter(xmax);
- Info("Generate","Fill bin (%d,%d,%d)",xmax,ymax,zmax);
+
+ snprintf(msg,1000, "Generate Fill bin chi2(%d,%d,%d)=%f",xmax,ymax,zmax,chiarray[xmax][ymax][zmax]);
+ logfile<<msg;
- qout = gRandom->Uniform(qout-binwdh,qout+binwdh);
- qside = gRandom->Uniform(qside-binwdh,qside+binwdh);
- qlong = gRandom->Uniform(qlong-binwdh,qlong+binwdh);
+ qout = gRandom->Uniform(qoutc -binwdh, qoutc +binwdh);
+ qside = gRandom->Uniform(qsidec-binwdh, qsidec+binwdh);
+ qlong = gRandom->Uniform(qlongc-binwdh, qlongc+binwdh);
TParticle* first = 0;
- while (j < genstack->GetNtrack())
+ Int_t jj = 0;
+
+ while (jj < genstack->GetNtrack())
{
- TParticle* tmpp = genstack->Particle(j++);
+ TParticle* tmpp = genstack->Particle(jj++);
if (tmpp->GetPdgCode() == fPID)
{
if (CheckParticle(tmpp,0x0,stack) == kFALSE)
SetTrack(first,etmp,stack);
SetTrack(second,etmp,stack);
- Double_t y = GetQOutQSideQLongCorrTheorValue(qout,qside,qlong);
+ Double_t y = GetQOutQSideQLongCorrTheorValue(qoutc,qsidec,qlongc);
sigarray[xmax][ymax][zmax] ++;
chiarray[xmax][ymax][zmax] = scale*sigarray[xmax][ymax][zmax]/fQBackground->GetBinContent(xmax,ymax,zmax);
Mix(fStackBuffer,fQBackground,fQSecondSignal); //upgrate background
Mix(stack,fQSignal,fQSecondBackground); //upgrate signal
-
+
+ delete work;
+
for (Int_t i = 1; i<=fQNBins; i++)
{
for (Int_t k = 1; k<=fQNBins; k++)
// TParticle(pdg, is, parent, -1, kFirstDaughter, kLastDaughter,
// px, py, pz, e, vx, vy, vz, tof);
- if (GetDebug()) Info("GetOneD","Randomized qinv = %f, obtained = %f",qinv,GetQInv(first,second));
+ AliDebug(1,Form("Randomized qinv = %f, obtained = %f",qinv,GetQInv(first,second)));
}
/***********************************************************/
second->SetMomentum(vector.X(),vector.Y(),vector.Z(),e);
////////////
- if ( GetDebug() > 3 )
+ if ( AliDebugLevel() > 3 )
{
e=TMath::Sqrt(m2+px*px);
TParticle* f = new TParticle(first->GetPdgCode(),0,-1,-1,-1,-1, px , 0.0, 0.0, e,0.0,0.0,0.0,0.0);
void AliGenHBTosl::StartSignal()
{
//Starts the signal histograms
+ ofstream& logfile = *fLogFile;
+ logfile<<"\n\n\n\n";
+ logfile<<"************************************************"<<endl;
+ logfile<<"************************************************"<<endl;
+ logfile<<" StartSignal "<<endl;
+ logfile<<"************************************************"<<endl;
+ logfile<<"************************************************"<<endl;
+
AliStack* stack;
fSwapped = kFALSE;
genstack->Reset();
}
- const Double_t ndf = fQNBins*fQNBins*fQNBins;
+ StartSignalPass1();
+ //We alread have detailed histograms and we do not need Coarse anymore
+ delete fQCoarseSignal;
+ delete fQCoarseBackground;
+ fQCoarseSignal = 0x0;
+ fQCoarseBackground = 0x0;
+
+
+ const Double_t kNDF = fQNBins*fQNBins*fQNBins;
TH3D* work = new TH3D("work","work",fQNBins,-fQRange,fQRange,fQNBins,-fQRange,fQRange,fQNBins,-fQRange,fQRange);
work->Sumw2();
Bool_t shortloop = kTRUE;
TCanvas* c1 = new TCanvas();
- StartSignalPass1();
printf("\n");
Info("StartSignal","\n\n\n\nSecond Pass\n\n\n\n");
while ( ( (chisqrPerDF > fMaxChiSquereChange) || flag) && (niterations++ < fMaxIterations) )
{
- printf("StartSignal\n");
- printf(" Row 1 Theory, 2 current value, 3 Chi2 \n");
+ logfile<<"StartSignal\n";
+ logfile<<" Row 1 Theory, 2 current value, 3 Chi2 \n";
Double_t chisqrnew = 0.0;
flag = kFALSE;
{
c1->cd();
char buff[50];
- sprintf(buff,"QTWorkPass2.%3d.root",counter);
+ snprintf(buff,50, "QTWorkPass2.%3d.root",counter);
TFile* file = TFile::Open(buff,"update");
work->Write();
work->SetDirectory(0x0);
file->Close();
delete file;
- sprintf(buff,"QTBackgroundPass2.%3d.root",counter);
+ snprintf(buff,50, "QTBackgroundPass2.%3d.root",counter);
file = TFile::Open(buff,"update");
fQBackground->Write();
fQBackground->SetDirectory(0x0);
file->Close();
delete file;
- sprintf(buff,"QTSignalPass2.%3d.root",counter);
+ snprintf(buff,50, "QTSignalPass2.%3d.root",counter);
file = TFile::Open(buff,"update");
fQSignal->Write();
fQSignal->SetDirectory(0x0);
}
- printf("\n");
+ char msg[1000];
- for (Int_t k = 1; k < 11; k++)
+ printf("\n");
+
+ for (Int_t k = 25; k < 36; k++)
{
- Double_t tx = work->GetXaxis()->GetBinCenter(1);
- Double_t ty = work->GetYaxis()->GetBinCenter(1);
+ Double_t tx = work->GetXaxis()->GetBinCenter(30);
+ Double_t ty = work->GetYaxis()->GetBinCenter(30);
Double_t tz = work->GetZaxis()->GetBinCenter(k);
- printf("% 6.5f ",GetQOutQSideQLongCorrTheorValue(tx,ty,tz));
+ snprintf(msg,1000, "% 6.5f ",GetQOutQSideQLongCorrTheorValue(tx,ty,tz));
+ logfile<<msg;
}
- printf("\n");
+ logfile<<endl;
- for (Int_t k = 1; k < 11; k++)
+ for (Int_t k = 25; k < 36; k++)
{
- printf("% 6.5f ",work->GetBinContent(1,1,k));
+ snprintf(msg, 1000, "%6.5f ",work->GetBinContent(30,30,k));
+ logfile<<msg;
}
- printf("\n");
+ logfile<<endl;
- for (Int_t k = 1; k < 11; k++)
+ for (Int_t k = 25; k < 36; k++)
{
- printf("% 6.5f ",chiarray[1][1][k]);
+ snprintf(msg,1000, "% 6.5f ",chiarray[30][30][k]);
+ logfile<<msg;
}
- printf("\n");
+ logfile<<endl;
chisqrchange = TMath::Abs(chisqrnew - chisqrold)/chisqrnew;
chisqrold = chisqrnew;
- chisqrPerDF = chisqrnew/ndf;
+ chisqrPerDF = chisqrnew/kNDF;
Info("StartSignal","Iteration %d Chi-sq change %f%%",niterations,chisqrchange*100.0);
- Info("StartSignal","ChiSq = %f, NDF = %f, ChiSq/NDF = %f",chisqrnew, ndf, chisqrPerDF );
+ Info("StartSignal","ChiSq = %f, NDF = %f, ChiSq/NDF = %f",chisqrnew, kNDF, chisqrPerDF );
Info("StartSignal","novertresh = %d",novertresh);
Mix(fStackBuffer,fQBackground,fQSecondBackground); //upgrate background
Info("StartSignal","Mixing signal...");
Mix(stack,fQSignal,fQSecondSignal); //upgrate background
-
- if ( (chisqrPerDF < 2.0) && (fSwapped == kFALSE) )
- {
- SwapGeneratingHistograms();
- }
+
+
+// if ( (chisqrPerDF < 2.0) && (fSwapped == kFALSE) )
+// {
+// SwapGeneratingHistograms();
+// }
}
TFile* filef = TFile::Open("QTBackground.root","recreate");
for (Int_t k = 1; k<=fQNBins; k++)
{
- for (Int_t j = 1; j<=fQNBins; j++)
+ for (j = 1; j<=fQNBins; j++)
{
for (Int_t i = 1; i<=fQNBins; i++)
{
}
}
- //if (GetDebug())
+ //if (AliDebugLevel())
TestCoarseSignal();
Info("FillCoarseSignal","DONE");
{
// if (niter > 20) break;
- cout<<niter++<<" bincont "<<fQCoarseBackground->GetBinContent(1,1,1)
- <<" "<<fQCoarseBackground->GetBinContent(1,1,2)
- <<" "<<fQCoarseBackground->GetBinContent(1,1,3)
- <<" "<<fQCoarseBackground->GetBinContent(1,1,4)
- <<" "<<fQCoarseBackground->GetBinContent(1,1,5)
+ cout<<niter++<<" bincont "<<fQCoarseBackground->GetBinContent(30,30,28)
+ <<" "<<fQCoarseBackground->GetBinContent(30,30,29)
+ <<" "<<fQCoarseBackground->GetBinContent(30,30,30)
+ <<" "<<fQCoarseBackground->GetBinContent(30,30,31)
+ <<" "<<fQCoarseBackground->GetBinContent(30,30,32)
<<"\n";
fflush(0);
}
Double_t beta = pzsum/esum;
- Double_t gamma = 1.0/TMath::Sqrt(1.0 - beta*beta);
+ Double_t gamma = 1.0/TMath::Sqrt((1.-beta)*(1.+beta));
lon = gamma * ( pzdiff - beta*ediff );
//Calculates the factor that should be used to scale
//quatience of num and den to 1 at tail
- if (GetDebug()) Info("Scale","Entered Scale()");
+ AliDebug(1,"Entered");
if(!num)
{
- Error("Scale","No numerator");
+ AliError("No numerator");
return 0.0;
}
if(!den)
{
- Error("Scale","No denominator");
+ AliError("No denominator");
return 0.0;
}
if(fNBinsToScale < 1)
{
+ AliError("Number of bins for scaling is smaller than 1");
return 0.0;
- Error("Scale","Number of bins for scaling is smaller thnan 1");
}
Int_t fNBinsToScaleX = fNBinsToScale;
Int_t fNBinsToScaleY = fNBinsToScale;
Int_t nbinsX = num->GetNbinsX();
if (fNBinsToScaleX > nbinsX)
{
- Error("Scale","Number of X bins for scaling is bigger thnan number of bins in histograms");
+ AliError("Number of X bins for scaling is bigger thnan number of bins in histograms");
return 0.0;
}
Int_t nbinsY = num->GetNbinsX();
if (fNBinsToScaleY > nbinsY)
{
- Error("Scale","Number of Y bins for scaling is bigger thnan number of bins in histograms");
+ AliError("Number of Y bins for scaling is bigger thnan number of bins in histograms");
return 0.0;
}
Int_t nbinsZ = num->GetNbinsZ();
if (fNBinsToScaleZ > nbinsZ)
{
- Error("Scale","Number of Z bins for scaling is bigger thnan number of bins in histograms");
+ AliError("Number of Z bins for scaling is bigger thnan number of bins in histograms");
return 0.0;
}
- if (GetDebug()>0) Info("Scale","No errors detected");
+ AliDebug(1,"No errors detected");
Int_t offsetX = nbinsX - fNBinsToScaleX - 1; //bin that we start loop over bins in axis X
Int_t offsetY = nbinsY - fNBinsToScaleY - 1; //bin that we start loop over bins in axis Y
}
}
- if(GetDebug() > 0)
- Info("Scale","numsum=%f densum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d fNBinsToScaleZ=%d",
- numsum,densum,fNBinsToScaleX,fNBinsToScaleY,fNBinsToScaleZ);
+ AliDebug(1,Form("numsum=%f densum=%f fNBinsToScaleX=%d fNBinsToScaleY=%d fNBinsToScaleZ=%d",
+ numsum,densum,fNBinsToScaleX,fNBinsToScaleY,fNBinsToScaleZ));
if (numsum == 0) return 0.0;
Double_t ret = densum/numsum;
- if(GetDebug() > 0) Info("Scale","returning %f",ret);
+ AliDebug(1,Form("returning %f",ret));
return ret;
}
}
/***********************************************************/
-void AliGenHBTosl::SetTrack(TParticle* p, Int_t& ntr)
+void AliGenHBTosl::SetTrack(TParticle* p, Int_t& ntr)
{
//Shortcut to PushTrack(bla,bla,bla,bla.............)
if (p->P() == 0.0)
}
/***********************************************************/
-void AliGenHBTosl::SetTrack(TParticle* p, Int_t& ntr, AliStack* stack)
+void AliGenHBTosl::SetTrack(TParticle* p, Int_t& ntr, AliStack* stack) const
{
//Shortcut to SetTrack(bla,bla,bla,bla.............)
if (p->P() == 0.0)
//In other words: To make equations easier
static TVector3 first;
- if (GetDebug())
+ if (AliDebugLevel()>=1)
{
first.SetXYZ(relvector.x(),relvector.y(),relvector.z());
}
vector.RotateY(rotAngleY);
vector.RotateZ(rotAngleZ);
- if (GetDebug()>5)
+ if (AliDebugLevel()>5)
{
TVector3 test(firstPx,0.0,0.0);
test.RotateY(rotAngleY);
test.RotateZ(rotAngleZ);
- ::Info("Rotate","Rotation test: px %f %f",first.x(),test.x());
- ::Info("Rotate","Rotation test: py %f %f",first.y(),test.y());
- ::Info("Rotate","Rotation test: pz %f %f",first.z(),test.z());
+ AliInfo(Form("Rotation test: px %f %f",first.x(),test.x()));
+ AliInfo(Form("Rotation test: py %f %f",first.y(),test.y()));
+ AliInfo(Form("Rotation test: pz %f %f",first.z(),test.z()));
}
}
/***********************************************************/
TVector3 v(x,y,z);
Double_t a1 = -TMath::ATan2(v.Y(),v.X());
- ::Info("Rotate","Xpr = %f Ypr = %f",xprime,yprime);
- ::Info("Rotate","Calc sin = %f, and %f",sinphi,TMath::Sin(a1));
- ::Info("Rotate","Calc cos = %f, and %f",cosphi,TMath::Cos(a1));
-
-
+ if (AliDebugLevel()>5)
+ {
+ AliInfo(Form("Xpr = %f Ypr = %f",xprime,yprime));
+ AliInfo(Form("Calc sin = %f, and %f",sinphi,TMath::Sin(a1)));
+ AliInfo(Form("Calc cos = %f, and %f",cosphi,TMath::Cos(a1)));
+ }
+
Double_t xprimezlength = TMath::Hypot(xprime,z);
Double_t sintheta = z/xprimezlength;
Double_t xbis = sintheta*z + costheta*(cosphi*x - sinphi*y);
- ::Info("Rotate","Calculated rot %f, modulus %f",xbis,TMath::Sqrt(x*x+y*y+z*z));
+ AliInfo(Form("Calculated rot %f, modulus %f",xbis,TMath::Sqrt(x*x+y*y+z*z)));
return xbis;
}
/***********************************************************/
Double_t AliGenHBTosl::GetQInvCorrTheorValue(Double_t qinv) const
{
//Function (deprecated)
- static const Double_t factorsqrd = 0.197*0.197;//squared conversion factor SI<->eV
+ static const Double_t kFactorsqrd = 0.197*0.197;//squared conversion factor SI<->eV
- return 1.0 + 0.5*TMath::Exp(-qinv*qinv*fQRadius*fQRadius/factorsqrd);
+ return 1.0 + 0.5*TMath::Exp(-qinv*qinv*fQRadius*fQRadius/kFactorsqrd);
}
/***********************************************************/
Double_t AliGenHBTosl::GetQOutQSideQLongCorrTheorValue(Double_t& out, Double_t& side, Double_t& lon) const
{
//Theoretical function. Wa want to get correlation of the shape of this function
- static const Double_t factorsqrd = 0.197*0.197;//squared conversion factor SI<->eV
- return 1.0 + 0.7*TMath::Exp(-fQRadius*fQRadius*(out*out+side*side+lon*lon)/factorsqrd);
+ static const Double_t kFactorsqrd = 0.197*0.197;//squared conversion factor SI<->eV
+ return 1.0 + 0.7*TMath::Exp(-fQRadius*fQRadius*(out*out+side*side+lon*lon)/kFactorsqrd);
}
/***********************************************************/
{
//Checks if a given particle is falling into signal region with any other particle
//already existing on stack
- return kFALSE;
+ //PH return kFALSE;
if (fSignalRegion <=0) return kFALSE;
fSwapped = kTRUE;
}
+
+AliGenHBTosl& AliGenHBTosl::operator=(const AliGenHBTosl& rhs)
+{
+// Assignment operator
+ rhs.Copy(*this);
+ return *this;
+}
+
+void AliGenHBTosl::Copy(TObject&) const
+{
+ //
+ // Copy
+ //
+ Fatal("Copy","Not implemented!\n");
+}
+
+
git://git.uio.no / u / mrichter / AliRoot.git / blobdiff