Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-02-14 13:32:17

0001 
0002 #include "OnlineDB/SiStripConfigDb/interface/SiStripPartition.h"
0003 #include "DataFormats/SiStripCommon/interface/SiStripEnumsAndStrings.h"
0004 #include "FWCore/MessageLogger/interface/MessageLogger.h"
0005 #include "OnlineDB/SiStripConfigDb/interface/SiStripConfigDb.h"
0006 #include <iostream>
0007 #include <cmath>
0008 
0009 using namespace sistrip;
0010 
0011 // -----------------------------------------------------------------------------
0012 //
0013 const std::string SiStripPartition::defaultPartitionName_ = "DefaultPartition";
0014 
0015 // -----------------------------------------------------------------------------
0016 //
0017 SiStripPartition::SiStripPartition()
0018     : partitionName_(defaultPartitionName_),
0019       runNumber_(0),
0020       runType_(sistrip::UNDEFINED_RUN_TYPE),
0021       forceVersions_(false),
0022       forceCurrentState_(false),
0023       cabVersion_(0, 0),
0024       fedVersion_(0, 0),
0025       fecVersion_(0, 0),
0026       dcuVersion_(0, 0),
0027       psuVersion_(0, 0),
0028       //#ifdef USING_DATABASE_MASKING
0029       maskVersion_(0, 0),
0030       //#endif
0031       globalAnalysisV_(0),
0032       runTableVersion_(0, 0),
0033       fastCablingV_(0, 0),
0034       apvTimingV_(0, 0),
0035       optoScanV_(0, 0),
0036       vpspScanV_(0, 0),
0037       apvCalibV_(0, 0),
0038       pedestalsV_(0, 0),
0039       pedsFullNoiseV_(0, 0),
0040       apvLatencyV_(0, 0),
0041       fineDelayV_(0, 0),
0042       inputModuleXml_(""),
0043       inputDcuInfoXml_(""),
0044       inputFecXml_(),
0045       inputFedXml_() {
0046   ;
0047 }
0048 
0049 // -----------------------------------------------------------------------------
0050 //
0051 SiStripPartition::SiStripPartition(std::string partition)
0052     : partitionName_(partition),
0053       runNumber_(0),
0054       runType_(sistrip::UNDEFINED_RUN_TYPE),
0055       forceVersions_(false),
0056       forceCurrentState_(false),
0057       cabVersion_(0, 0),
0058       fedVersion_(0, 0),
0059       fecVersion_(0, 0),
0060       dcuVersion_(0, 0),
0061       psuVersion_(0, 0),
0062       //#ifdef USING_DATABASE_MASKING
0063       maskVersion_(0, 0),
0064       //#endif
0065       globalAnalysisV_(0),
0066       runTableVersion_(0, 0),
0067       fastCablingV_(0, 0),
0068       apvTimingV_(0, 0),
0069       optoScanV_(0, 0),
0070       vpspScanV_(0, 0),
0071       apvCalibV_(0, 0),
0072       pedestalsV_(0, 0),
0073       pedsFullNoiseV_(0, 0),
0074       apvLatencyV_(0, 0),
0075       fineDelayV_(0, 0),
0076       inputModuleXml_(""),
0077       inputDcuInfoXml_(""),
0078       inputFecXml_(),
0079       inputFedXml_() {
0080   if (partitionName_.empty()) {
0081     partitionName_ = defaultPartitionName_;
0082   }
0083 }
0084 
0085 // -----------------------------------------------------------------------------
0086 //
0087 SiStripPartition::SiStripPartition(const SiStripPartition& input)
0088     : partitionName_(input.partitionName()),
0089       runNumber_(input.runNumber()),
0090       runType_(input.runType()),
0091       forceVersions_(input.forceVersions()),
0092       forceCurrentState_(input.forceCurrentState()),
0093       cabVersion_(input.cabVersion()),
0094       fedVersion_(input.fedVersion()),
0095       fecVersion_(input.fecVersion()),
0096       dcuVersion_(input.dcuVersion()),
0097       psuVersion_(input.psuVersion()),
0098       //#ifdef USING_DATABASE_MASKING
0099       maskVersion_(input.maskVersion()),
0100       //#endif
0101       globalAnalysisV_(input.globalAnalysisVersion()),
0102       runTableVersion_(input.runTableVersion()),
0103       fastCablingV_(input.fastCablingVersion()),
0104       apvTimingV_(input.apvTimingVersion()),
0105       optoScanV_(input.optoScanVersion()),
0106       vpspScanV_(input.vpspScanVersion()),
0107       apvCalibV_(input.apvCalibVersion()),
0108       pedestalsV_(input.pedestalsVersion()),
0109       pedsFullNoiseV_(input.pedsFullNoiseVersion()),
0110       apvLatencyV_(input.apvLatencyVersion()),
0111       fineDelayV_(input.fineDelayVersion()),
0112       inputModuleXml_(input.inputModuleXml()),
0113       inputDcuInfoXml_(input.inputDcuInfoXml()),
0114       inputFecXml_(input.inputFecXml()),
0115       inputFedXml_(input.inputFedXml()) {
0116   ;
0117 }
0118 
0119 // -----------------------------------------------------------------------------
0120 //
0121 SiStripPartition& SiStripPartition::operator=(const SiStripPartition& input) {
0122   if (this == &input) {
0123     return *this;
0124   }  // self-assignment
0125   partitionName_ = input.partitionName();
0126   runNumber_ = input.runNumber();
0127   runType_ = input.runType();
0128   forceVersions_ = input.forceVersions();
0129   forceCurrentState_ = input.forceCurrentState();
0130   cabVersion_ = input.cabVersion();
0131   fedVersion_ = input.fedVersion();
0132   fecVersion_ = input.fecVersion();
0133   dcuVersion_ = input.dcuVersion();
0134   psuVersion_ = input.psuVersion();
0135   //#ifdef USING_DATABASE_MASKING
0136   maskVersion_ = input.maskVersion();
0137   //#endif
0138   globalAnalysisV_ = input.globalAnalysisVersion();
0139   runTableVersion_ = input.runTableVersion();
0140   fastCablingV_ = input.fastCablingVersion();
0141   apvTimingV_ = input.apvTimingVersion();
0142   optoScanV_ = input.optoScanVersion();
0143   vpspScanV_ = input.vpspScanVersion();
0144   apvCalibV_ = input.apvCalibVersion();
0145   pedestalsV_ = input.pedestalsVersion();
0146   pedsFullNoiseV_ = input.pedsFullNoiseVersion();
0147   apvLatencyV_ = input.apvLatencyVersion();
0148   fineDelayV_ = input.fineDelayVersion();
0149   inputModuleXml_ = input.inputModuleXml();
0150   inputDcuInfoXml_ = input.inputDcuInfoXml();
0151   inputFecXml_ = input.inputFecXml();
0152   inputFedXml_ = input.inputFedXml();
0153   return *this;
0154 }
0155 
0156 // -----------------------------------------------------------------------------
0157 //
0158 bool SiStripPartition::operator==(const SiStripPartition& input) const {
0159   return (partitionName_ == input.partitionName() && runNumber_ == input.runNumber() && runType_ == input.runType() &&
0160           forceVersions_ == input.forceVersions() && forceCurrentState_ == input.forceCurrentState() &&
0161           cabVersion_ == input.cabVersion() && fedVersion_ == input.fedVersion() && fecVersion_ == input.fecVersion() &&
0162           dcuVersion_ == input.dcuVersion() && psuVersion_ == input.psuVersion() &&
0163           //#ifdef USING_DATABASE_MASKING
0164           maskVersion_ == input.maskVersion() &&
0165           //#endif
0166           globalAnalysisV_ == input.globalAnalysisVersion() && runTableVersion_ == input.runTableVersion() &&
0167           fastCablingV_ == input.fastCablingVersion() && apvTimingV_ == input.apvTimingVersion() &&
0168           optoScanV_ == input.optoScanVersion() && vpspScanV_ == input.vpspScanVersion() &&
0169           apvCalibV_ == input.apvCalibVersion() && pedestalsV_ == input.pedestalsVersion() &&
0170           pedsFullNoiseV_ == input.pedsFullNoiseVersion() && apvLatencyV_ == input.apvLatencyVersion() &&
0171           fineDelayV_ == input.fineDelayVersion() && inputModuleXml_ == input.inputModuleXml() &&
0172           inputDcuInfoXml_ == input.inputDcuInfoXml() && inputFecXml_ == input.inputFecXml() &&
0173           inputFedXml_ == input.inputFedXml());
0174 }
0175 
0176 // -----------------------------------------------------------------------------
0177 //
0178 bool SiStripPartition::operator!=(const SiStripPartition& input) const { return !(*this == input); }
0179 
0180 // -----------------------------------------------------------------------------
0181 //
0182 SiStripPartition::~SiStripPartition() {
0183   inputFecXml_.clear();
0184   inputFedXml_.clear();
0185 }
0186 
0187 // -----------------------------------------------------------------------------
0188 //
0189 void SiStripPartition::reset() {
0190   partitionName_ = "";
0191   runNumber_ = 0;
0192   runType_ = sistrip::UNDEFINED_RUN_TYPE;
0193   forceVersions_ = false;
0194   forceCurrentState_ = false;
0195 
0196   cabVersion_ = std::make_pair(0, 0);
0197   fedVersion_ = std::make_pair(0, 0);
0198   fecVersion_ = std::make_pair(0, 0);
0199   dcuVersion_ = std::make_pair(0, 0);
0200   psuVersion_ = std::make_pair(0, 0);
0201   //#ifdef USING_DATABASE_MASKING
0202   maskVersion_ = std::make_pair(0, 0);
0203   //#endif
0204 
0205   globalAnalysisV_ = 0;
0206   runTableVersion_ = std::make_pair(0, 0);
0207   fastCablingV_ = std::make_pair(0, 0);
0208   apvTimingV_ = std::make_pair(0, 0);
0209   optoScanV_ = std::make_pair(0, 0);
0210   vpspScanV_ = std::make_pair(0, 0);
0211   apvCalibV_ = std::make_pair(0, 0);
0212   pedestalsV_ = std::make_pair(0, 0);
0213   pedsFullNoiseV_ = std::make_pair(0, 0);
0214   apvLatencyV_ = std::make_pair(0, 0);
0215   fineDelayV_ = std::make_pair(0, 0);
0216 
0217   inputModuleXml_ = "";
0218   inputDcuInfoXml_ = "";
0219   inputFecXml_.clear();
0220   inputFecXml_.push_back("");
0221   inputFedXml_.clear();
0222   inputFedXml_.push_back("");
0223 }
0224 
0225 // -----------------------------------------------------------------------------
0226 //
0227 void SiStripPartition::pset(const edm::ParameterSet& pset) {
0228   partitionName_ = pset.getUntrackedParameter<std::string>("PartitionName", "");
0229   runNumber_ = pset.getUntrackedParameter<unsigned int>("RunNumber", 0);
0230   forceVersions_ = pset.getUntrackedParameter<bool>("ForceVersions", false);
0231   forceCurrentState_ = pset.getUntrackedParameter<bool>("ForceCurrentState", false);
0232 
0233   std::vector<uint32_t> tmp1(2, 0);
0234   cabVersion_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("CablingVersion", tmp1));
0235   fedVersion_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("FedVersion", tmp1));
0236   fecVersion_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("FecVersion", tmp1));
0237   dcuVersion_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("DcuDetIdsVersion", tmp1));
0238   psuVersion_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("DcuPsuMapVersion", tmp1));
0239   //#ifdef USING_DATABASE_MASKING
0240   maskVersion_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("MaskVersion", tmp1));
0241   //#endif
0242 
0243   std::vector<uint32_t> tmp2(2, 0);
0244   globalAnalysisV_ = pset.getUntrackedParameter<uint32_t>("GlobalAnalysisVersion", 0);
0245   fastCablingV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("FastCablingVersion", tmp2));
0246   apvTimingV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("ApvTimingVersion", tmp2));
0247   optoScanV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("OptoScanVersion", tmp2));
0248   vpspScanV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("VpspScanVersion", tmp2));
0249   apvCalibV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("ApvCalibVersion", tmp2));
0250   pedestalsV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("PedestalsVersion", tmp2));
0251   pedsFullNoiseV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("PedsFullNoiseVersion", tmp2));
0252   apvLatencyV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("ApvLatencyVersion", tmp2));
0253   fineDelayV_ = versions(pset.getUntrackedParameter<std::vector<uint32_t> >("FineDelayVersion", tmp2));
0254 
0255   std::vector<std::string> tmp3(1, "");
0256   inputModuleXml_ = pset.getUntrackedParameter<std::string>("InputModuleXml", "");
0257   inputDcuInfoXml_ = pset.getUntrackedParameter<std::string>("InputDcuInfoXml", "");
0258   inputFecXml_ = pset.getUntrackedParameter<std::vector<std::string> >("InputFecXml", tmp3);
0259   inputFedXml_ = pset.getUntrackedParameter<std::vector<std::string> >("InputFedXml", tmp3);
0260 }
0261 
0262 // -----------------------------------------------------------------------------
0263 //
0264 void SiStripPartition::update(const SiStripConfigDb* const db) {
0265   // Check
0266   if (!db) {
0267     edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0268                                << " NULL pointer to SiStripConfigDb object!"
0269                                << " Aborting update...";
0270     return;
0271   }
0272 
0273   // Check
0274   DeviceFactory* const df = db->deviceFactory(__func__);
0275   if (!df) {
0276     edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0277                                << " NULL pointer to DeviceFactory object!"
0278                                << " Aborting update...";
0279     return;
0280   }
0281 
0282   // Check partition name
0283   if (partitionName_ == defaultPartitionName_) {
0284     return;
0285   }
0286 
0287   // Debug
0288   std::stringstream ss;
0289   ss << "[SiStripPartition::" << __func__ << "]"
0290      << " Updating description versions for partition \"" << partitionName_ << "\"...";
0291   LogTrace(mlConfigDb_) << ss.str();
0292 
0293   try {
0294     // Reset container indicating state versions for commissioning runs
0295     runTableVersion_ = Versions(0, 0);
0296 
0297     // Update versions if using versions from "current state"
0298     if (forceCurrentState_ || forceVersions_) {
0299       // Find state for given partition
0300       tkStateVector states;
0301       states = df->getCurrentStates();
0302       tkStateVector::const_iterator istate = states.begin();
0303       tkStateVector::const_iterator jstate = states.end();
0304       while (istate != jstate) {
0305         if (*istate && partitionName_ == (*istate)->getPartitionName()) {
0306           break;
0307         }
0308         istate++;
0309       }
0310 
0311       // Set versions if state was found
0312       if (istate != states.end()) {
0313         if (!cabVersion_.first && !cabVersion_.second) {
0314           cabVersion_.first = (*istate)->getConnectionVersionMajorId();
0315           cabVersion_.second = (*istate)->getConnectionVersionMinorId();
0316         }
0317         if (!fecVersion_.first && !fecVersion_.second) {
0318           fecVersion_.first = (*istate)->getFecVersionMajorId();
0319           fecVersion_.second = (*istate)->getFecVersionMinorId();
0320         }
0321         if (!fedVersion_.first && !fedVersion_.second) {
0322           fedVersion_.first = (*istate)->getFedVersionMajorId();
0323           fedVersion_.second = (*istate)->getFedVersionMinorId();
0324         }
0325         if (!dcuVersion_.first && !dcuVersion_.second) {
0326           dcuVersion_.first = (*istate)->getDcuInfoVersionMajorId();
0327           dcuVersion_.second = (*istate)->getDcuInfoVersionMinorId();
0328         }
0329         if (!psuVersion_.first && !psuVersion_.second) {
0330           psuVersion_.first = (*istate)->getDcuPsuMapVersionMajorId();
0331           psuVersion_.second = (*istate)->getDcuPsuMapVersionMinorId();
0332         }
0333         //#ifdef USING_DATABASE_MASKING
0334         if (!forceVersions_ && !maskVersion_.first && !maskVersion_.second) {
0335           maskVersion_.first = (*istate)->getMaskVersionMajorId();
0336           maskVersion_.second = (*istate)->getMaskVersionMinorId();
0337         }
0338         //#endif
0339 
0340         // Retrieve global and local versions
0341         if (forceCurrentState_ || globalAnalysisV_) {  // use global version (or current state)
0342 
0343           // Set global version
0344           if (forceCurrentState_) {
0345             globalAnalysisV_ = (*istate)->getAnalysisVersionMapPointerId();
0346           }
0347 
0348           // Retrieve local versions
0349           HashMapAnalysisVersions local_versions = df->getLocalAnalysisVersions(globalAnalysisV_);
0350 
0351           // Iterate through map< AnalysisType, pair<Major,Minor> >
0352           HashMapAnalysisVersions::const_iterator ivers = local_versions.begin();
0353           HashMapAnalysisVersions::const_iterator jvers = local_versions.end();
0354           for (; ivers != jvers; ++ivers) {
0355             if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_FASTFEDCABLING) {
0356               fastCablingV_.first = ivers->second.first;
0357               fastCablingV_.second = ivers->second.second;
0358             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_TIMING) {
0359               apvTimingV_.first = ivers->second.first;
0360               apvTimingV_.second = ivers->second.second;
0361             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_OPTOSCAN) {
0362               optoScanV_.first = ivers->second.first;
0363               optoScanV_.second = ivers->second.second;
0364             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_VPSPSCAN) {
0365               vpspScanV_.first = ivers->second.first;
0366               vpspScanV_.second = ivers->second.second;
0367             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION) {
0368               apvCalibV_.first = ivers->second.first;
0369               apvCalibV_.second = ivers->second.second;
0370             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_PEDESTALS) {
0371               pedestalsV_.first = ivers->second.first;
0372               pedestalsV_.second = ivers->second.second;
0373             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_PEDSFULLNOISE) {
0374               pedsFullNoiseV_.first = ivers->second.first;
0375               pedsFullNoiseV_.second = ivers->second.second;
0376             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_APVLATENCY) {
0377               apvLatencyV_.first = ivers->second.first;
0378               apvLatencyV_.second = ivers->second.second;
0379             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_FINEDELAY) {
0380               fineDelayV_.first = ivers->second.first;
0381               fineDelayV_.second = ivers->second.second;
0382             } else if (ivers->first == CommissioningAnalysisDescription::T_UNKNOWN) {
0383               std::stringstream ss;
0384               edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0385                                          << " Found UNKNOWN AnalysisType!";
0386               edm::LogWarning(mlConfigDb_) << ss.str();
0387             } else {
0388               std::stringstream ss;
0389               edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0390                                          << " Unable to match content to any AnalysisType!";
0391               edm::LogWarning(mlConfigDb_) << ss.str();
0392             }
0393           }
0394 
0395         } else if (!globalAnalysisV_) {  // use local versions
0396 
0397           // Retrieve local versions and set if necessary
0398           globalAnalysisV_ = (*istate)->getAnalysisVersionMapPointerId();
0399           HashMapAnalysisVersions local_versions = df->getLocalAnalysisVersions(globalAnalysisV_);
0400 
0401           // Iterate through map< AnalysisType, pair<Major,Minor> >
0402           HashMapAnalysisVersions::const_iterator ivers = local_versions.begin();
0403           HashMapAnalysisVersions::const_iterator jvers = local_versions.end();
0404           for (; ivers != jvers; ++ivers) {
0405             if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_FASTFEDCABLING) {
0406               if (!fastCablingV_.first && !fastCablingV_.second) {
0407                 fastCablingV_.first = ivers->second.first;
0408                 fastCablingV_.second = ivers->second.second;
0409               }
0410             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_TIMING) {
0411               if (!apvTimingV_.first && !apvTimingV_.second) {
0412                 apvTimingV_.first = ivers->second.first;
0413                 apvTimingV_.second = ivers->second.second;
0414               }
0415             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_OPTOSCAN) {
0416               if (!optoScanV_.first && !optoScanV_.second) {
0417                 optoScanV_.first = ivers->second.first;
0418                 optoScanV_.second = ivers->second.second;
0419               }
0420             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_VPSPSCAN) {
0421               if (!vpspScanV_.first && !vpspScanV_.second) {
0422                 vpspScanV_.first = ivers->second.first;
0423                 vpspScanV_.second = ivers->second.second;
0424               }
0425             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION) {
0426               if (!apvCalibV_.first && !apvCalibV_.second) {
0427                 apvCalibV_.first = ivers->second.first;
0428                 apvCalibV_.second = ivers->second.second;
0429               }
0430             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_PEDESTALS) {
0431               if (!pedestalsV_.first && !pedestalsV_.second) {
0432                 pedestalsV_.first = ivers->second.first;
0433                 pedestalsV_.second = ivers->second.second;
0434               }
0435             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_PEDSFULLNOISE) {
0436               if (!pedsFullNoiseV_.first && !pedsFullNoiseV_.second) {
0437                 pedsFullNoiseV_.first = ivers->second.first;
0438                 pedsFullNoiseV_.second = ivers->second.second;
0439               }
0440             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_APVLATENCY) {
0441               if (!apvLatencyV_.first && !apvLatencyV_.second) {
0442                 apvLatencyV_.first = ivers->second.first;
0443                 apvLatencyV_.second = ivers->second.second;
0444               }
0445             } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_FINEDELAY) {
0446               if (!fineDelayV_.first && !fineDelayV_.second) {
0447                 fineDelayV_.first = ivers->second.first;
0448                 fineDelayV_.second = ivers->second.second;
0449               }
0450             } else if (ivers->first == CommissioningAnalysisDescription::T_UNKNOWN) {
0451               std::stringstream ss;
0452               edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0453                                          << " Found UNKNOWN AnalysisType!";
0454               edm::LogWarning(mlConfigDb_) << ss.str();
0455             } else {
0456               std::stringstream ss;
0457               edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0458                                          << " Unable to match content to any AnalysisType!";
0459               edm::LogWarning(mlConfigDb_) << ss.str();
0460             }
0461           }
0462         }
0463 
0464       } else {
0465         std::stringstream ss;
0466         edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0467                                    << " Unable to find \"current state\" for partition \"" << partitionName_ << "\"";
0468       }
0469 
0470     } else {  // ---------- USE RUN NUMBER ----------
0471 
0472       // Retrieve TkRun object for given run (0 means "latest run")
0473       TkRun* run = nullptr;
0474       if (!runNumber_) {
0475         run = df->getLastRun(partitionName_);
0476       } else {
0477         run = df->getRun(partitionName_, runNumber_);
0478       }
0479 
0480       // Retrieve versioning for given TkRun object
0481       if (run) {
0482         if (run->getRunNumber()) {
0483           if (!runNumber_) {
0484             runNumber_ = run->getRunNumber();
0485           }
0486 
0487           if (runNumber_ == run->getRunNumber()) {
0488             cabVersion_.first = run->getConnectionVersionMajorId();
0489             cabVersion_.second = run->getConnectionVersionMinorId();
0490 
0491             fecVersion_.first = run->getFecVersionMajorId();
0492             fecVersion_.second = run->getFecVersionMinorId();
0493 
0494             fedVersion_.first = run->getFedVersionMajorId();
0495             fedVersion_.second = run->getFedVersionMinorId();
0496 
0497             dcuVersion_.first = run->getDcuInfoVersionMajorId();
0498             dcuVersion_.second = run->getDcuInfoVersionMinorId();
0499 
0500             psuVersion_.first = run->getDcuPsuMapVersionMajorId();
0501             psuVersion_.second = run->getDcuPsuMapVersionMinorId();
0502 
0503             //#ifdef USING_DATABASE_MASKING
0504             maskVersion_.first = run->getMaskVersionMajorId();
0505             maskVersion_.second = run->getMaskVersionMinorId();
0506             //#endif
0507 
0508             // Check run type
0509             uint16_t type = run->getModeId(run->getMode());
0510             if (type == 1) {
0511               runType_ = sistrip::PHYSICS;
0512             } else if (type == 2) {
0513               runType_ = sistrip::PEDESTALS;
0514             } else if (type == 3) {
0515               runType_ = sistrip::CALIBRATION;
0516             } else if (type == 4) {
0517               runType_ = sistrip::OPTO_SCAN;
0518             } else if (type == 5) {
0519               runType_ = sistrip::APV_TIMING;
0520             } else if (type == 6) {
0521               runType_ = sistrip::APV_LATENCY;
0522             } else if (type == 7) {
0523               runType_ = sistrip::FINE_DELAY_PLL;
0524             } else if (type == 8) {
0525               runType_ = sistrip::FINE_DELAY_TTC;
0526             } else if (type == 10) {
0527               runType_ = sistrip::MULTI_MODE;
0528             } else if (type == 12) {
0529               runType_ = sistrip::FED_TIMING;
0530             } else if (type == 13) {
0531               runType_ = sistrip::FED_CABLING;
0532             } else if (type == 14) {
0533               runType_ = sistrip::VPSP_SCAN;
0534             } else if (type == 15) {
0535               runType_ = sistrip::DAQ_SCOPE_MODE;
0536             } else if (type == 16) {
0537               runType_ = sistrip::QUITE_FAST_CABLING;
0538             } else if (type == 17) {
0539               runType_ = sistrip::FINE_DELAY;
0540             } else if (type == 18) {
0541               runType_ = sistrip::PHYSICS_ZS;
0542             } else if (type == 19) {
0543               runType_ = sistrip::CALIBRATION_SCAN;
0544             } else if (type == 20) {
0545               runType_ = sistrip::CALIBRATION_SCAN_DECO;
0546             } else if (type == 21) {
0547               runType_ = sistrip::FAST_CABLING;
0548             } else if (type == 22) {
0549               runType_ = sistrip::PEDS_ONLY;
0550             } else if (type == 23) {
0551               runType_ = sistrip::NOISE;
0552             } else if (type == 24) {
0553               runType_ = sistrip::PEDS_FULL_NOISE;
0554             } else if (type == 33) {
0555               runType_ = sistrip::CALIBRATION_DECO;
0556             } else if (type == 0) {
0557               runType_ = sistrip::UNDEFINED_RUN_TYPE;
0558               edm::LogWarning(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0559                                            << " NULL run type returned!"
0560                                            << " for partition \"" << partitionName_ << "\"";
0561             } else {
0562               runType_ = sistrip::UNKNOWN_RUN_TYPE;
0563               edm::LogWarning(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0564                                            << " UNKNOWN run type (" << type << ") returned!"
0565                                            << " for partition \"" << partitionName_ << "\"";
0566             }
0567 
0568             // Retrieve global and local versions from state associated with given run
0569             globalAnalysisV_ = run->getAnalysisVersionMapPointerId();
0570             HashMapAnalysisVersions local_versions = df->getLocalAnalysisVersions(globalAnalysisV_);
0571             HashMapAnalysisVersions::const_iterator ivers = local_versions.begin();
0572             HashMapAnalysisVersions::const_iterator jvers = local_versions.end();
0573             for (; ivers != jvers; ++ivers) {
0574               if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_FASTFEDCABLING) {
0575                 fastCablingV_.first = ivers->second.first;
0576                 fastCablingV_.second = ivers->second.second;
0577               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_TIMING) {
0578                 apvTimingV_.first = ivers->second.first;
0579                 apvTimingV_.second = ivers->second.second;
0580               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_OPTOSCAN) {
0581                 optoScanV_.first = ivers->second.first;
0582                 optoScanV_.second = ivers->second.second;
0583               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_VPSPSCAN) {
0584                 vpspScanV_.first = ivers->second.first;
0585                 vpspScanV_.second = ivers->second.second;
0586               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION) {
0587                 apvCalibV_.first = ivers->second.first;
0588                 apvCalibV_.second = ivers->second.second;
0589               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_PEDESTALS) {
0590                 pedestalsV_.first = ivers->second.first;
0591                 pedestalsV_.second = ivers->second.second;
0592               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_PEDSFULLNOISE) {
0593                 pedsFullNoiseV_.first = ivers->second.first;
0594                 pedsFullNoiseV_.second = ivers->second.second;
0595               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_APVLATENCY) {
0596                 apvLatencyV_.first = ivers->second.first;
0597                 apvLatencyV_.second = ivers->second.second;
0598               } else if (ivers->first == CommissioningAnalysisDescription::T_ANALYSIS_FINEDELAY) {
0599                 fineDelayV_.first = ivers->second.first;
0600                 fineDelayV_.second = ivers->second.second;
0601               } else if (ivers->first == CommissioningAnalysisDescription::T_UNKNOWN) {
0602                 std::stringstream ss;
0603                 edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0604                                            << " Found UNKNOWN AnalysisType!";
0605                 edm::LogWarning(mlConfigDb_) << ss.str();
0606               } else {
0607                 std::stringstream ss;
0608                 edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0609                                            << " Unable to match content to any AnalysisType!";
0610                 edm::LogWarning(mlConfigDb_) << ss.str();
0611               }
0612             }
0613 
0614             // If commissioning run, override version of analysis type with version PRODUCED by run (from history)
0615             if (runType_ != sistrip::PHYSICS && runType_ != sistrip::UNDEFINED_RUN_TYPE &&
0616                 runType_ != sistrip::UNKNOWN_RUN_TYPE) {
0617               // Determine analysis type from run type
0618               CommissioningAnalysisDescription::commissioningType type = CommissioningAnalysisDescription::T_UNKNOWN;
0619               if (runType_ == sistrip::FAST_CABLING) {
0620                 type = CommissioningAnalysisDescription::T_ANALYSIS_FASTFEDCABLING;
0621               } else if (runType_ == sistrip::APV_TIMING) {
0622                 type = CommissioningAnalysisDescription::T_ANALYSIS_TIMING;
0623               } else if (runType_ == sistrip::OPTO_SCAN) {
0624                 type = CommissioningAnalysisDescription::T_ANALYSIS_OPTOSCAN;
0625               } else if (runType_ == sistrip::VPSP_SCAN) {
0626                 type = CommissioningAnalysisDescription::T_ANALYSIS_VPSPSCAN;
0627               } else if (runType_ == sistrip::CALIBRATION) {
0628                 type = CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION;
0629               } else if (runType_ == sistrip::CALIBRATION_SCAN) {
0630                 type = CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION;
0631               } else if (runType_ == sistrip::CALIBRATION_DECO) {
0632                 type = CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION;
0633               } else if (runType_ == sistrip::CALIBRATION_SCAN_DECO) {
0634                 type = CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION;
0635               } else if (runType_ == sistrip::PEDESTALS) {
0636                 type = CommissioningAnalysisDescription::T_ANALYSIS_PEDESTALS;
0637               } else if (runType_ == sistrip::PEDS_FULL_NOISE) {
0638                 type = CommissioningAnalysisDescription::T_ANALYSIS_PEDSFULLNOISE;
0639               } else if (runType_ == sistrip::APV_LATENCY) {
0640                 type = CommissioningAnalysisDescription::T_ANALYSIS_APVLATENCY;
0641               } else if (runType_ == sistrip::FINE_DELAY_TTC) {
0642                 type = CommissioningAnalysisDescription::T_ANALYSIS_FINEDELAY;
0643               }
0644 
0645               // Retrieve local versions for COMMISSIONING runs from history
0646               HashMapRunVersion local_versions = df->getAnalysisHistory(partitionName_, type);
0647 
0648               // Iterate through map< RunNumber, vector< pair<Major,Minor> > > to find appropriate run
0649               HashMapRunVersion::const_iterator ivers = local_versions.end();
0650               if (runNumber_ == 0) {
0651                 ivers = --(local_versions.end());
0652               } else {
0653                 ivers = local_versions.find(runNumber_);
0654               }
0655 
0656               // Set appropriate versions
0657               if (ivers != local_versions.end()) {
0658                 if (type == CommissioningAnalysisDescription::T_ANALYSIS_FASTFEDCABLING) {
0659                   runTableVersion_ = fastCablingV_;
0660                   fastCablingV_.first = ivers->second.back().first;
0661                   fastCablingV_.second = ivers->second.back().second;
0662 
0663                   //@@
0664 
0665                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_TIMING) {
0666                   runTableVersion_ = apvTimingV_;
0667                   apvTimingV_.first = ivers->second.back().first;
0668                   apvTimingV_.second = ivers->second.back().second;
0669                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_OPTOSCAN) {
0670                   runTableVersion_ = optoScanV_;
0671                   optoScanV_.first = ivers->second.back().first;
0672                   optoScanV_.second = ivers->second.back().second;
0673                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_VPSPSCAN) {
0674                   runTableVersion_ = vpspScanV_;
0675                   vpspScanV_.first = ivers->second.back().first;
0676                   vpspScanV_.second = ivers->second.back().second;
0677                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_CALIBRATION) {
0678                   runTableVersion_ = apvCalibV_;
0679                   apvCalibV_.first = ivers->second.back().first;
0680                   apvCalibV_.second = ivers->second.back().second;
0681                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_PEDESTALS) {
0682                   runTableVersion_ = pedestalsV_;
0683                   pedestalsV_.first = ivers->second.back().first;
0684                   pedestalsV_.second = ivers->second.back().second;
0685                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_PEDSFULLNOISE) {
0686                   runTableVersion_ = pedsFullNoiseV_;
0687                   pedsFullNoiseV_.first = ivers->second.back().first;
0688                   pedsFullNoiseV_.second = ivers->second.back().second;
0689                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_APVLATENCY) {
0690                   runTableVersion_ = apvLatencyV_;
0691                   apvLatencyV_.first = ivers->second.back().first;
0692                   apvLatencyV_.second = ivers->second.back().second;
0693                 } else if (type == CommissioningAnalysisDescription::T_ANALYSIS_FINEDELAY) {
0694                   runTableVersion_ = fineDelayV_;
0695                   fineDelayV_.first = ivers->second.back().first;
0696                   fineDelayV_.second = ivers->second.back().second;
0697                 } else if (type == CommissioningAnalysisDescription::T_UNKNOWN) {
0698                   std::stringstream ss;
0699                   edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0700                                              << " Found UNKNOWN AnalysisType!";
0701                   edm::LogWarning(mlConfigDb_) << ss.str();
0702                 } else {
0703                   std::stringstream ss;
0704                   edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0705                                              << " Unable to match content to any AnalysisType!";
0706                   edm::LogWarning(mlConfigDb_) << ss.str();
0707                 }
0708               } else {
0709                 std::stringstream ss;
0710                 edm::LogError(mlConfigDb_)
0711                     << "[SiStripPartition::" << __func__ << "]"
0712                     << " Unable to find run number " << runNumber_ << " in \"history\" hash map ";
0713                 edm::LogWarning(mlConfigDb_) << ss.str();
0714               }
0715             }
0716 
0717           } else {
0718             edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0719                                        << " Mismatch of run number requested (" << runNumber_ << ") and received ("
0720                                        << run->getRunNumber() << ")"
0721                                        << " to/from database for partition \"" << partitionName_ << "\"";
0722           }
0723 
0724         } else {
0725           edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0726                                      << " NULL run number returned!"
0727                                      << " for partition \"" << partitionName_ << "\"";
0728         }
0729 
0730       } else {
0731         edm::LogError(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0732                                    << " NULL pointer to TkRun object!"
0733                                    << " Unable to retrieve versions for run number " << runNumber_
0734                                    << ". Run number may not be consistent with partition \"" << partitionName_
0735                                    << "\"!";  //@@ only using first here!!!
0736       }
0737     }
0738 
0739   } catch (...) {
0740     db->handleException(__func__, "");
0741   }
0742 }
0743 
0744 // -----------------------------------------------------------------------------
0745 //
0746 void SiStripPartition::print(std::stringstream& ss, bool using_db) const {
0747   ss << "  Partition                  : \"" << partitionName_ << "\"" << std::endl;
0748 
0749   if (using_db) {
0750     ss << "  Run number                 : ";
0751     if (forceCurrentState_) {
0752       ss << "Forced \"current state\"! (equivalent to versions below)";
0753     } else if (forceVersions_) {
0754       ss << "Forced versions specified below!";
0755     } else /* use run number */ {
0756       ss << runNumber_;
0757     }
0758 
0759     ss << std::endl;
0760     if (!forceVersions_) {
0761       ss << "  Run type                   : " << SiStripEnumsAndStrings::runType(runType_) << std::endl;
0762     }
0763 
0764     ss << "  Cabling major/minor vers   : " << cabVersion_.first << "." << cabVersion_.second << std::endl
0765        << "  FEC major/minor vers       : " << fecVersion_.first << "." << fecVersion_.second << std::endl
0766        << "  FED major/minor vers       : " << fedVersion_.first << "." << fedVersion_.second << std::endl
0767        << "  DCU-DetId map maj/min vers : " << dcuVersion_.first << "." << dcuVersion_.second
0768        << std::endl
0769        //#ifdef USING_DATABASE_MASKING
0770        << "  DCU-PSU map maj/min vers   : " << psuVersion_.first << "." << psuVersion_.second << std::endl
0771        << "  Mask maj/min vers          : " << maskVersion_.first << "." << maskVersion_.second << std::endl;
0772     //#else
0773     //       << "  DCU-PSU map maj/min vers   : " << psuVersion_.first << "." << psuVersion_.second << std::endl;
0774     //#endif
0775 
0776     ss << "  Global analysis version    : " << globalAnalysisV_ << std::endl;
0777 
0778     if (runType_ == sistrip::PHYSICS || runType_ == sistrip::UNDEFINED_RUN_TYPE ||
0779         runType_ == sistrip::UNKNOWN_RUN_TYPE) {
0780       ss << "  FED cabling maj/min vers   : " << fastCablingV_.first << "." << fastCablingV_.second << std::endl;
0781       ss << "  APV timing maj/min vers    : " << apvTimingV_.first << "." << apvTimingV_.second << std::endl;
0782       ss << "  Opto scan maj/min vers     : " << optoScanV_.first << "." << optoScanV_.second << std::endl;
0783       ss << "  VPSP scan maj/min vers     : " << vpspScanV_.first << "." << vpspScanV_.second << std::endl;
0784       ss << "  APV calib maj/min vers     : " << apvCalibV_.first << "." << apvCalibV_.second << std::endl;
0785       ss << "  Pedestals maj/min vers     : " << pedestalsV_.first << "." << pedestalsV_.second << std::endl;
0786       ss << "  PedsFullNoise maj/min vers     : " << pedsFullNoiseV_.first << "." << pedsFullNoiseV_.second
0787          << std::endl;
0788       ss << "  APV latency maj/min vers   : " << apvLatencyV_.first << "." << apvLatencyV_.second << std::endl;
0789       ss << "  Fine delay maj/min vers    : " << fineDelayV_.first << "." << fineDelayV_.second << std::endl;
0790 
0791     } else {
0792       if (runType_ != sistrip::FAST_CABLING) {
0793         ss << "  FED cabling maj/min vers   : " << fastCablingV_.first << "." << fastCablingV_.second << std::endl;
0794       } else {
0795         ss << "  FED cabling maj/min vers   : " << runTableVersion_.first << "." << runTableVersion_.second
0796            << " <= This \"state\" version overriden by \"history\" version " << fastCablingV_.first << "."
0797            << fastCablingV_.second << " for this FED cabling run!" << std::endl;
0798       }
0799 
0800       if (runType_ != sistrip::APV_TIMING) {
0801         ss << "  APV timing maj/min vers    : " << apvTimingV_.first << "." << apvTimingV_.second << std::endl;
0802       } else {
0803         ss << "  APV timing maj/min vers    : " << runTableVersion_.first << "." << runTableVersion_.second
0804            << " <= This \"state\" version overriden by \"history\" version " << apvTimingV_.first << "."
0805            << apvTimingV_.second << " for this APV timing run!" << std::endl;
0806       }
0807 
0808       if (runType_ != sistrip::OPTO_SCAN) {
0809         ss << "  Opto scan maj/min vers     : " << optoScanV_.first << "." << optoScanV_.second << std::endl;
0810       } else {
0811         ss << "  Opto scan maj/min vers     : " << runTableVersion_.first << "." << runTableVersion_.second
0812            << " <= This \"state\" version overriden by \"history\" version " << optoScanV_.first << "."
0813            << optoScanV_.second << " for this opto scan run!" << std::endl;
0814       }
0815 
0816       if (runType_ != sistrip::VPSP_SCAN) {
0817         ss << "  VPSP scan maj/min vers     : " << vpspScanV_.first << "." << vpspScanV_.second << std::endl;
0818       } else {
0819         ss << "  VPSP scan maj/min vers     : " << runTableVersion_.first << "." << runTableVersion_.second
0820            << " <= This \"state\" version overriden by \"history\" version " << vpspScanV_.first << "."
0821            << vpspScanV_.second << " for this VPSP scan run!" << std::endl;
0822       }
0823 
0824       if (runType_ != sistrip::CALIBRATION and runType_ != sistrip::CALIBRATION_SCAN and
0825           runType_ != sistrip::CALIBRATION_DECO and runType_ != sistrip::CALIBRATION_SCAN_DECO) {
0826         ss << "  APV calib maj/min vers     : " << apvCalibV_.first << "." << apvCalibV_.second << std::endl;
0827       } else {
0828         ss << "  APV calib maj/min vers     : " << runTableVersion_.first << "." << runTableVersion_.second
0829            << " <= This \"state\" version overriden by \"history\" version " << apvCalibV_.first << "."
0830            << apvCalibV_.second << " for this APV calib run!" << std::endl;
0831       }
0832 
0833       if (runType_ != sistrip::PEDESTALS) {
0834         ss << "  Pedestals maj/min vers     : " << pedestalsV_.first << "." << pedestalsV_.second << std::endl;
0835       } else {
0836         ss << "  Pedestals maj/min vers     : " << runTableVersion_.first << "." << runTableVersion_.second
0837            << " <= This \"state\" version overriden by \"history\" version " << pedestalsV_.first << "."
0838            << pedestalsV_.second << " for this pedestals run!" << std::endl;
0839       }
0840 
0841       if (runType_ != sistrip::PEDS_FULL_NOISE) {
0842         ss << "  PedsFullNoise maj/min vers     : " << pedsFullNoiseV_.first << "." << pedsFullNoiseV_.second
0843            << std::endl;
0844       } else {
0845         ss << "  Pedestals maj/min vers     : " << runTableVersion_.first << "." << runTableVersion_.second
0846            << " <= This \"state\" version overriden by \"history\" version " << pedsFullNoiseV_.first << "."
0847            << pedsFullNoiseV_.second << " for this pedestals run!" << std::endl;
0848       }
0849 
0850       if (runType_ != sistrip::APV_LATENCY) {
0851         ss << "  APV latency maj/min vers   : " << apvLatencyV_.first << "." << apvLatencyV_.second << std::endl;
0852       } else {
0853         ss << "  APV latency maj/min vers   : " << runTableVersion_.first << "." << runTableVersion_.second
0854            << " <= This \"state\" version overriden by \"history\" version " << apvLatencyV_.first << "."
0855            << apvLatencyV_.second << " for this APV latency run!" << std::endl;
0856       }
0857 
0858       if (runType_ != sistrip::FINE_DELAY_TTC) {
0859         ss << "  Fine delay maj/min vers    : " << fineDelayV_.first << "." << fineDelayV_.second << std::endl;
0860       } else {
0861         ss << "  Fine delay maj/min vers    : " << runTableVersion_.first << "." << runTableVersion_.second
0862            << " <= This \"state\" version overriden by \"history\" version " << fineDelayV_.first << "."
0863            << fineDelayV_.second << " for this fine delay run!" << std::endl;
0864       }
0865     }
0866 
0867   } else {
0868     ss << "  Input \"module.xml\" file    : " << inputModuleXml_ << std::endl
0869        << "  Input \"dcuinfo.xml\" file   : " << inputDcuInfoXml_ << std::endl
0870        << "  Input \"fec.xml\" file(s)    : ";
0871     std::vector<std::string>::const_iterator ifec = inputFecXml_.begin();
0872     for (; ifec != inputFecXml_.end(); ifec++) {
0873       ss << *ifec << ", ";
0874     }
0875     ss << std::endl;
0876     ss << "  Input \"fed.xml\" file(s)    : ";
0877     std::vector<std::string>::const_iterator ifed = inputFedXml_.begin();
0878     for (; ifed != inputFedXml_.end(); ifed++) {
0879       ss << *ifed << ", ";
0880     }
0881     ss << std::endl;
0882   }
0883 }
0884 
0885 // -----------------------------------------------------------------------------
0886 //
0887 std::ostream& operator<<(std::ostream& os, const SiStripPartition& params) {
0888   std::stringstream ss;
0889   params.print(ss);
0890   os << ss.str();
0891   return os;
0892 }
0893 
0894 // -----------------------------------------------------------------------------
0895 //
0896 SiStripPartition::Versions SiStripPartition::versions(const std::vector<uint32_t>& _input) {
0897   std::vector<uint32_t> input = _input;
0898   if (input.size() != 2) {
0899     edm::LogWarning(mlConfigDb_) << "[SiStripPartition::" << __func__ << "]"
0900                                  << " Unexpected size (" << input.size()
0901                                  << ") for  vector containing version numbers (major,minor)!"
0902                                  << " Resizing to 2 elements (default values will be 0,0)...";
0903     input.resize(2, 0);
0904   }
0905   return std::make_pair(input[0], input[1]);
0906 }