SiStripConfigDb.h

Go to the documentation of this file.

 
#ifndef OnlineDB_SiStripConfigDb_SiStripConfigDb_h
#define OnlineDB_SiStripConfigDb_SiStripConfigDb_h
 
#define DATABASE  // Needed by DeviceFactory API! Do not comment!
//#define USING_DATABASE_MASKING
 
#include "FWCore/Utilities/interface/Exception.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/ServiceRegistry/interface/ActivityRegistry.h"
#include "DataFormats/Common/interface/MapOfVectors.h"
#include "DataFormats/SiStripCommon/interface/ConstantsForRunType.h"
#include "DataFormats/SiStripCommon/interface/SiStripConstants.h"
#include "DataFormats/SiStripCommon/interface/SiStripFecKey.h"
#include "CalibFormats/SiStripObjects/interface/SiStripFecCabling.h"
#include "OnlineDB/SiStripConfigDb/interface/SiStripDbParams.h"
#include "DeviceFactory.h"
#include "boost/range/iterator_range.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
#include <ostream>
#include <vector>
#include <string>
#include <list>
#include <map>
#include <atomic>
 
#include "DbClient.h"
#include <cstdint>
 
namespace sistrip {
  static const uint16_t FEC_CRATE_OFFSET = 0;  //@@ temporary
  static const uint16_t FEC_RING_OFFSET = 0;   //@@ temporary
}  // namespace sistrip
 
// Friend class
namespace cms {
  class SiStripO2O;
}
 
class SiStripConfigDb {
public:
  // ---------- Constructors, destructors ----------
 
  SiStripConfigDb(const edm::ParameterSet&, const edm::ActivityRegistry&);
 
  ~SiStripConfigDb();
 
  // ---------- PROTECTED INTERFACE ----------
 
protected:
  /*
    Access to the configuration database is reserved solely for the
    commissioning (database) client and the online-to-offline transfer
    tool. If you wish to use this interface to the configuration
    database, then please contact one of the package administrators.
  */
 
  // ESSources and O2O
  friend class SiStripFedCablingBuilderFromDb;
  friend class SiStripPedestalsBuilderFromDb;
  friend class SiStripNoiseBuilderFromDb;
  friend class SiStripCondObjBuilderFromDb;
  friend class SiStripPsuDetIdMap;
 
  // Commissioning clients
  friend class SiStripCommissioningDbClient;
  friend class SiStripCommissioningOfflineDbClient;
  friend class CommissioningHistosUsingDb;
  friend class FastFedCablingHistosUsingDb;
  friend class FedCablingHistosUsingDb;
  friend class ApvTimingHistosUsingDb;
  friend class OptoScanHistosUsingDb;
  friend class PedestalsHistosUsingDb;
  friend class PedsFullNoiseHistosUsingDb;
  friend class PedsOnlyHistosUsingDb;
  friend class NoiseHistosUsingDb;
  friend class VpspScanHistosUsingDb;
  friend class LatencyHistosUsingDb;
  friend class FineDelayHistosUsingDb;
  friend class CalibrationHistosUsingDb;
  friend class DaqScopeModeHistosUsingDb;
 
  // Utility and tests
  friend class SiStripPartition;
  friend class testSiStripConfigDb;
 
  // ---------- Typedefs ----------
 
  // FED connections
  typedef ConnectionDescription FedConnection;
  typedef edm::MapOfVectors<std::string, FedConnection*> FedConnections;
  typedef FedConnections::range FedConnectionsRange;
  typedef std::vector<FedConnection*> FedConnectionsV;
 
  // Device descriptions
  typedef enumDeviceType DeviceType;
  typedef deviceDescription DeviceDescription;
  typedef edm::MapOfVectors<std::string, DeviceDescription*> DeviceDescriptions;
  typedef DeviceDescriptions::range DeviceDescriptionsRange;
  typedef std::vector<DeviceDescription*> DeviceDescriptionsV;
 
  // FED descriptions
  typedef Fed9U::Fed9UDescription FedDescription;
  typedef edm::MapOfVectors<std::string, FedDescription*> FedDescriptions;
  typedef FedDescriptions::range FedDescriptionsRange;
  typedef std::vector<FedDescription*> FedDescriptionsV;
 
  // FED ids
  typedef std::vector<uint16_t> FedIds;
  typedef boost::iterator_range<FedIds::const_iterator> FedIdsRange;
 
  // DCU-DetId map
  typedef Sgi::hash_map<unsigned long, TkDcuInfo*> DcuDetIdMap;
  typedef std::pair<uint32_t, TkDcuInfo*> DcuDetId;
  typedef edm::MapOfVectors<std::string, DcuDetId> DcuDetIds;
  typedef DcuDetIds::range DcuDetIdsRange;
  typedef std::vector<DcuDetId> DcuDetIdsV;
 
  // Analysis descriptions
  typedef CommissioningAnalysisDescription::commissioningType AnalysisType;
  typedef CommissioningAnalysisDescription AnalysisDescription;
  typedef edm::MapOfVectors<std::string, AnalysisDescription*> AnalysisDescriptions;
  typedef AnalysisDescriptions::range AnalysisDescriptionsRange;
  typedef std::vector<AnalysisDescription*> AnalysisDescriptionsV;
 
  // ---------- Useful structs ----------
 
  class DeviceAddress {
  public:
    DeviceAddress();
    void reset();
    uint16_t fecCrate_;
    uint16_t fecSlot_;
    uint16_t fecRing_;
    uint16_t ccuAddr_;
    uint16_t ccuChan_;
    uint16_t lldChan_;
    uint16_t i2cAddr_;
    uint16_t fedId_;
    uint16_t feUnit_;
    uint16_t feChan_;
  };
 
  // ---------- Connection and useful methods ----------
 
  void openDbConnection();
 
  void closeDbConnection();
 
  inline const SiStripDbParams& dbParams() const;
 
  inline bool usingDb() const;
 
  DeviceFactory* const deviceFactory(std::string method_name = "") const;
 
  DbClient* const databaseCache(std::string method_name = "") const;
 
  // ---------- Run numbers for partitions and run types ----------
 
  class Run {
  public:
    sistrip::RunType type_;
    std::string partition_;
    uint16_t number_;
    Run() : type_(sistrip::UNDEFINED_RUN_TYPE), partition_(""), number_(0) { ; }
  };
 
  typedef std::vector<Run> Runs;
 
  typedef std::map<sistrip::RunType, Runs> RunsByType;
 
  typedef std::map<std::string, Runs> RunsByPartition;
 
  void runs(Runs&) const;
 
  void runs(const Runs& in, RunsByType& out, std::string optional_partition = "") const;
 
  void runs(const Runs& in, RunsByPartition& out, sistrip::RunType optional_type = sistrip::UNDEFINED_RUN_TYPE) const;
 
  void partitions(std::list<std::string>&) const;
 
  //@@ SiStripPartition::Versions ???
 
  // ---------- FED connections ----------
 
  FedConnectionsRange getFedConnections(std::string partition = "");
 
  void addFedConnections(std::string partition, FedConnectionsV&);
 
  void uploadFedConnections(std::string partition = "");
 
  void clearFedConnections(std::string partition = "");
 
  void printFedConnections(std::string partition = "");
 
  // ---------- FEC / Front-End devices ----------
 
  DeviceDescriptionsRange getDeviceDescriptions(std::string partition = "");
 
  DeviceDescriptionsRange getDeviceDescriptions(DeviceType, std::string partition = "");
 
  void addDeviceDescriptions(std::string partition, DeviceDescriptionsV&);
 
  void uploadDeviceDescriptions(std::string partition = "");
 
  void clearDeviceDescriptions(std::string partition = "");
 
  void printDeviceDescriptions(std::string partition = "");
 
  DeviceAddress deviceAddress(const deviceDescription&);  //@@ uses temp offsets!
 
  // ---------- FED descriptions ----------
 
  FedDescriptionsRange getFedDescriptions(std::string partition = "");
 
  void addFedDescriptions(std::string partition, FedDescriptionsV&);
 
  void uploadFedDescriptions(std::string partition = "");
 
  void clearFedDescriptions(std::string partition = "");
 
  void printFedDescriptions(std::string partition = "");
 
  FedIdsRange getFedIds(std::string partition = "");
 
  inline bool usingStrips() const;
 
  inline void usingStrips(bool);
 
  // ---------- DCU-DetId info ----------
 
  DcuDetIdsRange getDcuDetIds(std::string partition = "");
 
  void addDcuDetIds(std::string partition, DcuDetIdsV&);
 
  void uploadDcuDetIds(std::string partition = "");
 
  void clearDcuDetIds(std::string partition = "");
 
  void printDcuDetIds(std::string partition = "");
 
  static DcuDetIdsV::const_iterator findDcuDetId(DcuDetIdsV::const_iterator begin,
                                                 DcuDetIdsV::const_iterator end,
                                                 uint32_t dcu_id);
 
  static DcuDetIdsV::iterator findDcuDetId(DcuDetIdsV::iterator begin, DcuDetIdsV::iterator end, uint32_t dcu_id);
 
  // ---------- Commissioning analyses ----------
 
  AnalysisDescriptionsRange getAnalysisDescriptions(AnalysisType, std::string partition = "");
 
  void addAnalysisDescriptions(std::string partition, AnalysisDescriptionsV&);
 
  void uploadAnalysisDescriptions(bool calibration_for_physics = false, std::string partition = "");
 
  void clearAnalysisDescriptions(std::string partition = "");
 
  void printAnalysisDescriptions(std::string partition = "");
 
  DeviceAddress deviceAddress(const AnalysisDescription&);  //@@ uses temp offsets!
 
  std::string analysisType(AnalysisType) const;
 
private:
  // ---------- Private methods ----------
 
  void clearLocalCache();
 
  void usingDatabase();
 
  void usingDatabaseCache();
 
  void usingXmlFiles();
 
  void handleException(const std::string& method_name, const std::string& extra_info = "") const;
 
  bool checkFileExists(const std::string& path);
 
  std::string deviceType(const enumDeviceType& device_type) const;
 
  void clone(const DcuDetIdMap& in, DcuDetIdsV& out) const;
 
  void clone(const DcuDetIdsV& in, DcuDetIdMap& out) const;
 
  void clone(const DcuDetIdsV& in, DcuDetIdsV& out) const;
 
  // ---------- Database connection, partitions and versions ----------
 
  DeviceFactory* factory_;
 
  DbClient* dbCache_;
 
  SiStripDbParams dbParams_;
 
  // ---------- Local cache of vectors ----------
 
  FedConnections connections_;
 
  DeviceDescriptions devices_;
 
  FedDescriptions feds_;
 
  DcuDetIds dcuDetIds_;
 
  AnalysisDescriptions analyses_;
 
  DeviceDescriptionsV apvDevices_;
 
  DeviceDescriptionsV muxDevices_;
 
  DeviceDescriptionsV dcuDevices_;
 
  DeviceDescriptionsV lldDevices_;
 
  DeviceDescriptionsV pllDevices_;
 
  DeviceDescriptionsV dohDevices_;
 
  DeviceDescriptionsV typedDevices_;
 
  FedIds fedIds_;
 
  // ---------- Miscellaneous ----------
 
  bool usingStrips_;
 
  bool openConnection_;
 
  static std::atomic<uint32_t> cntr_;
 
  static std::atomic<bool> allowCalibUpload_;
};
 
// ---------- Inline methods ----------
 
const SiStripDbParams& SiStripConfigDb::dbParams() const { return dbParams_; }
 
bool SiStripConfigDb::usingDb() const { return dbParams_.usingDb(); }
 
bool SiStripConfigDb::usingStrips() const { return usingStrips_; }
 
void SiStripConfigDb::usingStrips(bool using_strips) { usingStrips_ = using_strips; }
 
#endif  // OnlineDB_SiStripConfigDb_SiStripConfigDb_h