Configuration.h

Go to the documentation of this file.

 
#ifndef CONFIGURATION_H
#define CONFIGURATION_H
 
#include <string>
#include <vector>
#include <map>
#include <iosfwd>
#include <memory>
 
#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; 
        std::vector<unsigned short> m_slotMap; 
        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(const Configuration& rhs) :
        m_crateId(rhs.m_crateId), m_slotMap(rhs.m_slotMap),
        m_settingsFilePath(rhs.m_settingsFilePath),
        m_modEvtLengths(rhs.m_modEvtLengths),
        m_fwMap(rhs.m_fwMap), m_hardwareMap(rhs.m_hardwareMap),
        m_moduleFirmwareMaps(rhs.m_moduleFirmwareMaps),
        m_moduleSetFileMap(rhs.m_moduleSetFileMap)
        {}
        ~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_slotMap.size(); };
        void setSlotMap(const std::vector<unsigned short>& map);
        std::vector<unsigned short> getSlotMap()
        const { return m_slotMap; };
        void setSettingsFilePath(const std::string& path)
        { m_settingsFilePath = path; };
        void setModuleSettingsFilePath(
        int modnum, const std::string& path
        );
        std::string getSettingsFilePath()
        const { return m_settingsFilePath; };
        std::string getSettingsFilePath(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; };
        void print(std::ostream& stream);
        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
        );
    };
 
    } // end DDAS namespace
} // end DAQ namesapce
 
#endif // CONFIGURATION_H