#include <RPCCalibSetUp.h>

Public Member Functions
std::vector< double >	getCls (uint32_t id)

std::map< int, std::vector< double > >	getClsMap ()

std::vector< float >	getEff (uint32_t id)

const RPCGeometry *	getGeometry ()

std::vector< float >	getNoise (uint32_t id)

float	getTime (uint32_t id)

	RPCCalibSetUp (const edm::ParameterSet &ps)

void	setGeometry (const RPCGeometry *geom)
	sets geometry More...

virtual	~RPCCalibSetUp ()

Public Attributes
std::map< RPCDetId, float >	_bxmap

std::map< int, std::vector< double > >	_clsMap

std::map< uint32_t, std::vector< double > >	_mapDetClsMap

std::map< uint32_t, std::vector< float > >	_mapDetIdEff

std::map< uint32_t, std::vector< float > >	_mapDetIdNoise

const RPCGeometry *	theGeometry

Detailed Description

Definition at line 23 of file RPCCalibSetUp.h.

Constructor & Destructor Documentation

◆ RPCCalibSetUp()

RPCCalibSetUp::RPCCalibSetUp ( const edm::ParameterSet & ps )

explicit

Definition at line 25 of file RPCCalibSetUp.cc.

                                                       {
   _mapDetIdNoise.clear();
   _mapDetIdEff.clear();
   _bxmap.clear();
   _mapDetClsMap.clear();
  
   //------------------------ Noise Reading ----------------------------
  
   edm::FileInPath fp1 = ps.getParameter<edm::FileInPath>("noisemapfile");
   std::ifstream _infile1(fp1.fullPath().c_str(), std::ios::in);
  
   std::vector<float> vnoise;
  
   int rpcdetid = 0;
   std::string buff;
  
   std::vector<std::string> words;
  
   int count = 0;
   while (getline(_infile1, buff, '\n')) {
     words.clear();
     vnoise.clear();
  
     stringstream ss;
     std::string chname;
     ss << buff;
     ss >> chname >> rpcdetid;
  
     std::string::size_type pos = 0, prev_pos = 0;
  
     while ((pos = buff.find("  ", pos)) != string::npos) {
       words.push_back(buff.substr(prev_pos, pos - prev_pos));
       prev_pos = ++pos;
     }
     words.push_back(buff.substr(prev_pos, pos - prev_pos));
  
     for (unsigned int i = 2; i < words.size(); ++i) {
       float value = atof(((words)[i]).c_str());
       vnoise.push_back(value);
     }
  
     _mapDetIdNoise.insert(make_pair(static_cast<uint32_t>(rpcdetid), vnoise));
  
     count++;
   }
   _infile1.close();
  
   //------------------------ Eff Reading ----------------------------
  
   edm::FileInPath fp2 = ps.getParameter<edm::FileInPath>("effmapfile");
   std::ifstream _infile2(fp2.fullPath().c_str(), std::ios::in);
  
   std::vector<float> veff;
   rpcdetid = 0;
  
   while (getline(_infile2, buff, '\n')) {
     words.clear();
     veff.clear();
  
     stringstream ss;
     std::string chname;
     ss << buff;
     ss >> chname >> rpcdetid;
  
     std::string::size_type pos = 0, prev_pos = 0;
     while ((pos = buff.find("  ", pos)) != string::npos) {
       words.push_back(buff.substr(prev_pos, pos - prev_pos));
       prev_pos = ++pos;
     }
     words.push_back(buff.substr(prev_pos, pos - prev_pos));
  
     for (unsigned int i = 2; i < words.size(); ++i) {
       float value = atof(((words)[i]).c_str());
       veff.push_back(value);
     }
     _mapDetIdEff.insert(make_pair(static_cast<uint32_t>(rpcdetid), veff));
   }
   _infile2.close();
  
   //---------------------- Timing reading ------------------------------------
  
   edm::FileInPath fp3 = ps.getParameter<edm::FileInPath>("timingMap");
   std::ifstream _infile3(fp3.fullPath().c_str(), std::ios::in);
  
   uint32_t detUnit = 0;
   float timing = 0.;
   while (!_infile3.eof()) {
     _infile3 >> detUnit >> timing;
     _bxmap[RPCDetId(detUnit)] = timing;
   }
   _infile3.close();
  
   //---------------------- Cluster size --------------------------------------
  
   edm::FileInPath fp4 = ps.getParameter<edm::FileInPath>("clsmapfile");
   std::ifstream _infile4(fp4.fullPath().c_str(), ios::in);
  
   string buffer;
   double sum = 0;
   unsigned int counter = 1;
   unsigned int row = 1;
   std::vector<double> sum_clsize;
  
   while (_infile4 >> buffer) {
     const char *buffer1 = buffer.c_str();
     double dato = atof(buffer1);
     sum += dato;
     sum_clsize.push_back(sum);
  
     if (counter == row * 20) {
       _clsMap[row] = sum_clsize;
       row++;
       sum = 0;
       sum_clsize.clear();
     }
     counter++;
   }
   _infile4.close();
  
   //---------------------- Cluster size Chamber by Chamber -------------------
  
   edm::FileInPath fp5 = ps.getParameter<edm::FileInPath>("clsidmapfile");
   std::ifstream _infile5(fp5.fullPath().c_str(), ios::in);
  
   std::vector<double> vClsDistrib;
   rpcdetid = 0;
  
   while (getline(_infile5, buff, '\n')) {
     words.clear();
     vClsDistrib.clear();
  
     stringstream ss1;
     ss1 << buff;
     ss1 >> rpcdetid;
  
     std::string::size_type pos = 0, prev_pos = 0;
     while ((pos = buff.find("  ", pos)) != string::npos) {
       words.push_back(buff.substr(prev_pos, pos - prev_pos));
       prev_pos = ++pos;
     }
     words.push_back(buff.substr(prev_pos, pos - prev_pos));
  
     float clusterSizeSumData(0.);
  
     for (unsigned int i = 1; i < words.size(); ++i) {
       float value = atof(((words)[i]).c_str());
  
       clusterSizeSumData += value;
       vClsDistrib.push_back(clusterSizeSumData);
       if (!(i % 20)) {
         clusterSizeSumData = 0.;
       }
     }
     if (vClsDistrib.size() != 100) {
       throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - cluster size - a wrong "
                                              "format "
                                           << std::endl;
     }
     _mapDetClsMap.insert(make_pair(static_cast<uint32_t>(rpcdetid), vClsDistrib));
     std::cout << "_mapDetClsMap.size()\t" << _mapDetClsMap.size() << std::endl;
   }
  
   _infile5.close();
 }

References edmScanValgrind::buffer, KineDebug3::count(), gather_cfg::cout, Exception, edm::FileInPath::fullPath(), edm::ParameterSet::getParameter(), mps_fire::i, recoMuon::in, contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, ecalMatacq_cfi::timing, and relativeConstraints::value.

◆ ~RPCCalibSetUp()

RPCCalibSetUp::~RPCCalibSetUp ( )

virtual

Definition at line 251 of file RPCCalibSetUp.cc.

251 {}

Member Function Documentation

◆ getCls()

std::vector< double > RPCCalibSetUp::getCls ( uint32_t id )

Definition at line 236 of file RPCCalibSetUp.cc.

                                                    {
   std::map<uint32_t, std::vector<double>>::iterator iter = _mapDetClsMap.find(id);
   if (iter == _mapDetClsMap.end()) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - no cluster size information "
                                            "for DetId\t"
                                         << id << std::endl;
   }
   if ((iter->second).size() != 100) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - cluster size information in "
                                            "a wrong format for DetId\t"
                                         << id << std::endl;
   }
   return iter->second;
 }

References Exception.

Referenced by RPCFakeCalibration::makeCls().

◆ getClsMap()

std::map< int, std::vector< double > > RPCCalibSetUp::getClsMap ( )

Definition at line 227 of file RPCCalibSetUp.cc.

                                                         {
   if (_clsMap.size() != 5) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - cluster size - a wrong "
                                            "format "
                                         << std::endl;
   }
   return _clsMap;
 }

References Exception.

◆ getEff()

std::vector< float > RPCCalibSetUp::getEff ( uint32_t id )

Definition at line 200 of file RPCCalibSetUp.cc.

                                                   {
   map<uint32_t, std::vector<float>>::iterator iter = _mapDetIdEff.find(id);
   if (iter == _mapDetIdEff.end()) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - no efficiency information "
                                            "for DetId\t"
                                         << id << std::endl;
   }
   if ((iter->second).size() != 96) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - efficiency information in a "
                                            "wrong format for DetId\t"
                                         << id << std::endl;
   }
   return iter->second;
 }

References Exception.

Referenced by RPCFakeCalibration::makeNoise().

◆ getGeometry()

const RPCGeometry* RPCCalibSetUp::getGeometry ( )

inline

Definition at line 37 of file RPCCalibSetUp.h.

37 { return theGeometry; }

References theGeometry.

◆ getNoise()

std::vector< float > RPCCalibSetUp::getNoise ( uint32_t id )

Definition at line 190 of file RPCCalibSetUp.cc.

                                                     {
   map<uint32_t, std::vector<float>>::iterator iter = _mapDetIdNoise.find(id);
   if (iter == _mapDetIdNoise.end()) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - no noise information for "
                                            "DetId\t"
                                         << id << std::endl;
   }
   return (iter->second);
 }

References Exception.

◆ getTime()

float RPCCalibSetUp::getTime ( uint32_t id )

Definition at line 215 of file RPCCalibSetUp.cc.

                                         {
   RPCDetId rpcid(id);
  
   std::map<RPCDetId, float>::iterator iter = _bxmap.find(rpcid);
   if (iter == _bxmap.end()) {
     throw cms::Exception("DataCorrupt") << "Exception comming from RPCCalibSetUp - no timing information for "
                                            "rpcid.rawId()\t"
                                         << rpcid.rawId() << std::endl;
   }
   return iter->second;
 }