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 /******************************************************************/
  92 void AliHBTMonitorFunction::SetParticleCut(AliHBTParticleCut* cut)
  93 {
  94 //Sets new Particle Cut. Old one is deleted
  95 //Note that it is created new object instead of simple pointer set
  96 //I do not want to have pointer
  97 //to object created somewhere else
  98 //because in that case I could not believe that
  99 //it would always exist (sb could delete it)
 100 //so we have always own copy
 101
 102  if(!cut)
 103    {
 104      Error("AliHBTMonitorFunction::SetParticleCut","argument is NULL");
 105      return;
 106    }
 107  delete fParticleCut;
 108  fParticleCut = (AliHBTParticleCut*)cut->Clone();
 109
 110 }
 111 /******************************************************************/
 112
 113 void AliHBTMonitorFunction::Rename(const Char_t * name)
 114  {
 115  //renames the function and histograms
 116   SetName(name);
 117   SetTitle(name);
 118
 119   TString numstr = fName + " Result";  //title and name of the
 120                                            //result histogram
 121   GetResult()->SetName(numstr.Data());
 122   GetResult()->SetTitle(numstr.Data());
 123  }
 124 /******************************************************************/
 125
 126 void AliHBTMonitorFunction::Rename(const Char_t * name, const Char_t * title)
 127  {
 128  //renames and retitle the function and histograms
 129
 130   SetName(name);
 131   SetTitle(title);
 132
 133   TString numstrn = fName + " Result";  //name of the
 134                                            //result histogram
 135
 136   TString numstrt = fTitle + " Result";  //title of the
 137                                            //result histogram
 138
 139
 140   GetResult()->SetName(numstrn.Data());
 141   GetResult()->SetTitle(numstrt.Data());
 142
 143  }
 144
 145 /******************************************************************/
 146 /******************************************************************/
 147 /******************************************************************/
 148 ClassImp( AliHBTMonOneParticleFctn )  //z.ch.
 149 /******************************************************************/
 150 /******************************************************************/
 151 ClassImp( AliHBTMonTwoParticleFctn )  //z.ch.
 152 /******************************************************************/
 153 /******************************************************************/
 154 /******************************************************************/
 155 ClassImp( AliHBTMonOneParticleFctn1D )
 156 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D():
 157  fResult(0x0)
 158  {
 159    //ctor
 160  }
 161 /******************************************************************/
 162
 163 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D(Int_t nbins, Double_t maxXval, Double_t minXval)
 164  {
 165    //ctor
 166    TString numstr = fName + " Result";  //title and name of the
 167                                            //result histogram
 168    fResult   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
 169  }
 170
 171 AliHBTMonOneParticleFctn1D::AliHBTMonOneParticleFctn1D(const Char_t *name, const Char_t *title,
 172                     Int_t nbins, Double_t maxXval, Double_t minXval)
 173         :AliHBTMonOneParticleFctn(name,title)
 174 {
 175   //ctor
 176    TString numstr = fName + " Result";  //title and name of the
 177                                            //result histogram
 178
 179    fResult   = new TH1D(numstr.Data(),numstr.Data(),nbins,minXval,maxXval);
 180 }
 181 /******************************************************************/
 182 AliHBTMonOneParticleFctn1D::~AliHBTMonOneParticleFctn1D()
 183 {
 184  //dtor
 185  delete fResult;
 186 }
 187 /******************************************************************/
 188
 189 void AliHBTMonOneParticleFctn1D::Process(AliHBTParticle* particle)
 190 {
 191  //Fills the result
 192    particle = CheckParticle(particle);
 193    if(particle) fResult->Fill(GetValue(particle));
 194 }
 195 /******************************************************************/
 196 /******************************************************************/
 197
 198 ClassImp( AliHBTMonOneParticleFctn2D )
 199
 200 AliHBTMonOneParticleFctn2D::AliHBTMonOneParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval ,
 201                     Int_t nYbins, Double_t maxYval, Double_t minYval)
 202
 203 {
 204   //ctor
 205    TString numstr = fName + " Result";  //title and name of the
 206                                            //result histogram
 207
 208    fResult   = new TH2D(numstr.Data(),numstr.Data(),
 209                            nXbins,minXval,maxXval,
 210                nYbins,minYval,maxYval);
 211 }
 212 /******************************************************************/
 213
 214 AliHBTMonOneParticleFctn2D::~AliHBTMonOneParticleFctn2D()
 215 {
 216   //dtor
 217   delete fResult;
 218 }
 219 void AliHBTMonOneParticleFctn2D::Process(AliHBTParticle* particle)
 220 {
 221   //fills the function for one particle
 222   particle = CheckParticle(particle);
 223   if(particle)
 224    {
 225      Double_t x,y;
 226      GetValues(particle,x,y);
 227      fResult->Fill(x,y);
 228    }
 229 }
 230
 231 /******************************************************************/
 232 /******************************************************************/
 233 /******************************************************************/
 234
 235 ClassImp( AliHBTMonOneParticleFctn3D)
 236
 237 AliHBTMonOneParticleFctn3D::
 238 AliHBTMonOneParticleFctn3D(Int_t nXbins, Double_t maxXval, Double_t minXval,
 239                     Int_t nYbins, Double_t maxYval, Double_t minYval,
 240                     Int_t nZbins, Double_t maxZval, Double_t minZval)
 241
 242 {
 243   //ctor
 244    TString numstr = fName + " Result";  //title and name of the
 245                                            //result histogram
 246
 247    fResult   = new TH3D(numstr.Data(),numstr.Data(),
 248                            nXbins,minXval,maxXval,
 249                nYbins,minYval,maxYval,
 250                nZbins,minZval,maxZval);
 251
 252 }
 253 /******************************************************************/
 254
 255 AliHBTMonOneParticleFctn3D::~AliHBTMonOneParticleFctn3D()
 256 {
 257   //dtor
 258   delete fResult;
 259 }
 260 /******************************************************************/
 261
 262
 263 /******************************************************************/
 264 /******************************************************************/
 265 /******************************************************************/
 266 ClassImp( AliHBTMonTwoParticleFctn1D)
 267
 268 AliHBTMonTwoParticleFctn1D::
 269 AliHBTMonTwoParticleFctn1D(Int_t nbins, Double_t maxval, Double_t minval)
 270  {
 271    //ctor
 272    TString numstr = fName + " Result";  //title and name of the
 273                                            //result histogram
 274
 275    fResult   = new TH1D(numstr.Data(),numstr.Data(),
 276                            nbins,minval,maxval);
 277
 278  }
 279
 280 AliHBTMonTwoParticleFctn1D::
 281 AliHBTMonTwoParticleFctn1D(const Char_t* name, const Char_t* title,
 282                     Int_t nbins, Double_t maxval, Double_t minval)
 283         :AliHBTMonTwoParticleFctn(name,title)
 284  {
 285    //ctor
 286    TString numstr = fName + " Result";  //title and name of the
 287                                            //result histogram
 288
 289    fResult   = new TH1D(numstr.Data(),numstr.Data(),
 290                            nbins,minval,maxval);
 291
 292  }
 293
 294
 295 /******************************************************************/
 296 AliHBTMonTwoParticleFctn1D::~AliHBTMonTwoParticleFctn1D()
 297 {
 298   //dtor
 299   delete fResult;
 300 }
 301 /******************************************************************/
 302 void AliHBTMonTwoParticleFctn1D::
 303 Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
 304 {
 305   //fills the function for one particle
 306   partparticle  = CheckParticle(partparticle);
 307   trackparticle = CheckParticle(trackparticle);
 308   if( partparticle && trackparticle)
 309    {
 310      Double_t x = GetValue(trackparticle,partparticle);
 311      fResult->Fill(x);
 312    }
 313 }
 314 /******************************************************************/
 315 /******************************************************************/
 316 /******************************************************************/
 317 ClassImp( AliHBTMonTwoParticleFctn2D)
 318
 319
 320 AliHBTMonTwoParticleFctn2D::
 321 AliHBTMonTwoParticleFctn2D(Int_t nXbins, Double_t maxXval, Double_t minXval ,
 322                     Int_t nYbins, Double_t maxYval, Double_t minYval)
 323
 324 {
 325   //ctor
 326    TString numstr = fName + " Result";  //title and name of the
 327                                            //result histogram
 328
 329    fResult   = new TH2D(numstr.Data(),numstr.Data(),
 330                            nXbins,minXval,maxXval,
 331                nYbins,minYval,maxYval);
 332
 333 }
 334 /******************************************************************/
 335 AliHBTMonTwoParticleFctn2D::~AliHBTMonTwoParticleFctn2D()
 336 {
 337   //dtor
 338   delete fResult;
 339 }
 340 /******************************************************************/
 341 void AliHBTMonTwoParticleFctn2D::
 342 Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
 343 {
 344   //fills the function for one particle
 345   partparticle  = CheckParticle(partparticle);
 346   trackparticle = CheckParticle(trackparticle);
 347   if( partparticle && trackparticle)
 348    {
 349      Double_t x,y;
 350      GetValues(trackparticle,partparticle,x,y);
 351      fResult->Fill(x,y);
 352    }
 353 }
 354 /******************************************************************/
 355 /******************************************************************/
 356 /******************************************************************/
 357 ClassImp(AliHBTMonTwoParticleFctn3D)
 358
 359 void AliHBTMonTwoParticleFctn3D::
 360 Process(AliHBTParticle* trackparticle, AliHBTParticle* partparticle)
 361 {
 362   //fills the function for one particle
 363   partparticle  = CheckParticle(partparticle);
 364   trackparticle = CheckParticle(trackparticle);
 365   if( partparticle && trackparticle)
 366    {
 367      Double_t x,y,z;
 368      GetValues(trackparticle,partparticle,x,y,z);
 369      fResult->Fill(x,y,z);
 370    }
 371 }
 372 /******************************************************************/
 373 /******************************************************************/
 374 /******************************************************************/
 375 /******************************************************************/
 376