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

MonMemTTConsistencyDat Class Reference

#include <MonMemTTConsistencyDat.h>

Inheritance diagram for MonMemTTConsistencyDat:
IDataItem IDBObject

List of all members.

Public Member Functions

int getProblematicEvents () const
int getProblemsBunchX () const
int getProblemsID () const
int getProblemsLV1 () const
int getProblemsSize () const
int getProcessedEvents () const
std::string getTable ()
bool getTaskStatus () const
 MonMemTTConsistencyDat ()
void setProblematicEvents (int prob)
void setProblemsBunchX (int bunchX)
void setProblemsID (int id)
void setProblemsLV1 (int LV1)
void setProblemsSize (int size)
void setProcessedEvents (int proc)
void setTaskStatus (bool status)
 ~MonMemTTConsistencyDat ()

Private Member Functions

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

Private Attributes

int m_problematicEvents
int m_problemsBunchX
int m_problemsID
int m_problemsLV1
int m_problemsSize
int m_processedEvents
bool m_taskStatus

Friends

class EcalCondDBInterface

Detailed Description

Definition at line 12 of file MonMemTTConsistencyDat.h.

Constructor & Destructor Documentation

MonMemTTConsistencyDat::MonMemTTConsistencyDat ( )

Definition at line 10 of file MonMemTTConsistencyDat.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_problemsSize = 0;
  m_problemsLV1 = 0;
  m_problemsBunchX = 0;
  m_taskStatus = 0;
}
MonMemTTConsistencyDat::~MonMemTTConsistencyDat ( )

Definition at line 28 of file MonMemTTConsistencyDat.cc.

{
}

Member Function Documentation

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

Definition at line 83 of file MonMemTTConsistencyDat.cc.

References alignCSCRings::e, edm::pset::fillMap(), o2o::iov, AlCaHLTBitMon_ParallelJobs::p, setProblematicEvents(), setProblemsBunchX(), setProblemsID(), setProblemsLV1(), setProblemsSize(), setProcessedEvents(), and setTaskStatus().

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

  iov->setConnection(m_env, m_conn);
  int iovID = iov->fetchID();
  if (!iovID) { 
    //  throw(std::runtime_error("MonMemTTConsistencyDat::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_size, d.problems_LV1, d.problems_bunch_X, d.task_status "
                 "FROM channelview cv JOIN mon_mem_tt_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, MonMemTTConsistencyDat > p;
    MonMemTTConsistencyDat 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.setProblemsSize( rset->getInt(10) );
      dat.setProblemsLV1( rset->getInt(11) );
      dat.setProblemsBunchX( rset->getInt(12) );
      dat.setTaskStatus( rset->getInt(13) );

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

Definition at line 25 of file MonMemTTConsistencyDat.h.

References m_problematicEvents.

Referenced by writeArrayDB().

{ return m_problematicEvents; }
int MonMemTTConsistencyDat::getProblemsBunchX ( ) const [inline]

Definition at line 37 of file MonMemTTConsistencyDat.h.

References m_problemsBunchX.

Referenced by writeArrayDB().

{ return m_problemsBunchX; }
int MonMemTTConsistencyDat::getProblemsID ( ) const [inline]

Definition at line 28 of file MonMemTTConsistencyDat.h.

References m_problemsID.

Referenced by writeArrayDB().

{ return m_problemsID; }
int MonMemTTConsistencyDat::getProblemsLV1 ( ) const [inline]

Definition at line 34 of file MonMemTTConsistencyDat.h.

References m_problemsLV1.

Referenced by writeArrayDB().

{ return m_problemsLV1; }
int MonMemTTConsistencyDat::getProblemsSize ( ) const [inline]

Definition at line 31 of file MonMemTTConsistencyDat.h.

References m_problemsSize.

Referenced by writeArrayDB().

{ return m_problemsSize; }
int MonMemTTConsistencyDat::getProcessedEvents ( ) const [inline]

Definition at line 22 of file MonMemTTConsistencyDat.h.

References m_processedEvents.

Referenced by writeArrayDB().

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

Implements IDataItem.

Definition at line 19 of file MonMemTTConsistencyDat.h.

{ return "MON_MEM_TT_CONSISTENCY_DAT"; }
bool MonMemTTConsistencyDat::getTaskStatus ( ) const [inline]

Definition at line 40 of file MonMemTTConsistencyDat.h.

References m_taskStatus.

Referenced by writeArrayDB().

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

Implements IDataItem.

Definition at line 34 of file MonMemTTConsistencyDat.cc.

References alignCSCRings::e.

{
  this->checkConnection();

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

Definition at line 24 of file MonMemTTConsistencyDat.h.

References m_problematicEvents.

Referenced by fetchData().

{ m_problematicEvents = prob; }
void MonMemTTConsistencyDat::setProblemsBunchX ( int  bunchX) [inline]

Definition at line 36 of file MonMemTTConsistencyDat.h.

References m_problemsBunchX.

Referenced by fetchData().

{ m_problemsBunchX = bunchX; }
void MonMemTTConsistencyDat::setProblemsID ( int  id) [inline]

Definition at line 27 of file MonMemTTConsistencyDat.h.

References m_problemsID.

Referenced by fetchData().

{ m_problemsID = id; }
void MonMemTTConsistencyDat::setProblemsLV1 ( int  LV1) [inline]

Definition at line 33 of file MonMemTTConsistencyDat.h.

References m_problemsLV1.

Referenced by fetchData().

{ m_problemsLV1 = LV1; }
void MonMemTTConsistencyDat::setProblemsSize ( int  size) [inline]

Definition at line 30 of file MonMemTTConsistencyDat.h.

References m_problemsSize, and findQualityFiles::size.

Referenced by fetchData().

{ m_problemsSize = size; }
void MonMemTTConsistencyDat::setProcessedEvents ( int  proc) [inline]

Definition at line 21 of file MonMemTTConsistencyDat.h.

References m_processedEvents, and proc.

Referenced by fetchData().

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

Definition at line 39 of file MonMemTTConsistencyDat.h.

References m_taskStatus, and ntuplemaker::status.

Referenced by fetchData().

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

Definition at line 132 of file MonMemTTConsistencyDat.cc.

References prof2calltree::count, AlCaHLTBitMon_QueryRunRegistry::data, alignCSCRings::e, EcalLogicID::getLogicID(), getProblematicEvents(), getProblemsBunchX(), getProblemsID(), getProblemsLV1(), getProblemsSize(), getProcessedEvents(), getTaskStatus(), o2o::iov, AlCaHLTBitMon_ParallelJobs::p, lumiQTWidget::t, groupFilesInBlocks::tt, w(), x, detailsBasic3DVector::y, and z.

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

  int iovID = iov->fetchID();
  if (!iovID) { throw(std::runtime_error("MonMemTTConsistencyDat::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* tt= 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* t_len= new ub2[nrows];
  ub2* st_len= new ub2[nrows];

  const EcalLogicID* channel;
  const MonMemTTConsistencyDat* dataitem;
  int count=0;
  typedef map< EcalLogicID, MonMemTTConsistencyDat >::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("MonMemTTConsistencyDat::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->getProblemsSize();
        int u=dataitem->getProblemsLV1();
        int t=dataitem->getProblemsBunchX();
        int statu=dataitem->getTaskStatus();




        xx[count]=x;
        yy[count]=y;
        zz[count]=z;
        ww[count]=w;
        uu[count]=u;
        tt[count]=t;
        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]);
        t_len[count]=sizeof(tt[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*)tt, OCCIINT , sizeof(tt[0]), t_len );
    m_writeStmt->setDataBuffer(9, (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 [] tt;
    delete [] st;

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



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

Definition at line 52 of file MonMemTTConsistencyDat.cc.

References alignCSCRings::e, and o2o::iov.

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

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

  int logicID = ecid->getLogicID();
  if (!logicID) { throw(std::runtime_error("MonMemTTConsistencyDat::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->getProblemsSize() );
    m_writeStmt->setInt(7, item->getProblemsLV1() );
    m_writeStmt->setInt(8, item->getProblemsBunchX() );
    m_writeStmt->setInt(9, item->getTaskStatus() );
    m_writeStmt->executeUpdate();
  } catch (SQLException &e) {
    throw(std::runtime_error("MonMemTTConsistencyDat::writeDB():  "+e.getMessage()));
  }
}

Friends And Related Function Documentation

friend class EcalCondDBInterface [friend]

Reimplemented from IDBObject.

Definition at line 14 of file MonMemTTConsistencyDat.h.

Member Data Documentation

int MonMemTTConsistencyDat::m_problematicEvents [private]

Definition at line 58 of file MonMemTTConsistencyDat.h.

Referenced by getProblematicEvents(), and setProblematicEvents().

int MonMemTTConsistencyDat::m_problemsBunchX [private]

Definition at line 62 of file MonMemTTConsistencyDat.h.

Referenced by getProblemsBunchX(), and setProblemsBunchX().

int MonMemTTConsistencyDat::m_problemsID [private]

Definition at line 59 of file MonMemTTConsistencyDat.h.

Referenced by getProblemsID(), and setProblemsID().

int MonMemTTConsistencyDat::m_problemsLV1 [private]

Definition at line 61 of file MonMemTTConsistencyDat.h.

Referenced by getProblemsLV1(), and setProblemsLV1().

int MonMemTTConsistencyDat::m_problemsSize [private]

Definition at line 60 of file MonMemTTConsistencyDat.h.

Referenced by getProblemsSize(), and setProblemsSize().

int MonMemTTConsistencyDat::m_processedEvents [private]

Definition at line 57 of file MonMemTTConsistencyDat.h.

Referenced by getProcessedEvents(), and setProcessedEvents().

bool MonMemTTConsistencyDat::m_taskStatus [private]

Definition at line 63 of file MonMemTTConsistencyDat.h.

Referenced by getTaskStatus(), and setTaskStatus().

Generated for CMSSW Reference Manual by doxygen 1.7.3