SiStripCondObjBuilderFromDb.cc

Go to the documentation of this file.

#include "OnlineDB/SiStripESSources/interface/SiStripCondObjBuilderFromDb.h"
#include "OnlineDB/SiStripESSources/interface/SiStripFedCablingBuilderFromDb.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "DataFormats/SiStripCommon/interface/SiStripFecKey.h"
#include "DataFormats/SiStripCommon/interface/SiStripFedKey.h"
#include "CondFormats/SiStripObjects/interface/SiStripPedestals.h"
#include "CondFormats/SiStripObjects/interface/SiStripNoises.h"
#include "CondFormats/SiStripObjects/interface/SiStripThreshold.h"
#include "CondFormats/SiStripObjects/interface/SiStripApvGain.h"
#include "CondFormats/SiStripObjects/interface/SiStripLatency.h"
#include "CondFormats/SiStripObjects/interface/SiStripFedCabling.h"
#include "CondFormats/SiStripObjects/interface/FedChannelConnection.h"
#include "CalibFormats/SiStripObjects/interface/SiStripFecCabling.h"
#include "CalibFormats/SiStripObjects/interface/SiStripDetCabling.h"
#include "DataFormats/TrackerCommon/interface/TrackerTopology.h"
#include "CalibFormats/SiStripObjects/interface/SiStripQuality.h"
#include "CalibTracker/SiStripCommon/interface/SiStripDetInfoFileReader.h"

#include <cstdlib>
#include <iostream>
#include <sstream>
#include <iomanip>
#include "Fed9UUtils.hh"

using namespace std;
using namespace sistrip;


// -----------------------------------------------------------------------------
SiStripCondObjBuilderFromDb::SiStripCondObjBuilderFromDb(const edm::ParameterSet& pset,
                             const edm::ActivityRegistry&):
  m_skippedDevices(pset.getUntrackedParameter<edm::VParameterSet>("SkippedDevices", edm::VParameterSet())),
  m_whitelistedDevices(pset.getUntrackedParameter<edm::VParameterSet>("WhitelistedDevices", edm::VParameterSet())),
  m_tickmarkThreshold(static_cast<float>(pset.getUntrackedParameter<double>("TickmarkThreshold",50.))),
  m_gaincalibrationfactor(static_cast<float>(pset.getUntrackedParameter<double>("GainNormalizationFactor",640.))),
  m_defaultpedestalvalue(static_cast<float>(pset.getUntrackedParameter<double>("DefaultPedestal",0.))),
  m_defaultnoisevalue(static_cast<float>(pset.getUntrackedParameter<double>("DefaultNoise",0.))),
  m_defaultthresholdhighvalue(static_cast<float>(pset.getUntrackedParameter<double>("DefaultThresholdHigh",0.))),
  m_defaultthresholdlowvalue(static_cast<float>(pset.getUntrackedParameter<double>("DefaultThresholdLow",0.))),
  m_defaultapvmodevalue(static_cast<uint16_t>(pset.getUntrackedParameter<uint32_t>("DefaultAPVMode",37))),
  m_defaultapvlatencyvalue(static_cast<uint16_t>(pset.getUntrackedParameter<uint32_t>("DefaultAPVLatency",142))),
  m_defaulttickheightvalue(static_cast<float>(pset.getUntrackedParameter<double>("DefaultTickHeight",690.))),
  m_useanalysis(static_cast<bool>(pset.getUntrackedParameter<bool>("UseAnalysis",false))),
  m_usefed(static_cast<bool>(pset.getUntrackedParameter<bool>("UseFED",false))),
  m_usefec(static_cast<bool>(pset.getUntrackedParameter<bool>("UseFEC",false))),
  m_debug(static_cast<bool>(pset.getUntrackedParameter<bool>("DebugMode",false))),
  tTopo(buildTrackerTopology())
{
  LogTrace(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Constructing object...";
  for (const auto &pset : m_skippedDevices){
    skippedDevices.emplace_back(pset);
  }
  for (const auto &pset : m_whitelistedDevices){
    whitelistedDevices.emplace_back(pset);
  }
}

// -----------------------------------------------------------------------------
SiStripCondObjBuilderFromDb::SiStripCondObjBuilderFromDb(): tTopo(buildTrackerTopology())
{
  LogTrace(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Constructing object...";
}

// -----------------------------------------------------------------------------
SiStripCondObjBuilderFromDb::~SiStripCondObjBuilderFromDb() {
  LogTrace(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Destructing object...";
  delete tTopo;
}

// -----------------------------------------------------------------------------

void SiStripCondObjBuilderFromDb::checkUpdate() {
  if (!(dbParams_==dbParams())){
    dbParams_=dbParams();
    buildCondObj();
  }
}
// -----------------------------------------------------------------------------
TrackerTopology * SiStripCondObjBuilderFromDb::buildTrackerTopology() {
  TrackerTopology::PixelBarrelValues pxbVals_;
  TrackerTopology::PixelEndcapValues pxfVals_;
  TrackerTopology::TECValues tecVals_;
  TrackerTopology::TIBValues tibVals_;
  TrackerTopology::TIDValues tidVals_;
  TrackerTopology::TOBValues tobVals_;

  pxbVals_.layerStartBit_        =   16;
  pxbVals_.ladderStartBit_       =   8;
  pxbVals_.moduleStartBit_       =   2;
  pxbVals_.layerMask_            =   0xF;
  pxbVals_.ladderMask_           =   0xFF;
  pxbVals_.moduleMask_           =   0x3F;
  pxfVals_.sideStartBit_         =   23;
  pxfVals_.diskStartBit_         =   16;
  pxfVals_.bladeStartBit_        =   10;
  pxfVals_.panelStartBit_        =   8;
  pxfVals_.moduleStartBit_       =   2;
  pxfVals_.sideMask_             =   0x3;
  pxfVals_.diskMask_             =   0xF;
  pxfVals_.bladeMask_            =   0x3F;
  pxfVals_.panelMask_            =   0x3;
  pxfVals_.moduleMask_           =   0x3F;
  tecVals_.sideStartBit_         =   18;
  tecVals_.wheelStartBit_        =   14;
  tecVals_.petal_fw_bwStartBit_  =   12;
  tecVals_.petalStartBit_        =   8;
  tecVals_.ringStartBit_         =   5;
  tecVals_.moduleStartBit_       =   2;
  tecVals_.sterStartBit_         =   0;
  tecVals_.sideMask_             =   0x3;
  tecVals_.wheelMask_            =   0xF;
  tecVals_.petal_fw_bwMask_      =   0x3;
  tecVals_.petalMask_            =   0xF;
  tecVals_.ringMask_             =   0x7;
  tecVals_.moduleMask_           =   0x7;
  tecVals_.sterMask_             =   0x3;
  tibVals_.layerStartBit_        =   14;
  tibVals_.str_fw_bwStartBit_    =   12;
  tibVals_.str_int_extStartBit_  =   10;
  tibVals_.strStartBit_          =   4;
  tibVals_.moduleStartBit_       =   2;
  tibVals_.sterStartBit_         =   0;
  tibVals_.layerMask_            =   0x7;
  tibVals_.str_fw_bwMask_        =   0x3;
  tibVals_.str_int_extMask_      =   0x3;
  tibVals_.strMask_              =   0x3F;
  tibVals_.moduleMask_           =   0x3;
  tibVals_.sterMask_             =   0x3;
  tidVals_.sideStartBit_         =   13;
  tidVals_.wheelStartBit_        =   11;
  tidVals_.ringStartBit_         =   9;
  tidVals_.module_fw_bwStartBit_ =   7;
  tidVals_.moduleStartBit_       =   2;
  tidVals_.sterStartBit_         =   0;
  tidVals_.sideMask_             =   0x3;
  tidVals_.wheelMask_            =   0x3;
  tidVals_.ringMask_             =   0x3;
  tidVals_.module_fw_bwMask_     =   0x3;
  tidVals_.moduleMask_           =   0x1F;
  tidVals_.sterMask_             =   0x3;
  tobVals_.layerStartBit_        =   14;
  tobVals_.rod_fw_bwStartBit_    =   12;
  tobVals_.rodStartBit_          =   5;
  tobVals_.moduleStartBit_       =   2;
  tobVals_.sterStartBit_         =   0;
  tobVals_.layerMask_            =   0x7;
  tobVals_.rod_fw_bwMask_        =   0x3;
  tobVals_.rodMask_              =   0x7F;
  tobVals_.moduleMask_           =   0x7;
  tobVals_.sterMask_             =   0x3;

  return new TrackerTopology(pxbVals_, pxfVals_, tecVals_, tibVals_, tidVals_, tobVals_);
}
// -----------------------------------------------------------------------------
bool SiStripCondObjBuilderFromDb::checkForCompatibility(std::stringstream& input,std::stringstream& output,std::string& label){
  // DEPRECATED. Superseded by SiStripCondObjBuilderFromDb::getConfigString(const std::type_info& typeInfo).

  //get current config DB parameter

  SiStripDbParams::const_iterator_range partitionsRange = dbParams().partitions();

  SiStripDbParams::SiStripPartitions::const_iterator ipart = partitionsRange.begin();
  SiStripDbParams::SiStripPartitions::const_iterator ipartEnd = partitionsRange.end();
  for ( ; ipart != ipartEnd; ++ipart ) {
    SiStripPartition partition=ipart->second;
    output  << "@ "
        << " Partition " << partition.partitionName() ;
    if (label!="Cabling" && label !="ApvLatency")
    output << " FedVer "    << partition.fedVersion().first << "." << partition.fedVersion().second;
    if(label=="Cabling")
      output << " CabVer "    << partition.cabVersion().first << "." << partition.cabVersion().second
         << " MaskVer "   << partition.maskVersion().first << "." << partition.maskVersion().second;
    if(label=="ApvTiming")
      output<< " ApvTimingVer " << partition.apvTimingVersion().first << "." << partition.apvTimingVersion().second;
    if(label=="ApvLatency")
      output<< " FecVersion " << partition.fecVersion().first << "." << partition.fecVersion().second;
  }

  if (!strcmp(output.str().c_str(),input.str().c_str()))
    return false;

  return true;
}
// -----------------------------------------------------------------------------
std::string SiStripCondObjBuilderFromDb::getConfigString(const std::type_info& typeInfo){
  // create config line used by fast O2O

  std::stringstream output;

  SiStripDbParams::const_iterator_range partitionsRange = dbParams().partitions();
  SiStripDbParams::SiStripPartitions::const_iterator ipart = partitionsRange.begin();
  SiStripDbParams::SiStripPartitions::const_iterator ipartEnd = partitionsRange.end();
  for ( ; ipart != ipartEnd; ++ipart ) {
    SiStripPartition partition=ipart->second;
    output << "%%" << "Partition: " << partition.partitionName();

    // Make everything depend on cabVersion and maskVersion!
    output << " CablingVersion: " << partition.cabVersion().first << "." << partition.cabVersion().second;
    output << " MaskVersion: " << partition.maskVersion().first << "." << partition.maskVersion().second;

    if(typeInfo==typeid(SiStripFedCabling)){
      // Do nothing. FedCabling only depends on cabVersion and maskVersion.
    }
    else if(typeInfo==typeid(SiStripLatency)){
      // Latency is FEC related, add fecVersion.
      output << " FecVersion: " << partition.fecVersion().first << "." << partition.fecVersion().second;
    }else{
      // BadStrip, Noises, Pedestals and Thresholds are FED related, add fecVersion.
      output << " FedVersion: " << partition.fedVersion().first << "." << partition.fedVersion().second;
      if(typeInfo==typeid(SiStripApvGain)){
        // Not used in O2O.
        output << " ApvTimingVersion: " << partition.apvTimingVersion().first << "." << partition.apvTimingVersion().second;
      }
    }
  }

  return output.str();

}
// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::buildCondObj() {
  LogTrace(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]";

  // Check if DB connection is made
  if ( db_ ) {

    // Check if DB connection is made
    if ( db_->deviceFactory() ||
     db_->databaseCache() ) {

      // Build FEC cabling object
      SiStripFecCabling fec_cabling;

      SiStripFedCablingBuilderFromDb::buildFecCabling( &*db_,
                               fec_cabling,
                               sistrip::CABLING_FROM_CONNS );
      fed_cabling_=new SiStripFedCabling;

      SiStripFedCablingBuilderFromDb::getFedCabling( fec_cabling, *fed_cabling_ );
      SiStripDetCabling det_cabling( *fed_cabling_, tTopo );
      buildStripRelatedObjects( &*db_, det_cabling );


      if(m_useanalysis)buildAnalysisRelatedObjects(&*db_, v_trackercon);
      if(m_usefed) buildFEDRelatedObjects(&*db_, v_trackercon);
      if(m_usefec) buildFECRelatedObjects(&*db_, v_trackercon);



    } else {
      edm::LogWarning(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " NULL pointer to DeviceFactory returned by SiStripConfigDb!"
    << " Cannot build Pedestals object!";
    }
  } else {
    edm::LogWarning(mlESSources_)
      << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " NULL pointer to SiStripConfigDb returned by DB \"service\"!"
      << " Cannot build Pedestals object!";
  }
}

// -----------------------------------------------------------------------------
//Retrieve FedDescriptions from configuration database
bool SiStripCondObjBuilderFromDb::retrieveFedDescriptions(SiStripConfigDb* const db){
  SiStripConfigDb::FedDescriptionsRange descriptions = db->getFedDescriptions();
  if ( descriptions.empty() ) {
    edm::LogWarning(mlESSources_)
      << "SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " No FED descriptions found!";

    return false;
  }
  return true;
}

// -----------------------------------------------------------------------------
  // Retrieve gain from configuration database
bool SiStripCondObjBuilderFromDb::retrieveTimingAnalysisDescriptions( SiStripConfigDb* const db){
  SiStripConfigDb::AnalysisDescriptionsRange anal_descriptions =
    db->getAnalysisDescriptions( CommissioningAnalysisDescription::T_ANALYSIS_TIMING );
  if ( anal_descriptions.empty() ) {
    edm::LogWarning(mlESSources_)
      << "SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to build SiStripApvGain object!"
      << " No timing-scan analysis descriptions found!";
    return false;
  }
  return true;
}

// -----------------------------------------------------------------------------
  // Retrieve list of active DetIds
vector<uint32_t> SiStripCondObjBuilderFromDb::retrieveActiveDetIds(const SiStripDetCabling& det_cabling){
  vector<uint32_t> det_ids;
  det_cabling.addActiveDetectorsRawIds(det_ids);
  if ( det_ids.empty() ) {
    edm::LogWarning(mlESSources_)
      << "SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to build Pedestals object!"
      << " No DetIds found!";
    return det_ids;
  }
  LogTrace(mlESSources_)
    << "\n\nSiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Found " << det_ids.size() << " active DetIds";
  return det_ids;
}

// -----------------------------------------------------------------------------
 //build connections per DetId
vector<const FedChannelConnection *> SiStripCondObjBuilderFromDb::buildConnections(const SiStripDetCabling& det_cabling, uint32_t det_id ){
  vector<const FedChannelConnection *> conns = det_cabling.getConnections(det_id);
  if (conns.empty()){
    edm::LogWarning(mlESSources_)
    << "SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Unable to build condition object!"
    << " No FED channel connections found for detid "<< det_id;
  }
  return conns;
}

// -----------------------------------------------------------------------------
//retrieve number of APV pairs per detid
uint16_t SiStripCondObjBuilderFromDb::retrieveNumberAPVPairs(uint32_t det_id){
  uint16_t nApvPairs;
  SiStripDetInfoFileReader * fr=edm::Service<SiStripDetInfoFileReader>().operator->();
  nApvPairs=fr->getNumberOfApvsAndStripLength(det_id).first/2;
  return nApvPairs;
}

// -----------------------------------------------------------------------------
//set default values for Cabling Objects Peds, Noise, thresh, Quality
void SiStripCondObjBuilderFromDb::setDefaultValuesCabling(uint16_t apvPair){
  uint16_t istrip = apvPair*sistrip::STRIPS_PER_FEDCH;
  std::cout << "Found disabled FedConnection!  APVPair: " << apvPair << " Strips: " << sistrip::STRIPS_PER_FEDCH << std::endl;
  inputQuality.push_back(quality_->encode(istrip,sistrip::STRIPS_PER_FEDCH));
  for ( ;istrip < (apvPair+1)*sistrip::STRIPS_PER_FEDCH; ++istrip ){
    pedestals_->setData(m_defaultpedestalvalue,inputPedestals );
    noises_->setData(m_defaultnoisevalue ,inputNoises );
    threshold_->setData( istrip, m_defaultthresholdlowvalue, m_defaultthresholdhighvalue, inputThreshold );
   }
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::setDefaultValuesApvTiming(uint32_t detid, uint32_t apvPair){
  float height = m_defaulttickheightvalue/m_gaincalibrationfactor;

  if (gain_last_){
    auto range = gain_last_->getRange(detid);
    if (apvPair*2 < range.second - range.first){
      height = gain_last_->getApvGain(apvPair*2, range);
      edm::LogWarning(mlESSources_) << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
          << " [ApvGain] Read gain value from last IOV for DetId: " << detid << " ApvPair: " << apvPair << ", value=" << height;
    }else{
      edm::LogWarning(mlESSources_) << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
          << " [ApvGain] Unable to read gain value from last IOV for DetId: " << detid << " ApvPair: " << apvPair << ", use dummy value=" << height;
    }
  } else {
    edm::LogWarning(mlESSources_) << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
        << " [ApvGain] NULL pointer for last stored gain object in DB!!! " << "Will use dummy value=" << height << " for DetId: " << detid << " ApvPair: " << apvPair;
  }

  inputApvGain.push_back(height); // APV0
  inputApvGain.push_back(height); // APV1
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::setDefaultValuesApvLatency(SiStripLatency & latency_, const FedChannelConnection& ipair, uint32_t detid, uint16_t apvnr){
  std::cout << "[SiStripCondObjBuilderFromDb::"<<__func__<<"]: Set Default Latency for Detid: " << detid << " ApvNr: " << apvnr << std::endl;
  if(!latency_.put( detid, apvnr, m_defaultapvmodevalue, m_defaultapvlatencyvalue))
    {
      std::cout << "[SiStripCondObjBuilderFromDb::"<<__func__<<"]: Unable to fill Latency for Detid: " << detid << " ApvNr: " << apvnr << std::endl;
    }
     if(!latency_.put( detid, ++apvnr, m_defaultapvmodevalue, m_defaultapvlatencyvalue))
       {
     std::cout << "[SiStripCondObjBuilderFromDb::"<<__func__<<"]: Unable to fill Latency for Detid: " << detid << " ApvNr: " << apvnr << std::endl;
       }

}



// -----------------------------------------------------------------------------
bool SiStripCondObjBuilderFromDb::setValuesApvTiming(SiStripConfigDb* const db, FedChannelConnection &ipair){
  SiStripConfigDb::AnalysisDescriptionsRange anal_descriptions = db->getAnalysisDescriptions( CommissioningAnalysisDescription::T_ANALYSIS_TIMING );
   SiStripConfigDb::AnalysisDescriptionsV::const_iterator iii = anal_descriptions.begin();
  SiStripConfigDb::AnalysisDescriptionsV::const_iterator jjj = anal_descriptions.end();

  while ( iii != jjj ) {
    CommissioningAnalysisDescription* tmp = *iii;
    uint16_t fed_id = tmp->getFedId();
    uint16_t fed_ch = SiStripFedKey::fedCh( tmp->getFeUnit(), tmp->getFeChan() );
    if ( fed_id == ipair.fedId() && fed_ch == ipair.fedCh() ) { break; }
    iii++;
  }

  TimingAnalysisDescription *anal=nullptr;
  if ( iii != jjj ) { anal = dynamic_cast<TimingAnalysisDescription*>(*iii); }
  if ( !anal ) {
    edm::LogWarning(mlESSources_) << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
        << " [ApvGain] Unable to find Timing Analysis Description from DB for DetId: " << ipair.detId() << " ApvPair:" << ipair.apvPairNumber();
    return false;
  }

  bool is_whitelist = false;
  for (const auto &desc : whitelistedDevices){
    if (desc.isConsistent(ipair)){
      is_whitelist = true;
      if (std::find(whitelistedDetIds.begin(), whitelistedDetIds.end(), ipair.detId()) == whitelistedDetIds.end()){
        whitelistedDetIds.push_back(ipair.detId());
      }
      break;
    }
  }

  if (!is_whitelist){
    // check if this should be skipped only if it is not in the whitelist
    for (const auto &desc : skippedDevices){
      if (desc.isConsistent(ipair)){
        edm::LogInfo(mlESSources_) << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
            << " [ApvGain] Skip module with DetId:" << ipair.detId() << " ApvPair:" << ipair.apvPairNumber()
            << " according to \n" << desc.dump();
        if (std::find(skippedDetIds.begin(), skippedDetIds.end(), ipair.detId()) == skippedDetIds.end()){
          skippedDetIds.push_back(ipair.detId());
        }
        return false;
      }
    }

  }


  if ( anal->getHeight() > m_tickmarkThreshold ) {
    float tick_height = (anal->getHeight() / m_gaincalibrationfactor);
    inputApvGain.push_back( tick_height ); // APV0
    inputApvGain.push_back( tick_height ); // APV1
  } else {
    edm::LogWarning(mlESSources_) << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
        << " [ApvGain] Low tickmark height for DetId:" << ipair.detId() << " ApvPair:" << ipair.apvPairNumber() << ", height=" << anal->getHeight();
    return false;
  }

  return true;
}

// -----------------------------------------------------------------------------
bool SiStripCondObjBuilderFromDb::setValuesApvLatency(SiStripLatency & latency_, SiStripConfigDb* const db, FedChannelConnection &ipair, uint32_t detid, uint16_t apvnr, SiStripConfigDb::DeviceDescriptionsRange apvs  ){
SiStripDetInfoFileReader * fr=edm::Service<SiStripDetInfoFileReader>().operator->();
 fr->getNumberOfApvsAndStripLength(detid);

 SiStripConfigDb::DeviceDescriptionsV::const_iterator iapv = apvs.begin();
 SiStripConfigDb::DeviceDescriptionsV::const_iterator japv = apvs.end();
 if(iapv==japv) return false;
 for ( ; iapv != japv; ++iapv ) {
   apvDescription* apv = dynamic_cast<apvDescription*>( *iapv );
   if ( !apv ) { continue; }
   if((apv->getCrateId()) != (ipair.fecCrate())) continue;
   if((apv->getFecSlot()) != (ipair.fecSlot())) continue;
   if((apv->getRingSlot()) != (ipair.fecRing())) continue;
   if((apv->getCcuAddress()) != (ipair.ccuAddr())) continue;
   if((apv->getChannel()) != (ipair.ccuChan())) continue;
     // Insert latency values into latency object
   if((apv->getAddress()) == (ipair.i2cAddr(0))) {
     if(!latency_.put( detid, apvnr, static_cast<uint16_t>(apv->getLatency()), static_cast<uint16_t>(apv->getApvMode()))){
       std::cout << "UNABLE APVLatency Put: Detid "<< dec<<detid
                 << " APVNr.: " << apvnr
                 << " Latency Value: " << dec <<static_cast<uint16_t>(apv->getLatency())
                 << " APV Mode: " << dec<< static_cast<uint16_t>(apv->getApvMode())
                 << std::endl;
       return false;
     }else{++apvnr;}
   }
   if((apv->getAddress()) == (ipair.i2cAddr(1))) {
     if(!latency_.put( detid, apvnr, static_cast<uint16_t>(apv->getLatency()), static_cast<uint16_t>(apv->getApvMode()))){
       std::cout << "UNABLE APVLatency Put: Detid "<<dec<< detid
                 << " APVNr.: " << apvnr
                 << " Latency Value: " << dec <<static_cast<uint16_t>(apv->getLatency())
                 << " APV Mode: " << dec <<static_cast<uint16_t>(apv->getApvMode())
                 << std::endl;
       continue;
       return false;
     }else{++apvnr;}
   }
  }
 return true;
}

// -----------------------------------------------------------------------------
//bool SiStripCondObjBuilderFromDb::setValuesCabling(SiStripConfigDb* const db, FedChannelConnection &ipair, uint32_t detid){
bool SiStripCondObjBuilderFromDb::setValuesCabling(SiStripConfigDb::FedDescriptionsRange &descriptions, FedChannelConnection &ipair, uint32_t detid){
  //SiStripConfigDb::FedDescriptionsRange descriptions = db->getFedDescriptions();
  SiStripConfigDb::FedDescriptionsV::const_iterator description = descriptions.begin();
  while ( description != descriptions.end() ) {
    if ( (*description)->getFedId() ==ipair.fedId() ) { break; }
    description++;
  }
  if ( description == descriptions.end() ) {return false;}
  // Retrieve Fed9UStrips object from FED description
  const Fed9U::Fed9UStrips& strips = (*description)->getFedStrips();


  // Retrieve StripDescriptions for each APV
  uint16_t jstrip = ipair.apvPairNumber()*sistrip::STRIPS_PER_FEDCH;
  for ( uint16_t iapv = 2*ipair.fedCh(); iapv < 2*ipair.fedCh()+2; iapv++ ) {

    // Get StripDescriptions for the given APV
    Fed9U::Fed9UAddress addr;
    addr.setFedApv(iapv);
    vector<Fed9U::Fed9UStripDescription> strip = strips.getApvStrips(addr);

    vector<Fed9U::Fed9UStripDescription>::const_iterator istrip = strip.begin();

    for ( ; istrip != strip.end(); istrip++ ) {
      pedestals_->setData( istrip->getPedestal() , inputPedestals);
      noises_   ->setData( istrip->getNoise()    , inputNoises );
      threshold_->setData( jstrip, istrip->getLowThresholdFactor(),
               istrip->getHighThresholdFactor(), inputThreshold );
      if(istrip->getDisable()){
    std::cout << "Found disabled strip! Detid: " << detid << " APVNr: " << iapv << " Strips: " << jstrip << std::endl;

    inputQuality.push_back(quality_->encode(jstrip,1));
      }
      jstrip++;
    }
  }
  return true;
}


// -----------------------------------------------------------------------------
//store objects
void SiStripCondObjBuilderFromDb::storePedestals(uint32_t det_id){
  if ( !pedestals_->put(det_id, inputPedestals ) ) {
    std::cout
      << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to insert values into SiStripPedestals object!"
      << " DetId already exists!" << std::endl;
  }
  inputPedestals.clear();

  }



// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::storeNoise(uint32_t det_id){
  // Insert noise values into Noises object

    if ( !noises_->put(det_id, inputNoises ) ) {
      std::cout
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Unable to insert values into SiStripNoises object!"
    << " DetId already exists!" << std::endl;
    }
    inputNoises.clear();

 }

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::storeThreshold(uint32_t det_id){
  // Insert threshold values into Threshold object
    if ( !threshold_->put(det_id, inputThreshold ) ) {
      std::cout
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " Unable to insert values into SiStripThreshold object!"
    << " DetId already exists!" << std::endl;
    }
    inputThreshold.clear();
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::storeQuality(uint32_t det_id){
  // Insert quality values into Quality object
    if (!inputQuality.empty()){
      quality_->compact(det_id,inputQuality);
      if ( !quality_->put(det_id, inputQuality ) ) {
    std::cout
      << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to insert values into SiStripQuality object!"
      << " DetId already exists!" << std::endl;
      }
    }
    inputQuality.clear();
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::storeTiming(uint32_t det_id){
  // Insert tick height values into Gain object
  SiStripApvGain::Range range( inputApvGain.begin(), inputApvGain.end() );
  if ( !gain_->put( det_id, range ) ) {
    edm::LogWarning(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " [ApvGain] Unable to insert values into SiStripApvGain object!"
    << " DetId already exists!";
  }
  inputApvGain.clear();
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::buildStripRelatedObjects( SiStripConfigDb* const db,
                                const SiStripDetCabling& det_cabling){
  //variables needed in this function
  uint16_t nApvPairs;
  vector<uint32_t>::const_iterator det_id;
  vector<uint32_t> det_ids;

  edm::LogInfo(mlESSources_)
    << "\n[SiStripCondObjBuilderFromDb::" << __func__ << "] first call to this method";

  //Check if FedDescriptions exist, if not return
  if (!retrieveFedDescriptions(db)) {std::cout<< "Found no FedDescription!" << std::endl;return;}
  // Retrieve list of active DetIds
  det_cabling.addActiveDetectorsRawIds(det_ids);
  if ( det_ids.empty() ) {
    std::cout
      << "SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to build Pedestals object!"
      << " No DetIds found!" << std::endl;
    return;
  }
  std::cout << "\n\nSiStripCondObjBuilderFromDb::" << __func__ << "]"
        << " Found " << det_ids.size() << " active DetIds";

  // Loop Active DetIds
  det_id = det_ids.begin();
  for ( ; det_id != det_ids.end(); det_id++ ) {
    std::stringstream ssMessage;

    // Ignore NULL DetIds
    if ( !(*det_id) ) { continue; }
    if ( *det_id == sistrip::invalid32_ ) { continue; }


    //build connections per DetId
    const vector<const FedChannelConnection *>& conns=buildConnections(det_cabling, *det_id);

    vector<const FedChannelConnection *>::const_iterator ipair = conns.begin();
    if(conns.empty() ) continue;

    //retrieve number of APV pairs per detid
    nApvPairs=retrieveNumberAPVPairs(*det_id);


    //loop connections and check if APVPair is connected
    vector< vector<const FedChannelConnection *>::const_iterator > listConns(nApvPairs,conns.end());

    for ( ; ipair != conns.end(); ++ipair ){
      // Check if the ApvPair is connected
      if ( !(*ipair) ) continue;
      if ((*ipair)->fedId()!=sistrip::invalid_ && (*ipair)->apvPairNumber()<3){
        // (*ipair)->print(ssMessage);
    // ssMessage<< std::endl;
    listConns[ipair-conns.begin()]=ipair;
      } else {
    std::cout
      << "\n impossible to assign connection position in listConns " << std::endl;
        // (*ipair)->print(ssMessage);
    // ssMessage << std::endl;
      }
    }

    // get data
    // vector< vector<const FedChannelConnection *>::const_iterator >::const_iterator ilistConns=listConns.begin();
    for (uint16_t apvPair=0;apvPair<listConns.size();++apvPair){
      ipair=listConns[apvPair];
          if ( ipair == conns.end() ) {
    // Fill object with default values
    std::cout
      << "\n "
      << " Unable to find FED connection for detid : " << std::dec << *det_id << " APV pair number " << apvPair
      << " Writing default values" << std::endl;
//  (*ipair)->print(ssMessage); // this will crash!
    //If no connection was found, add 100 to apvpair
    apvPair+=100;
    std::cout << " Put apvPair+100:" << apvPair << " into vector!" << std::endl;
    // use dummy FedChannelConnection since it's not used in this case
    FedChannelConnection dummy;
    p_apvpcon=std::make_pair(apvPair,dummy);
    v_apvpcon.push_back(p_apvpcon);
    apvPair=apvPair-100;
    continue;
      }
      p_apvpcon=std::make_pair(apvPair,**ipair);
      v_apvpcon.push_back(p_apvpcon);
    } //conns loop
    p_detcon=std::make_pair(*det_id,v_apvpcon);
    v_trackercon.push_back(p_detcon);
    v_apvpcon.clear();
  } // det id loop
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::buildAnalysisRelatedObjects( SiStripConfigDb* const db, const trackercon& _tc){
  trackercon tc = _tc;
  std::cout << "Entering [SiStripCondObjBuilderFromDb::"<<__func__ <<"]"<<std::endl;
  //data container
  gain_= new SiStripApvGain();

  //check if Timing analysis description is found, otherwise quit
  if(!retrieveTimingAnalysisDescriptions(&*db_)){
    edm::LogWarning(mlESSources_)
      << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " NULL pointer to AnalysisDescriptions returned by SiStripConfigDb!"
      << " Cannot build Analysis object! QUIT";
    throw cms::Exception("Cannot build Analysis object!");
  }

  // Get all detIds from the ideal geometry to build the payload
  SiStripDetInfoFileReader * fr=edm::Service<SiStripDetInfoFileReader>().operator->();
  const std::map<uint32_t, SiStripDetInfoFileReader::DetInfo >& DetInfos  = fr->getAllData();

  for(auto it = DetInfos.begin(); it != DetInfos.end(); ++it){
    // check if det id is correct and if it is actually cabled in the detector
    if( it->first==0 || it->first==sistrip::invalid32_) {
      edm::LogError("DetIdNotGood") << "@SUB=analyze" << "Invalid detid: " << it->first
          << "  ... neglecting!" << std::endl;
      continue;
    }

    uint32_t detid = it->first;
    bool update_ = true;
    i_trackercon det_iter = std::find_if(tc.begin(), tc.end(), [detid](const pair_detcon &p){ return p.first==detid; });
    if(det_iter==tc.end()) {
      update_ = false; // do not update if it is not connected in cabling
    }

    if(update_){
      //loop connections
      for(i_apvpairconn connections=det_iter->second.begin();connections!=det_iter->second.end();connections++){
        uint32_t apvPair =(*connections).first;
        FedChannelConnection ipair =(*connections).second;

        //no connection for apvPair found
        if(apvPair>=100){
          setDefaultValuesApvTiming(detid, apvPair-100);
          continue;
        }

        //fill data
        if(!setValuesApvTiming(db, ipair)){
          // either not found in analysis table or low tickmark height
          setDefaultValuesApvTiming(detid, apvPair);
        }
      }//connections

    }else{
      uint32_t nApvPairs = it->second.nApvs/2;
      for (uint32_t apvPair=0; apvPair<nApvPairs; ++apvPair){
        setDefaultValuesApvTiming(detid, apvPair);
      }
    }

    storeTiming(detid);

  }// end loop detids

  //print out skipped modules
  std::stringstream ss;
  for (const auto &id : whitelistedDetIds){
    ss << "\n" << id;
  }
  edm::LogInfo(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " [ApvGainSummary] " << whitelistedDetIds.size() << " modules are in the whitelist, updates will be ensured: " << ss.str();

  ss.str(""); // clear it!
  for (const auto &skip : skippedDetIds){
    ss << "\n" << skip;
  }
  edm::LogInfo(mlESSources_)
    << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
    << " [ApvGainSummary] Skipped " << skippedDetIds.size() << " modules: " << ss.str();



}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::buildFECRelatedObjects( SiStripConfigDb* const db, const trackercon& _tc){
  trackercon tc = _tc;
  std::cout << "Entering [SiStripCondObjBuilderFromDb::"<<__func__ <<"]"<<std::endl;
  //data container
  latency_ = new SiStripLatency();

  i_trackercon detids_end=tc.end();

  // get APV DeviceDescriptions
  SiStripConfigDb::DeviceDescriptionsRange apvs= db->getDeviceDescriptions( APV25 );;


  //loop detids
  for(i_trackercon detids=tc.begin();detids!=detids_end;detids++){
    uint32_t detid = (*detids).first;
    uint16_t apvnr=1;
    i_apvpairconn connections_end=((*detids).second).end();


    //loop connections
    for(i_apvpairconn connections=((*detids).second).begin();connections!=connections_end;connections++){
      uint32_t apvPair =(*connections).first;
      FedChannelConnection ipair =(*connections).second;

      //no connection for apvPair found
      if(apvPair>=100){
    //setDefaultValuesApvLatency((*latency_),ipair, detid, apvnr);
    std::cout << "[SiStripCondObjBuilderFromDb::" << __func__ << "] No FEDConnection for DetId " << detid << " ApvPair " << apvPair-100 << " found, skipping Latency Insertion!" << std::endl;
    continue;
      }

      //fill data
           if(!setValuesApvLatency((*latency_),db, ipair, detid, apvnr, apvs)){
    std::cout
      << "\n "
      << " Unable to find FEC Description"
      << " Skipping Insertion for DetId: " << detid << std::endl;
      //setDefaultValuesApvLatency((*latency_),ipair, detid, apvnr);
       }
       apvnr+=2;
    }//connections
     // compact Latency Object

  }//detids
  latency_->compress();
  std::stringstream ss;
  // latency debug output
  latency_->printSummary(ss, tTopo);
  latency_->printDebug(ss, tTopo);
  std::cout << ss.str() << std::endl;
}

// -----------------------------------------------------------------------------
void SiStripCondObjBuilderFromDb::buildFEDRelatedObjects( SiStripConfigDb* const db, const trackercon& _tc){
  trackercon tc = _tc;
  std::cout << "Entering [SiStripCondObjBuilderFromDb::"<<__func__ <<"]"<<std::endl;

  //data containers
  pedestals_= new SiStripPedestals();
  noises_ = new SiStripNoises();
  threshold_= new SiStripThreshold();
  quality_ = new SiStripQuality();

  i_trackercon detids_end=tc.end();

  //Build FED Descriptions out of db object
  SiStripConfigDb::FedDescriptionsRange descriptions = db->getFedDescriptions();

  //loop detids
  for(i_trackercon detids=tc.begin();detids!=detids_end;detids++){
    uint32_t detid = (*detids).first;
    i_apvpairconn connections_end=((*detids).second).end();

    //loop connections
    for(i_apvpairconn connections=((*detids).second).begin();connections!=connections_end;connections++){
      uint32_t apvPair =(*connections).first;
      FedChannelConnection ipair =(*connections).second;

      //no connection for apvPair found
      if(apvPair>=100){
    std::cout
      << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to find FED description for FED id: " << ipair.fedId()
      << " detid : " << detid << " APV pair number " << apvPair
      << " Writing default values"<< std::endl;
    setDefaultValuesCabling((apvPair-100));
    continue;
      }
      //  if(!setValuesCabling(db, ipair, detid)){
      if(!setValuesCabling(descriptions, ipair, detid)){
    std::cout
      << "[SiStripCondObjBuilderFromDb::" << __func__ << "]"
      << " Unable to find FED description for FED id: " << ipair.fedId()
      << " detid : " << detid << " APV pair number " << apvPair
      << " Writing default values"<< std::endl;
    setDefaultValuesCabling(apvPair);
      }
    }//connections
    storePedestals(detid);
    storeNoise(detid);
    storeThreshold(detid);
    storeQuality(detid);
  }//detids
}

SiStripCondObjBuilderFromDb::SkipDeviceDescription::SkipDeviceDescription():
    fec_(sistrip::invalid_),
    fed_(sistrip::invalid_),
    detid_(sistrip::invalid32_)
{}

SiStripCondObjBuilderFromDb::SkipDeviceDescription::SkipDeviceDescription(const edm::ParameterSet& pset):
    fec_(pset.getUntrackedParameter<uint32_t>("fecCrate", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("fecSlot", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("fecRing", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("ccuAddr", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("ccuChan", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("lldChan", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("i2cAddr", sistrip::invalid_)),
    fed_(pset.getUntrackedParameter<uint32_t>("fedId", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("feUnit", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("feChan", sistrip::invalid_),
        pset.getUntrackedParameter<uint32_t>("fedApv", sistrip::invalid_)),
    detid_(pset.getUntrackedParameter<uint32_t>("detid", sistrip::invalid32_))
{
  if (!fec_.isValid() && !fed_.isValid() && detid_==sistrip::invalid32_){
    throw cms::Exception("InvalidPSet") << "None of FEC coordinates/FED coordinates/detids are valid in this PSet!\n" << pset.dump(2);
  }
}

bool SiStripCondObjBuilderFromDb::SkipDeviceDescription::isConsistent(const FedChannelConnection &fc) const {

  auto comp = [](uint16_t desc, uint16_t device) { return desc==0 || desc==device; };

  // use FEC coordinates first if provided
  if (fec_.isValid()){
    return comp(fec_.fecCrate(), fc.fecCrate())
        && comp(fec_.fecSlot(), fc.fecSlot())
        && comp(fec_.fecRing(), fc.fecRing())
        && comp(fec_.ccuAddr(), fc.ccuAddr())
        && comp(fec_.ccuChan(), fc.ccuChan())
        && comp(fec_.lldChan(), fc.lldChannel())
        && (comp(fec_.i2cAddr(), fc.i2cAddr(0)) || comp(fec_.i2cAddr(), fc.i2cAddr(1))); // do not distinguish between APV1 and APV2
  }

  // then try FED coordinates
  if (fed_.isValid()){
    return comp(fed_.fedId(), fc.fedId())
        && comp(fed_.feUnit(), SiStripFedKey::feUnit(fc.fedCh()))
        && comp(fed_.feChan(), SiStripFedKey::feChan(fc.fedCh()));
    // no fedApv in FedChannelConnection -- and we do not distinguish between APV1 and APV2
  }

  // last try detids (will skip all APVs on the module)
  if (detid_!=sistrip::invalid32_){
    return detid_ == fc.detId();
  }

  return false;
}

std::string SiStripCondObjBuilderFromDb::SkipDeviceDescription::dump() const {
  std::stringstream ss;
  fec_.terse(ss);
  ss << "\n";
  fed_.terse(ss);
  ss << "\n";
  ss << "detid=" << detid_;
  return ss.str();
}