00001
00002
00003
00004
00005
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022 #include <memory>
00023
00024
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
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
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
00145
00146
00147 }
00148
00149
00150
00151
00152
00153
00154
00155 void
00156 EcalZmassClient::analyze (const edm::Event & iEvent,
00157 const edm::EventSetup & iSetup)
00158 {
00159
00160 }
00161
00162
00163
00164 void
00165 EcalZmassClient::beginJob ()
00166 {
00167 }
00168
00169
00170 void
00171 EcalZmassClient::endJob ()
00172 {
00173 }
00174
00175
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
00215 Double_t
00216 mybw (Double_t * x, Double_t * par)
00217 {
00218 Double_t arg1 = 14.0 / 22.0;
00219 Double_t arg2 = par[1] * par[1] * par[2] * par[2];
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
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];
00234 if (par[2] != 0)
00235 arg = (x[0] - par[1]) / par[2];
00236 return par[0] * TMath::Exp (-0.5 * arg * arg) / (TMath::Sqrt (2 * TMath::Pi ()) * par[2]);
00237
00238 }
00239
00240
00241
00242
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
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
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
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
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
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
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
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
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
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
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
00803 void
00804 EcalZmassClient::beginLuminosityBlock (edm::LuminosityBlock const &,
00805 edm::EventSetup const &)
00806 {
00807 }
00808
00809
00810 void
00811 EcalZmassClient::endLuminosityBlock (edm::LuminosityBlock const &,
00812 edm::EventSetup const &)
00813 {
00814 }
00815
00816
00817 void
00818 EcalZmassClient::fillDescriptions (edm::
00819 ConfigurationDescriptions & descriptions)
00820 {
00821
00822
00823 edm::ParameterSetDescription desc;
00824 desc.setUnknown ();
00825 descriptions.addDefault (desc);
00826 }
00827
00828
00829 DEFINE_FWK_MODULE (EcalZmassClient);