CMS 3D CMS Logo
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Pages
RPCObGasPyWrapper.cc
Go to the documentation of this file.
1 #include "CondFormats/RPCObjects/interface/RPCObGas.h"
2 #include "CondFormats/RPCObjects/interface/RPCObPVSSmap.h"
3 
4 #include "CondCore/DBCommon/interface/DbConnection.h"
5 #include "CondCore/DBCommon/interface/DbConnectionConfiguration.h"
6 //#include "CondCore/DBCommon/interface/DbSession.h"
7 #include "CondCore/DBCommon/interface/DbTransaction.h"
8 
9 //#include "CondCore/ORA/interface/Database.h"
10 //#include "CondCore/DBCommon/interface/PoolToken.h"
11 
12 #include "CondCore/Utilities/interface/PayLoadInspector.h"
13 #include "CondCore/Utilities/interface/InspectorPythonWrapper.h"
14 //#include "CondCore/IOVService/interface/IOVProxy.h"
15 
16 #include "DataFormats/MuonDetId/interface/RPCDetId.h"
17 #include "Geometry/RPCGeometry/interface/RPCGeomServ.h"
18 
19 //timestamp stuff
20 //#include "DataFormats/Provenance/interface/Timestamp.h"
21 //#include "CondTools/RPC/interface/RPCRunIOV.h"
22 #include <sys/time.h>
23 
25 #include "TROOT.h"
26 #include "TCanvas.h"
27 #include "TStyle.h"
28 #include "TColor.h"
29 #include "TLine.h"
30 #include "TVirtualPad.h"
31 #include "TH1D.h"
32 #include "TH2D.h"
33 #include "TGraph.h"
34 #include "TMultiGraph.h"
35 #include "TLegend.h"
36 #include "TF1.h"
37 #include "TDatime.h"
38 
39 #include <string>
40 #include <fstream>
41 #include <sstream>
42 #include <algorithm>
43 #include <numeric>
44 #include <iterator>
45 #include <iostream>
46 #include <fstream>
47 #include <utility>
48 #include <iomanip>
49 #include <boost/ref.hpp>
50 #include <boost/bind.hpp>
51 #include <boost/function.hpp>
52 #include <boost/shared_ptr.hpp>
53 #include <boost/iterator/transform_iterator.hpp>
54 
55 using std::pair;
56 using std::make_pair;
57 
58 namespace cond {
59 
60  namespace rpcobgas {
61  enum How { detid, flowin, flowout, day, time};
62 
63  void extractDetId(RPCObGas const & pl, std::vector<int> const & which,std::vector<float> & result,const float& starttime, const float& endtime) {
64  std::vector<RPCObGas::Item> const & gas = pl.ObGas_rpc;
65  for(unsigned int i = 0; i < gas.size(); ++i ){
66  if (which[0] == 0){
67  result.push_back(gas[i].dpid);
68  }
69  else{
70  if(gas[i].dpid == which[0])
71  result.push_back(gas[i].dpid);
72  }
73  }
74  }
75 
76  void extractFlowin(RPCObGas const & pl, std::vector<int> const & which,std::vector<float> & result,const float& starttime,const float& endtime) {
77  std::vector<RPCObGas::Item> const & gas = pl.ObGas_rpc;
78  for(unsigned int i = 0; i < gas.size(); ++i ){
79  if (which[0] == 0){
80  result.push_back(gas[i].flowin);
81  }
82  else{
83  if(gas[i].dpid == which[0])
84  result.push_back(gas[i].flowin);
85  }
86  }
87  }
88 
89  void extractFlowout(RPCObGas const & pl, std::vector<int> const & which,std::vector<float> & result,const float& starttime,const float& endtime) {
90  std::vector<RPCObGas::Item> const & gas = pl.ObGas_rpc;
91  for(unsigned int i = 0; i < gas.size(); ++i ){
92  if (which[0] == 0){
93  result.push_back(gas[i].flowout);
94  }
95  else{
96  if(gas[i].dpid == which[0])
97  result.push_back(gas[i].flowout);
98  }
99  }
100  }
101 
102  void extractDay(RPCObGas const & pl, std::vector<int> const & which,std::vector<float> & result,const float& starttime, const float& endtime) {
103  std::vector<RPCObGas::Item> const & gas = pl.ObGas_rpc;
104  for(unsigned int i = 0; i < gas.size(); ++i ){
105  if (which[0] == 0){
106  result.push_back(gas[i].day);
107  }
108  else{
109  if(gas[i].dpid == which[0])
110  result.push_back(gas[i].day);
111  }
112  }
113  }
114 
115  void extractTime(RPCObGas const & pl, std::vector<int> const & which,std::vector<float> & result,const float& starttime, const float& endtime) {
116  std::vector<RPCObGas::Item> const & gas = pl.ObGas_rpc;
117  for(unsigned int i = 0; i < gas.size(); ++i ){
118  if (which[0] == 0){
119  result.push_back(gas[i].time);
120  }
121  else{
122  if(gas[i].dpid == which[0])
123  result.push_back(gas[i].time);
124  }
125  }
126  }
127 
128  typedef boost::function<void(RPCObGas const & pl, std::vector<int> const & which,std::vector<float> & result/*In, std::vector<float> & resultOut*/,const float& starttime,const float& endtime)> RPCObGasExtractor;
129  }
130 
131  template<>
132  struct ExtractWhat<RPCObGas> {
133 
134  rpcobgas::How m_how;
135  std::vector<int> m_which;
136  float m_starttime;
137  float m_endtime;
138 
139  rpcobgas::How const & how() const { return m_how;}
140  std::vector<int> const & which() const { return m_which;}
141  float const & startTime() const {return m_starttime;}
142  float const & endTime() const {return m_endtime;}
143 
144  void set_how(rpcobgas::How i) {m_how=i;}
145  void set_which(std::vector<int> & i) { m_which.swap(i);}
146  void set_starttime(float& i){m_starttime = i;}
147  void set_endtime(float& i){m_endtime = i;}
148 
149  };
150 
151 
152  template<>
153  class ValueExtractor<RPCObGas>: public BaseValueExtractor<RPCObGas> {
154  public:
155 
156  static rpcobgas::RPCObGasExtractor & extractor(rpcobgas::How how) {
157  static rpcobgas::RPCObGasExtractor fun[5] = {
158  rpcobgas::RPCObGasExtractor(rpcobgas::extractDetId),
159  rpcobgas::RPCObGasExtractor(rpcobgas::extractFlowin),
160  rpcobgas::RPCObGasExtractor(rpcobgas::extractFlowout),
161  rpcobgas::RPCObGasExtractor(rpcobgas::extractDay),
162  rpcobgas::RPCObGasExtractor(rpcobgas::extractTime),
163  };
164  return fun[how];
165  }
166 
167  typedef RPCObGas Class;
168  typedef ExtractWhat<Class> What;
169  static What what() { return What();}
170 
171  ValueExtractor(){}
172  ValueExtractor(What const & what)
173  : m_what(what)
174  {
175  // here one can make stuff really complicated... (select mean rms, 12,6,1)
176  // ask to make average on selected channels...
177  }
178 
179  void compute(Class const & it){
180  std::vector<float> res;
181  extractor(m_what.how())(it,m_what.which(),res,m_what.startTime(),m_what.endTime());
182  swap(res);
183  // this->add(it.dpid);
184  // this->add(it.flowin);
185  // this->add(it.flowout);
186  // this->add(it.day);
187  // this->add(it.time);
188  }
189 
190  private:
191  What m_what;
192 
193  };
194 
195  // template<>
196  // std::string
197  // PayLoadInspector<RPCObGas>::dump() const {return std::string();}
198 
199  template<>
200  std::string PayLoadInspector<RPCObGas>::summary() const {
201 
202 // std::stringstream ss;
203 
204 // //BEGIN OF NEW DB-SESSION PART
205 // //hardcoded values
206 // std::string authPath="/afs/cern.ch/cms/DB/conddb";
207 // std::string conString="oracle://cms_orcoff_prod/CMS_COND_31X_RPC";
208 
209 // //frontend sends token instead of filename
210 // std::string token="[DB=00000000-0000-0000-0000-000000000000][CNT=RPCObPVSSmap][CLID=53B2D2D9-1F4E-9CA9-4D71-FFCCA123A454][TECH=00000B01][OID=0000000C-00000000]";
211 
212 // //make connection object
213 // DbConnection dbConn;
214 
215 // //set in configuration object authentication path
216 // dbConn.configuration().setAuthenticationPath(authPath);
217 // dbConn.configure();
218 
219 // //create session object from connection
220 // DbSession dbSes=dbConn.createSession();
221 
222 // //try to make connection
223 // dbSes.open(conString,true);
224 
225 // //start a transaction (true=readOnly)
226 // //cond::DbTransaction dbTr=
227 // dbSes.transaction().start(true);
228 
229 // //get the actual object
230 // boost::shared_ptr<RPCObPVSSmap> pvssPtr;
231 // pvssPtr=dbSes.getTypedObject<RPCObPVSSmap>(token);
232 
233 // //we have the object...
234 // std::vector<RPCObPVSSmap::Item> pvssCont=pvssPtr->ObIDMap_rpc;
235 // //END OF NEW DB-SESSION PART
236 
237 // std::vector<RPCObGas::Item> const & gas = object().ObGas_rpc;
238 
239 // ss<<"DetID\t\t\tI(uA)\tTime\tDay\n";
240 // for(unsigned int i = 0; i < gas.size(); ++i ){
241 // for(unsigned int p = 0; p < pvssCont.size(); ++p){
242 // if(gas[i].dpid!=pvssCont[p].dpid || pvssCont[p].suptype!=0 || pvssCont[p].region!=0)continue;
243 // RPCDetId rpcId(pvssCont[p].region,pvssCont[p].ring,pvssCont[p].station,pvssCont[p].sector,pvssCont[p].layer,pvssCont[p].subsector,1);
244 // RPCGeomServ rGS(rpcId);
245 // std::string chName(rGS.name().substr(0,rGS.name().find("_Backward")));
246 // ss <<chName <<"\t"<<gas[i].value<<"\t"<<gas[i].time<<"\t"<<gas[i].day<<"\n";
247 // }
248 // }
249 
250 // //close db session
251 // dbSes.close();
252 
253 // return ss.str();
254 
255  return "";
256 
257  }
258 
259 
260  Double_t linearF(Double_t *x, Double_t *par){
261  Double_t y=0.;
262  y=par[0]*(*x);
263  return y;
264  }
265 
266 
267  // return the real name of the file including extension...
268  template<>
269  std::string PayLoadInspector<RPCObGas>::plot(std::string const & filename,
270  std::string const & str,
271  std::vector<int> const & vInt,
272  std::vector<float> const& vFlt) const {
273 
274 // gStyle->SetPalette(1);
275 
276 // TH1D *iDistr=new TH1D("iDistr","IOV-averaged Current Distribution;Average Current (#muA);Entries/0.2 #muA",500,0.,100.);
277 // TH1D *rmsDistr=new TH1D("rmsDistr","RMS over IOV-Current Distribution;Current RMS (#muA);Entries/0.2 #muA",5000,0.,1000.);
278 
279 // //BEGIN OF NEW DB-SESSION PART
280 // //hardcoded values
281 // std::string authPath="/afs/cern.ch/cms/DB/conddb";
282 // std::string conString="oracle://cms_orcoff_prod/CMS_COND_31X_RPC";
283 
284 // //frontend sends token instead of filename
285 // std::string token="[DB=00000000-0000-0000-0000-000000000000][CNT=RPCObPVSSmap][CLID=53B2D2D9-1F4E-9CA9-4D71-FFCCA123A454][TECH=00000B01][OID=0000000C-00000000]";
286 
287 // //make connection object
288 // DbConnection dbConn;
289 
290 // //set in configuration object authentication path
291 // dbConn.configuration().setAuthenticationPath(authPath);
292 // dbConn.configure();
293 
294 // //create session object from connection
295 // DbSession dbSes=dbConn.createSession();
296 
297 // //try to make connection
298 // dbSes.open(conString,true);
299 
300 // //start a transaction (true=readOnly)
301 // dbSes.transaction().start(true);
302 
303 // //get the actual object
304 // boost::shared_ptr<RPCObPVSSmap> pvssPtr;
305 // pvssPtr=dbSes.getTypedObject<RPCObPVSSmap>(token);
306 
307 // //we have the object...
308 // std::vector<RPCObPVSSmap::Item> pvssCont=pvssPtr->ObIDMap_rpc;
309 // //END OF NEW DB-SESSION PART
310 
311 // std::vector<RPCObGas::Item> const & gas = object().ObGas_rpc;
312 
313 // RPCRunIOV *iovHelp=new RPCRunIOV();
314 
315 // std::map<int,std::pair<std::vector<double>,std::vector<double> > > dpidMap;
316 // for(unsigned int i = 0;i < gas.size(); ++i){
317 // for(unsigned int p = 0; p < pvssCont.size(); ++p){
318 // if(gas[i].dpid!=pvssCont[p].dpid || pvssCont[p].suptype!=0 || pvssCont[p].region!=0)continue;
319 // if(dpidMap.find(gas[i].dpid)==dpidMap.end()){
320 // std::vector<double> dumVec1;dumVec1.push_back(gas[i].value);
321 // std::vector<double> dumVec2;dumVec2.push_back((double)iovHelp->toUNIX(gas[i].day,gas[i].time));
322 // dpidMap[gas[i].dpid]=make_pair(dumVec1,dumVec2);
323 // }
324 // else {
325 // dpidMap[gas[i].dpid].first.push_back(gas[i].value);
326 // dpidMap[gas[i].dpid].second.push_back((double)iovHelp->toUNIX(gas[i].day,gas[i].time));
327 // }
328 // }
329 // }
330 
331 // delete iovHelp;
332 
333 // double maxMean(-1.),maxRms(-1.);
334 // double minMean(9999.),minRms(9999.);
335 // std::map<int,std::pair<std::vector<double>,std::vector<double> > >::const_iterator minIt,maxIt;
336 // std::vector<float> means,rmss;
337 // for(std::map<int,std::pair<std::vector<double>,std::vector<double> > >::const_iterator mIt=dpidMap.begin();
338 // mIt!=dpidMap.end();mIt++){
339 // std::pair<double, std::vector<double> > meanAndVals =
340 // make_pair(accumulate(mIt->second.first.begin(),mIt->second.first.end(),0.)/(double)mIt->second.first.size(),mIt->second.first);
341 
342 // iDistr->Fill(meanAndVals.first);
343 // if(meanAndVals.first>maxMean)maxMean=meanAndVals.first;
344 // if(meanAndVals.first<minMean)minMean=meanAndVals.first;
345 // double rms(0.);
346 // for(std::vector<double>::iterator rmsIt=meanAndVals.second.begin();
347 // rmsIt!=meanAndVals.second.end();++rmsIt){
348 // rms+=pow((*rmsIt-meanAndVals.first)/(double)meanAndVals.second.size(),2);
349 // }
350 // rmsDistr->Fill(sqrt(rms));
351 // if(sqrt(rms)>maxRms){
352 // maxRms=sqrt(rms);
353 // maxIt=mIt;
354 // }
355 // if(sqrt(rms)<minRms){
356 // minRms=sqrt(rms);
357 // if(mIt->second.first.size()>10)
358 // minIt=mIt;
359 // }
360 // means.push_back(meanAndVals.first);
361 // rmss.push_back(sqrt(rms));
362 // }
363 
364 // if(maxMean<100.)
365 // iDistr->GetXaxis()->SetRangeUser(minMean-0.00001,maxMean+1.);
366 // if(maxRms<1000.)
367 // rmsDistr->GetXaxis()->SetRangeUser(minRms-0.00001,maxRms+1.);
368 
369 // TCanvas c("Gas","Gas",1200,700);
370 // c.Divide(2,2);
371 
372 // TVirtualPad *p1=c.cd(1);
373 // p1->SetLogy(1);
374 // iDistr->SetFillColor(4);
375 // iDistr->SetLineColor(4);
376 // iDistr->Draw();
377 // c.cd(1);
378 
379 // TVirtualPad *p2=c.cd(2);
380 // p2->SetLogy(1);
381 // rmsDistr->SetFillColor(3);
382 // rmsDistr->SetLineColor(3);
383 // rmsDistr->Draw();
384 
385 // c.cd(3);
386 // TGraph *iRmsDistr=new TGraph(means.size(),static_cast<const float *>(&rmss[0]),static_cast<const float *>(&means[0]));
387 // iRmsDistr->SetMarkerStyle(7);
388 // iRmsDistr->SetMarkerColor(2);
389 // TF1 *func=new TF1("linearF",linearF,minRms,maxRms,1);
390 // iRmsDistr->Fit("linearF","r");
391 // iRmsDistr->GetXaxis()->SetTitle("Current RMS (#muA)");
392 // iRmsDistr->GetYaxis()->SetTitle("Current Means (#muA)");
393 // iRmsDistr->Draw("AP");
394 
395 
396 // TVirtualPad *p4=c.cd(4);
397 // p4->SetLogy(1);
398 // TMultiGraph *mProf=new TMultiGraph();
399 // TLegend *leg=new TLegend(0.65,0.91,0.99,0.99);
400 // TGraph *minProf=new TGraph(minIt->second.first.size(),&minIt->second.second[0],&minIt->second.first[0]);
401 // TGraph *maxProf=new TGraph(maxIt->second.first.size(),&maxIt->second.second[0],&maxIt->second.first[0]);
402 // minProf->SetMarkerStyle(20);
403 // maxProf->SetMarkerStyle(20);
404 // minProf->SetMarkerColor(2);
405 // maxProf->SetMarkerColor(4);
406 // mProf->Add(minProf);
407 // leg->AddEntry(minProf,"I vs IOV for Min RMS case","lpf");
408 // mProf->Add(maxProf);
409 // leg->AddEntry(maxProf,"I vs IOV for Max RMS case","lpf");
410 // leg->Draw();
411 // mProf->Draw("AP");
412 // mProf->GetXaxis()->SetTitle("IOV");
413 // mProf->GetYaxis()->SetTitle("I (#muA)");
414 
415 // c.SaveAs(filename.c_str());
416 
417 // return filename.c_str();
418 
419  return "";
420 
421  }
422 
423  template <>
424  std::string PayLoadInspector<RPCObGas>::trend_plot(std::string const & filename,
425  std::string const & opt_string,
426  std::vector<int> const& nts,
427  std::vector<float> const& floats,
428  std::vector<std::string> const& strings) const {
429 
430 // std::stringstream ss("");
431 
432 // if(strings.size()<2)
433 // return ("Error!Not enough data for initializing connection for making plots!(from template<> std::string PayLoadInspector<BeamSpotObjects>::trend_plot)");
434 
435 // std::vector<std::string>::const_iterator strIt=strings.begin();
436 
437 // std::string conString=(*strIt);strIt++;
438 // std::string authPath=(*strIt);strIt++;
439 
440 // //BEGIN OF NEW DB-SESSION PART
441 
442 // //make connection object
443 // DbConnection dbConn;
444 
445 // //set in configuration object authentication path
446 // dbConn.configuration().setAuthenticationPath(authPath);
447 // dbConn.configure();
448 
449 // //create session object from connection
450 // DbSession dbSes=dbConn.createSession();
451 
452 // //try to make connection
453 // dbSes.open(conString,true);
454 
455 // //start a transaction (true=readOnly)
456 // dbSes.transaction().start(true);
457 
458 // std::string pvssToken="[DB=00000000-0000-0000-0000-000000000000][CNT=RPCObPVSSmap][CLID=53B2D2D9-1F4E-9CA9-4D71-FFCCA123A454][TECH=00000B01][OID=0000000C-00000000]";
459 // //get the actual object
460 // boost::shared_ptr<RPCObGas> gasPtr;
461 // boost::shared_ptr<RPCObPVSSmap> pvssPtr;
462 // pvssPtr=dbSes.getTypedObject<RPCObPVSSmap>(pvssToken);
463 
464 // //we get the objects...
465 // std::vector<RPCObPVSSmap::Item> pvssCont=pvssPtr->ObIDMap_rpc,pvssZero;
466 
467 // for(unsigned int p=0;p<pvssCont.size();p++){
468 // if(pvssCont[p].suptype!=0)
469 // pvssZero.push_back(pvssCont[p]);
470 // }
471 
472 // std::string token;
473 // std::vector<float> vecI;vecI.assign(floats.size(),0.);
474 // int elCount(0);
475 
476 // for(;strIt!=strings.end();++strIt){
477 
478 // token=(*strIt);
479 // gasPtr=dbSes.getTypedObject<RPCObGas>(token);
480 // std::vector<RPCObGas::Item> const & gas = gasPtr->ObGas_rpc;
481 
482 // float iCount(0.);
483 // for(unsigned int i=0;i<gas.size();i++){
484 // for(unsigned int p=0;p<pvssZero.size();p++){
485 // if(gas[i].dpid!=pvssZero[p].dpid || pvssZero[p].region!=0)continue;
486 // iCount++;
487 // vecI[elCount]+=gas[i].value;
488 // }
489 // }
490 // if(iCount!=0)
491 // vecI[elCount]/=iCount;
492 // elCount++;
493 // }
494 
495 // //END OF NEW DB-SESSION PART
496 
497 // dbSes.close();
498 
499 // std::vector<unsigned long long> lngs ;
500 // for(std::vector<float>::const_iterator fIt=floats.begin();fIt!=floats.end();fIt++){
501 // lngs.push_back((unsigned long long)*fIt);
502 // // std::cout<<*fIt<<" "<<(long double)*fIt<<" "<<(unsigned long long)*fIt<<" "<<vecI[0]<<" "<<(unsigned long long)vecI[0]<<std::endl;
503 // }
504 // std::vector<unsigned long long> const longs=lngs;
505 
506 // // TGraph trend(vecI.size(),static_cast<const float *>(&longs[0]),static_cast<const float *>(&vecI[0]));
507 // std::cout<<(int)longs[longs.size()-1]-longs[0]<<std::endl;
508 // TH1F trend("trend","trend",(int)longs[longs.size()-1]-longs[0],longs[0],longs[longs.size()-1]);
509 // //TH1F trend("trend","trend",floats.size(),static_cast<const float* >(&floats[0]));
510 // trend.GetXaxis()->SetTimeDisplay(1);
511 // trend.GetXaxis()->SetTimeFormat("%d/%m/%y %H:%M");
512 // trend.SetLineColor(2);
513 // trend.SetLineWidth(2);
514 // trend.GetYaxis()->SetTitle("<I> (#muA)");
515 
516 // std::cout<<"Bins "<<trend.GetNbinsX()<<std::endl;
517 // for(unsigned int fill=0;fill<=longs.size();fill++){
518 // trend.SetBinContent(longs[fill]-longs[0],vecI[fill]);
519 // std::cout<<fill<<" "<<floats[fill]<<" "<<longs[fill]-longs[0]<<" "<<vecI[fill]<<std::endl;
520 // }
521 
522 // float min(*(floats.begin())),max(*(floats.end()-1));
523 // float scaleToggle((max-min)/max);
524 // TCanvas c("Itrend","Itrend",1200,700);
525 
526 // if(scaleToggle>=0.1)
527 // c.SetLogx(1);
528 
529 // trend.Draw(/*"LA*"*/);
530 
531 // TLegend leg(0.65,0.91,0.99,0.99);
532 // leg.AddEntry(&trend,"Gas trend","lpf");
533 
534 // leg.Draw("");
535 
536 // ss.str("");
537 // ss<<filename<<".C";
538 // c.SaveAs((ss.str()).c_str());
539 
540 // return ss.str();
541 
542  return "";
543 
544  }
545 
546  template<>
547  std::string PayLoadInspector<RPCObGas>::dumpFile(std::string const & filename,
548  std::string const & opt_string,
549  std::vector<int> const& nts,
550  std::vector<float> const& floats,
551  std::vector<std::string> const& strings) const { return filename; }
552 }
553 
554 
555 namespace condPython {
556  template<>
557  void defineWhat<RPCObGas>() {
558  using namespace boost::python;
559  enum_<cond::rpcobgas::How>("How")
560  .value("detid",cond::rpcobgas::detid)
561  .value("flowin",cond::rpcobgas::flowin)
562  .value("flowout",cond::rpcobgas::flowout)
563  .value("day",cond::rpcobgas::day)
564  .value("time",cond::rpcobgas::time)
565  ;
566 
567  typedef cond::ExtractWhat<RPCObGas> What;
568  class_<What>("What",init<>())
569  .def("set_how",&What::set_how)
570  .def("set_which",&What::set_which)
571  .def("how",&What::how, return_value_policy<copy_const_reference>())
572  .def("which",&What::which, return_value_policy<copy_const_reference>())
573  .def("set_starttime",&What::set_starttime)
574  .def("set_endtime",&What::set_endtime)
575  .def("startTime",&What::startTime, return_value_policy<copy_const_reference>())
576  .def("endTime",&What::endTime, return_value_policy<copy_const_reference>())
577  ;
578  }
579 }
580 
581 PYTHON_WRAPPER(RPCObGas,RPCObGas);
cond::rpcobgas::extractDetId
void extractDetId(RPCObGas const &pl, std::vector< int > const &which, std::vector< float > &result, const float &starttime, const float &endtime)
Definition: RPCObGasPyWrapper.cc:63
cond::PayLoadInspector::trend_plot
std::string trend_plot(std::string const &, std::string const &, std::vector< int > const &, std::vector< float > const &, std::vector< std::string > const &) const
Definition: PayLoadInspector.h:116
i
int i
Definition: DBlmapReader.cc:9
cond::PayLoadInspector::plot
std::string plot(std::string const &, std::string const &, std::vector< int > const &, std::vector< float > const &) const
Definition: PayLoadInspector.h:110
cond::rpcobgas::extractFlowout
void extractFlowout(RPCObGas const &pl, std::vector< int > const &which, std::vector< float > &result, const float &starttime, const float &endtime)
Definition: RPCObGasPyWrapper.cc:89
cond::ExtractWhat< RPCObGas >::endTime
float const & endTime() const
Definition: RPCObGasPyWrapper.cc:142
cond::ValueExtractor::What
ExtractWhat< Class > What
Definition: PayLoadInspector.h:56
cond::ValueExtractor< RPCObGas >::extractor
static rpcobgas::RPCObGasExtractor & extractor(rpcobgas::How how)
Definition: RPCObGasPyWrapper.cc:156
PYTHON_WRAPPER
#define PYTHON_WRAPPER(_class, _name)
Definition: InspectorPythonWrapper.h:48
cond::rpcobgas::extractFlowin
void extractFlowin(RPCObGas const &pl, std::vector< int > const &which, std::vector< float > &result, const float &starttime, const float &endtime)
Definition: RPCObGasPyWrapper.cc:76
lumiContext.starttime
tuple starttime
Definition: lumiContext.py:322
cond::linearF
Double_t linearF(Double_t *x, Double_t *par)
Definition: RPCObGasPyWrapper.cc:260
cond::PayLoadInspector::summary
std::string summary() const
Definition: PayLoadInspector.h:103
RPCObGas::ObGas_rpc
std::vector< Item > ObGas_rpc
Definition: RPCObGas.h:24
query.result
tuple result
Definition: query.py:137
cond::PayLoadInspector::dumpFile
std::string dumpFile(std::string const &, std::string const &, std::vector< int > const &, std::vector< float > const &, std::vector< std::string > const &) const
Definition: PayLoadInspector.h:126
cond::ExtractWhat< RPCObGas >::set_which
void set_which(std::vector< int > &i)
Definition: RPCObGasPyWrapper.cc:145
cond::rpcobgas::RPCObGasExtractor
boost::function< void(RPCObGas const &pl, std::vector< int > const &which, std::vector< float > &result, const float &starttime, const float &endtime)> RPCObGasExtractor
Definition: RPCObGasPyWrapper.cc:128
condPython::defineWhat< RPCObGas >
void defineWhat< RPCObGas >()
Definition: RPCObGasPyWrapper.cc:557
cond::BaseValueExtractor::swap
void swap(std::vector< float > &v)
Definition: PayLoadInspector.h:33
cond::ExtractWhat< RPCObGas >::which
std::vector< int > const & which() const
Definition: RPCObGasPyWrapper.cc:140
cond::ExtractWhat< RPCObGas >::startTime
float const & startTime() const
Definition: RPCObGasPyWrapper.cc:141
lut2db_cfg.filename
tuple filename
Definition: lut2db_cfg.py:20
cond::rpcobgas::extractTime
void extractTime(RPCObGas const &pl, std::vector< int > const &which, std::vector< float > &result, const float &starttime, const float &endtime)
Definition: RPCObGasPyWrapper.cc:115
vdt::x
x
Definition: VDTMath.h:216
cond::rpcobgas::extractDay
void extractDay(RPCObGas const &pl, std::vector< int > const &which, std::vector< float > &result, const float &starttime, const float &endtime)
Definition: RPCObGasPyWrapper.cc:102
cond::ExtractWhat< RPCObGas >::how
rpcobgas::How const & how() const
Definition: RPCObGasPyWrapper.cc:139
Generated for CMSSW Reference Manual by doxygen 1.8.5