Model.h

Go to the documentation of this file.

/*
 * This file is part of OpenModelica.
 *
 * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC),
 * c/o Linköpings universitet, Department of Computer and Information Science,
 * SE-58183 Linköping, Sweden.
 *
 * All rights reserved.
 *
 * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF AGPL VERSION 3 LICENSE OR
 * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8.
 * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES
 * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GNU AGPL
 * VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
 *
 * The OpenModelica software and the OSMC (Open Source Modelica Consortium)
 * Public License (OSMC-PL) are obtained from OSMC, either from the above
 * address, from the URLs:
 * http://www.openmodelica.org or
 * https://github.com/OpenModelica/ or
 * http://www.ida.liu.se/projects/OpenModelica,
 * and in the OpenModelica distribution.
 *
 * GNU AGPL version 3 is obtained from:
 * https://www.gnu.org/licenses/licenses.html#GPL
 *
 * This program is distributed WITHOUT ANY WARRANTY; without
 * even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY SET FORTH
 * IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF OSMC-PL.
 *
 * See the full OSMC Public License conditions for more details.
 *
 */
 
#ifndef _OMS_MODEL_H_
#define _OMS_MODEL_H_
 
#include "Clock.h"
#include "ComRef.h"
#include "Element.h"
#include "ResultWriter.h"
#include "OMSimulator/Types.h"
#include "Snapshot.h"
#include "Values.h"
#include <assert.h>
#include <pugixml.hpp>
 
#include <ctpl_stl.h>
 
#include <dcp/model/constant/DcpError.hpp>
#include <dcp/model/constant/DcpState.hpp>
//#include <dcp/logic/DcpManagerMaster.hpp>
//#include <dcp/driver/ethernet/udp/UdpDriver.hpp>
#include <dcp/log/OstreamLog.hpp>
 
struct DcpConnection
{
    size_t fromServer, fromVr;
    std::vector<size_t> toServers, toVrs;
};
 
//DCP related forward declarations
class DcpManagerMaster;
class UdpDriver;
class SlaveDescription_t;
 
namespace oms
{
  class Component;
  class ComponentDCP;
  class Connection;
  class System;
 
  class Model
  {
  public: // methods
    ~Model();
 
    static Model* NewModel(const ComRef& cref);
 
    const ComRef& getCref() const {return cref;}
    System* getSystem(const ComRef& cref);
    oms_status_enu_t delete_(const ComRef& cref);
    Component* getComponent(const ComRef& cref);
    System* getTopLevelSystem() const {return system;}
    std::string getTempDirectory() const {return tempDir;}
    oms_status_enu_t rename(const ComRef& cref);
    oms_status_enu_t rename(const ComRef& cref, const ComRef& newCref);
    oms_status_enu_t list(const ComRef& cref, char** contents);
    oms_status_enu_t listVariants(const ComRef& cref, char** contents);
    oms_status_enu_t addSystem(const ComRef& cref, oms_system_enu_t type);
    oms_status_enu_t newResources(const ComRef& cref);
    oms_status_enu_t addResources(const ComRef& cref, const std::string& path);
    oms_status_enu_t deleteReferencesInSSD(const ComRef& cref);
    oms_status_enu_t deleteResourcesInSSP(const std::string& filename);
    oms_status_enu_t duplicateVariant(const ComRef& crefA, const ComRef& crefB);
    oms_status_enu_t activateVariant(const ComRef& crefA, const ComRef& crefB);
    oms_status_enu_t referenceResources(const ComRef& cref, const std::string& ssmFile);
    oms_status_enu_t reduceSSV(const std::string& ssvfile, const std::string& ssmfile, const std::string& filepath);
    oms_status_enu_t exportToSSD(Snapshot& snapshot) const;
    oms_status_enu_t exportSnapshot(const ComRef& cref, char** contents);
    oms_status_enu_t exportSSVTemplate(const ComRef& cref, const std::string& filename);
    oms_status_enu_t exportSSMTemplate(const ComRef& cref, const std::string& filename);
    void exportSignalFilter(Snapshot& snapshot) const;
    void exportUnitDefinitionsToSSD(pugi::xml_node& node) const;
    void exportEnumerationDefinitionsToSSD(pugi::xml_node& node) const;
    oms_status_enu_t importFromSnapshot(const Snapshot& snapshot);
    oms_status_enu_t importSnapshot(const char* snapshot, char** newCref);
    oms_status_enu_t importSignalFilter(const std::string& filename, const Snapshot& snapshot);
    oms_status_enu_t exportToFile(const std::string& filename) const;
    oms_system_enu_t getSystemType(const pugi::xml_node& node, const std::string& sspVersion);
    oms_system_enu_t getSystemTypeHelper(const pugi::xml_node& node, const std::string& sspVersion);
    oms_status_enu_t updateParameterBindingsToSSD(pugi::xml_node& node, bool isTopSystemOrModel) const;
    void copyResources(bool copy_resources) {this->copy_resources = copy_resources;}
    bool copyResources() {return copy_resources;}
 
    oms::Element** getElements() {return system ? &elements[0] : nullptr;}
    void writeAllResourcesToFilesystem(std::vector<std::string>& resources, Snapshot& snapshot) const;
 
    oms_status_enu_t instantiate();
    oms_status_enu_t initialize();
    oms_status_enu_t simulate();
    oms_status_enu_t doStep();
    oms_status_enu_t stepUntil(double stopTime);
    oms_status_enu_t terminate();
    oms_status_enu_t reset();
 
    oms_status_enu_t configureDcpMaster();
    oms_status_enu_t addDcpSlave(ComponentDCP *component);
    oms_status_enu_t addDcpConnection(oms::Connection *connection);
    void startDcpMasterThread();
    oms_status_enu_t startDcpMaster();
    oms_status_enu_t setDcpPorts(int masterPort, int slavePort);
 
    oms_modelState_enu_t getModelState() const {return modelState;}
 
    oms_status_enu_t setStartTime(double value);
    double getStartTime() const {return startTime;}
    oms_status_enu_t setStopTime(double value);
    double getStopTime() const {return stopTime;}
    double getTime() const;
    
    oms_status_enu_t setLoggingInterval(double loggingInterval);
    double getLoggingInterval() const {return loggingInterval;}
    oms_status_enu_t setResultFile(const std::string& filename, int bufferSize);
    oms_status_enu_t getResultFile(char** filename, int* bufferSize);
    oms_status_enu_t emit(double time, bool force=false, bool* emitted=NULL);
    oms_status_enu_t addSignalsToResults(const char* regex);
    oms_status_enu_t removeSignalsFromResults(const char* regex);
    std::string escapeSpecialCharacters(const std::string& regex);
 
    bool validState(int validStates) const {return (modelState & validStates);}
 
    bool isIsolatedFMUModel() const {return isolatedFMU;}
    void setIsolatedFMUModel() {isolatedFMU = true;}
 
    bool useThreadPool() {return (pool != nullptr);}
    ctpl::thread_pool& getThreadPool() {assert(pool); return *pool;}
 
    oms_status_enu_t loadSnapshot(const pugi::xml_node& node);
 
    std::vector<std::string> importedResources;  
 
    std::map<ComRef, char*> ssdVariants;  
 
    std::string getVariantName() {return variantName;}
 
  private: // methods
    Model(const ComRef& cref, const std::string& tempDir);
 
    // stop the compiler generating methods copying the object
    Model(Model const& copy);            
    Model& operator=(Model const& copy); 
 
    oms_status_enu_t registerSignalsForResultFile();
 
  private: // attributes
    ComRef cref;
    System* system = NULL;
    std::string tempDir;
 
    std::vector<oms::Element*> elements;
    bool copy_resources = true;
 
    oms_modelState_enu_t modelState = oms_modelState_virgin;
 
    // ssd:DefaultExperiment
    double startTime = 0.0;
    double stopTime = 1.0;
 
    ResultWriter* resultFile = NULL;
    double lastEmit;
    double loggingInterval = 0.0;
    int bufferSize = 10;
    Clock clock;
 
    Values values;
 
    std::string resultFilename; 
    std::string signalFilterFilename = "resources/signalFilter.xml";
 
    std::string variantName = "SystemStructure.ssd";  
 
    std::vector<std::string> externalResources;  
 
    bool isolatedFMU = false;
 
    ctpl::thread_pool* pool = nullptr;
 
    ComRef new_root_cref;
 
    DcpManagerMaster *dcpManager;
    UdpDriver* dcpDriver;
    port_t dcpMasterPort;
    port_t dcpSlavePort;
    int dcpSlaveCount;
    std::map<ComponentDCP*, size_t> dcpComponents;
    std::shared_ptr<SlaveDescription_t> dcpInternalSystemSlaveDescription;
    std::map<ComponentDCP*, std::shared_ptr<SlaveDescription_t>> dcpComponentToSlaveDescriptionMap;
    std::vector<std::shared_ptr<SlaveDescription_t>> dcpSlaveDescriptions;
    std::vector<DcpConnection> dcpConnections;
    OstreamLog dcpLog;
    double dcpComStep;
    double dcpTime = 0; //TODO: Start time should not be hard-coded
    double dcpStopTime = 10;  //TODO: Should not be hard-coded
    std::map<uint8_t, uint64_t> dcpReceivedAcks;
    std::map<uint8_t, uint8_t> dcpNumOfCmd;
    uint8_t dcpMaxInitRuns = 0;
    uint8_t dcpIntializationRuns = 1;
    uint8_t dcpSlavesWaitingForInitialize = 0;
    uint8_t dcpSlavesWaitingForConfiguration = 0;
    uint8_t dcpSlavesWaitingForConfigure = 0;
    uint8_t dcpSlavesWaitingForStep = 0;
    size_t dcpSlavesStopped = 0;
    size_t dcpSlavesDeregistered = 0;
    uint8_t serversRunPastStopTime = 0;
    oms_status_enu_t dcpMasterThreadReturnValue;
 
    
    void dcpInitialize();
    void dcpConfiguration();
    void dcpConfigure();
    void dcpRun(DcpState currentState, uint8_t sender);
    void dcpDoStep();
    void dcpStop();
    void dcpDeregister(uint8_t sender);
    void dcpSendOutputs(DcpState currentState, uint8_t sender);
    void dcpReceiveAck(uint8_t sender, uint16_t);
    void dcpReceiveNAck(uint8_t sender, uint16_t pduSeqId, DcpError errorCode);
    void dcpDataReceived(uint16_t dataId, size_t length, uint8_t payload[]);
    void dcpReceiveStateChangedNotification(uint8_t sender, DcpState state);
  };
}
 
#endif