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