Reference Manual

Go to the documentation of this file.
00001 #ifndef HZZ4LROOPDFS
00002 #define HZZ4LROOPDFS
00003 
00004 #include "RooAbsPdf.h"
00005 #include "RooRealProxy.h"
00006 #include "RooCategoryProxy.h"
00007 #include "RooAbsReal.h"
00008 #include "RooAbsCategory.h"
00009 
00010 #include <iostream>
00011 #include <fstream>
00012 #include <string>
00013 
00014 /*
00015 namespace RooFit{
00016         
00017         void readFile();
00018         
00019         const Double_t FracEventsNoBrem_4mu = 0.703618;
00020         const Double_t FracEventsNoBrem_4e = 0.583196;
00021         const Double_t FracEventsNoBrem_2e2mu = 0.641297;
00022         
00023         Double_t Lgg_7(Double_t mHstar);
00024         Double_t HiggsWidth(Int_t ID,Double_t mHrequested);
00025         Double_t pdf1(double mHstar,double mHreq);
00026         Double_t rho(double r, TString proc);
00027         Double_t Sigma(double mHreq, TString proc);
00028         
00029         Double_t N(Double_t mH, TString proc);
00030         Double_t sigma_CB(Double_t mH, TString proc);
00031         Double_t mean(Double_t mH, TString proc);
00032         
00033         Double_t scratchMass;
00034         Double_t BR[26][217];
00035         Double_t CS[6][197];
00036         
00037 }
00038 */
00039 class RooqqZZPdf : public RooAbsPdf {
00040 public:
00041         RooqqZZPdf() {} ;
00042         RooqqZZPdf(const char *name, const char *title,
00043                            RooAbsReal& _m4l,
00044                            RooAbsReal& _a1,
00045                            RooAbsReal& _a2,
00046                            RooAbsReal& _a3,
00047                            RooAbsReal& _b1,
00048                            RooAbsReal& _b2,
00049                            RooAbsReal& _b3,
00050                            RooAbsReal& _frac);
00051         RooqqZZPdf(const RooqqZZPdf& other, const char* name=0) ;
00052         virtual TObject* clone(const char* newname) const { return new RooqqZZPdf(*this,newname); }
00053         inline virtual ~RooqqZZPdf() { }
00054         
00055 protected:
00056         
00057         RooRealProxy m4l ;
00058         RooRealProxy a1 ;
00059         RooRealProxy a2 ;
00060         RooRealProxy a3 ;
00061         RooRealProxy b1 ;
00062         RooRealProxy b2 ;
00063         RooRealProxy b3 ;
00064         RooRealProxy frac ;
00065         
00066         Double_t evaluate() const ;
00067         
00068 private:
00069         
00070         ClassDef(RooqqZZPdf,1) // Your description goes here...                                                                                                   
00071 };
00072 
00073 
00074 
00075 class RooggZZPdf : public RooAbsPdf {
00076 public:
00077         RooggZZPdf() {} ;
00078         RooggZZPdf(const char *name, const char *title,
00079                            RooAbsReal& _m4l,
00080                            RooAbsReal& _a1,
00081                            RooAbsReal& _a2,
00082                            RooAbsReal& _a3,
00083                            RooAbsReal& _b1,
00084                            RooAbsReal& _b2,
00085                            RooAbsReal& _b3,
00086                            RooAbsReal& _frac);
00087         RooggZZPdf(const RooggZZPdf& other, const char* name=0) ;
00088         virtual TObject* clone(const char* newname) const { return new RooggZZPdf(*this,newname); }
00089         inline virtual ~RooggZZPdf() { }
00090         
00091 protected:
00092         
00093         RooRealProxy m4l ;
00094         RooRealProxy a1 ;
00095         RooRealProxy a2 ;
00096         RooRealProxy a3 ;
00097         RooRealProxy b1 ;
00098         RooRealProxy b2 ;
00099         RooRealProxy b3 ;
00100         RooRealProxy frac ;
00101         
00102         Double_t evaluate() const ;
00103         
00104 private:
00105         
00106         ClassDef(RooggZZPdf,1) // Your description goes here...                                                                                                   
00107 };
00108 
00109 // ------- v2 below -------
00110 
00111 
00112 class RooqqZZPdf_v2 : public RooAbsPdf {
00113 public:
00114         RooqqZZPdf_v2() {} ;
00115         RooqqZZPdf_v2(const char *name, const char *title,
00116                            RooAbsReal& _m4l,
00117                            RooAbsReal& _a0,
00118                            RooAbsReal& _a1,
00119                            RooAbsReal& _a2,
00120                            RooAbsReal& _a3,
00121                            RooAbsReal& _a4,
00122                            RooAbsReal& _a5,
00123                            RooAbsReal& _a6,
00124                            RooAbsReal& _a7,
00125                            RooAbsReal& _a8,
00126                            RooAbsReal& _a9,
00127                            RooAbsReal& _a10,
00128                            RooAbsReal& _a11,
00129                            RooAbsReal& _a12,
00130                            RooAbsReal& _a13
00131                            
00132                            );
00133         RooqqZZPdf_v2(const RooqqZZPdf_v2& other, const char* name=0) ;
00134         virtual TObject* clone(const char* newname) const { return new RooqqZZPdf_v2(*this,newname); }
00135         inline virtual ~RooqqZZPdf_v2() { }
00136         
00137 protected:
00138         
00139         RooRealProxy m4l ;
00140         RooRealProxy a0 ;
00141         RooRealProxy a1 ;
00142         RooRealProxy a2 ;
00143         RooRealProxy a3 ;
00144         RooRealProxy a4 ;
00145         RooRealProxy a5 ;
00146         RooRealProxy a6 ;
00147         RooRealProxy a7 ;
00148         RooRealProxy a8 ;
00149         RooRealProxy a9 ;
00150         RooRealProxy a10 ;
00151         RooRealProxy a11 ;
00152         RooRealProxy a12 ;
00153         RooRealProxy a13 ;
00154         
00155         
00156         Double_t evaluate() const ;
00157         
00158 private:
00159         
00160         ClassDef(RooqqZZPdf_v2,1) // Your description goes here...                                                                                                   
00161 };
00162 
00163 
00164 
00165 class RooggZZPdf_v2 : public RooAbsPdf {
00166 public:
00167         RooggZZPdf_v2() {} ;
00168         RooggZZPdf_v2(const char *name, const char *title,
00169                            RooAbsReal& _m4l,
00170                            RooAbsReal& _a0,
00171                            RooAbsReal& _a1,
00172                            RooAbsReal& _a2,
00173                            RooAbsReal& _a3,
00174                            RooAbsReal& _a4,
00175                            RooAbsReal& _a5,
00176                            RooAbsReal& _a6,
00177                            RooAbsReal& _a7,
00178                            RooAbsReal& _a8,
00179                            RooAbsReal& _a9
00180                            
00181                            );
00182         RooggZZPdf_v2(const RooggZZPdf_v2& other, const char* name=0) ;
00183         virtual TObject* clone(const char* newname) const { return new RooggZZPdf_v2(*this,newname); }
00184         inline virtual ~RooggZZPdf_v2() { }
00185         
00186 protected:
00187         
00188         RooRealProxy m4l ;
00189         RooRealProxy a0 ;
00190         RooRealProxy a1 ;
00191         RooRealProxy a2 ;
00192         RooRealProxy a3 ;
00193         RooRealProxy a4 ;
00194         RooRealProxy a5 ;
00195         RooRealProxy a6 ;
00196         RooRealProxy a7 ;
00197         RooRealProxy a8 ;
00198         RooRealProxy a9 ;
00199         
00200         Double_t evaluate() const ;
00201         
00202 private:
00203         
00204         ClassDef(RooggZZPdf_v2,1) // Your description goes here...                                                                                                   
00205 };
00206 
00207 class RooBetaFunc_v2 : public RooAbsPdf {
00208 public:
00209         RooBetaFunc_v2();
00210         RooBetaFunc_v2(const char *name, const char *title,
00211                                    RooAbsReal& _mZstar,      
00212                                    RooAbsReal& _mZ,          
00213                                    RooAbsReal& _m0,          
00214                                    RooAbsReal& _mZZ,         
00215                                    RooAbsReal& _Gamma,
00216                                    RooAbsReal& _Gamma0,
00217                                    RooAbsReal& _a0,  // mZZ distribution vars
00218                                    RooAbsReal& _a1, 
00219                                    RooAbsReal& _a2,
00220                                    RooAbsReal& _a3,
00221                                    RooAbsReal& _f,
00222                                    RooAbsReal& _f0
00223                                    );
00224         RooBetaFunc_v2(const RooBetaFunc_v2& other, const char* name=0) ;
00225         virtual TObject* clone(const char* newname) const { return new RooBetaFunc_v2(*this,newname); }
00226         inline virtual ~RooBetaFunc_v2() { }
00227         
00228 protected:
00229         
00230     RooRealProxy mZstar;             
00231     RooRealProxy mZ;     
00232         RooRealProxy m0;     
00233     RooRealProxy mZZ;     
00234     RooRealProxy Gamma;
00235         RooRealProxy Gamma0;
00236     RooRealProxy a0;  // mZZ distribution vars
00237     RooRealProxy a1;  // mZZ distribution vars
00238     RooRealProxy a2;
00239     RooRealProxy a3;
00240     RooRealProxy f;
00241         RooRealProxy f0;
00242         
00243     Double_t evaluate() const ;
00244         
00245 private:
00246         
00247         ClassDef(RooBetaFunc_v2,1) 
00248 };
00249 
00250 class Roo4lMasses2D_Bkg : public RooAbsPdf {
00251 public:
00252         Roo4lMasses2D_Bkg();
00253         Roo4lMasses2D_Bkg(const char *name, const char *title,
00254                                           RooAbsReal& _mZstar,         
00255                                           RooAbsReal& _mZZ,          
00256                                           RooAbsReal& _channelVal            
00257                                           );
00258         Roo4lMasses2D_Bkg(const Roo4lMasses2D_Bkg& other, const char* name=0) ;
00259         virtual TObject* clone(const char* newname) const { return new Roo4lMasses2D_Bkg(*this,newname); }
00260         inline virtual ~Roo4lMasses2D_Bkg() { }
00261         
00262 protected:
00263         
00264     RooRealProxy mZstar;             
00265     RooRealProxy mZZ;     
00266     RooRealProxy channelVal;     
00267         
00268     Double_t evaluate() const ;
00269     Double_t UnitStep(double arg) const;
00270 private:
00271         
00272         ClassDef(Roo4lMasses2D_Bkg,1) 
00273 };
00274 
00275 //------------------------
00276 
00277 class Roo4lMasses2D_BkgGGZZ : public RooAbsPdf {
00278 public:
00279         Roo4lMasses2D_BkgGGZZ();
00280         Roo4lMasses2D_BkgGGZZ(const char *name, const char *title,
00281                                           RooAbsReal& _mZstar,         
00282                                           RooAbsReal& _mZZ,          
00283                                           RooAbsReal& _channelVal            
00284                                           );
00285         Roo4lMasses2D_BkgGGZZ(const Roo4lMasses2D_BkgGGZZ& other, const char* name=0) ;
00286         virtual TObject* clone(const char* newname) const { return new Roo4lMasses2D_BkgGGZZ(*this,newname); }
00287         inline virtual ~Roo4lMasses2D_BkgGGZZ() { }
00288         
00289 protected:
00290         
00291     RooRealProxy mZstar;             
00292     RooRealProxy mZZ;     
00293     RooRealProxy channelVal;     
00294         
00295     Double_t evaluate() const ;
00296     Double_t UnitStep(double arg) const;
00297 private:
00298         
00299         ClassDef(Roo4lMasses2D_BkgGGZZ,1) 
00300 };
00301 
00302 // --------------------------------------------------------------------
00303 // --------------------------------------------------------------------
00304 // backgrounds above
00305 // --------------------------------------------------------------------
00306 // --------------------------------------------------------------------
00307 
00308 // --------------------------------------
00309 // 2D signal
00310 class Roo4lMasses2D : public RooAbsPdf {
00311 public:
00312         Roo4lMasses2D();
00313         Roo4lMasses2D(const char *name, const char *title,
00314                                   RooAbsReal& _mZstar,         
00315                                   RooAbsReal& _mZ,             
00316                                   RooAbsReal& _mZZ,            
00317                                   RooAbsReal& _Gamma,          
00318                                   RooAbsReal& _p0,             
00319                                   RooAbsReal& _p1,             
00320                                   RooAbsReal& _p2,             
00321                                   RooAbsReal& _CBmean,         
00322                                   RooAbsReal& _CBwidth,        
00323                                   RooAbsReal& _CBalpha,        
00324                                   RooAbsReal& _CBn             
00325                                   );
00326         Roo4lMasses2D(const Roo4lMasses2D& other, const char* name=0) ;
00327         virtual TObject* clone(const char* newname) const { return new Roo4lMasses2D(*this,newname); }
00328         inline virtual ~Roo4lMasses2D() { }
00329         
00330 protected:
00331         
00332     RooRealProxy mZstar;             
00333     RooRealProxy mZ;     
00334     RooRealProxy mZZ;     
00335     RooRealProxy Gamma;     
00336     RooRealProxy p0;     
00337     RooRealProxy p1;     
00338     RooRealProxy p2;     
00339     RooRealProxy CBmean;    
00340     RooRealProxy CBwidth;    
00341     RooRealProxy CBalpha;            
00342     RooRealProxy CBn;             
00343         
00344     Double_t evaluate() const ;
00345         
00346 private:
00347         
00348         ClassDef(Roo4lMasses2D,1) 
00349 };
00350 
00351 // --------------------------------------
00352 
00353 class RooFourMuMassShapePdf2 : public RooAbsPdf {
00354 public:
00355         RooFourMuMassShapePdf2() {} ;
00356         RooFourMuMassShapePdf2(const char *name, const char *title,
00357                                                    RooAbsReal& _m4l,
00358                                                    RooAbsReal& _mH);
00359         RooFourMuMassShapePdf2(const RooFourMuMassShapePdf2& other, const char* name=0) ;
00360         virtual TObject* clone(const char* newname) const { return new RooFourMuMassShapePdf2(*this,newname); }
00361         inline virtual ~RooFourMuMassShapePdf2() { }
00362         
00363 protected:
00364         
00365         RooRealProxy m4l ;
00366         RooRealProxy mH ;
00367         
00368         Double_t evaluate() const ;
00369         //void readFile() const ;
00370         
00371 private:
00372         
00373         ClassDef(RooFourMuMassShapePdf2,2) // Your description goes here...                                                                                       
00374 };
00375 
00376 
00377 class RooFourEMassShapePdf2 : public RooAbsPdf {
00378 public:
00379         RooFourEMassShapePdf2() {} ;
00380         RooFourEMassShapePdf2(const char *name, const char *title,
00381                                                   RooAbsReal& _m4l,
00382                                                   RooAbsReal& _mH);
00383         RooFourEMassShapePdf2(const RooFourEMassShapePdf2& other, const char* name=0) ;
00384         virtual TObject* clone(const char* newname) const { return new RooFourEMassShapePdf2(*this,newname); }
00385         inline virtual ~RooFourEMassShapePdf2() { }
00386         
00387 protected:
00388         
00389         RooRealProxy m4l ;
00390         RooRealProxy mH ;
00391         
00392         Double_t evaluate() const ;
00393         //void readFile() const ;
00394         
00395 private:
00396         
00397         ClassDef(RooFourEMassShapePdf2,2) // Your description goes here...                                                                                        
00398 };
00399 
00400 
00401 
00402 class RooTwoETwoMuMassShapePdf2 : public RooAbsPdf {
00403 public:
00404         RooTwoETwoMuMassShapePdf2() {} ;
00405         RooTwoETwoMuMassShapePdf2(const char *name, const char *title,
00406                                                           RooAbsReal& _m4l,
00407                                                           RooAbsReal& _mH);
00408         RooTwoETwoMuMassShapePdf2(const RooTwoETwoMuMassShapePdf2& other, const char* name=0) ;
00409         virtual TObject* clone(const char* newname) const { return new RooTwoETwoMuMassShapePdf2(*this,newname); }
00410         inline virtual ~RooTwoETwoMuMassShapePdf2() { }
00411         
00412 protected:
00413         
00414         RooRealProxy m4l ;
00415         RooRealProxy mH ;
00416         
00417         Double_t evaluate() const ;
00418         //void readFile() const ;
00419         
00420 private:        
00421         
00422         ClassDef(RooTwoETwoMuMassShapePdf2,2) // Your description goes here...                                                                                    
00423 };
00424 
00425 
00426 class RooFourMuMassRes : public RooAbsPdf {
00427 public:
00428         RooFourMuMassRes() {} ;
00429         RooFourMuMassRes(const char *name, const char *title,
00430                                          RooAbsReal& _m4l,
00431                                          RooAbsReal& _mH);
00432         RooFourMuMassRes(const RooFourMuMassRes& other, const char* name=0) ;
00433         virtual TObject* clone(const char* newname) const { return new RooFourMuMassRes(*this,newname); }
00434         inline virtual ~RooFourMuMassRes() { }
00435         
00436 protected:
00437         
00438         RooRealProxy m4l ;
00439         RooRealProxy mH  ;
00440         
00441         Double_t evaluate() const ;
00442         
00443 private:
00444         
00445         ClassDef(RooFourMuMassRes,1) // Your description goes here...                                                                                             
00446 };
00447 
00448 class RooFourEMassRes : public RooAbsPdf {
00449 public:
00450         RooFourEMassRes() {} ;
00451         RooFourEMassRes(const char *name, const char *title,
00452                                         RooAbsReal& _m4l,
00453                                         RooAbsReal& _mH);
00454         RooFourEMassRes(const RooFourEMassRes& other, const char* name=0) ;
00455         virtual TObject* clone(const char* newname) const { return new RooFourEMassRes(*this,newname); }
00456         inline virtual ~RooFourEMassRes() { }
00457         
00458 protected:
00459         
00460         RooRealProxy m4l ;
00461         RooRealProxy mH  ;
00462         
00463         Double_t evaluate() const ;
00464         
00465 private:
00466         
00467         ClassDef(RooFourEMassRes,1) // Your description goes here...                                                                                              
00468 };
00469 
00470 
00471 class RooTwoETwoMuMassRes : public RooAbsPdf {
00472 public:
00473         RooTwoETwoMuMassRes() {} ;
00474         RooTwoETwoMuMassRes(const char *name, const char *title,
00475                                                 RooAbsReal& _m4l,
00476                                                 RooAbsReal& _mH);
00477         RooTwoETwoMuMassRes(const RooTwoETwoMuMassRes& other, const char* name=0) ;
00478         virtual TObject* clone(const char* newname) const { return new RooTwoETwoMuMassRes(*this,newname); }
00479         inline virtual ~RooTwoETwoMuMassRes() { }
00480         
00481 protected:
00482         
00483         RooRealProxy m4l ;
00484         RooRealProxy mH  ;
00485         
00486         
00487         Double_t evaluate() const ;
00488         
00489 private:
00490         
00491         ClassDef(RooTwoETwoMuMassRes,1) // Your description goes here...                                                                                          
00492 };
00493 
00494 class RooRelBW1 : public RooAbsPdf {
00495 public:
00496         RooRelBW1() {} ;
00497         RooRelBW1(const char *name, const char *title,
00498                           RooAbsReal& _m,
00499                           RooAbsReal& _mean,
00500                           RooAbsReal& _gamma);
00501         RooRelBW1(const RooRelBW1& other, const char* name=0) ;
00502         virtual TObject* clone(const char* newname) const { return new RooRelBW1(*this,newname); }
00503         inline virtual ~RooRelBW1() { }
00504         
00505 protected:
00506         
00507         RooRealProxy m ;
00508         RooRealProxy mean ;
00509         RooRealProxy gamma ;
00510         
00511         Double_t evaluate() const ;
00512         
00513 private:
00514         
00515         ClassDef(RooRelBW1,1) // Your description goes here...                                                                                                    
00516 };
00517 
00519 
00520 class RooRelBWUF : public RooAbsPdf {
00521 public:
00522         RooRelBWUF() {} ;
00523         RooRelBWUF(const char *name, const char *title,
00524                           RooAbsReal& _m4l,
00525                           RooAbsReal& _mH);
00526         RooRelBWUF(const RooRelBWUF& other, const char* name=0) ;
00527         virtual TObject* clone(const char* newname) const { return new RooRelBWUF(*this,newname); }
00528         inline virtual ~RooRelBWUF() { }
00529         
00530 protected:
00531         
00532         RooRealProxy m4l ;
00533         RooRealProxy mH ;
00534         
00535         Double_t evaluate() const ;
00536         
00537 private:
00538         
00539         ClassDef(RooRelBWUF,2) // Your description goes here...                                                                                                    
00540 };
00541 
00542 
00544 
00545 class RooRelBWUF_SM4 : public RooAbsPdf {
00546 public:
00547         RooRelBWUF_SM4() {} ;
00548         RooRelBWUF_SM4(const char *name, const char *title,
00549                           RooAbsReal& _m4l,
00550                           RooAbsReal& _mH);
00551         RooRelBWUF_SM4(const RooRelBWUF_SM4& other, const char* name=0) ;
00552         virtual TObject* clone(const char* newname) const { return new RooRelBWUF_SM4(*this,newname); }
00553         inline virtual ~RooRelBWUF_SM4() { }
00554         
00555 protected:
00556         
00557         RooRealProxy m4l ;
00558         RooRealProxy mH ;
00559         
00560         Double_t evaluate() const ;
00561         
00562 private:
00563         
00564         ClassDef(RooRelBWUF_SM4,2) // Your description goes here...                                                                                                    
00565 };
00566 
00567 
00569 
00570 class RooRelBWUFParam : public RooAbsPdf {
00571 public:
00572         RooRelBWUFParam() {} ;
00573         RooRelBWUFParam(const char *name, const char *title,
00574                                         RooAbsReal& _m4l,
00575                                         RooAbsReal& _mH,
00576                                         RooAbsReal& _scaleParam);
00577         RooRelBWUFParam(const RooRelBWUFParam& other, const char* name=0) ;
00578         virtual TObject* clone(const char* newname) const { return new RooRelBWUFParam(*this,newname); }
00579         inline virtual ~RooRelBWUFParam() { }
00580         
00581 protected:
00582         
00583         RooRealProxy m4l ;
00584         RooRealProxy mH ;
00585         RooRealProxy scaleParam ;
00586         
00587         Double_t evaluate() const ;
00588         
00589 private:
00590         
00591         ClassDef(RooRelBWUFParam,2) // Your description goes here...                                                                                                    
00592 };
00593 
00594 
00595 
00596 #endif
/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_5_3_14/src/HiggsAnalysis/CombinedLimit/interface/HZZ4LRooPdfs.h
