CMS 3D CMS Logo

/afs/cern.ch/work/a/aaltunda/public/www/CMSSW_6_2_5/src/DQMOffline/Ecal/src/EcalZmassClient.cc

Go to the documentation of this file.
00001 // -*- C++ -*-
00002 //
00003 // Package:    ZfitterAnalyzer
00004 // Class:      ZfitterAnalyzer
00005 // 
00013 //
00014 // Original Author:  Vieri Candelise
00015 //         Created:  Mon Jun 13 09:49:08 CEST 2011
00016 // $Id: EcalZmassClient.cc,v 1.3 2013/05/10 22:01:23 yiiyama Exp $
00017 //
00018 //
00019 
00020 
00021 // system include files
00022 #include <memory>
00023 
00024 // user include files
00025 #include "FWCore/Framework/interface/Frameworkfwd.h"
00026 #include "FWCore/Framework/interface/EDAnalyzer.h"
00027 #include "FWCore/ServiceRegistry/interface/Service.h"
00028 #include "FWCore/Framework/interface/Event.h"
00029 #include "FWCore/Framework/interface/MakerMacros.h"
00030 #include "DQM/Physics/src/EwkDQM.h"
00031 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00032 #include "TMath.h"
00033 #include <string>
00034 #include <cmath>
00035 #include "TH1.h"
00036 #include "DQMServices/Core/interface/DQMStore.h"
00037 #include "DQMServices/Core/interface/MonitorElement.h"
00038 #include "FWCore/Framework/interface/MakerMacros.h"
00039 #include "FWCore/Framework/interface/EventSetup.h"
00040 #include <iostream>
00041 #include "FWCore/ParameterSet/interface/ParameterSet.h"
00042 #include "FWCore/Utilities/interface/Exception.h"
00043 
00044 class DQMStore;
00045 class MonitorElement;
00046 
00047 //
00048 // class declaration
00049 //
00050 
00051 class EcalZmassClient:public
00052   edm::EDAnalyzer
00053 {
00054 public:
00055   explicit
00056   EcalZmassClient (const edm::ParameterSet &);
00057    ~
00058   EcalZmassClient ();
00059 
00060   static void
00061   fillDescriptions (edm::ConfigurationDescriptions & descriptions);
00062 
00063 
00064 private:
00065   virtual void
00066   beginJob ();
00067   virtual void
00068   analyze (const edm::Event &, const edm::EventSetup &);
00069   virtual void
00070   endJob ();
00071 
00072   virtual void
00073   beginRun (edm::Run const &, edm::EventSetup const &);
00074   virtual void
00075   endRun (edm::Run const &, edm::EventSetup const &);
00076   virtual void
00077   beginLuminosityBlock (edm::LuminosityBlock const &,
00078                         edm::EventSetup const &);
00079   virtual void
00080   endLuminosityBlock (edm::LuminosityBlock const &, edm::EventSetup const &);
00081 
00082   // ----------member data ---------------------------
00083 
00084   std::string prefixME_;
00085 
00086   MonitorElement *
00087     h_ee_invMass_EB;
00088   MonitorElement *
00089     h_ee_invMass_EE;
00090   MonitorElement *
00091     h_ee_invMass_BB;
00092   MonitorElement *
00093     h_95_ee_invMass_EB;
00094   MonitorElement *
00095     h_95_ee_invMass_EE;
00096   MonitorElement *
00097     h_95_ee_invMass_BB;
00098   MonitorElement *
00099     h_ee_invMass;
00100   MonitorElement *
00101     h_e1_et;
00102   MonitorElement *
00103     h_e2_et;
00104   MonitorElement *
00105     h_e1_eta;
00106   MonitorElement *
00107     h_e2_eta;
00108   MonitorElement *
00109     h_e1_phi;
00110   MonitorElement *
00111     h_e2_phi;
00112   MonitorElement *
00113     h_fitres1;
00114   MonitorElement *
00115     h_fitres1bis;
00116   MonitorElement *
00117     h_fitres1Chi2;
00118   MonitorElement *
00119     h_fitres2;
00120   MonitorElement *
00121     h_fitres2bis;
00122   MonitorElement *
00123     h_fitres2Chi2;
00124   MonitorElement *
00125     h_fitres3;
00126   MonitorElement *
00127     h_fitres3bis;
00128   MonitorElement *
00129     h_fitres3Chi2;
00130 
00131 
00132 };
00133 
00134 EcalZmassClient::EcalZmassClient (const edm::ParameterSet & iConfig)
00135 {
00136   prefixME_ = iConfig.getUntrackedParameter < std::string > ("prefixME", "");
00137 
00138 }
00139 
00140 
00141 EcalZmassClient::~EcalZmassClient ()
00142 {
00143 
00144   // do anything here that needs to be done at desctruction time
00145   // (e.g. close files, deallocate resources etc.)
00146 
00147 }
00148 
00149 
00150 //
00151 // member functions
00152 //
00153 
00154 // ------------ method called for each event  ------------
00155 void
00156 EcalZmassClient::analyze (const edm::Event & iEvent,
00157                           const edm::EventSetup & iSetup)
00158 {
00159 
00160 }
00161 
00162 
00163 // ------------ method called once each job just before starting event loop  ------------
00164 void
00165 EcalZmassClient::beginJob ()
00166 {
00167 }
00168 
00169 // ------------ method called once each job just after ending the event loop  ------------
00170 void
00171 EcalZmassClient::endJob ()
00172 {
00173 }
00174 
00175 // ------------ method called when starting to processes a run  ------------
00176 void
00177 EcalZmassClient::beginRun (edm::Run const &, edm::EventSetup const &)
00178 {
00179   DQMStore *theDbe = edm::Service < DQMStore > ().operator-> ();
00180 
00181   theDbe->setCurrentFolder (prefixME_ + "/Zmass");
00182   h_fitres1 =
00183     theDbe->book1D ("Gaussian mean WP80 EB-EB",
00184                     "Gaussian mean WP80 EB-EB", 1, 0, 1);
00185   h_fitres1bis =
00186     theDbe->book1D ("Gaussian sigma WP80 EB-EB",
00187                     "Gaussian sigma WP80 EB-EB", 1, 0, 1);
00188   h_fitres1Chi2 =
00189     theDbe->book1D ("Gaussian Chi2 result over NDF  WP80 EB-EB",
00190                     "Gaussian Chi2 result over NDF  WP80 EB-EB", 1, 0, 1);
00191 
00192   h_fitres3 =
00193     theDbe->book1D ("Gaussian mean WP80 EB-EE",
00194                     "Gaussian mean result WP80 EB-EE", 1, 0, 1);
00195   h_fitres3bis =
00196     theDbe->book1D ("Gaussian sigma WP80 EB-EE",
00197                     "Gaussian sigma WP80 EB-EE", 1, 0, 1);
00198   h_fitres3Chi2 =
00199     theDbe->book1D ("Gaussian Chi2 result over NDF WP80 EB-EE",
00200                     "Gaussian Chi2 result over NDF WP80 EB-EE", 1, 0, 1);
00201 
00202   h_fitres2 =
00203     theDbe->book1D ("Gaussian mean WP80 EE-EE",
00204                     "Gaussian mean WP80 EE-EE", 1, 0, 1);
00205   h_fitres2bis =
00206     theDbe->book1D ("Gaussian sigma WP80 EE-EE",
00207                     "Gaussian sigma WP80 EE-EE", 1, 0, 1);
00208   h_fitres2Chi2 =
00209     theDbe->book1D ("Gaussian Chi2 result over NDF WP80 EE-EE",
00210                     "Gaussian Chi2 result over NDF WP80 EE-EE", 1, 0, 1);
00211 }
00212 
00213 
00214 //Breit-Wigner function
00215 Double_t
00216 mybw (Double_t * x, Double_t * par)
00217 {
00218   Double_t arg1 = 14.0 / 22.0;  // 2 over pi
00219   Double_t arg2 = par[1] * par[1] * par[2] * par[2];    //Gamma=par[2]  M=par[1]
00220   Double_t arg3 =
00221     ((x[0] * x[0]) - (par[1] * par[1])) * ((x[0] * x[0]) - (par[1] * par[1]));
00222   Double_t arg4 =
00223     x[0] * x[0] * x[0] * x[0] * ((par[2] * par[2]) / (par[1] * par[1]));
00224   return par[0] * arg1 * arg2 / (arg3 + arg4);
00225 }
00226 
00227 //Gaussian
00228 Double_t
00229 mygauss (Double_t * x, Double_t * par)
00230 {
00231   Double_t arg = 0;
00232   if (par[2] < 0)
00233     par[2] = -par[2];           // par[2]: sigma
00234   if (par[2] != 0)
00235     arg = (x[0] - par[1]) / par[2];     // par[1]: mean
00236   return par[0] * TMath::Exp (-0.5 * arg * arg) / (TMath::Sqrt (2 * TMath::Pi ()) * par[2]);    // par[0] is constant
00237 
00238 }
00239 
00240 
00241 
00242 // ------------ method called when ending the processing of a run  ------------
00243 void
00244 EcalZmassClient::endRun (edm::Run const &, edm::EventSetup const &)
00245 {
00246   DQMStore *theDbe = edm::Service < DQMStore > ().operator-> ();
00247 
00248   LogTrace ("EwkAnalyzer") << "Parameters initialization";
00249 
00250   MonitorElement *me1 = theDbe->get (prefixME_ + "/Zmass/Z peak - WP80 EB-EB");
00251   MonitorElement *me2 = theDbe->get (prefixME_ + "/Zmass/Z peak - WP80 EE-EE");
00252   MonitorElement *me3 = theDbe->get (prefixME_ + "/Zmass/Z peak - WP80 EB-EE");
00253 
00254 
00255   if (me1 != 0)
00256     {
00257       TH1F *B = me1->getTH1F ();
00258       TH1F *R1 = h_fitres1->getTH1F ();
00259       int division = B->GetNbinsX ();
00260       float massMIN = B->GetBinLowEdge (1);
00261       float massMAX = B->GetBinLowEdge (division + 1);
00262       //float BIN_SIZE = B->GetBinWidth(1);
00263 
00264       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00265       func->SetParameter (0, 1.0);
00266       func->SetParName (0, "const");
00267       func->SetParameter (1, 95.0);
00268       func->SetParName (1, "mean");
00269       func->SetParameter (2, 5.0);
00270       func->SetParName (2, "sigma");
00271 
00272       double stats[4];
00273       R1->GetStats (stats);
00274       float N = 0;
00275       float mean = 0;
00276       float sigma = 0;
00277       N = B->GetEntries ();
00278 
00279       try
00280       {
00281         if (N != 0)
00282           {
00283 
00284             B->Fit ("mygauss", "QR");
00285             mean = fabs (func->GetParameter (1));
00286             sigma = fabs (func->GetParError (1));
00287           }
00288 
00289         if (N == 0 || mean < 50 || mean > 100 || sigma <= 0 || sigma > 20)
00290           {
00291             N = 1;
00292             mean = 0;
00293             sigma = 0;
00294           }
00295 
00296       }
00297       catch (cms::Exception& e)
00298       {
00299         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00300         N = 1;
00301         mean = 40;
00302         sigma = 0;
00303       }
00304 
00305       stats[0] = N;
00306       stats[1] = N;
00307       stats[2] = mean * N;
00308       stats[3] = sigma * sigma * N + mean * mean * N;
00309 
00310       R1->SetEntries (N);
00311       R1->PutStats (stats);
00312     }
00313 /*******************************************************/
00314   if (me1 != 0)
00315     {
00316       TH1F *Bbis = me1->getTH1F ();
00317       TH1F *R1bis = h_fitres1bis->getTH1F ();
00318       int division = Bbis->GetNbinsX ();
00319       float massMIN = Bbis->GetBinLowEdge (1);
00320       float massMAX = Bbis->GetBinLowEdge (division + 1);
00321       //float BIN_SIZE = B->GetBinWidth(1);
00322 
00323       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00324       func->SetParameter (0, 1.0);
00325       func->SetParName (0, "const");
00326       func->SetParameter (1, 95.0);
00327       func->SetParName (1, "mean");
00328       func->SetParameter (2, 5.0);
00329       func->SetParName (2, "sigma");
00330 
00331       double stats[4];
00332       R1bis->GetStats (stats);
00333       float N = 0;
00334       float rms = 0;
00335       float rmsErr = 0;
00336       N = Bbis->GetEntries ();
00337 
00338       try
00339       {
00340         if (N != 0)
00341           {
00342 
00343             Bbis->Fit ("mygauss", "QR");
00344             rms = fabs (func->GetParameter (2));
00345             rmsErr = fabs (func->GetParError (2));
00346           }
00347 
00348         if (N == 0 || rms < 0 || rms > 50 || rmsErr <= 0 || rmsErr > 50)
00349           {
00350             N = 1;
00351             rms = 0;
00352             rmsErr = 0;
00353           }
00354 
00355       }
00356       catch (cms::Exception& e)
00357       {
00358         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00359         N = 1;
00360         rms = 40;
00361         rmsErr = 0;
00362       }
00363 
00364       stats[0] = N;
00365       stats[1] = N;
00366       stats[2] = rms * N;
00367       stats[3] = rmsErr * rmsErr * N + rms * rms * N;
00368 
00369       R1bis->SetEntries (N);
00370       R1bis->PutStats (stats);
00371     }
00372 /****************************************/
00373 
00374   if (me2 != 0)
00375     {
00376       TH1F *E = me2->getTH1F ();
00377       TH1F *R2 = h_fitres2->getTH1F ();
00378       int division = E->GetNbinsX ();
00379       float massMIN = E->GetBinLowEdge (1);
00380       float massMAX = E->GetBinLowEdge (division + 1);
00381       //float BIN_SIZE = E->GetBinWidth(1);
00382 
00383       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00384       func->SetParameter (0, 1.0);
00385       func->SetParName (0, "const");
00386       func->SetParameter (1, 95.0);
00387       func->SetParName (1, "mean");
00388       func->SetParameter (2, 5.0);
00389       func->SetParName (2, "sigma");
00390 
00391       double stats[4];
00392       R2->GetStats (stats);
00393       float N = 0;
00394       float mean = 0;
00395       float sigma = 0;
00396       N = E->GetEntries ();
00397 
00398       try
00399       {
00400         if (N != 0)
00401           {
00402             E->Fit ("mygauss", "QR");
00403             mean = fabs (func->GetParameter (1));
00404             sigma = fabs (func->GetParError (1));
00405           }
00406 
00407         if (N == 0 || mean < 50 || mean > 100 || sigma <= 0 || sigma > 20)
00408           {
00409             N = 1;
00410             mean = 0;
00411             sigma = 0;
00412 
00413           }
00414 
00415       }
00416       catch (cms::Exception& e)
00417       {
00418         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00419         N = 1;
00420         mean = 40;
00421         sigma = 0;
00422       }
00423 
00424       stats[0] = N;
00425       stats[1] = N;
00426       stats[2] = mean * N;
00427       stats[3] = sigma * sigma * N + mean * mean * N;
00428 
00429       R2->SetEntries (N);
00430       R2->PutStats (stats);
00431     }
00432 /**************************************************************************/
00433 
00434   if (me2 != 0)
00435     {
00436       TH1F *Ebis = me2->getTH1F ();
00437       TH1F *R2bis = h_fitres2bis->getTH1F ();
00438       int division = Ebis->GetNbinsX ();
00439       float massMIN = Ebis->GetBinLowEdge (1);
00440       float massMAX = Ebis->GetBinLowEdge (division + 1);
00441       //float BIN_SIZE = B->GetBinWidth(1);
00442 
00443       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00444       func->SetParameter (0, 1.0);
00445       func->SetParName (0, "const");
00446       func->SetParameter (1, 95.0);
00447       func->SetParName (1, "mean");
00448       func->SetParameter (2, 5.0);
00449       func->SetParName (2, "sigma");
00450 
00451       double stats[4];
00452       R2bis->GetStats (stats);
00453       float N = 0;
00454       float rms = 0;
00455       float rmsErr = 0;
00456       N = Ebis->GetEntries ();
00457 
00458       try
00459       {
00460         if (N != 0)
00461           {
00462 
00463             Ebis->Fit ("mygauss", "QR");
00464             rms = fabs (func->GetParameter (2));
00465             rmsErr = fabs (func->GetParError (2));
00466           }
00467 
00468         if (N == 0 || rms < 0 || rms > 50 || rmsErr <= 0 || rmsErr > 50)
00469           {
00470             N = 1;
00471             rms = 0;
00472             rmsErr = 0;
00473           }
00474 
00475       }
00476       catch (cms::Exception& e)
00477       {
00478         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00479         N = 1;
00480         rms = 40;
00481         rmsErr = 0;
00482       }
00483 
00484       stats[0] = N;
00485       stats[1] = N;
00486       stats[2] = rms * N;
00487       stats[3] = rmsErr * rmsErr * N + rms * rms * N;
00488 
00489       R2bis->SetEntries (N);
00490       R2bis->PutStats (stats);
00491     }
00492 /*********************************************************************************************/
00493 
00494   if (me3 != 0)
00495     {
00496       TH1F *R3 = h_fitres3->getTH1F ();
00497       TH1F *M = me3->getTH1F ();
00498       int division = M->GetNbinsX ();
00499       float massMIN = M->GetBinLowEdge (1);
00500       float massMAX = M->GetBinLowEdge (division + 1);
00501       //float BIN_SIZE = M->GetBinWidth(1);
00502 
00503       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00504       func->SetParameter (0, 1.0);
00505       func->SetParName (0, "const");
00506       func->SetParameter (1, 95.0);
00507       func->SetParName (1, "mean");
00508       func->SetParameter (2, 5.0);
00509       func->SetParName (2, "sigma");
00510 
00511       double stats[4];
00512       R3->GetStats (stats);
00513       float N = 0;
00514       float mean = 0;
00515       float sigma = 0;
00516       N = M->GetEntries ();
00517 
00518 
00519       try
00520       {
00521         if (N != 0)
00522           {
00523 
00524             M->Fit ("mygauss", "QR");
00525             mean = fabs (func->GetParameter (1));
00526             sigma = fabs (func->GetParError (1));
00527           }
00528         if (N == 0 || mean < 50 || mean > 100 || sigma <= 0 || sigma > 20)
00529           {
00530             N = 1;
00531             mean = 0;
00532             sigma = 0;
00533           }
00534 
00535       }
00536       catch (cms::Exception& e)
00537       {
00538         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00539         N = 1;
00540         mean = 40;
00541         sigma = 0;
00542       }
00543 
00544       stats[0] = N;
00545       stats[1] = N;
00546       stats[2] = mean * N;
00547       stats[3] = sigma * sigma * N + mean * mean * N;
00548 
00549       R3->SetEntries (N);
00550       R3->PutStats (stats);
00551     }
00552   /********************************************************************************/
00553 
00554   if (me3 != 0)
00555     {
00556       TH1F *Mbis = me3->getTH1F ();
00557       TH1F *R3bis = h_fitres3bis->getTH1F ();
00558       int division = Mbis->GetNbinsX ();
00559       float massMIN = Mbis->GetBinLowEdge (1);
00560       float massMAX = Mbis->GetBinLowEdge (division + 1);
00561       //float BIN_SIZE = B->GetBinWidth(1);
00562 
00563       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00564       func->SetParameter (0, 1.0);
00565       func->SetParName (0, "const");
00566       func->SetParameter (1, 95.0);
00567       func->SetParName (1, "mean");
00568       func->SetParameter (2, 5.0);
00569       func->SetParName (2, "sigma");
00570 
00571       double stats[4];
00572       R3bis->GetStats (stats);
00573       float N = 0;
00574       float rms = 0;
00575       float rmsErr = 0;
00576       N = Mbis->GetEntries ();
00577 
00578       try
00579       {
00580         if (N != 0)
00581           {
00582 
00583             Mbis->Fit ("mygauss", "QR");
00584             rms = fabs (func->GetParameter (2));
00585             rmsErr = fabs (func->GetParError (2));
00586           }
00587 
00588         if (N == 0 || rms < 0 || rms > 50 || rmsErr <= 0 || rmsErr > 50)
00589           {
00590             N = 1;
00591             rms = 0;
00592             rmsErr = 0;
00593           }
00594 
00595       }
00596       catch (cms::Exception& e)
00597       {
00598         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00599         N = 1;
00600         rms = 40;
00601         rmsErr = 0;
00602       }
00603 
00604       stats[0] = N;
00605       stats[1] = N;
00606       stats[2] = rms * N;
00607       stats[3] = rmsErr * rmsErr * N + rms * rms * N;
00608 
00609       R3bis->SetEntries (N);
00610       R3bis->PutStats (stats);
00611     }
00612 
00613   /*Chi2 */
00614 
00615   if (me1 != 0)
00616     {
00617       TH1F *C1 = me1->getTH1F ();
00618       TH1F *S1 = h_fitres1Chi2->getTH1F ();
00619       int division = C1->GetNbinsX ();
00620       float massMIN = C1->GetBinLowEdge (1);
00621       float massMAX = C1->GetBinLowEdge (division + 1);
00622       //float BIN_SIZE = B->GetBinWidth(1);
00623 
00624       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00625       func->SetParameter (0, 1.0);
00626       func->SetParName (0, "const");
00627       func->SetParameter (1, 95.0);
00628       func->SetParName (1, "mean");
00629       func->SetParameter (2, 5.0);
00630       func->SetParName (2, "sigma");
00631 
00632       double stats[4];
00633       S1->GetStats (stats);
00634       float N = 0;
00635       float Chi2 = 0;
00636       float NDF = 0;
00637       N = C1->GetEntries ();
00638 
00639       try
00640       {
00641         if (N != 0)
00642           {
00643 
00644             C1->Fit ("mygauss", "QR");
00645             if ((func->GetNDF () != 0))
00646               {
00647                 Chi2 = fabs (func->GetChisquare ()) / fabs (func->GetNDF ());
00648                 NDF = 0.1;
00649               }
00650           }
00651 
00652         if (N == 0 || Chi2 < 0 || NDF < 0)
00653           {
00654             N = 1;
00655             Chi2 = 0;
00656             NDF = 0;
00657           }
00658 
00659       }
00660       catch (cms::Exception& e)
00661       {
00662         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00663         N = 1;
00664         Chi2 = 40;
00665         NDF = 0;
00666       }
00667 
00668       stats[0] = N;
00669       stats[1] = N;
00670       stats[2] = Chi2 * N;
00671       stats[3] = NDF * NDF * N + Chi2 * Chi2 * N;
00672 
00673       S1->SetEntries (N);
00674       S1->PutStats (stats);
00675     }
00676   /**********************************************/
00677 
00678   if (me2 != 0)
00679     {
00680       TH1F *C2 = me2->getTH1F ();
00681       TH1F *S2 = h_fitres2Chi2->getTH1F ();
00682       int division = C2->GetNbinsX ();
00683       float massMIN = C2->GetBinLowEdge (1);
00684       float massMAX = C2->GetBinLowEdge (division + 1);
00685       //float BIN_SIZE = B->GetBinWidth(1);
00686 
00687       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00688       func->SetParameter (0, 1.0);
00689       func->SetParName (0, "const");
00690       func->SetParameter (1, 95.0);
00691       func->SetParName (1, "mean");
00692       func->SetParameter (2, 5.0);
00693       func->SetParName (2, "sigma");
00694 
00695       double stats[4];
00696       S2->GetStats (stats);
00697       float N = 0;
00698       float Chi2 = 0;
00699       float NDF = 0;
00700       N = C2->GetEntries ();
00701 
00702       try
00703       {
00704         if (N != 0)
00705           {
00706             C2->Fit ("mygauss", "QR");
00707             if (func->GetNDF () != 0)
00708               {
00709                 Chi2 = fabs (func->GetChisquare ()) / fabs (func->GetNDF ());
00710                 NDF = 0.1;
00711               }
00712           }
00713 
00714         if (N == 0 || Chi2 < 0 || NDF < 0)
00715           {
00716             N = 1;
00717             Chi2 = 0;
00718             NDF = 0;
00719           }
00720 
00721       }
00722       catch (cms::Exception& e)
00723       {
00724         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00725         N = 1;
00726         Chi2 = 40;
00727         NDF = 0;
00728       }
00729 
00730       stats[0] = N;
00731       stats[1] = N;
00732       stats[2] = Chi2 * N;
00733       stats[3] = NDF * NDF * N + Chi2 * Chi2 * N;
00734 
00735       S2->SetEntries (N);
00736       S2->PutStats (stats);
00737     }
00738   /**************************************************************************/
00739   if (me3 != 0)
00740     {
00741       TH1F *C3 = me3->getTH1F ();
00742       TH1F *S3 = h_fitres3Chi2->getTH1F ();
00743       int division = C3->GetNbinsX ();
00744       float massMIN = C3->GetBinLowEdge (1);
00745       float massMAX = C3->GetBinLowEdge (division + 1);
00746       //float BIN_SIZE = B->GetBinWidth(1);
00747 
00748       TF1 *func = new TF1 ("mygauss", mygauss, massMIN, massMAX, 3);
00749       func->SetParameter (0, 1.0);
00750       func->SetParName (0, "const");
00751       func->SetParameter (1, 95.0);
00752       func->SetParName (1, "mean");
00753       func->SetParameter (2, 5.0);
00754       func->SetParName (2, "sigma");
00755 
00756       double stats[4];
00757       S3->GetStats (stats);
00758       float N = 0;
00759       float Chi2 = 0;
00760       float NDF = 0;
00761       N = C3->GetEntries ();
00762 
00763       try
00764       {
00765         if (N != 0)
00766           {
00767             C3->Fit ("mygauss", "QR");
00768             if ((func->GetNDF () != 0))
00769               {
00770                 Chi2 = fabs (func->GetChisquare ()) / fabs (func->GetNDF ());
00771                 NDF = 0.1;
00772               }
00773           }
00774 
00775 
00776         if (N == 0 || Chi2 < 0 || NDF < 0)
00777           {
00778             N = 1;
00779             Chi2 = 0;
00780             NDF = 0;
00781           }
00782 
00783       }
00784       catch (cms::Exception& e)
00785       {
00786         edm::LogError ("ZFitter") << "[Zfitter]: Exception when fitting..." << e.what();
00787         N = 1;
00788         Chi2 = 40;
00789         NDF = 0;
00790       }
00791 
00792       stats[0] = N;
00793       stats[1] = N;
00794       stats[2] = Chi2 * N;
00795       stats[3] = NDF * NDF * N + Chi2 * Chi2 * N;
00796 
00797       S3->SetEntries (N);
00798       S3->PutStats (stats);
00799     }
00800 }
00801 
00802         // ------------ method called when starting to processes a luminosity block  ------------
00803 void
00804 EcalZmassClient::beginLuminosityBlock (edm::LuminosityBlock const &,
00805                                        edm::EventSetup const &)
00806 {
00807 }
00808 
00809         // ------------ method called when ending the processing of a luminosity block  ------------
00810 void
00811 EcalZmassClient::endLuminosityBlock (edm::LuminosityBlock const &,
00812                                      edm::EventSetup const &)
00813 {
00814 }
00815 
00816         // ------------ method fills 'descriptions' with the allowed parameters for the module  ------------
00817 void
00818 EcalZmassClient::fillDescriptions (edm::
00819                                    ConfigurationDescriptions & descriptions)
00820 {
00821   //The following says we do not know what parameters are allowed so do no validation
00822   // Please change this to state exactly what you do use, even if it is no parameters
00823   edm::ParameterSetDescription desc;
00824   desc.setUnknown ();
00825   descriptions.addDefault (desc);
00826 }
00827 
00828         //define this as a plug-in
00829 DEFINE_FWK_MODULE (EcalZmassClient);