HBTAN/AliHBTMonitorFunction.cxx

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