HcalAssistant.cc

Go to the documentation of this file.

// -*- C++ -*-
//
// Package:     HcalOnlineDb
// Class  :     HcalAssistant
// 
// Implementation:
//     <Notes on implementation>
//
// Original Author:  Gena Kukartsev, kukarzev@fnal.gov
//         Created:  Thu Jul 16 11:39:22 CEST 2009
//


#include <ctime>
#include <unistd.h>
#include <sys/types.h>
#include <pwd.h>
#include "CaloOnlineTools/HcalOnlineDb/interface/HcalAssistant.h"
#include "CaloOnlineTools/HcalOnlineDb/interface/ConnectionManager.h"
#include "CaloOnlineTools/HcalOnlineDb/interface/ConfigurationDatabaseException.hh"
#include "OnlineDB/Oracle/interface/Oracle.h"
#include "DataFormats/HcalDetId/interface/HcalDetId.h"

#ifdef HAVE_XDAQ
#include <toolbox/string.h>
#else
#include "CaloOnlineTools/HcalOnlineDb/interface/xdaq_compat.h"  // Includes typedef for log4cplus::Logger
#endif

using namespace std;
using namespace oracle::occi;

HcalAssistant::HcalAssistant()
{
  addQuotes();
  srand(time(nullptr));
  listIsRead = false;
}


HcalAssistant::~HcalAssistant()
{
}


int HcalAssistant::addQuotes(){
  quotes.push_back("Fear is the path to the Dark Side...");
  quotes.push_back("You don't know the power of the Dark Side...");
  quotes.push_back("You must learn the ways of the Force!");
  quotes.push_back("Where's the money, Lebowski?!");
  quotes.push_back("You see what happens when you find a stranger in the Alps!!!?");
  quotes.push_back("You hear this? This is the sound of inevitability. This is the sound of your death. Goodbye, mr. Anderson");
  quotes.push_back("Welcome to the desert of the Real");
  quotes.push_back("In Tyler we trust");
  quotes.push_back("How about a little snack?..Let's have a snack now, we can get friendly later");
  quotes.push_back("Is he human? Hey, no need for name calling!");
  quotes.push_back("Frankly, my dear, I don't give a damn");
  quotes.push_back("I've a feeling we're not in Kansas anymore");
  quotes.push_back("What we've got here is failure to communicate");
  quotes.push_back("I love the smell of napalm in the morning!");
  quotes.push_back("I see stupid people");
  quotes.push_back("Stella! Hey, Stella!");
  quotes.push_back("Houston, we have a problem");
  quotes.push_back("Mrs. Robinson, you're trying to seduce me. Aren't you?");
  quotes.push_back("I feel the need - the need for speed!");
  quotes.push_back("He's got emotional problems. What, beyond pacifism?");
  return quotes.size();
}



std::string HcalAssistant::getRandomQuote(){
  int _quotes_array_size = quotes.size();
  int _num = rand()%_quotes_array_size;
  return quotes[_num];
}


std::string HcalAssistant::getUserName(void){
  struct passwd * _pwd = getpwuid(geteuid());
  std::string _name(_pwd->pw_name);
  return _name;
}



int HcalAssistant::getGeomId(HcalSubdetector _det, int _ieta, int _iphi, int _depth){
  int _geomId = 
    _det
    +   10 * _depth
    +  100 * _iphi
    +10000 * abs(_ieta);
  if (_ieta<0){
    _geomId = -_geomId;
  }
  return _geomId;
}


int HcalAssistant::getHcalIeta(int _geomId){
  int _ieta = _geomId/10000;
  return _ieta;
}


int HcalAssistant::getHcalIphi(int _geomId){
  int _iphi = abs( _geomId % 10000 )/100;
  return _iphi;
}


int HcalAssistant::getHcalDepth(int _geomId){
  int _depth = abs( _geomId % 100 ) / 10;
  return _depth;
}


HcalSubdetector HcalAssistant::getHcalSubdetector(int _geomId){
  int _det = abs(_geomId) % 10;
  if (_det==1) return HcalBarrel;
  else if (_det==2) return HcalEndcap;
  else if (_det==3) return HcalOuter;
  else if (_det==4) return HcalForward;
  else if (_det==5) return HcalTriggerTower;
  else if (_det==0) return HcalEmpty;
  else return HcalOther;
}


std::string HcalAssistant::getSubdetectorString(int _geomId){
  int _det = abs(_geomId) % 10;
  std::string s_det = "";
  if (_det==1) s_det = "HB";
  else if (_det==2) s_det = "HE";
  else if (_det==3) s_det = "HO";
  else if (_det==4) s_det = "HF";
  else if (_det==5) s_det = "HT";
  else if (_det==6) s_det = "ZDC";
  else if (_det==0) s_det = "Empty";
  else s_det = "Other";
  return s_det;
}


HcalSubdetector HcalAssistant::getSubdetector(std::string _det){
  if      ( _det.find("HB") != std::string::npos ) return HcalBarrel;
  else if ( _det.find("HE") != std::string::npos ) return HcalEndcap;
  else if ( _det.find("HF") != std::string::npos ) return HcalForward;
  else if ( _det.find("HO") != std::string::npos ) return HcalOuter;
  else if ( _det.find("HT") != std::string::npos ) return HcalTriggerTower;
  else return HcalOther;
}

std::string HcalAssistant::getSubdetectorString(HcalSubdetector _det){
  std::string sDet;
  if      ( _det==HcalBarrel)  sDet = "HB";
  else if ( _det==HcalEndcap)  sDet = "HE";
  else if      ( _det==HcalForward) sDet = "HF";
  else if      ( _det==HcalOuter)   sDet = "HO";
  else if      ( _det==HcalTriggerTower)   sDet = "HT";
  else sDet = "other";
  return sDet;
}


std::string HcalAssistant::getZDCSectionString(HcalZDCDetId::Section _section){
  std::string zdcSection;
  if           ( _section==HcalZDCDetId::EM)   zdcSection = "ZDC EM";
  else if      ( _section==HcalZDCDetId::HAD)  zdcSection = "ZDC HAD";
  else if      ( _section==HcalZDCDetId::LUM)  zdcSection = "ZDC LUM";
  else if      ( _section==HcalZDCDetId::RPD)  zdcSection = "ZDC RPD";
  else zdcSection = "UNKNOWN";
  return zdcSection;
}


HcalZDCDetId::Section HcalAssistant::getZDCSection(std::string _section){
  if      ( _section.find("ZDC EM") != std::string::npos ) return HcalZDCDetId::EM;
  else if ( _section.find("ZDC HAD") != std::string::npos ) return HcalZDCDetId::HAD;
  else if ( _section.find("ZDC LUM") != std::string::npos ) return HcalZDCDetId::LUM;
  else if ( _section.find("ZDC RPD") != std::string::npos ) return HcalZDCDetId::RPD;
  else return HcalZDCDetId::Unknown;
}



int HcalAssistant::getListOfChannelsFromDb(){
  int _n_channels = 0;
  static ConnectionManager conn;
  conn.connect();
  std::string query = "select ";
  query            += "       channel_map_id,subdet,ieta,iphi,depth ";
  query            += "from ";
  query            += "       cms_hcl_hcal_cond.hcal_channels ";
  query            += "where ";
  query            += "       subdet='HB' or subdet='HE' or subdet='HF' or subdet='HO' ";
  try {
    oracle::occi::Statement* stmt = conn.getStatement(query);
    oracle::occi::ResultSet *rs = stmt->executeQuery();
    geom_to_rawid.clear();
    rawid_to_geom.clear();
    while (rs->next()) {
      _n_channels++;
      int _rawid = rs->getInt(1);
      int _geomId = getGeomId( getSubdetector(rs->getString(2)),
                   rs->getInt(3),
                   rs->getInt(4),
                   rs->getInt(5)
                   );
      geom_to_rawid.insert(std::pair<int, int>(_geomId, _rawid));
      rawid_to_geom.insert(std::pair<int, int>(_rawid, _geomId));
    }
    listIsRead = true;
  }
  catch (SQLException& e) {
    std::cerr << ::toolbox::toString("Oracle  exception : %s",e.getMessage().c_str()) << std::endl;
    XCEPT_RAISE(hcal::exception::ConfigurationDatabaseException,::toolbox::toString("Oracle  exception : %s",e.getMessage().c_str()));
  }
  conn.disconnect();
  return _n_channels;
}


int HcalAssistant::getGeomId(int _rawid){
  if (listIsRead){
    std::map<int,int>::const_iterator _geomId = rawid_to_geom.find(_rawid);
    if (_geomId!=rawid_to_geom.end()){
      return _geomId->second;
    }
    else return -1;
  }
  else return -1;
}



int HcalAssistant::getRawId(int _geomId){
  if (listIsRead){
    std::map<int,int>::const_iterator _rawid = geom_to_rawid.find(_geomId);
    if (_rawid!=geom_to_rawid.end()){
      return _rawid->second;
    }
    else return -1;
  }
  else return -1;
}


int HcalAssistant::getRawIdFromCmssw(int _geomId){
  std::string s_det = getSubdetectorString(_geomId);
  if ( s_det.find("HB") != std::string::npos ||
       s_det.find("HE") != std::string::npos ||
       s_det.find("HF") != std::string::npos ||
       s_det.find("HO") != std::string::npos ||
       s_det.find("HT") != std::string::npos )
    {
      HcalDetId _id( getSubdetector(s_det),
             getHcalIeta(_geomId),
             getHcalIphi(_geomId),
             getHcalDepth(_geomId)
             );
      return _id.rawId();
    }
  else if ( s_det.find("ZDC") != std::string::npos )
    {
      // FIXME: implement for ZDC channels
      return -1;
    }
  else{
      return -1;
  }
}


int HcalAssistant::getSubdetector(int _rawid){
  return getHcalSubdetector( getGeomId(_rawid) );
}


int HcalAssistant::getIeta(int _rawid){
  return getHcalIeta( getGeomId(_rawid) );
}



int HcalAssistant::getIphi(int _rawid){
  return getHcalIphi( getGeomId(_rawid) );
}



int HcalAssistant::getDepth(int _rawid){
  return getHcalDepth( getGeomId(_rawid) );
}



int HcalAssistant::getRawId(HcalSubdetector _det, int _ieta, int _iphi, int _depth){
  return getRawId( getGeomId(_det, _ieta, _iphi, _depth) );
}




int HcalAssistant::a_to_i(char * inbuf){
  int result;
  sscanf(inbuf,"%d",&result);
  return result;
}