HBTAN/AliHBTMonitorFunction.cxx

   1 #include "AliHBTMonitorFunction.h"
   2 //__________________________________________________________________
   3 ////////////////////////////////////////////////////////////////////
   4 //
   5 // class AliHBTMonitorFunction
   6 //
   7 // class AliHBTMonOneParticleFctn
   8 // class AliHBTMonTwoParticleFctn
   9 //
  10 // class AliHBTMonOneParticleFctn1D
  11 // class AliHBTMonOneParticleFctn2D
  12 // class AliHBTMonOneParticleFctn3D
  13 //
  14 // class AliHBTMonTwoParticleFctn1D
  15 // class AliHBTMonTwoParticleFctn2D
  16 // class AliHBTMonTwoParticleFctn3D
  17 //
  18 // Base Classes for monitoring functions
  19 // author: chajecki@if.pw.edu.pl
  20 //
  21 /******************************************************************/
  22 /*
  23 Base classes for monitor functions
  24
  25           monitor function
  26                /    \
  27               /      \
  28              /        \
  29             /          \
  30            /            \
  31           /              \
  32          /                \
  33    one particle     two particle
  34      /  |  \            /  |  \
  35     /   |   \          /   |   \
  36    1D  2D   3D        1D  2D   3D
  37
  38 Zbigniew.Chajecki@cern.ch
  39
  40 */
  41 ///////////////////////////////////////////////////////////////////////
  42
  43
  44 ClassImp( AliHBTMonitorFunction )
  45
  46 AliHBTMonitorFunction::AliHBTMonitorFunction():
  47  fParticleCut(new AliHBTEmptyParticleCut())
  48 {
  49   //ctor
  50 }
  51 /******************************************************************/
  52 AliHBTMonitorFunction::AliHBTMonitorFunction(const char* name,const char* title):
  53  TNamed(name,title),
  54  fParticleCut(new AliHBTEmptyParticleCut())
  55 {
  56   //ctor
  57 }
  58 /******************************************************************/
  59 AliHBTMonitorFunction::AliHBTMonitorFunction(const AliHBTMonitorFunction& /*in*/):
  60  TNamed(),
  61  fParticleCut(new AliHBTEmptyParticleCut())
  62 {
  63   //cpy ctor
  64   // We cannot copy because it is a mess with names (histogram and functions)
  65   MayNotUse("AliHBTMonitorFunction(const AliHBTMonitorFunction&");
  66 }
  67 /******************************************************************/
  68 AliHBTMonitorFunction& AliHBTMonitorFunction::operator=(const AliHBTMonitorFunction& /*in*/)
  69 {
  70   //assigment operator
  71   // We cannot copy because it is a mess with names (histogram and functions)
  72   MayNotUse("operator=");
  73   return *this;
  74 }
  75 /******************************************************************/
  76
  77 AliHBTMonitorFunction::~AliHBTMonitorFunction()
  78  {
  79   //dtor
  80   delete fParticleCut;
  81  }
  82 /******************************************************************/
  83
  84 void AliHBTMonitorFunction::Write()
  85  {
  86    //Writes an function to disk
  87    if (GetResult()) GetResult()->Write();
  88  }
  89 /******************************************************************/
  90
  91 void AliHBTMonitorFunction::Init()
  92  {
  93    //Writes an function to disk
  94    if (AliHBTParticle::GetDebug()>0) Info("Init","%s",GetName());
  95
  96    if (GetResult() == 0x0)
  97     {
  98       Warning("Init","Function has NULL result histogram!");
  99       return;
 100     }
 101    GetResult()->Reset();
 102    GetResult()->SetDirectory(0x0);
 103    if (AliHBTParticle::GetDebug()>0) Info("Init","%s Done.",GetName());
 104  }
 105 /******************************************************************/
 106
 107 void AliHBTMonitorFunction::SetParticleCut(AliHBTParticleCut* cut)
 108 {
 109 //Sets new Particle Cut. Old one is deleted
 110 //Note that it is created new object instead of simple pointer set
 111 //I do not want to have pointer
 112 //to object created somewhere else
 113 //because in that case I could not believe that
 114 //it would always exist (sb could delete it)
 115 //so we have always own copy
 116
 117  if(!cut)
 118    {
 119      Error("AliHBTMonitorFunction::SetParticleCut","argument is NULL");
 120      return;
 121    }
 122  delete fParticleCut;
 123  fParticleCut = (AliHBTParticleCut*)cut->Clone();
 124
 125 }
 126 /******************************************************************/
 127
 128 void AliHBTMonitorFunction::Rename(const Char_t * name)
 129  {
 130  //renames the function and histograms
 131   SetName(name);
 132   SetTitle(name);
 133
 134   TString numstr = fName + " Result";  //title and name of the
 135                                            //result histogram
 136   GetResult()->SetName(numstr.Data());
 137   GetResult()->SetTitle(numstr.Data());
 138  }
 139 /******************************************************************/
 140
 141 void AliHBTMonitorFunction::Rename(const Char_t * name, const Char_t * title)
 142  {
 143  //renames and retitle the function and histograms
 144
 145   SetName(name);
 146   SetTitle(title);
 147
 148   TString numstrn = fName + " Result";  //name of the
 149                                            //result histogram
 150
 151   TString numstrt = fTitle + " Result";  //title of the
 152                                            //result histogram
 153
 154
 155   GetResult()->SetName(numstrn.Data());
 156   GetResult()->SetTitle(numstrt.Data());
 157
 158  }
 159
 160 /******************************************************************/
 161 /******************************************************************/
 162 /******************************************************************/
 163 ClassImp( AliHBTMonOneParticleFctn )  //z.ch.
 164 /******************************************************************/
 165 /******************************************************************/
 166 ClassImp( AliHBTMonTwoParticleFctn )  //z.ch.
 167 /******************************************************************/
 168 /******************************************************************/
 169 /******************************************************************/
 170 ClassImp( AliHBTMonOneParticleFctn1D )
 171 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D():
 172  fResult(0x0)
 173  {
 174    //ctor
 175  }
 176 /******************************************************************/
 177
 178 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval)
 179  {
 180    //ctor
 181    TString numstr = fName + " Result";  //title and name of the
 182                                            //result histogram
 183    fResult   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
 184  }
 185
 186 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
 187                     Int_t nbins, Double_t maxXval, Double_t minXval)
 188         :AliHBTMonOneParticleFctn(name,title)
 189 {
 190   //ctor
 191    TString numstr = fName + " Result";  //title and name of the
 192                                            //result histogram
 193
 194    fResult   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
 195    fResult->SetDirectory(0x0);
 196
 197 }
 198 /******************************************************************/
 199 AliHBTMonOneParticleFctn1D::~AliHBTMonOneParticleFctn1D()
 200 {
 201  //dtor
 202  delete fResult;
 203 }
 204 /******************************************************************/
 205
 206 void AliHBTMonOneParticleFctn1D::Process(AliHBTParticle* particle)
 207 {
 208  //Fills the result
 209    particle = CheckParticle(particle);
 210    if(particle) fResult->Fill(GetValue(particle));
 211 }
 212 /******************************************************************/
 213 /******************************************************************/
 214
 215 ClassImp( AliHBTMonOneParticleFctn2D )
 216
 217 AliHBTMonOneParticleFctn2D::AliHBTMonOneParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval ,
 218                     Int_t nYbins, Double_t maxYval, Double_t minYval)
 219
 220 {
 221   //ctor
 222    TString numstr = fName + " Result";  //title and name of the
 223                                            //result histogram
 224
 225    fResult   = new TH2D(numstr.Data(),numstr.Data(),
 226                            nXbins,minXval,maxXval,
 227                nYbins,minYval,maxYval);
 228    fResult->SetDirectory(0x0);
 229 }
 230 /******************************************************************/
 231
 232 AliHBTMonOneParticleFctn2D::~AliHBTMonOneParticleFctn2D()
 233 {
 234   //dtor
 235   delete fResult;
 236 }
 237 void AliHBTMonOneParticleFctn2D::Process(AliHBTParticle* particle)
 238 {
 239   //fills the function for one particle
 240   particle = CheckParticle(particle);
 241   if(particle)
 242    {
 243      Double_t x,y;
 244      GetValues(particle,x,y);
 245      fResult->Fill(x,y);
 246    }
 247 }
 248
 249 /******************************************************************/
 250 /******************************************************************/
 251 /******************************************************************/
 252
 253 ClassImp( AliHBTMonOneParticleFctn3D)
 254
 255 AliHBTMonOneParticleFctn3D::
 256 AliHBTMonOneParticleFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 257                     Int_t nYbins, Double_t maxYval, Double_t minYval,
 258                     Int_t nZbins, Double_t maxZval, Double_t minZval)
 259
 260 {
 261   //ctor
 262    TString numstr = fName + " Result";  //title and name of the
 263                                            //result histogram
 264
 265    fResult   = new TH3D(numstr.Data(),numstr.Data(),
 266                            nXbins,minXval,maxXval,
 267                nYbins,minYval,maxYval,
 268                nZbins,minZval,maxZval);
 269    fResult->SetDirectory(0x0);
 270
 271 }
 272 /******************************************************************/
 273
 274 AliHBTMonOneParticleFctn3D::~AliHBTMonOneParticleFctn3D()
 275 {
 276   //dtor
 277   delete fResult;
 278 }
 279 /******************************************************************/
 280
 281
 282 /******************************************************************/
 283 /******************************************************************/
 284 /******************************************************************/
 285 ClassImp( AliHBTMonTwoParticleFctn1D)
 286
 287 AliHBTMonTwoParticleFctn1D::
 288 AliHBTMonTwoParticleFctn1D(Int_t nbins, Double_t maxval, Double_t minval)
 289  {
 290    //ctor
 291    TString numstr = fName + " Result";  //title and name of the
 292                                            //result histogram
 293
 294    fResult   = new TH1D(numstr.Data(),numstr.Data(),
 295                            nbins,minval,maxval);
 296    fResult->SetDirectory(0x0);
 297  }
 298
 299 AliHBTMonTwoParticleFctn1D::
 300 AliHBTMonTwoParticleFctn1D(const Char_t* name, const Char_t* title,
 301                     Int_t nbins, Double_t maxval, Double_t minval)
 302         :AliHBTMonTwoParticleFctn(name,title)
 303  {
 304    //ctor
 305    TString numstr = fName + " Result";  //title and name of the
 306                                            //result histogram
 307
 308    fResult   = new TH1D(numstr.Data(),numstr.Data(),
 309                            nbins,minval,maxval);
 310    fResult->SetDirectory(0x0);
 311  }
 312
 313
 314 /******************************************************************/
 315 AliHBTMonTwoParticleFctn1D::~AliHBTMonTwoParticleFctn1D()
 316 {
 317   //dtor
 318   delete fResult;
 319 }
 320 /******************************************************************/
 321 void AliHBTMonTwoParticleFctn1D::
 322 Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
 323 {
 324   //fills the function for one particle
 325   partparticle  = CheckParticle(partparticle);
 326   trackparticle = CheckParticle(trackparticle);
 327   if( partparticle && trackparticle)
 328    {
 329      Double_t x = GetValue(trackparticle,partparticle);
 330      fResult->Fill(x);
 331    }
 332 }
 333 /******************************************************************/
 334 /******************************************************************/
 335 /******************************************************************/
 336 ClassImp( AliHBTMonTwoParticleFctn2D)
 337
 338
 339 AliHBTMonTwoParticleFctn2D::
 340 AliHBTMonTwoParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval ,
 341                     Int_t nYbins, Double_t maxYval, Double_t minYval)
 342
 343 {
 344   //ctor
 345    TString numstr = fName + " Result";  //title and name of the
 346                                            //result histogram
 347
 348    fResult   = new TH2D(numstr.Data(),numstr.Data(),
 349                            nXbins,minXval,maxXval,
 350                nYbins,minYval,maxYval);
 351    fResult->SetDirectory(0x0);
 352 }
 353 /******************************************************************/
 354 AliHBTMonTwoParticleFctn2D::~AliHBTMonTwoParticleFctn2D()
 355 {
 356   //dtor
 357   delete fResult;
 358 }
 359 /******************************************************************/
 360 void AliHBTMonTwoParticleFctn2D::
 361 Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
 362 {
 363   //fills the function for one particle
 364   partparticle  = CheckParticle(partparticle);
 365   trackparticle = CheckParticle(trackparticle);
 366   if( partparticle && trackparticle)
 367    {
 368      Double_t x,y;
 369      GetValues(trackparticle,partparticle,x,y);
 370      fResult->Fill(x,y);
 371    }
 372 }
 373 /******************************************************************/
 374 /******************************************************************/
 375 /******************************************************************/
 376 ClassImp(AliHBTMonTwoParticleFctn3D)
 377
 378 void AliHBTMonTwoParticleFctn3D::
 379 Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
 380 {
 381   //fills the function for one particle
 382   partparticle  = CheckParticle(partparticle);
 383   trackparticle = CheckParticle(trackparticle);
 384   if( partparticle && trackparticle)
 385    {
 386      Double_t x,y,z;
 387      GetValues(trackparticle,partparticle,x,y,z);
 388      fResult->Fill(x,y,z);
 389    }
 390 }
 391 /******************************************************************/
 392 /******************************************************************/
 393 /******************************************************************/
 394 /******************************************************************/
 395