Back to home page

Project CMSSW displayed by LXR
 
 

    

File indexing completed on 2023-05-10 03:53:10 

0001 // -*- C++ -*-
0002 //
0003 // Package:    Compare
0004 // Class:      Compare
0005 //
0006 /**\class Compare Compare.cc CalibMuon/Compare/src/Compare.cc
0007 
0008  Description: <one line class summary>
0009 
0010  Implementation:
0011      <Notes on implementation>
0012 */
0013 //
0014 // Original Author:  Thomas Nummy,Bld. 32 Room 4-C21,+41227671337,
0015 //         Created:  Thu Oct 29 13:55:15 CET 2009
0016 //
0017 //
0018 //////////////////////////////////READ THIS
0019 /// FIRST//////////////////////////////////////////////////////////
0020 //////////////////"std::bad_alloc exception caught in cmsRun" ERROR when you
0021 /// have text inside the .dat/////
0022 /////////////////files ---->Check them first before running this
0023 /// code!/////////////////////////////////////
0024 ///////////////////////////////////////////////////////////////////////////////////////////////////////////
0025 
0026 // system include files
0027 #include <fstream>
0028 #include <iostream>
0029 #include <memory>
0030 #include <string>
0031 #include <vector>
0032 
0033 // user include files
0034 #include "FWCore/Framework/interface/one/EDAnalyzer.h"
0035 #include "FWCore/Framework/interface/Frameworkfwd.h"
0036 
0037 #include "FWCore/Framework/interface/Event.h"
0038 #include "FWCore/Framework/interface/MakerMacros.h"
0039 
0040 #include "FWCore/ParameterSet/interface/ParameterSet.h"
0041 //
0042 // class decleration
0043 //
0044 
0045 class Compare : public edm::one::EDAnalyzer<> {
0046 public:
0047   explicit Compare(const edm::ParameterSet &);
0048   ~Compare() override = default;
0049 
0050 private:
0051   void analyze(const edm::Event &, const edm::EventSetup &) override;
0052 
0053   // ----------member data ---------------------------
0054 };
0055 
0056 //
0057 // constants, enums and typedefs
0058 //
0059 
0060 //
0061 // static data member definitions
0062 //
0063 
0064 //
0065 // constructors and destructor
0066 //
0067 Compare::Compare(const edm::ParameterSet &iConfig) {
0068   // now do what ever initialization is needed
0069   /*
0070 
0071 
0072   */
0073 
0074   //=========== Compare Pedestals =================
0075   std::cout << "Comparing PEDESTALS, please wait!" << std::endl;
0076 
0077   const int MAX_SIZE = 252288;
0078 
0079   int old_index;
0080   float old_ped, old_rms;
0081   std::vector<int> old_index_id;
0082   std::vector<float> old_peds;
0083   int new_index;
0084   float new_ped, new_rms;
0085   std::vector<int> new_index_id;
0086   std::vector<float> new_peds;
0087   std::vector<float> diffPeds;
0088   std::vector<float> diffGains;
0089 
0090   std::ifstream olddata;
0091   olddata.open("old_dbpeds.dat", std::ios::in);
0092   if (!olddata) {
0093     std::cerr << "Error: old_dbpeds.dat -> no such file!" << std::endl;
0094     exit(1);
0095   }
0096 
0097   while (!olddata.eof()) {
0098     olddata >> old_index >> old_ped >> old_rms;
0099     old_index_id.push_back(old_index);
0100     old_peds.push_back(old_ped);
0101   }
0102   olddata.close();
0103 
0104   std::ifstream newdata;
0105   std::ofstream myPedsFile("diffPedsTest.dat", std::ios::out);
0106   newdata.open("goodPeds.dat", std::ios::in);
0107   if (!newdata) {
0108     std::cerr << "Error: goodPeds.dat -> no such file!" << std::endl;
0109     exit(1);
0110   }
0111 
0112   while (!newdata.eof()) {
0113     newdata >> new_index >> new_ped >> new_rms;
0114     new_index_id.push_back(new_index);
0115     new_peds.push_back(new_ped);
0116   }
0117   newdata.close();
0118 
0119   diffPeds.resize(MAX_SIZE);
0120 
0121   for (int i = 0; i < MAX_SIZE; ++i) {
0122     for (unsigned int k = 0; k < new_index_id.size() - 1; ++k) {
0123       if (old_index_id[i] == new_index_id[k]) {
0124         diffPeds[k] = old_peds[i] / 10. - new_peds[k];
0125         myPedsFile << old_index_id[i] << "  " << diffPeds[k] << std::endl;
0126       }
0127     }
0128   }
0129 
0130   // ============= Compare Crosstalk ===================
0131   std::cout << "Comparing CROSSTALK, please wait!" << std::endl;
0132 
0133   old_index = 0;
0134   float old_xtalk_left, old_xtalk_right, old_int_left, old_int_right;
0135   old_index_id.clear();
0136   std::vector<float> old_Rxtalk;
0137   std::vector<float> old_Lxtalk;
0138   std::vector<float> old_Rint;
0139   std::vector<float> old_Lint;
0140   std::vector<float> diffXtalkR;
0141   std::vector<float> diffXtalkL;
0142   std::vector<float> diffIntR;
0143   std::vector<float> diffIntL;
0144 
0145   std::vector<float> myoldxtalkR;
0146   std::vector<float> myoldxtalkL;
0147   std::vector<float> myoldintR;
0148   std::vector<float> myoldintL;
0149 
0150   new_index = 0;
0151   float new_xtalk_left, new_xtalk_right, new_int_left, new_int_right;
0152   new_index_id.clear();
0153   std::vector<float> new_Rxtalk;
0154   std::vector<float> new_Lxtalk;
0155   std::vector<float> new_Rint;
0156   std::vector<float> new_Lint;
0157 
0158   int counter, counter1;
0159 
0160   std::ifstream olddata1;
0161   olddata1.open("old_dbxtalk.dat", std::ios::in);
0162   if (!olddata1) {
0163     std::cerr << "Error: old_dbxtalk.dat -> no such file!" << std::endl;
0164     exit(1);
0165   }
0166 
0167   while (!olddata1.eof()) {
0168     olddata1 >> old_index >> old_xtalk_left >> old_int_left >> old_xtalk_right >> old_int_right;
0169     old_index_id.push_back(old_index);
0170     old_Rxtalk.push_back(old_xtalk_right);
0171     old_Rint.push_back(old_int_right);
0172     old_Lxtalk.push_back(old_xtalk_left);
0173     old_Lint.push_back(old_int_left);
0174   }
0175   olddata1.close();
0176 
0177   std::ifstream newdata1;
0178   std::ofstream myXtalkFile("diffXtalkTest.dat", std::ios::out);
0179 
0180   newdata1.open("goodXtalk.dat", std::ios::in);
0181   if (!newdata1) {
0182     std::cerr << "Error: goodXtalk.dat  -> no such file!" << std::endl;
0183     exit(1);
0184   }
0185 
0186   while (!newdata1.eof()) {
0187     newdata1 >> new_index >> new_xtalk_left >> new_int_left >> new_xtalk_right >> new_int_right;
0188     new_index_id.push_back(new_index);
0189     new_Rxtalk.push_back(new_xtalk_right);
0190     new_Rint.push_back(new_int_right);
0191     new_Lxtalk.push_back(new_xtalk_left);
0192     new_Lint.push_back(new_int_left);
0193   }
0194   newdata1.close();
0195 
0196   diffXtalkR.resize(MAX_SIZE);
0197   diffXtalkL.resize(MAX_SIZE);
0198   diffIntR.resize(MAX_SIZE);
0199   diffIntL.resize(MAX_SIZE);
0200   myoldxtalkR.resize(MAX_SIZE);
0201   myoldxtalkL.resize(MAX_SIZE);
0202   myoldintR.resize(MAX_SIZE);
0203   myoldintR.resize(MAX_SIZE);
0204 
0205   for (int i = 0; i < MAX_SIZE; ++i) {
0206     counter = old_index_id[i];
0207     myoldxtalkR[i] = old_Rxtalk[i];
0208     myoldxtalkL[i] = old_Lxtalk[i];
0209     myoldintR[i] = old_Rint[i];
0210     myoldintR[i] = old_Lint[i];
0211 
0212     for (unsigned int k = 0; k < new_index_id.size() - 1; k++) {
0213       counter1 = new_index_id[k];
0214       if (counter == counter1) {
0215         diffXtalkR[k] = old_Rxtalk[i] / 10000000. - new_Rxtalk[k];
0216         diffXtalkL[k] = old_Lxtalk[i] / 10000000. - new_Lxtalk[k];
0217         diffIntR[k] = old_Rint[i] / 100000. - new_Rint[k];
0218         diffIntL[k] = old_Rint[i] / 100000. - new_Rint[k];
0219         myXtalkFile << counter << "  " << diffXtalkL[k] << "  " << diffIntL[k] << "  " << diffXtalkR[k] << "  "
0220                     << diffIntR[k] << "  " << std::endl;
0221       }
0222     }
0223   }
0224 
0225   // ================= Compare Gains ===============
0226   std::cout << "Comparing GAINS, please wait!" << std::endl;
0227 
0228   old_index = 0;
0229   float old_slope;
0230   old_index_id.clear();
0231   std::vector<float> old_gains;
0232   std::vector<float> old_intercept;
0233   std::vector<float> old_chi;
0234 
0235   new_index = 0;
0236   float new_slope, new_int, new_chi2;
0237   new_index_id.clear();
0238   std::vector<float> new_gains;
0239   std::vector<float> new_intercept;
0240   std::vector<float> new_chi;
0241 
0242   std::vector<float> myoldgains;
0243 
0244   counter = 0;
0245   counter1 = 0;
0246 
0247   std::ifstream olddata2;
0248   olddata2.open("old_dbgains.dat", std::ios::in);
0249   if (!olddata2) {
0250     std::cerr << "Error: old_dbgains.dat -> no such file!" << std::endl;
0251     exit(1);
0252   }
0253 
0254   while (!olddata2.eof()) {
0255     olddata2 >> old_index >> old_slope;
0256     old_index_id.push_back(old_index);
0257     old_gains.push_back(old_slope);
0258   }
0259   olddata2.close();
0260 
0261   std::ifstream newdata2;
0262   std::ofstream myGainsFile("diffGainsTest.dat", std::ios::out);
0263   newdata2.open("goodGains.dat", std::ios::in);
0264   if (!newdata2) {
0265     std::cerr << "Error: goodGains.dat -> no such file!" << std::endl;
0266     exit(1);
0267   }
0268 
0269   while (!newdata2.eof()) {
0270     newdata2 >> new_index >> new_slope >> new_int >> new_chi2;
0271     new_index_id.push_back(new_index);
0272     new_gains.push_back(new_slope);
0273     new_intercept.push_back(new_int);
0274     new_chi.push_back(new_chi2);
0275   }
0276   newdata2.close();
0277   diffGains.resize(MAX_SIZE);
0278   myoldgains.resize(MAX_SIZE);
0279 
0280   for (int i = 0; i < MAX_SIZE; ++i) {
0281     counter = old_index_id[i];
0282     myoldgains[i] = old_gains[i];
0283 
0284     for (unsigned int k = 0; k < new_index_id.size() - 1; k++) {
0285       counter1 = new_index_id[k];
0286       if (counter == counter1) {
0287         diffGains[k] = old_gains[i] / 1000. - new_gains[k];
0288         myGainsFile << counter << "  " << diffGains[k] << std::endl;
0289       }
0290     }
0291   }
0292 
0293   //=================== Compare Noise Matrix ===============
0294   std::cout << "Comparing NOISE MATRIX, please wait!" << std::endl;
0295 
0296   old_index = 0;
0297   float old_elem33, old_elem34, old_elem35, old_elem44, old_elem45, old_elem46, old_elem55, old_elem56;
0298   float old_elem57, old_elem66, old_elem67, old_elem77;
0299   old_index_id.clear();
0300   std::vector<float> old_el33;
0301   std::vector<float> old_el34;
0302   std::vector<float> old_el35;
0303   std::vector<float> old_el44;
0304   std::vector<float> old_el45;
0305   std::vector<float> old_el46;
0306   std::vector<float> old_el55;
0307   std::vector<float> old_el56;
0308   std::vector<float> old_el57;
0309   std::vector<float> old_el66;
0310   std::vector<float> old_el67;
0311   std::vector<float> old_el77;
0312 
0313   new_index = 0;
0314   float new_elem33, new_elem34, new_elem35, new_elem44, new_elem45, new_elem46, new_elem55, new_elem56;
0315   float new_elem57, new_elem66, new_elem67, new_elem77;
0316   new_index_id.clear();
0317   std::vector<float> new_el33;
0318   std::vector<float> new_el34;
0319   std::vector<float> new_el35;
0320   std::vector<float> new_el44;
0321   std::vector<float> new_el45;
0322   std::vector<float> new_el46;
0323   std::vector<float> new_el55;
0324   std::vector<float> new_el56;
0325   std::vector<float> new_el57;
0326   std::vector<float> new_el66;
0327   std::vector<float> new_el67;
0328   std::vector<float> new_el77;
0329 
0330   // differences
0331   std::vector<float> diff_el33;
0332   std::vector<float> diff_el34;
0333   std::vector<float> diff_el35;
0334   std::vector<float> diff_el44;
0335   std::vector<float> diff_el45;
0336   std::vector<float> diff_el46;
0337   std::vector<float> diff_el55;
0338   std::vector<float> diff_el56;
0339   std::vector<float> diff_el57;
0340   std::vector<float> diff_el66;
0341   std::vector<float> diff_el67;
0342   std::vector<float> diff_el77;
0343 
0344   // old vectors
0345   std::vector<float> myoldel33;
0346   std::vector<float> myoldel34;
0347   std::vector<float> myoldel35;
0348   std::vector<float> myoldel44;
0349   std::vector<float> myoldel45;
0350   std::vector<float> myoldel46;
0351   std::vector<float> myoldel55;
0352   std::vector<float> myoldel56;
0353   std::vector<float> myoldel57;
0354   std::vector<float> myoldel66;
0355   std::vector<float> myoldel67;
0356   std::vector<float> myoldel77;
0357 
0358   counter = 0;
0359   counter1 = 0;
0360   // old_nrlines=0;
0361   // new_nrlines=0;
0362 
0363   std::ifstream olddata3;
0364   olddata3.open("old_dbmatrix.dat", std::ios::in);
0365   if (!olddata3) {
0366     std::cerr << "Error: old_dbmatrix.dat -> no such file!" << std::endl;
0367     exit(1);
0368   }
0369 
0370   while (!olddata3.eof()) {
0371     olddata3 >> old_index >> old_elem33 >> old_elem34 >> old_elem44 >> old_elem35 >> old_elem45 >> old_elem55 >>
0372         old_elem46 >> old_elem56 >> old_elem66 >> old_elem57 >> old_elem67 >> old_elem77;
0373     old_index_id.push_back(old_index);
0374     old_el33.push_back(old_elem33);
0375     old_el34.push_back(old_elem34);
0376     old_el35.push_back(old_elem35);
0377     old_el44.push_back(old_elem44);
0378     old_el45.push_back(old_elem45);
0379     old_el46.push_back(old_elem46);
0380     old_el55.push_back(old_elem55);
0381     old_el56.push_back(old_elem56);
0382     old_el57.push_back(old_elem57);
0383     old_el66.push_back(old_elem66);
0384     old_el67.push_back(old_elem67);
0385     old_el77.push_back(old_elem77);
0386     // old_nrlines++;
0387   }
0388   olddata3.close();
0389 
0390   std::ifstream newdata3;
0391   std::ofstream myMatrixFile("diffMatrixTest.dat", std::ios::out);
0392   newdata3.open("goodMatrix.dat", std::ios::in);
0393   if (!newdata3) {
0394     std::cerr << "Error: goodMatrix.dat -> no such file!" << std::endl;
0395     exit(1);
0396   }
0397 
0398   while (!newdata3.eof()) {
0399     newdata3 >> new_index >> new_elem33 >> new_elem34 >> new_elem44 >> new_elem35 >> new_elem45 >> new_elem55 >>
0400         new_elem46 >> new_elem56 >> new_elem66 >> new_elem57 >> new_elem67 >> new_elem77;
0401     new_index_id.push_back(new_index);
0402     new_el33.push_back(new_elem33);
0403     new_el34.push_back(new_elem34);
0404     new_el35.push_back(new_elem35);
0405     new_el44.push_back(new_elem44);
0406     new_el45.push_back(new_elem45);
0407     new_el46.push_back(new_elem46);
0408     new_el55.push_back(new_elem55);
0409     new_el56.push_back(new_elem56);
0410     new_el57.push_back(new_elem57);
0411     new_el66.push_back(new_elem66);
0412     new_el67.push_back(new_elem67);
0413     new_el77.push_back(new_elem77);
0414     // new_nrlines++;
0415   }
0416   newdata3.close();
0417 
0418   // resize
0419   diff_el33.resize(MAX_SIZE);
0420   diff_el34.resize(MAX_SIZE);
0421   diff_el35.resize(MAX_SIZE);
0422   diff_el44.resize(MAX_SIZE);
0423   diff_el45.resize(MAX_SIZE);
0424   diff_el46.resize(MAX_SIZE);
0425   diff_el55.resize(MAX_SIZE);
0426   diff_el56.resize(MAX_SIZE);
0427   diff_el57.resize(MAX_SIZE);
0428   diff_el66.resize(MAX_SIZE);
0429   diff_el67.resize(MAX_SIZE);
0430   diff_el77.resize(MAX_SIZE);
0431 
0432   myoldel33.resize(MAX_SIZE);
0433   myoldel34.resize(MAX_SIZE);
0434   myoldel35.resize(MAX_SIZE);
0435   myoldel44.resize(MAX_SIZE);
0436   myoldel45.resize(MAX_SIZE);
0437   myoldel46.resize(MAX_SIZE);
0438   myoldel55.resize(MAX_SIZE);
0439   myoldel56.resize(MAX_SIZE);
0440   myoldel57.resize(MAX_SIZE);
0441   myoldel66.resize(MAX_SIZE);
0442   myoldel67.resize(MAX_SIZE);
0443   myoldel77.resize(MAX_SIZE);
0444 
0445   for (int i = 0; i < MAX_SIZE; ++i) {
0446     counter = old_index_id[i];
0447     myoldel33[i] = old_el33[i];
0448     myoldel34[i] = old_el34[i];
0449     myoldel35[i] = old_el35[i];
0450     myoldel44[i] = old_el44[i];
0451     myoldel45[i] = old_el45[i];
0452     myoldel46[i] = old_el46[i];
0453     myoldel55[i] = old_el55[i];
0454     myoldel56[i] = old_el56[i];
0455     myoldel57[i] = old_el57[i];
0456     myoldel66[i] = old_el66[i];
0457     myoldel67[i] = old_el67[i];
0458     myoldel77[i] = old_el77[i];
0459 
0460     for (unsigned int k = 0; k < new_index_id.size() - 1; k++) {
0461       counter1 = new_index_id[k];
0462       if (counter == counter1) {
0463         diff_el33[k] = old_el33[i] / 1000. - new_el33[k];
0464         diff_el34[k] = old_el34[i] / 1000. - new_el34[k];
0465         diff_el35[k] = old_el35[i] / 1000. - new_el35[k];
0466         diff_el44[k] = old_el44[i] / 1000. - new_el44[k];
0467         diff_el45[k] = old_el45[i] / 1000. - new_el45[k];
0468         diff_el46[k] = old_el46[i] / 1000. - new_el46[k];
0469         diff_el55[k] = old_el55[i] / 1000. - new_el55[k];
0470         diff_el56[k] = old_el56[i] / 1000. - new_el56[k];
0471         diff_el57[k] = old_el57[i] / 1000. - new_el57[k];
0472         diff_el66[k] = old_el66[i] / 1000. - new_el66[k];
0473         diff_el67[k] = old_el67[i] / 1000. - new_el67[k];
0474         diff_el77[k] = old_el77[i] / 1000. - new_el77[k];
0475         myMatrixFile << counter << "  " << diff_el33[k] << "  " << diff_el34[k] << "  " << diff_el35[k] << "  "
0476                      << diff_el44[k] << "  " << diff_el45[k] << "  " << diff_el46[k] << "  " << diff_el55[k] << "  "
0477                      << diff_el56[k] << "  " << diff_el57[k] << "  " << diff_el66[k] << "  " << diff_el67[k] << "  "
0478                      << diff_el77[k] << "  " << std::endl;
0479       }
0480     }
0481   }
0482   std::cout << "DONE with comparison!" << std::endl;
0483 }
0484 
0485 //
0486 // member functions
0487 //
0488 
0489 // ------------ method called to for each event  ------------
0490 void Compare::analyze(const edm::Event &iEvent, const edm::EventSetup &iSetup) {}
0491 
0492 // define this as a plug-in
0493 DEFINE_FWK_MODULE(Compare);
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.2.1 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!