SiStripDbParams.cc

Go to the documentation of this file.

#include "OnlineDB/SiStripConfigDb/interface/SiStripDbParams.h"
#include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include <iostream>

using namespace sistrip;

// -----------------------------------------------------------------------------
// 
SiStripDbParams::SiStripDbParams() :
  usingDb_(false),
  confdb_(null_),
  user_(null_),
  passwd_(null_),
  path_(null_),
  usingDbCache_(false),
  sharedMemory_(""),
  tnsAdmin_(""),
  partitions_(),
  outputModuleXml_("/tmp/module.xml"),
  outputDcuInfoXml_("/tmp/dcuinfo.xml"),
  outputFecXml_("/tmp/fec.xml"),
  outputFedXml_("/tmp/fed.xml")
{;}

// -----------------------------------------------------------------------------
// 
SiStripDbParams::SiStripDbParams( const SiStripDbParams& input ) :
  usingDb_( input.usingDb() ),
  confdb_( input.confdb() ),
  user_( input.user() ),
  passwd_( input.passwd() ),
  path_( input.path() ),
  usingDbCache_( input.usingDbCache() ),
  sharedMemory_( input.sharedMemory() ),
  tnsAdmin_( input.tnsAdmin() ),
  partitions_( input.partitions().begin(), input.partitions().end() ),
  outputModuleXml_( input.outputModuleXml() ),
  outputDcuInfoXml_( input.outputDcuInfoXml() ),
  outputFecXml_( input.outputFecXml() ),
  outputFedXml_( input.outputFedXml() )
{;}

// -----------------------------------------------------------------------------
// 
SiStripDbParams& SiStripDbParams::operator= ( const SiStripDbParams& input ) {
  usingDb_ = input.usingDb();
  confdb_ = input.confdb();
  user_ = input.user();
  passwd_ = input.passwd();
  path_ = input.path();
  confdb( confdb_ );
  usingDbCache_ = input.usingDbCache();
  sharedMemory_ = input.sharedMemory();
  tnsAdmin_ = input.tnsAdmin();
  partitions_.clear();
  partitions_ = SiStripPartitions( input.partitions().begin(), input.partitions().end() );
  outputModuleXml_ = input.outputModuleXml();
  outputDcuInfoXml_ = input.outputDcuInfoXml();
  outputFecXml_ = input.outputFecXml(); 
  outputFedXml_ = input.outputFedXml();
  return *this;
}

// -----------------------------------------------------------------------------
// 
bool SiStripDbParams::operator== ( const SiStripDbParams& input ) const {
  if ( !( usingDb_ == input.usingDb() &&
      confdb_ == input.confdb() && 
      user_ == input.user() &&
      passwd_ == input.passwd() &&
      path_ == input.path() &&
      usingDbCache_ == input.usingDbCache() &&
      sharedMemory_ == input.sharedMemory() &&
      tnsAdmin_ == input.tnsAdmin() &&
      outputModuleXml_ == input.outputModuleXml() &&
      outputDcuInfoXml_ == input.outputDcuInfoXml() &&
      outputFecXml_ == input.outputFecXml() && 
      outputFedXml_ == input.outputFedXml() ) ) { return false; }
  if ( partitionsSize() != input.partitionsSize() ) { return false; }
//   SiStripPartitions::const_iterator ii = input.partitions().begin();
//   SiStripPartitions::const_iterator jj = input.partitions().end();
//   SiStripPartitions::const_iterator iter = partitions_.begin();
//   for ( ; ii != jj; ++ii ) {
//     if ( ii->first != iter->first || ii->second != iter->second ) { return false; }
//     iter++;
//   }
//   return true;
  return partitions_ == input.partitions_;
}

// -----------------------------------------------------------------------------
// 
bool SiStripDbParams::operator!= ( const SiStripDbParams& input ) const {
  return !( *this == input );
}

// -----------------------------------------------------------------------------
// 
SiStripDbParams::~SiStripDbParams() {
  reset();
}

// -----------------------------------------------------------------------------
// 
void SiStripDbParams::reset() {
  usingDb_      = false;
  confdb_       = null_;
  user_         = null_;
  passwd_       = null_;
  path_         = null_;
  usingDbCache_ = false;
  sharedMemory_ = "";
  tnsAdmin_     = "";
  partitions_.clear();
  confdb( confdb_ );
  outputModuleXml_  = "/tmp/module.xml";
  outputDcuInfoXml_ = "/tmp/dcuinfo.xml";
  outputFecXml_     = "/tmp/fec.xml";
  outputFedXml_     = "/tmp/fed.xml";
}

// -----------------------------------------------------------------------------
// 
void SiStripDbParams::addPartition( const SiStripPartition& in ) {

  if ( in.partitionName() == "" ) {
    std::stringstream ss;
    ss << "[SiStripDbParams::" << __func__ << "]"
       << " Attempting to add partition with null name!";
    //edm::LogWarning(mlConfigDb_) << ss.str();
  }

  SiStripPartitions::const_iterator iter = partitions_.find( in.partitionName() );
  if ( iter == partitions_.end() ) { 
    partitions_[in.partitionName()] = in; 
    if ( in.partitionName() != SiStripPartition::defaultPartitionName_ ) {
      std::stringstream ss;
      ss << "[SiStripDbParams::" << __func__ << "]"
     << " Added new partition with name \"" 
     << in.partitionName() << "\"";
      //ss << std::endl << partitions_[in.partitionName()];
      ss << " (Currently have " 
     << partitions_.size()
     << " partitions in cache...)";
      LogTrace(mlConfigDb_) << ss.str();
    }
  } else {
    std::stringstream ss;
    ss << "[SiStripDbParams::" << __func__ << "]"
       << " Partition with name \""
       << in.partitionName()
       << "\" already found!"
       << " Not adding to cache...";
    edm::LogWarning(mlConfigDb_) << ss.str();
  }

}

// -----------------------------------------------------------------------------
// 
void SiStripDbParams::pset( const edm::ParameterSet& cfg ) {

  // "Common" configurables
  usingDb_      = cfg.getUntrackedParameter<bool>( "UsingDb", false ); 
  usingDbCache_ = cfg.getUntrackedParameter<bool>( "UsingDbCache", false ); 
  sharedMemory_ = cfg.getUntrackedParameter<std::string>( "SharedMemory", "" ); 
  tnsAdmin_     = cfg.getUntrackedParameter<std::string>( "TNS_ADMIN", "" );
  confdb( cfg.getUntrackedParameter<std::string>( "ConfDb", "") );

  // Check if top-level PSet (containing partition-level Psets) exists
  std::string partitions = "Partitions";
  std::vector<std::string> str = cfg.getParameterNamesForType<edm::ParameterSet>(false);
  std::vector<std::string>::const_iterator istr = std::find( str.begin(), str.end(), partitions );
  if ( istr != str.end() ) {

    // Retrieve top-level PSet containing partition-level Psets
    edm::ParameterSet psets = cfg.getUntrackedParameter<edm::ParameterSet>( partitions );
    
    // Extract names of partition-level PSets
    std::vector<std::string> names = psets.getParameterNamesForType<edm::ParameterSet>(false);
    
    // Iterator through PSets names, retrieve PSet for each partition and extract info
    std::vector<std::string>::iterator iname = names.begin();
    std::vector<std::string>::iterator jname = names.end();
    for ( ; iname != jname; ++iname ) {
      edm::ParameterSet pset = psets.getUntrackedParameter<edm::ParameterSet>( *iname );
      SiStripPartition tmp;
      tmp.pset( pset );
      addPartition( tmp );
    }

  }
  
  // Ensure at least one "default" partition
  if ( partitions_.empty() ) { addPartition( SiStripPartition() ); }

  // Set output XML files
  outputModuleXml_  = cfg.getUntrackedParameter<std::string>( "OutputModuleXml", "/tmp/module.xml" );
  outputDcuInfoXml_ = cfg.getUntrackedParameter<std::string>( "OutputDcuInfoXml", "/tmp/dcuinfo.xml" );
  outputFecXml_     = cfg.getUntrackedParameter<std::string>( "OutputFecXml", "/tmp/fec.xml" );
  outputFedXml_     = cfg.getUntrackedParameter<std::string>( "OutputFedXml", "/tmp/fed.xml" );
  
}

// -----------------------------------------------------------------------------
// 
void SiStripDbParams::confdb( const std::string& confdb ) {
  confdb_ = confdb;
  size_t ipass = confdb.find("/");
  size_t ipath = confdb.find("@");
  if ( ipass != std::string::npos && 
       ipath != std::string::npos ) {
    user_   = confdb.substr(0,ipass); 
    passwd_ = confdb.substr(ipass+1,ipath-ipass-1); 
    path_   = confdb.substr(ipath+1,confdb.size());
  } else {
    user_   = null_;
    passwd_ = null_;
    path_   = null_;
  }
}

// -----------------------------------------------------------------------------
// 
void SiStripDbParams::confdb( const std::string& user,
                  const std::string& passwd,
                  const std::string& path ) {
  if ( user != "" && passwd != "" && path != "" &&
       user != null_ && passwd != null_ && path != null_ ) {
    user_   = user;
    passwd_ = passwd;
    path_   = path;
  } else {
    user_   = null_;
    passwd_ = null_;
    path_   = null_;
  }
  confdb_ = user_ + "/" + passwd_ + "@" + path_;
}

// -----------------------------------------------------------------------------
// 
SiStripDbParams::SiStripPartitions::const_iterator SiStripDbParams::partition( std::string partition_name ) const {
  SiStripDbParams::SiStripPartitions::const_iterator ii = partitions().begin();
  SiStripDbParams::SiStripPartitions::const_iterator jj = partitions().end();
  for ( ; ii != jj; ++ii ) { if ( partition_name == ii->second.partitionName() ) { return ii; } }
  return partitions().end(); 
}

// -----------------------------------------------------------------------------
// 
SiStripDbParams::SiStripPartitions::iterator SiStripDbParams::partition( std::string partition_name ) {
  SiStripDbParams::SiStripPartitions::iterator ii = partitions().begin();
  SiStripDbParams::SiStripPartitions::iterator jj = partitions().end();
  for ( ; ii != jj; ++ii ) { if ( partition_name == ii->second.partitionName() ) { return ii; } }
  return partitions().end(); 
}

// -----------------------------------------------------------------------------
// 
std::vector<std::string> SiStripDbParams::partitionNames() const {
  std::vector<std::string> partitions;
  SiStripPartitions::const_iterator ii = partitions_.begin();
  SiStripPartitions::const_iterator jj = partitions_.end();
  for ( ; ii != jj; ++ii ) { 
    if ( std::find( partitions.begin(), 
            partitions.end(), 
            ii->second.partitionName() ) == partitions.end() ) {
      if ( !ii->second.partitionName().empty() ) { partitions.push_back( ii->second.partitionName() ); }
    } else {
      edm::LogWarning(mlConfigDb_)
    << "[SiStripConfigDb::" << __func__ << "]"
    << " Partition " << ii->second.partitionName()
    << " already found! Not adding to vector...";
    }
  }
  return partitions;
}

// -----------------------------------------------------------------------------
// 
std::vector<std::string> SiStripDbParams::partitionNames( std::string input ) const {
  std::istringstream ss(input);
  std::vector<std::string> partitions;
  std::string delimiter = ":";
  std::string token;
  while ( getline( ss, token, ':' ) ) { if ( !token.empty() ) { partitions.push_back(token); } }
  return partitions;
}

// -----------------------------------------------------------------------------
// 
std::string SiStripDbParams::partitionNames( const std::vector<std::string>& partitions ) const {
  std::stringstream ss;
  std::vector<std::string>::const_iterator ii = partitions.begin();
  std::vector<std::string>::const_iterator jj = partitions.end();
  bool first = true;
  for ( ; ii != jj; ++ii ) { 
    if ( !ii->empty() ) { 
      first ? ss << *ii : ss << ":" << *ii; 
      first = false;
    }
  }
  return ss.str();
}

// -----------------------------------------------------------------------------
// 
void SiStripDbParams::print( std::stringstream& ss ) const {

  ss << " Using database account     : " << std::boolalpha << usingDb_ << std::noboolalpha << std::endl;
  ss << " Using XML files            : " << std::boolalpha << !usingDb_ << std::noboolalpha << std::endl;
  ss << " Using database cache       : " << std::boolalpha << usingDbCache_ << std::noboolalpha << std::endl;
  if ( usingDbCache_ ) { 
    ss << " Shared memory name         : " << std::boolalpha << sharedMemory_ << std::noboolalpha << std::endl;
  }

  if ( !usingDbCache_ ) {

    if ( usingDb_ ) {
      ss << " Database account (ConfDb)  : " << user_ + "/******@" + path_ << std::endl;
    }
    
    ss << " Number of partitions       : " << partitions_.size();
    if ( partitions_.empty() ) { 
      if ( !usingDbCache_ ) { ss << " (Empty!)"; }
      else { ss << " (Using database cache!)"; }
    }
    ss << std::endl;
    
    uint16_t cntr = 0;
    SiStripPartitions::const_iterator ii = partitions_.begin();
    SiStripPartitions::const_iterator jj = partitions_.end();
    for ( ; ii != jj; ++ii ) { 
      cntr++;
      ss << " Partition #" << cntr << " (out of " << partitions_.size() << "):" << std::endl;
      ii->second.print( ss, usingDb_ ); 
    }
    
    if ( !usingDb_ ) {
      ss << " Output \"module.xml\" file   : " << outputModuleXml_ << std::endl
     << " Output \"dcuinfo.xml\" file  : " << outputDcuInfoXml_ << std::endl
     << " Output \"fec.xml\" file(s)   : " << outputFecXml_ << std::endl
     << " Output \"fed.xml\" file(s)   : " << outputFedXml_ << std::endl;
    }

  }
 
}

// -----------------------------------------------------------------------------
// 
std::ostream& operator<< ( std::ostream& os, const SiStripDbParams& params ) {
  std::stringstream ss;
  params.print(ss);
  os << ss.str();
  return os;
}

// -----------------------------------------------------------------------------
// 
std::vector<std::string> SiStripDbParams::inputModuleXmlFiles() const {
  std::vector<std::string> files;
  SiStripPartitions::const_iterator ii = partitions_.begin();
  SiStripPartitions::const_iterator jj = partitions_.end();
  for ( ; ii != jj; ++ii ) { files.insert( files.end(), ii->second.inputModuleXml() ); }
  return files;
}

// -----------------------------------------------------------------------------
// 
std::vector<std::string> SiStripDbParams::inputDcuInfoXmlFiles() const {
  std::vector<std::string> files;
  SiStripPartitions::const_iterator ii = partitions_.begin();
  SiStripPartitions::const_iterator jj = partitions_.end();
  for ( ; ii != jj; ++ii ) { files.insert( files.end(), ii->second.inputDcuInfoXml() ); }
  return files;
}

// -----------------------------------------------------------------------------
// 
std::vector<std::string> SiStripDbParams::inputFecXmlFiles() const {
  std::vector<std::string> files;
  SiStripPartitions::const_iterator ii = partitions_.begin();
  SiStripPartitions::const_iterator jj = partitions_.end();
  for ( ; ii != jj; ++ii ) { files.insert( files.end(), ii->second.inputFecXml().begin(), ii->second.inputFecXml().end() ); }
  return files;
}

// -----------------------------------------------------------------------------
// 
std::vector<std::string> SiStripDbParams::inputFedXmlFiles() const {
  std::vector<std::string> files;
  SiStripPartitions::const_iterator ii = partitions_.begin();
  SiStripPartitions::const_iterator jj = partitions_.end();
  for ( ; ii != jj; ++ii ) { files.insert( files.end(), ii->second.inputFedXml().begin(), ii->second.inputFedXml().end() ); }
  return files;
}