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 "boost/cstdint.hpp"
#include <iostream>
#include <fstream>
#include <sstream>
#include <ostream>
#include <vector>
#include <string>
#include <list>
#include <map>
#include <atomic>

#include "DbClient.h"

namespace sistrip {
  static const uint16_t FEC_CRATE_OFFSET =  0; //@@ temporary
  static const uint16_t FEC_RING_OFFSET  =  0; //@@ temporary
}

// 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;

  // 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