CMS 3D CMS Logo
Public Member Functions | Private Member Functions | Private Attributes | Friends

MonMemChConsistencyDat Class Reference

#include <MonMemChConsistencyDat.h>

Inheritance diagram for MonMemChConsistencyDat:
IDataItem IDBObject

List of all members.

Public Member Functions

int getProblematicEvents () const
int getProblemsGainSwitch () const
int getProblemsGainZero () const
int getProblemsID () const
int getProcessedEvents () const
std::string getTable ()
bool getTaskStatus () const
 MonMemChConsistencyDat ()
void setProblematicEvents (int prob)
void setProblemsGainSwitch (int prob)
void setProblemsGainZero (int prob)
void setProblemsID (int id)
void setProcessedEvents (int proc)
void setTaskStatus (bool status)
 ~MonMemChConsistencyDat ()

Private Member Functions

void fetchData (std::map< EcalLogicID, MonMemChConsistencyDat > *fillVec, MonRunIOV *iov) throw (std::runtime_error)
void prepareWrite () throw (std::runtime_error)
void writeArrayDB (const std::map< EcalLogicID, MonMemChConsistencyDat > *data, MonRunIOV *iov) throw (std::runtime_error)
void writeDB (const EcalLogicID *ecid, const MonMemChConsistencyDat *item, MonRunIOV *iov) throw (std::runtime_error)

Private Attributes

int m_problematicEvents
int m_problemsGainSwitch
int m_problemsGainZero
int m_problemsID
int m_processedEvents
bool m_taskStatus

Friends

class EcalCondDBInterface

Detailed Description

Definition at line 12 of file MonMemChConsistencyDat.h.

Constructor & Destructor Documentation

MonMemChConsistencyDat::MonMemChConsistencyDat ( )

Definition at line 10 of file MonMemChConsistencyDat.cc.

References NULL.

{
  m_env = NULL;
  m_conn = NULL;
  m_writeStmt = NULL;
  m_readStmt = NULL;

  m_processedEvents = 0;
  m_problematicEvents = 0;
  m_problemsID = 0;
  m_problemsGainZero = 0;
  m_problemsGainSwitch = 0;
  m_taskStatus = 0;
}
MonMemChConsistencyDat::~MonMemChConsistencyDat ( )

Definition at line 27 of file MonMemChConsistencyDat.cc.

{
}

Member Function Documentation

void MonMemChConsistencyDat::fetchData ( std::map< EcalLogicID, MonMemChConsistencyDat > *  fillVec,
MonRunIOV *  iov 
) throw (std::runtime_error) [private]

Definition at line 81 of file MonMemChConsistencyDat.cc.

References edm::pset::fillMap(), o2o::iov, AlCaHLTBitMon_ParallelJobs::p, setProblematicEvents(), setProblemsGainSwitch(), setProblemsGainZero(), setProblemsID(), setProcessedEvents(), and setTaskStatus().

{
  this->checkConnection();
  fillMap->clear();

  iov->setConnection(m_env, m_conn);
  int iovID = iov->fetchID();
  if (!iovID) { 
    //  throw(std::runtime_error("MonMemChConsistencyDat::writeDB:  IOV not in DB")); 
    return;
  }

  try {

    m_readStmt->setSQL("SELECT cv.name, cv.logic_id, cv.id1, cv.id2, cv.id3, cv.maps_to, "
                 "d.processed_events, d.problematic_events, d.problems_id, d.problems_gain_zero, d.problems_gain_switch, d.task_status "
                 "FROM channelview cv JOIN mon_mem_ch_consistency_dat d "
                 "ON cv.logic_id = d.logic_id AND cv.name = cv.maps_to "
                 "WHERE d.iov_id = :iov_id");
    m_readStmt->setInt(1, iovID);
    ResultSet* rset = m_readStmt->executeQuery();
    
    std::pair< EcalLogicID, MonMemChConsistencyDat > p;
    MonMemChConsistencyDat dat;
    while(rset->next()) {
      p.first = EcalLogicID( rset->getString(1),     // name
                             rset->getInt(2),        // logic_id
                             rset->getInt(3),        // id1
                             rset->getInt(4),        // id2
                             rset->getInt(5),        // id3
                             rset->getString(6));    // maps_to

      dat.setProcessedEvents( rset->getInt(7) );
      dat.setProblematicEvents( rset->getInt(8) );
      dat.setProblemsID( rset->getInt(9) );
      dat.setProblemsGainZero( rset->getInt(10) );
      dat.setProblemsGainSwitch( rset->getInt(11) );
      dat.setTaskStatus( rset->getInt(12) );

      p.second = dat;
      fillMap->insert(p);
    }
  } catch (SQLException &e) {
    throw(std::runtime_error("MonMemChConsistencyDat::fetchData():  "+e.getMessage()));
  }
}
int MonMemChConsistencyDat::getProblematicEvents ( ) const [inline]

Definition at line 25 of file MonMemChConsistencyDat.h.

References m_problematicEvents.

Referenced by writeArrayDB().

{ return m_problematicEvents; }
int MonMemChConsistencyDat::getProblemsGainSwitch ( ) const [inline]

Definition at line 34 of file MonMemChConsistencyDat.h.

References m_problemsGainSwitch.

Referenced by writeArrayDB().

{ return m_problemsGainSwitch; }
int MonMemChConsistencyDat::getProblemsGainZero ( ) const [inline]

Definition at line 31 of file MonMemChConsistencyDat.h.

References m_problemsGainZero.

Referenced by writeArrayDB().

{ return m_problemsGainZero; }
int MonMemChConsistencyDat::getProblemsID ( ) const [inline]

Definition at line 28 of file MonMemChConsistencyDat.h.

References m_problemsID.

Referenced by writeArrayDB().

{ return m_problemsID; }
int MonMemChConsistencyDat::getProcessedEvents ( ) const [inline]

Definition at line 22 of file MonMemChConsistencyDat.h.

References m_processedEvents.

Referenced by writeArrayDB().

{ return m_processedEvents; }
std::string MonMemChConsistencyDat::getTable ( ) [inline, virtual]

Implements IDataItem.

Definition at line 19 of file MonMemChConsistencyDat.h.

{ return "MON_MEM_CH_CONSISTENCY_DAT"; }
bool MonMemChConsistencyDat::getTaskStatus ( ) const [inline]

Definition at line 37 of file MonMemChConsistencyDat.h.

References m_taskStatus.

Referenced by writeArrayDB().

{ return m_taskStatus; }
void MonMemChConsistencyDat::prepareWrite ( ) throw (std::runtime_error) [private, virtual]

Implements IDataItem.

Definition at line 33 of file MonMemChConsistencyDat.cc.

{
  this->checkConnection();

  try {
    m_writeStmt = m_conn->createStatement();
    m_writeStmt->setSQL("INSERT INTO mon_mem_ch_consistency_dat (iov_id, logic_id, "
                        "processed_events, problematic_events, problems_id, problems_gain_zero, problems_gain_switch, task_status) "
                        "VALUES (:iov_id, :logic_id, "
                        ":3, :4, :5, :6, :7, :8)");
  } catch (SQLException &e) {
    throw(std::runtime_error("MonMemChConsistencyDat::prepareWrite():  "+e.getMessage()));
  }
}
void MonMemChConsistencyDat::setProblematicEvents ( int  prob) [inline]

Definition at line 24 of file MonMemChConsistencyDat.h.

References m_problematicEvents.

Referenced by fetchData().

{ m_problematicEvents = prob; }
void MonMemChConsistencyDat::setProblemsGainSwitch ( int  prob) [inline]

Definition at line 33 of file MonMemChConsistencyDat.h.

References m_problemsGainSwitch.

Referenced by fetchData().

{ m_problemsGainSwitch = prob; }
void MonMemChConsistencyDat::setProblemsGainZero ( int  prob) [inline]

Definition at line 30 of file MonMemChConsistencyDat.h.

References m_problemsGainZero.

Referenced by fetchData().

{ m_problemsGainZero = prob; }
void MonMemChConsistencyDat::setProblemsID ( int  id) [inline]

Definition at line 27 of file MonMemChConsistencyDat.h.

References m_problemsID.

Referenced by fetchData().

{ m_problemsID = id; }
void MonMemChConsistencyDat::setProcessedEvents ( int  proc) [inline]

Definition at line 21 of file MonMemChConsistencyDat.h.

References m_processedEvents, and proc.

Referenced by fetchData().

{ m_processedEvents = proc; }
void MonMemChConsistencyDat::setTaskStatus ( bool  status) [inline]

Definition at line 36 of file MonMemChConsistencyDat.h.

References m_taskStatus, and ntuplemaker::status.

Referenced by fetchData().

{ m_taskStatus = status; }
void MonMemChConsistencyDat::writeArrayDB ( const std::map< EcalLogicID, MonMemChConsistencyDat > *  data,
MonRunIOV *  iov 
) throw (std::runtime_error) [private]

Definition at line 129 of file MonMemChConsistencyDat.cc.

References prof2calltree::count, AlCaHLTBitMon_QueryRunRegistry::data, EcalLogicID::getLogicID(), getProblematicEvents(), getProblemsGainSwitch(), getProblemsGainZero(), getProblemsID(), getProcessedEvents(), getTaskStatus(), o2o::iov, AlCaHLTBitMon_ParallelJobs::p, x, detailsBasic3DVector::y, and z.

{
  this->checkConnection();
  this->checkPrepare();

  int iovID = iov->fetchID();
  if (!iovID) { throw(std::runtime_error("MonMemChConsistencyDat::writeArrayDB:  IOV not in DB")); }


  int nrows=data->size(); 
  int* ids= new int[nrows];
  int* iovid_vec= new int[nrows];
  int* xx= new int[nrows];
  int* yy= new int[nrows];
  int* zz= new int[nrows];
  int* ww= new int[nrows];
  int* uu= new int[nrows];
  int* st= new int[nrows];

  ub2* ids_len= new ub2[nrows];
  ub2* iov_len= new ub2[nrows];
  ub2* x_len= new ub2[nrows];
  ub2* y_len= new ub2[nrows];
  ub2* z_len= new ub2[nrows];
  ub2* w_len= new ub2[nrows];
  ub2* u_len= new ub2[nrows];
  ub2* st_len= new ub2[nrows];

  const EcalLogicID* channel;
  const MonMemChConsistencyDat* dataitem;
  int count=0;
  typedef map< EcalLogicID, MonMemChConsistencyDat >::const_iterator CI;
  for (CI p = data->begin(); p != data->end(); ++p) {
        channel = &(p->first);
        int logicID = channel->getLogicID();
        if (!logicID) { throw(std::runtime_error("MonMemChConsistencyDat::writeArrayDB:  Bad EcalLogicID")); }
        ids[count]=logicID;
        iovid_vec[count]=iovID;

        dataitem = &(p->second);
        // dataIface.writeDB( channel, dataitem, iov);
        int x=dataitem->getProcessedEvents();
        int y=dataitem->getProblematicEvents();
        int z=dataitem->getProblemsID();
        int w=dataitem->getProblemsGainZero();
        int u=dataitem->getProblemsGainSwitch();
        int statu=dataitem->getTaskStatus();



        xx[count]=x;
        yy[count]=y;
        zz[count]=z;
        ww[count]=w;
        uu[count]=u;
        st[count]=statu;


        ids_len[count]=sizeof(ids[count]);
        iov_len[count]=sizeof(iovid_vec[count]);
        
        x_len[count]=sizeof(xx[count]);
        y_len[count]=sizeof(yy[count]);
        z_len[count]=sizeof(zz[count]);
        w_len[count]=sizeof(ww[count]);
        u_len[count]=sizeof(uu[count]);
        st_len[count]=sizeof(st[count]);

        count++;
     }


  try {
    m_writeStmt->setDataBuffer(1, (dvoid*)iovid_vec, OCCIINT, sizeof(iovid_vec[0]),iov_len);
    m_writeStmt->setDataBuffer(2, (dvoid*)ids, OCCIINT, sizeof(ids[0]), ids_len );
    m_writeStmt->setDataBuffer(3, (dvoid*)xx, OCCIINT , sizeof(xx[0]), x_len );
    m_writeStmt->setDataBuffer(4, (dvoid*)yy, OCCIINT , sizeof(yy[0]), y_len );
    m_writeStmt->setDataBuffer(5, (dvoid*)zz, OCCIINT , sizeof(zz[0]), z_len );
    m_writeStmt->setDataBuffer(6, (dvoid*)ww, OCCIINT , sizeof(ww[0]), w_len );
    m_writeStmt->setDataBuffer(7, (dvoid*)uu, OCCIINT , sizeof(uu[0]), u_len );
    m_writeStmt->setDataBuffer(8, (dvoid*)st, OCCIINT , sizeof(st[0]), st_len );
   

    m_writeStmt->executeArrayUpdate(nrows);

    delete [] ids;
    delete [] iovid_vec;
    delete [] xx;
    delete [] yy;
    delete [] zz;
    delete [] ww;
    delete [] uu;
    delete [] st;

    delete [] ids_len;
    delete [] iov_len;
    delete [] x_len;
    delete [] y_len;
    delete [] z_len;
    delete [] w_len;
    delete [] u_len;
    delete [] st_len;



  } catch (SQLException &e) {
    throw(std::runtime_error("MonMemChConsistencyDat::writeArrayDB():  "+e.getMessage()));
  }
}
void MonMemChConsistencyDat::writeDB ( const EcalLogicID *  ecid,
const MonMemChConsistencyDat *  item,
MonRunIOV *  iov 
) throw (std::runtime_error) [private]

Definition at line 51 of file MonMemChConsistencyDat.cc.

References o2o::iov.

{
  this->checkConnection();
  this->checkPrepare();

  int iovID = iov->fetchID();
  if (!iovID) { throw(std::runtime_error("MonMemChConsistencyDat::writeDB:  IOV not in DB")); }

  int logicID = ecid->getLogicID();
  if (!logicID) { throw(std::runtime_error("MonMemChConsistencyDat::writeDB:  Bad EcalLogicID")); }
  
  try {
    m_writeStmt->setInt(1, iovID);
    m_writeStmt->setInt(2, logicID);

    m_writeStmt->setInt(3, item->getProcessedEvents() );
    m_writeStmt->setInt(4, item->getProblematicEvents() );
    m_writeStmt->setInt(5, item->getProblemsID() );
    m_writeStmt->setInt(6, item->getProblemsGainZero() );
    m_writeStmt->setInt(7, item->getProblemsGainSwitch() );
    m_writeStmt->setInt(8, item->getTaskStatus() );
    m_writeStmt->executeUpdate();
  } catch (SQLException &e) {
    throw(std::runtime_error("MonMemChConsistencyDat::writeDB():  "+e.getMessage()));
  }
}

Friends And Related Function Documentation

friend class EcalCondDBInterface [friend]

Reimplemented from IDBObject.

Definition at line 14 of file MonMemChConsistencyDat.h.

Member Data Documentation

int MonMemChConsistencyDat::m_problematicEvents [private]

Definition at line 55 of file MonMemChConsistencyDat.h.

Referenced by getProblematicEvents(), and setProblematicEvents().

int MonMemChConsistencyDat::m_problemsGainSwitch [private]

Definition at line 58 of file MonMemChConsistencyDat.h.

Referenced by getProblemsGainSwitch(), and setProblemsGainSwitch().

int MonMemChConsistencyDat::m_problemsGainZero [private]

Definition at line 57 of file MonMemChConsistencyDat.h.

Referenced by getProblemsGainZero(), and setProblemsGainZero().

int MonMemChConsistencyDat::m_problemsID [private]

Definition at line 56 of file MonMemChConsistencyDat.h.

Referenced by getProblemsID(), and setProblemsID().

int MonMemChConsistencyDat::m_processedEvents [private]

Definition at line 54 of file MonMemChConsistencyDat.h.

Referenced by getProcessedEvents(), and setProcessedEvents().

bool MonMemChConsistencyDat::m_taskStatus [private]

Definition at line 59 of file MonMemChConsistencyDat.h.

Referenced by getTaskStatus(), and setTaskStatus().

Generated for CMSSW Reference Manual by doxygen 1.7.3