Source.hpp

/*
Copyright (c) 2017-2026,
Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Energy
Innovation LLC.  See the top-level NOTICE for additional details. All rights reserved.
SPDX-License-Identifier: BSD-3-Clause
*/
 
#pragma once
#include "../application_api/Endpoints.hpp"
#include "../application_api/HelicsPrimaryTypes.hpp"
#include "../application_api/Publications.hpp"
#include "helicsApp.hpp"
 
#include <deque>
#include <map>
#include <memory>
#include <set>
#include <string>
#include <vector>
 
namespace helics {
namespace apps {
    struct SourceObject {
        Publication pub;
        Time period;
        Time nextTime{timeZero};
        int generatorIndex{-1};
        std::string generatorName;
        SourceObject() = default;
        SourceObject(const Publication& p, Time per): pub(p), period(per) {}
        // source type
    };
 
    class HELICS_CXX_EXPORT SignalGenerator {
      protected:
        Time lastTime{timeZero};
        Time keyTime{timeZero};
        std::string mName;
 
      public:
        SignalGenerator() = default;
        explicit SignalGenerator(std::string_view name): mName{name} {};
        virtual ~SignalGenerator() = default;
        virtual void set(std::string_view parameter, double val);
        virtual void setString(std::string_view parameter, std::string_view val);
        virtual defV generate(Time signalTime) = 0;
        void setTime(Time indexTime) { keyTime = indexTime; }
        const std::string& getName() { return mName; }
    };
 
    class HELICS_CXX_EXPORT Source: public App {
      public:
        Source() = default;
        explicit Source(std::vector<std::string> args);
        Source(int argc, char* argv[]);
        Source(std::string_view name, const FederateInfo& fedInfo);
        Source(std::string_view name,
               const std::shared_ptr<Core>& core,
               const FederateInfo& fedInfo);
 
        Source(std::string_view name, CoreApp& core, const FederateInfo& fedInfo);
        Source(std::string_view name, const std::string& configString);
 
        Source(Source&& other_source) = default;
 
        Source& operator=(Source&& fed) = default;
 
        virtual void initialize() override;
 
        virtual void runTo(Time stopTime_input) override;
 
        void addPublication(std::string_view key,
                            std::string_view generator,
                            DataType type,
                            Time period,
                            std::string_view units = std::string_view());
 
        void addPublication(std::string_view key,
                            DataType type,
                            Time period,
                            std::string_view units = std::string_view())
        {
            addPublication(key, std::string_view(), type, period, units);
        }
        int addSignalGenerator(std::string_view name, std::string_view type);
        void setStartTime(std::string_view key, Time startTime);
        void setPeriod(std::string_view key, Time period);
        void linkPublicationToGenerator(std::string_view key, std::string_view generator);
        void linkPublicationToGenerator(std::string_view key, int genIndex);
        std::shared_ptr<SignalGenerator> getGenerator(int index);
 
      private:
        void initialSetup();
        void processArgs();
        virtual void loadJsonFile(const std::string& jsonString,
                                  bool enableFederateInterfaceRegistration) override;
        Time runSource(SourceObject& obj, Time currentTime);
        Time runSourceLoop(Time currentTime);
 
      private:
        std::deque<SourceObject> sources;  
        std::vector<std::shared_ptr<SignalGenerator>> generators;  
        std::map<std::string_view, int> generatorLookup;  
        std::vector<Endpoint> endpoints;  
        std::map<std::string_view, int> pubids;  
        Time defaultPeriod = 1.0;  
    };
}  // namespace apps
}  // namespace helics