Configuration.h

Go to the documentation of this file.

 
#ifndef CONFIGURATION_H
#define CONFIGURATION_H
 
#include <iosfwd>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#include "HardwareRegistry.h"
 
namespace DAQ {
namespace DDAS {
 
struct FirmwareConfiguration {
  std::string s_ComFPGAConfigFile;
  std::string s_SPFPGAConfigFile;
  std::string s_DSPCodeFile; 
  std::string s_DSPVarFile;  
};
 
typedef std::map<int, FirmwareConfiguration> FirmwareMap;
 
class Configuration {
private:
  int m_crateId{0};                         
  size_t m_numModules{0};                   
  std::vector<unsigned short> m_slotMap;    
  std::vector<unsigned short> m_channelMap; 
  std::string m_settingsFilePath;           
  std::vector<int> m_modEvtLengths;         
  FirmwareMap m_fwMap;            
  std::vector<int> m_hardwareMap; 
 
  // These additions support per module firmware maps and set files:
 
  std::map<int, FirmwareMap> m_moduleFirmwareMaps;
  std::map<int, std::string> m_moduleSetFileMap;
 
public:
  Configuration() = default;
  ~Configuration() = default;
 
  void setCrateId(int id) { m_crateId = id; };
  int getCrateId() const { return m_crateId; };
  void setNumberOfModules(size_t size);
  size_t getNumberOfModules() const { return m_numModules; };
  void setSlotMap(const std::vector<unsigned short> &map);
  std::vector<unsigned short> getSlotMap() const { return m_slotMap; };
  void setChannelMap(const std::vector<unsigned short> &map);
  std::vector<unsigned short> getChannelMap() { return m_channelMap; };
  unsigned short getModuleChannelCount(size_t mod);
  void setSettingsFilePath(const std::string &path) {
    m_settingsFilePath = path;
  };
  std::string getSettingsFilePath() const { return m_settingsFilePath; };
  void setModuleSettingsFilePath(int modnum, const std::string &path);
  std::string getModuleSettingsFilePath(int modNum);
  void setFirmwareConfiguration(int specifier,
                                const FirmwareConfiguration &config) {
    m_fwMap[specifier] = config;
  };
  FirmwareConfiguration &getFirmwareConfiguration(int hdwrType);
  void setModuleFirmwareMap(int module, const FirmwareMap &mapping);
  FirmwareConfiguration &getModuleFirmwareConfiguration(int hdwrType,
                                                        int modnum);
  FirmwareMap &getDefaultFirmwareMap() { return m_fwMap; }
  void setModuleEventLengths(const std::vector<int> &lengths);
  std::vector<int> getModuleEventLengths() const { return m_modEvtLengths; };
  void setHardwareMap(const std::vector<int> &map);
  std::vector<int> getHardwareMap() const { return m_hardwareMap; };
  std::map<int, FirmwareMap> getModuleFirmwareMaps() const {
    return m_moduleFirmwareMaps;
  };
  std::map<int, std::string> getModuleSetFileMap() const {
    return m_moduleSetFileMap;
  };
  void print(std::ostream &stream);
  static std::unique_ptr<Configuration>
  generate(const std::string &cfgPixiePath);
  static std::unique_ptr<Configuration>
  generate(const std::string &fwVsnPath, const std::string &cfgPixiePath);
  static std::unique_ptr<Configuration>
  generate(const std::string &fwVsnPath, const std::string &cfgPixiePath,
           const std::string &modEvtLenPath);
  static std::unique_ptr<Configuration>
  generateManagedFW(const std::string &cfgPixiePath,
                    const std::string &modEvtLenPath);
};
 
} // namespace DDAS
} // namespace DAQ
 
#endif // CONFIGURATION_H