From bfa685802534547b0e8159433088d2b2075ddb69 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Fri, 13 Dec 2024 15:42:34 +0100 Subject: [PATCH 01/32] add FMI3.0 prototype for cosimulation --- 3rdParty | 2 +- include/OMSimulator/Types.h | 1 + src/OMSimulatorLib/CMakeLists.txt | 1 + src/OMSimulatorLib/Component.cpp | 33 + src/OMSimulatorLib/Component.h | 2 +- src/OMSimulatorLib/ComponentFMU3CS.cpp | 1940 +++++++++++++++++ src/OMSimulatorLib/ComponentFMU3CS.h | 167 ++ src/OMSimulatorLib/ComponentFMUCS.cpp | 4 +- src/OMSimulatorLib/ComponentFMUME.cpp | 4 +- src/OMSimulatorLib/FMUInfo.cpp | 75 +- src/OMSimulatorLib/FMUInfo.h | 5 +- src/OMSimulatorLib/System.cpp | 23 +- src/OMSimulatorLib/System.h | 1 + src/OMSimulatorLib/SystemWC.cpp | 5 + src/OMSimulatorLib/Values.cpp | 150 ++ src/OMSimulatorLib/Values.h | 2 + src/OMSimulatorLib/Variable.cpp | 199 +- src/OMSimulatorLib/Variable.h | 50 +- testsuite/reference-fmus/3.0/BouncingBall.lua | 45 + .../aarch64-darwin/BouncingBall.dylib | Bin 0 -> 89632 bytes .../binaries/aarch64-linux/BouncingBall.so | Bin 0 -> 71848 bytes .../binaries/x86-windows/BouncingBall.dll | Bin 0 -> 135680 bytes .../binaries/x86_64-darwin/BouncingBall.dylib | Bin 0 -> 88944 bytes .../binaries/x86_64-linux/BouncingBall.so | Bin 0 -> 71312 bytes .../binaries/x86_64-windows/BouncingBall.dll | Bin 0 -> 168448 bytes .../BouncingBall3/documentation/index.html | 146 ++ .../BouncingBall3/documentation/result.svg | 1 + .../BouncingBall3/modelDescription.xml | 75 + .../sources/buildDescription.xml | 13 + .../resources/BouncingBall3/sources/config.h | 34 + .../BouncingBall3/sources/cosimulation.c | 691 ++++++ .../BouncingBall3/sources/cosimulation.h | 5 + .../BouncingBall3/sources/fmi3Functions.c | 1446 ++++++++++++ .../resources/BouncingBall3/sources/model.c | 222 ++ .../resources/BouncingBall3/sources/model.h | 250 +++ testsuite/resources/Makefile | 1 + 36 files changed, 5529 insertions(+), 64 deletions(-) create mode 100644 src/OMSimulatorLib/ComponentFMU3CS.cpp create mode 100644 src/OMSimulatorLib/ComponentFMU3CS.h create mode 100644 testsuite/reference-fmus/3.0/BouncingBall.lua create mode 100644 testsuite/resources/BouncingBall3/binaries/aarch64-darwin/BouncingBall.dylib create mode 100644 testsuite/resources/BouncingBall3/binaries/aarch64-linux/BouncingBall.so create mode 100644 testsuite/resources/BouncingBall3/binaries/x86-windows/BouncingBall.dll create mode 100644 testsuite/resources/BouncingBall3/binaries/x86_64-darwin/BouncingBall.dylib create mode 100644 testsuite/resources/BouncingBall3/binaries/x86_64-linux/BouncingBall.so create mode 100644 testsuite/resources/BouncingBall3/binaries/x86_64-windows/BouncingBall.dll create mode 100644 testsuite/resources/BouncingBall3/documentation/index.html create mode 100644 testsuite/resources/BouncingBall3/documentation/result.svg create mode 100644 testsuite/resources/BouncingBall3/modelDescription.xml create mode 100644 testsuite/resources/BouncingBall3/sources/buildDescription.xml create mode 100644 testsuite/resources/BouncingBall3/sources/config.h create mode 100644 testsuite/resources/BouncingBall3/sources/cosimulation.c create mode 100644 testsuite/resources/BouncingBall3/sources/cosimulation.h create mode 100644 testsuite/resources/BouncingBall3/sources/fmi3Functions.c create mode 100644 testsuite/resources/BouncingBall3/sources/model.c create mode 100644 testsuite/resources/BouncingBall3/sources/model.h diff --git a/3rdParty b/3rdParty index da12def4a..7efd72686 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit da12def4aa789be4c73461b66e5dfe172f74ea86 +Subproject commit 7efd726863a9eb0317139bc15128d735e86c62fc diff --git a/include/OMSimulator/Types.h b/include/OMSimulator/Types.h index b2aa2094e..6270a3fd2 100644 --- a/include/OMSimulator/Types.h +++ b/include/OMSimulator/Types.h @@ -100,6 +100,7 @@ typedef enum { typedef enum { oms_component_none, oms_component_fmu, ///< FMU + oms_component_fmu3, ///< FMU3 oms_component_table, ///< lookup table oms_component_external ///< external model } oms_component_enu_t; diff --git a/src/OMSimulatorLib/CMakeLists.txt b/src/OMSimulatorLib/CMakeLists.txt index 89c2dfc4a..3fef7ac68 100644 --- a/src/OMSimulatorLib/CMakeLists.txt +++ b/src/OMSimulatorLib/CMakeLists.txt @@ -26,6 +26,7 @@ set(OMSIMULATORLIB_SOURCES Clocks.cpp Component.cpp ComponentFMUCS.cpp + ComponentFMU3CS.cpp ComponentFMUME.cpp ComponentTable.cpp ComRef.cpp diff --git a/src/OMSimulatorLib/Component.cpp b/src/OMSimulatorLib/Component.cpp index b9940e42f..2d8aee60f 100644 --- a/src/OMSimulatorLib/Component.cpp +++ b/src/OMSimulatorLib/Component.cpp @@ -89,6 +89,39 @@ void oms::fmi2logger(fmi2ComponentEnvironment env, fmi2String instanceName, fmi2 } } +void oms::fmi3logger(fmi3InstanceEnvironment env, fmi3Status status, fmi3String category, fmi3String message) +{ + if (status == fmi3OK && !logDebugEnabled()) + { + // When frequently called for debug logging during simulation, avoid costly formatting. + return; + } + + std::string msg = message; // Directly use the message as a string. + + switch (status) + { + case fmi3OK: + logDebug("[fmi3OK] " + std::string(category) + ": " + msg); + break; + case fmi3Warning: + logWarning("[fmi3Warning] " + std::string(category) + ": " + msg); + break; + case fmi3Discard: + logError("[fmi3Discard] " + std::string(category) + ": " + msg); + break; + case fmi3Error: + logError("[fmi3Error] " + std::string(category) + ": " + msg); + break; + case fmi3Fatal: + logError("[fmi3Fatal] " + std::string(category) + ": " + msg); + break; + default: + logError("[unknown] " + std::string(category) + ": " + msg); + break; + } +} + oms::Component::Component(const ComRef& cref, oms_component_enu_t type, System* parentSystem, const std::string& path) : element(oms_element_component, cref), cref(cref), type(type), parentSystem(parentSystem), path(path) { diff --git a/src/OMSimulatorLib/Component.h b/src/OMSimulatorLib/Component.h index 90853c6fb..8115808cc 100644 --- a/src/OMSimulatorLib/Component.h +++ b/src/OMSimulatorLib/Component.h @@ -55,7 +55,7 @@ namespace oms class Variable; void fmi2logger(fmi2ComponentEnvironment env, fmi2String instanceName, fmi2Status status, fmi2String category, fmi2String message, ...); - + void fmi3logger(fmi3InstanceEnvironment env, fmi3Status status, fmi3String category, fmi3String message); class Component { public: diff --git a/src/OMSimulatorLib/ComponentFMU3CS.cpp b/src/OMSimulatorLib/ComponentFMU3CS.cpp new file mode 100644 index 000000000..18037cd8e --- /dev/null +++ b/src/OMSimulatorLib/ComponentFMU3CS.cpp @@ -0,0 +1,1940 @@ +/* + * This file is part of OpenModelica. + * + * Copyright (c) 1998-CurrentYear, 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 GPL VERSION 3 LICENSE OR + * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.2. + * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES + * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GPL VERSION 3, + * ACCORDING TO RECIPIENTS CHOICE. + * + * The OpenModelica software and the Open Source Modelica + * Consortium (OSMC) Public License (OSMC-PL) are obtained + * from OSMC, either from the above address, + * from the URLs: http://www.ida.liu.se/projects/OpenModelica or + * http://www.openmodelica.org, and in the OpenModelica distribution. + * GNU version 3 is obtained from: http://www.gnu.org/copyleft/gpl.html. + * + * 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. + * + */ + +#include "ComponentFMU3CS.h" + +#include "Flags.h" +#include "Logging.h" +#include "Model.h" +#include "OMSFileSystem.h" +#include "ssd/Tags.h" +#include "System.h" +#include "SystemWC.h" + +#include +#include +#include +#include +#include + + +oms::ComponentFMU3CS::ComponentFMU3CS(const ComRef& cref, System* parentSystem, const std::string& fmuPath) + : oms::Component(cref, oms_component_fmu3, parentSystem, fmuPath), fmuInfo(fmuPath) +{ +} + +oms::ComponentFMU3CS::~ComponentFMU3CS() +{ + if (oms_modelState_virgin != getModel().getModelState()) + fmi3_freeInstance(fmu); + + fmi4c_freeFmu(fmu); +} + +oms::Component* oms::ComponentFMU3CS::NewComponent(const oms::ComRef& cref, oms::System* parentSystem, const std::string& fmuPath, std::string replaceComponent) +{ + if (!cref.isValidIdent()) + { + logError_InvalidIdent(cref); + return NULL; + } + + if (!parentSystem) + { + logError_InternalError; + return NULL; + } + // replaceComponent string will be used to avoid name conflicts when replacing a fmu with oms_replaceSubModel(), the default is "" + + filesystem::path temp_root(parentSystem->getModel().getTempDirectory()); + filesystem::path temp_temp = temp_root / "temp"; + filesystem::path relFMUPath = parentSystem->copyResources() ? (filesystem::path("resources") / (parentSystem->getUniqueID() + "_" + replaceComponent + std::string(cref) + ".fmu")) : filesystem::path(fmuPath); + filesystem::path absFMUPath = temp_root / relFMUPath; + + ComponentFMU3CS* component = new ComponentFMU3CS(cref, parentSystem, relFMUPath.generic_string()); + + /* parse the modeldescription.xml at top level to get the GUID to check whether instance already exist + * so we don't need to unpack the fmu, and also parse start values before instantiating fmu's + */ + std::string guid_ = ""; + filesystem::path modelDescriptionPath; + /* + * check for modeldescription path from file system or temp directory + * because when importingSnapshot the path will be resources/0001_tank1.fmu + */ + if (parentSystem->copyResources()) + modelDescriptionPath = fmuPath; + else + modelDescriptionPath = parentSystem->getModel().getTempDirectory() / filesystem::path(fmuPath); + + component->values.parseModelDescriptionFmi3(modelDescriptionPath, guid_); + + /* + * check if instance of an fmu already exist by using guid of the fmu + * if instance exist use the existing instance path + * eg: tank1 => resources /0001_tank1.fmu + * tank2 => resources /0001_tank1.fmu + */ + auto it = parentSystem->fmuGuid.find(guid_); + if (it == parentSystem->fmuGuid.end()) + parentSystem->fmuGuid[guid_] = relFMUPath; + else + { + // instance exists and update the FMU path to already existing instance + relFMUPath = parentSystem->fmuGuid[guid_]; + absFMUPath = temp_root / relFMUPath; + component->setPath(relFMUPath.generic_string()); + } + + // Copy the resource to the temp directory of the model? We don't want have + // to copy resources if importing an SSP file or snapshot. + if (parentSystem->copyResources() && !filesystem::exists(absFMUPath)) + oms_copy_file(filesystem::path(fmuPath), absFMUPath); + + // set temp directory + filesystem::path tempDir = temp_temp / relFMUPath.stem(); + component->setTempDir(tempDir.string()); + + bool dirExist = true; + if (!filesystem::is_directory(tempDir)) + { + dirExist = false; + if (!filesystem::create_directory(tempDir)) + { + logError("Creating temp directory for component \"" + std::string(cref) + "\" failed"); + return NULL; + } + } + + // TODO check for fmu already unpacked or not and read directly modeldescription.xml from unpacked resources + + // load the fmu and parse modelDescription.xml + component->fmu = fmi4c_loadFmu(absFMUPath.string().c_str(), tempDir.generic_string().c_str()); + if (!component->fmu) + { + logError("Error parsing modelDescription.xml"); + delete component; + return NULL; + } + + fmiVersion_t version = fmi4c_getFmiVersion(component->fmu); + if (fmiVersion3 != version) + { + logError("Unsupported FMI version: " + version); + delete component; + return NULL; + } + + if (!fmi3_supportsCoSimulation(component->fmu)) + { + logError("FMU \"" + std::string(cref) + "\" doesn't support co-simulation mode."); + delete component; + return NULL; + } + + // update FMU info + component->fmuInfo.update(oms_component_fmu3, component->fmu); + component->omsfmi3logger = oms::fmi3logger; + + //std::cout << "\n Numberof variables: " << fmi3_getNumberOfVariables(component->fmu); + + // create a list of all variables using fmi4c variable structure + component->allVariables.reserve(fmi3_getNumberOfVariables(component->fmu)); + component->exportVariables.reserve(fmi3_getNumberOfVariables(component->fmu)); + for (unsigned int i = 0; i < fmi3_getNumberOfVariables(component->fmu); ++i) + { + oms::Variable v(component->fmu, i, oms_component_fmu3); + //logInfo("vars: " + std::string(v.getCref().c_str())); + if (v.getIndex() != i) + { + logError("Index mismatch " + std::to_string(v.getIndex()) + " != " + std::to_string(i) + ".\nPlease report the problem to the dev team: https://github.com/OpenModelica/OMSimulator/issues/new?assignees=&labels=&template=bug_report.md"); + delete component; + return NULL; + } + + // extract continuous-time derivatives + if (v.isContinuousTimeDer()) + component->derivatives.push_back(v.getIndex()); + + component->allVariables.push_back(v); + component->exportVariables.push_back(true); + } + + // mark states and continuous-time states + for (unsigned int i = 0; i < fmi3_getNumberOfVariables(component->fmu); ++i) + { + if (component->allVariables[i].isContinuousTimeDer()) + component->allVariables[component->allVariables[i].getStateIndex()-1].markAsContinuousTimeState(i); + else if (component->allVariables[i].isDer()) + component->allVariables[component->allVariables[i].getStateIndex()-1].markAsState(i); + } + + // create some special variable maps + for (auto const& v : component->allVariables) + { + if (v.isInput()) + component->inputs.push_back(v.getIndex()); + else if (v.isOutput()) + { + component->outputs.push_back(v.getIndex()); + component->outputsGraph.addNode(Connector(oms_causality_output, v.getType(), v.getCref(), component->getFullCref())); + } + else if (v.isParameter()) + component->parameters.push_back(v.getIndex()); + else if (v.isCalculatedParameter()) + component->calculatedParameters.push_back(v.getIndex()); + + if (v.isInitialUnknown()) + component->initialUnknownsGraph.addNode(Connector(v.getCausality(), v.getType(), v.getCref(), component->getFullCref())); + + component->exportVariables.push_back(v.isInput() || v.isOutput()); + } + + // create connectors + while (component->connectors.size() > 0 && NULL == component->connectors.back()) + component->connectors.pop_back(); + + int j = 1; + int size = 1 + component->inputs.size(); + for (const auto& i : component->inputs) + component->connectors.push_back(new Connector(oms_causality_input, component->allVariables[i].getType(), component->allVariables[i].getCref(), component->getFullCref(), j++/(double)size)); + j = 1; + size = 1 + component->outputs.size(); + for (const auto& i : component->outputs) + component->connectors.push_back(new Connector(oms_causality_output, component->allVariables[i].getType(), component->allVariables[i].getCref(), component->getFullCref(), j++/(double)size)); + for (const auto& i : component->parameters) + component->connectors.push_back(new Connector(oms_causality_parameter, component->allVariables[i].getType(), component->allVariables[i].getCref(), component->getFullCref())); + for (const auto& i : component->calculatedParameters) + component->connectors.push_back(new Connector(oms_causality_calculatedParameter, component->allVariables[i].getType(), component->allVariables[i].getCref(), component->getFullCref())); + component->connectors.push_back(NULL); + component->element.setConnectors(&component->connectors[0]); + + if (oms_status_ok != component->initializeDependencyGraph_initialUnknowns()) + { + logError(std::string(cref) + ": Couldn't initialize dependency graph for initial unknowns."); + delete component; + return NULL; + } + if (oms_status_ok != component->initializeDependencyGraph_outputs()) + { + logError(std::string(cref) + ": Couldn't initialize dependency graph for simulation unknowns."); + delete component; + return NULL; + } + + // set units to connector + for (auto &connector : component->connectors) + { + if (connector) + { + oms::ComRef connectorCref = connector->getName(); + std::string unitName = component->values.getUnitFromModeldescription(connectorCref); + if (!unitName.empty()) + connector->connectorUnits[unitName] = component->values.modeldescriptionUnitDefinitions[unitName]; + + // get enumerationTypes + std::string enumType = component->values.getEnumerationTypeFromModeldescription(connectorCref); + if (!enumType.empty()) + connector->enumerationName[connectorCref] = enumType; + } + } + return component; +} + +oms::Component* oms::ComponentFMU3CS::NewComponent(const pugi::xml_node& node, oms::System* parentSystem, const std::string& sspVersion, const Snapshot& snapshot, std::string variantName) +{ + ComRef cref = ComRef(node.attribute("name").as_string()); + std::string type = node.attribute("type").as_string(); + std::string source = node.attribute("source").as_string(); + + if (type != "application/x-fmu-sharedlibrary" && !type.empty()) + { + logError("Unexpected component type: " + type); + return NULL; + } + + oms::ComponentFMU3CS* component = dynamic_cast(oms::ComponentFMU3CS::NewComponent(cref, parentSystem, source)); + if (!component) + return NULL; + + for (const auto& connector : component->connectors) + if (connector) + delete connector; + component->connectors.clear(); + for(pugi::xml_node_iterator it = node.begin(); it != node.end(); ++it) + { + std::string name = it->name(); + if(name == oms::ssp::Draft20180219::ssd::connectors) + { + // get the ssdNode to parse UnitDefinitions in "SystemStructure.ssd" + pugi::xml_node ssdNode = snapshot.getResourceNode(variantName); + component->values.importUnitDefinitions(ssdNode); + // import connectors + for(pugi::xml_node_iterator itConnectors = (*it).begin(); itConnectors != (*it).end(); ++itConnectors) + { + component->connectors.push_back(oms::Connector::NewConnector(*itConnectors, sspVersion, component->getFullCref())); + // set units to connector + if ((*itConnectors).child(oms::ssp::Version1_0::ssc::real_type)) + { + std::string unitName = (*itConnectors).child(oms::ssp::Version1_0::ssc::real_type).attribute("unit").as_string(); + if (!unitName.empty()) + component->connectors.back()->connectorUnits[unitName] = component->values.modeldescriptionUnitDefinitions[unitName]; + } + // set enumeration definitions + if ((*itConnectors).child(oms::ssp::Version1_0::ssc::enumeration_type)) + { + std::string enumTypeName = (*itConnectors).child(oms::ssp::Version1_0::ssc::enumeration_type).attribute("name").as_string(); + if (!enumTypeName.empty()) + component->connectors.back()->enumerationName[component->connectors.back()->getName().c_str()] = enumTypeName; + + // give priority to enum definitions in ssd over modeldescription.xml, it is possible the user might have manually change values in ssd file + component->values.importEnumerationDefinitions(ssdNode, enumTypeName); + } + } + } + else if(name == oms::ssp::Draft20180219::ssd::element_geometry) + { + oms::ssd::ElementGeometry geometry; + geometry.importFromSSD(*it); + component->setGeometry(geometry); + } + else if(name == oms::ssp::Version1_0::ssd::parameter_bindings) + { + // set parameter bindings associated with the component + Values resources; + std::string tempdir = parentSystem->getModel().getTempDirectory(); + resources.importFromSnapshot(*it, sspVersion, snapshot, variantName); + component->values.parameterResources.push_back(resources); + } + else + { + logError_WrongSchema(name); + delete component; + return NULL; + } + } + + component->connectors.push_back(NULL); + component->element.setConnectors(&component->connectors[0]); + + return component; +} + +oms_status_enu_t oms::ComponentFMU3CS::exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const +{ + node.append_attribute("name") = this->getCref().c_str(); + node.append_attribute("type") = "application/x-fmu-sharedlibrary"; + node.append_attribute("source") = getPath().c_str(); + + if (element.getGeometry()) + element.getGeometry()->exportToSSD(node); + + if (connectors.size() > 1) + { + pugi::xml_node node_connectors = node.append_child(oms::ssp::Draft20180219::ssd::connectors); + for (const auto& connector : connectors) + if (connector) + if (oms_status_ok != connector->exportToSSD(node_connectors)) + return oms_status_error; + } + + // export ParameterBindings at component level + values.exportParameterBindings(node, snapshot, variantName); + + return oms_status_ok; +} + +void oms::ComponentFMU3CS::getFilteredUnitDefinitionsToSSD(std::map>& unitDefinitions) +{ + // get units from connectors + for (const auto &connector : connectors) + { + if (connector) + { + if (!connector->connectorUnits.empty()) + { + for (auto &con : connector->connectorUnits) + { + auto unitvalue = unitDefinitions.find(con.first); + if (unitvalue == unitDefinitions.end()) + unitDefinitions[con.first] = con.second; + } + } + } + } + + return values.getFilteredUnitDefinitionsToSSD(unitDefinitions); +} + +void oms::ComponentFMU3CS::getFilteredEnumerationDefinitionsToSSD(std::map>& enumerationDefinitions) +{ + return values.getFilteredEnumerationDefinitionsToSSD(enumerationDefinitions); +} + +oms_status_enu_t oms::ComponentFMU3CS::exportToSSV(pugi::xml_node& ssvNode) +{ + return values.exportToSSV(ssvNode); +} + +oms_status_enu_t oms::ComponentFMU3CS::exportToSSVTemplate(pugi::xml_node& ssvNode, Snapshot& snapshot) +{ + values.exportToSSVTemplate(ssvNode, getCref()); + values.exportUnitDefinitionsToSSVTemplate(snapshot, "template.ssv"); + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::exportToSSMTemplate(pugi::xml_node& ssmNode) +{ + values.exportToSSMTemplate(ssmNode, getCref()); + return oms_status_ok; +} + +void oms::ComponentFMU3CS::dumpInitialUnknowns() +{ + std::string str = ""; + int n=0; + for (auto &v : allVariables) + { + if (v.isInitialUnknown()) + { + n++; + if (!str.empty()) + str += ", "; + str += std::to_string(v.getIndex()+1) + ": " + std::string(v.getCref()); + } + } + logInfo("[" + std::string(getCref()) + ": " + getPath() + "] The FMU contains " + std::to_string(n) + " initial unknowns: " + str); +} + +oms_status_enu_t oms::ComponentFMU3CS::initializeDependencyGraph_initialUnknowns() +{ + if (initialUnknownsGraph.getEdges().connections.size() > 0) + return logError(std::string(getCref()) + ": " + getPath() + " is already initialized"); + + //dumpInitialUnknowns(); + + // Check if initial unknowns from modelDescription.xml are the same as in initialUnknownsGraph + size_t N_ModelStructure = values.modelStructureInitialUnknowns.size(); + size_t N = initialUnknownsGraph.getNodes().size(); + + bool badInitialUnknowns = false; + + std::unordered_set setA_ModelStructure; + for (const auto &it : values.modelStructureInitialUnknowns) + setA_ModelStructure.insert(it.first-1); + + std::string missing_unknowns = ""; + for (auto &v : allVariables) + { + if (v.isInitialUnknown() && setA_ModelStructure.find(v.getIndex()) == setA_ModelStructure.end()) + { + badInitialUnknowns = true; + missing_unknowns += "\n * " + std::to_string(v.getIndex()+1) + ": " + std::string(v.getCref()) + " is missing"; + } + } + + for (const auto &it : values.modelStructureInitialUnknowns) + { + const Variable &var_oms = allVariables[it.first - 1]; + fmi3VariableHandle *var = fmi3_getVariableByIndex(fmu, (it.first - 1)); + oms::ComRef name_fmilib = fmi3_getVariableName(var); + // std::cout << "\nDebug: " << var_oms.getCref().c_str() << "===>" << name_fmilib.c_str() << "===>" << var_oms.isInitialUnknown(); + if (var_oms.getCref() != name_fmilib) + { + missing_unknowns += "\n * " + std::to_string(it.first) + ": " + std::string(var_oms.getCref()) + " could not be found"; + badInitialUnknowns = true; + } + else if (!var_oms.isInitialUnknown()) + { + missing_unknowns += "\n * " + std::to_string(it.first) + ": " + std::string(var_oms.getCref()) + " is wrongly listed"; + badInitialUnknowns = true; + } + } + + + if (badInitialUnknowns && !Flags::IgnoreInitialUnknowns() && N_ModelStructure > 0) + logWarning("[" + std::string(getCref()) + ": " + getPath() + "] The FMU lists " + std::to_string(N_ModelStructure) + " initial unknowns and exposes " + std::to_string(N) + " initial unknowns." + missing_unknowns); + + if (badInitialUnknowns) + { + if(!Flags::IgnoreInitialUnknowns() && N_ModelStructure > 0) + logInfo("[" + std::string(getCref()) + ": " + getPath() + "] The FMU contains bad initial unknowns. This might cause problems, e.g. wrong simulation results."); + else + { + if (N_ModelStructure > 0) + logWarning("[" + std::string(getCref()) + ": " + getPath() + "] The dependencies of the initial unknowns defined in the FMU are ignored because the flag --ignoreInitialUnknowns is active. Instead, all the initial unknowns will depend on all inputs."); + for (int i=0; i < N; i++) + { + logDebug(std::string(getCref()) + ": " + getPath() + " initial unknown " + std::string(initialUnknownsGraph.getNodes()[i]) + " depends on all inputs"); + for (const auto& j : inputs) + initialUnknownsGraph.addEdge(allVariables[j].makeConnector(this->getFullCref()), initialUnknownsGraph.getNodes()[i]); + } + return oms_status_ok; + } + } + + // get the initial unknowns dependencies + int i = 0; + for (const auto &it : values.modelStructureInitialUnknowns) + { + //std::cout << "\nInitialUnknowns dependencies: " << it.first << "===>" << it.second.size() << "==>" << values.modelStructureInitialUnknownsDependencyExist[it.first]; + // no dependencies + if (it.second.empty() && values.modelStructureInitialUnknownsDependencyExist[it.first]) + logDebug(std::string(getCref()) + ": " + getPath() + " initial unknown " + std::string(initialUnknownsGraph.getNodes()[i]) + " has no dependencies"); + + // dependency attribute not provided in modeldescription.xml, all output depends on all inputs + else if (it.second.empty() && !values.modelStructureInitialUnknownsDependencyExist[it.first]) + { + logDebug(std::string(getCref()) + ": " + getPath() + " initial unknown " + std::string(initialUnknownsGraph.getNodes()[i]) + " depends on all inputs"); + for (const auto& j : inputs) + initialUnknownsGraph.addEdge(allVariables[j].makeConnector(this->getFullCref()), initialUnknownsGraph.getNodes()[i]); + } + else + { + //dependency exist + for (const auto &index : it.second) + { + if (index < 1 || index > allVariables.size()) + { + logWarning("Initial unknown " + std::string(initialUnknownsGraph.getNodes()[i]) + " has bad dependency on variable with index " + std::to_string(index) + " which couldn't be resolved"); + return logError(std::string(getCref()) + ": Erroneous initial unknowns detected in modelDescription.xml\nUse flag --ignoreInitialUnknowns=true to ignore all initial unknowns, but this can cause inflated loop size."); + } + logDebug(std::string(getCref()) + ": " + getPath() + " initial unknown " + std::string(initialUnknownsGraph.getNodes()[i]) + " depends on " + std::string(allVariables[index - 1])); + initialUnknownsGraph.addEdge(allVariables[index - 1].makeConnector(this->getFullCref()), initialUnknownsGraph.getNodes()[i]); + } + } + i = i + 1; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::initializeDependencyGraph_outputs() +{ + if (outputsGraph.getEdges().connections.size() > 0) + { + logError(std::string(getCref()) + ": " + getPath() + " is already initialized."); + return oms_status_error; + } + + // if (!startIndex) + // { + // logDebug(std::string(getCref()) + ": " + getPath() + " no dependencies"); + // return oms_status_ok; + // } + + // get the output dependencies + int i = 0; + for (const auto &it : values.modelStructureOutputs) + { + Variable& output = allVariables[outputs[i]]; + // no dependencies + if (it.second.empty() && values.modelStructureOutputDependencyExist[it.first]) + { + logDebug(std::string(getCref()) + ": " + getPath() + " output " + std::string(output) + " has no dependencies"); + } + // dependency attribute not provided in modeldescription.xml, all output depends on all inputs + else if (it.second.empty() && !values.modelStructureOutputDependencyExist[it.first]) + { + logDebug(std::string(getCref()) + ": " + getPath() + " output " + std::string(output) + " depends on all"); + for (const auto& j : inputs) + outputsGraph.addEdge(allVariables[j].makeConnector(this->getFullCref()), output.makeConnector(this->getFullCref())); + } + else + { + for (const auto &index : it.second) + { + if (index < 1 || index > allVariables.size()) + { + logWarning("Output " + std::string(output) + " has bad dependency on variable with index " + std::to_string(index) + " which couldn't be resolved"); + return logError(std::string(getCref()) + ": erroneous dependencies detected in modelDescription.xml"); + } + logDebug(std::string(getCref()) + ": " + getPath() + " output " + std::string(output) + " depends on " + std::string(allVariables[index - 1])); + outputsGraph.addEdge(allVariables[index - 1].makeConnector(this->getFullCref()), output.makeConnector(this->getFullCref())); + } + } + i = i + 1; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::instantiate() +{ + // TODO investigate fmi3IntermediateUpdateCallback = NULL + if(!fmi3_instantiateCoSimulation(fmu, fmi3False, fmi3True, fmi3False, fmi3False, NULL, 0, fmu, omsfmi3logger, NULL)) + { + logInfo("fmi3Instantiate() failed"); + exit(1); + } + + // set start values from local resources + if (values.hasResources()) + { + for (const auto &it : values.parameterResources) + { + for (const auto &res : it.allresources) + { + if (res.second.linkResources) // set values only if resources are linked in ssd + setResourcesHelper1(res.second); + } + } + /* + check for parameter entry at system level and override the start values if exist, + as system level parameter has highest priority, this is done after checking for + local resources because it is possible some parameters have local entry and other + parameters have top level system entry + */ + if (getParentSystem() && getParentSystem()->getValues().hasResources()) + setResourcesHelper2(getParentSystem()->getValues()); + } + // set start values from root resources + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + setResourcesHelper2(getParentSystem()->getValues()); + } + // set start values from top level root resources + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + setResourcesHelper2(getParentSystem()->getParentSystem()->getValues()); + } + // set start values from inline resources + else + { + setResourcesHelper1(values); + } + // enterInitialization + time = getModel().getStartTime(); + + double relativeTolerance = 0.0; + dynamic_cast(getParentSystem())->getTolerance(&relativeTolerance); + + fmi3Status status_ = fmi3_enterInitializationMode(fmu, fmi3False, relativeTolerance, time, fmi3True, getModel().getStopTime()); + + if (fmi3OK != status_) return logError_FMUCall("fmi3_enterInitializationMode", this); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setResourcesHelper1(Values values) +{ + for (const auto &v : values.booleanStartValues) + { + oms::ComRef cref = getValidCref(v.first); + if (oms_status_ok != setBoolean(cref, v.second)) + return logError("Failed to set start value for " + std::string(v.first)); + } + for (const auto &v : values.integerStartValues) + { + oms::ComRef cref = getValidCref(v.first); + if (oms_status_ok != setInteger(cref, v.second)) + return logError("Failed to set start value for " + std::string(v.first)); + } + for (const auto &v : values.realStartValues) + { + oms::ComRef cref = getValidCref(v.first); + if (oms_status_ok != setReal(cref, v.second)) + return logError("Failed to set start value for " + std::string(v.first)); + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setResourcesHelper2(Values values) +{ + for (const auto &it : values.parameterResources) + { + for (const auto &res : it.allresources) + { + for (const auto &v : res.second.booleanStartValues) + { + if (res.second.linkResources) // set values only if resources are linked in ssd + { + oms::ComRef tail(v.first); + oms::ComRef head = tail.pop_front(); + if (head == getCref()) + { + if (oms_status_ok != setBoolean(tail, v.second)) + return logError("Failed to set start value for " + std::string(v.first)); + } + } + } + for (const auto &v : res.second.integerStartValues) + { + if (res.second.linkResources) // set values only if resources are linked in ssd + { + oms::ComRef tail(v.first); + oms::ComRef head = tail.pop_front(); + if (head == getCref()) + { + if (oms_status_ok != setInteger(tail, v.second)) + return logError("Failed to set start value for " + std::string(v.first)); + } + } + } + for (const auto &v : res.second.realStartValues) + { + if (res.second.linkResources) // set values only if resources are linked in ssd + { + oms::ComRef tail(v.first); + oms::ComRef head = tail.pop_front(); + if (head == getCref()) + { + if (oms_status_ok != setReal(tail, v.second)) + return logError("Failed to set start value for " + std::string(v.first)); + } + } + } + } + } + + return oms_status_ok; +} + +/* + * function which returns validCrefs + * (e.g) add.P => P + * (e.g) chassis.C.mChassis => C.mChassis + * inline parameters should be returned as default value (e.g.) P => P or C.mChassis => C.mChassis + */ +oms::ComRef oms::ComponentFMU3CS::getValidCref(ComRef cref) +{ + oms::ComRef tail(cref); + oms::ComRef head = tail.pop_front(); + + if (tail.isEmpty() || head != getCref()) // check for inline parameter crefs, (e.g.) P => P or C.mChassis => C.mChassis + tail = cref; + return tail; +} + +oms_status_enu_t oms::ComponentFMU3CS::newResources(const std::string& ssvFilename, const std::string& ssmFilename, bool externalResources) +{ + Values resources; + if (externalResources) // check of external resources and override the start values with new references + { + Snapshot snapshot; + snapshot.importResourceFile(ssvFilename, getModel().getTempDirectory() + "/resources"); + + // import ssm file, if provided + if (!ssmFilename.empty()) + snapshot.importResourceFile(ssmFilename, getModel().getTempDirectory() + "/resources"); + + if (oms_status_ok != resources.importFromSnapshot(snapshot, ssvFilename, ssmFilename)) + return logError("referenceResources failed for \"" + std::string(getFullCref()) + ":" + ssvFilename + "\""); + } + + if (!values.hasResources()) + { + if(!ssmFilename.empty()) + resources.ssmFile = "resources/" + ssmFilename; + // copy modeldescriptionVariableUnits to ssv resources which will be used to export units + resources.modelDescriptionVariableUnits = values.modelDescriptionVariableUnits; + // copy modeldescriptionVariableUnitDefinitions to ssv resources which will be used to export unit definitions + resources.modeldescriptionUnitDefinitions = values.modeldescriptionUnitDefinitions; + resources.allresources["resources/" + ssvFilename] = resources; + values.parameterResources.push_back(resources); + } + else + { + // generate empty ssv file, if more resources are added to same level + if(!ssmFilename.empty()) + resources.ssmFile = "resources/" + ssmFilename; + // copy modeldescriptionVariableUnits to ssv resources which will be used to export units + resources.modelDescriptionVariableUnits = values.modelDescriptionVariableUnits; + // copy modeldescriptionVariableUnitDefinitions to ssv resources which will be used to export unit definitions + resources.modeldescriptionUnitDefinitions = values.modeldescriptionUnitDefinitions; + values.parameterResources[0].allresources["resources/" + ssvFilename] = resources; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::deleteReferencesInSSD(const std::string& filename) +{ + if (values.hasResources()) + return values.deleteReferencesInSSD(filename); + + return oms_status_error; +} + +oms_status_enu_t oms::ComponentFMU3CS::deleteResourcesInSSP(const std::string& filename) +{ + if (values.hasResources()) + return values.deleteResourcesInSSP(filename); + + return oms_status_error; +} + +oms_status_enu_t oms::ComponentFMU3CS::initialize() +{ + clock.reset(); + CallClock callClock(clock); + + // exitInitialization + fmi3Status status = fmi3_exitInitializationMode(fmu); + + if (fmi3OK != status) return logError_FMUCall("fmi3_exitInitializationMode", this); + + //logInfo("FMI3 initialization successfull"); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::terminate() +{ + freeState(); + fmi3Status fmistatus = fmi3_terminate(fmu); + if (fmi3OK != fmistatus) + return logError_Termination(getCref()); + + fmi3_freeInstance(fmu); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::reset() +{ + fmi3Status fmistatus = fmi3_reset(fmu); + if (fmi3OK != fmistatus) + return logError_ResetFailed(getCref()); + + // enterInitialization + time = getModel().getStartTime(); + double relativeTolerance = 0.0; + dynamic_cast(getParentSystem())->getTolerance(&relativeTolerance); + + fmi3Status status_ = fmi3_enterInitializationMode(fmu, fmi3False, relativeTolerance, time, fmi3True, getModel().getStopTime()); + if (fmi3OK != fmistatus) return logError_FMUCall("fmi3_enterInitializationMode", this); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::stepUntil(double stopTime) +{ + CallClock callClock(clock); + System *topLevelSystem = getModel().getTopLevelSystem(); + + double hdef = (stopTime-time) / 1.0; + bool eventEncountered, terminateSimulation, earlyReturn; + double lastT; + + while (time < stopTime) + { + fmi3Status status = fmi3_doStep(fmu, time, hdef, fmi3True, &eventEncountered, &terminateSimulation, &earlyReturn, &lastT); + time += hdef; + + if (status == fmi3Discard) + { + getModel().setStopTime(time); + logInfo("fmi3_doStep discarded for FMU \"" + std::string(getFullCref()) + "\""); + return oms_status_ok; + } + else if (status != fmi3OK) + return logError_FMUCall("fmi3_doStep", this); + } + time = stopTime; + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getBoolean(const fmi3ValueReference& vr, bool& value) +{ + CallClock callClock(clock); + + // bool value_; + if (fmi3OK != fmi3_getBoolean(fmu, &vr, 1, &value, 1)) + return oms_status_error; + + // value = value_ ? true : false; + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getBoolean(const ComRef& cref, bool& value) +{ + CallClock callClock(clock); + + if (oms_modelState_virgin == getModel().getModelState()) + { + // check for start values exist, priority over modeldescription.xml start values + if (values.hasResources()) // search in local resources + { + if (oms_status_ok == values.getBooleanResources(cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if (oms_status_ok == values.getBooleanFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) // search in root resources + { + if (oms_status_ok == getParentSystem()->getValues().getBooleanResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getBooleanFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) // search in top level root resources + { + if (oms_status_ok == getParentSystem()->getParentSystem()->getValues().getBooleanResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getBooleanFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else // search inline + { + // check for start values exist, priority over modeldescription.xml start values + if (oms_status_ok == values.getBoolean(cref, value)) + { + return oms_status_ok; + } + else + { + return values.getBooleanFromModeldescription(cref, value); + } + } + } + + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeBoolean()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + return getBoolean(vr, value); +} + +oms_status_enu_t oms::ComponentFMU3CS::getInteger(const fmi3ValueReference& vr, int& value) +{ + CallClock callClock(clock); + int64_t value_; + + if (fmi3OK != fmi3_getInt64(fmu, &vr, 1, &value_, 1)) + return oms_status_error; + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getInteger(const ComRef& cref, int& value) +{ + CallClock callClock(clock); + + if (oms_modelState_virgin == getModel().getModelState()) + { + // check for start values exist, priority over modeldescription.xml start values + if (values.hasResources()) // search in local resources + { + if (oms_status_ok == values.getIntegerResources(cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if (oms_status_ok == values.getIntegerFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) // search in root resources + { + if (oms_status_ok == getParentSystem()->getValues().getIntegerResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getIntegerFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) // search in top level root resources + { + if (oms_status_ok == getParentSystem()->getParentSystem()->getValues().getIntegerResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getIntegerFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else // search inline + { + // check for start values exist, priority over modeldescription.xml start values + if (oms_status_ok == values.getInteger(cref, value)) + { + return oms_status_ok; + } + else + { + return values.getIntegerFromModeldescription(cref, value); + } + } + } + + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeInteger()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + return getInteger(vr, value); +} + +oms::Variable* oms::ComponentFMU3CS::getVariable(const ComRef& cref) +{ + CallClock callClock(clock); + for (size_t i=0; i < allVariables.size(); i++) + if (allVariables[i].getCref() == cref) + return &allVariables[i]; + + logError_UnknownSignal(getFullCref() + cref); + return NULL; +} + +oms_status_enu_t oms::ComponentFMU3CS::getReal(const fmi3ValueReference& vr, double& value) +{ + CallClock callClock(clock); + + if (fmi3OK != fmi3_getFloat64(fmu, &vr, 1, &value, 1)) + return oms_status_error; + + if (std::isnan(value)) + return logError("getReal returned NAN"); + if (std::isinf(value)) + return logError("getReal returned +/-inf"); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getReal(const ComRef& cref, double& value) +{ + CallClock callClock(clock); + + if (oms_modelState_virgin == getModel().getModelState()) + { + // check for start values exist, priority over modeldescription.xml start values + if (values.hasResources()) // search in local resources + { + if (oms_status_ok == values.getRealResources(cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if (oms_status_ok == values.getRealFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) // search in root resources + { + if (oms_status_ok == getParentSystem()->getValues().getRealResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getRealFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) // search in top level root resources + { + if (oms_status_ok == getParentSystem()->getParentSystem()->getValues().getRealResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getRealFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else // search inline + { + // check for start values exist, priority over modeldescription.xml start values + if (oms_status_ok == values.getReal(cref, value)) + { + return oms_status_ok; + } + else + { + return values.getRealFromModeldescription(cref, value); + } + } + } + + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeReal()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + return getReal(vr, value); +} + +oms_status_enu_t oms::ComponentFMU3CS::getString(const fmi3ValueReference& vr, std::string& value) +{ + CallClock callClock(clock); + fmi3String str; + + if (fmi3OK != fmi3_getString(fmu, &vr, 1, &str, 1)) + return oms_status_error; + + value = std::string(str); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getString(const ComRef& cref, std::string& value) +{ + CallClock callClock(clock); + + if (oms_modelState_virgin == getModel().getModelState()) + { + // check for start values exist, priority over modeldescription.xml start values + if (values.hasResources()) // search in local resources + { + if (oms_status_ok == values.getStringResources(cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if (oms_status_ok == values.getStringFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) // search in root resources + { + if (oms_status_ok == getParentSystem()->getValues().getStringResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getStringFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) // search in top level root resources + { + if (oms_status_ok == getParentSystem()->getParentSystem()->getValues().getStringResources(getCref()+cref, value, false, oms_modelState_virgin)) + { + return oms_status_ok; + } + // search in modelDescription.xml + else if(oms_status_ok == values.getStringFromModeldescription(cref, value)) + { + return oms_status_ok; + } + + return logError("no start value set or available for signal: " + std::string(getFullCref() + cref)); + } + else // search inline + { + // check for start values exist, priority over modeldescription.xml start values + if (oms_status_ok == values.getString(cref, value)) + { + return oms_status_ok; + } + else + { + return values.getStringFromModeldescription(cref, value); + } + } + } + + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeString()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + return getString(vr, value); +} + +oms_status_enu_t oms::ComponentFMU3CS::getDirectionalDerivative(const ComRef& unknownCref, const ComRef& knownCref, double& value) +{ + if (!getModel().validState(oms_modelState_instantiated|oms_modelState_initialization|oms_modelState_simulation)) + return logError_ModelInWrongState(getModel().getCref()); + + if (!getFMUInfo()->getProvidesDirectionalDerivative()) + return logError("FMU \"" + std::string(getFullCref()) + "\" doesn't support directional derivatives (providesDirectionalDerivative = false in modelDescription.xml)"); + + int j = -1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == unknownCref && allVariables[i].isTypeReal()) + { + j = i; + break; + } + } + + // check for knownIndex, if provided + int knownIndex = -1; + if (!knownCref.isEmpty()) + { + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == knownCref && allVariables[i].isTypeReal()) + { + knownIndex = i; + break; + } + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + unknownCref); + + if (oms_modelState_instantiated == getModel().getModelState() || oms_modelState_initialization == getModel().getModelState()) + { + // check index exist in ModelStructure inititalUnknowns + auto index = values.modelStructureInitialUnknowns.find(j+1); + if (index == values.modelStructureInitialUnknowns.end()) + return logError("Signal \"" + std::string(getFullCref() + unknownCref) + "\" could not be resolved to an index in "); + + //get dependencylist from in + std::vector dependencyList = values.modelStructureInitialUnknowns[j+1]; + getDirectionalDerivativeHeper(j, knownIndex, dependencyList, value); + } + + if (oms_modelState_simulation == getModel().getModelState()) + { + if (!allVariables[j].isOutput() && !allVariables[j].isState() && !allVariables[j].isDer()) + return logError("Signal \"" + std::string(getFullCref() + unknownCref) + "\" could not be resolved to an output or state or derivates after initalization"); + + // + if (allVariables[j].isOutput()) + { + // check index exist in ModelStructure inititalUnknowns + auto index = values.modelStructureOutputs.find(j + 1); + if (index == values.modelStructureOutputs.end()) + return logError("Signal \"" + std::string(getFullCref() + unknownCref) + "\" could not be resolved to an index in "); + + // get dependencylist from in + std::vector dependencyList = values.modelStructureOutputs[j + 1]; + getDirectionalDerivativeHeper(j, knownIndex, dependencyList, value); + } + // + if (allVariables[j].isState() || allVariables[j].isDer()) + { + // check index exist in ModelStructure inititalUnknowns + auto index = values.modelStructureDerivatives.find(j + 1); + if (index == values.modelStructureDerivatives.end()) + return logError("Signal \"" + std::string(getFullCref() + unknownCref) + "\" could not be resolved to an index in "); + + // get dependencylist from in + std::vector dependencyList = values.modelStructureDerivatives[j + 1]; + getDirectionalDerivativeHeper(j, knownIndex, dependencyList, value); + } + } + + // fmi3ValueReference vr_unknown[1] = {5}; + // fmi3ValueReference vr_known[4] = {0, 2, 3, 4}; + // fmi2Real dvknown[4] = {1.0, 1.0, 1.0, 1.0}; + // fmi2Real val; + // std::cout << "Get directional derivative_static_1: " << val << std::endl; + // fmi2_import_get_directional_derivative(fmu, vr_unknown, 1, vr_known, 4, dvknown, &val); + // std::cout << "\nGet directional derivative_static_2: " << val << std::endl; + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getDirectionalDerivativeHeper(const int unknownIndex, const int knownIndex, const std::vector &dependencyList, double &value) +{ + fmi3ValueReference vr_unknown = allVariables[unknownIndex].getValueReferenceFMI3(); + fmi3ValueReference *vr_known = (fmi3ValueReference *)calloc(dependencyList.size(), sizeof(fmi3ValueReference *)); + fmi3Float64 *dvknown = (fmi3Float64 *)calloc(dependencyList.size(), sizeof(fmi3Float64 *)); + + for (int i = 0; i < dependencyList.size(); i++) + { + vr_known[i] = allVariables[dependencyList[i] - 1].getValueReferenceFMI3(); + + // The knownIndex is < 0 if not specified. In this case, we + // calculate the sum of the row, which means we set all seed + // values to 1.0. Otherwise we just set the explicitly provided + // element to 1.0. + if (knownIndex < 0 || (dependencyList[i] == knownIndex + 1)) + dvknown[i] = 1.0; + else + dvknown[i] = 0.0; + } + + fmi3_getDirectionalDerivative(fmu, &vr_unknown, 1, vr_known, dependencyList.size(), dvknown, 1, &value, 1); + + free(vr_known); + free(dvknown); + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::getRealOutputDerivative(const ComRef& cref, SignalDerivative& der) +{ + CallClock callClock(clock); + + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeReal() && allVariables[i].isOutput()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + der = SignalDerivative(getFMUInfo()->getMaxOutputDerivativeOrder(), fmu, allVariables[j].getValueReferenceFMI3()); + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setRealInputDerivative(const ComRef& cref, const SignalDerivative& der) +{ + CallClock callClock(clock); + + if (!getFMUInfo()->getCanInterpolateInputs()) + return oms_status_ok; + + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref) + { + if (allVariables[i].isTypeReal() && allVariables[i].isInput()) + { + j = i; + break; + } + else + return logError_OnlyForRealInputs(getFullCref() + cref); + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + return der.setRealInputDerivatives(fmu, vr); +} + +oms_status_enu_t oms::ComponentFMU3CS::setBoolean(const ComRef& cref, bool value) +{ + CallClock callClock(clock); + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeBoolean()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + if (oms_modelState_virgin == getModel().getModelState()) + { + values.updateModelDescriptionBooleanStartValue(cref, value); + // check for local resources available + if (values.hasResources()) + { + return values.setBooleanResources(cref, value, getFullCref(), false, oms_modelState_virgin); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().setBooleanResources(getCref()+cref, value, getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().setBooleanResources(getCref()+cref, value, getParentSystem()->getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + else + { + //inline parameter settings + values.setBoolean(cref, value); + } + } + else + { + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + // int value_ = value ? 1 : 0; + if (fmi3OK != fmi3_setBoolean(fmu, &vr, 1, &value, 1)) + return oms_status_error; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setInteger(const ComRef& cref, int value) +{ + CallClock callClock(clock); + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeInteger()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + if (oms_modelState_virgin == getModel().getModelState()) + { + // update start values in top level Modeldescription.xml to be exported in ssv templates + values.updateModelDescriptionIntegerStartValue(cref, value); + // check for local resources available + if (values.hasResources()) + { + return values.setIntegerResources(cref, value, getFullCref(), false, oms_modelState_virgin); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().setIntegerResources(getCref()+cref, value, getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().setIntegerResources(getCref()+cref, value, getParentSystem()->getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + else + { + //inline parameter settings + values.setInteger(cref, value); + } + } + else + { + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + int64_t value_; + if (fmi3OK != fmi3_setInt64(fmu, &vr, 1, &value_, 1)) + return oms_status_error; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setReal(const ComRef& cref, double value) +{ + CallClock callClock(clock); + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeReal()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + if (getModel().validState(oms_modelState_virgin|oms_modelState_enterInstantiation|oms_modelState_instantiated)) + if (allVariables[j].isCalculated() || allVariables[j].isIndependent()) + return logWarning("It is not allowed to provide a start value if initial=\"calculated\" or causality=\"independent\"."); + + if (oms_modelState_virgin == getModel().getModelState()) + { + // update start values in top level Modeldescription.xml to be exported in ssv templates + values.updateModelDescriptionRealStartValue(cref, value); + // check for local resources available + if (values.hasResources()) + { + values.copyModelDescriptionUnitToResources(values); + return values.setRealResources(cref, value, getFullCref(), false, oms_modelState_virgin); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + getParentSystem()->getValues().copyModelDescriptionUnitToResources(values); + return getParentSystem()->getValues().setRealResources(getCref()+cref, value, getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + getParentSystem()->getParentSystem()->getValues().copyModelDescriptionUnitToResources(values); + return getParentSystem()->getParentSystem()->getValues().setRealResources(getCref()+cref, value, getParentSystem()->getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + else + { + //inline parameter settings + values.setReal(cref, value); + } + } + else + { + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + if (fmi3OK != fmi3_setFloat64(fmu, &vr, 1, &value, 1)) + return oms_status_error; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setString(const ComRef& cref, const std::string& value) +{ + CallClock callClock(clock); + int j=-1; + for (size_t i = 0; i < allVariables.size(); i++) + { + if (allVariables[i].getCref() == cref && allVariables[i].isTypeString()) + { + j = i; + break; + } + } + + if (!fmu || j < 0) + return logError_UnknownSignal(getFullCref() + cref); + + if (getModel().validState(oms_modelState_virgin|oms_modelState_enterInstantiation|oms_modelState_instantiated)) + if (allVariables[j].isCalculated() || allVariables[j].isIndependent()) + return logWarning("It is not allowed to provide a start value if initial=\"calculated\" or causality=\"independent\"."); + + if (oms_modelState_virgin == getModel().getModelState()) + { + values.updateModelDescriptionStringStartValue(cref, value); + // check for local resources available + if (values.hasResources()) + { + return values.setStringResources(cref, value, getFullCref(), false, oms_modelState_virgin); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().setStringResources(getCref()+cref, value, getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().setStringResources(getCref()+cref, value, getParentSystem()->getParentSystem()->getFullCref(), false, oms_modelState_virgin); + } + else + { + //inline parameter settings + values.setString(cref, value); + } + } + else + { + fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); + fmi3String value_ = value.c_str(); + if (fmi3OK != fmi3_setString(fmu, &vr, 1, &value_, 1)) + return oms_status_error; + } + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::setUnit(const ComRef &cref, const std::string &value) +{ + // set units to connectors + for (auto &connector : connectors) + { + if (connector) + { + if (connector->getName() == cref) + { + connector->connectorUnits.clear(); + connector->connectorUnits[value] = {}; + } + } + } + + // set unit in top level modeldescription.xml + values.updateModelDescriptionVariableUnit(cref, value); + + // check for local resources available + if (values.hasResources()) + { + return values.setUnitResources(cref, value, getFullCref()); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().setUnitResources(getCref() + cref, value, getParentSystem()->getFullCref()); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().setUnitResources(getCref() + cref, value, getParentSystem()->getParentSystem()->getFullCref()); + } + else + { + // inline unit settings + values.setUnit(cref, value); + } + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::deleteStartValue(const ComRef& cref) +{ + // check for local resources + if (values.hasResources()) + { + return values.deleteStartValueInResources(cref); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().deleteStartValueInResources(getCref()+cref); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().deleteStartValueInResources(getCref()+cref); + } + else + { + return values.deleteStartValue(cref); + } + + return oms_status_error; +} + +oms_status_enu_t oms::ComponentFMU3CS::setValuesResources(Values& values) +{ + // set all ssv and ssm resources from the old component to replacing component + this->values.parameterResources = values.parameterResources; + // set all user define values from the old component to replacing component as user defined values have higher priority + // over modeldescription.xml + this->values.realStartValues = values.realStartValues; + this->values.integerStartValues = values.integerValues; + this->values.booleanStartValues = values.booleanStartValues; + + return oms_status_ok; +} + +oms_status_enu_t oms::ComponentFMU3CS::updateOrDeleteStartValueInReplacedComponent(std::vector& warningList) +{ + // check for local resources available + if (values.hasResources()) + { + return values.updateOrDeleteStartValueInReplacedComponent(values, this->getCref(), warningList); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().updateOrDeleteStartValueInReplacedComponent(values, this->getCref(), warningList); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().updateOrDeleteStartValueInReplacedComponent(values, this->getCref(), warningList); + } + else + { + // inline parameter settings, no need to update the values + return oms_status_ok; + } + + return oms_status_error; +} + +oms_status_enu_t oms::ComponentFMU3CS::registerSignalsForResultFile(ResultWriter& resultFile) +{ + resultFileMapping.clear(); + + if (Flags::WallTime()) + clock_id = resultFile.addSignal(std::string(getFullCref() + ComRef("$wallTime")), "wall-clock time [s]", SignalType_REAL); + else + clock_id = 0; + + for (unsigned int i=0; i& filteredSignals) const +{ + for (unsigned int i = 0; i < allVariables.size(); ++i) + { + if (exportVariables[i]) + filteredSignals.push_back(allVariables[i].makeConnector(this->getFullCref())); + } +} + +oms_status_enu_t oms::ComponentFMU3CS::renameValues(const ComRef& oldCref, const ComRef& newCref) +{ + // check for local resources + if (values.hasResources()) + { + return values.renameInResources(oldCref, newCref); + } + // check for resources in root + else if (getParentSystem() && getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getValues().renameInResources(oldCref, newCref); + } + // check for resources in top level root + else if (getParentSystem()->getParentSystem() && getParentSystem()->getParentSystem()->getValues().hasResources()) + { + return getParentSystem()->getParentSystem()->getValues().renameInResources(oldCref, newCref); + } + else + { + return values.rename(oldCref, newCref); + } + + return oms_status_error; +} diff --git a/src/OMSimulatorLib/ComponentFMU3CS.h b/src/OMSimulatorLib/ComponentFMU3CS.h new file mode 100644 index 000000000..249d8c0e0 --- /dev/null +++ b/src/OMSimulatorLib/ComponentFMU3CS.h @@ -0,0 +1,167 @@ +/* + * This file is part of OpenModelica. + * + * Copyright (c) 1998-CurrentYear, 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 GPL VERSION 3 LICENSE OR + * THIS OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.2. + * ANY USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES + * RECIPIENT'S ACCEPTANCE OF THE OSMC PUBLIC LICENSE OR THE GPL VERSION 3, + * ACCORDING TO RECIPIENTS CHOICE. + * + * The OpenModelica software and the Open Source Modelica + * Consortium (OSMC) Public License (OSMC-PL) are obtained + * from OSMC, either from the above address, + * from the URLs: http://www.ida.liu.se/projects/OpenModelica or + * http://www.openmodelica.org, and in the OpenModelica distribution. + * GNU version 3 is obtained from: http://www.gnu.org/copyleft/gpl.html. + * + * 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_COMPONENT_FMU_3_CS_H_ +#define _OMS_COMPONENT_FMU_3_CS_H_ + +#include "Component.h" +#include "ComRef.h" +#include "ResultWriter.h" +#include "Snapshot.h" +#include "Values.h" +#include "Variable.h" + +#include +#include +#include +#include +#include +#include +#include + +namespace oms +{ + class System; + + class ComponentFMU3CS : public Component + { + public: + ~ComponentFMU3CS(); + + static Component* NewComponent(const ComRef& cref, System* parentSystem, const std::string& fmuPath, std::string replaceComponent = ""); + static Component* NewComponent(const pugi::xml_node& node, System* parentSystem, const std::string& sspVersion, const Snapshot& snapshot, std::string variantName); + const FMUInfo* getFMUInfo() const {return &(this->fmuInfo);} + + oms_status_enu_t exportToSSD(pugi::xml_node& node, Snapshot& snapshot, std::string variantName) const; + oms_status_enu_t exportToSSV(pugi::xml_node& ssvNode); + void getFilteredUnitDefinitionsToSSD(std::map>& unitDefinitions); + void getFilteredEnumerationDefinitionsToSSD(std::map>& enumerationDefinitions); + oms_status_enu_t exportToSSVTemplate(pugi::xml_node& ssvNode, Snapshot& snapshot); + oms_status_enu_t exportToSSMTemplate(pugi::xml_node& ssmNode); + oms_status_enu_t instantiate(); + oms_status_enu_t initialize(); + oms_status_enu_t terminate(); + oms_status_enu_t reset(); + + oms_status_enu_t stepUntil(double stopTime); + + oms_status_enu_t initializeDependencyGraph_initialUnknowns(); + oms_status_enu_t initializeDependencyGraph_outputs(); + + Variable* getVariable(const ComRef& cref); + + Values& getValues() { return values; } + oms_status_enu_t setValuesResources(Values& values); + + oms_status_enu_t getBoolean(const ComRef& cref, bool& value); + oms_status_enu_t getBoolean(const fmi3ValueReference& vr, bool& value); + oms_status_enu_t getInteger(const ComRef& cref, int& value); + oms_status_enu_t getInteger(const fmi3ValueReference& vr, int& value); + oms_status_enu_t getReal(const ComRef& cref, double& value); + oms_status_enu_t getReal(const fmi3ValueReference& vr, double& value); + oms_status_enu_t getString(const ComRef& cref, std::string& value); + oms_status_enu_t getString(const fmi3ValueReference& vr, std::string& value); + oms_status_enu_t setBoolean(const ComRef& cref, bool value); + oms_status_enu_t setInteger(const ComRef& cref, int value); + oms_status_enu_t setReal(const ComRef& cref, double value); + oms_status_enu_t setString(const ComRef& cref, const std::string& value); + oms_status_enu_t setUnit(const ComRef& cref, const std::string& value); + + oms_status_enu_t getDirectionalDerivative(const ComRef& unknownCref, const ComRef& knownCref, double& value); + oms_status_enu_t getDirectionalDerivativeHeper(const int unknownIndex, const int knownindex, const std::vector& dependencyList, double& value); + + oms_status_enu_t deleteStartValue(const ComRef& cref); + oms_status_enu_t updateOrDeleteStartValueInReplacedComponent(std::vector& warningList); + + oms_status_enu_t setFmuTime(double time) {this->time = time; return oms_status_ok;} + fmiHandle* getFMU() {return fmu;} + std::vector getAllVariables() {return allVariables;} + + oms_status_enu_t getRealOutputDerivative(const ComRef& cref, SignalDerivative& der); + oms_status_enu_t setRealInputDerivative(const ComRef& cref, const SignalDerivative& der); + + oms_status_enu_t registerSignalsForResultFile(ResultWriter& resultFile); + oms_status_enu_t updateSignals(ResultWriter& resultWriter); + oms_status_enu_t addSignalsToResults(const char* regex); + oms_status_enu_t removeSignalsFromResults(const char* regex); + + bool getCanGetAndSetState() {return getFMUInfo()->getCanGetAndSetFMUstate();} + oms_status_enu_t saveState(); + oms_status_enu_t freeState(); + oms_status_enu_t restoreState(); + + void getFilteredSignals(std::vector& filteredSignals) const; + + oms_status_enu_t newResources(const std::string& ssvFilename, const std::string& ssmFilename, bool externalResources); + oms_status_enu_t setResourcesHelper1(Values value); + oms_status_enu_t setResourcesHelper2(Values value); + + oms_status_enu_t deleteReferencesInSSD(const std::string& filename); + oms_status_enu_t deleteResourcesInSSP(const std::string& filename); + void copyModelDescriptionUnit(Values& value); + + protected: + ComponentFMU3CS(const ComRef& cref, System* parentSystem, const std::string& fmuPath); + + // stop the compiler generating methods copying the object + ComponentFMU3CS(ComponentFMU3CS const& copy); ///< not implemented + ComponentFMU3CS& operator=(ComponentFMU3CS const& copy); ///< not implemented + + oms_status_enu_t renameValues(const ComRef& oldCref, const ComRef& newCref); + + void dumpInitialUnknowns(); + + private: + fmi3LogMessageCallback omsfmi3logger; + fmiHandle *fmu = NULL; + FMUInfo fmuInfo; + + std::vector allVariables; + std::vector calculatedParameters; + std::vector derivatives; + std::vector inputs; + std::vector outputs; + std::vector parameters; + std::vector exportVariables; + + Values values; ///< start values defined before instantiating the FMU and external inputs defined after initialization + + std::unordered_map resultFileMapping; + + double time; + fmi3FMUState fmuState = NULL; + double fmuStateTime; + + oms::ComRef getValidCref(ComRef cref); + }; +} + +#endif diff --git a/src/OMSimulatorLib/ComponentFMUCS.cpp b/src/OMSimulatorLib/ComponentFMUCS.cpp index b55df32f6..45705fe75 100644 --- a/src/OMSimulatorLib/ComponentFMUCS.cpp +++ b/src/OMSimulatorLib/ComponentFMUCS.cpp @@ -162,7 +162,7 @@ oms::Component* oms::ComponentFMUCS::NewComponent(const oms::ComRef& cref, oms:: } // update FMU info - component->fmuInfo.update(version, component->fmu); + component->fmuInfo.update(oms_component_fmu, component->fmu); component->omsfmi2logger = oms::fmi2logger; // create a list of all variables using fmi4c variable structure @@ -170,7 +170,7 @@ oms::Component* oms::ComponentFMUCS::NewComponent(const oms::ComRef& cref, oms:: component->exportVariables.reserve(fmi2_getNumberOfVariables(component->fmu)); for (unsigned int i = 0; i < fmi2_getNumberOfVariables(component->fmu); ++i) { - oms::Variable v(component->fmu, i); + oms::Variable v(component->fmu, i, oms_component_fmu); if (v.getIndex() != i) { logError("Index mismatch " + std::to_string(v.getIndex()) + " != " + std::to_string(i) + ".\nPlease report the problem to the dev team: https://github.com/OpenModelica/OMSimulator/issues/new?assignees=&labels=&template=bug_report.md"); diff --git a/src/OMSimulatorLib/ComponentFMUME.cpp b/src/OMSimulatorLib/ComponentFMUME.cpp index 71eddce6d..7e9f8e906 100644 --- a/src/OMSimulatorLib/ComponentFMUME.cpp +++ b/src/OMSimulatorLib/ComponentFMUME.cpp @@ -158,7 +158,7 @@ oms::Component* oms::ComponentFMUME::NewComponent(const oms::ComRef& cref, oms:: } // update FMU info - component->fmuInfo.update(version, component->fmu); + component->fmuInfo.update(oms_component_fmu, component->fmu); component->omsfmi2logger = oms::fmi2logger; component->nEventIndicators = fmi2_getNumberOfEventIndicators(component->fmu); @@ -168,7 +168,7 @@ oms::Component* oms::ComponentFMUME::NewComponent(const oms::ComRef& cref, oms:: component->exportVariables.reserve(fmi2_getNumberOfVariables(component->fmu)); for (unsigned int i = 0; i < fmi2_getNumberOfVariables(component->fmu); ++i) { - oms::Variable v(component->fmu, i); + oms::Variable v(component->fmu, i, oms_component_fmu); if (v.getIndex() != i) { logError("Index mismatch " + std::to_string(v.getIndex()) + " != " + std::to_string(i) + ".\nPlease report the problem to the dev team: https://github.com/OpenModelica/OMSimulator/issues/new?assignees=&labels=&template=bug_report.md"); diff --git a/src/OMSimulatorLib/FMUInfo.cpp b/src/OMSimulatorLib/FMUInfo.cpp index d6f7b1820..c1ffdcbba 100644 --- a/src/OMSimulatorLib/FMUInfo.cpp +++ b/src/OMSimulatorLib/FMUInfo.cpp @@ -75,7 +75,24 @@ oms::FMUInfo::~FMUInfo() if (this->version) delete[] this->version; } -void oms::FMUInfo::update(fmiVersion_t version, fmiHandle* fmu) +void oms::FMUInfo::update(oms_component_enu_t componentType, fmiHandle* fmu) +{ + // Check the component type + switch (componentType) + { + case oms_component_fmu: // FMI 2.0 + updateFMI2Info(fmu); + break; + case oms_component_fmu3: // FMI 3.0 + updateFMI3Info(fmu); + break; + default: // Unsupported type + logError("Unsupported component type for Variable constructor"); + } + +} + +void oms::FMUInfo::updateFMI2Info(fmiHandle* fmu) { if (fmi2_getSupportsCoSimulation(fmu)) this->fmiKind = oms_fmi_kind_cs; @@ -120,3 +137,59 @@ void oms::FMUInfo::update(fmiVersion_t version, fmiHandle* fmu) this->providesDirectionalDerivative = fmi2me_getProvidesDirectionalDerivative(fmu) > 0; } } + +void oms::FMUInfo::updateFMI3Info(fmiHandle* fmu) +{ + if (fmi3_supportsCoSimulation(fmu)) + this->fmiKind = oms_fmi_kind_cs; + else if (fmi3_supportsModelExchange(fmu)) + this->fmiKind = oms_fmi_kind_me; + else if (fmi3_supportsModelExchange(fmu) && fmi3_supportsCoSimulation(fmu)) + this->fmiKind = oms_fmi_kind_me_and_cs; + + this->author = allocateAndCopyString(fmi3_author(fmu)); + this->copyright = allocateAndCopyString(fmi3_copyright(fmu)); + this->description = allocateAndCopyString(fmi3_description(fmu)); + this->fmiVersion = allocateAndCopyString(fmi3_getFmiVersion(fmu)); + this->generationDateAndTime = allocateAndCopyString(fmi3_generationDateAndTime(fmu)); + this->generationTool = allocateAndCopyString(fmi3_generationTool(fmu)); + this->guid = allocateAndCopyString(fmi3_instantiationToken(fmu)); + + this->license = allocateAndCopyString(fmi3_license(fmu)); + this->modelName = allocateAndCopyString(fmi3_modelName(fmu)); + + if (oms_fmi_kind_cs == fmiKind || oms_fmi_kind_me_and_cs == fmiKind) + { + + this->canBeInstantiatedOnlyOncePerProcess = fmi3cs_getCanBeInstantiatedOnlyOncePerProcess(fmu) > 0; + this->canGetAndSetFMUstate = fmi3cs_getCanGetAndSetFMUState(fmu) > 0; + this->canSerializeFMUstate = fmi3cs_getCanSerializeFMUState(fmu) > 0; + this->completedIntegratorStepNotNeeded = false; + this->needsExecutionTool = fmi3cs_getNeedsExecutionTool(fmu) > 0; + this->providesDirectionalDerivative = fmi3cs_getProvidesDirectionalDerivative(fmu) > 0; + this->maxOutputDerivativeOrder = fmi3cs_getMaxOutputDerivativeOrder(fmu); + // TODO handle the following FMI3 CS attributes + // providesIntermediateUpdate + // mightReturnEarlyFromDoStep + // providesEvaluateDiscreteStates + // recommendedIntermediateInputSmoothness + // canHandleVariableCommunicationStepSize + // canReturnEarlyAfterIntermediateUpdate + // fixedInternalStepSize + // hasEventMode + } + + if (oms_fmi_kind_me == fmiKind || oms_fmi_kind_me_and_cs == fmiKind) + { + this->canBeInstantiatedOnlyOncePerProcess = fmi3me_getCanBeInstantiatedOnlyOncePerProcess(fmu) > 0; + this->canGetAndSetFMUstate = fmi3me_getCanGetAndSetFMUState(fmu) > 0; + this->canSerializeFMUstate = fmi3me_getCanSerializeFMUState(fmu) > 0; + this->completedIntegratorStepNotNeeded = fmi3me_getNeedsCompletedIntegratorStep(fmu) > 0; + this->needsExecutionTool = fmi3me_getNeedsExecutionTool(fmu) > 0; + this->providesDirectionalDerivative = fmi3me_getProvidesDirectionalDerivative(fmu) > 0; + // TODO handle the following FMI3 ME attributes + //providesAdjointDerivatives + //providesPerElementDependencies + //providesEvaluateDiscreteStates + } +} \ No newline at end of file diff --git a/src/OMSimulatorLib/FMUInfo.h b/src/OMSimulatorLib/FMUInfo.h index f924edb23..d13ee756f 100644 --- a/src/OMSimulatorLib/FMUInfo.h +++ b/src/OMSimulatorLib/FMUInfo.h @@ -47,7 +47,7 @@ namespace oms FMUInfo(const std::string& path); ~FMUInfo(); - void update(fmiVersion_t version, fmiHandle* fmi4c); + void update(oms_component_enu_t componentType, fmiHandle* fmi4c); std::string getPath() const {return std::string(path);} oms_fmi_kind_enu_t getKind() const {return fmiKind;} @@ -59,6 +59,9 @@ namespace oms std::string getGenerationTool() const {return std::string(generationTool);} private: + void updateFMI2Info(fmiHandle *fmi4c); + void updateFMI3Info(fmiHandle *fmi4c); + // methods to copy the object FMUInfo(const FMUInfo& rhs); ///< not implemented FMUInfo& operator=(const FMUInfo& rhs); ///< not implemented diff --git a/src/OMSimulatorLib/System.cpp b/src/OMSimulatorLib/System.cpp index c059b4ae9..b4c986038 100644 --- a/src/OMSimulatorLib/System.cpp +++ b/src/OMSimulatorLib/System.cpp @@ -33,6 +33,7 @@ #include "Component.h" #include "ComponentFMUCS.h" +#include "ComponentFMU3CS.h" #include "ComponentFMUME.h" #include "ComponentTable.h" #include "Flags.h" @@ -43,6 +44,7 @@ #include "SystemSC.h" #include "SystemWC.h" #include "Variable.h" +#include "miniunz.h" #include @@ -267,8 +269,13 @@ oms_status_enu_t oms::System::addSubModel(const oms::ComRef& cref, const std::st if (path.length() > 4) extension = path.substr(path.length() - 4); - if (extension == ".fmu" && oms_system_wc == type) + // unpack the modelDescription.xml in memory to detect the fmiVersion + std::string fmiVersion = getFmiVersion(path); + + if (extension == ".fmu" && oms_system_wc == type && fmiVersion == "2.0") component = ComponentFMUCS::NewComponent(cref, this, path_.string()); + else if (extension == ".fmu" && oms_system_wc == type && fmiVersion == "3.0") + component = ComponentFMU3CS::NewComponent(cref, this, path_.string()); else if (extension == ".fmu" && oms_system_sc == type) component = ComponentFMUME::NewComponent(cref, this, path_.string()); else if (extension == ".csv" || extension == ".mat") @@ -296,6 +303,20 @@ oms_status_enu_t oms::System::addSubModel(const oms::ComRef& cref, const std::st return system->addSubModel(tail, path); } +std::string oms::System::getFmiVersion(const std::string& path) +{ + // unpack the modelDescription.xml in memory to detect the fmiVersion + const char* modelDescription = ::miniunz_onefile_to_memory(path.c_str(), "modelDescription.xml"); + if (!modelDescription) + logError("failed to extract \"modelDescription.xml\" from \"" + path + "\""); + oms::Snapshot snapshot; + oms_status_enu_t status = snapshot.importResourceMemory("modelDescription.xml", modelDescription); + const pugi::xml_node node = snapshot.getResourceNode("modelDescription.xml"); + std::string fmiVersion = node.attribute("fmiVersion").as_string(); + ::miniunz_free(modelDescription); + return fmiVersion; +} + oms_status_enu_t oms::System::replaceSubModel(const oms::ComRef& cref, const std::string& path, bool dryRun, int& warningCount) { /* diff --git a/src/OMSimulatorLib/System.h b/src/OMSimulatorLib/System.h index fc5dccc97..7e39bb5fe 100644 --- a/src/OMSimulatorLib/System.h +++ b/src/OMSimulatorLib/System.h @@ -237,6 +237,7 @@ namespace oms bool loopsNeedUpdate = true; std::vector algLoops; ///< vector of algebraic loop objects + std::string getFmiVersion(const std::string& path); }; } diff --git a/src/OMSimulatorLib/SystemWC.cpp b/src/OMSimulatorLib/SystemWC.cpp index 651603160..5eb323809 100644 --- a/src/OMSimulatorLib/SystemWC.cpp +++ b/src/OMSimulatorLib/SystemWC.cpp @@ -33,6 +33,7 @@ #include "Component.h" #include "ComponentFMUCS.h" +#include "ComponentFMU3CS.h" #include "Flags.h" #include "Model.h" #include "ssd/Tags.h" @@ -396,6 +397,10 @@ oms_status_enu_t oms::SystemWC::doStep() { dynamic_cast(component.second)->setFmuTime(time); } + if (oms_component_fmu3 == component.second->getType()) + { + dynamic_cast(component.second)->setFmuTime(time); + } } } } diff --git a/src/OMSimulatorLib/Values.cpp b/src/OMSimulatorLib/Values.cpp index 7288af21e..924fdcd19 100644 --- a/src/OMSimulatorLib/Values.cpp +++ b/src/OMSimulatorLib/Values.cpp @@ -1706,6 +1706,156 @@ oms_status_enu_t oms::Values::parseModelDescription(const filesystem::path& root return oms_status_ok; } +oms_status_enu_t oms::Values::parseModelDescriptionFmi3(const filesystem::path& root, std::string& guid_) +{ + + const char* modelDescription = ::miniunz_onefile_to_memory(root.generic_string().c_str(), "modelDescription.xml"); + + // TODO validate modeldescription.xml against schema fmi3ModelDescription.xsd + // XercesValidator xercesValidator; + // xercesValidator.validateFMU(modelDescription, root.generic_string()); + + Snapshot snapshot; + oms_status_enu_t status = snapshot.importResourceMemory("modelDescription.xml", modelDescription); + ::miniunz_free(modelDescription); + + if (oms_status_ok != status) + return logError("Failed to import modelDescription.xml from memory for fmu " + root.generic_string()); + + const pugi::xml_node node = snapshot.getResourceNode("modelDescription.xml"); + + if (!node) + return logError("Failed to find root node in modelDescription.xml"); + + guid_ = node.attribute("instantiationToken").as_string(); + std::string fmiVersion = node.attribute("fmiVersion").as_string(); + + for(pugi::xml_node_iterator it = node.begin(); it != node.end(); ++it) + { + std::string name = it->name(); + if (name == "TypeDefinitions") + { + pugi::xml_node Enumeration = it->child("EnumerationType"); + if (Enumeration) + { + std::map enumerationItems; + for (pugi::xml_node enumItem = Enumeration.child("Item"); enumItem; enumItem = enumItem.next_sibling("Item")) + { + enumerationItems[enumItem.attribute("name").as_string()] = enumItem.attribute("value").as_string(); + } + modeldescriptionTypeDefinitions[Enumeration.attribute("name").as_string()] = enumerationItems; + } + } + if (name == "UnitDefinitions") + { + pugi::xml_node units = node.child("UnitDefinitions"); + if (units) + { + + for (pugi::xml_node unit = units.child("Unit"); unit; unit = unit.next_sibling("Unit")) + { + std::string unitName = unit.attribute("name").as_string(); + pugi::xml_node baseUnitNode = unit.child("BaseUnit"); + std::map baseUnits; + for (pugi::xml_attribute attr = baseUnitNode.first_attribute(); attr; attr = attr.next_attribute()) + { + baseUnits[attr.name()] = attr.value(); + } + modeldescriptionUnitDefinitions[unitName] = baseUnits; + //unitToExport_1 unit_to_export = {"", unitName, baseUnits, false}; + //exportunitdefinitionToSSp_1.push_back(unit_to_export); + } + } + } + if(name == "ModelVariables") + { + pugi::xml_node modelVariableNode = node.child("ModelVariables"); + if (!modelVariableNode) + { + return logError("Error parsing modelDescription.xml"); + } + for(pugi::xml_node_iterator it_ = modelVariableNode.begin(); it_ != modelVariableNode.end(); ++it_) + { + if (std::string(it_->name()) == "Float64") + { + // start values + if (strlen(it_->attribute("start").as_string()) != 0) + modelDescriptionRealStartValues[ComRef(it_->attribute("name").as_string())] = it_->attribute("start").as_double(); + // check for units + if (strlen(it_->attribute("unit").as_string()) != 0) + modelDescriptionVariableUnits[ComRef(it_->attribute("name").as_string())] = it_->attribute("unit").as_string(); + } + // TODO check start values for other dataTypes + } + } + if (name == "ModelStructure") + { + for(pugi::xml_node_iterator it_ = it->begin(); it_ != it->end(); ++it_) + { + //Output + if (std::string(it_->name()) == "Output") + { + int index = it_->attribute("valueReference").as_int(); + pugi::xml_attribute dependencynode = it_->attribute("dependencies"); + if (dependencynode) + { + std::string dependencies = it_->attribute("dependencies").as_string(); + std::vector dependenciesList; + parseModelStructureDependencies(dependencies, dependenciesList); + modelStructureOutputs[index] = dependenciesList; + modelStructureOutputDependencyExist[index] = true; + } + else + { + modelStructureOutputs[index] = {}; + modelStructureOutputDependencyExist[index] = false; + } + } + // ContinuousStateDerivative + if (std::string(it_->name()) == "ContinuousStateDerivative") + { + int index = it_->attribute("valueReference").as_int(); + pugi::xml_attribute dependencynode = it_->attribute("dependencies"); + if (dependencynode) + { + std::string dependencies = it_->attribute("dependencies").as_string(); + std::vector dependenciesList; + parseModelStructureDependencies(dependencies, dependenciesList); + modelStructureDerivatives[index] = dependenciesList; + modelStructureDerivativesDependencyExist[index] = true; + } + else + { + modelStructureDerivatives[index] = {}; + modelStructureDerivativesDependencyExist[index] = false; + } + } + // IntialUnknowns + if (std::string(it_->name()) == "InitialUnknowns") + { + int index = it_->attribute("valueReference").as_int(); + pugi::xml_attribute dependencynode = it_->attribute("dependencies"); + if (dependencynode) + { + std::string dependencies = it_->attribute("dependencies").as_string(); + std::vector dependenciesList; + parseModelStructureDependencies(dependencies, dependenciesList); + modelStructureInitialUnknowns[index] = dependenciesList; + modelStructureInitialUnknownsDependencyExist[index] = true; + } + else + { + modelStructureInitialUnknowns[index] = {}; + modelStructureDerivativesDependencyExist[index] = false; + } + } + //TODO handle other FMI3 types + } + } + } + return oms_status_ok; +} + void oms::Values::parseModelStructureDependencies(std::string &dependencies, std::vector &dependencyList) { std::stringstream ss(dependencies); diff --git a/src/OMSimulatorLib/Values.h b/src/OMSimulatorLib/Values.h index 3a420e8da..6347638f3 100644 --- a/src/OMSimulatorLib/Values.h +++ b/src/OMSimulatorLib/Values.h @@ -111,6 +111,8 @@ namespace oms oms_status_enu_t exportToSSMTemplate(pugi::xml_node& ssmNode, const ComRef& cref); ///< start values read from modelDescription.xml and creates a ssm template oms_status_enu_t parseModelDescription(const filesystem::path& root, std::string& guid_); ///< path without the filename, i.e. modelDescription.xml + oms_status_enu_t parseModelDescriptionFmi3(const filesystem::path& root, std::string& guid_); ///< path without the filename, i.e. modelDescription.xml + oms_status_enu_t rename(const oms::ComRef& oldCref, const oms::ComRef& newCref); oms_status_enu_t renameInResources(const oms::ComRef& oldCref, const oms::ComRef& newCref); diff --git a/src/OMSimulatorLib/Variable.cpp b/src/OMSimulatorLib/Variable.cpp index 90f55f13e..06b21919c 100644 --- a/src/OMSimulatorLib/Variable.cpp +++ b/src/OMSimulatorLib/Variable.cpp @@ -33,20 +33,43 @@ #include "Logging.h" #include "Util.h" +#include -oms::Variable::Variable(fmiHandle* fmi4c, int index_) - : der_index(0), state_index(0), is_state(false), is_der(false), is_continuous_time_state(false), is_continuous_time_der(false), index(index_) +oms::Variable::Variable(fmiHandle* fmi4c, int index_, oms_component_enu_t componentType) + : der_index(0), state_index(0), is_state(false), is_der(false), is_continuous_time_state(false), is_continuous_time_der(false), index(index_), fmi2(false), fmi3(false), componentType(componentType) +{ + + // Check the component type + switch (componentType) + { + case oms_component_fmu: // FMI 2.0 + fmi2 = true; + configureFMI2Variable(fmi4c, index); + break; + + case oms_component_fmu3: // FMI 3.0 + fmi3 = true; + configureFMI3Variable(fmi4c, index); + break; + + default: // Unsupported type + logError("Unsupported component type for Variable constructor"); + } +} + + +void oms::Variable::configureFMI2Variable(fmiHandle* fmi4c, int index_) { // extract the attributes fmi2VariableHandle *var = fmi2_getVariableByIndex(fmi4c, index_); cref = fmi2_getVariableName(var); description = fmi2_getVariableDescription(var) ? fmi2_getVariableDescription(var) : ""; trim(description); - vr = fmi2_getVariableValueReference(var); - causality = fmi2_getVariableCausality(var); - variability = fmi2_getVariableVariability(var); + fmi2Vr = fmi2_getVariableValueReference(var); + fmi2Causality = fmi2_getVariableCausality(var); + fmi2Variability = fmi2_getVariableVariability(var); // TODO implement the initial attribute table in fmi4c according to FMI specification - initialProperty = fmi2_getVariableInitial(var); + fmi2InitialProperty = fmi2_getVariableInitial(var); switch (fmi2_getVariableDataType(var)) { @@ -79,7 +102,59 @@ oms::Variable::Variable(fmiHandle* fmi4c, int index_) { is_der = true; state_index = derivative_index; - if (variability == fmi2VariabilityContinuous) + if (fmi2Variability == fmi2VariabilityContinuous) + { + is_continuous_time_der = true; + } + } + } +} + +void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) +{ + // extract the attributes + fmi3VariableHandle *var = fmi3_getVariableByIndex(fmi4c, index_); + cref = fmi3_getVariableName(var); + description = fmi3_getVariableDescription(var) ? fmi3_getVariableDescription(var) : ""; + trim(description); + fmi3Vr = fmi3_getVariableValueReference(var); + fmi3Causality = fmi3_getVariableCausality(var); + fmi3Variability = fmi3_getVariableVariability(var); + // TODO implement the initial attribute table in fmi4c according to FMI specification + fmi3InitialProperty = fmi3_getVariableInitial(var); + + switch (fmi3_getVariableDataType(var)) + { + case fmi3DataTypeFloat64: + type = oms_signal_type_real; + break; + case fmi3DataTypeInt64: + type = oms_signal_type_integer; + break; + case fmi3DataTypeBoolean: + type = oms_signal_type_boolean; + break; + case fmi3DataTypeString: + type = oms_signal_type_string; + break; + case fmi3DataTypeEnumeration: + type = oms_signal_type_enum; + break; + default: + logError("Unknown FMI3 base type"); + type = oms_signal_type_real; + break; + } + + // mark derivatives + if (oms_signal_type_real == type) + { + int derivative_index = fmi3_getVariableDerivativeIndex(var); + if (derivative_index != 0) + { + is_der = true; + state_index = derivative_index; + if (fmi3Variability == fmi3VariabilityContinuous) { is_continuous_time_der = true; } @@ -93,55 +168,101 @@ oms::Variable::~Variable() oms_causality_enu_t oms::Variable::getCausality() const { - switch (causality) + if (isFmi2()) { - case fmi2CausalityInput: - return oms_causality_input; + // FMI2 + switch (fmi2Causality) + { + case fmi2CausalityInput: + return oms_causality_input; - case fmi2CausalityOutput: - return oms_causality_output; + case fmi2CausalityOutput: + return oms_causality_output; - case fmi2CausalityParameter: - return oms_causality_parameter; + case fmi2CausalityParameter: + return oms_causality_parameter; - case fmi2CausalityCalculatedParameter: - return oms_causality_calculatedParameter; + case fmi2CausalityCalculatedParameter: + return oms_causality_calculatedParameter; - default: - return oms_causality_undefined; + default: + return oms_causality_undefined; + } } -} - -std::string oms::Variable::getCausalityString() const -{ - switch (causality) + else { - case fmi2CausalityInput: - return "input"; - - case fmi2CausalityOutput: - return "output"; + // FMI3 + switch (fmi3Causality) + { + case fmi3CausalityInput: + return oms_causality_input; - case fmi2CausalityParameter: - return "parameter"; + case fmi3CausalityOutput: + return oms_causality_output; - case fmi2CausalityCalculatedParameter: - return "calculatedParameter"; + case fmi3CausalityParameter: + return oms_causality_parameter; - case fmi2CausalityIndependent: - return "independent"; + case fmi3CausalityCalculatedParameter: + return oms_causality_calculatedParameter; - case fmi2CausalityLocal: - return "local"; + default: + return oms_causality_undefined; + } + } +} - default: - return "undefined"; +std::string oms::Variable::getCausalityString() const +{ + if (isFmi2()) + { + // FMI2 + switch (fmi2Causality) + { + case fmi2CausalityInput: + return "input"; + case fmi2CausalityOutput: + return "output"; + case fmi2CausalityParameter: + return "parameter"; + case fmi2CausalityCalculatedParameter: + return "calculatedParameter"; + case fmi2CausalityIndependent: + return "independent"; + case fmi2CausalityLocal: + return "local"; + default: + return "undefined"; + } + } + else + { + // FMI3 + switch (fmi3Causality) + { + case fmi3CausalityInput: + return "input"; + case fmi3CausalityOutput: + return "output"; + case fmi3CausalityParameter: + return "parameter"; + case fmi3CausalityCalculatedParameter: + return "calculatedParameter"; + case fmi3CausalityIndependent: + return "independent"; + case fmi3CausalityLocal: + return "local"; + default: + return "undefined"; + } } } bool oms::operator==(const oms::Variable& v1, const oms::Variable& v2) { - return v1.cref == v2.cref && v1.vr == v2.vr; + return v1.cref == v2.cref && + ((v1.isFmi2() && v2.isFmi2() && v1.fmi2Vr == v2.fmi2Vr) || + (v1.isFmi3() && v2.isFmi3() && v1.fmi3Vr == v2.fmi3Vr)); } bool oms::operator!=(const oms::Variable& v1, const oms::Variable& v2) diff --git a/src/OMSimulatorLib/Variable.h b/src/OMSimulatorLib/Variable.h index 23a6a240a..d5cfe1158 100644 --- a/src/OMSimulatorLib/Variable.h +++ b/src/OMSimulatorLib/Variable.h @@ -45,7 +45,7 @@ namespace oms class Variable { public: - Variable(fmiHandle * fmi4c, int index); + Variable(fmiHandle * fmi4c, int index, oms_component_enu_t componentType); ~Variable(); void markAsState(size_t der_index) { is_state = true; this->der_index = der_index; } @@ -54,13 +54,16 @@ namespace oms unsigned int getStateIndex() const { return state_index; } + bool isFmi2() const {return fmi2;} + bool isFmi3() const {return fmi3;} + // causality attribute - bool isParameter() const { return fmi2CausalityParameter == causality; } - bool isCalculatedParameter() const { return fmi2CausalityCalculatedParameter == causality; } - bool isInput() const { return fmi2CausalityInput == causality; } - bool isOutput() const { return fmi2CausalityOutput == causality; } - bool isLocal() const { return fmi2CausalityLocal == causality; } - bool isIndependent() const { return fmi2CausalityIndependent == causality; } + bool isParameter() const { return isFmi2() ? (fmi2CausalityParameter == fmi2Causality) : (fmi3CausalityParameter == fmi3Causality);} + bool isCalculatedParameter() const { return isFmi2() ? (fmi2CausalityCalculatedParameter == fmi2Causality) : (fmi3CausalityCalculatedParameter ==fmi3Causality);} + bool isInput() const { return isFmi2() ? (fmi2CausalityInput == fmi2Causality) : (fmi3CausalityInput == fmi3Causality);} + bool isOutput() const { return isFmi2() ? (fmi2CausalityOutput == fmi2Causality) : (fmi3CausalityOutput == fmi3Causality);} + bool isLocal() const { return isFmi2() ? (fmi2CausalityLocal == fmi2Causality) : (fmi3CausalityLocal == fmi3Causality);} + bool isIndependent() const { return isFmi2() ? (fmi2CausalityIndependent == fmi2Causality) : (fmi3CausalityIndependent == fmi3Causality);} bool isState() const { return is_state; } bool isDer() const { return is_der; } @@ -68,9 +71,9 @@ namespace oms bool isContinuousTimeDer() const { return is_continuous_time_der; } // initial attribute - bool isExact() const { return fmi2InitialExact == initialProperty; } - bool isApprox() const { return fmi2InitialApprox == initialProperty; } - bool isCalculated() const { return fmi2InitialCalculated == initialProperty; } + bool isExact() const { return isFmi2() ? (fmi2InitialExact == fmi2InitialProperty) : (fmi3InitialExact == fmi3InitialProperty);} + bool isApprox() const { return isFmi2() ? (fmi2InitialApprox == fmi2InitialProperty) : (fmi3InitialApprox == fmi3InitialProperty);} + bool isCalculated() const { return isFmi2() ? (fmi2InitialCalculated == fmi2InitialProperty) : (fmi3InitialCalculated == fmi3InitialProperty); } bool isInitialUnknown() const { return (isOutput() && (isApprox() || isCalculated())) @@ -82,7 +85,8 @@ namespace oms const ComRef& getCref() const { return cref; } operator std::string() const { return std::string(cref); } - fmi2ValueReference getValueReference() const { return vr; } + fmi2ValueReference getValueReference() const { return fmi2Vr; } + fmi3ValueReference getValueReferenceFMI3() const { return fmi3Vr; } oms_signal_type_enu_t getType() const { return type; } const std::string& getDescription() const { return description; } @@ -98,12 +102,25 @@ namespace oms oms::Connector makeConnector(const oms::ComRef& owner) const { return oms::Connector(getCausality(), type, cref, owner); } private: + + void configureFMI2Variable(fmiHandle *fmi4c, int index); + void configureFMI3Variable(fmiHandle *fmi4c, int index); + ComRef cref; std::string description; - fmi2ValueReference vr; - fmi2Causality causality; - fmi2Variability variability; - fmi2Initial initialProperty; + oms_component_enu_t componentType; + + // FMI 2.0 specific members + fmi2ValueReference fmi2Vr; + fmi2Causality fmi2Causality; + fmi2Variability fmi2Variability; + fmi2Initial fmi2InitialProperty; + + // FMI 3.0 specific members + fmi3ValueReference fmi3Vr; + fmi3Causality fmi3Causality; + fmi3Variability fmi3Variability; + fmi3Initial fmi3InitialProperty; bool is_state; bool is_der; @@ -113,7 +130,8 @@ namespace oms unsigned int index; ///< index origin = 0 size_t state_index; ///< index origin = 0 size_t der_index; ///< index origin = 0 - + bool fmi2; + bool fmi3; friend bool operator==(const oms::Variable& v1, const oms::Variable& v2); friend bool operator!=(const oms::Variable& v1, const oms::Variable& v2); }; diff --git a/testsuite/reference-fmus/3.0/BouncingBall.lua b/testsuite/reference-fmus/3.0/BouncingBall.lua new file mode 100644 index 000000000..25a556293 --- /dev/null +++ b/testsuite/reference-fmus/3.0/BouncingBall.lua @@ -0,0 +1,45 @@ +-- status: correct +-- teardown_command: rm -rf BouncingBall3-lua/ +-- linux: yes +-- ucrt64: yes +-- win: yes +-- mac: yes +-- asan: yes + +oms_setCommandLineOption("--suppressPath=true") +oms_setTempDirectory("./BouncingBall3-lua/") +oms_setWorkingDirectory("./BouncingBall3-lua/") + +oms_newModel("model") +oms_addSystem("model.root", oms_system_wc) + +oms_addSubModel("model.root.BouncingBall", "../../../resources/BouncingBall3.fmu") + +oms_setResultFile("model", "BouncingBall-cs.mat") +oms_setStopTime("model", 3.0) +oms_setTolerance("model.root", 1e-5) + +oms_instantiate("model") +oms_initialize("model") +oms_simulate("model") +oms_terminate("model") +oms_delete("model") + +if 1 == oms_compareSimulationResults("../../../references/BouncingBall-cs.mat", "BouncingBall-cs.mat", "model.root.BouncingBall.h", 1e-4, 1e-4) then + print("signal h is equal") +else + print("signal h is not equal") +end + +if 1 == oms_compareSimulationResults("../../../references/BouncingBall-cs.mat", "BouncingBall-cs.mat", "model.root.BouncingBall.v", 1e-4, 1e-4) then + print("signal v is equal") +else + print("signal v is not equal") +end + +-- Result: +-- Loading FMI version 3... +-- info: Result file: BouncingBall-cs.mat (bufferSize=1) +-- signal h is equal +-- signal v is equal +-- endResult diff --git a/testsuite/resources/BouncingBall3/binaries/aarch64-darwin/BouncingBall.dylib b/testsuite/resources/BouncingBall3/binaries/aarch64-darwin/BouncingBall.dylib new file mode 100644 index 0000000000000000000000000000000000000000..456f75e3eb42662a5273601e066b7b414e596937 GIT binary patch literal 89632 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/BouncingBall3/binaries/aarch64-linux/BouncingBall.so b/testsuite/resources/BouncingBall3/binaries/aarch64-linux/BouncingBall.so new file mode 100644 index 0000000000000000000000000000000000000000..28e7292f21b64714632a2f7640f7a07ec4c606e8 GIT binary patch literal 71848 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/BouncingBall3/binaries/x86-windows/BouncingBall.dll b/testsuite/resources/BouncingBall3/binaries/x86-windows/BouncingBall.dll new file mode 100644 index 0000000000000000000000000000000000000000..e37a3c220cae02cdf9000fbdf15af901e130f28f GIT binary patch literal 135680 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 Yeb|H%Y(7OF3g~@{`$GRY{wY21e;c_VbN~PV literal 0 HcmV?d00001 diff --git a/testsuite/resources/BouncingBall3/binaries/x86_64-darwin/BouncingBall.dylib b/testsuite/resources/BouncingBall3/binaries/x86_64-darwin/BouncingBall.dylib new file mode 100644 index 0000000000000000000000000000000000000000..de088d19a5899b66f86a0d5239d0940f09e43480 GIT binary patch literal 88944 zcmeHw3t$x0)&FcBm>{@oH7)j`TPyvb{luVXp;WtIhAx)HScs2S8ba7WG$h+>f?$nZ z3}BXRZ19OzZCWjj*4p$FYtWW1N=d9xx7KP@tXoB$t+cMTThVfURL=1rNg`1ieh4m;a zzLVbKNna8=STSxn?!0B)w9sM^Tj_uc-AwqH!gkhr%z9-J{@sh{8(F$LM!u*VPVEo*ZcXO zLmHzWclsNH-&Fhv7t!uIdn(M*rJU9rZafXmrr*4k;illSNi)ri_$=}gp7O7_lz!YN z3YgmM{5c$OIN)%=;ef*dhXW1=91b`fa5&&_z~O+y0fz$)2OJJK9B??`aKPb!!vTi_ z4hI|#I2>>|;Bdgp($we)VQKh~1=$0`sT==ZmuN%eIrTK%nx z(yP8pFVm(j$BV8hsxqbmts3{YYDc-RorYLoiu>EgR#33IV3pt1H<(0R8jbOJ5CBkt znn(MizxTIpN9CuZc?EqyOz2V{;V3A(WXl0cBvDLMAUSt{68D=*bn@^4N?c_sL0ms@ zJI>3U%TxHtUofE>t^Op--I9(~>;b>8L^AmO{w+GcW9qy9)@?oryJOS)gM+W&S2D>L@7oZ~d>Mt6Q*S-3`4annOeWKtBSaKUD;fhR0m^c9Lm^c9Lm^jeHYfjx{a9|(j)&V%s zX{x!GmjLgnW|JgPvxyGWY@#Dm5@&Hbs!VizYe;mE-AE36nUz2%(|+ccfbU@(vOyX@ z#)LG}Brf5#zHy`8dfg=4CnDK zt4|Rm#VWK|fUIy7uX2S^Woi}jpu>x*yIQHpM*#{WKt#TK^>~W#;lj1gqxVP9M7`}_ zGNpI&aMGNf+3>!fGtRtygQel6)ECJ99@WvTW4ljo*EB+`kzi`iuA{_aUY}&Wl|V5q%#}WR6l_1v;voSH!h8Yd905TPF|` zzU{s%T&W@h5RuEpy;C^VYYxKAoG#eY`rt*RrjNJg~kLg!? zVe8L`yRb6`V?6P-fxRv1Q(SH8o6@Q1RiCCJ{??W>x|T5r!q}OwaH{C;xS!F|w*^)? z=x;A61zPO{BzC#nYgV8Dv!z~j8Rp@Qx7X~yasCzq!FF{}Nu7lNNiOCK zeMa5WIso3E#G;r7mqb5Sz`eKb?}-w0Fb|5l)~SQkNVsm>yd+&|UyyHETYOGT^`P1T zX$q0QxY`1*lf++}0~Zq9f-_fvdtd-r({o}0ZJqksk2*V=o*mtXsuI4o?P%mw{7UhgfS(t? zaqCnMh#5d$(nrk~dClc(YkocQva7A)HAeBPMDcE*K)Gg=uRz%hip|85l4w0K5F1td zp~(G;d-dlLw=Mt-YCj=tBkfujcvXj~t0Vy0M~tN)np$r7-<+2dz$7nz;|{=A*4JhF z^R0WhAYv^8+8fs~PI@xswXh8gdW)2VwfRk$w@O0_X>ptSEJ79VueX6bJM%owFwY(^ zs%HypM|;T+?*TWi#K>wf&rK%t+$PPF*=%deHff&R2)7wV(Id^1j1ULVO1-1TGDw;=`*EJK$l=PNQ}@p;TpB#z9K z4}_4y#?)=P5iZQ0U$yQjC06&Udyv2E|@9*|VhVBH5T3hxQ3{6UgKEP89hEfV+=&iWgF%)f0?u|r26<8U;jb$QIwTIst z9E9>ii>Irgg?D)UQS>Y=Iw>=Ak}@GDDaT}!LR4&LR1ou%F`pMEzb5Wp{a=zIOi`Ji zMN?8nB8$j#ubxg3GjO4TXe|u^smTIf*FiS9*@sIHCG36FD0rKto=W|GXIDg~l^x|9IKZfbk`#%DIqkFUX`zurbyhHZS zJ9z)RL-x@N8cBRhl}=FW*VtW~mF>3m;cDxbh4kk+MSCGc;|_=-8cQjRZTkIyCX2_;bD zwj)Vg3%x-jNe_nA=_I5-Ap@L6~tllJu(GXrbco zRY|W&&Rtm7OuAdqD$#J_UQE^C2zJG$v2lO!zLA|j{~xl)r+xr?-1qi~vB$^Z+G1Er;s$&4 zUBk5R1K8tAj<1vBORuuUH)MNEzCHr&aXKUVaJ9#=cQ8p`7&$WRF>pKVvG&aoV~^9m z&+M@rH`rtM)wcF?5aVO&Hipl`@h!B+H)MM(-#r5D@r|~_d3VkN(;Rk3f4o8dI~wcYOR5c4$G;HA{{Rd%OeB zS+$jLvqs4HIGdh0wwEl#4N{5+Kd3$KqbH8-C0>p%WRGvi_PFqg5onK(;MIo1*B;yP z;1QC3ruxXR$B&`8S_*E~2(ib_^n|dzB!L^GRJ!Pc+G8!p*TL~6t8DQN*&Y+UBhVf% z$JFfbwa54H;1QCZweZNW$LrBt?UE-)j6F`ICywnUKHMOs&Trb<&q1u`JV#F)+e;LV zuiPHrknPd8Z3NomCoVsn?Qt0%JVMgHy!0@)$B^CrRlL};pO-f7%VXM0dxZH*8)6S@ z5t^+17Os|Mj2zNS8>IVqHN)5~sK2!F1)fr%zf+~ZwDBpVq!j#FF4(TB?_u31w`^wa zVeP?|#+&FVVSCAaxIt25zQI~0tCf3Len^X@Fbz}~ z8(H}V)?T#}8EGSHC*R15UH+We*c}SlvyH5s=8dd)7j8~_piA3=d0JGxJ*M7nBK-DD z!qI8vAiRvH*ogddk^rm7i9~*$Kxb+WHnXyH^V>8bdYi`P{V%Kj=YE&)QZO2ACcW=N z`}KDTKfWA#zq2n(?}zj*p^Hh+?hU@z858W@;Me}kgq(U(^9?x}uO713*MN9<`|InC zz9~*SnC1TZ@8F51HW6;8rEeP2ex>7B4`jE$o_ZJioy;#G#iFAOH1|!9$UK>SQyksM zK0KF0-{irAQ}j)t3z<-@`*~OCnVFVP> zvh$pE*lWf6QDQ&63)yn-M;{9Yfio9Y9OmQeLGDM-rN6(!Vt`f)H*JLI?=*VC*j`eO z8>G}d?~v;6`bTJ#-2YDP!%cq!4U984f9?Oc{{DG1Q-l&USG#BHh|%Ab%NW@mxIur@ z<%d*%kF6Ye{ck%SS%NdqoPT8K?*cSeOX2j05z_x|#&b*bzX{wRrP8^FRDaiFk~`A+ z-<@!L!I_T+jtu?Xh~{b&e>GzCcOT}DK zH*3iM-8^FScN#shg#U{hq}1&{r24!5qLHV+0n9nUnVY|IWa#fSG*`Rlmm@}hS1w}u z+kqRTlvWR^{vL}-{7CD6+p8F7p212LR!RTQybqtX{vhUW*Pyvt>VXlXznd|oBL5dR z=x^z{hg5&pV-i2o^miv#b-|gB&O9>ocL$oQP5i}((cgWTQj!0=fJrIjJEZ!1ES5J$ zn*NRjgP^|`e)-7I-x4%etG$23=_e)*>oJKRY5E(ugmLEPFC7{B zTZ!gs_xyCk=p@kkP!`REr8bNwC0{;Wo9SHQD#V}F*I!==$=ZT!Y8 z9UjvDtd9X{j$KA z)*4xde(D~kmuH!X3-$bArEI~MJO zpmPNK^mF;J^Qr=e3kUkZq(U$W+?hLt^mv159U|xP$Z(c&Nb(GxQjopV?gXURNs`4` zc3HVkiXgY#zf(T+{Z;f`7ooQq`>ST6iQ2Nevh;RH`>Q-mJMA_v?FEtcC#3H}id}1= zVwU|?KSNHCj1!^*J$nm^aHR1XS=O@SO51}qhy(4ks^%man{4!hGvZfnPiGhgo{_w8=_#%QIDXQ)Fw)Zh1WDb`Bb%=$B`z-p5l6QBVpK#q~(B zlLCt)%5V<6rrm`l7o0YY^Q5P%sD2a*AskhAn`*~^O2pXIJ}GDI$LFX$rta2{&18o? zA1r^_=al$(lEL3y=t;Cc{a|?feJ5uNlQ~;RGO^x zijBcV?&&24WXj|_Gd^UQ_+)=M1bu%Pf{ zT7&}PG=FTW7Q%SS!oA2yTArbZ_UCc?q`lL5%DpOe#dbD-KSgt$M7PqCkT!oMrc&CB zJF~we-ctG%@?YL1NeKD z0VK!NUAh6X4laU7DesK-(g)IV??3*W(a&X!k9Xi1uok#ItIb0iAD;v%_FoWrkf#`J z)`y($BgMYWEg+29;U_>7?C^6$+W(xM!w#_~03ot6^r^SkXR|VcxXtJx#%Vnm8fe2! zmIV{nQ8Gy#>cf=P-;2FvgM-?u7-cOVGRgEu4uao-9Q>{Zf!d3=4UgY%gIIfh_wy7R zes4j_e)ydP?_QxN%###6SYOYlJObodm`4@`~CX+_AhFfz8`sr^kXdaUOVBI!%jaS`61{Bj+D=#AN*w; zrXO8WKi@8N8P4nyV8tBCL6JWUbpB`24W{BO#VKXVC$pOEu=I5o^< z?7oKs4-95z_dN@YfmUOZy=F329@?zrVOE8o()vz;yNry7J{gn!Ne}DynGVqYyLo40 zv_B7Zp#9S@PHHFIIK1}H22%S^(VWIpjLsw}`^OTb*!GWTD87ja7tDjkQ?pT`fS6S) zVD@pIr!61ndD{AM9z@{dJmaY#xupUT;Y@wPfPDlXZNL$N@#7crD71f`Le{eXuMlBy z$-w|VJ+o7Q+|#p+Z}DIruqQ z(`R6w-?dfS1&fNR_r=uvOrOiRFY|L5{LM8x!eRc9pdI0#ljImQvk=fyfdl+)p>KUWkH@v}^4@`$&ALJ?^ZsZ@}6A$EeAgd zNBZFW;>V1Bpa-?~$bR55uu}WtGKomj!bOn+UvJ_qwHzln=QlCunAc;l<#NpF|o=Aj;@ohkS9Tj2Bn6~MQ z2IWu={=M0Q|6UoRy1j%xTc=I@ZkF7K`iK@G*@gvAAbA#20g~zVNKTMQ zpn6Hrk6S-(mKl1czR{O1wcHEvzhLcPPBt5cwy=h^mn;Gy+9sH{<)x`1Ex=z0r1neT z=shXLV7k5lf3j?w!D<$wX)D|cwI2=fc`WOYnd?L4=Ds%f`s2ffp0QC=>e&@j(d4ad zSxp|&`eP;QMeWufRi0urSzmwrJW?#JWguFc;EN)d_~0|b(6fZ*UqfH{YQcyQh|iA3 zp)xOUz1xGEb{@tf+ts$6lC4lV(|6#=Rk&aZQ@JfD50&ft7}F=YY%2A(U6vP=!O6h7 z9UfvPwNao5$0?v^oUUSBb`)|VOdmNnmSwrOZO0bwZQCu&Qr~LF7V}yxb*ow5gB+s# z@3G2%DqnZn4inV2t{tBI`6z1FP#Q(;*PlOrQ1WlJ%6|&)GWOu%x^~_tbIAW!U?%Ag z)P|n1D7?%ksHxB7D$^zfzzYg-Ujza^RB;bi-px7WeF`z|537eKZ<3w;^9CiSykC=i zwP?4!y|1#$`&w?Vx8SCI9Rq}|z1z#~1t9wnWhc%9`GEHMbL?@@J`F9j3`s-kpAWfx zc74Yxuj4>3hV(g@>}vOp%ONj|eZGXuD3hi#XJNQM2pN9?1bm1xKG69*xyR#%9QOG> zo*-$Hp}E76_whOH^Bq{BeSe(XzkPPYPH8-*Nm*L!X<_n4WT1zS$913=vbz)>l=kpP zbI9%*)M4t6r}8r8)YMrRfo;xRy#13Q_&P3p^XQcG>B$>Kbq#Mx!uKo^GefT19umJeh`hmjT*fM8fcN#kle*i zAhmZF*YXs@chcR(I;2>-Q3K5Mb!cfNh=oOv`Hj<FDjM(=fU%@8H8!-)rT$r#$#y>{EM8*_;>r*A@J{(D~H9u z+|L8mg0__5Wy0-WzUwg@2=&-aYFd>Ul-<^+i@sMki+zi8{+}g59Zid;6O&0)-%`jb} zr%U~Srx+b7r9k{jiZ*H(Vl+Z>{!LGb+v3QnU5(z8sJa;dkxZgSVuTWLXY-6V!0PTi zEnG~!tN9h%oHQ5ar1^~k)*2g{|9}*OQX_}rzqrGvl@;vR_g6}i_wz!}KnkmxVcK7yW>c)h{Y z4q)&El7j2yMQGJuC!$sPS|MxIcZbrdTad|KLt1!>4Y#Y2V({1qfs({_rp0~y7Uwro zio&Rul;UC^t&XY@YH?&T6HZ6lng&>!do8>kQX7^S=+L}l6lKaFPh7{ckVVDzsxh#E zMrf*TuY&EmaIpyJ+8gOX2ocaACG|OaNGh{&l;m^Rv;K-*Xb&BwHOFEi2c7N3%dxl*z@mfo?^ql&mhI%8Vl_umuV0UgP4`Q zYlsfC<9y!9qhXs7jR>%WwQ0NJO3?#7y$Rasjp!-YG%=#-Y9gAzOrn3p`gyxriae!)EH?cMXYP5 zD~iPV69L}+`8sc4^TeN8p;Nx9)Hxo6fRyG4X5x_gf$WNv3swtoZ2kH7xOS!Si*49{zWP`4(yuTr6L2gjAOP zSTq|wM3DMhk^{BLEi(99SB!&L>7f`TO)odKeumA0nExXM*d%iEeSdgR5g13l z#J(6-pRb8m=4%%B<>G#YxUXP$jwlil)oKGl*5{aBECQFXeSjWMw{Ejp4_~z>iL$HX z?$r}ai7jwf+xJ&{EMv^r+tS%|Dd!9nQ0TWYCWx|A7zlt zsV4Tb7;T1;BaxMZVziTt99mWmiqYPKL&L?{lg`RPG1?0(N6Ucr6a`whdFYj!GJU^M zDUA=%(X@8->XC5!@XG%B-TYYzo+2>SPMO;M0?X1=#Y%=Zh&`VM1cr0k7vN2(FvnKDdB-O4ruNw>S)vfexSVz zJv~!&oAr}Ya)fB=9e|VNq0ptOrjc&DC-fnv@OZQpbE~cHYl;!MT^)3#zK(z?^CAYq zonmp?JOSciGdwp9rX^6R{n{)2xCU;^Z9+u2Tn3ak+mj0qzA0FpK(Fnt0SUXammSBzFeRbT=#v(*T{FD0-Qy&+tMMLS~r&k04eBzqq7dX~ zJs&KUIGFu_exdVNFU&p|d`SPUXnc+*rT>~`&`=CQPYCp4{qjH&0J#Q`)`x0$4 z2_u)b(ZfB#HDuoF0&kKKxu2A($u4pp6$$4mQkCM|6m*bsu*JMFRNIN1re*(YG;bCv zFgj2cVy)!6GZU#|_z9_xTj??rS!L~o#D14U+)AOZ-Q;d@tu(5+u?6T%)VTuE&+xsRiWy4G!2*VV$vLF}~cKlJyh#r9v| z9DruuG>&x=H~e#O(6r6g;(t>AlcRhyFF$X%<-f+uA2;0crM&zf|1nJZj}h%3Zu!5# z8%8HPZ@A^3;N_1SZuxt8`9Hor%=WkO@;3~({1Var;g;9DGuUEG(eK{H2s5%5H!{9HN`XH~tSWf0exg zz?biN1TEwv2W|4_5fnlMZSCg~6hg!bJ%U0+LL@>S0Vh<3wRLT6B9`it0HUMjXbHgU zK$F*ZP+GKu-D2xEaERSv>pMBbZn0<=gWA{)RQO|U-4p{NuxcZMsH{gsG8zPcXqq6( zW=MdwBrX!b&xj2B^(7FR^0F#oJsJ<9;%+0@k)&9x{z&&OP@oq`8wHGDR)J5-0{VKB zShX0ya#_MaVFcL{kGan0u>1fbZCJwA1GvIl^*xj^-yS@3 zfBLEq6nvy#nFq}o{}?w(fYzR=7n&oF+)$`2o1i2VLy$X z%^JG{@6qXv-9fa{gH3Z|si9mI2e%qZNox#6|8QR&=_c|glstk`HSR@N3z<;z8y3Fw zQ7n_xxJ$5VaWUR2_mo5sElH+k>BhdD@q=X52V|Hkm)ppS*v6T`R|7{g^85HB0?z6_ zB7cKk*1TVivzpMmTes+#BK<5Fi1Y0N1%2*oK5HcM8rjymg1&B-ShQ(Vf8xG&wvkJs zVA7flOl)bVP2K2TYdrjkNL+eFH^h-;ow^a|)~P?CB_rqq`lTY6xcirn7yqGkpW?o0 zD;azd60n}cL>o_?%2we?D4cperz08Z9E!FHqIwv^q9P@b#&gXXE3h>2V>f#^NvR;4 z^|-WB#5z4UQTF3?fgdAPyg|k6XoU}IGDUB<&&Sjk6E3;~%M6b?Ilh^ubC?=FG^f3y zt1P-b`nx&N<4+k(WQ-Z11&+9^AV%Im=^>6I@CcD1HuK!@yf8omh zXtAiK=Cv=MwC0TqdhYy8oX4iWeA}(`xB1H)_9&11`q}4Ry6S~ri}dfjd(T@>1s0Wm z`K_g|v^_Ym`y3umS2|_9lpa@@{wR+AN>z15C|KPTTx??8okS@q_;6x6Ko9DR|mc0 zQRKp^#@ebybwTgROHcMzSJitP>g!f|7X`gx;Hs_n&aMwPRn<4uR#Dx7hQ-1EMpP}} zy4owNnra*BMdY~+$W-6l&>Z&8uU!@tu~qepz3TE{eG`MtwJrbuS=*AVmQ~d>1sl;m z**IzlID`h*X0~n_nrxywI226(odXZm5M3(@Wfhh)Aql zK$Db;`k+({OX)8%@y=fw^foj%g`g#igN?PzA+qI&X$0UMpGzxr-C15$TSv+Iddi{j7?vYHW21;7`0mL%ig?% zby0P*>zk(1y+Q_XpL~{#;UPqUAd!iO5OvlR8O1|08yf0@RrM4(uc?uEgV0R0u5l%W z&aG>xzMR-68z_S)jUcNYcTNY7KmPzR@W}8 zs#E3$uPCbxS2qTmf{dlmQp#a;wbauxl;<{(6d(dZu>^HBG|p=Zh7=Nu$!Gv@qnTH` zthtU+L}DT|bT<%->V(*`;_I_ws`c()6eYdQj58P$W&+%Q4s=kWw+eq_0kM~v{_Oh2 zwGdB3qmIHFU2l!Zu0}6wAuz01Tfu9d+dxdK3!h(;Re%_T3Pg^qoZc`h^O6Pez7zfCIo?uhkr_=Gl}z}(AyxrLUuDA4P$TLjAEhz)EqE^E zNRZbOZfXd5o5)u{Pr^!0Qf9!iFh((@t}Cx!cnB~^781ncVH zpa2`(m`O^ov9Y013Dkze=sU%r4)>Xb6|j8mtU&YX5?S*bc>#*8nNojGIH=RCqthVt~y_I3IO$Ci9^< zD;Yg^)BgA^(?MG{zhxp(o;wwZHVieF-A^(K+c4Bzct6P~Y{O7<;r%4%;SWKc>9nDqoOpyJV?^vc#$}uza;ZDDk-ogcc zK6W)OSbrVV)2C1^yi822oEiN;Lj7GGIYoK7`xMRQi4Z``%&UvB<{uHPFptc z7hzZD;&8y>fWrZY0}clq4mcceIN)%=;ef*dhXW1=91b`fa5&&_z~O+y0fz$)2OJJK z9B??`aKPb!!vTi_4hI|#I2>>|;BdgdOhJtidr$nK4V6s~Q(m)benB2q#}P)$meuz)M55QdxuJp_EFV zqEt2pMRd5Sv3glZ0qVxZ&HP>$tmpN+D(O%jB|!}?P!e7FxJKT|qww=|O@1Fu&$Brk z>I8m{&PfGI=WCR)V*pLhvz*;D6DMuZA$R)8Oa1~SeY*?UJ8zqR#LO;}}r9g@QgDULQShaM1WF9bBYToR!!Gh0W<`HNz<`mII?6 zaN#sH<+m&raJ?Ruur_bwp132D)~yXW<>dm7jGW(<24e7LWZ4GP2@Vl zBo2SfAiQ%_urW-hE^Qp8jLAOK?2){g%FeuVm9_b%b5INoP&)Ii4BD7KOZi!LVmC5U=8R_+OjnkLkAPUo|W!sM;%c@gXR4=Wn zUlLSy95t_cX>f5fj&W001go3bu~APQ1x9odhUBx<=JcP4wYu`(Sd@9r+-*f*%QnWG z&6JVr{;!LK?mvd)_~Q)E`;^Qyd{l(Voucaao#rKLKikpfJ z<&G9J<^Fy#D&N2g+{LcE3(in((C z8F;(jrt)cAjq=xz*2`}g4f?iFB2%n8M{~t`5YdtMsAT*OcI{%<2iWy`WGD4{YBVbC zAB{@?JbJ3Kd$dwCQ+d4TTtzF&IP0;sc$V^$Vv_H_isvbhjAkd!?HJ7@{@2k;o;ava z=`3ne22pSFPGVr>pQz>N9A|=!&2{G8ab?PQRY|+(XhG$!Je--P>>On}##HG)iXRzy zUD3Rtvgzpg@=!cw+tC%F#o2x6?`SAVT(uB~=5&loxY90<$LI5PxIF2+P$=p0dDD5x zf;8e2c^yaD|BH<3%#Ro5`q!QBD^KQiyf|{l^V4IJd5J@> z(*mv(aOo_LuR*{e0k;A^2KXZ6=-_X?Nbmj=hc^nComGseZV5lf(;pLXh`v;WzXV{y z=i9~MKa2FVfL|5x!WVh^-$j1UpE=SUkfFlB4A(`SmVb?x-z>`uc$+LQ;3s8y0n=x(Nk5d=dHLP4ynz2M%L{lwmKSh74yf34xcDsMVvT2U8etxr_UE~awmru z3fTJqhp!T_=T{uQRluRS940hWU*~xo{+)nJpWrZ=1*OO7(*XF}habV-O$=0yN0?yG z91fQXIDHR?X9_qX@Xr^p@(Z3`FW`klDE?Xmj8B=ezjm4a9S(nAz@e=i-XdVnZ#n#| zfRp!g_+J8E_!x)Bg26v&hi41e z)5GC!3bjfmc{yI@r)$ zU(^Dxx4^er;A=r<8-DBXi{VFNYsZh+L!bHVz>h>H^AQ^klowePFBUhjPLad8Wofw_ zT$X5ej5SZ-%NQ&ykBhb}C1j*o7c`7SV*$g6vsr^M67?kw9%a8G!PBrRk-fyBC*`Uo zE`_KYP+DQ}~IVob|{k4?LI2{DgBI%ADF6bKJ0wAZvL*mbIT7%T((O zS;p&AQ$2#_hL~Yxz?f`F7&9tN!c34UFVZq|PBmxDIB492fW_-mLz%FjBe3->xsI^5 zX2{iec?P!aYKlaXy>=i|=F#L;F8yRgX0?VN`>Jz;W}zl75@=#0fhIl@XfSfWv|cFI zQ5Z3%324SbhBYyBS;LxYv&g}+@ChvoW}lXy8J)T2A=2b2|2invJS1!~3>=PYuk}dC znDfiBnM#dZ@-qf{2L8noE)S%e#K9pc4Gu|Ra7f641KCP#iqBL7BxGxhjLgo;mqaAR zZ23Y0X7vFAv-$|oM6pSIjCBWw$#&`CLtIR+4AWO2a0L5>?0YjxCD!Dt>7xNb8L>o& zlA4Fi^3xcVh_{-lQW>Q0p71s*ltWs3R&QWR%hod_W=Ep#>`3Iy=&%82RVBWSLr0n8 zDFeQ`{azv07iGNAa+HJi(APvX7Ef)`np@VWeWLpRtIK8-c17 zN@XoSC7yFZ2L&bd&2@F`#C|O76K6BcN}k28R3a1zhQn1@|0I^`c7-tSr4SGb$D^p1 z6LBJld}LiBQUno6G8K^`sE?J1mK`X9azvF1KqwIA^&=qa=TTIth!a6kzlbyn3!S3U zBBZ+B9vjmZ+VmogmWo<21oQ z_t6ropcXCTB&|OME%XnUMf}&{KW~EF=wEl%5OgSggqtOe*bf|YYRBPQ1zfG`!i(o3R{v4@|ijFGALOi=@P*? zQ#gj>MBn|un%%2UeeCD=H{G=KyM4Pqcq#SWODO3q{D$I3_C5kX%Z=&H(RYPe!q=_} zv+bFXXt{a#s<|WYwrJ6}tkDu9wK3Y%F~i1ap0LWw{NXeEownzth~&8~+VIK4M@MS5 znKqIYg&*lQ48NoB8-d?3_^InR2pq?e6BwSza1=uYEC`Ij?<7W?3^@uTav_??B{bo|c7?_B&6@uMqA0`Y$)hm#Gs*$AJ9-}wey3Wrkx zFW~S3zzqBr<98u`kDc((YqL|1tv-FimSdLuR5EmN>7~0*-gQyf??0GOzUZ6 zs`~MS@bmL?{=Bs2?qLr-z4eqo#?+j6;w7J5c-%LS=UJ~p{E~%tK6h5cs;e%Di{Clo zrI+t{uj0f-EuTF5(%1j_D5L(uJLh$N^-V%&HEJLQjaFFk$fvJYPRZ0+B7f1ES7 z_06?E-17eBwo3-T`}vK7u8xWL$E4`fzq%WG){YB%;i&1KtbF*MyuIfxEWE0G)iFgg zPP+WWr=Z6@CuPl>cJILJPI$8FU#AWF`N*R1lWIrYSN6%@U=Nrp=w*XL4-Y~i|FQ(Z z-xnf%5gKPOIT>hB!SHv6kh3_19BP-r^tn2O9D4{k3S1CN`D45B3!B+R-q#y{F7@XevSm18}bPM4K*xWAF`ZO zQQo0ioLXmNceffk33jpQG9twbm}vpM~g$r7*RoXYts zPdWwZ==zcI|5+vD=P`aW%dwIHaVa?;G5(`@X8bWM=j;^{-z9;zmhrD&B@ySc{M%WM zCsE>+{Li^u>;E9}Ur3-G!}XF#9S5!%Y|qo#{WqXHNeF=X=gNiC6yllS*GE@zj6QHIMPr zvSeJ9>ucymcGx;!;#Ga^Wc*2U&G?Vlo{6g@{;v{fOIdzdwnQlTt60w8X%NDt%V+)9 zu>Rbfv{+96c$`dMFM)O(yX<(kLsIuiVJ4Pre9FP8BH#^5Sl5;tAP`EZopw)8yes#S>I9N_Mmunu^dp)NwDREFxXUC$ z={bq>y^0(I*B_uCT}hn&$4g~grT;UcRIUj2LoS|nBd0GeG^f9v?fE0uyQ<$p#+Ufv zAL4T5al#KFS6rEyc}0%m%u-jD)0LU2WzJ1c&CIbo?Rf>IF1s^5bylIH*q)xXywEOb z!6}*9@z zu7WI=J=Kw8FSM3t=Vuk?Nqz%ymSbT-k-IRIqpJxj znGQ#xJxkUEDrTX}spl%I;SR78=5)E{A={*u5NGsPG4 zY0M=jh zWp|cQKG_9DS-KM|^lWFAP(;~rVSYg_vNoj^I8#CxQ3)`nHK6^I2gpU*K)F^Z>PAf^ z7nEi@?Jm2hHfgntlAPcKWf)gMvD@J;O)n@C{g5coEJsmEA>`zcws|m{!@1C9FX1Y7 zQCby-0a=0}Q`pZB@2eHPGDXKSw>YODo8;?gKSmut&p{neVd(|AAycrwhY+lqLr`{M z4JxDF)1eF(xLxo*f7O#6x-F9618_pwfu~^%K@W>AztrW-E-E3A<1W#hcIn7vrNt%a zd0e?#VZrk3*iuLARBfiijpkUKHxo&K(dMMgojEIWa_ppdJ?INfj-_cA4PD{*ixB_m zxtYR*VS0b){n0oZ25nbhP7qBITTOdr|#gm`!@x6+!U@ofVjB$ z#v_uW(PLyF(huJN4ivc6>sxOI*CAieQiXN+q>_&;;T(X@>-+Eg*$bX~EAfqw1uTsWXdjKwHQij}4Dno0^ zvecHfjc%VY`WcK7sTeX2VN`G5~N2blh|iybb{<>jItN&vJGC}W=xTwQkcBnLfx&$z1Ne` zg}$%7s-i2*HMS;oZw=z;aFNY>Mj>6-s3PQ4RqPFOMdE*i>x9m!lo+0*dS>z_)_J-j z)sx!N(R>YbFXyt=n9H>)7lW$4QK6bf0~!f(qt4h7wfX@mmU6Eqm(eNfxVsS}3CUL; zt`wrw-$h+LTzpLXpMp0zVWQwQ&F=!+6}Ny^MCLaI_jOyQmU?>$26RiOf|6 z0WXITvt)x9u!>#*w$n#n!X>gCX%yj3o&BpK#Kr>;x~7dz1~Q@>7NF0-Eg6iP?;-W}Z|C)%;6RwOcg|Vb`jPZp}SVBGSP>boxfAfw!f%GgEQCmFGNa%<>c_wim8`}2LIH?YU{2h z>uwkbbC8Nw%{@p?EO_w6JcTDEwIfb}q-~f#d69AZbik^vur-aYq$X<@%|%fB>DJw4 z0{}hN-BlI4!(CV5e}sDom7^)Kgr4wrI)Lh@qtH`oofk)KcJIP;r%}vDkXFbq*EElH zFUrnB_bQ>|1BL!Z2tA7P5kd#nb@r?446CcL?lzdCYImHN^|2d!nv*@xr+89ZtF51U zTB@yWQJYiSY&8|IGW=XlzFIHS=Fj!~FqbU$y3OgD5qB`4&EIZNWoieMEC=VggdqC?(_m7Xr%JF(-+upuubTS zlJ5T5;7)s`JE7*g$emF0T^KIHT^0E6=T4Uc<>yWpQrXcEt)!J!S<$As22!-SGm@I; zQ#5H1DTb*&MkY;+HZoQ=N{z{J;kTM_r7n{l$dy`~tnHwh+YarJgDhj)8BT>IIaICQ zpHyMbN7Ivq-96pfPKDj=v0`j&506?i9a0dAa0|V-{dAlmvHf%`d3(pPGDmnur3Z1e z%1fy*lv%-dUM~zNTBpbXt&?+jA4vmq_`AgVN!u ztm+PPMRlG-$)IjDI6C7f0;vH^EQ|Tpfi;?Tbr%?O&)3 zFA!?GCJ2>HoyrM7^>ZK1a>yc`gX%hcT|m33-YnEaO-?#c^m&~tA;9RNF6>;}whYop zq4R!Jm4*&4l!s0U^w80P9y*j26}F%*%IsGMtluZtdAN=GUefR3AO7e1i4HqZKlb~; zG2>Y>mD%slBNf${G0>=Ds4;^E2){<29XMvBkqN2TJJ3b;#yC*|C)t92yaE0AMvRm7 zxLMzjW2@;mcARhsYxktaChMyRYv|~<=pEfEc_#!`%!W|2xc5%E5jNO2R8~_&x2h(z z{TA8wTc%rIrMBPVvA$YW@haN>I7mTAw*4;E_Qy!9Y?*`=ZU0Ehv8rOD7PV$Cbpuru z4VpWi^M0=mnA(I-38<$BH@gslYAjZc_b*A-4Vr5@B-HyPG)W2f7$qzWCgJxa0bq)=49^p8DKp8yN_iL>0vrg~pIz0)gfjZqMv3@$yW=UI>wH*&r z(05F?Zj4%8MpGmj)X%hTa1|k2&YqkhVciXeni!0&jZM~8=>@H3w|F+ZXHFbgiL+^eE7SO$W?7#ce zyML*LF>4bBKn2~q|BCsF!DRdK?hYwoCjr$y+`%OD;N1gvA9~)s4mJKOc=tx!3F~&8 zSkgD%eN;#9dG`PmNcZkJd-~M7N7cZXwF%=0DBpai7!hBGupjRpEG2w?twF*cgGuPY zyT`-2hg#nqBL@9G@4H{d+*+@R3yS*2yAwX|J@1Y~fpqUK_@+<2JEj-J1uOgtGn1iM zGSzG1ro6uK?v-u5=iTe74Bq`12I)TZ?zO97%-V$O2`KMAH#dlHhPAl--F{U8Gy!+3v?xE)0>)~0yf_E>t+E5d3XZ4MDZ+*A-y!(R+ zgLi+6LAnpU`z0(E!n@xfpuD?k*}-`CQ&K{mQ9@EM2|alCo3QSo=G}YYS-*mJyRI_S z#1EJDjdy?acJF!j5h##8?>_2Zed^tvcK+)xw8UEDX`9rn-O^X_;QNcZl95Bt=+hpZ6ZeKY~(-Azjl#=C#O zAp&S0y9g)=YlBJX!Ml%vbq_V~-UQG375eTiZi5}qxu|cv`=mE|&%2kQK)QD?ey>lx z`wUuDtWB6kK>23JVnh!3iQsWk!uMEK(5=I&&yp$e9LJ!`(6xKb| zyxWBq`YU+%&$PKt)x@fWedFDEuljlSGVC*H#y*oq>@&fpk<^6+v3%C6%V2o==^2Dx6jShCj3y(Sxd5|&B{ zQ;ib7m>)#K2$Fz?6J)Q+N?6!qZN)YuE-Cg?a7kNXz`&BeD6xJeZ6ISKhfsS>UWtt+=A9oc{yRVZ^OB#xCDNuv_*;wG|J!8!6h)<4^=#uECU2woj@-+HbYd zbs6usfBM_v}DvwtYBA6si5nzxS#4ETHAV+JvP9l=mEY9wPsH@A(+5{E+aT z+h{>k6?W9zKJcE%=X=k4YET;8d(M8PPrWAw3s3N#69_1S{$oz>cn@0nA>ln2(}JNY z?7wFBf%m+;z4yFl5lW+b&p!0;eK>Nxl_k9ABLd2xb=KbT9<=g9!h23M7WUrcKJcFF zw)UR)j7Dj6?`gyYs}H?r0~Suu_uNfDdC!7bz2iOT(hdplX~Qz4URe9gKJcD-&-R}8 ze1+2J-m@ALtUmOfCA4%{n;=#YmG{IX^^W(TOFJaI=N>G^=-zW`Vjp-<^wYiPJzG#3 z-FuQT!RkZrIew||p0Na!_q;Wucf1E(+9BaRIkX(93fpl`A9&9jn|sfD)}S=H_Y7$4 zQ}6lkLg77M5Kso)aCYx_54yBN!h23J7WR?pec(OoH}#(PT!7N(-qVZ;Rv-2~^?0<3 zk?SD>%6pca)jQsE?jhnm?X)1L3R`q$A9&BAzx1B>9EYmYz2{m?u=>z@meayyZNlXQ zltGW5);r#VG2)QudmhFjqF&fDe%lA$GqR!gyr&(d(Y+@H6RbY;o|9?Wur^^L0p&d( zCiIT?V2n51M#4nAti8e z=sJn@TO2B*9OYV9mJAx!x<0-D#M*>T0?Md&Oc5%o)g8H7F@;$D*19^X+SZ;o1h6)oZOK~?58=Q!A}T^$x`I+rHla$2)h zPTds8>u#nMYqGx1%}0%*AvdBV?Y>q0gwaMx6+tDD9%92luv5ZlE!VI9I)45L53RY@Cfr8=9=Z86d9sq|%{rI(S!wmu z-m#K}{0rMif*$r&Ev;m5v=IZKt?m_G%vz+CdN@jHX5djuae+rEod65A(fPTs#Cs3$ zxhqY`KjevBLTfsl?Lba|x)_T=y4tn_QTxD8fNHfhY2;5KP8QSk#HO$oldgP1Unh7` zdZU$hVnJ0`_tqzrmC@gYIIt>e&E1e9EN$||>m=51vkdk;(OEXs1j!NeY5BG`;W7d+ z|HN@dM@&7i*Ct~jsNpF2dGKl>>dH17#41NUFehqYl99)bB zdI!rhx`E0cR|di>;UNvQJ*a^mRt8dLLta|Pdi+DVTggVoa$kaMVJQazSn9G)LCi=D57hyCn_h)RaRp^uZ=5yk>?OZ=6N}fnUxZ_#cnJChnRqQ%f$kTmmmd7$#@PQa_yrCm z^Y;t5N{@c={GZHzA&#hR4>ktXN}n}$u|Hw0dD||+qv?!zNL6+ZBmJDfkse2%`5)^^ zCy;m7B+_Bn?t#x>=d;$?{~7u)7~$y{$>5^|hWXv1T8;Z#Ewb-w_05DwEG4zWNgUL^ zbfZ!mBSXk(TnprisVjBP`ZR8b#QII+=w?JOK)8PXZ9kwpXG(%NO!G84OmmX&FwIj~ zbTlQTbKfYRM2ZAGHS?4cdS|+qrfve%u3_v_-x6%+a1hHLgM}r1%1|z*OZ$TRlhvBe`Snp$TFHhYnQ1PnG<3_Iw-M+XN zZECMLjqDg~Tk(H)o0lK*HZM_4q-jb@Q$1L=Imn&b3RF5=a|?>BwZAzg*gapIzbKT( z&@vO^jUwuTiU_KWpO~-kuwK_>Zcs7%)8t{Jhyg)G9Ec{_Mlst*|2H$$mIwc62-dGj_o_6g9IkG!y%~O)u?~eE0pd!VXf@gr5OPrG% zwK>g&99pWQ@%*dVhjatkERc;pWEqf+0*U?MiXBgRtXl-K!G|mdvOyrDHP`Woh|}LI zWpOb1!ujpK^MlPth>MyujfNr451xtY-9|k(S!d8a%Jw}Bg$I83NaKJ7qC*UO?c#uU z(V^gMbCa@s`$+YPVjDV$5f5V_Wg7`4eV1TzsQXIDyQ4>uI`H=Kj}q(GQ?DY)Vi=x8 z_QoCLd}N6GqS>^ns9Mi|FoY4AAB)KQn-uW1Xl}(fPVx;k@@)^sM@R6tz9iIU@4hRcPgTG4)^-!Zz11C2p2TpE=QHg2B-v(6@ql4&~ zXdHoqwf(t)ZT|$)*23Cei%FecpCQ}+4@e!@_P>-^zxouDJgP`|%g#ILW_1T{ew(Q% zb3M)S8NuUNT|o^$O#sPCjuCgh?1HzDYNm>PNG4C1CX&m+?(^di@plLuZ%#SUCz413 z@vPuB=n%C3asA&u8L(f|^XHM!+Mo;RQ#;~YxaPKLd@CGv*MXS+tDvT*``5s3x0x&_ zO5W5y_m1GEpF*vpHes!7B<=qmVKn` zf`u2|-1Sgw|DL`rsJWjAYHoTotIXYWTX1tPg9tgn2zp~qZCHn<&*H_Ts zbo(uXV*9t>f9tNd-5T6}Yw$cD_REk>zkT*mJ-e%w($yxM!pR$Ca_+W+xoZOQ?E`le zPo3l_$GzOBKzF?zW!267Efmwu9r9}s{}hht|22q4iS_H4>ER^Y75!0D`{^5kn|s7m zVL#fXK*`=7W^`AFdUz{4@$s^1A~fwHbc?!M3pP0mQp}f;zh2C( zf9$Pd{z7ZywFysRl7lkHV&k`Nj%g}JVL5{imo=E8-;wj@lS{ie7f<1#QHVm$4CV> zUk9zq__Z^3?woFIq*v2-daR9A6^(c`eFq-AAtdid+qn65(AS87l~q7k z^xRse)U4LZDq9kXS#v)B!8XxhLvE>jtXdcFGng8+~ZW+AhADw{9b{ zWxV*_641(aZw_MHMXg!wOC`Bc1o62Jvf%5Ag^IJ5J76k8`^!;OoE8e>5djwmpHbmz z{sg8DEY8~!>sOo|z(UVzdAC?8fN)QV5apspnf_~_0E$ctFye!6)-E!9d)Zh~Xox^u zmGE114AMIWiZ8Qu_7^>BwRL-?eS27C#da-f?W1yjP%Ss0&_~Sh8L~=Bx27>_Eq_bO zNF_I)cLR00Qrp^$ZCI|_N{oCb^ga4fwPGbaAE$k=N!~E=q3BZbS z)ztAVPn)f#x>e6e-1kkaqrBwX;vz2`tHF8E8hK!8-;!9r(l)YG-S}?0D@R=1bP zrev`D`D?shtPBNFCSM8~7EI782r}#{_`Ztn2k?x7J|`Hp=2=pm9wgAN1y5Q&hhe0& zX&i>J(h^0uDKU-8$KeY(+(Np2B*fC93g#DSBOx76WvTr%5_N~9(t@4h_oR)Z#7&8q zXiAazs^N3hY0C)vVqzApVRze_DjSH5OQ1!s$U*9T$jbOAqHrl&P2xz}LO~zI#S@r> z;t3$D8SFjiheh3VQnOWGQI%i(tH~JYNwW|dBR+;wDL>K0P<=I3eMMD$Rkd8u)%RB` znU6|)2bC7$d`FWQKgC$JI~rc7?5{sVliIteKS5=nC=fJgwG@Q-I227Mjw9k%s}!-a zl`;oid;rr{BjZT&vM))CUlI{Vk_UZB=+4zBMZ}S0jW0=;UlI{Vk}Q=3;S7Y)OB(kT zh>vdi+MRd=JP`$Lle=DAQ7R1fqot@eY>uK!R$7`$AiPv;|GSjZDL)pKj#imaeVU=t z9~;OEDxIR2hKs{DqlLr(?OKro8bDKfdo`Jr8pCQHaX_jRL0FjPczWEop4e)uRf7^3 z#h|orpO|5z%hOzuIG(8EXxX4caEtm7DhTdI!QF+MQo-HTA*xv9tp-8}^3U^R59PTR zUrH8Sdpqu-`r?9(@fEC1p=&Bd5Cx-!6H-mY%>@&F;8Sg^P_0`uy#8?3&cx8H!asbh zUt$FHSbwgn_*rv-^=F<9nJPmz4s&DFH}wF`VcB&3`UgX2LRA@4DO(7)L%)ir;ZHnr zCz0Y4zE1I((C*G*G!A!*?=_3xxogCPU5)#GJZI-fGNb6q=13EgRd`86IVl!$T4RN}))kPJl9%W#w5C|A3<%emzh{RvP ztxcGDs-cz5L6>Qq+ZrRFDti(GSy!|t+fISj))qE-)thjr3XSV|#ZFw3uP!Sk1) zMw>nEotSBDQO6qk-QI)08AIDN3_4M3K7m!5tTY^ATGjvCu>jucTgPS5?I>EvotkA#XoIsv5&=8@7>e zQn#@S{FFDO69F0c4)YTk+~mukoTh}$DO3nqn0zEg!^zlELq(@4Aqax&9B|2<{=m>S zJozP2e4TM2C=@&_MQDHb=TIg{MO_+9z+Wo&xc8z3VeX{&)#x`8 z-hoJXmuPkEFJeFzE%rdUpEYtJ2h5EvO4Rj{x7HXXj67fo z%w1&Ue)p$?Ec*pU?mG^aJJ!g3>A`XjHF8@HmiylpL!E#8<3X1DEhG1R2h07mkvsQb zxo{V4^t*KekDWqqs+a z?wT~rV<<+ToA(U1SBtHK6s5;Lh>E8_h|=vYq6COaI|LCWK+$p;B|sThR-zDuf;K9Q zWOdbyu2vyJdUT`=k=@-W*^(Kqoj$L=SC5O23S&R5Omz4 zcvO(GBI628Rfv#k<+xgfLDV0El)!jbs{xNH%eEjeJfvV=af0Uw91m)9>76;Av zLh*EQZr~9?$#aL~AxX`Y0Qu5a>M36l_uWrXzAZi(A}D2CsOPH;p==W9Y0Kcnxb=`P zITCqZO6wEa@#~CQ=~W}MXW-da=f_Drzfsd zk^p}F1tIY^kY3m`t!>Wh0(F+`kR(f*CQ3?2lM9_&I+lg2l8Ohiw%RnhF+_4z4O`Go zl*SFxs^tUs*rHBr>>NQavAzB!ErA^IJfWV)5=SG_k64bKee{MCt)`JUYVFj>8(!3N z6P`i$hsj|IryhWzOv+1?-X{sY#jT$!68CQ%8;MK33dZfF0ng*3Hn#}<`B^DFJTSz&2nzGYF%JJo8dNy)I3yOR*)vef~Y;Bj; z=7w@6?!Z@15%*l8?pw*;@+~}aV5zOB96=EdLPLN~!L437?i%T-2i2RfIR&aKAxV_n zq>Wg-%GfAYu8=`uA~oFFVnCp2dNwmzTQ4!iR z^iSLk(gUp~aew@Vt!k%yCQJP!?g``7+i7QCPB%oF_FdG8KMH|WJ0lT2d>yvHVGA6# zz+np-`SD z*lhVL0Hoi2_`Q!G$z7D?EXZ13Xt#{XA7jbRDz-R^3s+i}+byNYu%Os7x46`mRqQIr zA{|p5Ira%a6(C+%aAlUOz){S|Sq>yBc01gqmh^%mJ7cqob1c>}d$CKzsUW`m%KA3H zynxbW<+|)nlu;Fs3IkK3&;{la7NOXp5{&xW4@BOC5Yi|gyReIrt=pw6vj`fD3#`!b zRPWgisjh`Ai|Qgjkd?&>W)$0%NBN03OE|@z9Iy9r_yob}@BxC&fHuH?;Fq3nw>aFc z61ZQE-C0nEIxYjoiHK!vC|}b(vMj5hki02Y3oa+Ps|H~w*TmIz?x?k$^S9h}Qe&>T zK0o)iTj_fGTuG0XK+`H!;MuKjzw^=W-rJg6R4`?1=~s>&14KLqI>R8~{t zDc8Bhu4x1_Q~+?&RE3ctpr98gk|CfZKk>=XOoyY;o>ffg7P_2dB7|n5kj|A9npNn? zzMQP6%Bh0jMi64A5tMpJ1afDL3`sp01wCXc$w{Vf}*TKZJvEaazSaf z)9$hhqn7FtU2+hhF+hl%<)C^%C6I_b=0Egx-z{V%XT|4ML`u56}gMaWN_Fta!(6-w%AEi^L$euim7qe zl-^Q`d@aR^cC^D!4HypwSDgp5aOQGmI zb_Wzg(dB?1K-Tq>!+anegMuhO&piSXC_2;&w6G$Q@}a392C*#L-zXwTDn*8jAl8Kp zl^}%u6&d`&tZU{EmO=>#Wq(BvWq(BvWq-qD!*HWeiar8e8g5ET-6bUsrTmsN4Np79n#Bsz69??0geT10GtNc0(cEz7vKwk(E~JX&{FUN)&iyh z?glIY`~|QM@TZHx54iLa@B@Aa*abN1Qt%Jdv>AYLfU`5f54aDzAxi-7$^t*pao^Pd zcoOcnS^&fFLTVS_N7ybI9jR$sv6d7EczZGU0as#gLJ8nv7x)1aut?hgc+{2P2mJPT z;0Ju|8t~)Yk;hhpAFu{5Q>6j^^n36F#$m^O9bj<{_yHfS1wY`IH-H~-9Nx2y##@fL zcq=sy@IJgCoCf&u2Jiz~ZU;Z$rFViK@Qy!$ACOLF>;fElANU8OK5(>c9N>L8J}nLK zW55!?2^+x=cs$P8YXF@2F!%wx0lNU}9|8Z7nzrLn@B?Z%@-z*Qz8g>i7>DzU>j1w1 zYyh0J3H*RHPk|rsEx_m@ns)4F@B=ObOar_Zumtc+z&gN*INZGf&;{56_y}MZ;Eboi zKUC8`1dIb5{4DqZp9CxcjNJ-;z&p2rAMk_i;0H|E0e-?i4}QGkx#k7%175xp{D6c1 z27Zda2!6m{UI9N~H$MK|0(kXn;0G*e0Y7eKhrSMez}w#dKj6SO!4G&2U>#rqU;|(` zU<<`}fgkWjKzdX6E5JCw?6<%V_@}qQ4|q>2_yO;K2mFAa0JZ>*ei!_JnSjy5Q4YX3 z!1n;t0FQkS{D6xA>i};CYyf-{umy0~```z>05BRa!`%oN2lyIb8sLx*zz=vnU>%?b zumP|Mum!OHhu{aC1sENpX{!L^0Jj6C0saD50yzC6@B>x=HUQoP*aG+%U>D#kfYBo~ z?Q_65z)@}B2fPZf1n{$u!4F6ml8Y;AA|Bg2>N#>`j4AS2=x=~tW#kXPQrCYk=m{7bGEMYFIz0wkIZ_w%MLH`N#2}XLhFaJ%T4_xf^ zjxy4v`m+8(9{_qJ%BkBg+^fsq3;Nffih*pIJ#_sd{;B)tdeD!!G&Fq^=uH?)L-FqdeJ#e+Q1rc^ z&%#(6iXMYGL|8#+dOYacFAq&m2fd;=G~EUIbd2Sp@?Q`752c~$n?V0-S!nt$(A_IT z)Axct<#*@{P4>^z?H_|VP}S95Z-UW(A|~km5fA!?YrNhWCjJDSKOOYVt3uOVpzo>* zO7w8ji_j(ge_4ix7{`P{NatGua+o#*tzr=P5h7P{Odv2{^a#; zG|~U0(>H-$4f<%4{E@o+U7&mFz20+8^r1xUzBdY7>vX9_lBm&gTCQ@ zulKJe{T|o#O9%Z7%ze)@<)5VI?*jcI%!QYj=<{{@deCpe9Qk~c{F%D^O`vZBeU_0f zhd0^(gZ?kj=NRdR@pUigk(hgj;*Y^S!0Die;*SS?K@a@tpu2nEcY%Hf=)X1US1gJr z$A8eD1pOwHeXiB*vkCN5aF0-LRB>&OS{uP6JnCbWsz*Q!G zr_LV_`Yn%py$%ySSEr|g{@D|u+n)>c{(lb5zaI2-+}q4I$+zk9H-WzPNw4<{Q~5vC z{bLvCDVsvm_kw;D?vX;-F9!EuH-Wy)l>cHq|9H^f-0b!K0sW|N{Py%G1!(@64!ZR@ zulFaDetUHNT%cRFdcEsR?XN;_f9pYCw;gMdCjJhce-r2zHhR5xndmp`^j)C81$wPX z|24Y)dqJOtd$d9mznox^{xP_Rya99^(dH{(kq|G+7Z3XVpof~DrGx%w&~GsEhp*H1 zbAfJo!Rx)kM9p{N)^l?UdrZ4|Zpsxh|Vk13#q0YYx^rt|lPmTHNr^r`+(CJ?E zY!iKoPLIJo@Ts^*jWE)~f7Ip2gFdJ!G(8>kuRsqqzPLai+#H&|9`x}&&^LiTrw95j z(Ct0Y_kv#413d=!@OSq>j|Y8w5A<}vu}ejf}^m9dW7r_Te!LA*OM9FUOT#yEwj@GyZ|&K0T$pzWN`{_28dh zoJC?18KyB@#;}B8CBr&~^$Z&rF4Mv^y5`K9b(UpZ#&UPD%WXL`Ha<3P;v~0-O}ct= zTx?u??BwwhFOv88F9I?*s){tEjL^ch=Aifp-JcA}wFs@B?nh>Pf8F2A_yL-#H#2^q zUf*VXq^A7Fj6XtC{$<9)n=M9+3`b~#HA_(Zky>L={1B}rD1NB6Y_ybV{2!r3X{!C2 z@wjnoG-6~pLK~(My?2Lgci&%BebKnHm@EBU@#jA-@iRF+eW!%vTz|4eh&>Mop2ql< zT&^29{ba_!IbI^>Fg}U#nXHeJe?H?~V`M_qsJNCg{)}-l{vG4<7=Qo65~0dlK{-mwRP;@yr&%-!nde^;G%Z%lJ?HI3TJN)E)%lM~w09NJwnekh>zD|_lw8(HN|HOKU5YOlljA8sj zzj{A`@wF_6rvcjOjQ^hT;#n8uBr^VPwx@W;1w5^lQn`LVM&>K_&LFs$@%OSE)#EH< z{0KjN=$V-Cx4Wbqu||R5?-)PH&pvAzf9x2UeyIc+?ePc;(jVT<>GS;R_hH7r{iqb6 z?EEC-$NQz<%J>`o^lxJPdt6>MAEdnqR4yC)n`#$(7(a&b$`6M`$n=lgE%hnnavjC^ z6a4f%p7ATWUbxw4;~C%SXSd0WztvC9*^K}9pJj&P86<)>;KPE9Q}a3fQa?FM82_E0 z-!5l-cVh&$k(Ww;%pv#;-Y5%3-qhJ>zRwzIf(~B;nX260Qx>G>c5H{znS@ zQ0<8aBu4cc!+;+SJ+Hc1;>Fq^g2yxdqj?f9_Pii?I^#cIBk{8&(9RWjju^mvPX8Pm zKA zB)(n(?IMBahyl1c{kUr+QtXjH@Os7{w_f6xg-Q4z;~%?G#=nq2dy(;j7fXcLON8K? zjK6$>#M69;u5TDWEJ4OqdG|3ssY>F-o(Tj;43PF&{|AXz`6e*__H>CCdz=uQ#rW}S zC0_Z-g^Yi!R^k)6Tn@%>vP-GLGx zx6YUN4>3N`wS)1mUnS#W?+=3SFn$y3qx$V%7=PTgGQDb#M?^|H%$q3jVh<&PV;O(- z5{Xy(#52Bu+x2MH|2)QDb(2hAFM)P35Ui}Uc_=-ZW&koST^uu0+VakaQZ~{lfQDB+Zg{1 z7gW{D1B{PgKVi4fni>D2UwPkW{MT$xu@?(@bTi(QC^J;@wQQ%W)aB02jm_5ZMy)-s z0Iyp*GhIcQ*@bv7uT;y-%yDGq6*`t@6=vqpd$pNa?sB{b%dZp1PK%p5DR`pHT%6yK zndNk5t<1!mrg&LB*NK-bGjrTUMJvH#h-K1A52mC=c;mkiI?+43>Xq_R#QCrd@eVPx zDAiw62CX#HX(u|pXGn}m%fr*yX>XD z7u+c*Uu#E5yxE3V;R{Off_tf*IE*jXBFbsAvkJ56ooV|bae|0ur-LOjN^(dWq>^vw zX~HTR0Dz$XyTL3O@A1>?lj40#ybq2%>3!frd2C3wP(Zv#N1CW} z0uTgFyig8Ps+Z91q?~x)P0Qk!Yvr5$NG@KmHNDne>@F-6uMOLsx@Z^+X(bb6$ye)8 z`Sw7a#G8MVAu81AV#C4ZN*$T`I9j7nDGrfRE6l$jn?TMH9?gOx)hnG zEUGxe0dfL#%gmfJFC)`xV;8k0FMzwIr_N$$&76~R!OWzT%nN4EUT96vOi!AbVihi| z&L801rx7&Nvi~dLf~?MA5N%I55BaNTaQwnJzb~(xkE09o3v%JS@&E#=)WpO&DRXDe z%A6cKIW|G?FBG<#row__wv*}zuV%9t>0z03(^E5j{SJysy-qrvU83RalTx$nveM!b z*v^$}Mw3Kj$!Aiqd~R-%7WCW*W`iQAE#@*slm(gQS6jwTfKph^Cn;oRmb$XCFVD=* zzdSP+he!BSj#rrlo(I7>`PY~47=aK61Sk!~Ngxz492YdpVK~cy6RJLqqbRlMSP4d} zX5v?HT^sKAICaok_HSX7R(c0o5=G=8E$BL-y3a)9NTn`kc2S8L$Lw6UnVES-j$*R2 z(}k{_iF#Y0_#C@yk=hvrAU`*A? zaN!_F>~L|7UK4oeiY|cqLva`dvys|*U!Yt~?+$p#_SK8(L_(bGAhN+pKyXUGQ&Wh7 z`Zm=+)tWvAQUXK65Mzb4JR1WIrUlFm{kXzm7=wdLr^QIa>8MbgFvPh;lrUW#r($H& zZQ<9k25n}dN_-UkJQtE~EyF|uBYkk^HE1Z64`|{*`y`7|PWRM+Y7!l_njV_EX|&TE zckp&9rvRCm+2vU@?Gb191Xi>vV({vOCemPrnp>EiZ_jb#JRWPgJ=?91DkzV6aDt6+ zUP;h%Zw%FlCZ)xet}Jq8EeCWtCCpbLyhU%1%`0}tmN*?HcBgBl7OSI{y9)|)CKlvq zB0+vuX}%Vlv$7b%By>3?rHuO^k&GjmpgHY@S;WAhl0ugjOH*Mj7Qxs&2M0>+*;=g2 zUXCcusgc@&S!I?MYtQFdbbbz`shE@@r_+){g^^WOQ2~TOG-UxTg`DN3rCKbV&tk_6 z;D2(_^KIPf<5{M>)H=0-7RD=p+g{T}x1mPGqar zGdZ1F=U1@Rz<&(F{`@t-kxlT}OkNfysAN)Lsj#|B1zi$zittd~*!e>8^_q{pg8 z{zi*TprA^}Y?_KIc$*)83-c>jrx+P3J_Yaf<5%nJ3g+_jU?oQJsrW;F{Ayo=f{|RFBEfNKL1hJ z*AN(rAGJYosRyNB%c$}1Z$S-3+5&_pT@!$7P@hSKNNJjo;A_hL@ zSLu`l|F{mOtm&oG*XemJH suljF1Hq>>ODdqp}aGApZ8XOFl%2%PtJyqEij^Mr_G9?3@A0QMGSQUCw| literal 0 HcmV?d00001 diff --git a/testsuite/resources/BouncingBall3/binaries/x86_64-windows/BouncingBall.dll b/testsuite/resources/BouncingBall3/binaries/x86_64-windows/BouncingBall.dll new file mode 100644 index 0000000000000000000000000000000000000000..459896043326e9eec67a1ba485b2c447faf6b976 GIT binary patch literal 168448 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

)~K=mi|75-aT0;)~Pgh*p*y_ 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/BouncingBall3/documentation/index.html b/testsuite/resources/BouncingBall3/documentation/index.html new file mode 100644 index 000000000..109a9e089 --- /dev/null +++ b/testsuite/resources/BouncingBall3/documentation/index.html @@ -0,0 +1,146 @@ + + + BouncingBall + + + +

+ +

BouncingBall

+ +

The BouncingBall implements the following system of equations:

+ +
der(h) = v
+der(v) = g
+
+when h <= 0    then h := 0 and v := -e * v
+when v < v_min then h := 0 and v := 0
+
+ + +

with the variables

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableStartUnitCausalityVariabilityDescription
timeindependentcontinuousSimulation time
h1moutputcontinuousPosition of the ball
der(h)m/slocalcontinuousDerivative of h
v0m/soutputcontinuousVelocity of the ball
der(v)m/s2localcontinuousDerivative of v
g-9.81m/s2parameterfixedGravity acting on the ball
e0.7parametertunableCoefficient of restitution
v_min0.1m/slocalconstantVelocity below which the ball stops bouncing
+ +

The plot shows the trajectories of the output variables computed with fmusim.

+ + 
fmusim --interface-type me --solver cvode --output-interval 0.05 --output-file BouncingBall_out.csv BouncingBall.fmu
+ +

plot

+ +
+ + \ No newline at end of file diff --git a/testsuite/resources/BouncingBall3/documentation/result.svg b/testsuite/resources/BouncingBall3/documentation/result.svg new file mode 100644 index 000000000..811aa9779 --- /dev/null +++ b/testsuite/resources/BouncingBall3/documentation/result.svg @@ -0,0 +1 @@ +00.5100.511.522.53−4−202time [s]hv \ No newline at end of file diff --git a/testsuite/resources/BouncingBall3/modelDescription.xml b/testsuite/resources/BouncingBall3/modelDescription.xml new file mode 100644 index 000000000..5284c057d --- /dev/null +++ b/testsuite/resources/BouncingBall3/modelDescription.xml @@ -0,0 +1,75 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testsuite/resources/BouncingBall3/sources/buildDescription.xml b/testsuite/resources/BouncingBall3/sources/buildDescription.xml new file mode 100644 index 000000000..0417ee4e5 --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/buildDescription.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/testsuite/resources/BouncingBall3/sources/config.h b/testsuite/resources/BouncingBall3/sources/config.h new file mode 100644 index 000000000..c655ac7dd --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/config.h @@ -0,0 +1,34 @@ +#ifndef config_h +#define config_h + +// define class name and unique id +#define MODEL_IDENTIFIER BouncingBall +#define INSTANTIATION_TOKEN "{1AE5E10D-9521-4DE3-80B9-D0EAAA7D5AF1}" + +#define CO_SIMULATION +#define MODEL_EXCHANGE + +#define HAS_CONTINUOUS_STATES +#define HAS_EVENT_INDICATORS + +#define SET_FLOAT64 +#define GET_OUTPUT_DERIVATIVE +#define EVENT_UPDATE + +#define FIXED_SOLVER_STEP 1e-3 +#define DEFAULT_STOP_TIME 3 + +typedef enum { + vr_time, vr_h, vr_der_h, vr_v, vr_der_v, vr_g, vr_e, vr_v_min +} ValueReference; + +typedef struct { + + double h; + double v; + double g; + double e; + +} ModelData; + +#endif /* config_h */ diff --git a/testsuite/resources/BouncingBall3/sources/cosimulation.c b/testsuite/resources/BouncingBall3/sources/cosimulation.c new file mode 100644 index 000000000..782edf1b2 --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/cosimulation.c @@ -0,0 +1,691 @@ +#include // for calloc(), free() +#include // for DBL_EPSILON +#include +#include +#include +#include "config.h" +#include "cosimulation.h" + +#if FMI_VERSION == 3 +#include "fmi3Functions.h" +#endif + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#ifdef CALL +#undef CALL +#endif + +#define CALL(f) do { const Status status = f; if (status != OK) return status; } while (false) + + +ModelInstance *createModelInstance( + loggerType cbLogger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType) { + + ModelInstance *comp = NULL; + + if (!instanceName || strlen(instanceName) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, "?", Error, "error", "Missing instance name."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instance name."); +#endif + } + return NULL; + } + + if (!instantiationToken || strlen(instantiationToken) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Missing GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instantiationToken."); +#endif + } + return NULL; + } + + if (strcmp(instantiationToken, INSTANTIATION_TOKEN)) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Wrong GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Wrong instantiationToken."); +#endif + } + return NULL; + } + + comp = (ModelInstance *)calloc(1, sizeof(ModelInstance)); + + if (comp) { + comp->componentEnvironment = componentEnvironment; + comp->logger = cbLogger; + comp->intermediateUpdate = intermediateUpdate; + comp->lockPreemption = NULL; + comp->unlockPreemption = NULL; + comp->instanceName = strdup(instanceName); + comp->resourceLocation = resourceLocation ? strdup(resourceLocation) : NULL; + comp->status = OK; + comp->logEvents = loggingOn; + comp->logErrors = true; // always log errors + comp->nSteps = 0; + comp->earlyReturnAllowed = false; + comp->eventModeUsed = false; + } + + if (!comp || !comp->instanceName) { + logError(comp, "Out of memory."); + return NULL; + } + + comp->time = 0.0; // overwrite in fmi*SetupExperiment, fmi*SetTime + comp->type = interfaceType; + + comp->state = Instantiated; + + comp->newDiscreteStatesNeeded = false; + comp->terminateSimulation = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->valuesOfContinuousStatesChanged = false; + comp->nextEventTimeDefined = false; + comp->nextEventTime = 0; + + setStartValues(comp); + + comp->isDirtyValues = true; + + return comp; +} + +void freeModelInstance(ModelInstance *comp) { + + if (!comp) return; + + if (comp->instanceName) free((void*)comp->instanceName); + + if (comp->resourceLocation) free((void*)comp->resourceLocation); + + if (comp->prez) free(comp->prez); + + if (comp->z) free(comp->z); + + if (comp->x) free(comp->x); + + if (comp->dx) free(comp->dx); + + free(comp); +} + +static Status s_reallocate(ModelInstance* comp, void** memory, size_t size) { + + if (size == 0) { + if (*memory) { + free(*memory); + } + *memory = NULL; + return OK; + } + + void* temp = realloc(*memory, size); + + if (!temp) { + logError(comp, "Failed to allocate memory."); + return Error; + } + + *memory = temp; + + return OK; +} + +Status configurate(ModelInstance* comp) { + + (void)comp; + +#ifdef HAS_EVENT_INDICATORS + comp->nz = getNumberOfEventIndicators(comp); + + if (comp->nz > 0) { + CALL(s_reallocate(comp, (void**)&comp->prez, comp->nz * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->z, comp->nz * sizeof(double))); + } + + CALL(getEventIndicators(comp, comp->prez, comp->nz)); +#endif + +#ifdef HAS_CONTINUOUS_STATES + comp->nx = getNumberOfContinuousStates(comp); + + if (comp->nx > 0) { + CALL(s_reallocate(comp, (void**)&comp->x, comp->nx * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->dx, comp->nx * sizeof(double))); + } +#endif + + return OK; +} + +Status reset(ModelInstance* comp) { + + comp->state = Instantiated; + comp->startTime = 0.0; + comp->time = 0.0; + comp->nSteps = 0; + comp->status = OK; + setStartValues(comp); + comp->isDirtyValues = true; + + return OK; +} + +#define EPSILON (1.0e-5) + +static double fmiAbs(double v) { + return v >= 0 ? v : -v; +} + +static double fmiMax(double a, double b) { + return (a < b) ? b : a; +} + +bool isClose(double a, double b) { + + if (fmiAbs(a - b) <= EPSILON) { + return true; + } + + return fmiAbs(a - b) <= EPSILON * fmiMax(fmiAbs(a), fmiAbs(b)); +} + +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected) { + + if (actual != expected) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = %d. Expected %d.", f, arg, actual, expected); + return true; + } + + return false; +} + +bool invalidState(ModelInstance *comp, const char *f, int statesExpected) { + + UNUSED(f); + UNUSED(statesExpected); + + if (!comp) { + return true; + } + + // TODO: add missing states and check state + return false; + +// if (!(comp->state & statesExpected)) { +// comp->state = modelError; +// logError(comp, "%s: Illegal call sequence.", f); +// return true; +// } +// +// return false; +} + +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p) { + + if (!p) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = NULL.", f, arg); + return true; + } + + return false; +} + +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]) { + + if (nCategories > 0) { + + if (categories == NULL) { + logError(comp, "Argument categories must not be NULL."); + return Error; + } + + for (size_t i = 0; i < nCategories; i++) { + + if (categories[i] == NULL) { + logError(comp, "Argument categories[%zu] must not be NULL.", i); + return Error; + } else if (strcmp(categories[i], "logEvents") == 0) { + comp->logEvents = loggingOn; + } else if (strcmp(categories[i], "logStatusError") == 0) { + comp->logErrors = loggingOn; + } else { + logError(comp, "Log categories[%zu] must be one of \"logEvents\" or \"logStatusError\" but was \"%s\".", i, categories[i]); + return Error; + } + } + + } else { + + comp->logEvents = loggingOn; + comp->logErrors = loggingOn; + + } + + return OK; +} + +static void logMessage(ModelInstance *comp, int status, const char *category, const char *message, va_list args) { + + if (!comp->logger) { + return; + } + + va_list args1; + int len = 0; + char *buf = ""; + + va_copy(args1, args); + len = vsnprintf(buf, len, message, args1); + va_end(args1); + + if (len < 0) { + return; + } + + va_copy(args1, args); + buf = (char *)calloc(len + 1, sizeof(char)); + len = vsnprintf(buf, len + 1, message, args); + va_end(args1); + + if (len >= 0) { + // no need to distinguish between FMI versions since we're not using variadic arguments +#if FMI_VERSION < 3 + comp->logger(comp->componentEnvironment, comp->instanceName, status, category, buf); +#else + comp->logger(comp->componentEnvironment, status, category, buf); +#endif + } + + free(buf); +} + +void logEvent(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logEvents) return; + + va_list args; + va_start(args, message); + logMessage(comp, OK, "logEvents", message, args); + va_end(args); +} + +void logError(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logErrors) return; + + va_list args; + va_start(args, message); + logMessage(comp, Error, "logStatusError", message, args); + va_end(args); +} + +#define GET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Getting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef GET_FLOAT32 +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + GET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef GET_INT8 +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef GET_UINT8 +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef GET_INT16 +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int16"); + +} +#endif + +#ifndef GET_UINT16 +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef GET_INT32 +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef GET_UINT32 +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef GET_INT64 +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef GET_UINT64 +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef GET_BOOLEAN +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef GET_STRING +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("String"); +} +#endif + +#ifndef GET_BINARY +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index) { + UNUSED(sizes); + GET_NOT_ALLOWED("Binary"); +} +#endif + +#define SET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Setting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef SET_FLOAT32 +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef SET_FLOAT64 +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float64"); +} +#endif + +#ifndef SET_INT8 +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef SET_UINT8 +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef SET_INT16 +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int16"); +} +#endif + +#ifndef SET_UINT16 +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef SET_INT32 +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef SET_UINT32 +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef SET_INT64 +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef SET_UINT64 +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef SET_BOOLEAN +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef SET_STRING +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("String"); +} +#endif + +#ifndef SET_BINARY +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char *const values[], size_t nValues, size_t* index) { + UNUSED(size); + SET_NOT_ALLOWED("Binary"); +} +#endif + +#ifndef ACTIVATE_CLOCK +Status activateClock(ModelInstance* comp, ValueReference vr) { + UNUSED(comp); + UNUSED(vr); + return Error; +} +#endif + +#ifndef GET_CLOCK +Status getClock(ModelInstance* comp, ValueReference vr, bool* value) { + UNUSED(comp); + UNUSED(vr); + UNUSED(value); + return Error; +} +#endif + +#ifndef GET_INTERVAL +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier) { + UNUSED(comp); + UNUSED(vr); + UNUSED(interval); + UNUSED(qualifier); + return Error; +} +#endif + +#ifndef ACTIVATE_MODEL_PARTITION +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime) { + UNUSED(comp); + UNUSED(vr); + UNUSED(activationTime); + return Error; +} +#endif + +#ifndef GET_PARTIAL_DERIVATIVE +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + UNUSED(comp); + UNUSED(unknown); + UNUSED(known); + UNUSED(partialDerivative); + logError(comp, "Directional derivatives are not supported."); + return Error; +} +#endif + +Status getFMUState(ModelInstance* comp, void** FMUState) { + + CALL(s_reallocate(comp, FMUState, sizeof(ModelInstance))); + + memcpy(*FMUState, comp, sizeof(ModelInstance)); + + return OK; +} + +Status setFMUState(ModelInstance* comp, void* FMUState) { + + ModelInstance* s = (ModelInstance*)FMUState; + + comp->startTime = s->startTime; + comp->stopTime = s->stopTime; + comp->time = s->time; + // instanceName + // type + // resourceLocation + + comp->status = s->status; + + // logger + // intermediateUpdate + // clockUpdate + + // lockPreemption + // unlockPreemption + + // logEvents + // logErrors + + // componentEnvironment + comp->state = s->state; + + comp->newDiscreteStatesNeeded = s->newDiscreteStatesNeeded; + comp->terminateSimulation = s->terminateSimulation; + comp->nominalsOfContinuousStatesChanged = s->nominalsOfContinuousStatesChanged; + comp->valuesOfContinuousStatesChanged = s->valuesOfContinuousStatesChanged; + comp->nextEventTimeDefined = s->nextEventTimeDefined; + comp->nextEventTime = s->nextEventTime; + comp->clocksTicked = s->clocksTicked; + + comp->isDirtyValues = s->isDirtyValues; + + comp->modelData = s->modelData; + + comp->nSteps = s->nSteps; + + comp->earlyReturnAllowed = s->earlyReturnAllowed; + comp->eventModeUsed = s->eventModeUsed; + comp->nextCommunicationPoint = s->nextCommunicationPoint; + + if (comp->nx > 0) { + memcpy(comp->x, s->x, s->nx * sizeof(double)); + memcpy(comp->dx, s->dx, s->nx * sizeof(double)); + } + + if (comp->nz > 0) { + memcpy(comp->z, s->z, s->nz * sizeof(double)); + } + + comp->nSteps = s->nSteps; + + return OK; +} + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent) { + +#ifdef HAS_CONTINUOUS_STATES + if (comp->nx > 0) { + + CALL(getContinuousStates(comp, comp->x, comp->nx)); + CALL(getDerivatives(comp, comp->dx, comp->nx)); + + // forward Euler step + for (size_t i = 0; i < comp->nx; i++) { + comp->x[i] += FIXED_SOLVER_STEP * comp->dx[i]; + } + + CALL(setContinuousStates(comp, comp->x, comp->nx)); + } +#endif + + comp->nSteps++; + + comp->time = comp->startTime + comp->nSteps * FIXED_SOLVER_STEP; + + // state event + *stateEvent = false; + +#ifdef HAS_EVENT_INDICATORS + if (comp->nz > 0) { + + CALL(getEventIndicators(comp, comp->z, comp->nz)); + + // check for zero-crossings + for (size_t i = 0; i < comp->nz; i++) { + *stateEvent |= + (comp->prez[i] <= 0 && comp->z[i] > 0) || + (comp->prez[i] > 0 && comp->z[i] <= 0); + } + + // remember the current event indicators + double* temp = comp->prez; + comp->prez = comp->z; + comp->z = temp; + } +#endif + + // time event + *timeEvent = comp->nextEventTimeDefined && comp->time >= comp->nextEventTime; + + bool earlyReturnRequested; + double earlyReturnTime; + + // intermediate update + if (comp->intermediateUpdate) { + comp->intermediateUpdate( + comp->componentEnvironment, // instanceEnvironment + comp->time, // intermediateUpdateTime + false, // intermediateVariableSetRequested + true, // intermediateVariableGetAllowed + true, // intermediateStepFinished + false, // canReturnEarly + &earlyReturnRequested, // earlyReturnRequested + &earlyReturnTime); // earlyReturnTime + } + + return OK; +} diff --git a/testsuite/resources/BouncingBall3/sources/cosimulation.h b/testsuite/resources/BouncingBall3/sources/cosimulation.h new file mode 100644 index 000000000..fda1ebf99 --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/cosimulation.h @@ -0,0 +1,5 @@ +#pragma once + +#include "model.h" + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent); diff --git a/testsuite/resources/BouncingBall3/sources/fmi3Functions.c b/testsuite/resources/BouncingBall3/sources/fmi3Functions.c new file mode 100644 index 000000000..b4ad5fbb2 --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/fmi3Functions.c @@ -0,0 +1,1446 @@ +#if FMI_VERSION != 3 +#error FMI_VERSION must be 3 +#endif + +#include +#include +#include +#include +#include + +#include "config.h" +#include "model.h" +#include "cosimulation.h" + +// C-code FMUs have functions names prefixed with MODEL_IDENTIFIER_. +// Define DISABLE_PREFIX to build a binary FMU. +#if !defined(DISABLE_PREFIX) && !defined(FMI3_FUNCTION_PREFIX) +#define pasteA(a,b) a ## b +#define pasteB(a,b) pasteA(a,b) +#define FMI3_FUNCTION_PREFIX pasteB(MODEL_IDENTIFIER, _) +#endif +#include "fmi3Functions.h" + +#define ASSERT_NOT_NULL(p) \ +do { \ + if (!p) { \ + logError(S, "Argument %s must not be NULL.", xstr(p)); \ + S->state = Terminated; \ + return (fmi3Status)Error; \ + } \ +} while (0) + +#define CALL(f) do { \ + const Status s = f; \ + if (s > status) { \ + status = s; \ + } \ + if (status == Discard) { \ + goto TERMINATE; \ + } else if (status == Error) { \ + S->state = Terminated; \ + goto TERMINATE; \ + } else if (status == Fatal) { \ + S->state = StartAndEnd; \ + goto TERMINATE; \ + } \ +} while (false) + +#define GET_VARIABLES(T) \ +BEGIN_FUNCTION(Get ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +if (nValues > 0) ASSERT_NOT_NULL(values); \ +if (S->isDirtyValues) { \ + CALL(calculateValues(S)); \ + S->isDirtyValues = false; \ +} \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(get ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#define SET_VARIABLES(T) \ +BEGIN_FUNCTION(Set ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(set ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (nValueReferences > 0) S->isDirtyValues = true; \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#ifndef max +#define max(a,b) ((a)>(b) ? (a) : (b)) +#endif + +#ifndef DT_EVENT_DETECT +#define DT_EVENT_DETECT 1e-10 +#endif + +// --------------------------------------------------------------------------- +// Function calls allowed state masks for both Model-exchange and Co-simulation +// --------------------------------------------------------------------------- +#define MASK_AnyState (~0) + +/* Inquire version numbers and set debug logging */ +#define MASK_fmi3GetVersion MASK_AnyState +#define MASK_fmi3SetDebugLogging MASK_AnyState + +/* Creation and destruction of FMU instances */ +#define MASK_fmi3InstantiateInstantiateModelExchange MASK_AnyState +#define MASK_fmi3InstantiateCoSimulation MASK_AnyState +#define MASK_fmi3InstantiateScheduledExectuion MASK_AnyState +#define MASK_fmi3FreeInstance MASK_AnyState + +/* Enter and exit initialization mode, terminate and reset */ +#define MASK_fmi3EnterInitializationMode Instantiated +#define MASK_fmi3ExitInitializationMode InitializationMode +#define MASK_fmi3EnterEventMode (ContinuousTimeMode | StepMode) +#define MASK_fmi3Terminate (ContinuousTimeMode | StepMode | StepDiscarded | EventMode | ClockActivationMode | ReconfigurationMode) +#define MASK_fmi3Reset MASK_AnyState + +/* Common Functions */ + +/* Getting and setting variable values */ +#define MASK_fmi3GetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3GetFloat64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetBoolean MASK_fmi3GetFloat32 +#define MASK_fmi3GetString MASK_fmi3GetFloat32 +#define MASK_fmi3GetBinary MASK_fmi3GetFloat32 +#define MASK_fmi3GetClock MASK_AnyState + +#define MASK_fmi3SetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3SetFloat64 MASK_fmi3SetFloat32 +#define MASK_fmi3SetInt8 (Instantiated | ConfigurationMode | ReconfigurationMode | InitializationMode | EventMode | StepMode | ClockActivationMode | Terminated) +#define MASK_fmi3SetUInt8 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetBoolean MASK_fmi3SetInt8 +#define MASK_fmi3SetString MASK_fmi3SetInt8 +#define MASK_fmi3SetBinary MASK_fmi3SetInt8 +#define MASK_fmi3SetClock MASK_AnyState + +/* Getting Variable Dependency Information */ +#define MASK_fmi3GetNumberOfVariableDependencies MASK_AnyState +#define MASK_fmi3GetVariableDependencies MASK_AnyState + +/* Getting and setting the internal FMU state */ +#define MASK_fmi3GetFMUState MASK_AnyState +#define MASK_fmi3SetFMUState MASK_AnyState +#define MASK_fmi3FreeFMUState MASK_AnyState +#define MASK_fmi3SerializedFMUStateSize MASK_AnyState +#define MASK_fmi3SerializeFMUState MASK_AnyState +#define MASK_fmi3DeserializeFMUState MASK_AnyState + +/* Getting partial derivatives */ +#define MASK_fmi3GetDirectionalDerivative (InitializationMode | StepMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetAdjointDerivative MASK_fmi3GetDirectionalDerivative + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define MASK_fmi3EnterConfigurationMode (Instantiated | StepMode | EventMode | ClockActivationMode) +#define MASK_fmi3ExitConfigurationMode (ConfigurationMode | ReconfigurationMode) + +/* Clock related functions */ +// TODO: fix masks +#define MASK_fmi3GetIntervalDecimal MASK_AnyState +#define MASK_fmi3GetIntervalFraction MASK_AnyState +#define MASK_fmi3SetIntervalDecimal MASK_AnyState +#define MASK_fmi3SetIntervalFraction MASK_AnyState +#define MASK_fmi3NewDiscreteStates MASK_AnyState + +/* Functions for Model Exchange */ + +#define MASK_fmi3EnterContinuousTimeMode EventMode +#define MASK_fmi3CompletedIntegratorStep ContinuousTimeMode + +/* Providing independent variables and re-initialization of caching */ +#define MASK_fmi3SetTime (EventMode | ContinuousTimeMode) +#define MASK_fmi3SetContinuousStates ContinuousTimeMode + +/* Evaluation of the model equations */ +#define MASK_fmi3GetContinuousStateDerivatives (InitializationMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetEventIndicators MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetContinuousStates MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetNominalsOfContinuousStates MASK_fmi3GetContinuousStateDerivatives + +#define MASK_fmi3GetNumberOfContinuousStates MASK_AnyState +#define MASK_fmi3GetNumberOfEventIndicators MASK_AnyState + +/* Functions for Co-Simulation */ + +#define MASK_fmi3EnterStepMode (InitializationMode | EventMode) +#define MASK_fmi3SetInputDerivatives (Instantiated | InitializationMode | StepMode) +#define MASK_fmi3GetOutputDerivatives (StepMode | StepDiscarded | Terminated) +#define MASK_fmi3DoStep StepMode +#define MASK_fmi3ActivateModelPartition ClockActivationMode +#define MASK_fmi3DoEarlyReturn IntermediateUpdateMode +#define MASK_fmi3GetDoStepDiscardedStatus StepMode + +// --------------------------------------------------------------------------- +// Private helpers used below to validate function arguments +// --------------------------------------------------------------------------- + +#define NOT_IMPLEMENTED \ +do { \ + ModelInstance *comp = (ModelInstance *)instance; \ + logError(comp, "Function is not implemented."); \ + return fmi3Error; \ +} while (0) + +#define BEGIN_FUNCTION(F) \ +Status status = OK; \ +if (!instance) return fmi3Error; \ +ModelInstance *S = (ModelInstance *)instance; \ +if (!allowedState(S, MASK_fmi3##F, #F)) CALL(Error); + +#define END_FUNCTION() \ +TERMINATE: \ + return (fmi3Status)status; + +static bool allowedState(ModelInstance *instance, int statesExpected, char *name) { + + if (!instance) { + return false; + } + + if (!(instance->state & statesExpected)) { + logError(instance, "fmi3%s: Illegal call sequence.", name); + return false; + } + + return true; +} + +/*************************************************** + Common Functions + ****************************************************/ + +const char* fmi3GetVersion(void) { + return fmi3Version; +} + +fmi3Status fmi3SetDebugLogging(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]) { + + BEGIN_FUNCTION(SetDebugLogging); + + CALL(setDebugLogging(S, loggingOn, nCategories, categories)); + + END_FUNCTION(); +} + +fmi3Instance fmi3InstantiateModelExchange( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage) { + + UNUSED(visible); + +#ifndef MODEL_EXCHANGE + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + + return NULL; +#else + return createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ModelExchange); +#endif +} + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) { + + UNUSED(visible); + UNUSED(requiredIntermediateVariables); + UNUSED(nRequiredIntermediateVariables); + +#ifndef EVENT_UPDATE + if (eventModeUsed) { + if (logMessage) { + logMessage(instanceEnvironment, fmi3Error, "error", "Event Mode is not supported."); + } + return NULL; + } +#endif + + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + (intermediateUpdateType)intermediateUpdate, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + CoSimulation); + + if (instance) { + instance->earlyReturnAllowed = earlyReturnAllowed; + instance->eventModeUsed = eventModeUsed; + instance->state = Instantiated; + } + + return instance; +} + +fmi3Instance fmi3InstantiateScheduledExecution( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption) { + + UNUSED(visible); + +#ifndef SCHEDULED_CO_SIMULATION + + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + UNUSED(clockUpdate); + UNUSED(lockPreemption); + UNUSED(unlockPreemption); + + return NULL; +#else + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ScheduledExecution + ); + + if (instance) { + instance->state = Instantiated; + instance->clockUpdate = clockUpdate; + instance->lockPreemption = lockPreemption; + instance->unlockPreemption = unlockPreemption; + } + + return instance; +#endif +} + +void fmi3FreeInstance(fmi3Instance instance) { + freeModelInstance((ModelInstance*)instance); +} + +fmi3Status fmi3EnterInitializationMode(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime) { + + UNUSED(toleranceDefined); + UNUSED(tolerance); + + BEGIN_FUNCTION(EnterInitializationMode); + + S->startTime = startTime; + S->stopTime = stopTimeDefined ? stopTime : INFINITY; + S->time = startTime; + S->nextCommunicationPoint = startTime; + S->state = InitializationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitInitializationMode); + + // if values were set and no fmi3GetXXX triggered update before, + // ensure calculated values are updated now + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = S->eventModeUsed ? EventMode : StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + + CALL(configurate(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3EnterEventMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterEventMode); + + S->state = EventMode; + + END_FUNCTION(); +} + +fmi3Status fmi3Terminate(fmi3Instance instance) { + + BEGIN_FUNCTION(Terminate); + + S->state = Terminated; + + END_FUNCTION(); +} + +fmi3Status fmi3Reset(fmi3Instance instance) { + + BEGIN_FUNCTION(Reset); + + CALL(reset(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues) { + GET_VARIABLES(Float32); +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) { + GET_VARIABLES(Float64); +} + +fmi3Status fmi3GetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues) { + GET_VARIABLES(Int8); +} + +fmi3Status fmi3GetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues) { + GET_VARIABLES(UInt8); +} + +fmi3Status fmi3GetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues) { + GET_VARIABLES(Int16); +} + +fmi3Status fmi3GetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues) { + GET_VARIABLES(UInt16); +} + +fmi3Status fmi3GetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues) { + GET_VARIABLES(Int32); +} + +fmi3Status fmi3GetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues) { + GET_VARIABLES(UInt32); +} + +fmi3Status fmi3GetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues) { + GET_VARIABLES(Int64); +} + +fmi3Status fmi3GetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues) { + GET_VARIABLES(UInt64); +} + +fmi3Status fmi3GetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues) { + GET_VARIABLES(Boolean); +} + +fmi3Status fmi3GetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues) { + GET_VARIABLES(String); +} + +fmi3Status fmi3GetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(GetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } else { + ASSERT_NOT_NULL(valueReferences); + } + + if (nValues > 0) { + ASSERT_NOT_NULL(values); + } + + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char**)values, nValues, &index)); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]) { + + BEGIN_FUNCTION(GetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getClock(instance, (ValueReference)valueReferences[i], &values[i])); + } + END_FUNCTION(); +} + +fmi3Status fmi3SetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues) { + SET_VARIABLES(Float32); +} + +fmi3Status fmi3SetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues) { + SET_VARIABLES(Float64); +} + +fmi3Status fmi3SetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues) { + SET_VARIABLES(Int8); +} + +fmi3Status fmi3SetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues) { + SET_VARIABLES(UInt8); +} + +fmi3Status fmi3SetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues) { + SET_VARIABLES(Int16); +} + +fmi3Status fmi3SetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues) { + SET_VARIABLES(UInt16); +} + +fmi3Status fmi3SetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues) { + SET_VARIABLES(Int32); +} + +fmi3Status fmi3SetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues) { + SET_VARIABLES(UInt32); +} + +fmi3Status fmi3SetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues) { + SET_VARIABLES(Int64); +} + +fmi3Status fmi3SetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues) { + SET_VARIABLES(UInt64); +} + +fmi3Status fmi3SetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues) { + SET_VARIABLES(Boolean); +} + +fmi3Status fmi3SetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues) { + SET_VARIABLES(String); +} + +fmi3Status fmi3SetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(SetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } + + ASSERT_NOT_NULL(valueReferences); + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(setBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char* const*)values, nValues, &index)); + } + + if (nValueReferences > 0) { + S->isDirtyValues = true; + } + + if (index != nValues) { + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); + } + + END_FUNCTION(); +} + +fmi3Status fmi3SetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]) { + + BEGIN_FUNCTION(SetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + if (values[i]) { + CALL(activateClock(instance, (ValueReference)valueReferences[i])); + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfVariableDependencies(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies) { + UNUSED(valueReference); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetVariableDependencies(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies) { + + UNUSED(dependent); + UNUSED(elementIndicesOfDependent); + UNUSED(independents); + UNUSED(elementIndicesOfIndependents); + UNUSED(dependencyKinds); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(GetFMUState); + + CALL(getFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState FMUState) { + + BEGIN_FUNCTION(SetFMUState); + + if (nullPointer(S, "fmi3SetFMUState", "FMUState", FMUState)) { + return fmi3Error; + } + + CALL(setFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(FreeFMUState); + + free(*FMUState); + + *FMUState = NULL; + + END_FUNCTION(); +} + +fmi3Status fmi3SerializedFMUStateSize(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size) { + + UNUSED(instance); + UNUSED(FMUState); + + BEGIN_FUNCTION(SerializedFMUStateSize); + + *size = sizeof(ModelInstance); + + END_FUNCTION(); +} + +fmi3Status fmi3SerializeFMUState(fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size) { + + BEGIN_FUNCTION(SerializeFMUState); + + if (nullPointer(S, "fmi3SerializeFMUState", "FMUstate", FMUState)) { + return fmi3Error; + } + + if (invalidNumber(S, "fmi3SerializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + memcpy(serializedState, FMUState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3DeserializeFMUState(fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(DeserializeFMUState); + + if (invalidNumber(S, "fmi3DeserializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + if (*FMUState == NULL) { + *FMUState = calloc(1, sizeof(ModelInstance)); + if (*FMUState == NULL) { + printf("Failed to allocate memory for FMUState.\n"); + return fmi3Error; + } + } + + memcpy(*FMUState, serializedState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetDirectionalDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetDirectionalDerivative); + + // TODO: check value references + // TODO: assert nUnknowns == nDeltaOfUnknowns + // TODO: assert nKnowns == nDeltaKnowns + + for (size_t i = 0; i < nUnknowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nKnowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[i], (ValueReference)knowns[j], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetAdjointDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetAdjointDerivative); + + // TODO: check value references + + for (size_t i = 0; i < nKnowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nUnknowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[j], (ValueReference)knowns[i], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3EnterConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterConfigurationMode); + + S->state = (S->state == Instantiated) ? ConfigurationMode : ReconfigurationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitConfigurationMode); + + if (S->state == ConfigurationMode) { + S->state = Instantiated; + } else { + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + } + +#if defined(HAS_CONTINUOUS_STATES) || defined(HAS_EVENT_INDICATORS) + CALL(configurate(S)); +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]) { + + BEGIN_FUNCTION(GetIntervalDecimal); + + // TODO: Check nValueReferences != nValues ? + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getInterval(instance, (ValueReference)valueReferences[i], &intervals[i], (int*)&qualifiers[i])); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 intervalCounters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + UNUSED(qualifiers); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 shiftCounters[], + fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervals); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 intervalCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 shiftCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3EvaluateDiscreteStates(fmi3Instance instance) { + NOT_IMPLEMENTED; +} + +fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime) { + + BEGIN_FUNCTION(NewDiscreteStates); + +#ifdef EVENT_UPDATE + CALL(eventUpdate(S)); +#endif + + // copy internal eventInfo of component to output arguments + if (discreteStatesNeedUpdate) *discreteStatesNeedUpdate = S->newDiscreteStatesNeeded; + if (terminateSimulation) *terminateSimulation = S->terminateSimulation; + if (nominalsOfContinuousStatesChanged) *nominalsOfContinuousStatesChanged = S->nominalsOfContinuousStatesChanged; + if (valuesOfContinuousStatesChanged) *valuesOfContinuousStatesChanged = S->valuesOfContinuousStatesChanged; + if (nextEventTimeDefined) *nextEventTimeDefined = S->nextEventTimeDefined; + if (nextEventTime) *nextEventTime = S->nextEventTime; + + END_FUNCTION(); +} + +/*************************************************** + Functions for Model Exchange + ****************************************************/ + +fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterContinuousTimeMode); + + S->state = ContinuousTimeMode; + + END_FUNCTION(); +} + +fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(CompletedIntegratorStep); + + ASSERT_NOT_NULL(enterEventMode); + ASSERT_NOT_NULL(terminateSimulation); + + *enterEventMode = fmi3False; + *terminateSimulation = fmi3False; + + END_FUNCTION(); +} + +/* Providing independent variables and re-initialization of caching */ +fmi3Status fmi3SetTime(fmi3Instance instance, fmi3Float64 time) { + + BEGIN_FUNCTION(SetTime); + + S->time = time; + + END_FUNCTION(); +} + +fmi3Status fmi3SetContinuousStates(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(SetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3SetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + ASSERT_NOT_NULL(continuousStates); + + CALL(setContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +/* Evaluation of the model equations */ +fmi3Status fmi3GetContinuousStateDerivatives(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStateDerivatives); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStateDerivatives", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStateDerivatives", "derivatives[]", derivatives)) + return fmi3Error; + + CALL(getDerivatives(S, derivatives, nContinuousStates)); +#else + UNUSED(derivatives); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetEventIndicators(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators) { + + BEGIN_FUNCTION(GetEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + if (invalidNumber(S, "fmi3GetEventIndicators", "nEventIndicators", nEventIndicators, getNumberOfEventIndicators(S))) { + return fmi3Error; + } + + CALL(getEventIndicators(S, eventIndicators, nEventIndicators)); +#else + + UNUSED(eventIndicators); + + if (nEventIndicators > 0) { + // TODO: log error + return fmi3Error; + } +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetContinuousStates(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStates", "continuousStates[]", continuousStates)) + return fmi3Error; + + CALL(getContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNominalsOfContinuousStates(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetNominalsOfContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetNominalContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(instance))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetNominalContinuousStates", "nominals[]", nominals)) + return fmi3Error; + + for (size_t i = 0; i < nContinuousStates; i++) { + nominals[i] = 1; + } + + return fmi3OK; +#else + UNUSED(nominals); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfEventIndicators(fmi3Instance instance, + size_t* nEventIndicators) { + + BEGIN_FUNCTION(GetNumberOfEventIndicators); + + ASSERT_NOT_NULL(nEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + *nEventIndicators = getNumberOfEventIndicators(instance); +#else + *nEventIndicators = 0; +#endif + + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfContinuousStates(fmi3Instance instance, + size_t* nContinuousStates) { + + BEGIN_FUNCTION(GetNumberOfContinuousStates); + + ASSERT_NOT_NULL(nContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + *nContinuousStates = getNumberOfContinuousStates(instance); +#else + *nContinuousStates = 0; +#endif + + END_FUNCTION(); +} + +/*************************************************** + Functions for Co-Simulation + ****************************************************/ + +fmi3Status fmi3EnterStepMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterStepMode); + + S->state = StepMode; + + END_FUNCTION(); +} + +fmi3Status fmi3GetOutputDerivatives(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues) { + + UNUSED(nValues); + + BEGIN_FUNCTION(GetOutputDerivatives); + +#ifdef GET_OUTPUT_DERIVATIVE + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getOutputDerivative(S, (ValueReference)valueReferences[i], orders[i], &values[i])); + } +#else + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(orders); + UNUSED(values); + + NOT_IMPLEMENTED; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(DoStep); + + if (!isClose(currentCommunicationPoint, S->nextCommunicationPoint)) { + logError(S, "Expected currentCommunicationPoint = %.16g but was %.16g.", + S->nextCommunicationPoint, currentCommunicationPoint); + CALL(Error); + } + + if (communicationStepSize <= 0) { + logError(S, "Communication step size must be > 0 but was %.16g.", communicationStepSize); + CALL(Error); + } + + const fmi3Float64 nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + + if (nextCommunicationPoint > S->stopTime && !isClose(nextCommunicationPoint, S->stopTime)) { + logError(S, "At communication point %.16g a step size of %.16g was requested but stop time is %.16g.", + currentCommunicationPoint, communicationStepSize, S->stopTime); + CALL(Error); + } + + bool nextCommunicationPointReached; + + *eventHandlingNeeded = fmi3False; + *terminateSimulation = fmi3False; + *earlyReturn = fmi3False; + + while (true) { + + const fmi3Float64 nextSolverStepTime = S->time + FIXED_SOLVER_STEP; + + nextCommunicationPointReached = nextSolverStepTime > nextCommunicationPoint && !isClose(nextSolverStepTime, nextCommunicationPoint); + + if (nextCommunicationPointReached || (*eventHandlingNeeded && S->earlyReturnAllowed)) { + break; + } + +#ifdef EVENT_UPDATE + if (*eventHandlingNeeded) { + eventUpdate(S); + *eventHandlingNeeded = fmi3False; + } +#endif + + bool stateEvent, timeEvent; + + CALL(doFixedStep(S, &stateEvent, &timeEvent)); + +#ifdef EVENT_UPDATE + if (stateEvent || timeEvent) { + + if (S->eventModeUsed) { + *eventHandlingNeeded = fmi3True; + } else { + CALL(eventUpdate(S)); +#ifdef HAS_EVENT_INDICATORS + CALL(getEventIndicators(S, S->prez, S->nz)); +#endif + } + + if (S->earlyReturnAllowed) { + break; + } + } +#endif + + if (S->terminateSimulation) { + break; + } + } + + *terminateSimulation = S->terminateSimulation; + *earlyReturn = S->earlyReturnAllowed && !nextCommunicationPointReached; + *lastSuccessfulTime = S->time; + + if (nextCommunicationPointReached) { + S->nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + } else { + S->nextCommunicationPoint = S->time; + } + + END_FUNCTION(); +} + +fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime) { + + BEGIN_FUNCTION(ActivateModelPartition); + + CALL(activateModelPartition(S, (ValueReference)clockReference, activationTime)); + + END_FUNCTION(); +} diff --git a/testsuite/resources/BouncingBall3/sources/model.c b/testsuite/resources/BouncingBall3/sources/model.c new file mode 100644 index 000000000..7095e9893 --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/model.c @@ -0,0 +1,222 @@ +#include // for fabs() +#include // for DBL_MIN +#include "config.h" +#include "model.h" + +#define V_MIN (0.1) +#define EVENT_EPSILON (1e-10) + + +void setStartValues(ModelInstance *comp) { + M(h) = 1; + M(v) = 0; + M(g) = -9.81; + M(e) = 0.7; +} + +Status calculateValues(ModelInstance *comp) { + UNUSED(comp); + // nothing to do + return OK; +} + +Status getFloat64(ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_time: + values[(*index)++] = comp->time; + return OK; + case vr_h: + values[(*index)++] = M(h); + return OK; + case vr_der_h: + case vr_v: + values[(*index)++] = M(v); + return OK; + case vr_der_v: + case vr_g: + values[(*index)++] = M(g); + return OK; + case vr_e: + values[(*index)++] = M(e); + return OK; + case vr_v_min: + values[(*index)++] = V_MIN; + return OK; + default: + logError(comp, "Get Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status setFloat64(ModelInstance* comp, ValueReference vr, const double value[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + + case vr_h: +#if FMI_VERSION > 1 + if (comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != ContinuousTimeMode && + comp->state != EventMode) { + logError(comp, "Variable \"h\" can only be set in Instantiated Mode, Initialization Mode, Continuous Time Mode, and Event Mode."); + return Error; + } +#endif + M(h) = value[(*index)++]; + return OK; + + case vr_v: +#if FMI_VERSION > 1 + if (comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != ContinuousTimeMode && + comp->state != EventMode) { + logError(comp, "Variable \"v\" can only be set in Instantiated Mode, Initialization Mode, Continuous Time Mode, and Event Mode."); + return Error; + } +#endif + M(v) = value[(*index)++]; + return OK; + + case vr_g: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode) { + logError(comp, "Variable g can only be set after instantiation or in initialization mode."); + return Error; + } +#endif + M(g) = value[(*index)++]; + return OK; + + case vr_e: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != EventMode) { + logError(comp, "Variable e can only be set after instantiation, in initialization mode or event mode."); + return Error; + } +#endif + M(e) = value[(*index)++]; + return OK; + + case vr_v_min: + logError(comp, "Variable v_min (value reference %u) is constant and cannot be set.", vr_v_min); + return Error; + + default: + logError(comp, "Unexpected value reference: %u.", vr); + return Error; + } +} + +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value) { + + if (order != 1) { + logError(comp, "The output derivative order %d for value reference %u is not available.", order, valueReference); + return Error; + } + + switch (valueReference) { + case vr_h: + *value = M(v); + return OK; + case vr_v: + *value = M(g); + return OK; + default: + logError(comp, "The output derivative for value reference %u is not available.", valueReference); + return Error; + } +} + +Status eventUpdate(ModelInstance *comp) { + + if (M(h) <= 0 && M(v) < 0) { + + M(h) = DBL_MIN; // slightly above 0 to avoid zero-crossing + M(v) = -M(v) * M(e); + + if (M(v) < V_MIN) { + // stop bouncing + M(v) = 0; + M(g) = 0; + } + + comp->valuesOfContinuousStatesChanged = true; + } else { + comp->valuesOfContinuousStatesChanged = false; + } + + comp->nominalsOfContinuousStatesChanged = false; + comp->terminateSimulation = false; + comp->nextEventTimeDefined = false; + + return OK; +} + +size_t getNumberOfEventIndicators(ModelInstance* comp) { + + UNUSED(comp); + + return 1; +} + +size_t getNumberOfContinuousStates(ModelInstance* comp) { + + UNUSED(comp); + + return 2; +} + +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx) { + + UNUSED(nx); + + x[0] = M(h); + x[1] = M(v); + + return OK; +} + +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx) { + + UNUSED(nx); + + M(h) = x[0]; + M(v) = x[1]; + + return OK; +} + +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx) { + + UNUSED(nx); + + dx[0] = M(v); + dx[1] = M(g); + + return OK; +} + +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz) { + + UNUSED(nz); + + if (M(h) > -EVENT_EPSILON && M(h) <= 0 && M(v) > 0) { + // hysteresis for better stability + z[0] = -EVENT_EPSILON; + } else { + z[0] = M(h); + } + + return OK; +} diff --git a/testsuite/resources/BouncingBall3/sources/model.h b/testsuite/resources/BouncingBall3/sources/model.h new file mode 100644 index 000000000..8dabb0cad --- /dev/null +++ b/testsuite/resources/BouncingBall3/sources/model.h @@ -0,0 +1,250 @@ +#pragma once + +#if FMI_VERSION != 1 && FMI_VERSION != 2 && FMI_VERSION != 3 +#error FMI_VERSION must be one of 1, 2 or 3 +#endif + +#define UNUSED(x) (void)(x) + +#include // for size_t +#include // for bool +#include + +#include "config.h" + +#if FMI_VERSION == 1 + +#define not_modelError (Instantiated| Initialized | Terminated) + +typedef enum { + Instantiated = 1<<0, + Initialized = 1<<1, + Terminated = 1<<2, + modelError = 1<<3 +} ModelState; + +#elif FMI_VERSION == 2 + +typedef enum { + StartAndEnd = 1<<0, + Instantiated = 1<<1, + InitializationMode = 1<<2, + + // ME states + EventMode = 1<<3, + ContinuousTimeMode = 1<<4, + + // CS states + StepComplete = 1<<5, + StepInProgress = 1<<6, + StepFailed = 1<<7, + StepCanceled = 1<<8, + + Terminated = 1<<9, +} ModelState; + +#else + +typedef enum { + StartAndEnd = 1 << 0, + ConfigurationMode = 1 << 1, + Instantiated = 1 << 2, + InitializationMode = 1 << 3, + EventMode = 1 << 4, + ContinuousTimeMode = 1 << 5, + StepMode = 1 << 6, + ClockActivationMode = 1 << 7, + StepDiscarded = 1 << 8, + ReconfigurationMode = 1 << 9, + IntermediateUpdateMode = 1 << 10, + Terminated = 1 << 11, +} ModelState; + +#endif + +typedef enum { + ModelExchange, + CoSimulation, + ScheduledExecution, +} InterfaceType; + +typedef enum { + OK, + Warning, + Discard, + Error, + Fatal, + Pending +} Status; + +#if FMI_VERSION < 3 +typedef void (*loggerType) (void *componentEnvironment, const char *instanceName, int status, const char *category, const char *message, ...); +#else +typedef void (*loggerType) (void *componentEnvironment, int status, const char *category, const char *message); +#endif + +typedef void (*lockPreemptionType) (void); +typedef void (*unlockPreemptionType) (void); + + +typedef void (*intermediateUpdateType) (void *instanceEnvironment, + double intermediateUpdateTime, + bool intermediateVariableSetRequested, + bool intermediateVariableGetAllowed, + bool intermediateStepFinished, + bool canReturnEarly, + bool *earlyReturnRequested, + double *earlyReturnTime); + +typedef void(*clockUpdateType) (void *instanceEnvironment); + +typedef struct { + + double startTime; + double stopTime; + double time; + const char *instanceName; + InterfaceType type; + const char *resourceLocation; + + Status status; + + // callback functions + loggerType logger; + intermediateUpdateType intermediateUpdate; + clockUpdateType clockUpdate; + + lockPreemptionType lockPreemption; + unlockPreemptionType unlockPreemption; + + bool logEvents; + bool logErrors; + + void *componentEnvironment; + ModelState state; + + // event info + bool newDiscreteStatesNeeded; + bool terminateSimulation; + bool nominalsOfContinuousStatesChanged; + bool valuesOfContinuousStatesChanged; + bool nextEventTimeDefined; + double nextEventTime; + bool clocksTicked; + + bool isDirtyValues; + + ModelData modelData; + + // internal solver steps + uint64_t nSteps; + + // Co-Simulation + bool earlyReturnAllowed; + bool eventModeUsed; + double nextCommunicationPoint; + + // solver + size_t nz; + double* z; + double* prez; + + size_t nx; + double* x; + double* dx; + +} ModelInstance; + +ModelInstance *createModelInstance( + loggerType logger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType); + +void freeModelInstance(ModelInstance *comp); + +Status configurate(ModelInstance* comp); + +Status reset(ModelInstance* comp); + +void setStartValues(ModelInstance* comp); + +Status calculateValues(ModelInstance *comp); + +Status getFloat32 (ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t *index); +Status getFloat64 (ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t *index); +Status getInt8 (ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index); +Status getUInt8 (ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index); +Status getInt16 (ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index); +Status getUInt16 (ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index); +Status getInt32 (ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index); +Status getUInt32 (ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index); +Status getInt64 (ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index); +Status getUInt64 (ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index); +Status getBoolean (ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index); +Status getString (ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index); +Status getBinary (ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index); + +Status setFloat32 (ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t *index); +Status setFloat64 (ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t *index); +Status setInt8 (ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t *index); +Status setUInt8 (ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t *index); +Status setInt16 (ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t *index); +Status setUInt16 (ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t *index); +Status setInt32 (ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t *index); +Status setUInt32 (ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t *index); +Status setInt64 (ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t *index); +Status setUInt64 (ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t *index); +Status setBoolean (ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t *index); +Status setString (ModelInstance* comp, ValueReference vr, const char* const values[], size_t nValues, size_t *index); +Status setBinary (ModelInstance* comp, ValueReference vr, const size_t sizes[], const char* const values[], size_t nValues, size_t *index); + +Status activateClock(ModelInstance* comp, ValueReference vr); +Status getClock(ModelInstance* comp, ValueReference vr, bool* value); +Status setClock(ModelInstance* comp, ValueReference vr, const bool* value); + +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier); + +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime); + +size_t getNumberOfEventIndicators(ModelInstance* comp); +size_t getNumberOfContinuousStates(ModelInstance* comp); +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx); +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx); +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx); +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value); +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative); +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz); +Status eventUpdate(ModelInstance *comp); + +bool isClose(double a, double b); +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected); +bool invalidState(ModelInstance *comp, const char *f, int statesExpected); +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p); +void logError(ModelInstance *comp, const char *message, ...); +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]); +void logEvent(ModelInstance *comp, const char *message, ...); +void logError(ModelInstance *comp, const char *message, ...); + +Status getFMUState(ModelInstance* comp, void** FMUState); +Status setFMUState(ModelInstance* comp, void* FMUState); + +// shorthand to access the variables +#define M(v) (comp->modelData.v) + +// "stringification" macros +#define xstr(s) str(s) +#define str(s) #s + +// assert size of nValues for scalar variables +#define ASSERT_NVALUES(N) do { \ + const size_t expected_nValues = *index + (N); \ + if (expected_nValues > nValues) { \ + logError(comp, "Expected nValues >= %zu but was %zu.", expected_nValues, nValues); \ + return Error; \ + } \ +} while (0) diff --git a/testsuite/resources/Makefile b/testsuite/resources/Makefile index af86abaaf..fb47e49f3 100644 --- a/testsuite/resources/Makefile +++ b/testsuite/resources/Makefile @@ -10,6 +10,7 @@ AircraftVehicleDemonstrator.eCS_SW \ AircraftVehicleDemonstrator.engine \ B \ BouncingBall \ +BouncingBall3 \ Dahlquist \ DualMassOscillator.System1 \ DualMassOscillator.System2 \ From dbf8e13024736a38e61a08d72afc6a4f4ba91141 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Fri, 13 Dec 2024 16:13:48 +0100 Subject: [PATCH 02/32] check for .fmu --- src/OMSimulatorLib/System.cpp | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/OMSimulatorLib/System.cpp b/src/OMSimulatorLib/System.cpp index b4c986038..edb3df7a6 100644 --- a/src/OMSimulatorLib/System.cpp +++ b/src/OMSimulatorLib/System.cpp @@ -270,7 +270,9 @@ oms_status_enu_t oms::System::addSubModel(const oms::ComRef& cref, const std::st extension = path.substr(path.length() - 4); // unpack the modelDescription.xml in memory to detect the fmiVersion - std::string fmiVersion = getFmiVersion(path); + std::string fmiVersion = ""; + if (extension == ".fmu") + fmiVersion = getFmiVersion(path); if (extension == ".fmu" && oms_system_wc == type && fmiVersion == "2.0") component = ComponentFMUCS::NewComponent(cref, this, path_.string()); From fadef84f61a890461a548cb4a50734257f475215 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Sat, 14 Dec 2024 01:17:43 +0100 Subject: [PATCH 03/32] fix variable name conflicts --- src/OMSimulatorLib/Variable.cpp | 20 ++++++++++---------- src/OMSimulatorLib/Variable.h | 20 ++++++++++---------- 2 files changed, 20 insertions(+), 20 deletions(-) diff --git a/src/OMSimulatorLib/Variable.cpp b/src/OMSimulatorLib/Variable.cpp index 06b21919c..8f636b389 100644 --- a/src/OMSimulatorLib/Variable.cpp +++ b/src/OMSimulatorLib/Variable.cpp @@ -66,8 +66,8 @@ void oms::Variable::configureFMI2Variable(fmiHandle* fmi4c, int index_) description = fmi2_getVariableDescription(var) ? fmi2_getVariableDescription(var) : ""; trim(description); fmi2Vr = fmi2_getVariableValueReference(var); - fmi2Causality = fmi2_getVariableCausality(var); - fmi2Variability = fmi2_getVariableVariability(var); + fmi2Causality_ = fmi2_getVariableCausality(var); + fmi2Variability_ = fmi2_getVariableVariability(var); // TODO implement the initial attribute table in fmi4c according to FMI specification fmi2InitialProperty = fmi2_getVariableInitial(var); @@ -102,7 +102,7 @@ void oms::Variable::configureFMI2Variable(fmiHandle* fmi4c, int index_) { is_der = true; state_index = derivative_index; - if (fmi2Variability == fmi2VariabilityContinuous) + if (fmi2Variability_ == fmi2VariabilityContinuous) { is_continuous_time_der = true; } @@ -118,8 +118,8 @@ void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) description = fmi3_getVariableDescription(var) ? fmi3_getVariableDescription(var) : ""; trim(description); fmi3Vr = fmi3_getVariableValueReference(var); - fmi3Causality = fmi3_getVariableCausality(var); - fmi3Variability = fmi3_getVariableVariability(var); + fmi3Causality_ = fmi3_getVariableCausality(var); + fmi3Variability_ = fmi3_getVariableVariability(var); // TODO implement the initial attribute table in fmi4c according to FMI specification fmi3InitialProperty = fmi3_getVariableInitial(var); @@ -154,7 +154,7 @@ void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) { is_der = true; state_index = derivative_index; - if (fmi3Variability == fmi3VariabilityContinuous) + if (fmi3Variability_ == fmi3VariabilityContinuous) { is_continuous_time_der = true; } @@ -171,7 +171,7 @@ oms_causality_enu_t oms::Variable::getCausality() const if (isFmi2()) { // FMI2 - switch (fmi2Causality) + switch (fmi2Causality_) { case fmi2CausalityInput: return oms_causality_input; @@ -192,7 +192,7 @@ oms_causality_enu_t oms::Variable::getCausality() const else { // FMI3 - switch (fmi3Causality) + switch (fmi3Causality_) { case fmi3CausalityInput: return oms_causality_input; @@ -217,7 +217,7 @@ std::string oms::Variable::getCausalityString() const if (isFmi2()) { // FMI2 - switch (fmi2Causality) + switch (fmi2Causality_) { case fmi2CausalityInput: return "input"; @@ -238,7 +238,7 @@ std::string oms::Variable::getCausalityString() const else { // FMI3 - switch (fmi3Causality) + switch (fmi3Causality_) { case fmi3CausalityInput: return "input"; diff --git a/src/OMSimulatorLib/Variable.h b/src/OMSimulatorLib/Variable.h index d5cfe1158..a4692ec84 100644 --- a/src/OMSimulatorLib/Variable.h +++ b/src/OMSimulatorLib/Variable.h @@ -58,12 +58,12 @@ namespace oms bool isFmi3() const {return fmi3;} // causality attribute - bool isParameter() const { return isFmi2() ? (fmi2CausalityParameter == fmi2Causality) : (fmi3CausalityParameter == fmi3Causality);} - bool isCalculatedParameter() const { return isFmi2() ? (fmi2CausalityCalculatedParameter == fmi2Causality) : (fmi3CausalityCalculatedParameter ==fmi3Causality);} - bool isInput() const { return isFmi2() ? (fmi2CausalityInput == fmi2Causality) : (fmi3CausalityInput == fmi3Causality);} - bool isOutput() const { return isFmi2() ? (fmi2CausalityOutput == fmi2Causality) : (fmi3CausalityOutput == fmi3Causality);} - bool isLocal() const { return isFmi2() ? (fmi2CausalityLocal == fmi2Causality) : (fmi3CausalityLocal == fmi3Causality);} - bool isIndependent() const { return isFmi2() ? (fmi2CausalityIndependent == fmi2Causality) : (fmi3CausalityIndependent == fmi3Causality);} + bool isParameter() const { return isFmi2() ? (fmi2CausalityParameter == fmi2Causality_) : (fmi3CausalityParameter == fmi3Causality_);} + bool isCalculatedParameter() const { return isFmi2() ? (fmi2CausalityCalculatedParameter == fmi2Causality_) : (fmi3CausalityCalculatedParameter ==fmi3Causality_);} + bool isInput() const { return isFmi2() ? (fmi2CausalityInput == fmi2Causality_) : (fmi3CausalityInput == fmi3Causality_);} + bool isOutput() const { return isFmi2() ? (fmi2CausalityOutput == fmi2Causality_) : (fmi3CausalityOutput == fmi3Causality_);} + bool isLocal() const { return isFmi2() ? (fmi2CausalityLocal == fmi2Causality_) : (fmi3CausalityLocal == fmi3Causality_);} + bool isIndependent() const { return isFmi2() ? (fmi2CausalityIndependent == fmi2Causality_) : (fmi3CausalityIndependent == fmi3Causality_);} bool isState() const { return is_state; } bool isDer() const { return is_der; } @@ -112,14 +112,14 @@ namespace oms // FMI 2.0 specific members fmi2ValueReference fmi2Vr; - fmi2Causality fmi2Causality; - fmi2Variability fmi2Variability; + fmi2Causality fmi2Causality_; + fmi2Variability fmi2Variability_; fmi2Initial fmi2InitialProperty; // FMI 3.0 specific members fmi3ValueReference fmi3Vr; - fmi3Causality fmi3Causality; - fmi3Variability fmi3Variability; + fmi3Causality fmi3Causality_; + fmi3Variability fmi3Variability_; fmi3Initial fmi3InitialProperty; bool is_state; From 4395cd657cdc6d09c5f506291a41b092d655c957 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Sat, 14 Dec 2024 01:40:01 +0100 Subject: [PATCH 04/32] add Makefile --- testsuite/Makefile | 4 +++ testsuite/reference-fmus/3.0/Makefile | 51 +++++++++++++++++++++++++++ 2 files changed, 55 insertions(+) create mode 100644 testsuite/reference-fmus/3.0/Makefile diff --git a/testsuite/Makefile b/testsuite/Makefile index 4636975b2..e43bd3d68 100644 --- a/testsuite/Makefile +++ b/testsuite/Makefile @@ -36,3 +36,7 @@ simulation.log: difftool reference-fmus.log: difftool @$(MAKE) -C reference-fmus -f Makefile test > $@ @grep == reference-fmus.log + +reference-fmus3.log: difftool + @$(MAKE) -C reference-fmus/3.0 -f Makefile test > $@ + @grep == reference-fmus3.log \ No newline at end of file diff --git a/testsuite/reference-fmus/3.0/Makefile b/testsuite/reference-fmus/3.0/Makefile new file mode 100644 index 000000000..ff68e6866 --- /dev/null +++ b/testsuite/reference-fmus/3.0/Makefile @@ -0,0 +1,51 @@ +TEST = ../../rtest -v + +TESTFILES = \ +BouncingBall.lua \ + +# Run make failingtest +FAILINGTESTFILES = \ + +# Dependency files that are not .lua or Makefile +# Add them here or they will be cleaned. +DEPENDENCIES = \ +*.lua \ +*.py \ +Makefile \ + +CLEAN = `ls | grep -w -v -f deps.tmp` + +.PHONY : test clean getdeps failingtest + +test: + @echo + @echo Running tests... + @$(TEST) $(TESTFILES) + +baseline: + @echo + @echo Updating badelines... + @$(TEST) -b $(TESTFILES) + +# Cleans all files that are not listed as dependencies +clean: + @echo $(DEPENDENCIES) | sed 's/ /\\\|/g' > deps.tmp + @rm -rf $(CLEAN) + +# Run this if you want to list out the files (dependencies). +# do it after cleaning and updating the folder +# then you can get a list of file names (which must be dependencies +# since you got them from repository + your own new files) +# then add them to the DEPENDENCIES. You can find the +# list in deps.txt +getdeps: + @echo $(DEPENDENCIES) | sed 's/ /\\\|/g' > deps.tmp + @echo $(CLEAN) | sed -r 's/deps.txt|deps.tmp//g' | sed 's/ / \\\n/g' > deps.txt + @echo Dependency list saved in deps.txt. + @echo Copy the list from deps.txt and add it to the Makefile @DEPENDENCIES + +failingtest: + @echo + @echo Running failing tests... + @echo + @$(TEST) $(FAILINGTESTFILES) From c941bd02637df042348a587692684f893944d2a7 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Sat, 14 Dec 2024 01:55:02 +0100 Subject: [PATCH 05/32] add test VanDerPol.lua --- testsuite/reference-fmus/3.0/Makefile | 1 + testsuite/reference-fmus/3.0/VanDerPol.lua | 42 + .../binaries/aarch64-darwin/VanDerPol.dylib | Bin 0 -> 89552 bytes .../binaries/aarch64-linux/VanDerPol.so | Bin 0 -> 71712 bytes .../binaries/x86-windows/VanDerPol.dll | Bin 0 -> 134656 bytes .../binaries/x86_64-darwin/VanDerPol.dylib | Bin 0 -> 88864 bytes .../binaries/x86_64-linux/VanDerPol.so | Bin 0 -> 67080 bytes .../binaries/x86_64-windows/VanDerPol.dll | Bin 0 -> 166400 bytes .../VanDerPol3/documentation/index.html | 127 ++ .../VanDerPol3/documentation/result.svg | 1 + .../resources/VanDerPol3/modelDescription.xml | 53 + .../VanDerPol3/sources/buildDescription.xml | 13 + .../resources/VanDerPol3/sources/config.h | 34 + .../VanDerPol3/sources/cosimulation.c | 691 ++++++++ .../VanDerPol3/sources/cosimulation.h | 5 + .../VanDerPol3/sources/fmi3Functions.c | 1446 +++++++++++++++++ .../resources/VanDerPol3/sources/model.c | 130 ++ .../resources/VanDerPol3/sources/model.h | 250 +++ 18 files changed, 2793 insertions(+) create mode 100644 testsuite/reference-fmus/3.0/VanDerPol.lua create mode 100644 testsuite/resources/VanDerPol3/binaries/aarch64-darwin/VanDerPol.dylib create mode 100644 testsuite/resources/VanDerPol3/binaries/aarch64-linux/VanDerPol.so create mode 100644 testsuite/resources/VanDerPol3/binaries/x86-windows/VanDerPol.dll create mode 100644 testsuite/resources/VanDerPol3/binaries/x86_64-darwin/VanDerPol.dylib create mode 100644 testsuite/resources/VanDerPol3/binaries/x86_64-linux/VanDerPol.so create mode 100644 testsuite/resources/VanDerPol3/binaries/x86_64-windows/VanDerPol.dll create mode 100644 testsuite/resources/VanDerPol3/documentation/index.html create mode 100644 testsuite/resources/VanDerPol3/documentation/result.svg create mode 100644 testsuite/resources/VanDerPol3/modelDescription.xml create mode 100644 testsuite/resources/VanDerPol3/sources/buildDescription.xml create mode 100644 testsuite/resources/VanDerPol3/sources/config.h create mode 100644 testsuite/resources/VanDerPol3/sources/cosimulation.c create mode 100644 testsuite/resources/VanDerPol3/sources/cosimulation.h create mode 100644 testsuite/resources/VanDerPol3/sources/fmi3Functions.c create mode 100644 testsuite/resources/VanDerPol3/sources/model.c create mode 100644 testsuite/resources/VanDerPol3/sources/model.h diff --git a/testsuite/reference-fmus/3.0/Makefile b/testsuite/reference-fmus/3.0/Makefile index ff68e6866..590535c52 100644 --- a/testsuite/reference-fmus/3.0/Makefile +++ b/testsuite/reference-fmus/3.0/Makefile @@ -2,6 +2,7 @@ TEST = ../../rtest -v TESTFILES = \ BouncingBall.lua \ +VanDerPol.lua \ # Run make failingtest FAILINGTESTFILES = \ diff --git a/testsuite/reference-fmus/3.0/VanDerPol.lua b/testsuite/reference-fmus/3.0/VanDerPol.lua new file mode 100644 index 000000000..d255f31a2 --- /dev/null +++ b/testsuite/reference-fmus/3.0/VanDerPol.lua @@ -0,0 +1,42 @@ +-- status: correct +-- teardown_command: rm -rf VanDerPol3-lua/ +-- linux: yes +-- ucrt64: yes +-- win: yes +-- mac: yes +-- asan: yes + +oms_setCommandLineOption("--suppressPath=true") +oms_setTempDirectory("./VanDerPol3-lua/") +oms_setWorkingDirectory("./VanDerPol3-lua/") + +oms_newModel("model") +oms_addSystem("model.root", oms_system_wc) +oms_addSubModel("model.root.VanDerPol", "../../../resources/VanDerPol3.fmu") +oms_setResultFile("model", "VanDerPol-cs.mat") +oms_setStopTime("model", 20.0) +oms_setTolerance("model.root", 1e-5) +oms_instantiate("model") +oms_initialize("model") +oms_simulate("model") +oms_terminate("model") +oms_delete("model") + +if 1 == oms_compareSimulationResults("../../../references/VanDerPol-cs.mat", "VanDerPol-cs.mat", "model.root.VanDerPol.x0", 1e-4, 1e-4) then + print("signal x0 is equal") +else + print("signal x0 is not equal") +end + +if 1 == oms_compareSimulationResults("../../../references/VanDerPol-cs.mat", "VanDerPol-cs.mat", "model.root.VanDerPol.x1", 1e-4, 1e-4) then + print("signal x1 is equal") +else + print("signal x1 is not equal") +end + +-- Result: +-- Loading FMI version 3... +-- info: Result file: VanDerPol-cs.mat (bufferSize=1) +-- signal x0 is equal +-- signal x1 is equal +-- endResult diff --git a/testsuite/resources/VanDerPol3/binaries/aarch64-darwin/VanDerPol.dylib b/testsuite/resources/VanDerPol3/binaries/aarch64-darwin/VanDerPol.dylib new file mode 100644 index 0000000000000000000000000000000000000000..0bd2e12816913aea80524a7a136edf303ea40745 GIT binary patch literal 89552 zcmeHw3t&{m)&J~n0-J#H3W7Y64T46%fP#=HN?u^Fh!pTq1(p~V5)BDv6NTaf8c?ig zxk|+ct)Qrh^%4E_lT;Km)W&{jgAa;|8eY0VR4nS3RARp0naAedyLUG<2LJz(8@=p3 zGiT1soH^&r%(?UU`@g>Yu`6Q^hQCgDy5aFeF}8wrryzDJo?VFbdS^_yat04F{lk;$ z!UP{+0@x%Qv!Fr0gpR z5bTogRzF^EY2l6eg>$|6h4YGlV5XNX>1~pU3D(!wOq1I6eoiMVeMY)B^U^8PW$ViJ zOj9Y0FqM%W3MC2gdgm9l)RJIpdQ*Wb{v3vSlFY@bDEv~nvhjGmlP692#e}R$vQ#Y1 zSPli(4it$gR$}mglko3IJj7ppcv|tooRYi|m**5_`HH6&6(rAHT#$baW1|^c$|WB8 z)FRC&3D*M7Mj?rpMC9Yycotv98}#>@lMY#@GQrpuNOeWU+q)}i!+1> zpg(>nALnU9p18s_{+_al_YQFXWxwkjgn97rx^zbEoG0^lE;EiFT|*Ja%a33BBe_n& z!)f8yaX|{y(ZNQP`in=P#`H{I>@V>xNX}3^02(_T57Ft1dhWvSnG&XY(;u;$;#Xhg zU}=#AmXPf~n*%lnY!28QusL9Jz~+F>0hkPOHV14D*c`Aq zU~|CcfXxA$12zY24%i&9Ibd_Z=D^Ryf#yuMqpmY+40KLwWZmb)vq`Lpzwc)w*e~UK z_riGgE7k;DZL7<>(~#zuX#)QeiTf)7J0^)=Cw^T>pSUU`f#^DcpXk0Op1&iGt<2%! z>@wDbWhc{ud6YSJG%bm)Xv%bG>s<*A8>-_sJ>rUQ*w=?O?(fAKu_7Zb&?~Lc?Z6Yw zv_Lo1p<7yGeIE*o`66)p!~JR;Y%JlecX=BQA})ZqdKc4%I#^>;G;7RZtTJ)oN!mSU zu{C+fySzGK)0MziY2IjVURz#0dz0J2t`Br!jqcv;o50$K`>k}dv0rpaYs4Ct)fe}O z*W6eZGHLOjfERNob0q96M}90Ot*P8KyWtCzF&||diZWh{eA(hNk8VLe7a|{y2OdPi z!`d8ycS&SCtbq}D;BO>)9))*VWV}-p9@;Y!J*>6i{H*|=0uG4M&Kx`|@l@iWwKs_W+1kISu8dcqK2%O>_dp+31=+ej z&5#gW>5S9BmcU5#DCCCu?sHZ_x)K2NB8$ zyFg`(CwvMNjF!;S5;Wa-tuO(a5v?QaVxjHgE!ru&h zP7gY&%En>nn7(WVdS$Y1kg>hJSk*qNAIVmXY+ogBy%0t+h&HcbQr^f`lYIscvLG8_ z(~+E-(~&JlI+7`#j^qY7N^W3NgZa6Ye1q>~&sq0{@ywkQPkeWP@4t1Ek6>Uf;Ma12ia^!`*EFe zpl={P$~IE{33Q6vL^!-|z`z0lmYKpMmAQ{9PlPg`tZ*WfnPfthQ~eT;s6QuoJ@0d}Dw;8t z;Nuq;wX3V53A(Mu7JFf1^z9gs{BxsC+^8!(ToL6P>4KxlLjS&Yy1M^wS&-=dK#Y*kKdh@lI>(;sGg+fsQWk6zvk&|K^^kT0e!9~**&ye=u7UL z9vX9u-%07Vp#F*YtwZ`fC?m<_qp07;ve^xfVa!#&Z&nJ`?+nnGf%>WOt;#DP^D3{N zl|r&V6nJh&Y;2Oll}hE~I)n5{(XLc_Ux|3qA6{nC1LRNdWc!r=j0UV4VK7EH?Jwr!4iijP*SD5!wiR`3!vd9DJz0dNtsA)+$#!jkFYH2HK8muWJep1R%0Dn=Zy$`` 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 PFDV=MUDx-?wZr}oT6@2` literal 0 HcmV?d00001 diff --git a/testsuite/resources/VanDerPol3/binaries/aarch64-linux/VanDerPol.so b/testsuite/resources/VanDerPol3/binaries/aarch64-linux/VanDerPol.so new file mode 100644 index 0000000000000000000000000000000000000000..5d9696d2f0d97a0a4415b29efe66537c0b60cf86 GIT binary patch literal 71712 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 QKHb7M&i~&2|3=_{09c|PxBvhE literal 0 HcmV?d00001 diff --git a/testsuite/resources/VanDerPol3/binaries/x86_64-darwin/VanDerPol.dylib b/testsuite/resources/VanDerPol3/binaries/x86_64-darwin/VanDerPol.dylib new file mode 100644 index 0000000000000000000000000000000000000000..d3adbd7cc2982570be742c6e621aa9a8e822e226 GIT binary patch literal 88864 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/VanDerPol3/documentation/index.html b/testsuite/resources/VanDerPol3/documentation/index.html new file mode 100644 index 000000000..56b04de9f --- /dev/null +++ b/testsuite/resources/VanDerPol3/documentation/index.html @@ -0,0 +1,127 @@ + + + VanDerPol + + + +

+ + \ No newline at end of file diff --git a/testsuite/resources/VanDerPol3/documentation/result.svg b/testsuite/resources/VanDerPol3/documentation/result.svg new file mode 100644 index 000000000..17a14d5d7 --- /dev/null +++ b/testsuite/resources/VanDerPol3/documentation/result.svg @@ -0,0 +1 @@ +−2−101205101520−202time [s]x0x1 \ No newline at end of file diff --git a/testsuite/resources/VanDerPol3/modelDescription.xml b/testsuite/resources/VanDerPol3/modelDescription.xml new file mode 100644 index 000000000..dcb544110 --- /dev/null +++ b/testsuite/resources/VanDerPol3/modelDescription.xml @@ -0,0 +1,53 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testsuite/resources/VanDerPol3/sources/buildDescription.xml b/testsuite/resources/VanDerPol3/sources/buildDescription.xml new file mode 100644 index 000000000..316deeb9c --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/buildDescription.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/testsuite/resources/VanDerPol3/sources/config.h b/testsuite/resources/VanDerPol3/sources/config.h new file mode 100644 index 000000000..bdacc3851 --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/config.h @@ -0,0 +1,34 @@ +#ifndef config_h +#define config_h + +// define class name and unique id +#define MODEL_IDENTIFIER VanDerPol +#define INSTANTIATION_TOKEN "{BD403596-3166-4232-ABC2-132BDF73E644}" + +#define CO_SIMULATION +#define MODEL_EXCHANGE + +#define HAS_CONTINUOUS_STATES + +#define SET_FLOAT64 + +#define GET_PARTIAL_DERIVATIVE + +#define FIXED_SOLVER_STEP 1e-2 +#define DEFAULT_STOP_TIME 20 + +typedef enum { + vr_time, vr_x0, vr_der_x0, vr_x1, vr_der_x1, vr_mu +} ValueReference; + +typedef struct { + + double x0; + double der_x0; + double x1; + double der_x1; + double mu; + +} ModelData; + +#endif /* config_h */ diff --git a/testsuite/resources/VanDerPol3/sources/cosimulation.c b/testsuite/resources/VanDerPol3/sources/cosimulation.c new file mode 100644 index 000000000..782edf1b2 --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/cosimulation.c @@ -0,0 +1,691 @@ +#include // for calloc(), free() +#include // for DBL_EPSILON +#include +#include +#include +#include "config.h" +#include "cosimulation.h" + +#if FMI_VERSION == 3 +#include "fmi3Functions.h" +#endif + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#ifdef CALL +#undef CALL +#endif + +#define CALL(f) do { const Status status = f; if (status != OK) return status; } while (false) + + +ModelInstance *createModelInstance( + loggerType cbLogger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType) { + + ModelInstance *comp = NULL; + + if (!instanceName || strlen(instanceName) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, "?", Error, "error", "Missing instance name."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instance name."); +#endif + } + return NULL; + } + + if (!instantiationToken || strlen(instantiationToken) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Missing GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instantiationToken."); +#endif + } + return NULL; + } + + if (strcmp(instantiationToken, INSTANTIATION_TOKEN)) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Wrong GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Wrong instantiationToken."); +#endif + } + return NULL; + } + + comp = (ModelInstance *)calloc(1, sizeof(ModelInstance)); + + if (comp) { + comp->componentEnvironment = componentEnvironment; + comp->logger = cbLogger; + comp->intermediateUpdate = intermediateUpdate; + comp->lockPreemption = NULL; + comp->unlockPreemption = NULL; + comp->instanceName = strdup(instanceName); + comp->resourceLocation = resourceLocation ? strdup(resourceLocation) : NULL; + comp->status = OK; + comp->logEvents = loggingOn; + comp->logErrors = true; // always log errors + comp->nSteps = 0; + comp->earlyReturnAllowed = false; + comp->eventModeUsed = false; + } + + if (!comp || !comp->instanceName) { + logError(comp, "Out of memory."); + return NULL; + } + + comp->time = 0.0; // overwrite in fmi*SetupExperiment, fmi*SetTime + comp->type = interfaceType; + + comp->state = Instantiated; + + comp->newDiscreteStatesNeeded = false; + comp->terminateSimulation = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->valuesOfContinuousStatesChanged = false; + comp->nextEventTimeDefined = false; + comp->nextEventTime = 0; + + setStartValues(comp); + + comp->isDirtyValues = true; + + return comp; +} + +void freeModelInstance(ModelInstance *comp) { + + if (!comp) return; + + if (comp->instanceName) free((void*)comp->instanceName); + + if (comp->resourceLocation) free((void*)comp->resourceLocation); + + if (comp->prez) free(comp->prez); + + if (comp->z) free(comp->z); + + if (comp->x) free(comp->x); + + if (comp->dx) free(comp->dx); + + free(comp); +} + +static Status s_reallocate(ModelInstance* comp, void** memory, size_t size) { + + if (size == 0) { + if (*memory) { + free(*memory); + } + *memory = NULL; + return OK; + } + + void* temp = realloc(*memory, size); + + if (!temp) { + logError(comp, "Failed to allocate memory."); + return Error; + } + + *memory = temp; + + return OK; +} + +Status configurate(ModelInstance* comp) { + + (void)comp; + +#ifdef HAS_EVENT_INDICATORS + comp->nz = getNumberOfEventIndicators(comp); + + if (comp->nz > 0) { + CALL(s_reallocate(comp, (void**)&comp->prez, comp->nz * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->z, comp->nz * sizeof(double))); + } + + CALL(getEventIndicators(comp, comp->prez, comp->nz)); +#endif + +#ifdef HAS_CONTINUOUS_STATES + comp->nx = getNumberOfContinuousStates(comp); + + if (comp->nx > 0) { + CALL(s_reallocate(comp, (void**)&comp->x, comp->nx * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->dx, comp->nx * sizeof(double))); + } +#endif + + return OK; +} + +Status reset(ModelInstance* comp) { + + comp->state = Instantiated; + comp->startTime = 0.0; + comp->time = 0.0; + comp->nSteps = 0; + comp->status = OK; + setStartValues(comp); + comp->isDirtyValues = true; + + return OK; +} + +#define EPSILON (1.0e-5) + +static double fmiAbs(double v) { + return v >= 0 ? v : -v; +} + +static double fmiMax(double a, double b) { + return (a < b) ? b : a; +} + +bool isClose(double a, double b) { + + if (fmiAbs(a - b) <= EPSILON) { + return true; + } + + return fmiAbs(a - b) <= EPSILON * fmiMax(fmiAbs(a), fmiAbs(b)); +} + +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected) { + + if (actual != expected) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = %d. Expected %d.", f, arg, actual, expected); + return true; + } + + return false; +} + +bool invalidState(ModelInstance *comp, const char *f, int statesExpected) { + + UNUSED(f); + UNUSED(statesExpected); + + if (!comp) { + return true; + } + + // TODO: add missing states and check state + return false; + +// if (!(comp->state & statesExpected)) { +// comp->state = modelError; +// logError(comp, "%s: Illegal call sequence.", f); +// return true; +// } +// +// return false; +} + +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p) { + + if (!p) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = NULL.", f, arg); + return true; + } + + return false; +} + +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]) { + + if (nCategories > 0) { + + if (categories == NULL) { + logError(comp, "Argument categories must not be NULL."); + return Error; + } + + for (size_t i = 0; i < nCategories; i++) { + + if (categories[i] == NULL) { + logError(comp, "Argument categories[%zu] must not be NULL.", i); + return Error; + } else if (strcmp(categories[i], "logEvents") == 0) { + comp->logEvents = loggingOn; + } else if (strcmp(categories[i], "logStatusError") == 0) { + comp->logErrors = loggingOn; + } else { + logError(comp, "Log categories[%zu] must be one of \"logEvents\" or \"logStatusError\" but was \"%s\".", i, categories[i]); + return Error; + } + } + + } else { + + comp->logEvents = loggingOn; + comp->logErrors = loggingOn; + + } + + return OK; +} + +static void logMessage(ModelInstance *comp, int status, const char *category, const char *message, va_list args) { + + if (!comp->logger) { + return; + } + + va_list args1; + int len = 0; + char *buf = ""; + + va_copy(args1, args); + len = vsnprintf(buf, len, message, args1); + va_end(args1); + + if (len < 0) { + return; + } + + va_copy(args1, args); + buf = (char *)calloc(len + 1, sizeof(char)); + len = vsnprintf(buf, len + 1, message, args); + va_end(args1); + + if (len >= 0) { + // no need to distinguish between FMI versions since we're not using variadic arguments +#if FMI_VERSION < 3 + comp->logger(comp->componentEnvironment, comp->instanceName, status, category, buf); +#else + comp->logger(comp->componentEnvironment, status, category, buf); +#endif + } + + free(buf); +} + +void logEvent(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logEvents) return; + + va_list args; + va_start(args, message); + logMessage(comp, OK, "logEvents", message, args); + va_end(args); +} + +void logError(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logErrors) return; + + va_list args; + va_start(args, message); + logMessage(comp, Error, "logStatusError", message, args); + va_end(args); +} + +#define GET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Getting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef GET_FLOAT32 +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + GET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef GET_INT8 +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef GET_UINT8 +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef GET_INT16 +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int16"); + +} +#endif + +#ifndef GET_UINT16 +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef GET_INT32 +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef GET_UINT32 +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef GET_INT64 +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef GET_UINT64 +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef GET_BOOLEAN +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef GET_STRING +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("String"); +} +#endif + +#ifndef GET_BINARY +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index) { + UNUSED(sizes); + GET_NOT_ALLOWED("Binary"); +} +#endif + +#define SET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Setting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef SET_FLOAT32 +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef SET_FLOAT64 +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float64"); +} +#endif + +#ifndef SET_INT8 +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef SET_UINT8 +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef SET_INT16 +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int16"); +} +#endif + +#ifndef SET_UINT16 +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef SET_INT32 +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef SET_UINT32 +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef SET_INT64 +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef SET_UINT64 +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef SET_BOOLEAN +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef SET_STRING +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("String"); +} +#endif + +#ifndef SET_BINARY +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char *const values[], size_t nValues, size_t* index) { + UNUSED(size); + SET_NOT_ALLOWED("Binary"); +} +#endif + +#ifndef ACTIVATE_CLOCK +Status activateClock(ModelInstance* comp, ValueReference vr) { + UNUSED(comp); + UNUSED(vr); + return Error; +} +#endif + +#ifndef GET_CLOCK +Status getClock(ModelInstance* comp, ValueReference vr, bool* value) { + UNUSED(comp); + UNUSED(vr); + UNUSED(value); + return Error; +} +#endif + +#ifndef GET_INTERVAL +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier) { + UNUSED(comp); + UNUSED(vr); + UNUSED(interval); + UNUSED(qualifier); + return Error; +} +#endif + +#ifndef ACTIVATE_MODEL_PARTITION +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime) { + UNUSED(comp); + UNUSED(vr); + UNUSED(activationTime); + return Error; +} +#endif + +#ifndef GET_PARTIAL_DERIVATIVE +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + UNUSED(comp); + UNUSED(unknown); + UNUSED(known); + UNUSED(partialDerivative); + logError(comp, "Directional derivatives are not supported."); + return Error; +} +#endif + +Status getFMUState(ModelInstance* comp, void** FMUState) { + + CALL(s_reallocate(comp, FMUState, sizeof(ModelInstance))); + + memcpy(*FMUState, comp, sizeof(ModelInstance)); + + return OK; +} + +Status setFMUState(ModelInstance* comp, void* FMUState) { + + ModelInstance* s = (ModelInstance*)FMUState; + + comp->startTime = s->startTime; + comp->stopTime = s->stopTime; + comp->time = s->time; + // instanceName + // type + // resourceLocation + + comp->status = s->status; + + // logger + // intermediateUpdate + // clockUpdate + + // lockPreemption + // unlockPreemption + + // logEvents + // logErrors + + // componentEnvironment + comp->state = s->state; + + comp->newDiscreteStatesNeeded = s->newDiscreteStatesNeeded; + comp->terminateSimulation = s->terminateSimulation; + comp->nominalsOfContinuousStatesChanged = s->nominalsOfContinuousStatesChanged; + comp->valuesOfContinuousStatesChanged = s->valuesOfContinuousStatesChanged; + comp->nextEventTimeDefined = s->nextEventTimeDefined; + comp->nextEventTime = s->nextEventTime; + comp->clocksTicked = s->clocksTicked; + + comp->isDirtyValues = s->isDirtyValues; + + comp->modelData = s->modelData; + + comp->nSteps = s->nSteps; + + comp->earlyReturnAllowed = s->earlyReturnAllowed; + comp->eventModeUsed = s->eventModeUsed; + comp->nextCommunicationPoint = s->nextCommunicationPoint; + + if (comp->nx > 0) { + memcpy(comp->x, s->x, s->nx * sizeof(double)); + memcpy(comp->dx, s->dx, s->nx * sizeof(double)); + } + + if (comp->nz > 0) { + memcpy(comp->z, s->z, s->nz * sizeof(double)); + } + + comp->nSteps = s->nSteps; + + return OK; +} + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent) { + +#ifdef HAS_CONTINUOUS_STATES + if (comp->nx > 0) { + + CALL(getContinuousStates(comp, comp->x, comp->nx)); + CALL(getDerivatives(comp, comp->dx, comp->nx)); + + // forward Euler step + for (size_t i = 0; i < comp->nx; i++) { + comp->x[i] += FIXED_SOLVER_STEP * comp->dx[i]; + } + + CALL(setContinuousStates(comp, comp->x, comp->nx)); + } +#endif + + comp->nSteps++; + + comp->time = comp->startTime + comp->nSteps * FIXED_SOLVER_STEP; + + // state event + *stateEvent = false; + +#ifdef HAS_EVENT_INDICATORS + if (comp->nz > 0) { + + CALL(getEventIndicators(comp, comp->z, comp->nz)); + + // check for zero-crossings + for (size_t i = 0; i < comp->nz; i++) { + *stateEvent |= + (comp->prez[i] <= 0 && comp->z[i] > 0) || + (comp->prez[i] > 0 && comp->z[i] <= 0); + } + + // remember the current event indicators + double* temp = comp->prez; + comp->prez = comp->z; + comp->z = temp; + } +#endif + + // time event + *timeEvent = comp->nextEventTimeDefined && comp->time >= comp->nextEventTime; + + bool earlyReturnRequested; + double earlyReturnTime; + + // intermediate update + if (comp->intermediateUpdate) { + comp->intermediateUpdate( + comp->componentEnvironment, // instanceEnvironment + comp->time, // intermediateUpdateTime + false, // intermediateVariableSetRequested + true, // intermediateVariableGetAllowed + true, // intermediateStepFinished + false, // canReturnEarly + &earlyReturnRequested, // earlyReturnRequested + &earlyReturnTime); // earlyReturnTime + } + + return OK; +} diff --git a/testsuite/resources/VanDerPol3/sources/cosimulation.h b/testsuite/resources/VanDerPol3/sources/cosimulation.h new file mode 100644 index 000000000..fda1ebf99 --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/cosimulation.h @@ -0,0 +1,5 @@ +#pragma once + +#include "model.h" + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent); diff --git a/testsuite/resources/VanDerPol3/sources/fmi3Functions.c b/testsuite/resources/VanDerPol3/sources/fmi3Functions.c new file mode 100644 index 000000000..b4ad5fbb2 --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/fmi3Functions.c @@ -0,0 +1,1446 @@ +#if FMI_VERSION != 3 +#error FMI_VERSION must be 3 +#endif + +#include +#include +#include +#include +#include + +#include "config.h" +#include "model.h" +#include "cosimulation.h" + +// C-code FMUs have functions names prefixed with MODEL_IDENTIFIER_. +// Define DISABLE_PREFIX to build a binary FMU. +#if !defined(DISABLE_PREFIX) && !defined(FMI3_FUNCTION_PREFIX) +#define pasteA(a,b) a ## b +#define pasteB(a,b) pasteA(a,b) +#define FMI3_FUNCTION_PREFIX pasteB(MODEL_IDENTIFIER, _) +#endif +#include "fmi3Functions.h" + +#define ASSERT_NOT_NULL(p) \ +do { \ + if (!p) { \ + logError(S, "Argument %s must not be NULL.", xstr(p)); \ + S->state = Terminated; \ + return (fmi3Status)Error; \ + } \ +} while (0) + +#define CALL(f) do { \ + const Status s = f; \ + if (s > status) { \ + status = s; \ + } \ + if (status == Discard) { \ + goto TERMINATE; \ + } else if (status == Error) { \ + S->state = Terminated; \ + goto TERMINATE; \ + } else if (status == Fatal) { \ + S->state = StartAndEnd; \ + goto TERMINATE; \ + } \ +} while (false) + +#define GET_VARIABLES(T) \ +BEGIN_FUNCTION(Get ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +if (nValues > 0) ASSERT_NOT_NULL(values); \ +if (S->isDirtyValues) { \ + CALL(calculateValues(S)); \ + S->isDirtyValues = false; \ +} \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(get ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#define SET_VARIABLES(T) \ +BEGIN_FUNCTION(Set ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(set ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (nValueReferences > 0) S->isDirtyValues = true; \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#ifndef max +#define max(a,b) ((a)>(b) ? (a) : (b)) +#endif + +#ifndef DT_EVENT_DETECT +#define DT_EVENT_DETECT 1e-10 +#endif + +// --------------------------------------------------------------------------- +// Function calls allowed state masks for both Model-exchange and Co-simulation +// --------------------------------------------------------------------------- +#define MASK_AnyState (~0) + +/* Inquire version numbers and set debug logging */ +#define MASK_fmi3GetVersion MASK_AnyState +#define MASK_fmi3SetDebugLogging MASK_AnyState + +/* Creation and destruction of FMU instances */ +#define MASK_fmi3InstantiateInstantiateModelExchange MASK_AnyState +#define MASK_fmi3InstantiateCoSimulation MASK_AnyState +#define MASK_fmi3InstantiateScheduledExectuion MASK_AnyState +#define MASK_fmi3FreeInstance MASK_AnyState + +/* Enter and exit initialization mode, terminate and reset */ +#define MASK_fmi3EnterInitializationMode Instantiated +#define MASK_fmi3ExitInitializationMode InitializationMode +#define MASK_fmi3EnterEventMode (ContinuousTimeMode | StepMode) +#define MASK_fmi3Terminate (ContinuousTimeMode | StepMode | StepDiscarded | EventMode | ClockActivationMode | ReconfigurationMode) +#define MASK_fmi3Reset MASK_AnyState + +/* Common Functions */ + +/* Getting and setting variable values */ +#define MASK_fmi3GetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3GetFloat64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetBoolean MASK_fmi3GetFloat32 +#define MASK_fmi3GetString MASK_fmi3GetFloat32 +#define MASK_fmi3GetBinary MASK_fmi3GetFloat32 +#define MASK_fmi3GetClock MASK_AnyState + +#define MASK_fmi3SetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3SetFloat64 MASK_fmi3SetFloat32 +#define MASK_fmi3SetInt8 (Instantiated | ConfigurationMode | ReconfigurationMode | InitializationMode | EventMode | StepMode | ClockActivationMode | Terminated) +#define MASK_fmi3SetUInt8 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetBoolean MASK_fmi3SetInt8 +#define MASK_fmi3SetString MASK_fmi3SetInt8 +#define MASK_fmi3SetBinary MASK_fmi3SetInt8 +#define MASK_fmi3SetClock MASK_AnyState + +/* Getting Variable Dependency Information */ +#define MASK_fmi3GetNumberOfVariableDependencies MASK_AnyState +#define MASK_fmi3GetVariableDependencies MASK_AnyState + +/* Getting and setting the internal FMU state */ +#define MASK_fmi3GetFMUState MASK_AnyState +#define MASK_fmi3SetFMUState MASK_AnyState +#define MASK_fmi3FreeFMUState MASK_AnyState +#define MASK_fmi3SerializedFMUStateSize MASK_AnyState +#define MASK_fmi3SerializeFMUState MASK_AnyState +#define MASK_fmi3DeserializeFMUState MASK_AnyState + +/* Getting partial derivatives */ +#define MASK_fmi3GetDirectionalDerivative (InitializationMode | StepMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetAdjointDerivative MASK_fmi3GetDirectionalDerivative + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define MASK_fmi3EnterConfigurationMode (Instantiated | StepMode | EventMode | ClockActivationMode) +#define MASK_fmi3ExitConfigurationMode (ConfigurationMode | ReconfigurationMode) + +/* Clock related functions */ +// TODO: fix masks +#define MASK_fmi3GetIntervalDecimal MASK_AnyState +#define MASK_fmi3GetIntervalFraction MASK_AnyState +#define MASK_fmi3SetIntervalDecimal MASK_AnyState +#define MASK_fmi3SetIntervalFraction MASK_AnyState +#define MASK_fmi3NewDiscreteStates MASK_AnyState + +/* Functions for Model Exchange */ + +#define MASK_fmi3EnterContinuousTimeMode EventMode +#define MASK_fmi3CompletedIntegratorStep ContinuousTimeMode + +/* Providing independent variables and re-initialization of caching */ +#define MASK_fmi3SetTime (EventMode | ContinuousTimeMode) +#define MASK_fmi3SetContinuousStates ContinuousTimeMode + +/* Evaluation of the model equations */ +#define MASK_fmi3GetContinuousStateDerivatives (InitializationMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetEventIndicators MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetContinuousStates MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetNominalsOfContinuousStates MASK_fmi3GetContinuousStateDerivatives + +#define MASK_fmi3GetNumberOfContinuousStates MASK_AnyState +#define MASK_fmi3GetNumberOfEventIndicators MASK_AnyState + +/* Functions for Co-Simulation */ + +#define MASK_fmi3EnterStepMode (InitializationMode | EventMode) +#define MASK_fmi3SetInputDerivatives (Instantiated | InitializationMode | StepMode) +#define MASK_fmi3GetOutputDerivatives (StepMode | StepDiscarded | Terminated) +#define MASK_fmi3DoStep StepMode +#define MASK_fmi3ActivateModelPartition ClockActivationMode +#define MASK_fmi3DoEarlyReturn IntermediateUpdateMode +#define MASK_fmi3GetDoStepDiscardedStatus StepMode + +// --------------------------------------------------------------------------- +// Private helpers used below to validate function arguments +// --------------------------------------------------------------------------- + +#define NOT_IMPLEMENTED \ +do { \ + ModelInstance *comp = (ModelInstance *)instance; \ + logError(comp, "Function is not implemented."); \ + return fmi3Error; \ +} while (0) + +#define BEGIN_FUNCTION(F) \ +Status status = OK; \ +if (!instance) return fmi3Error; \ +ModelInstance *S = (ModelInstance *)instance; \ +if (!allowedState(S, MASK_fmi3##F, #F)) CALL(Error); + +#define END_FUNCTION() \ +TERMINATE: \ + return (fmi3Status)status; + +static bool allowedState(ModelInstance *instance, int statesExpected, char *name) { + + if (!instance) { + return false; + } + + if (!(instance->state & statesExpected)) { + logError(instance, "fmi3%s: Illegal call sequence.", name); + return false; + } + + return true; +} + +/*************************************************** + Common Functions + ****************************************************/ + +const char* fmi3GetVersion(void) { + return fmi3Version; +} + +fmi3Status fmi3SetDebugLogging(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]) { + + BEGIN_FUNCTION(SetDebugLogging); + + CALL(setDebugLogging(S, loggingOn, nCategories, categories)); + + END_FUNCTION(); +} + +fmi3Instance fmi3InstantiateModelExchange( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage) { + + UNUSED(visible); + +#ifndef MODEL_EXCHANGE + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + + return NULL; +#else + return createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ModelExchange); +#endif +} + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) { + + UNUSED(visible); + UNUSED(requiredIntermediateVariables); + UNUSED(nRequiredIntermediateVariables); + +#ifndef EVENT_UPDATE + if (eventModeUsed) { + if (logMessage) { + logMessage(instanceEnvironment, fmi3Error, "error", "Event Mode is not supported."); + } + return NULL; + } +#endif + + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + (intermediateUpdateType)intermediateUpdate, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + CoSimulation); + + if (instance) { + instance->earlyReturnAllowed = earlyReturnAllowed; + instance->eventModeUsed = eventModeUsed; + instance->state = Instantiated; + } + + return instance; +} + +fmi3Instance fmi3InstantiateScheduledExecution( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption) { + + UNUSED(visible); + +#ifndef SCHEDULED_CO_SIMULATION + + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + UNUSED(clockUpdate); + UNUSED(lockPreemption); + UNUSED(unlockPreemption); + + return NULL; +#else + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ScheduledExecution + ); + + if (instance) { + instance->state = Instantiated; + instance->clockUpdate = clockUpdate; + instance->lockPreemption = lockPreemption; + instance->unlockPreemption = unlockPreemption; + } + + return instance; +#endif +} + +void fmi3FreeInstance(fmi3Instance instance) { + freeModelInstance((ModelInstance*)instance); +} + +fmi3Status fmi3EnterInitializationMode(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime) { + + UNUSED(toleranceDefined); + UNUSED(tolerance); + + BEGIN_FUNCTION(EnterInitializationMode); + + S->startTime = startTime; + S->stopTime = stopTimeDefined ? stopTime : INFINITY; + S->time = startTime; + S->nextCommunicationPoint = startTime; + S->state = InitializationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitInitializationMode); + + // if values were set and no fmi3GetXXX triggered update before, + // ensure calculated values are updated now + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = S->eventModeUsed ? EventMode : StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + + CALL(configurate(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3EnterEventMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterEventMode); + + S->state = EventMode; + + END_FUNCTION(); +} + +fmi3Status fmi3Terminate(fmi3Instance instance) { + + BEGIN_FUNCTION(Terminate); + + S->state = Terminated; + + END_FUNCTION(); +} + +fmi3Status fmi3Reset(fmi3Instance instance) { + + BEGIN_FUNCTION(Reset); + + CALL(reset(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues) { + GET_VARIABLES(Float32); +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) { + GET_VARIABLES(Float64); +} + +fmi3Status fmi3GetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues) { + GET_VARIABLES(Int8); +} + +fmi3Status fmi3GetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues) { + GET_VARIABLES(UInt8); +} + +fmi3Status fmi3GetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues) { + GET_VARIABLES(Int16); +} + +fmi3Status fmi3GetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues) { + GET_VARIABLES(UInt16); +} + +fmi3Status fmi3GetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues) { + GET_VARIABLES(Int32); +} + +fmi3Status fmi3GetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues) { + GET_VARIABLES(UInt32); +} + +fmi3Status fmi3GetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues) { + GET_VARIABLES(Int64); +} + +fmi3Status fmi3GetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues) { + GET_VARIABLES(UInt64); +} + +fmi3Status fmi3GetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues) { + GET_VARIABLES(Boolean); +} + +fmi3Status fmi3GetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues) { + GET_VARIABLES(String); +} + +fmi3Status fmi3GetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(GetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } else { + ASSERT_NOT_NULL(valueReferences); + } + + if (nValues > 0) { + ASSERT_NOT_NULL(values); + } + + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char**)values, nValues, &index)); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]) { + + BEGIN_FUNCTION(GetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getClock(instance, (ValueReference)valueReferences[i], &values[i])); + } + END_FUNCTION(); +} + +fmi3Status fmi3SetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues) { + SET_VARIABLES(Float32); +} + +fmi3Status fmi3SetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues) { + SET_VARIABLES(Float64); +} + +fmi3Status fmi3SetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues) { + SET_VARIABLES(Int8); +} + +fmi3Status fmi3SetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues) { + SET_VARIABLES(UInt8); +} + +fmi3Status fmi3SetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues) { + SET_VARIABLES(Int16); +} + +fmi3Status fmi3SetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues) { + SET_VARIABLES(UInt16); +} + +fmi3Status fmi3SetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues) { + SET_VARIABLES(Int32); +} + +fmi3Status fmi3SetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues) { + SET_VARIABLES(UInt32); +} + +fmi3Status fmi3SetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues) { + SET_VARIABLES(Int64); +} + +fmi3Status fmi3SetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues) { + SET_VARIABLES(UInt64); +} + +fmi3Status fmi3SetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues) { + SET_VARIABLES(Boolean); +} + +fmi3Status fmi3SetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues) { + SET_VARIABLES(String); +} + +fmi3Status fmi3SetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(SetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } + + ASSERT_NOT_NULL(valueReferences); + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(setBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char* const*)values, nValues, &index)); + } + + if (nValueReferences > 0) { + S->isDirtyValues = true; + } + + if (index != nValues) { + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); + } + + END_FUNCTION(); +} + +fmi3Status fmi3SetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]) { + + BEGIN_FUNCTION(SetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + if (values[i]) { + CALL(activateClock(instance, (ValueReference)valueReferences[i])); + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfVariableDependencies(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies) { + UNUSED(valueReference); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetVariableDependencies(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies) { + + UNUSED(dependent); + UNUSED(elementIndicesOfDependent); + UNUSED(independents); + UNUSED(elementIndicesOfIndependents); + UNUSED(dependencyKinds); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(GetFMUState); + + CALL(getFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState FMUState) { + + BEGIN_FUNCTION(SetFMUState); + + if (nullPointer(S, "fmi3SetFMUState", "FMUState", FMUState)) { + return fmi3Error; + } + + CALL(setFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(FreeFMUState); + + free(*FMUState); + + *FMUState = NULL; + + END_FUNCTION(); +} + +fmi3Status fmi3SerializedFMUStateSize(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size) { + + UNUSED(instance); + UNUSED(FMUState); + + BEGIN_FUNCTION(SerializedFMUStateSize); + + *size = sizeof(ModelInstance); + + END_FUNCTION(); +} + +fmi3Status fmi3SerializeFMUState(fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size) { + + BEGIN_FUNCTION(SerializeFMUState); + + if (nullPointer(S, "fmi3SerializeFMUState", "FMUstate", FMUState)) { + return fmi3Error; + } + + if (invalidNumber(S, "fmi3SerializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + memcpy(serializedState, FMUState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3DeserializeFMUState(fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(DeserializeFMUState); + + if (invalidNumber(S, "fmi3DeserializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + if (*FMUState == NULL) { + *FMUState = calloc(1, sizeof(ModelInstance)); + if (*FMUState == NULL) { + printf("Failed to allocate memory for FMUState.\n"); + return fmi3Error; + } + } + + memcpy(*FMUState, serializedState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetDirectionalDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetDirectionalDerivative); + + // TODO: check value references + // TODO: assert nUnknowns == nDeltaOfUnknowns + // TODO: assert nKnowns == nDeltaKnowns + + for (size_t i = 0; i < nUnknowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nKnowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[i], (ValueReference)knowns[j], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetAdjointDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetAdjointDerivative); + + // TODO: check value references + + for (size_t i = 0; i < nKnowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nUnknowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[j], (ValueReference)knowns[i], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3EnterConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterConfigurationMode); + + S->state = (S->state == Instantiated) ? ConfigurationMode : ReconfigurationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitConfigurationMode); + + if (S->state == ConfigurationMode) { + S->state = Instantiated; + } else { + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + } + +#if defined(HAS_CONTINUOUS_STATES) || defined(HAS_EVENT_INDICATORS) + CALL(configurate(S)); +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]) { + + BEGIN_FUNCTION(GetIntervalDecimal); + + // TODO: Check nValueReferences != nValues ? + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getInterval(instance, (ValueReference)valueReferences[i], &intervals[i], (int*)&qualifiers[i])); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 intervalCounters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + UNUSED(qualifiers); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 shiftCounters[], + fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervals); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 intervalCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 shiftCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3EvaluateDiscreteStates(fmi3Instance instance) { + NOT_IMPLEMENTED; +} + +fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime) { + + BEGIN_FUNCTION(NewDiscreteStates); + +#ifdef EVENT_UPDATE + CALL(eventUpdate(S)); +#endif + + // copy internal eventInfo of component to output arguments + if (discreteStatesNeedUpdate) *discreteStatesNeedUpdate = S->newDiscreteStatesNeeded; + if (terminateSimulation) *terminateSimulation = S->terminateSimulation; + if (nominalsOfContinuousStatesChanged) *nominalsOfContinuousStatesChanged = S->nominalsOfContinuousStatesChanged; + if (valuesOfContinuousStatesChanged) *valuesOfContinuousStatesChanged = S->valuesOfContinuousStatesChanged; + if (nextEventTimeDefined) *nextEventTimeDefined = S->nextEventTimeDefined; + if (nextEventTime) *nextEventTime = S->nextEventTime; + + END_FUNCTION(); +} + +/*************************************************** + Functions for Model Exchange + ****************************************************/ + +fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterContinuousTimeMode); + + S->state = ContinuousTimeMode; + + END_FUNCTION(); +} + +fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(CompletedIntegratorStep); + + ASSERT_NOT_NULL(enterEventMode); + ASSERT_NOT_NULL(terminateSimulation); + + *enterEventMode = fmi3False; + *terminateSimulation = fmi3False; + + END_FUNCTION(); +} + +/* Providing independent variables and re-initialization of caching */ +fmi3Status fmi3SetTime(fmi3Instance instance, fmi3Float64 time) { + + BEGIN_FUNCTION(SetTime); + + S->time = time; + + END_FUNCTION(); +} + +fmi3Status fmi3SetContinuousStates(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(SetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3SetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + ASSERT_NOT_NULL(continuousStates); + + CALL(setContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +/* Evaluation of the model equations */ +fmi3Status fmi3GetContinuousStateDerivatives(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStateDerivatives); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStateDerivatives", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStateDerivatives", "derivatives[]", derivatives)) + return fmi3Error; + + CALL(getDerivatives(S, derivatives, nContinuousStates)); +#else + UNUSED(derivatives); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetEventIndicators(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators) { + + BEGIN_FUNCTION(GetEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + if (invalidNumber(S, "fmi3GetEventIndicators", "nEventIndicators", nEventIndicators, getNumberOfEventIndicators(S))) { + return fmi3Error; + } + + CALL(getEventIndicators(S, eventIndicators, nEventIndicators)); +#else + + UNUSED(eventIndicators); + + if (nEventIndicators > 0) { + // TODO: log error + return fmi3Error; + } +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetContinuousStates(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStates", "continuousStates[]", continuousStates)) + return fmi3Error; + + CALL(getContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNominalsOfContinuousStates(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetNominalsOfContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetNominalContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(instance))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetNominalContinuousStates", "nominals[]", nominals)) + return fmi3Error; + + for (size_t i = 0; i < nContinuousStates; i++) { + nominals[i] = 1; + } + + return fmi3OK; +#else + UNUSED(nominals); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfEventIndicators(fmi3Instance instance, + size_t* nEventIndicators) { + + BEGIN_FUNCTION(GetNumberOfEventIndicators); + + ASSERT_NOT_NULL(nEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + *nEventIndicators = getNumberOfEventIndicators(instance); +#else + *nEventIndicators = 0; +#endif + + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfContinuousStates(fmi3Instance instance, + size_t* nContinuousStates) { + + BEGIN_FUNCTION(GetNumberOfContinuousStates); + + ASSERT_NOT_NULL(nContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + *nContinuousStates = getNumberOfContinuousStates(instance); +#else + *nContinuousStates = 0; +#endif + + END_FUNCTION(); +} + +/*************************************************** + Functions for Co-Simulation + ****************************************************/ + +fmi3Status fmi3EnterStepMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterStepMode); + + S->state = StepMode; + + END_FUNCTION(); +} + +fmi3Status fmi3GetOutputDerivatives(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues) { + + UNUSED(nValues); + + BEGIN_FUNCTION(GetOutputDerivatives); + +#ifdef GET_OUTPUT_DERIVATIVE + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getOutputDerivative(S, (ValueReference)valueReferences[i], orders[i], &values[i])); + } +#else + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(orders); + UNUSED(values); + + NOT_IMPLEMENTED; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(DoStep); + + if (!isClose(currentCommunicationPoint, S->nextCommunicationPoint)) { + logError(S, "Expected currentCommunicationPoint = %.16g but was %.16g.", + S->nextCommunicationPoint, currentCommunicationPoint); + CALL(Error); + } + + if (communicationStepSize <= 0) { + logError(S, "Communication step size must be > 0 but was %.16g.", communicationStepSize); + CALL(Error); + } + + const fmi3Float64 nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + + if (nextCommunicationPoint > S->stopTime && !isClose(nextCommunicationPoint, S->stopTime)) { + logError(S, "At communication point %.16g a step size of %.16g was requested but stop time is %.16g.", + currentCommunicationPoint, communicationStepSize, S->stopTime); + CALL(Error); + } + + bool nextCommunicationPointReached; + + *eventHandlingNeeded = fmi3False; + *terminateSimulation = fmi3False; + *earlyReturn = fmi3False; + + while (true) { + + const fmi3Float64 nextSolverStepTime = S->time + FIXED_SOLVER_STEP; + + nextCommunicationPointReached = nextSolverStepTime > nextCommunicationPoint && !isClose(nextSolverStepTime, nextCommunicationPoint); + + if (nextCommunicationPointReached || (*eventHandlingNeeded && S->earlyReturnAllowed)) { + break; + } + +#ifdef EVENT_UPDATE + if (*eventHandlingNeeded) { + eventUpdate(S); + *eventHandlingNeeded = fmi3False; + } +#endif + + bool stateEvent, timeEvent; + + CALL(doFixedStep(S, &stateEvent, &timeEvent)); + +#ifdef EVENT_UPDATE + if (stateEvent || timeEvent) { + + if (S->eventModeUsed) { + *eventHandlingNeeded = fmi3True; + } else { + CALL(eventUpdate(S)); +#ifdef HAS_EVENT_INDICATORS + CALL(getEventIndicators(S, S->prez, S->nz)); +#endif + } + + if (S->earlyReturnAllowed) { + break; + } + } +#endif + + if (S->terminateSimulation) { + break; + } + } + + *terminateSimulation = S->terminateSimulation; + *earlyReturn = S->earlyReturnAllowed && !nextCommunicationPointReached; + *lastSuccessfulTime = S->time; + + if (nextCommunicationPointReached) { + S->nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + } else { + S->nextCommunicationPoint = S->time; + } + + END_FUNCTION(); +} + +fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime) { + + BEGIN_FUNCTION(ActivateModelPartition); + + CALL(activateModelPartition(S, (ValueReference)clockReference, activationTime)); + + END_FUNCTION(); +} diff --git a/testsuite/resources/VanDerPol3/sources/model.c b/testsuite/resources/VanDerPol3/sources/model.c new file mode 100644 index 000000000..51600e1ed --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/model.c @@ -0,0 +1,130 @@ +#include "config.h" +#include "model.h" + + +void setStartValues(ModelInstance *comp) { + M(x0) = 2; + M(x1) = 0; + M(mu) = 1; +} + +Status calculateValues(ModelInstance *comp) { + M(der_x0) = M(x1); + M(der_x1) = M(mu) * ((1.0 - M(x0) * M(x0)) * M(x1)) - M(x0); + return OK; +} + +Status getFloat64(ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + calculateValues(comp); + + switch (vr) { + case vr_time: + values[(*index)++] = comp->time; + return OK; + case vr_x0: + values[(*index)++] = M(x0); + return OK; + case vr_der_x0 : + values[(*index)++] = M(der_x0); + return OK; + case vr_x1: + values[(*index)++] = M(x1); + return OK; + case vr_der_x1: + values[(*index)++] = M(der_x1); + return OK; + case vr_mu: + values[(*index)++] = M(mu); + return OK; + default: + logError(comp, "Get Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_x0: + M(x0) = values[(*index)++]; + return OK; + case vr_x1: + M(x1) = values[(*index)++]; + return OK; + case vr_mu: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != EventMode) { + logError(comp, "Variable mu can only be set after instantiation, in initialization mode or event mode."); + return Error; + } +#endif + M(mu) = values[(*index)++]; + return OK; + default: + logError(comp, "Set Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + +size_t getNumberOfContinuousStates(ModelInstance* comp) { + UNUSED(comp); + return 2; +} + +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx) { + UNUSED(nx); + x[0] = M(x0); + x[1] = M(x1); + return OK; +} + +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx) { + UNUSED(nx); + M(x0) = x[0]; + M(x1) = x[1]; + calculateValues(comp); + return OK; +} + +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx) { + UNUSED(nx); + calculateValues(comp); + dx[0] = M(der_x0); + dx[1] = M(der_x1); + return OK; +} + +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + + if (unknown == vr_der_x0 && known == vr_x0) { + *partialDerivative = 0; + } else if (unknown == vr_der_x0 && known == vr_x1) { + *partialDerivative = 1; + } else if (unknown == vr_der_x1 && known == vr_x0) { + *partialDerivative = -2 * M(x0) * M(x1) * M(mu) - 1; + } else if (unknown == vr_der_x1 && known == vr_x1) { + *partialDerivative = M(mu) * (1 - M(x0) * M(x0)); + } else { + *partialDerivative = 0; + } + + return OK; +} + +Status eventUpdate(ModelInstance *comp) { + + comp->valuesOfContinuousStatesChanged = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->terminateSimulation = false; + comp->nextEventTimeDefined = false; + + return OK; +} diff --git a/testsuite/resources/VanDerPol3/sources/model.h b/testsuite/resources/VanDerPol3/sources/model.h new file mode 100644 index 000000000..8dabb0cad --- /dev/null +++ b/testsuite/resources/VanDerPol3/sources/model.h @@ -0,0 +1,250 @@ +#pragma once + +#if FMI_VERSION != 1 && FMI_VERSION != 2 && FMI_VERSION != 3 +#error FMI_VERSION must be one of 1, 2 or 3 +#endif + +#define UNUSED(x) (void)(x) + +#include // for size_t +#include // for bool +#include + +#include "config.h" + +#if FMI_VERSION == 1 + +#define not_modelError (Instantiated| Initialized | Terminated) + +typedef enum { + Instantiated = 1<<0, + Initialized = 1<<1, + Terminated = 1<<2, + modelError = 1<<3 +} ModelState; + +#elif FMI_VERSION == 2 + +typedef enum { + StartAndEnd = 1<<0, + Instantiated = 1<<1, + InitializationMode = 1<<2, + + // ME states + EventMode = 1<<3, + ContinuousTimeMode = 1<<4, + + // CS states + StepComplete = 1<<5, + StepInProgress = 1<<6, + StepFailed = 1<<7, + StepCanceled = 1<<8, + + Terminated = 1<<9, +} ModelState; + +#else + +typedef enum { + StartAndEnd = 1 << 0, + ConfigurationMode = 1 << 1, + Instantiated = 1 << 2, + InitializationMode = 1 << 3, + EventMode = 1 << 4, + ContinuousTimeMode = 1 << 5, + StepMode = 1 << 6, + ClockActivationMode = 1 << 7, + StepDiscarded = 1 << 8, + ReconfigurationMode = 1 << 9, + IntermediateUpdateMode = 1 << 10, + Terminated = 1 << 11, +} ModelState; + +#endif + +typedef enum { + ModelExchange, + CoSimulation, + ScheduledExecution, +} InterfaceType; + +typedef enum { + OK, + Warning, + Discard, + Error, + Fatal, + Pending +} Status; + +#if FMI_VERSION < 3 +typedef void (*loggerType) (void *componentEnvironment, const char *instanceName, int status, const char *category, const char *message, ...); +#else +typedef void (*loggerType) (void *componentEnvironment, int status, const char *category, const char *message); +#endif + +typedef void (*lockPreemptionType) (void); +typedef void (*unlockPreemptionType) (void); + + +typedef void (*intermediateUpdateType) (void *instanceEnvironment, + double intermediateUpdateTime, + bool intermediateVariableSetRequested, + bool intermediateVariableGetAllowed, + bool intermediateStepFinished, + bool canReturnEarly, + bool *earlyReturnRequested, + double *earlyReturnTime); + +typedef void(*clockUpdateType) (void *instanceEnvironment); + +typedef struct { + + double startTime; + double stopTime; + double time; + const char *instanceName; + InterfaceType type; + const char *resourceLocation; + + Status status; + + // callback functions + loggerType logger; + intermediateUpdateType intermediateUpdate; + clockUpdateType clockUpdate; + + lockPreemptionType lockPreemption; + unlockPreemptionType unlockPreemption; + + bool logEvents; + bool logErrors; + + void *componentEnvironment; + ModelState state; + + // event info + bool newDiscreteStatesNeeded; + bool terminateSimulation; + bool nominalsOfContinuousStatesChanged; + bool valuesOfContinuousStatesChanged; + bool nextEventTimeDefined; + double nextEventTime; + bool clocksTicked; + + bool isDirtyValues; + + ModelData modelData; + + // internal solver steps + uint64_t nSteps; + + // Co-Simulation + bool earlyReturnAllowed; + bool eventModeUsed; + double nextCommunicationPoint; + + // solver + size_t nz; + double* z; + double* prez; + + size_t nx; + double* x; + double* dx; + +} ModelInstance; + +ModelInstance *createModelInstance( + loggerType logger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType); + +void freeModelInstance(ModelInstance *comp); + +Status configurate(ModelInstance* comp); + +Status reset(ModelInstance* comp); + +void setStartValues(ModelInstance* comp); + +Status calculateValues(ModelInstance *comp); + +Status getFloat32 (ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t *index); +Status getFloat64 (ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t *index); +Status getInt8 (ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index); +Status getUInt8 (ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index); +Status getInt16 (ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index); +Status getUInt16 (ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index); +Status getInt32 (ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index); +Status getUInt32 (ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index); +Status getInt64 (ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index); +Status getUInt64 (ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index); +Status getBoolean (ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index); +Status getString (ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index); +Status getBinary (ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index); + +Status setFloat32 (ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t *index); +Status setFloat64 (ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t *index); +Status setInt8 (ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t *index); +Status setUInt8 (ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t *index); +Status setInt16 (ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t *index); +Status setUInt16 (ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t *index); +Status setInt32 (ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t *index); +Status setUInt32 (ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t *index); +Status setInt64 (ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t *index); +Status setUInt64 (ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t *index); +Status setBoolean (ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t *index); +Status setString (ModelInstance* comp, ValueReference vr, const char* const values[], size_t nValues, size_t *index); +Status setBinary (ModelInstance* comp, ValueReference vr, const size_t sizes[], const char* const values[], size_t nValues, size_t *index); + +Status activateClock(ModelInstance* comp, ValueReference vr); +Status getClock(ModelInstance* comp, ValueReference vr, bool* value); +Status setClock(ModelInstance* comp, ValueReference vr, const bool* value); + +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier); + +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime); + +size_t getNumberOfEventIndicators(ModelInstance* comp); +size_t getNumberOfContinuousStates(ModelInstance* comp); +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx); +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx); +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx); +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value); +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative); +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz); +Status eventUpdate(ModelInstance *comp); + +bool isClose(double a, double b); +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected); +bool invalidState(ModelInstance *comp, const char *f, int statesExpected); +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p); +void logError(ModelInstance *comp, const char *message, ...); +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]); +void logEvent(ModelInstance *comp, const char *message, ...); +void logError(ModelInstance *comp, const char *message, ...); + +Status getFMUState(ModelInstance* comp, void** FMUState); +Status setFMUState(ModelInstance* comp, void* FMUState); + +// shorthand to access the variables +#define M(v) (comp->modelData.v) + +// "stringification" macros +#define xstr(s) str(s) +#define str(s) #s + +// assert size of nValues for scalar variables +#define ASSERT_NVALUES(N) do { \ + const size_t expected_nValues = *index + (N); \ + if (expected_nValues > nValues) { \ + logError(comp, "Expected nValues >= %zu but was %zu.", expected_nValues, nValues); \ + return Error; \ + } \ +} while (0) From 229e53564fdb3ad17eed56f1420daa46ed3513b9 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Sat, 14 Dec 2024 02:51:51 +0100 Subject: [PATCH 06/32] add test to Makefile --- testsuite/resources/Makefile | 1 + 1 file changed, 1 insertion(+) diff --git a/testsuite/resources/Makefile b/testsuite/resources/Makefile index fb47e49f3..9ee4ddb19 100644 --- a/testsuite/resources/Makefile +++ b/testsuite/resources/Makefile @@ -55,6 +55,7 @@ tank2 \ tank3 \ testArray \ VanDerPol \ +VanDerPol3 \ ypipe \ SSPs = \ From f1be98b5765f1ca92b4d4cf2add0e7618992b7ae Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 18 Dec 2024 13:42:12 +0100 Subject: [PATCH 07/32] handle numeric types for data types --- include/OMSimulator/Types.h | 13 ++++ src/OMSimulatorLib/ComponentFMU3CS.cpp | 91 +++++++++++++++++++++----- src/OMSimulatorLib/ComponentFMU3CS.h | 4 +- src/OMSimulatorLib/Values.cpp | 8 ++- src/OMSimulatorLib/Variable.cpp | 38 ++++++++++- src/OMSimulatorLib/Variable.h | 2 + 6 files changed, 135 insertions(+), 21 deletions(-) diff --git a/include/OMSimulator/Types.h b/include/OMSimulator/Types.h index 6270a3fd2..838efaa93 100644 --- a/include/OMSimulator/Types.h +++ b/include/OMSimulator/Types.h @@ -114,6 +114,19 @@ typedef enum { oms_signal_type_bus } oms_signal_type_enu_t; +typedef enum { + oms_signal_numeric_type_FLOAT32, // Represents fmi3Float32 + oms_signal_numeric_type_FLOAT64, // Represents fmi3Float64 + oms_signal_numeric_type_INT8, // Represents fmi3Int8 + oms_signal_numeric_type_UINT8, // Represents fmi3UInt8 + oms_signal_numeric_type_INT16, // Represents fmi3Int16 + oms_signal_numeric_type_UINT16, // Represents fmi3UInt16 + oms_signal_numeric_type_INT32, // Represents fmi3Int32 + oms_signal_numeric_type_UINT32, // Represents fmi3UInt32 + oms_signal_numeric_type_INT64, // Represents fmi3Int64 + oms_signal_numeric_type_UINT64 // Represents fmi3UInt64 +} oms_signal_numeric_type_enu_t; + /** * \brief Connection type */ diff --git a/src/OMSimulatorLib/ComponentFMU3CS.cpp b/src/OMSimulatorLib/ComponentFMU3CS.cpp index 18037cd8e..a02579335 100644 --- a/src/OMSimulatorLib/ComponentFMU3CS.cpp +++ b/src/OMSimulatorLib/ComponentFMU3CS.cpp @@ -956,14 +956,36 @@ oms_status_enu_t oms::ComponentFMU3CS::getBoolean(const ComRef& cref, bool& valu return getBoolean(vr, value); } -oms_status_enu_t oms::ComponentFMU3CS::getInteger(const fmi3ValueReference& vr, int& value) +oms_status_enu_t oms::ComponentFMU3CS::getInteger(const fmi3ValueReference& vr, int& value, oms_signal_numeric_type_enu_t numericType) { CallClock callClock(clock); - int64_t value_; - - if (fmi3OK != fmi3_getInt64(fmu, &vr, 1, &value_, 1)) - return oms_status_error; + // Temporary variables for different types + int64_t value64; + int32_t value32; + int16_t value16; + int8_t value8; + uint64_t valueU64; + uint32_t valueU32; + uint16_t valueU16; + uint8_t valueU8; + + switch (numericType) + { + case oms_signal_numeric_type_INT64: + if (fmi3OK != fmi3_getInt64(fmu, &vr, 1, &value64, 1)) + return oms_status_error; + if (value64 < INT_MIN || value64 > INT_MAX) + return oms_status_error; // Value out of range for int + value = static_cast(value64); // Cast to int + break; + case oms_signal_numeric_type_INT32: + if (fmi3OK != fmi3_getInt32(fmu, &vr, 1, &value, 1)) + return oms_status_error; + break; + default : + return oms_status_error; + } return oms_status_ok; } @@ -1044,7 +1066,7 @@ oms_status_enu_t oms::ComponentFMU3CS::getInteger(const ComRef& cref, int& value return logError_UnknownSignal(getFullCref() + cref); fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); - return getInteger(vr, value); + return getInteger(vr, value, allVariables[j].getNumericType()); } oms::Variable* oms::ComponentFMU3CS::getVariable(const ComRef& cref) @@ -1058,12 +1080,28 @@ oms::Variable* oms::ComponentFMU3CS::getVariable(const ComRef& cref) return NULL; } -oms_status_enu_t oms::ComponentFMU3CS::getReal(const fmi3ValueReference& vr, double& value) +oms_status_enu_t oms::ComponentFMU3CS::getReal(const fmi3ValueReference& vr, double& value, oms_signal_numeric_type_enu_t numericType) { CallClock callClock(clock); - if (fmi3OK != fmi3_getFloat64(fmu, &vr, 1, &value, 1)) - return oms_status_error; + switch (numericType) + { + case oms_signal_numeric_type_FLOAT64: + if (fmi3OK != fmi3_getFloat64(fmu, &vr, 1, &value, 1)) + return oms_status_error; + break; + + case oms_signal_numeric_type_FLOAT32: + float value_; + if (fmi3OK != fmi3_getFloat32(fmu, &vr, 1, &value_, 1)) + return oms_status_error; + // Convert the float to double and assign to 'value' + value = static_cast(value_); + break; + + default: + oms_status_error; + } if (std::isnan(value)) return logError("getReal returned NAN"); @@ -1150,7 +1188,7 @@ oms_status_enu_t oms::ComponentFMU3CS::getReal(const ComRef& cref, double& value return logError_UnknownSignal(getFullCref() + cref); fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); - return getReal(vr, value); + return getReal(vr, value, allVariables[j].getNumericType()); } oms_status_enu_t oms::ComponentFMU3CS::getString(const fmi3ValueReference& vr, std::string& value) @@ -1508,9 +1546,22 @@ oms_status_enu_t oms::ComponentFMU3CS::setInteger(const ComRef& cref, int value) else { fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); - int64_t value_; - if (fmi3OK != fmi3_setInt64(fmu, &vr, 1, &value_, 1)) + int64_t value64; + switch (allVariables[j].getNumericType()) + { + case oms_signal_numeric_type_INT64: + value64 = static_cast(value); // Cast to int + if (fmi3OK != fmi3_setInt64(fmu, &vr, 1, &value64, 1)) + return oms_status_error; + break; + case oms_signal_numeric_type_INT32: + if (fmi3OK != fmi3_setInt32(fmu, &vr, 1, &value, 1)) + return oms_status_error; + break; + default: return oms_status_error; + } + } return oms_status_ok; @@ -1567,8 +1618,16 @@ oms_status_enu_t oms::ComponentFMU3CS::setReal(const ComRef& cref, double value) else { fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); - if (fmi3OK != fmi3_setFloat64(fmu, &vr, 1, &value, 1)) - return oms_status_error; + switch (allVariables[j].getNumericType()) + { + case oms_signal_numeric_type_FLOAT64: + if (fmi3OK != fmi3_setFloat64(fmu, &vr, 1, &value, 1)) + return oms_status_error; + case oms_signal_numeric_type_FLOAT32: + float value_= value; + if (fmi3OK != fmi3_setFloat32(fmu, &vr, 1, &value_, 1)) + return oms_status_error; + } } return oms_status_ok; @@ -1816,13 +1875,13 @@ oms_status_enu_t oms::ComponentFMU3CS::updateSignals(ResultWriter& resultWriter) SignalValue_t value; if (var.isTypeReal()) { - if (oms_status_ok != getReal(vr, value.realValue)) + if (oms_status_ok != getReal(vr, value.realValue, var.getNumericType())) return logError("failed to fetch variable " + std::string(var.getCref())); resultWriter.updateSignal(ID, value); } else if (var.isTypeInteger()) { - if (oms_status_ok != getInteger(vr, value.intValue)) + if (oms_status_ok != getInteger(vr, value.intValue, var.getNumericType())) return logError("failed to fetch variable " + std::string(var.getCref())); resultWriter.updateSignal(ID, value); } diff --git a/src/OMSimulatorLib/ComponentFMU3CS.h b/src/OMSimulatorLib/ComponentFMU3CS.h index 249d8c0e0..166665287 100644 --- a/src/OMSimulatorLib/ComponentFMU3CS.h +++ b/src/OMSimulatorLib/ComponentFMU3CS.h @@ -84,9 +84,9 @@ namespace oms oms_status_enu_t getBoolean(const ComRef& cref, bool& value); oms_status_enu_t getBoolean(const fmi3ValueReference& vr, bool& value); oms_status_enu_t getInteger(const ComRef& cref, int& value); - oms_status_enu_t getInteger(const fmi3ValueReference& vr, int& value); + oms_status_enu_t getInteger(const fmi3ValueReference& vr, int& value, oms_signal_numeric_type_enu_t numericType); oms_status_enu_t getReal(const ComRef& cref, double& value); - oms_status_enu_t getReal(const fmi3ValueReference& vr, double& value); + oms_status_enu_t getReal(const fmi3ValueReference& vr, double& value, oms_signal_numeric_type_enu_t numericType); oms_status_enu_t getString(const ComRef& cref, std::string& value); oms_status_enu_t getString(const fmi3ValueReference& vr, std::string& value); oms_status_enu_t setBoolean(const ComRef& cref, bool value); diff --git a/src/OMSimulatorLib/Values.cpp b/src/OMSimulatorLib/Values.cpp index 924fdcd19..d0395829b 100644 --- a/src/OMSimulatorLib/Values.cpp +++ b/src/OMSimulatorLib/Values.cpp @@ -1776,7 +1776,7 @@ oms_status_enu_t oms::Values::parseModelDescriptionFmi3(const filesystem::path& } for(pugi::xml_node_iterator it_ = modelVariableNode.begin(); it_ != modelVariableNode.end(); ++it_) { - if (std::string(it_->name()) == "Float64") + if (std::string(it_->name()) == "Float64" || std::string(it_->name()) == "Float32") { // start values if (strlen(it_->attribute("start").as_string()) != 0) @@ -1785,6 +1785,12 @@ oms_status_enu_t oms::Values::parseModelDescriptionFmi3(const filesystem::path& if (strlen(it_->attribute("unit").as_string()) != 0) modelDescriptionVariableUnits[ComRef(it_->attribute("name").as_string())] = it_->attribute("unit").as_string(); } + if (std::string(it_->name()) == "Int32" || std::string(it_->name()) == "Int64") + { + // start values + if (strlen(it_->attribute("start").as_string()) != 0) + modelDescriptionIntegerStartValues[ComRef(it_->attribute("name").as_string())] = it_->attribute("start").as_int(); + } // TODO check start values for other dataTypes } } diff --git a/src/OMSimulatorLib/Variable.cpp b/src/OMSimulatorLib/Variable.cpp index 8f636b389..b693e8ab5 100644 --- a/src/OMSimulatorLib/Variable.cpp +++ b/src/OMSimulatorLib/Variable.cpp @@ -89,7 +89,7 @@ void oms::Variable::configureFMI2Variable(fmiHandle* fmi4c, int index_) type = oms_signal_type_enum; break; default: - logError("Unknown fmi base type"); + logError("Unknown fmi base type: " + fmi2_getVariableDataType(var)); type = oms_signal_type_real; break; } @@ -127,9 +127,43 @@ void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) { case fmi3DataTypeFloat64: type = oms_signal_type_real; + numericType = oms_signal_numeric_type_FLOAT64; + break; + case fmi3DataTypeFloat32: + type = oms_signal_type_real; + numericType = oms_signal_numeric_type_FLOAT32; break; case fmi3DataTypeInt64: type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_INT64; + break; + case fmi3DataTypeInt32: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_INT32; + break; + case fmi3DataTypeInt16: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_INT16; + break; + case fmi3DataTypeInt8: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_INT8; + break; + case fmi3DataTypeUInt64: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_UINT64; + break; + case fmi3DataTypeUInt32: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_UINT32; + break; + case fmi3DataTypeUInt16: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_UINT16; + break; + case fmi3DataTypeUInt8: + type = oms_signal_type_integer; + numericType = oms_signal_numeric_type_UINT8; break; case fmi3DataTypeBoolean: type = oms_signal_type_boolean; @@ -141,7 +175,7 @@ void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) type = oms_signal_type_enum; break; default: - logError("Unknown FMI3 base type"); + logError("Unknown FMI3 base type for var : " + std::string(cref)); type = oms_signal_type_real; break; } diff --git a/src/OMSimulatorLib/Variable.h b/src/OMSimulatorLib/Variable.h index a4692ec84..a4a14fcbc 100644 --- a/src/OMSimulatorLib/Variable.h +++ b/src/OMSimulatorLib/Variable.h @@ -88,6 +88,7 @@ namespace oms fmi2ValueReference getValueReference() const { return fmi2Vr; } fmi3ValueReference getValueReferenceFMI3() const { return fmi3Vr; } oms_signal_type_enu_t getType() const { return type; } + oms_signal_numeric_type_enu_t getNumericType() const {return numericType;} const std::string& getDescription() const { return description; } bool isTypeBoolean() const { return oms_signal_type_boolean == type; } @@ -127,6 +128,7 @@ namespace oms bool is_continuous_time_state; bool is_continuous_time_der; oms_signal_type_enu_t type; + oms_signal_numeric_type_enu_t numericType; unsigned int index; ///< index origin = 0 size_t state_index; ///< index origin = 0 size_t der_index; ///< index origin = 0 From 0aba6ae4579ef3d5d37c748d7c843caed97dfed3 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 18 Dec 2024 13:48:48 +0100 Subject: [PATCH 08/32] add reference test Stair.lua --- testsuite/reference-fmus/3.0/Makefile | 1 + testsuite/reference-fmus/3.0/Stair.lua | 42 + testsuite/resources/Makefile | 1 + .../binaries/aarch64-darwin/Stair.dylib | Bin 0 -> 89384 bytes .../Stair3/binaries/aarch64-linux/Stair.so | Bin 0 -> 71592 bytes .../Stair3/binaries/x86-windows/Stair.dll | Bin 0 -> 133120 bytes .../Stair3/binaries/x86_64-darwin/Stair.dylib | Bin 0 -> 72288 bytes .../Stair3/binaries/x86_64-linux/Stair.so | Bin 0 -> 66936 bytes .../Stair3/binaries/x86_64-windows/Stair.dll | Bin 0 -> 164864 bytes .../resources/Stair3/documentation/index.html | 91 ++ .../resources/Stair3/documentation/result.svg | 1 + .../resources/Stair3/modelDescription.xml | 41 + .../Stair3/sources/buildDescription.xml | 13 + testsuite/resources/Stair3/sources/config.h | 29 + .../resources/Stair3/sources/cosimulation.c | 691 ++++++++ .../resources/Stair3/sources/cosimulation.h | 5 + .../resources/Stair3/sources/fmi3Functions.c | 1446 +++++++++++++++++ testsuite/resources/Stair3/sources/model.c | 105 ++ testsuite/resources/Stair3/sources/model.h | 250 +++ 19 files changed, 2716 insertions(+) create mode 100644 testsuite/reference-fmus/3.0/Stair.lua create mode 100644 testsuite/resources/Stair3/binaries/aarch64-darwin/Stair.dylib create mode 100644 testsuite/resources/Stair3/binaries/aarch64-linux/Stair.so create mode 100644 testsuite/resources/Stair3/binaries/x86-windows/Stair.dll create mode 100644 testsuite/resources/Stair3/binaries/x86_64-darwin/Stair.dylib create mode 100644 testsuite/resources/Stair3/binaries/x86_64-linux/Stair.so create mode 100644 testsuite/resources/Stair3/binaries/x86_64-windows/Stair.dll create mode 100644 testsuite/resources/Stair3/documentation/index.html create mode 100644 testsuite/resources/Stair3/documentation/result.svg create mode 100644 testsuite/resources/Stair3/modelDescription.xml create mode 100644 testsuite/resources/Stair3/sources/buildDescription.xml create mode 100644 testsuite/resources/Stair3/sources/config.h create mode 100644 testsuite/resources/Stair3/sources/cosimulation.c create mode 100644 testsuite/resources/Stair3/sources/cosimulation.h create mode 100644 testsuite/resources/Stair3/sources/fmi3Functions.c create mode 100644 testsuite/resources/Stair3/sources/model.c create mode 100644 testsuite/resources/Stair3/sources/model.h diff --git a/testsuite/reference-fmus/3.0/Makefile b/testsuite/reference-fmus/3.0/Makefile index 590535c52..631db1d5a 100644 --- a/testsuite/reference-fmus/3.0/Makefile +++ b/testsuite/reference-fmus/3.0/Makefile @@ -3,6 +3,7 @@ TEST = ../../rtest -v TESTFILES = \ BouncingBall.lua \ VanDerPol.lua \ +Stair.lua \ # Run make failingtest FAILINGTESTFILES = \ diff --git a/testsuite/reference-fmus/3.0/Stair.lua b/testsuite/reference-fmus/3.0/Stair.lua new file mode 100644 index 000000000..3884505cd --- /dev/null +++ b/testsuite/reference-fmus/3.0/Stair.lua @@ -0,0 +1,42 @@ +-- status: correct +-- teardown_command: rm -rf Stair-lua/ +-- linux: yes +-- ucrt64: yes +-- win: yes +-- mac: yes +-- asan: yes + +oms_setCommandLineOption("--suppressPath=true") +oms_setTempDirectory("./Stair3-lua/") +oms_setWorkingDirectory("./Stair3-lua/") + +oms_newModel("model") +oms_addSystem("model.root", oms_system_wc) + +oms_addSubModel("model.root.Stair", "../../../resources/Stair3.fmu") + +oms_setResultFile("model", "Stair-cs.mat") +oms_setStopTime("model", 9) +oms_setTolerance("model.root", 1e-5) +oms_setFixedStepSize("model.root", 0.2) + +oms_instantiate("model") + +oms_initialize("model") +oms_simulate("model") +oms_terminate("model") +oms_delete("model") + +if 1 == oms_compareSimulationResults("../../../references/Stair-cs.mat", "Stair-cs.mat", "model.root.Stair.counter", 1e-4, 1e-4) then + print("signal counter is equal") +else + print("signal counter is not equal") +end + +-- Result: +-- info: vars: time +-- info: vars: counter +-- Loading FMI version 3... +-- info: Result file: Stair-cs.mat (bufferSize=1) +-- signal counter is equal +-- endResult diff --git a/testsuite/resources/Makefile b/testsuite/resources/Makefile index 9ee4ddb19..2caeb1650 100644 --- a/testsuite/resources/Makefile +++ b/testsuite/resources/Makefile @@ -49,6 +49,7 @@ replaceA_extended \ replaceB \ Resource \ Stair \ +Stair3 \ str_hello_world \ tank1 \ tank2 \ diff --git a/testsuite/resources/Stair3/binaries/aarch64-darwin/Stair.dylib b/testsuite/resources/Stair3/binaries/aarch64-darwin/Stair.dylib new file mode 100644 index 0000000000000000000000000000000000000000..4369325cb75a6eb2aa10c7dcc3a88de3bd6a1736 GIT binary patch literal 89384 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 %Wn@n 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/Stair3/binaries/x86-windows/Stair.dll b/testsuite/resources/Stair3/binaries/x86-windows/Stair.dll new file mode 100644 index 0000000000000000000000000000000000000000..ee5f9dd5c041c05f80fba481ba1348c6225bf20c GIT binary patch literal 133120 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/Stair3/binaries/x86_64-darwin/Stair.dylib b/testsuite/resources/Stair3/binaries/x86_64-darwin/Stair.dylib new file mode 100644 index 0000000000000000000000000000000000000000..5ec64858923db2b16f3eaddaca73f52218c38fd1 GIT binary patch literal 72288 zcmeHQ3w%@c^}p!@3pf*}ow|o)3>?f^TS2TtU4UK|CdE1^(>ZNRNlT=pwQaDd)nHm| z8tW?RChBH={8^n&tD@HFFd(CK>Wu!`>^3(uWqR`;oAt%2L;L@p-y`=Xxq(u~XLKa( zeVpIp{LVSQbAFF=fA@D^`uOjk9-%0fOhr+~;W!G1ElW{a6&vmp5l&r@i};LisK$0PcX>Pe_4u82MAw7qjy5FAIJ2$vV&YiO)@d#Xi1B0gmk zkGN-|NFZRDKSSP#Ygw7sbGh5Iyv*&Xszq2LzI&hH2`>=o2~NZzqS%G%^;R5ZWkqwA z%qg39-lD}zSVV}O6~!U02{7pi9Z(6TA!TLNwYt<&^K;YM}WJGqu4!@rRCGi zuOW`pj~o1s#8HTYa1rg6vkPI47UfiLL;b1XnvTV58X8@z^5z=la1zoIp28z6N*LGa z0w%uGzqAC>5=cuRErGNI(h^8ZAT5Ek1kw^Xyd_ZT4E)s@XdZF~)uBEg&5UTCK+t>Md?%b z&?G5ZPA42nP~FuUvbJKz$6+8E1hEbqZX&>eLMAu^zj6Avqny(~epWwlP|oNVaiWrf zrMpnbU+-pxtkDYzs(YONZ4R&)$KQeTQ_71vN-rvUxuhTb_%(~Q_1iLl81gsO*{rRY zpfY;3Qg)*b20N*WIHO)LdXzKplGEP@M$ZWx+h)#Y0WW)fM@*JFo1Luw{JU&Y2X>=| ztu0G=A*2ILtaQ`nL!kEb4-};v#FB3)da6hkY$K}tTPy)~1M-;m*zY3kxqxX;OpE;6 zY!Gj}{v5b`KkQ;v`5@?!`tl-Ch=cTn$rnj+1u#yHYz zEz$mX{SA_4YbSp?Jj__?1tH1=>kS4HvpCK+9cT0mPU7Hp$K^~C+a0U9L`3!?eKoHF7L2Uv>?8o$}Bm1{qib4%StUYkF4N{XZ#nPs}BO8T2bqD2h`kMz8 zYwMA?m34QDh1UyjCz|^=598F;yYDLFvW%VVq@@Yl_AC zIOGol385lb%%ixa*zQup(KyTm{4+T3L=8)j)1x+rW?YZ?Z)<(%a_`c z?dq@+B{vsUWzbRg6_~~lWIu@ou@*Q2?Z5F}rv2pskt2&|wY00l#AFCw8I2pt!#%puQ034;J??2!w;BFHj$|ATYQf@DYj%JKDB` z$wD0YIHuvS<2b%uwSkx+q$PdS9KN?KjyCVxzBepwrEf8c|4J0^1PbKyB7Z6J#!+k} zmXt(W(F$S%>HrjZK(V%*jIj1%U{D7LVcV??{%Z{00GI%19|@Lj!D@-#e{xw)gOKbv zj^Bq|spm~o zC@6-RXA5G?%oE)egc?+P!HBY3eHC4r6-g<$pIGgVewKsTEw`}|4nh#X5_F4vjvONv zhs_B2x{#RCfe=#Ipt>z)gyl3qO6=eANz{GnE~GUR=rp)^fetE3BbesMW1h*a(44~K`L{LtdrDrn&i-ar5?OLL5rxhYARmXegCl1U*dwlgY7T9Kf`4wJ`N zu;r_gA`CI9uWz9tB_ojqWLR5fQ@|XYC?mL~E+ASU;Py_k$tN8+^-{#{trjaAphg1D zy68lNh+ID0>YV4JkwU|c7TCZ!T4N*UPUJAJ1m4u|GO2{rP5rKzmgUFW^FH+JLC%7% zU*#0gk$V~V)}H%lbo#Y8C2ME$7!%g0qhSI}I2mdM!!;w9toh$xdrIPW5Viq+JJA+v zzaKhe_@&Xuzk}Z|!B!wby?(`b>1RIzztMk=j^C{*>$f{){oatGes!an=qIDudvkFR zjYf=*%Beke2E3Xai_+ksPkjO8o3+p9kos`>hS2DRHh+2))2EUjLcW3BN%DP~nqn~? zeL=R*FHoSr`32cNzlla4px!=*Wc&OakJ0UiVo=3O^dZC~m<|`Mzd3?&9GjH|Wg3h} zGz8`oPaqltyZdipWN*a-2dk8{Zi5UBvNS%kkx#cZuli4R{!0A1kI3MP}MLH><-Rs6QkJh!Va}Zn|K}R^Swd!UIWqh#uNP! z5SbJGI*&0S`d6~>WXijR3#B_+Lerw4+5>vS))q|gc|`|Hdq8R!75>gmtfqg6$!nk5 zH4?2XPDv{ssS_6_w4RWHRz`XdgLFATVPhk+@%+EZ9;bj^?W6a`j6Hr~J!-5Y_cUB! zkAqh-?K=Q_eEvp;?>$_Auge_Yi0#q7YYf`sm473m4^?|C>tr=E?ux_19`A%RM02BA zPnZxMs{LaS;}_WD-MGMh%9{?<9%plW%Q!xpIld9wW2ZI-?eS#aq1->d1SctKdiCnV z!yb zGr(%*t@^{m9y{A$j|}~S^N)yAWR z93%F4GA28)$GNzmmXyi^wZ}h_N3|n2gX8O2W{Pjb_L%>_W6&Na)*Q=mxu5^p!DVj}zhdruiN&u*b+n2WpQ`k%zV;_YGWtuhSggi0#q# z!Wgv2m99hC9?yfz8#S~0!o$NJcVhCOU5I9VjP#FJdYJvJ#|5=ia>0Sx`XSRM7FShLErHuzNnD){dVgAyFSi|}~ zu&n*+`6Qbh(MuaNHpHtL`Wn{QOB-kKn5@`4Rk4>gzJ!>BMU4!^a@E)x){o?p&G#f=9ifJ6Be>!VXIuoN=Vmpq)&3B)#gYqjYo=g zs-_EBd$qT>kzw{=VdiWV@4JjsXq9(QK;33|-Q_qSGnd>aNN)bR%bSQvkQ`Qj_Ua2+ z`2tp~^h82h$lAphvTg*#1%a1!#6s3C<3d)v3%9VNxLezN2^r@dLG=y;;djInjwC4v zFXAyKRsJ&c8nUQcEu?xmi3MLqRKm+1ARzk0}CUjyRN zt*`g!ZBxj&zW(KE)Y0_5q&gbW`oUvZ3uLywo>~|4mCUarCP7DeMHt$qr(~M=wkd>W zH zgq7z^DC@-gQDQy41<6vcM=!%@9FiG#-XY$#P zuehL=%JD7$YE!C=>|6g``uj45zhg~*?_9GCx9i&nRe#UNBw?)S@9S{MLNeQKUxS*Eo>Os}t^Uoi9`djurCYf=V zDPfkLiIMic-V(+bjK=9EBlsCSCM)J)p@AC4`%3f#I^i%q9gO!elg7Vd{4fXXYVIe; zjQ$46Ba87bF3{idxd&B$UtTo!^!Lv1GRe%Jb9m@)5bSFAJw9gi_xVz$zi;3I{q6eZ zLDk&`hm^mhl?)uNA%8U3AzAt{Z2aX~Fb&N`_2dm|=6 zV@-c2eTPYA`|QI*e@_Iv+VqFVjQ*ZW9$$=qae@BYzj09Y_h?KH$D00@!SM^pj63u2 z(BEpXtGOQ>Gx{4Ok1xi*xS*EG&p4?1dm|=6V@-eWgyR>InLq3B(BFr_u6E!3V@7|U zCyy`uzqp{5x@I0!{XH7f!?C8nuVc&u$*hC#;BfFi>;b!4w0q3x??fll-^sY3mLdfQ zRex{9^l+@{?<9~Qa)Qw3xJfihk#{p@IRYq)O zfZ3+HZz9IbduUvr6+)7Qc z+zOwlfP@YEy$=PvAJD$*$UP)Cl7_0~&SR=})5+plgWSBm1r)^cJCMnSHFYr@f#L|Z zM8$VI=wk;AA6q;Je80l52dX>IfX_kd6NfKfuFvaJcTzDhk;FazzpU#GDx!HHw#Ps4 zYp36pq&GVZRsk)N_{mnb&o~qk9s8_{++*9=d9;53G#ef7Qx}HurOix4^_JP;5 zdoX3i9FBnJ7?aZTc#KKu$EGMasP2rJC)@0Kf8|@6LcV!( zAm88KIXd}%oRY&xN)D+`%;d{OTdYB+Haegp9k~zTqFsSDksjA)Q??^9q~&pnXucn}L)ts-r`)GfQ*37Q4^l9f0h*QOu(bIX;E&hl{5VMlY|CWv zg!DCO^RIE6e@)svoWDRPq3kuyRK>Mtm%vkz;_ zhKIGs3rXJkYT^TtcX0}NKZd6X+MjM4oxI-zvF7q7Hq6H(n-Q}Yc}F0-)9DFEM{X`I zLUvDoHHGX}lepNYLJINf0@lAMGzM2TGl{p6r!GLB>KSkba`a@Mr%WAZzXgj%m+e6+ z*_fgjP8>@dEKI7BuOM+!mBiY+I%KosI35R$8_=r7@1?%?cTt|x>!=qB(Yv`RhY6wz zglcDQNUEa|&2>CLYChLl!eexspy>!nFZvCfP3tIWGw_K>$r�wthE+uZU#zWAf4k zEEGR3IXp(J$z*gW!oe>?0TlKP5{$`F*kde4nFUmwyQQ7m{PPFP{$iZ&;rs{}H{< z!Qc2ZTgmqcSTTPW=S|6^&Mvz{&(lK!fWYWw8?-E&WJ=IGh+yh=dgMD}lxj;P(`ng? zP>j48nBlZ+(H4GH~()S3D5^`3kH?Ci3(FwtOQbTEt`YUMRK%5oirnq*Kqz z=G{wA^c>l}B&|tIv=PePEQj%SD(A#B7%WCQ8!_-<&4K)eTp~Vdf8y|gE^?X- zKzcN&CD%LfTw=h(CgF1YpOl}RB?1TJ+f3iyxP#;Pd^`^G`BM_U1bRw1uHT%X^R?gf z9LaIC$Kx0sJs~*YA)j;Nap~WCOyb8xK38!ZA0HpblQ}&$R$si1pxw~$j?>TL`F~-^ zZ{u%^Cfk1rAdEjQ!I)Ir08LAHpJqfpiwJO-&!Ndf zXg-G~uWf?%=^$6ORx|_9L-->)PJbTV4#<27E=06WT~H0u76^(yv?iy%)Sbm4fm#}o ztm8;Fa3mL*BSFK*k)VJG=*MLMmxLK}yuQ(wC$-cL@rM~71_vQytRr^{2+^jrCkcH- z4)LWxYVMMT&w*m}#wO+vpDcOPrNr)N8i`?rIsir-wgkUm{PUwY|5$2&;6pmgtk;x! zcIMZ?azP-8dZLACpZM-p1+Ki-$L&9xEO<9 zZBE;N9ly^&Y)}~Vy7cLH_-CKx4(!&Gq}x6QSE|)*#1*AHcP$d0Ucr z9Z_?AE7M@JCx}<`7+tqx%{AGBnQpT%D7fJpkTkXV=~qB^NA3!ci9YhG&+xu0p^yBW z#0d^lJqR*Be?9Y_e}}wM`@fRLpP1ti5%0lM zqMdMUlC1ty<4*_38qxUE)c>-NX9UDD?>qS1%Q2qGV9ylDAa`w&3`R8f@&Kv%+>5uW zW-}lfHJI6#Ag&u7TQ}_L=U-+Da`FUyq{&AO`V0i0zhvt**6!*APBA2Bqe7gDBlPL@ z*YN-~3qlBp;?u1yX>zucupRdUPU>(HkI&!8}2UzMEw(AUR&7rwnafNU2?o&XuMPKLo(U zhQ|stZ=*df#JjR6Pvs2KFhc{K$JUG;@Z5K2W z7ZKF&AJ7i;ShRB)U3ZK`mcK_LbGn}4F(!2V4`R%eji}J@kVcJ=zH}1U2?gv1v5p+; zx<|PHc^D#{IofBTh$L(3Qb^VUgRMA1`2dyVfU7fzt4z&%1ZnN{BjGADC0Ef5#;*xi zFCoT^D^L>N&a}9nUqbvs}%NBam&@XX#Yg>9B6IAZIGR3tI$;tqi_)G#|#!mJ|%OlxR1w}$nOV; zNs!;}R-yomp#xWTw-O!T<0(cpF}4AB2%wQIm$D`5$9;?iZR;91j9MER(R4NtO<+9H zN2MhC10V%ECPe>17MDPIvf#fYQ?e+BS5^qCmA`+&48B%YGSsEB{}1e5%&T0 zH54g35obyY;6EbTOei=u1qBJSFu6Vz&#&84dvwX}`|ymU7f7k=B*)`1bPMmkb`7lG z=^ujA2TyZE$J#+JK9Y0-}bv({SNQu{{r zKs;GR0;j*}cvLGnO+g1OMlb&&8-3ItcDV)U0A1{}PIq-$r?2X=PWSd$r#EAG*x^Lf!a%D77iXZOkX>%cr%N#V zUC6;1q`Du1w|fAy*)Zfa0C^q7C{+h`L(XEMrAk2^G|=g=Gb~OUR;k!fyE%Q1EUKnH z#m2JH+RNhbLZp>;(t}1+dlW4JLlDev5(Ni~hn#2jTU*CdzO~yTxLo|K7KWNwCnl^H zMnQNU=WiZD^|4l;t0@VLs8 z=_z`E6$m(AR6)HIqB-;w{Yfb(L_1MW5l%`$A=;j!iH_zW?R~oOZ^M%*y?+3&1tAKE zt*7GrLqT-)8{%rkxRI*LIEyn1WXLB9SXrlfnBoob4Ph;?JXSCssUgD2r($$` zHoE)1s%bv}BI~q%gk)a@vN5*YV!f7XZ@W5diGB|^hQ!Mli0+MrX^RC2=P-Ix4PBu? zr4DF6;yH^W)@flvJ_*Qa(Ge@)rVzE(!|m$u6pQt7A~_!xV$=_!b%@YHB+qf8$l_TD z<0JZI3066+SBIQW0;HeMSiw1o;X1P3Y$>M=SN;DF_F_U*`l* z+c&}S^rAeo=Tj&%f^C~mq27@-Tw)N^-ao%C!p)u%Fx1d(CBFe1uH zX04Xfe-=8b*2yf0$(-c;6i0QL0Tqp1S#`1H5@*q~r4UkSXQ1h1LkBbf=(pY>S@3=< zT9usTN0cQiRhEh0Aj{)VqEgo6yfN2wA<0oBR-BU zBTxZJ5ds>uax>%4Lk~{>a~YnI?W_MOm;KLNkhQ=4Pr+^s(xzjqq0N%HgW3N&o|kIg z`7FkK$T~66Ui`bt(O+&6IYoaN@a}*wrXRi-bhH?YQ2qFu3S|fNCW@54nU3r|(0p{X z@B`6;wPK_`A5D6R&1$n?ssa1%c2;^f!L~!#XFF2xid^{o940N8X;C&zq7-Wf>-?^Z zv6F}ivkt26%Aw6L3VhK6*;%nDKt>I+Qb2=VN@YSR*JHp4qDbK!g&-H#H7kPPHwb<) zwZdo@2(?1O9?ZUvc*8hCN|c8DP#-w6v@E0`ahkRtiSH6o7X{6J1EXdbZstFShvgC- zH2B8$UbLSn@^9t&pWQvm{CD#F{?X=d=K1H1HvdI}|Iz0EhT#9hQSyI+;D5CF|B0p# z^*3*{`G3drXO1@i<2?VfAM7vx{9QJtgEw*<*CgVIjmN0}PN9E|g8#(4EijAN{C_X` zmk9nxn}4R@|NZ^tU)bN#JimXm`QO3djp~22`CsJuGe?{M0iOTa_eRNokmvW0Hosf& zKid3G!T)IUPZRvVyTAM!^gom1xF!*Y(0{J`taUaW-|Ds@)5MSG^mtmTDbvKwfAFp< z8&m6%arR>u_7^A}1PTm{nc1$iG1coI)LFN40^`f~@1p$3iFZ=i&|181q%DGl@>e!7 z?L*&%kW8!M+C4N7GjejbfX2G`2+{p1yCJ_=%Vq3 zfkSM3%$5jp7cLJVXD(9EB0wHMcL<=Re>{Nh5YQA0pgSVL=i`DRLgl^I-qt2UsXPfF zIA9Ex03@Xa1J@%e&_-v%>sB>k<(}oxFGYdqW7u zY=)-Ilnu@XawYJBd-U7R5QT1eBU26$Z=>lC&pX=a`CzV&M6)U!^@wWE|O z>oT|jrsYmy_utu0 zPd-n=-StD5!ZYo#-V{QD_TpDbbfg?Pj6i>r17do zvh#X&z8PozH~39{KX}b;8|e4kH{V_HX4_*!JI_&+{CPOYJ!kk)82$29wW-ck+2~qs z_bjcb@wyu9=bUYydWF}%%-d+cyrO~b^OSG78twCIYAYIN&9u84?4H_2dqqu6?d8Z; zRa{A=; ztGo@3tmZ)CqSA#6^AuKX-;uS}z~KgznxGNp3L*4?ii7M5=~^mpa4nc6L--w&uM7fd zJlm|9GKk;Jt*xzbRd^_HabrEn26uD8UHuxmn^#j?xst>u8I-rkjaybcuAB}YfYL<> zzvFa>Ake{6@%)sJ-$^Y+grXW{)z&X=bk!-a0;ACY;6}3;twar@h^mRu&{an)iX-KV z6~@AJ?iz?^W{(Rz%iWM!Z9NN0$iTuD)l#uF4d+#v#(GyRbJd?$m59uf7=Qv7iL^<0 zJV_x;RwM-`A>=*J+gRr{)K7y_RLi6kv;9hMJ=${cylR!#Lp-6HOQ=%qXbtiTW>xDQ z1VMR9TuOTb3bT{)@n#22&N=q{#4K|f?UhFS_BvJoM_*yUQClU-qzrP$rjfMy4cI1GsTGEc=SM8*eG_XCVeYFD~EdCHY@i)QA}IQ`67r_3mr zHS3g_r_DI+lsR+fopwsWjML^8%|By?I&0?4X63u}wK2T$2v8e#u*mH!Phm8Ap!{z1 zaE1mPf?u9zkJS)>y(Hx=e60N^L$0o^ccXt#?gva#U4(A`Vw0pbwbe`&8x-7;8F(91 zCO33t5U4D~kR4TD>%mcFpB&3P*^WU2fd&kdW7;u!YQtpKe!{e?`LH8t6rsn%%nK8S z7anrLgL0~6N$@c;NA<-gnKX1sU$9ur;xaeP9bqa2Wej(>kJ!U)o52R zSZwgt)z#LcDZ_J|lpQbPXbORK2<&IPW+232!$DUZzDIGw&%w_632p%8NMNxsOe~yG z8h$n(53uEmOxqpX$hnykd{DN0%-}PC6JatS^{Yaq$QA+Kw1K6 z38W>EmOxqpX$hnykd{DN0%-}PC6JatS^{Yaq$QA+Kw1K638W>EmOxqpX$hnykd{DN z0%-}PC6JatS^{Yaq$QA+Kw1K638W>EmcWQ5U`I+PjwT$msiARm0KN|Z-uOp2{jkR| zHW)Pg2Twj8azb62T3P z^_8pY6riqO?&a4Smq!p?MtdMBPZ7geO6L<9ICtGl=g5Z^oO|vEM;RttC!N5z%9(^D zYbklpdP3kuy{A6)KrZPd;V&DY9f?pB`lq+fIe;%X68@R$r@QyY^fO zx;j{K{tTe$nt?KbAfebNEG9^PX;Ct1_akMkg|_^{E-eXrDLrh#Mq|oWOP1n$2Wgeg zd?1&5Jt;S5@J-h$UCM14kklt6oxz*v9BxI`XYlR0ewiWm?s^u91~*W&?{*@1@Fyf6 z<911JWHcyRhLXW{^Li~KeqSZ!AC!NH6>nJ?G#Q!Zvmp*tF}xOl;HjXr_`O zci8IAq}}Q8ak5Nh@O#98o3dPvQ+Odzbgd&qkpL%zZz=V+%=z^dZ2KzZ-ApALyMw)& z3DmC<>c3XR`T%GPhaMzD0XSkQB2;*a9IRA#7e~#p&SeqxH&}|b?=&vUf zD&YxA&Rpg3oO#M`bK-VA9L$-o+%%r5_AlcXD?gpU_Fn6qz$*K96O;_GWu4NI)2RGy z0xJGY6xDSD2%eZ?hp*41+WhU9B4w(o{M|x(>?wCyTd6x6HDusC%2f7O$^x`wy-5)@mWF{ofg|*MqORR;;;{9M6w1ggO+ec=MmIv+5FGaTkWJAMu%4P%p^yU?Ydhzg|rgy{FMfPDhqD&S55|3<*& z*a@0`1AyrxZ}jaO`u(4X4+;1K0W0*KF8nOmK#0=YKF47zU@Cv`4h~NdaOh4B=SjGW z!*c}Oa~Fpf$#?;m3ON669)Ag7Dla17Dgit0;qe}kzEi->0=C`DyQ2JBz&$tN2ERYyp!mo-1}Yy3xMwYgk3}5C zci|%}^vf5p?{W^$6|hagHTVnLf6L4rUhtCmk-66q) z3Al$U2EP>oE;)(AUIE+v9Hx$x$+LyS8wFh6$>HY&>|4*_{}XV@jT}Y?$MP$J{!<0q zbu*7&AmIE~4qqbRIsrEdxO_g3_X}8|y}R*SFJOBihwl=wL+l*gBjCt%9#7w9BYyA+ zJNEmdfIE-n@ZSVHDB5p~gIIc>fKL)|7$1M3-vR+g=+iOyEfH|t8V;|N`I|U=oq#)Q zIs8Kb+b-qsMgf=9b9j?Xe?5m^6mXZI_YDCLdU^c&GW{YBXJUgp;vG zWdYmDIDD#%U(VsPW&9Eje_OzzRt_%{up;d3N&%M$xKqHL0^TU#a1GD@n1H*29NsGP zf1krI%k&i-j>!0G4!NHC=#ep}0uM5G3h+2M z29muDv8Ys~#O-CxQd3CGjle=M2v43v${4<(CKo*t%I&yiG~a(a2F1^|^eJaU3_;RF zUFJ2Ps>;~J39Af`%@$(;G+)E4Cl1C0NWz%qU}9u|3~3P;pR&-HFm4-c0|FKvo9@Yo zy=*TXOOk5e=)?r6n3o$*oBA~*lH{qpj9En*#t--aB7#Z(qNQ^acJFp~tmdS3D_i~R9j(00n% z2^$Opd()b0JtE@f;WBT$QX`ezWIvXGe*uEm2jUIY!68{29Fmp6AyF3`NLFe?c)S`Q zB3WZ(U~*FKrjQgfmx2V0>H`Eu^%076H7Lae{KU_@>raUJ}$u-Rm#MdK4`CQ_}H-rKdwys_4b^0 z_Ga6FGe>+vWM#}tjqLU86BT9d254#nVDznXmhpDFxS~lZbMuYQc^eZ0McE#2O%2d%HeQY8_Towz?uuOv4HeZWKr&Cd$(e^H;zm?35298@gc)x2EJAXWN8HAGBxIA# z6mDg|1>$1XBkw6E7cnTnji7)BQL!S-a7z^Mc#&CBfWR09xR(@AF!#onk!zba!51w8 xXw&b&26qI;Qn4!2x5_7BFevWJ4iu_45)JY(3sVb}tVb=co$qdPEvI3I^8Z=jaLoV! literal 0 HcmV?d00001 diff --git a/testsuite/resources/Stair3/binaries/x86_64-linux/Stair.so b/testsuite/resources/Stair3/binaries/x86_64-linux/Stair.so new file mode 100644 index 0000000000000000000000000000000000000000..c1768b76cfe6d849dd3552efe4b21b2d9345222a GIT binary patch literal 66936 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/Stair3/binaries/x86_64-windows/Stair.dll b/testsuite/resources/Stair3/binaries/x86_64-windows/Stair.dll new file mode 100644 index 0000000000000000000000000000000000000000..69c2abd666423c8914cbfe5a236e5b39465971c8 GIT binary patch literal 164864 zcmeFa3w%`7wfH}iWXJ#sXHX*XJ?dDaphn{(F+t~$88~Am8U+L&2sVN!RwK+n5QM}@ zY9_}~tlDZ{(%wF>k9%!v6|j{AFbVQ7;0yFt(b{_AXhp0%TI>A3YoD1UAn|pz_xJhy zuYSnc=j^@LUVH7m)?Rz9wf9tCvDA_6a5!@Kmr6MtD|pI(e)ad0|9G4Z$FO5p4Rbs? zc++t!oZ(H!O`LW8TyNc+o3ER5%{RQY*W7f|%@Oa{XL#pCZ}MJ$lQ(ej1n)O)zIMiG z`T0Y9Y0yi5boi#{+UEZ-^RM`k$U|FsFMedsLle|_ep+BkT+=pIL&p8i$ zpz`NE^disa+UEW6PM(v;%~kJ{$IXA}dG+4%L;D$3@0VU*J4@OcsAn}nhvV9B4s!hL zhnHQKDYMgYymx5Uuu~j&(cv8a@!zaz{PCz{gZd)rEQe!|`qcMybn{V&%YWI9=@hjq zWgZ`Yx4(F5vK$|}9ge)qvm8ZI`H?Kg4ryp8H)P_L|5w4#x{^Bp0|1`UpW1ApZN5gqMC+?4c-{ELGtK^O# zaSlgQTjUttV)oZ5uG;&Yj#TVURc5&QYQ)xguUxy){;#Ahld|7G5&knU+kx=2KL$Vc zgtRtf@exL%;HURGL3D%lJT+H{+_D?je$Y0vvvQup(NY;LY3r!0cV>{X+Yg%)eKjF- zTeW#ab)wQ)UEV%#B+yd#I2~5&{-Bz-Mve%WYsekUG`4QsKi4pI&xP@vmqV$nlD146 z>8`7X5x>gkHsTSVXR;91Fc(R~J0Wh^%nha5r0L@T-Xu+Hy}-?@e8q+t@s$e9X=`Ku za7KJK7EegQzXmehJ+R<{I#1MPo%2yDWvW3jOwEuo@tnJiRIUPPBRb6<7loffEle>` z+Z!^E45w*w6o@64(%!uN+v~;YSR1D|1*c07QpVKlVph(>|4gM)5dn6-6g>H01#=#X z?H#g6%G@AjTn8y*_oGn;Ka|SeuNQq3H_{8%&I>wKNs&B8ys?2thhFboYb0FT7i2kl zCuLv%OI|k2eMa;8sK=g2in6MwyY;$;=;(05HU0r+TcV&|Fs!X~IG&Ih*EzmUgowFT z;b)JRb^jQLqq%Kyp}8%#H!Ctcwl_QSVr*|tG?&tX(tf4;u-~}Ro}YBi+zu|03u)UM zJ(0F!_p7!)l;L<2@uZOKtW<5=6R*0tO_jXGE_u6P`A15o3-x1sn3E})d`@q1 z=q(ur>6@=ce37qEzl>R1T=H_Y`JQ3!vI!KKS9W<_^aSd^D%_VSm?bz(pr!rkk(^L% zb{U-kpLZKQrucHZcsmd4C%UkDbX3S3WPtbitE9|IA&vFZhZ*3w`h1d+$p3{D|4Vtl z3GbI_Y$#Tu=f(QfYcSX|4g`NO??5m>;G!BMZq%4-duB7Y`wgIf z!eo7-KG|q|y9I2*=1+VU&yrNw{DW@?DaKVhd693rR@n}Tg^~#3_%fhsMV;2SC;&yz=G(pUjf$(O zKQp8)?$(N4mFGSYmA|0eet?Pqq)l#{scWaV%{f`uin^(~E>l&i%s;To2MiSLRJpa2 zBfdJVXwNQPo3eAJcKUns46Ufc8bk$fsh~`y8)%OK4Zz!WX~UTgg35NS=tX(%75F0$ zgwKS6Yk%bvW;V=U`P2l8Kk94XJ#0Se>*fjh!ao15fab~X6grXJ#%I0de1FSrJTB0V zMTiIn9>K01>^kOow4%+{tP2D?t?8E(_n*02FFhwx=r8@<1H5X@5As)Vny@dG(p%06 zCjuggHyDZge2rdu6N`*4YSe{is$&`X~bj8$W0cLL09YyN=9B6I_zZ( zo>2K71cNYKGB+beplll-gu)Fxh4L~2Oi?JU6*1Iir&h%5;J&74Kg8c_@-iZTe8!Wl1pJ+r|v!~GBtfO5=DieZj5tg@?cnBn?5b1SI>5U9+>FzThui8K;@Z zan{Dar&1^m!q?^Gr}uUpaj=9kS(#4XePEaP*{N+6ciP)PajZ9q9{peH6U7GkKF+p zsOSb~FhCRRNgHmV@8_O(pl)FIy-&e4%punAe*}{8W0a0MpnlZzy>lFnegeRVPxN^v zOwuo7&5gZnC`~0~T86nMyq`7~TW27ruAX}3+C6$*Jsc1{6(oOXBl+_?K=NBkclMX`uzOMJ9wml!blP(h_XOdD4cUPM|5Ik(Yj&^9i zBC5<`y%VDzFva>*)`zR73gJH*CKQbLW`$8M>!KA5!L!gF9`SvXA<#+>oF`$X$gD8P z)ya(651bJ2mFng}-Ml+`91VSoA~ZBx8u}RoR!F9Y zI{BT_2NeUJZB@Oe81O`;xob@eggy4Mz+bNtInlf{A$z9r!Qb+@RFnPPbnwxdF65(j ztlu$HJGO}o7A|wdqXs&}bR!<{6;+#?tIemR^IpSz#=7{dzH!!?hDi(mq^XbCy~%jr zZ=^bm@(<=b(eplE>|qdoEVSt_6TY|v`oE^=|Br*vU)IuMwLTv}f2CfQ+7x-X35whY zTlH7pdj^XNCS7unfRKvJ$23Fc!!!B;l#QG$BOtnJ30aUgkB2oLVExJ4^CXl=Q}|@7 z=UqkN!_yRAMxKbdZzATjCX=@Vs2T~+oY|kAk1KjYN+GGY+FU23^p*6HGE$?+c&4H! zY?CG<nt4Dx1VP}pQh-V=t%Rm4ax5ZNeG@m(6G{o)w3I+B)c!jDsXx#T6X@nU!LPnqBs zFn?BGl*l>PFgIKN)1{BB4Qf;A6QUK$+Au_90qp;5($hK4=JH$;qEiW98@4d5G2rYe zBG*L_UcKLXo8E1n0E?E2Y&-%a=h%#C-VT!Un5e7|y;_<;u{Az>y*^m|8|?a3QvaL* z>xbiEpEt}v7EVahucqYXkl7wKcclfmW=oUUx*EZ|PkzgW{7HM#z1c_`TbTihkQo7| zgjl*#Mr^Z3)|y^rj>(YKi-IdcUHBJ@f4Ttovyx59<@)gU;+X z8?O)nUM&oL{>KD(lag2cW%z%F%_d(1NcEH9)#cWlZysER(~CX+g7*@Qs|2VN=`Ob8z|i5k&`(kB8d8-WFgd z0c>FTxc;rLKtBHcw0<-4Gs?$V;F^|?(c=G!eEgEuD+l;69{X;Cgl{lIK7GBqY4L#L z5hDv=SMjjE1F(U|qpasE7>@`*dsV#8I3C;RczQhk!f<}^_3BF+j|ad95?;Ru5>5o6 zPalt0C^`UtyiXRuHVUv@fDJqz55M^pjK|+ceSZEhz%@M{lTQ7AU_6R!5^ld060RHl zS;pg{g#(U9Em@351rKXJzy=#92 zCuH_io0#zb5wch&DdO zFyEKm`!unnOcxEeEnvD(IK+qi#_Ew zVx2jm@;!5&7Tr0$Gs6C1H!47@AkPyE2-$s*=C8Oa4wu{_SfAYsZLZ^=`-pYHx%M<&P1d zEC;Lo>jK@SJiqaOzFWlL&Cq)pHCl;#S|T2Jnkh6U^fb|p95^*@d&;26^uvZ*v~&6 z)=jyX~>CufC;4oS~h5<@-ggFw*Akjp8Ki-=5Ty z_IUJf567BntYoY8(ny-=g&^|QZM#AT^#5k;ozKly^CiT?I_v09w0A7cC?L0fo+l*3kn$+V^(Iw{CW2*%3{CX@MBH-OxCjye#zp0yMWo0}>4 zv|aF79@Y=(1(7q&%g7ZUO26Q)4N^?vWC|XZlIxCC5kR*RnWYU6ItZL1psJdHDhbI7 z5>O=}S=9toNk~@E&wCB;HM~#feYz2Qr-5`jEGxKEg=JL(M&h!9fRVVYYQRWbRuC`} zmsRbz2ao5ohTezGQdN)TVO>Gh zgV5Wq*h_ER`asr;Mz*oKO89TBg%ImN{}^^ktc zl8+AH;bcN(Je*q&?&0)n%^v&zoB@UpBH$0cd1q4f zllKG02TQlb8`%OhCe-BuGyu^4v)ab6Sdg2x)*8f|`9k5rAB)Ff5h5PP7VpAlBHktZ z<|i@_*k4}@E-MZ@P`n=)eq&4e2D?sN7~)azCxWxgFkg_spd^Zo zQgszozkL2|f*@anKSu~=@TU)~z6}2S9Q1t9Cd#U>LzJJ6_+0e-TCJkz={&3(sQTs8 zb0T8mi_mi&y%Bmocj&*1p1te!EjCeZxCWw3qWJ^Z{gdYB3)EqLzA9CZpz4=TPapjI zMd%q3%%Eozg81JvKYQt^%TOi?j+hQnTr~eV==n|RQ1x!9`t` zu}?6Ao@as8znPxH?Me3Z)ezh`V9J5uYA78Ci<d5?;s;5x( z%b)*`BBj32{1?n*{tx}K#_QAc+g^HJbEP86DVIZ(0-FCE^!zq;Wd2Llm#`mv`Sff; zN_`P}o+X&c{0FNqXa0X?dY)lVvX>@9l&A1Qehzw$o1*A>F%PSis$V`mCnDg!2tD7R zH$u<96PEjLre~u~l-A22N|fe52R(OFhxwV3s^?Ml%crLg`T9lZd7oegJ%5t>Wzlm$ z`HXFEXEuA;Lbl_7oTLbHJ`d|;npPWQbq?)-Lubm~Af{Z5E}Xv=1D#h{v%Dp#kojJ< zxl@Ie%Z5L5Wc0`BZNEg8pK1$+7ben9`=I@|{mEOc#cj%!aD;uj=ms&^y)N7M!Pq~< z;+~u=K^M6kGmPjhxf0(m>8ReqY24kBL8RxAG{aa~uwKghd`=EySqnPZEm5is7n)=5GUzTc;Vna;fs8pAmu z=rqY$X{{+tlc7#pN-+p)j8vQ6P~mh$chgI)>2xwPG|`$4m7=LN*tLdJpt^aheS!jR zxJ6dKMc)w1Po%(T=9s}Dlnp2H8_4MSfKI7H&@uyx?LL0*M%72v%5p`>dQR$WCI&q| zYnBnOui@X6aJ>DCM*NAT zz?&IY2T6^xg@utSMr{_Ro_M9#h%fXQ%m_I*=WkhvC*+9+lGZY24~GftlV}XPx})Gm zIXn~*gPxpP5Zl|;9I`LisMdiERs}#x+LBx8Zv?kPewgpcJb8mH@{i$-S$jGUb%4(> zH>F;r`10N{6Mv17Y7}faqZ~Hll44Bib9aTbQ`(aR-M8zp*PO-{D>Srym!X}~Ml?PD zE_eL~`9<1^@}qk?xE6&=Eh2{!g0Fix3*0DOnv?U0GnsW}8%N-|$-ys^_H+uMD+kOpXe*@z$fM4kJp*%R`(F}x|cQz?W5`r4YA6ZAvG8-Yx@l{ zl2t{L?XotgH**CT*dJEeA0Fxb@UZ=%tM|hL_J{7?4|k{!8>}Vr?9=R^mz=NslgzcY zthAsZKXbk^oqwC;FFRO%uYZfEF1lb(NmH{%(N5TGgGA9|Y2ZV(E^V-`>V=`E1Bgt+ zyO0}-S@>_Vwc)sIs&LsDxNItM+4ynURN=BQaM@Jivhn+Qui?Fh_vyS(=ZV)R*`V{X zQ}Ybv$#MKjkGun<%1c5HMG8FgMs6nyMFWU4-$jbf*?3Qtf z96*mvlD~A|{CsApB_eWw`qfguX5jpHgx9Ng0MwtKT)q_ipYC!CV~-j{DM*(nfs9T z0VVCVriZAgf)1@MPo%iEK^$d?f^oon7mauJq_IPW0e=q7wWk=i1Z& z71;w+v^L}aOdpfxsIthdxQ_avgl=3fwwA9-rMN{$9YD_96VksupuZ#Yrv~T)%)f-> z7auHN~w12N9)Xhtb-*6M**mztXMsw31cwGDidhEWPGg zuZpg68O6MGS*YiRdWfw-{+64kC*_`>k?D+gXQ+%}WL#sU)`rSonX@`M2I5mDn=*Jx zMOUoPw3IwSz9b61L;I33tv6$czvcSr{JVy^!9e=^xttM+a&YZq_w5+5m2DsnpqC6Y zOOzX-{aA>hqe6{k0CbNzwwM7h$JWL5I_4KFe$t*6+8wQeJr$nSsL85?uUF{mtB^HXGXx~}0xP_R5S%hh8S zTSMKvT}l<}7XHBOKMpbx6Zs2yST}rK35=7iUz101FZoy4`BjoXi2P1h9zbb>yJb?X z8>~YHk!ngsFR-SNV#{L0N*!!|%r0x1LK98c>{ulgh-o*>?68^tLV){nQd?549~_*!ANz*T>&zz zU(%?ej5jvs3O-~-ODs8*X?>jxYm97>PaMm42i>Rw*OION)@Q64q_oGjDY}|#lRvW& zF!{Q4=|+R&*zqZx==B%IYmi}vo4W$!5-C5oo~d&JgtcpB1?!H=axBR$Y3un5*eAwv z#@;#KZ}~&lJ@ePkTEG^`=DWPx3=WtkAYgU(7at>=5-oF3=GNrw5hFf5ofd9obF6KDST)l(njq>)j+HX1Qv zGd#@PYEP=*e7^|OAmb6-nJOsa4Nd+GNsqA8iRwc8{lg2$3l>ssr_sK{Ym|^K3GOsX z+6~3lawn*90xu3mZJCsT_2OXp8kI_iSRc(+FS*w9d`-UHufDa1EbB==r$1(R zw4csHJD40$LU+m>=&`!tWv1+5v41+F!_}N*U(7~6Rq&)5N4BQQ1Y^&P-VL~#9-gbA zi1gJ|KqBm9^B*`|jYLt;&*__W;nx*(mvtfuMc8yd?*~(P@2LP=`6f3Pbhs{|w$rK; zvG4@4G2Q18)^0Y0ybOjy@A5tQR&NJwow8v}AvGQ5_ULt7R5SkuYabGVkt=F`IqCze zEOM>O!HBL3mP6z{q~0T^LDdqr4zB!*n7Fa7)ce{J*Oo%M5qG`BLtf>{>z{daxPHxF zr$PW1$4VMj{ZR^6|FaF^J_>Tyz}Le{d8lQ-18cpwqht4 z&n(jmqZ7lU)@YAkGQx)ox}tv@prOSVFnp-nGG zbB#L+UK*)Ji+*J2_zYhht=l6xOD%v4wb74g}M9>V_vaRnG=>|@QQH) z$s(6Nl&nt`bO->mxl1y+1*gV{H%l{ui2A6n5Ixk0wV@R^w+Nnjf>yc)@_jn$NDZMh zex9gU(zjcIX>P+JD0@TMu=%|9hnJw!*C2b|^wI2t}_JFxnZ`^hLO*2Az5x^huV~Qxql{0Vf)}L#}i0D z=(^*hPS<0+3dWtTM@Z34ks3cBsjYf*#M~n(^lqo?p1!QxNyd+Eu?rlj#YRz?hMe6- z`|Dm~Xtxocx=s%I9^kyE(TnaozLR|GD{m{7=_JZ>3<^~;&q`k*; zVv5_SW3T1LT|YY%P>t)02-P+AY%xyAU!Y*;&*8y<%o}RNUR!O%^S_=3STJ{l0HmEA zht3_$CLCMmLED+i+F#OE=9=XLx%+!fJ4h|$maPY6;@8!^Qt9)h ze)J(_o9V(l6E@$nCL$)P&FkFN=D8trT50vDzwaKGGgCL07+UjtYFxQ&QP$Pcp3S_P z&luV3&3DbfhMaKuPVIIvxAMY`SUa`YFL{YA+Td|$P0Q?Lo-=YJ*?A%J`B3&c5fa6z zZZyl5yUAa?xbghjx!>3kEiz(b?ikOM5aUz+Vp3MmF-n*YOWS!irwXp)GeXCyD^@hJ z+kk22tqo;ww60=C1k7QQ%Xb#{kh#em!A@tqKa~BPvagXYl7u%^@X9&Bznm(m&hm2Y z_EQkj>MkYp=0AW{$h_Gb8ufP1L!<-dGu7Ga$M*I%&Nq3J?#^8Tp}dg`O11`(SZA3} z3t=FO!M!raN*NM!50lcKGX6z}N-~dRUL-fQMlbK4v$6cpsJIeRZ9>&H>c=Y9IwBr3 zXDxN3#|r%DNy(9k@lN`x$HyB10r4AWb@n-L3BP@;p)EfZLkZM|W|n^pR}{owe!n zwW)$XoDIq8+@Xe9C|j#p6NER341GEJ4%5)St48#qJy5e(Z(D4?M0bbgEH&OKUmu4kkma7$B^-_|vQY*t+KIzE5Jqysib87L|;~GBuAT#1<6hM5|5R zd#cxU@8Mi?BikRnSo(0TQCpM4W_h@geFCgPHUukJ;_;KowIjlC3vT^9>W5 zksl5JC(IQ3sT>hT>h&~Tu;p1#GFc6?W=e9fQFa7Jqs>dHx;45hF*a?>!{4%dqfwh> zWVgp|&2cO`EL?kGj!}E5J7ne!4%g-ksm^W>Wy7|;drPlj5*WO_@q$Y$D|bW=X}qBN zVxB`9FOaT9j!zzHg=jQZU+h@yw$3M+GT5WAk3lY|mC-s`kc!s>=t{SBlzN#`WSwx0 zy4z3DdZe9JLSkdz{a>Hblg)(z zIyu$M{~aZ)vE=jZqE!vlOsmUlBO@ zX8vr-a%yU?o0jOv4txUUGpT~npkZJ>viB^#QR0eM5Tw5Wi1jure%y5m0AhPn?5`6A zcjbe2m-S14(e|)T*L!@B_RywtExtO^yF3NQ%>SFyrgWZV0V|gOC*Cs#@7}ZcF9Z1Z zz)>!}yzimbKfP)hCMN3vyP4rB*OO$Y)}k5Cc~-T=2Gwp!4M=)ikA8qs$)g#%>!dhG zpA@jJRKaAF)KvZgz9N2J?bXt;jfCTdvW*yNtLnW^e*_p*n!=|vhqX`6$hj_ z)MoBZh=+pf2Mb4%HB7Cnb;`4S;Q9$Xuel&koEbeBFh(V&rOba?t1w&`i4ore+;q@f zYSdy2$ZjvM%USFyuX8UR1fI{!qOEKV`|T)U5WBz1PQ69Ov<^C9nIpAWhCU-CZ5g}2 zT|=%$Gq`9UXQCAZd&7K@dgAjK)eEG|1`-{l$JVEkIRVqiQHFO)ZnnIfgE?^0NT1P* zV?OivJY9~ny2DvA1r4ABeP3NsXI~~5GGzehUl3ct>^$qQsJX$CtpT%3PC&d0fy3rBw;tP=GHS2% z1kH6p^KJ9_#H|c|-s(^y#|)H*3v(9d%7aliU*!DQYpgULEO165r-8dQV&Uu!$?R(L zY2Dl!O5`1h&m}TkH}#w{=i*~{y36#OB?W==jt(T36?+3(klEA`5I?)-LGNOFKZt)9 zc|N8WSod9N%RN7P+Z%nav9aBurj;x9F9b{p#>b!*HYd%8E4NhPcJx4z?Mj)`JUF3; z(;_}-q9J+353S=#_Tz^R;Yh{@JzV$mjvqQyqj_2yfXt`qe1bvqsQN_B=W@z)KvUfc&OmQR^7 zcc`^dlBO{Qn=x@QRc`AE`4FGN?2~(4`}ow}*P8pR@2bl6Q=(^EcdN=Z1oUi;oMf0+ zpd0=}B6*&bb?UI>JJwCTz(iQs%lSu_%c!Vz>S9$NF{741`&+sFO?;N(ckjj9I^Kq* z*db%@5S?X+{aq@6t!-0=<7cs-Aa5=Y%>RM?PG^;h0Lau#jndO4V8D;)@zZL%|B=S_~8$&={^!>l*#k` zJ>61FXgm}*q}JR{PI7j&`G-BFtDP*U+%2iE5MO($po|@*?N(x;^}pMbJH-VX{*4n{+yELOrjb#3glqI zrQ49k3M3s!zyMZWrt+MAfHo^Y{ooueaKu&soWVAnAp&O~3+VxHPU#0{o`Ta~Pksrc zECUsc*tLRJNhot0P&bgaej)3!`7EObW_UYZflx^-O6LH_UiB1ziH^Gex~j9jCGvkR zfN8Sm5Jw)dmx(6E^mGM~0?2Pm|Ifo(d;(heJLv%aBN%x%?oH&2`Qvf7-K)_+QEgA*u(xu_r%dzfW>aI%U z93dps1ExL#kt*BV;;Ka6h6`&)3=d^*HOgO_WNT_1@UQix`kCFJ0i#nkG`DY@s{qE-TmAKJ!w(Xb8pJ zMmCUk?#^zAoT={~n}RY4 z#_O$vd^x+f9l3tb_EbCeO>E1Y|4;i%kzIt%h`&^1mz)^I!m!q=#ynsd@~2Y%oG*XM z__Ne1k-z=<%^rVoVR~6`#J~KqURHP;o!gbn4b|2$PG?%1V78d$j8tGLi(Y3WCey8p zimadQln|nwWzz~HdDeR}(QBuH{5D<5sA|~{iI2~Eokb^E+*|GD{?%6XRqLzpQz|U& zrx!~|t?(Sdm)0$psyy+-y2THhzO6kyfv1PL^tcWBV_M_V_He@RuzGT;KO|n&jn+f_ zL_pZQQ~ksWsLQR$T~ZoKi+_|sVhOeWB$Am@+sI-iHp{Hk9_ighd7NXH>pC7GgB?ce zoxZ)2GM{h3ybpX)1`V-k`w?iRq8ZB7%(lJDI%&5+{l0IRREe#d-n-Ipd%4K@Nkjt6 z#q+8wsDIl~|KI|^yPDpI8;#p`Gve4HPCaf^|#xnG2 z!Z@e1P`zi3WebS?oUNyJ=aop%^6@!Z;!+Zg!{`e}t^)J{YnMuE zP1jPpr<^}>oj$Y}hnXbUWyEi5%XIMfEO>SYB`}~L2HG9pm8>Os4(*$5(A#WYCLK;p zQhGcdogET0MNhmzv%@;|eS+XT)jROt@uNF)x4CC(i`!7=tGmmCd$rgS00hk2w#l#m zp!-(0pd&M<92mVkI@=?>Y$3K8;Y3cWt`U~O9?Ic~SFaE#-1V_sN0qu;e6lkQz8LM6 z7hiyO_mMIWvM+K6OWv>>Rk`u%2c!f&T`HpTub|CZ@e|-S0*kG5qbDBpSeJbu<5Pt? z+lJ-qk~|}Ojp&AT)|gBN9|PuSPx1`w6!nRpYzUi`#YXL5W;qmK4tCQ@gY_L|3~nW_ zp4w!@0Fe`HerL(kdTL#ue8$qq&1muu^ejNdYHb#~k_z;@R&FBSAQw8!3YpKLm`-VB zdho1)G|L1LJYLHvP0Ekuc)5HkC9gp#uzW%6D=n50u(Cen$AZ`i12s8VJ;G*ni;fAl z{5A}*cZnvHdm(9Mu9x2|LRjm}lGnbPt;e;B%hH8m`M#|u;dO0!(o_o-s5}$oM^q3Or-+Iafv7n z@S_*D5c~rH=^zxV_c$U~ihFhBu^@(q_5{U^vMHWOu`$TH z%{*(c3BlM#!p2i*=a(;BpK-0P7=|X~&Yq-apa5iG>!}V|oP{ERa{EWdwA**6#rXTa zLZK6mYw32zlfuerO}|j7wCUI^hHe&n={hD|eL8MVez9VwVM?rR+2#BQ$4;S6?JYUh zDKIB~{BZVWt?6YxqKj!p?fe{TxU6G|yg{PlZ7|<2y&Oe$6$N(ZHbjQ(4mv!x%1HU) z)?XNS6j>w!^x7$!@B8U*Xv0C#hK=&~B2{J6awxpwAcf^yn3ADbniR#VUsaqZ4^M|?`rCFzVDPBKTn=0t|+O@j!h z$c?z3fM)y}BiBVqBCS#N8bJGn*(pDP(y2a1zv<9T9U1Df$!PtO8_KP5mUP>;-mN?t zK3?@T{>1A2j%aDxQ&L=}MLn@4g<5o&(YR!~*n1*Jm5n5_B-<9y$Ma>*klmF&C!!Ms zcaP7RsWpkdEptxA$Z*S?`B|l<=UNf5#<(23) zT(tm`b%`~^d;zW7TEVi_gQdvgmX$dpVhh!h@+N` zW;HJHO2K*440C*Oj2~@^OtO9@;LMAODq)Ga#2wDw8u82hZ=&ZR?Gb0P2%sp-f`Qs8 zO6oGc$j-Ew{RkXZBuBVlFZNJ3p*1AW7haVzN{N93shx%c04hkm)+W^ii!xkEUF&Al zfL=%Dbj+I`Y@3A`EWIIfAx->QRPn!#6VB^d%kH4pP9a*TMC9iWFT*}Lxy^_VH4+ot zM#6Aw!?RRe4>m;~nMNF5Nn7lU*fkQ&=Q>J#Cqg{oa;hXNQhR@!nhpE+2=$M{J{EI$ zFGSX#geyTgi93(AyL;{-x4(}s;ksFJRbV=SX%w+;qR8&G&Pe{MLZK9 zH^cn>)pX_G*cU8G$@=0A9QOycH3%Qa8Xo3F_7>KWe-SY=3uPD~Xyx;Uqrz*%n|y7m znfW#HD_bj6dc2_)D8roQmuaDdXxN-jU3I_P2J1AgKeyKNM{I>wn@ZqYd|VP{jTiqX zF-T$GbnB1I-mtkt3Egnnk|~j+I_))xneMReQ00v}BYvks66+h^Lo)GkX;}BUr2pHb zGU~)16r#y`oHVio6URpF*mOTdY`kGo*%1*_BPzsZtLHVr#)ceDguK`-3e8J$%)!b0 zaN;6f#}%5F<(R`#1y_!A!l{r>s7w&HEEDPWb=%IB*O7obV;T?wjlX^*3KL!D-8I` zT&(L`TEqdBwgs7kF^cFhuVba`mGrW~(Q9<^aO*2Xs6~&$ap2WQwTYYC!{LS^?!hjK z4(iMnVoB)|RXRFa=lA*aQC+cpS@XT2*n(n5^lXv{byfs(8L(a>h==9CuCjD&u)ZGOAVXa%|0tzq-=x=-qHJLDCH+)n4_6VL9F~k z?XK5J$d|jYNjSGl(mt*awnk|v+5G4B?AVM3> z2cMyADmVd_F(WAa-U^#N$_^$`HNi9SkC&aP-6fk9tDLo*{Y=OV7Kdx6=Y?YHa>CiK zTfV-}unBv^vxWqlcQ2l3)S{c_G{^*-Vx@>*4w+L~KlX-d@d#$`wYKreF!AlmDq35e zL*b>ewaV_YreghI=QvDHZI)I5x8#q>Z2fU(s-ryW(C)lN@gVWldMiZe=bY$gk+&lL zw62%wFRC8*f+|lBzgmcbck<$zlHFE~;8A-q+E<4?#g4Sb^nJ2t*l78Xo~Eo$>~wzi zHb(1f{#(h9<5ExY`+_6NPha#~obWcmdle@bbDD%+zsYhWr#MnOSpPz1Ti9ef*c~+6 zL&T_X`pzwDTA{=SXhGeLJhA`#?C~B4mKPtCz1E92F~Be&E)QXiv|j%c^y{{Uz9Iv_ zR3w`m`{!k?r^sYt7iE00ne+GR=z_NaJnj8gBrFj(@NB?{J(J>h*BUBH9nn2T;$o+D z&-wO}K<-gt#3pCnXvn%p8aW4K9$bg^nyv?#TqQ579|fba+!Ye5 znRKy#3wIi|U8~%1W84*y8F)vf180#Dcikj!@9}1o9sPCE(bMf>W2$)(^<-+MWI#%G z+9gY+q)W{G#Iz-i#M!UDimyL$b{mgS;v#q z96t-y?5Ws}3)lp;;qC86E9k-~(auo?)~-RFgVc(teui_3itmke@O;-9{o%*MEc)*< zOpHnS=YohayKM^FOJNCn4p@JwLLBWJPuH13`E!$kP2N!J1wMmht^J-24#la0=dsAx z&Hl46O3XlhfNZN1No~YVJePE4=16foY4=keepKmuR9fVRI_axKN9IV_5NiWmv{XoY zS038?Uc(%!V#h@;_xgjuStf&$xBcXgv4Xnt-x5{?qr7|GaJ|D{?Bw`;r++li9LcM= z+8}Y(Ax7CsH~W$3V59LP!c!gd1{>wSk;HsCuYay6Q1?|!uT@CW(T16j;+Dk{WW;|U zX-;|>@!v}ojwf{U-7hjzsj2(RsDsVNUSChxJWoei5Y?eau6{kldI#~^>EJ$1ena#E z5I&RZa>wZj|3|UC$Ilznp%**xK6UD&r3BMR*|wRf%2-8I)Q^=csFK({t*J>y!OTYe z?pZ)mZ#}mf|BtRc)*dX`Ehg)%*fUxFhL29wf_o!_NQ{aO)?151DZpmw>L-3_eXw5M zqcz_{dx>$~6@%vw_G?de#M-)($0Wu*RB?Fb{o&-W#JJVGUv1~Fhs7r7t!`pjpwyuW zefjcNBd0dM6OL!E5KhyAPnlK|XRq~AcjO%F13H`T_kYrdu$i4a&fj`wm>@z`hY*fU zy4jP=Ykp^i1WT#vC0pUKJs+^oOkC96u+PSAbF95Pc|sppKc6YitL2OnswaZ0}XNThiEBD+1$|(2_M?)}Sq$q_2p1;n> zW&F*G-E>xFX-z+eJHlaBpURb4pZe=p#jFhe*0;>i zS+RXC?e2Ck;*bp!Y$&seABxtRzR4%~#po;4+u!AF9~OnjNtjhdt7W_m=fXm>z1_-L z&f>roB4*v*^lM}oF1Q7QjXkf#*8AgCMambEc!@flm0}cds3Uv=2YHQHsVsE&0~EOc5aGg*Ccq6gRJ5 z;*y{hUqVmmt?Tu;zqsKwV!izShW28;y(hcH9ZDH~`H*}@A4NSbsEXGZ+=Sy7{n5y@ zjUv)s6KvhafvS%+-c0H7wX`^wy_=Us1MrnBKaf;XP;DYp#a&+$?&i`vuVuaCLw3r@>LW zAR3J8AgT+Z7{Ua*kl83I+yO|+aYC~{lAKBi+en(16gO`b5^ar?63D8zZf$s7)7#(5 z0U_{hUDNQ7vUyR+v~1|HMv>c9HQ_OnhQ3PO8y~WV-o-yL$K+knHn#ynE4pN zK6$((UgDtR75W0>CA;PWr%QiQe0;pPcPuh7Jzj@C@F*uJfFn8^HLaG?S;38 z&0E}I6D#U7)}qPsv8qsAHa67Xx)YVo8#WKGX76mCM-C<@f=H{}s26?*e+>B(mOnL) znf#q1$yturPg?-bc0{(w?32B?`~q@k*o}^v+LC5DP92UX8q|XwcbM%`vAFw6tu=@n zb~N>5VHq27HgBSp+>5`)!Euj%*fwJl2w`e$+ZzQ@v5Dn!~}MA zQ%7^To36Gip*U)|xrv8my@hW#&Oud)kSR5aBZFe~qmSo|4;FF1Q9e$N0ma98xE2n5 zZAxpq5uZ9*a56-R+h2cUCfa8dBzO#L{akbT2sp=Ko z*1D+}I;d^I6x-@2_E)(=!rF_%%TT>;l+E@;*?WAdN-Qv~V}K{Nk6))^vjmYR1e7N}+wix{_61tGuL1i|r6}Ig{D`)=gXy>C+zLF!qS9*y~H!+~!=?Qt7L3YcT<1b_qaC zQ1(7$7t>QI{NJ?`k*j%&Tq1vtmp_N9ZOgmL-Mzv34f~elOtGdtB&zpSdc)pRP_Ppd zAoT_-iO(%*sC@?ADKw3}Y>AA`@v7ovaeQ`h&kZ!HYGA0FFgl6xgN;kNWV~v0^ZEsY zV^u{td$#lP2+Tq(C++r>*wwrdKb232oWb8wk>mM$Dlw%EdyBPZiM6DryGMNf0-}eB zD+y=MZad-adB;v<^}IpCh|ey9)TQycAa)k1aL*?BY%X-mi@)^dq9_s2&sa;j)GW}- zD71D}Yfp9u%3oMC3m+JpH9X;u=Uj54qk*m8ByLTT877+-vt~s5TY0GN9y|nHAb}eOg)_V$tur|>aBO~R@O3Dx+9(F|}`s^@1+ z=~ScQs+DQ3TFNK5DvG07C_6A$O{8Fks|?a#kgL8<)i1?2#YBg1x*w@7sy2p0|X3KF(Fo z%IA-9)p^5vxk@BhdB-Ax^t#i0)yGy>aG9;l6D7vWbWhadFTK9d=9?4Xo8&QYkdcz5 zMzJ4E8IZei?U$4q{g3gLZJPNakXZothkP*J`mc}k)_j|{WW_pQIr*%d_6o5q2jMiu z5C^VZzoo3%k-UdJNbK#>R=uoZT=cNrP6EoWXY@LBpDf~~J#RAiDlUrZD(7N52U)E5 za(+M7RO|=e^_h68X#^9`;W8f57N6!{JE!OCsr|dK_500Ld{Gn-2L+OnK>&S|zdn9HC z4~4pNF0P-Yj7-2`F>>_8d&|%2D-VW_m~ z|54_R|M7bLu_^lFdd0O%rrN=F`gxsN)05;?R7Os%2xxabA?fkjUB8g$gvgcpc^#3H zDz1neRdJ2hBqq>`TCMrpJaI*oFs*vTFl=4V1W%%}J#XDi97Hl&aoyq@E3S`RS#eXO zrsC$v=!&{XVa41?enm7=}VdB5S8x0Ff31-_)3X5$? z+st@yN6GG%;Ook&EPzKzYLKJ`bp&^unk>|tHmT$&4xqPhu~g&acthp~trN=F;+)d4 z{MD$|i>b7Wc`p$AaNdj2Y`yg(f6Jn? zU&Ga%6)+c$4vbo81V(+dyFD*DJ#5Z(mq^Ub;*8E^D%D8P8J3aHDsJuYv~I)>Zlzaf z{(A#q#Ub}Xv&x&$o$*R{7PL7AIH(Wg zkPOHO=LQZVT6HBm1&1{xjp|{hCYa_5qWOCE2YUIQMXT}DXsL#UVTaaaQdo@L+FgyL zXvEJg1E^r2^hQv7JdXp>)jMJ{b~vgN*ZQ*b6(Vj$jC(DAK!wb6Wk_&`oZPxV5TWmV zsA(D0qOO25H#wqTci)h{p2qA0rSiE(^v`!|6t7(eq;yd6TEOzcmg6rj& zbPd~fw(D{a%0eT(ZI`=HIQf#+Uq3-+$f*qb^vi)V!;j2(Y(JU7LDWx@8U9a@87bBX zTV|Xsx}lO8<-*sWQD&SglIC;B42?)YWJZ{&(knCmOi&6kqX-1jGGj@v%$T#E%-H$` zWybTe$I@Hd{2!MZn?!1?Cr?QfB{tS)#74o6;sCUB1<&h}^gs{MvZv0pz1QRWd$WsAS=qE%bL~ay$ zuz04(0$kdkO&FB;l`t5c5e6q@s)=-yE{T=yyUd7S_6GrB_~pstgyA`5idWZsMi^fD z3eVfpmz))QD=Xra+i^$6{xLXm2m1<06fvJq(GK|G<(WhL~(Qa%JA(rWp2ZLkq}nRrq@?F=6vw z+h=km6f5ESc>iAQ$=PN6o&(3DupCG8!il@3IU>xGzOZ?>13)49*@AneDHu#1p)Ebt z*-sl=-U@B8#LQ~QO)An4iCj`=ip1VHosB%POe*;4MXTdH=8U*-UAS-;iN`xSPj-$C zONty(ka@<+5d#5!+^~6ZVL*F~Td(dR+=)$Wg=a=&c*t~OH8S(s2;vve_yNHWkWH(mV=Q8aoy%FD?abolj!{SaA5 z{{<1k%?ho<rSZPn?X2Yr?KWK0T1Rq9+Do&hVXskMpp36VAL2$=vi}rL>md%w* zfoN3yXvrQiGuDY~ny{_-1Vi?U5`rM%TXrlGgSOoy+@L2ba)a3A4v*~{93kMJ*?NT_ ztY&K)+Eh3_mTDYfP-ZjyS+@+IMG; z*rkip+=x+D$BI_J*K!drf~V!P7*jFx6JOAMglv407nxNOeX+zFITu#05~2*_PxM&r z@k;N^cy98f)=Fr- zk1v9*SVxECrjNZ6Shd8Qa2B_)w8?Ob9H|gFa=6G5dt^rMH!{bF?U{oI`7aMfb)ZV9 zwwtI1r4TGIH1_v2wdwp0(`=?UExH*Nh>8_@962BPJAZq+&h^i7Z`FJzFjWRA%3qf zaPL{MOeeEZ{u*vAb3{+d6dsB5(`esIT+a^F(VVqhCeRk9sJ?sb7-wXJ^#|*Z-Nf1H9aUiHc+r5r^rLKdx^&+u8z6KT8lwxc*6qLT9@uDO9u7W;8gMg zW0aVa;78)$It^_s#O$zcc;4O)$ih3waMrO953)4}XF0#DQ@)2=tB0nNSqmA)G@x9ytq5_} zt^9*z3#+>wAQQh@d0PCLNEsFPj8NiS_++^as2wk#*nPP8dbOh?_zeHv$Tt8toqnMNP$-x&n*to=q2j_Dm&&^!(In9Vyb4S`%F}DO) z0|+0L?Vz!Pi&XScXE2EyM#2oA;z>|&GAzsbCaO?>62@mPBuZ4n5y92G=kh)>oCs>X zUq|{_l(JmXv==;y9nuog^GTm>-THzYN@%$4%`EuTtX>`ak+8Uei# zUA4I$OF62(ED-zPq!=&O07lRQ5#(YzPfsn)^Q|Z4SI_;|2aw#y(h@nxh;2aM zSldu>xQd>ya#|BKnRz>9N}(liYmnq57jBW2d@UiptUFk?2(~RUyRr0cd0y36O8K@(bz|v0@;tw>^jq>gy|MIOd3qa5AI;)9 zys?x^F51lhkGpq|Z?Zfe|C1(x04+~Z3PnXKR7HzgENW{2lQxkjl1iPRI8SU%Q*meC>*OS5ucQb@pm;rcIr(x>0_{uWpu~6IRQfP93va$cog_ ztM8DX+|^O}ajm|cpV-B+hGjcSXN-BsSmovk#*B z_nnO>_;#&IeWyuY|Fc>k#ADp|py3-hC^gwe8v2cp@0 ziHo+tc*YmNQzl^YTg2~ve&PHA-AXSL3%nK!5Sgm_H4bTt%-XHTtGAjL(WT|lrA0PO zWk5l57(>mKYpB#orGjKE`kc^pC-VT#XIQ%6S?RISVX#4;=aRw@IQ*mw9_3cn9~#yi zGDXNGVozU-H^+%{q{M&yjlV4)y3yN5#Nolp88F_;2T&^fYmv+lq$50t4yDU+$Mj!@ zoq^2MMXKFUvCP&fndj+(uimug?#+1`JGS4kV}j8(xA)AC>dqS*(Yy^Gd7mHa)mE&-!zy)7Fg;Mt!GX;Kn;aY(+RNwg z7=~f%OvN4^b=Z4eiU+`P)DrmGu9JAp=jhC+Es`v1&&PEVU=c@<=*Q%!HF{(sO}YuSG_K zrEA2?41c6-5YlW+w_XpOF=FxP=~yrYJhO*Gaw3#uaZP&wwY(mpvw5@N1i7l*-9r*2%H7UopZiioppwYzhk4_^24BA-twst z2Vo}I*;sQf^|GD4N*D;_a<7XrVncw@UMviIZAsfxJ)NaKMP?(&dc;A)sF+aojq3jJ-^X3ov75cHy8|=H-V2&`7 zb;18Nk4T+Z_vI8qz1tDiw20tVD689cQ!q=Qn0+d}$fpYRQ>p4I&eH}vk zA9BmqoF6hiYaYPHx>}EJqK47ehB09{S zpmPNDiO95IY^rQ}l^0%je35!uW}r$zf?3D6sW?q8Qk7s^dBnYimEK|Wsrd^IQSd&f z_7K{TlMyk%!IUO_7%P>=Z-eRr>wzVt;i0Obz8SU74kZ`J`)`;x!j3;FNFb`>tID}z zy}QGDXB_gby!Qm*Y@bO9^BLa59_7uDo0rv%k@r2hxk$b=@}_c4<>g5q_pc^jVCTsB zCFJc9=$8&41yW&)3HyVKAOy_dv%dus@~v1;VVEWU$$jz%CgT&GApS5@ZlEBEevD=I zgbdeXzoi!hj1QJ|2g`Q*EJ|j_7JbJ?JwA=WcYmWT6H16T1Y&{A2@!=62hV6qsN(ro zL%k4(HT-cu)DA#1w#(+%a2G+hvt}ETuWgUDK+_9dosy$o4@Sb(y z->K{r2X%1~+?{#=SD>_nDkU!@%S>JSeNq_qeO*L?Fjipl{_=2PGdccqRr z0E!%`!XCj7+I6{fitfbd2u3Ba1d0w}k%Qnt^EVK)TnD(uQ}irBjplOe*(x><&rVU# zmRQgJU_Eyv>; zfZS|7dF@a)%+G$U#V#Dl7zX|vk2q+4`#XL-8^gKgJ?P6osjfbkwR@wYsTQwsP`8 zso9zp7~DhpZD=ky zv&gYcqs(IlaK^#3+c@F2Gojd(t3x|vtPhp6R5d%@z9xH6vB~f0$dtiIh{X2rWhWAW z7sv8tYOOW?&*YS*KZ93EedZ*VrOS0Qib;Pu7z z9J8KjQ4w;@`-!i^*scE#;opU&yx~9#>tYL!&hYV9aw_2b8U7xK|3ck*8F}|e4E>?} zd;(TU@$)YzMm}n~7it7S&k^dz;_A2b=jva5Rc5V_N7@Vax%A`cxt<*CyOiH|Yfg|5 zppk#@N_$~&NsIE;%%C@xzDPGFa^`~R5m9;41xGOx?BG&w`7M&zBzB9ttqSQR7Vx)# zB6e9u@E@_tmJ$4ZJ%&&HKeo!Mi=VxmS-tFb1{Vt|%~t{gaS=xk_DT8o^CN}ng5U8O zhidFsG&2-YLX|l9?3Y>V8XHSoj#5L%C3N0xv!= z{HJ6vKn?9Om)>Kg5hI|RmAlKld>u!sBo@ohBo@1X2O^4_ClnccOLabU6wQIq(gnZW zBAD~9Zoohy5qPo4fM!b<+{<%;ECff_s7zy$>Yfk|-fWgJENhe+FXM1QrJ_m_cIb!l zsnO_`zQ-D^nyow1iZNmIqwy(Vskcm^4nK@=x?mz7maR9s(*@^96-doUAXdyJAdrtY zcy9Eov|=oqej$fsTqZ*-I!3Kz4DpAGWw!c!F^C5xiICu_CjJ42Nu8Y;o_8Js>x3;j zWfuq#4s|R4O#bcXU$-Tt?s;6K)TWYB!;l6NN)U~>x>S+1<^}Y>ZmFpx#eqad;#aqH zzY+@nlQ~Y93pQsY#og-R=j!2A>LJX*L&bG61%&s>*qih}n*m-(wWLpo6yg|Kxna%Y zh3RKWrV$!nOd#dj10p*0(nSIOeGLWSG=3qH&N6!Z~RjlL~ib(9@NhGU$o5v-P5JR-4ASGSX^$Y1aUypsCT&`wxty9QTn~(N;|6=xik$P{nAt}ZMu@NI!_IhQfe&932gY&C`+B3U_UZ8h-A?y2f@R?-qccm^g~GPZvD=s_IdATPn|#XsPWsxC#kWVvUS7rLD6idrA?0 zNy5+Nol6D8GvPz_=Lq6sZxo!T=piO*k_^4j`dsb3{HfNKUg$KRGYGG3MTa(@XEWih7Z*^w@Z|k*5p2JB%Xf5DlV)T z|6PyWnj;f|aiC|P*7zkaROEqbVW0LV+0riKj1G>1$i3^b2{ zk^#W#Su~RYK)mc3?8INeY#WJHURr0IB^~;XEs);Rm;Fsmhef<1N%%Lp0nYlvDgElF ziEe5pilF;5Ro_8=%#IAUE1z^r=C=gfsC4J&2>%j%Quro6GO=j+` zUyJX_p3_zw|7U1H#qobcT2yiTUo{yQauh3$zl`JlD>slF2KPt9Zc#epF}?b0@eiWJOrHnx_ALY0VGE zJpQf(GkuJ1fopZc3g)U}a5WUy@l*_GycW)fLb+2#W0eD-lOhEW1P7J6Z4p6a9QTtkvKO~xt z=iU6NOb5wd3VzDfD(GMVlFPX^zf{2-5~T83J@3rjGsg{h>q8YiJ6&*%bchYS(Y#8} z&L+^3iOH}8o;5zDP?!VaFFwf+dU?Y&@P4k2T~FG?=sU-MrelRiL5t6^@FSKyXTVjQ zr0C>QC*`bbV{rm~aBE5;fGH0iP49W>7m3OY%nZf92c zXl(W)^e^dx6>T#5yu57bJ5~Au*EheWdr@M#r`M#GSsgi@j&S-?g*ZW~qde2+Lu3Pz z@IgnpVZ5N?2NCcRWticXx%j>j94@xm(!~pnmSV@`oQSKdB@r2{t$t_7d}lgGV*XU& zdtnntIQfhrZ8Iqj%Z5OHkog50PzFP-Rc-{l1NkkCx*^Ln^F&&-wnb(k6`Ux!g~%hB z*Ev=u8G4s@q7q$HB-VQDsm<`(70toI-& zX*19bNm!_Y|6p++3%qB(Mk{qo^KE4L)B@;8qHDcM?|b<9DW|ZKU=f3cnNaI@A?p_o z8lI9{urVWYDHhavtPGp;vt(~A#AGHU1R=X;Cx`T1HMk3QhX?PEP9L5RN1hsHRAJjg z@bR!~f3$Y^H`ZYT6?&+ev6t^z(yKt4qljs`L!M4HC}i^y=;=S+*Pot7(j)@Jbqv?& zM%GDOd$W*Zg0)q$&M~SpL+A{SlN(JrZs_x=(-fugb{TW@Zz=DCtw*4|-%}5jSbm<& z0t$QPcaEChXYI)f`jVvseRx*xVRz8}$!aSP;EJGELATjO$iV&ewZp{>fGLV$Z69;s zt4meAd6Rf_NWACze=Zjoj_Xb7g1N1t>+PEBuLu|aP;2;=0&Z+J0Bfz`PPwZs)Z_D< zuh@#XcD!9tu7%1Ga1EWwdQGu`2elbf4uY}>dNjvp{7a8|(l7*3Pfu9IU7p-Ez>Nyg z7?Lg+vPO}5r|QN!u<$w<8aW7B4vH-ni6%R+!%A2iYuotd0ZsmG<%n$cbeqD95;*M% z;i;tSM~<~CIOn^}t?+ih{J3^AxI3g8ZV??Q)?MU)L(x5%`ST*oV2Hko6@Vo;k%<&JAWQ;?-M;WN_ygjv z^HgXMj6Wea_l+m~X=I>O?oCaMb~_>yv1Gbg5kh>*Xkqn@Tw-Od4-YomMZOj-_E?8i{Z}?P-uWqsSVIN@)& zKD=8Bug9c7yYn8FNV2;#0y5QfjtQ0|f(Le2AGGyL3JM+MnsysL!;Y+UIIvvTN*0!0bq;u*T?!e4skzrc>dfOou*8 zjX=aR4DB7`=Q-n79sP{Kqs3cexPEn)%;$EdQB5iQ6Xr|_dl=QR^CBI4Nl%B?z^;KN zo?9_kYXEh!{;fG!6GZ-%Y~n8Z&KR`|HGuFJko5!d?G~1^8PME?cg``ik$EWqh3tG8eIeL#Z=F2K6NpJjybHuqF3$! zWqYah%>{-tamaUDR;cgh9r-)MwMeKYLWTEl>p|mtjXa{^i;y~NV)8qq!R=AbnK+qW4Y{fDU#c#1svin|2 zGY0$-I(;ikDd{u*>5u(J%~s1lT)Om*|MuS&T{kee3Mk`0jp{lgh5jaNqX!@h*9EVB zhG6ZH|e-_#!)EP?xWHjnL;0sY&pcUp_tpPTy$$eH-z}%l7uw7l@ND2eMo@ zn!0HX$$PWS*MuHosCLKwJiw!6YjCx61d}G4_QD3J#R;nMR%w5SIoIb%%#C(eEOg9u ztZN#O-U4|bA%o^dTfe?}OX@;D%bMV0oCiQeo3ZIO|G|>c3A6$b&ljefhs7&b<4qxM zO9Zn?eH`>`2_H>(sK@|s-MVvAj`$6BZ__C$M~@HV1Z#rm#b`ySZZ`J4B9rHB-eora zkpVb9qw17PJq(nO32A{IU*bKNuWoHkpy}l5_>3H}&<0vg6v&bDW)t}I<^e?K){&+( zZeLkKby%olOrzlJ?T~EkY4rTIw*oPQ}B=j3wAL{qv z;3Xyc%IoG@|5?ppcz;N9nXkI|%A2#r*W?Z~&9;l!)AC;|mGrKb4`csa?pACbbeA_0 zpJxH_d2X@tjvzZ~D6V4)h|f+k8;i9?`7PNKV-za^pVQg5hVdWSbuCA!?C-Csr%E zV~em?Ui0P|YV)~B7MwcE&n6QhQ;)N8rTTKeu?~A;GO~zVLl`rX+F4m9)YdPSn7(|_7-~l0=t=pn4z3*?28O+8+e)?zuMmT(XA7kt4Lk;oa&pxHom%B z#Vtx?jvsB}z#@4;zdi158X^fgq;&}Y?sw=z^b@=8cuRNe(Mu3lYz(3}=cGR`sQGu9 z7r!fvm)0nDnRo)_1R6dHgKYv5j;W5Au9uPDIlP&3gq+_aNOA1MFGF9$_W(B%ZUspNGCFe z_(cSUViRJ=_yjaUA}I{_w^Rsgu>$AV%*3ARg>Rvr`+;_MW~x+3?m-xx3tY2=0@}t- z0dDbU^O{3BRsFF4ewMi(NGo6z;ndSAvx$JVz%iB+rG7`70!XG$!Fe#AI||_5Wr6jt zLm9AkNRo2OBijVrksSigMF0YIZZzR#zXiTZm?r#`C9C|FjRw}`bNFaaur}x<9VQ`? z!^cXjIqZRt#xyWm0c0fz96z_+Z%>y(m{*(@!Sd}iu}!P>p~Kk13f~rtz3xg+)1?esbWi1yD3DZX5FzF zoM683IQ7=9TP;U}^z4SGtQqx+%;F}PGG%WkoEbTplpOI8oN!BFHPK@*iaP{oOtIfF zzC_q67~oK#=>wU)H3BkA1Y{B!km=~fg0E+BB_NZ4&{nuo;Ki5TqB3Ua(Qnvx$ARE1 zc`Kmvx&je_i)${(P$UCw$tYbAz)W{UyT4vCl}ugIsikN6J>5%lo5ds(f6oI=RXy37 zR4vjT$P&A%Edp?M^A9kdsdEoOu-OkNrf{uQ7VVVuvp<&os}eu#bul=cRj0*m(m#i80MnHRIe{kHJNZNg(Ury^gQe?j(#AYOSZuBd+c26S7wkJ2} z4`mV}n3N5qpm>ChTNfO+R!EU(w|n70F?6w|W-NdN+La>qip&#+)tx$Q`WL^%@H`G*J;gw$H`WbTv%pmn?#ON||wQ!IMW z7tV|OUPK16(1qN8kBctUL&Tc^*1SXUMaA z!2n-djxBYa9Dg`dAI;rq!E~!UtoG~# zL)LNHYA=MqJscc{o?Cw~`3)QMEZCQABC5Y$1uDR0TIivItE}2{VgsVxPVKH|sIUC$ z(y+t0dIEL}=jas=lv8`;@|76x+vfT`9ShGEyX~WNLi^{1jCD#UY>wdUT6roZV$&wH zO#?q>2~N>`d6m##zCxSwQTXOSlSFI}Pir4Q%{I)4rBgt}^=gr&i;HEpN`08LQ6q#w z84(4-u%RPSsBIh87ogs(*vL-LI-m283&kVO+br8SJBqb!`(a10mz@-rh$ z4=Z>ycdYirO-^=yYf2mgIWb}cTAvje1U|NNkXEBet zl2NS}dQ)#nijXK&@n^Lj!}UgzK#43*dwu}^+sR+5OCTTzVfiF|=@0zI1#WWW*>5c& z0mG7$ByxWv`qH-5gQO&g+}I$y&Pw6jT2kqFlJhlx`9ixW#0gI6b*H9_ zRR(CNy=sCibjm}G)(TnmQXjQSmA?2z$n=*mpF>o&;dM&HO0w73SrLSJmafFxkNAK@ zn5}pLF-ZRBcqT7WV2*uTq^rtMZ!c&{v@Q;DgO6G^#75r4pR2l}>+O0)UNIFzN34n7 zkZ;$Trd};uIj0F}Vh;H#IA^l*rah}TB(T?ikTn2-%@uiQzE(_X#Kat9F0=^x?PDwTxAD#VT7q-MoGye$Rms;OzqHZ5#O0Y_CF8j%0UuS5BBYeM~vv@gJkJj^1tg5_9gUqWk^_=t{ z*YlKBk2Q{1lT0&I!|_01))Mz9gpgxzVY?!>9$@AJp3>8`eAj=R-i(qH)oHa@#Stf1 zl$+H>iV_no=Smlq#{xw$w3pU<6rO=jQFf}}eX+n+9KLAmT0?LHYR`)(nD;@4G$i%8 zx%(yiK<;A8MS5yIZ<1ceFQ`;^@mb^N#+t-wOK!Pr1s{nrRlSWq_86bp%#&at>D*TO zC0bWntu8eGOYxQBOD6mlvv7<88kj3nj6Vcej@k=k0#ldc!)SD|pDD`{|pNPD&00 z$|;TC$P~B zSIDP*`^LgyMqVl3igm`R=2RfhGMEaFHu4I2PSm=I>fuK7$Fg=*^Rqpwua=Fu!e4!M zxaoqD-@+8+y|s`}yNumZ?P&7@SyFN*an=q-<0ulTp45CJ?*&RpBo=cs1;C9i9XFuw zukK*(EbMpJZcu05aw(=hk4O}~$0>}k`a|BO;7E6w%dM}EGVmCj{P8d;b%S;&U!mpNFNX$HGyHHozc`2ke8NjjTNvgu#G61&>AiOyB zV%^Hxas-Rl%(hD6a;OQ zo^LdBt)AN{-kZhLj3Q?4lT~Exs?r62c|zv>TB)XY-hZlU`}Vw_m+kl^R{P(Y_Ytc1 zg{t@Rx$6BX6sGs{d1uXgq4hPr|5sS`exPbEGw&CErHWTcRm}Ub^zR5$ei-~1c~3}H z4F6MW=ARZ|vp~n1`I}|tZ>5j|oO^lAqFmE&=D#m-B=WA15`8f9W6II@=Xocx`(5T0 z>O-0NGp)W)R}E$Q{);bF@nsa(fAqG%qwd&e0g5Gg%pN_;o)nxpk-?h#S*V!n?+bt$ z;(^FPUtrFZO~V8ZqIF^6Qc0ybmar-6TO;q!QXVMFHCOU|H1BclvmPM*`PtqB3aRr! zOn1Hq(p?Ux_Nzul8b50RpDAh&WN^1Uf*Kj6SCmO)Mrgl{<}tGSMf-(q&Q45e<_gkg z4|ru1t7e-%C4Tu=yt}`f- z#u-aBg#E(|%BAyyyk@BT)ItlE?5ndU+FR$b{p&2-D-6oDy5T%=j!l+DFRHlAy=0h< z1hdrqnkhrvRf=&CUhQmis9M!m&xQrc--*GZ*S{avrX$LQvV4ZmNUGCBEljb$eExU| zlYT+I`RERKyru=P%nS1QSIEDjpO-0aQKDbI4TNKZBdLN9 z5K!&F)@WxgqIQ^!6)jEE#}kUGPz2lwHL$9DIGEDZ!#>y$zevnjOvQ{Do1pUto8uAC z>b3ZZib?anM;L5}`6ejOtOYe2w$xJLbac1$jom|{%1^vjMX|ImkJsGA58wX%;fu?){E zWq_g7*d&Vr-7YI)&Vy;otj0};uSU(cRY1rG#P0;2Lj13@w(eH61%#hixQn?C!jX~Y zPzL0SUn$<#?YM>@^V`MDOD>eyxzLajB&m~FI1;5rYhWTk2($FL?E(GN^B^t#O-nB@ zJy-A)qf8)nvXFI32w=8Qjq-M;nx&m6lyuKhQ)_rj&D;?4blO#hUY;vWj7k(IE_AxF z)zmm_R~cAEJu~kZWflr zKL}@Q&f&5yJa2(08C`mvw|vqmkpqew3nCwJd?*2PJm$ipcqLZ5ebRi(f;*$Cq!VkZ zJql;VdfgMlaH1Gu(P?T7K%s zp^|g50{rxC0z4tl{zb>b1y7GpfOLJGw2EeX& zO7;K56vU<*u3N6>NL9{xr7-5z$=a49FJo){*hb51=WUx{Se8)7V~o&Og=&FzB=;^!R2H> zS(K~Nzfjws?DL75-KLl95)?)N%2xT+yLQV@jhx`~W5=SD{Q%Og#~yy7&Njb>%6PnDa~fn(D;>Se?kJ{ih-cOG13Ka{3P| zC$*SAWQ{w4RsZ# zN5(Y!>}c||@>#pX=Zf_D{teKkrISyOxXLfe37ZU@?I+yAr;zu4!=xMG^1$w}QvKgR zVM#1s&Y1wv!Qzx-)dP6QCQU>3W6N3`#L3UCWA)ear30!3R=ou63P>@YH?<3Uq4@c3 z^RgP53BEV)6N;nOLt?*C_VgQy(}JO|3+D~wb$FS%dnR>KIv^-_JR0i z*5Ar+{aV>4S!8F$F*}UsYV#G+{y{zdGvw*pCBR*d#0;#snH7rU5#VkfTa2S{K zZ$Is`kA7Y`%iE&IqPp%SvJ#j)P<8^(v7-liMI>#-Za(Ki(GuPC{Otv|Qol*lB# z;)cS=iG8KaF&*jjsGQ0D8pI7XUO| z6q*0XV@_+g0tk?&-W7^8n$iwww3a`Rry-)zLY{70nCmUSaeO!~jii=kX&hBKb*j3{ zwu>d6R4g>kol>z-oZ%-Ap*Cy!(KpD4GJZMAUwKJ!;Vi+2bA-ht-r!hkS-k)BWM;g8F+@_it?zAX9d{auQxoIr=5b0tqFdW9T0eNBm9Y z!EAKf^K9lS!NK4slq!O?{DQU$fJd)Q{9_T?XSQ&v!n_Z_q`_m#;TSEXmVKGoz$2{h z6u!&80uKq+DiV~Xvxn{C=Hot9?l{U7$C4>S`v5nDmVm*$Z!wc6>NGhKe=4hSrB8*Q2pAoNfV!2~kJ>Q1 zmape)!-9m<^cHEud_~-sa$m~5mwPYwHQd*5KZpA{x?=;6=J80`!=l@aJl||E?V%La^H?8LxdkKH4B zl=uY$=6?1+$O|sz6|Q-y`_Qi%=P`&wKODw~ z&^_})C3pkJ<$b6Gy69f%547K?t{j|R>fHGx^s{}C8rGFV%<4LK5x4dah)cJgla6nc zF)&lshqjIeQ!67#Vr+C6HKyKYc^ys{{Tkioix4d|5Mc1`tC30xO* zyJP;VU^KNnV6@E(EsQ4XcPK{dl`YIeLZcUjV%|b4SjAI|E%YxV@HZ2f0!M%#$FPTc zW23nif{g|qqd}uPWMMp?hY;-p!TCKrT{WJ9=2?mo-wpnVXwcnvwXnO0Mf8>o)@YQk z1uVR)(Jiu+xQ?jM*8cbfO9a~}d};XcwKHqg{gQ^ncFI_Q`HU!RIp1 zpq_RIliEAEu?G|`v_3JKMDf;`C-^fmlii}`pPiumBa3b!%XQ;X3%$$6^&B6bDuDpTS_g$g z4hsBqT&L3)LAaEVc^Ro@n|!0otWOy+$AQ9jR?UBw`KBIL3KXHj!U)TyFroRQmC`H% z>$)jP+1Zg0g8AGZ&_XP49S>;lqUPn%F$ zTEl6)&|bh7ep|DJwvXe%N}<9$-9+w=o$u6Rj|lRNT~# zn81Y|yFj>axp5=7R0__&^1D#USHHKWK6#i#rOi158E z*ew)4&Kqob*IDh@2qyKFj|xvM|Gqt3!HI|IN2T5GNh~T3#B1!B+Q^~3V5F~kpx?31 z=k}jj=y$xHDYLLs4vF$(A~@K!xRLFIO1_Bvkx8V7^&hLjo)Z1o89p}pab7sj^G$?t zj$VW}h>UaeT)AMJqi4wl;~eehB2@BrW@+{KCAn%rr^hFc(_Zk8?4BFT(c|CCk@@^M zse(bU&eLG^MeY^i4CQp0H&2F##)sX`zZ-Sg?IH+642J69FxyEle1oW;w-K{J;T3c3 zCxY$Rl-lz|x?Xfdkm2RX;|@QjlleOy#Cee^!6+EZ}ufQM~>&59d|)phda9)lUKm zK9T{>cSR4L8aad9Z6);wAJ_?S71ba7{o6L%!ei?X{zZP@!|{Y&6Mi#e(dLN$9s8aW z|9hDzdt@)WFOAn1BE1UWT-|NQpWmn5*IJg&G<#hCW>;pKP0TN&+0;pyCizuO7G|0p zk!f)$9&jMCVq716X#F zRUiO$vo2?DMZ^|)SHzy>dPz!tk$A4l(YJj=AN+{t5gI}E@KeNDvIXQ9QVN41N;q*F zEvD`hdBt0B3>h`7Xxh$Rg@ENvRV|gMYNbA_HlYW_%B!B*phFNZZ82T)!C=1p8sx50 zLm>MoqIwk%?1&y9O8lRN<^J*m4meXu55zJu3~SRDxMzW8I%pv4e4Fx#E#P4Do{%)u zO(1qm7M^(v)F~7~0UjHf$n7HtZNFfcUa}9FPB|k%gMazWy`3u+-o0GZtC=H8_Lze0 zx$q1uEZ`l!0W{ScKkvkAxCO#9`U{yLE52FAI1ty+>qU71!vt7JO!Qx0amCt4R_sd` zJV=#z5{T9yUj*NK`4jdKcqe=&kGl2fEd;_kCiA5P(DPh2HS)V(-Y+4;u9ogZK{zOQ zMIO36W1|L)F@|3A2y0I;f})HNhVEd3Th%R{IjqXuY?YpU5e(0%$Wn(Y+x1wU2s8{@$WupOLO#izgHbyT%A8u?^ zvA##2OzlL;-T+HWXd}>!iV}Y->aEWWCm-P)r)gt z;lleJdhxqKWr|`DT$1;&)ELWq#QJ&E`gx3>EZ!9ZUZq}OdSP<|Wgq!ZxT%;Fn065s z&x;<+37-%>=nRLV2M3TX>!6!VBL|0sr$i5GVRzh@0zoZWN{St=;Td|xF`6}|#;aD2 zYx3}D4Y$h$X4K)bbn0id-+K4n$-{wTBMxnAkO&;P=<{iBW&B5-Dx8UW{be9Dv8p*SDK#eH%C zxJ`LjF31NmWeFF0^f$$IbW4cq@DM93;!T(iEZ2>5&_aM*$U~tU*EAA|2Dfd zKz6LwFp}Nl`&&LHsnM^7ESkbO@aBSZf<^$m*r2Kw609^Bz1B?ucjRJo%3i2oZ$3{K z^RLJ}jr(?Q{+)C}3Y4iIfp~L(MeXx2{ z`~-6=ILRnDi!K`*^s<8CbFoGtSOg)yutdIBObP^kzqwXo_!$Lxl*4mg6;1N2w`fF? zEzrxK&7A%Iz^2`BpyG;n(z>l%uLXVMUh{?SAaK}#vZi{}|6Uj55==~&h6UiB8dkUU~=U7mKeH2~!?d8^9V$Y~BExGHh9(B+o z{7{j9U=UHmzu6)rs}a6!wxFM)jFdc7tef93qp73Kb9);yKl_6Pkx_|`Ec<+Ie~XCt z^}k1L&?%tY9yq|qFtAXNhHLzE@RzWw0kVSa55)p6glb{`_k@fe-xiAf_!;)29;^O9 zRNT_pSl~&R;lI4mlNM|ctNu6?pS&Jy)LL4XW4plcccW$r>05CkFh(&ENb&6lT>pG5B)*vA`4TV2SMG4pm(Hf)@QXM{Qqo`;1-9Lz|$3 zV@snxa&-t-GrElSef8bK2WyR3Fx$ic;y}=7SR>sad(AgfrJ$pOI4R!p^6=1ftJp&j zuM+Nh$w%nhwT9QFgfZ*M=|;m2`KnTTKGZ$+eC_4mjC$nS*G3oF%LztH8|o`5m4vSj8`!@s;ap6 zbJ@gRRnc{sivGek(WT4m+U?JBl_s)VmD9M`sjDe?ghwpKJ`%+~kyPns8n@qC94zU| zLJ%NU+3Y;KvWa=dl7{itwiC2t$v*qV&Qz^HA|`Kaidi27NeM_*Y}DLD7S>TXbTm89 zZ1NA|V=)P;Z3i}%bo%X8&eVy`1FEFjY~jkfQ1=ukDNUc`oWD4|^SND(!- z=16BB!VQ++`n8?(y}!wg&=m03A}cEt&$X2`!=Xk?YbjjPsT;1}ou9!#4aHvGgle}V zeI&Sy&mbs-gt5vCUxL5}w{|$%7+<($k1Ll7|nmRcfK5x5*_4kr9C zI|siG{NLta-mL#*4z%d)0y)`vn5ex#)Qq+qJbDL5@}tw-Ijc}T+vdh3n^w+TWgv_w zsiAmkW>Plvn-mmNYF6}ZUn%Hy;B6>@S&3uC@Q*MxO)@owkt0mayI20ZsX26Rlq_}S zJUV3N{vbO)xBGkNXAW-^jG+8z4M0s=Fj6zqnxAUN{%WIJg>lY;$u$<3II2Bu95PyT zvzj6l-9b;!g447YG(FnR6dfEK$z5$tPd?;5)5D=o)U^1W#oYr0W?JUMf?Sh{&|M>! zr7XB8%u8AX$;=Y9KBa8~`GtfP-Ll{4P)c*iw);MU8Z()%d%6wLVX~XJDhR^ zZUv+S!J5JSjnc(*?g@(7PG$ES9MeNDO1`q=fz4 z1BpQ4jo_X>@n0{^yBO==IYp4ZzHHbI%IyglonkjxdoY^ri5%x^^Of6u(H~5*aaC&f zwfiOrEtGtPKR7BjA)g^!-Zr-A0(95yq@@V9e9W#bco`;}_;*N4*rV(&q9A?Q!d*f`^|M9GCic0$3<+U( zsP-M^3C~;Ni)anoITgjk^c>YT{DCia^CX1oGF@fsWx|Ao5NcjJsE!3QVl|(9Ku%N+ zvUtJW7pduD=_PO=q*X^KK7kWCcSEK2ayVHLKR-R$zG#roXg{zOce{HkyZp)WB8f@u z16tyhIp!x2JzR6RcbZd9rccH!>TsP+#nMgTmmxH_R+cX@%eAp5pt$mA5~}#I~WK74YzVM?!UkYCC8@=o}4c*sx|z9SEPH=8tUbu zXEVvE?AkI9HOz5XeC0V}oB4e{;x;k5Y(j|AX6$MLb!@G^j zq@symLVN%9&}S8xD5M@g^qC9IODe9W2{M2TiUAIc6CgmudY+Dwi!EI+`)4wJ98?8w z|5SC~Sh|~D2DXw3T#SU(k}QA|=M3*8c0dt@ujCT6FhMd8jy!Cq#HuDGpFp2wRP*r; z^Yve&{keyGwTNAQv)mgV;H#T@On8j!sm#a6F&(nal0T9!1Miizt9+Evwb%C@cz zEIwms-F120Fc-0N+NZf~w!wqjrsWRyHceF42n=xkXJBWnf~IYyuEGj+~Q4-F@s89>9u@qz%85=602xUSvo#r zpm_)C_vOYu!}YLiGyzi2{v~H44S`m-1uG`+3+JT9n# zKT_rB9CRB~XpLKZON#W`J+QR%J)_@d<1DxVI*?H7+d~$vCoNgazd-(z6Tn+nm%kfq zPsr3I-Q&~Y^UM|JLh_;wJ{hge5-G1Fe*$i*c<$=;&}d+-JCdQ_D)hxUG+x{wi^>B&1zMsTWLi}{%= zpAjG}5U#exWCX)AOu2{&p!ED($ES`n|0h$`8h$f9S@MX$GX01ux2RY5rzNd*eJAU} z(uEyLr(M7Q&|CA+TN?ta*cF4Z85 z&pt{N1;wrcd0|Y*@Z`<>>7%Rq?N|Dy^rPYxkqF-mb^U%7jUd?kv2H{=GadVZq_(_5 zHw>%ewK=c>9$o9;-@7rRMm4&yQ2r(d@9NNn@2% zB}bB8pX`zH-7>F+kUf}+Y%$-no)t4aHk2jj;!_qrTAtK))XmCB0sedT&*IRo>wsva|P?oT!%!t^z z?)TdH+>Xa?tU`2>r-?}w z=qe>^@N^HDRVP)4M$=tQ^)PD_hul?5?1(7)ig|$`Wn(KT33^8OV#UDaIsY zpp~}j8SyIlZP56UTaRCc+2uEcg-jKww45r1XU?BWtpIoF4l20qeZq5U7^{Jy3D*rB zIWgj{JMS#*;Y8{zb7Y|+Qc8Jn+sq|bQ(_)FY#O*dMTD$Gv%BtKX}F6-0O#nQZ^Gv_ zPfHhLY@gCHk)G<#D-E9-?Kv%cVrqmH>FGFmG?GV=qa@rW@hUeqJ0@3zKkrF2Iec~J zO^giirO$V!NKUF^_f^#`8Hjz<7sMqB#xF%Zzr{Rn76RLZ?82IUX49Mj*8@|QyN$$% z>i?faq0hhA5{pWz&ia3rLVo*=VO9*CfP`bIb^>|F$f?}8S8F(rJ70Q3yb2|?*7y;# z<2Qcj#5O(pwLNl@ahWoDoQb`QGj=))hlrzQ^{Xt7c_k!23uWhfs*RkTEgCyT)>q2+ z7Cn=q$fDNx4t(CYJ$8xHtKGXUc6yTau=!qLi+~1E#D5X+>s<|}a`Eb#|N@M09 zo!EK29wWdVMSKW$)o9}Zg2*u<;fBWpiWBHGQaZT)fS@V%JYmz|GnqsHa9&&80iaX1I9J<%?VUY}gU|bS`%!A2G z)pkI^mtGU|-{tgs_RhyJ#H!GmUkOkv)q@me4uhW71=W7zb$U=0LewZd2;nUkUE}Px zA87APU%FK$8v^bQpW&#EU+!cALJmNv(n+McB0pBRyBKL8J_~I)R)xOwCQQJJfEBUF zVY+tvqW`i>xa4vzRszNk5uH+&+86(x-Pqt6v0!+1yhcm9C3e#tPS4Q!pT|akkB6o= zRNQo*GcrK#BA-h3F0o^%Un_VdnR(WC|mBW z5HRG7^YWaWO-hc!)<#k^N8Gp;hho)De!wqm{^krO3%?EDD}X6-mobya5ZBa?i$_XR z<;{Ol!rvtLQ8*{HRgCs(YQYm|Z+u1`VWO07(-(7Mc8Ybj`Onj(H*0)WaA@Mz^~F05 zj%$sK4L0rx4?Td@H!Y%>Pw?YID&|D^#4MN^N4<7 z?O^H$s=xzum7UOHmL1sY8`mD~$O*u2IgxpV{qpB*`7_>!(F&R|*B!K=8~5r=4S38v z5En}#t#MO6owHBRCx_SaJW%E6UOeXJ%YMB|FeiU#%8 zvXBfo+Wolx{zHi`1M!E7HzT?L0mUmx@BHox~5o%nKa&R^g)?k1!GrodKxBJGuW^CT^p?};)pRv)m;~n3SZI!W^ z_paasmMUDvtmUbdXy9R7j*4CrUt#k(w%~^l`All+^2Z{}0|qC;OLG`}dm{$bHs;Ef z9K)RSj&{@kk4G!8n4HL8$dj|R24v>{7DkGB|7{qNP!NZ}i1yN&?5Z=%CEcDLpZ1G3 zAIfmnS{7QnW0?g4FQ3hP%QE;%P$VH;)1kC2llStMPeSZv?z}vie zM`x^Iv=sEmud|DAx1}@3AN#FO2QUPF2+4`2`@j!B%0oaCg5W})EM!A4g za5@zT#H~KCS3fqP04Un&WG}c@95Nq1Px`P4SxC&x6j0hSfdTmpDK~7)kKgE0SIiyv?`rB&uNZL1JmsBy=AUbd7F;Vc&jxK@K|T=WdVk zD|VO1smYByhti7-RKyx(fz9LS5CVv6X+&>%KSz6^VO1R;>GA)Xmn%OCf+T^t1GkXj zx0|6LP+{CF-$L3hy4+A`4K~>wD0?p{Vgb$u%V<8(_#PeQ2>>245IwH1H11TO!x}@L zY{0e++osBx^-w5-fMZL*^J-*Q^7o7^;Q2sXhRV%mJS^~54aEdx28_S^WA|pDGVEP> z2t+0p4b|foG(Mqo+#G{xFKVB2W-!uUFx8n^pMGcWtP7&9WQ}|nZr(zV!wXe!cl>X9 zE6A`ss!-m71t%Dd(m8*uL1Dkl;szWbMYYVS0w(HA+`z57!I=WS=5_)RHl70J;C<$; zNG}%?f?8MtpH+A*j(9emhB9p{{q5 zslaGZrMQx}A>)nM3iW`gl~014<#16VLZsWNhXYWs)zXgEAmQfy@$1BG^i&u z$5{xl#_m-2nQDb&^BV|aBY%OIn`~9+r9xpR6p>QOn)p2%wZ;#5+J{*GE$m7c%nt&6 zuzL$O(dN$PUf8`GEl~z$glz#q{Qmi#bV;b#Z{Y*h%uB3ej#x-h=}LLrS?5TUkYq;! zWD`f-Xt=#_L=GAc#?KSAUw^@c+OILWC`*9v{92+2yL=-@*Z%_DnWIgZAPm$jclyE!D-v*_JQl_1lMu# zT%91he~0Sid;-<|oVNZWRQCh_A*gOve^l3%{9M3NP@N5sR~z&IPx_&{P<+K>J=mu>cegARekVr`31no^G&_* z@zZ58zmes#8)s$^+Z_5AzPuk|`@i;0P})g?Jr)%7Vh$<|I1UJHkktf6 za|nj{D2riKTi?Pk7DiDRhT8iujH>of4CA#h%tH#pRM#mkD2rfH3c--9Mku$)cYuyU zEqD6*K&OZ!(!Ax4UeKA;Xn_uBlF&-7i~bB=nOUr>y$8mhjGZ4cR#1whktpp&E0@4G zOL_*Qp)QM84zRJ+<~WykYI97Ki$1*a9|7Q4>-hR_K_}Vcs}Bg1Z+BbWO}@@WRMD$2 zoa*#a@E5OM0q9t=z>5Gxjxa&JXpxtjkrZ`eorY14*0>x<@j23M14zwym0h91yA<$P zhi!wRSq?dGtw+5_?yHeKvSF^s(f}h5!+v%}8>A*5)=5PH&>vNQZ&!auA5+6b<>)I( zr`%5TwpZDk#D1)ash=HN>}*Ug9#+qMrf*v`2sv=r7RhmJ!RJ)iaKVe{R@-&0vRilb z5C~s#K{tFVLws5Eqkf}$IhhEwhIg|=+zy9&?+X1#9kva>A}TbQH7v3WBHTh(y8@nV zkvC+7=O~mgw0AWiCQ{=L89wPe#UXw~bGyRepqpK^1w>_iSgXP+oVYBj?m(fRS%obcXV5@I6aRu074IEgudj zJ}ykDP<-`2@(teRYdT8obB(RZzjB6K&hp7WbD4?n=oP8!Jkh$bBBjbW)O?cH z7}q)%9U~MQuE92&w1?1T8e`fUcFc|84ZT((MaUYUTE(uhFZ7&*3p36oYl4A^kV)nv z%i%$5_&`9>*rV9lKXEN$#X5e=2S(gJCAm!2qC38nXQJ-Z8fUX+!IHOwvGc?j5WR-@ z%-}3X1*s2s>T3&#Wmv$9?*0?W=ToOj?EYVjPA0O5(P7^)PKJiHZ@5sD)OX2pL?jgp zIt~6}4DggRm}yUG-=Tt$Yu==?W%rAh8^-kE zq1vrv^@S>>--bsFSuS>y-xs$*61F&us-koU5e~_hc6>ed6Vp?E0;i_}j!_9VxCse`rv4!fY#EfgTm~m}T zW?XlnY?Hx9ey1`9OI&uE6cfx+3r?iz3Yw-FY`0}cV*79t{s zU9I-8lX|YgN98GT8#H`wiPaJ^f`#Uew}op^;lIKjD@u>(ippW##V?{07JxN4LA8&n zGhNVTJwa5cQyOEQy8({@^V>RC2ZiK~Uk+tVBbc}X-Q%9Ni_kM2H;LIXgU9l7aJzC_u zrT-VRq#(hh^5%^t$hXTp$X5VX5l`k?Pd>1ojOWP})|1z*C&W|8`=0e=jrF9QC%X0I zS?h_HCsVB_k6KT#c*>h(J;9ku+Pa=6mDZD6tS9q$@_*QS6R;@DHGcSI(_zsWQw&XW zTrf;g6f+FX83h{@lw7e*kVQzgm>I#!#IS-UicXuS)z)KmDo>{cZ4tx;%oJ_IEJLjv zoEFkD)RO=2exCc8874ZN|8jl*@4CM4&D6_LPPZWXJ^uvascNZjz+k zWn7m;UY)1tqrpd^!$D)Q73w{7)X4mUj!&G}(T05sv*YmkC|;}WL3D0mcCi!M9xxou zu!)}bHi=@;<5e#_=Oi5^Ho2GpojpaQ9Ts{&cZ)E`_9V^uBfVEUX!Horr%DgjOEiu> zC-kXvD0`0X1E{Y=H9!HS7}uaWPY=zX1hr~b!TCf>ysJFJ0{ByPYR z{q7r9@m+bGAE!R^`gEKm$;JLo^rJzaLkDAt-GSYWP*0pl6jut+HI3CNnzICl%^dGh z(ZGi_p$|#aIm*I*eS(Sw_D!ZZwmbG+bO2)=oJJEP9-Pqc+~y3dQ^(DF;vnniu#CeW zIM;`}B~S+1>C;EUpuX7kCBJ$9@Eo7JW<(IHWN2@VBf;Fu7?4;K41Lul(5m#}B9TBGD zAiu|e{Rr1?r7<6x;|3b6qRFlp`;j^WE?PLnf z9^};BOh@D*G;t}S#y6@_QREuUcpsaoq?5OfV!77nru8JlhA-cp=<*ri>al8X!7fFU3~T7cm^5jU(TtKplC+ zQgPN_fBQo)vtR|@LcU_%+a%~4BjN;ocSHs(mugJbM+_8esk=^we!cK|*eWiVN^~AAB4jjBcpA`RV>81K18jhG&9lqhA zx9tx=jM$BXjnbXrPtBwb$)cb8RZ;+KcCI{#ZMnD{H3>>ooRIm-D?D+FM_6Bs2rENy zVTPaBB6kA!sUp162T4C=#O?(2?|8vRb`*Qu@wg`@+41fkBS2d+N{(f}3+m#-v#KYK z_Kwb{IL9WUV-V4~Z5*y|MKMW^|G_rGy*~q*A(Yl;%jl2vZ-rF)4#8Rf>zxhUWWBCR|fX+N|CdRXSldPM66VL z7OSN5t1T+ou@|0s_K*Cje~vGc9Gy8emiSXEM<)dw#_a;u;hsRmg^;)~1(|Vy4CIh& zlzxZ_N5c*y7fJ_rYxQ`7NZcWdo-t z!`86n$bz#Oqd!3TMcX0@&#j}AmTzLZsXqOY(DtG~Ck{6;O2tW*|!T~kytjHgAV!_Eh)geah*vRNGWh>A^f z$MQ>2IoEEdnlDfDV+_dMmD&QGNcFD;3M85%j;BTd{|?ytIe)f!CW-&FQZt6yhBgvQ zwq8Rb>ZL!%C-Q9j$bC=(rf}FpdPu&#V;PMR%zk`=jc#AWCl2iW?nbrq$Kf&zvHm4$ z-Vd&^FvGMB}$;sj_vqyA+&&{>H$obbfJ@k`ebRJwX`nH^r5DvtET z4uyb^j;>n}XtWPOjZVB?Mgt`V233K%&(#sV_ zq_-=Gh#r@sn>Xtr*Brf#KjN-m7mHDb{@vyjOyzqdRxdf}>IV&{W7}o}>?MufjY@%K z&;}?-Mq`Ihz5cF!Fn8Q@XQPPw-p(WN`HUZV@7MN*@Y;IDpP+x+^9%zB2DClQFpywi z+g%Jr)Ph{M!1PQHV)bwp(R)vN@9D~HI6M^C}_sfv|7#Lxn)C!D$z-l#25Z2Gj*9mj?9h+c2PQ!mk;>&+t2p-#7Suhu^xYIDH!?%^2J?Igew1X#7rGn|Z6h z182kSWl*KlustBbQH)`GIntki@dP$RI`(!mZcl!L#_i(PyJZ+lVc>^rH!$MGpuHa3 zDe&P^EYyQx+2S6ePZgtg+<;)g=)JKtfK&z*N7^yFcKTleo1>3ds_8HdwoMM()l-bz z`$I?J%*N0e$|xFBy9e*PPzAq&P5rvvXtoltjVwyWRvf>RjXCyzy@0!GXqoSMSfW{n ziKZg-5{FK97ro#U&-i|?Bb#;*MIjmJWU@vWaewbk2$ZhD(yz;f<1G~TggZ{y<~b6J z$?#Gb#<%P5!}SXP$!Dx4MvU0K7YPe;vICJ}L5`YL_k?HsDw0`C7nxzggK}E(ALM{tZz8rd?{VH% zOtQ0$m*T<%X(%*Q5HbV+y)sG#+Qcz1iz0^6`N-=sVfITfFZRrP3>()T5Jya%yuA1jJQ^pa=xC-?I+P@a67N8Xcc8>qXB&hz9bbUJ zOv$ScM#U}0U0YC{i;M5@fi|q2J3n{^zO5TkNAiV18e(O_@DoP0FiOBB;m~-Yj=*3O z41i+jHlB@SpHhJL4bt4`EW%(;>ils$0-p1|Cv-1gF%IUUMYKlXV6M0)tKz#T=jc}; zj3(^Gc(5Lu2`hx22<9|Y8{nL?!riX)yb-yl4jp04K(o_c{Vztnh8vvnik~dT8yM^N_a*f~88E3LC8 zdO2^ah9A(*r6b`_n@DH>(`i46DFHcG zCRCjCCazvB6IxKpQXC$l-LPk|&gmLMVbfY7f{$&Y2$1_IToXizpwA#s3h|jZRet|?2b4dZDc_mcOxHc(*N$I@X2+$_ zL8E$j-2sKu&vnjY80^v=Q0S@u!zEBJPUz+ms0W3iyabBYTd{avhRCIp;;Zf7sFtW> zIowc0IcN4FS=fe%`YU>Rs=qPLC#5;goTG;0)>2v}qxKT_k_KHofbJ}l_Y9i#TiW|# zv-0pd92miv=*8CG+JCb}()2f!&SE+5=#6GS!1+FMSuL%u%%XP7brJS+nH^2kMd91A z!kR0{xeza?E@;oNIwHe>x6VmDg*Sb5ATw~0s_cpVl;yQL8pi=EzSu|A9(!3m#28ed%N~tkScFKSaM74HO>J44gtU(><5CG2=qD&A)vO;7Z&O zvAb;v9Smp7?bBdv9ZlnqW$38z%@pco=_#kCS10z~>s&KIgFcxEUF{SEwi#s{*Yr6j zUfL)YPH|#}zN3NfFAd-3<%&AKUbqy;24B*G9)W9WjJ+P}S90`gaIa~_)X`Lw^>?&k zNSdRMYQe7+6QYkM=2-N%VYYK_@X{9q$C;yF5ItPHkBhztRKM;H>8AOV{@YVI`o-Vp z=*R8Q-#Jd09tyt-c24TAi`*yOT(;>-6zfZC1IGaM`89BRS(7oa0$r` z{s{I!dp#!TlFv`-m+Zz5v)8Cr$Y$`f!aS|l3dx6=u+vDqQpqFxUjTmqf1;0J#tz); zF-dF-Vph?h>9Wl4N#c3BMLvk!zR4%$2=?p-dyZn7_6?$s2pTT?0vLWF^A8P{?yqYAzZGVfe1&~;)ANdMkR_5DyEmcme8O_@IpnYE~myTj`|@9 zs6w%IJC0bJCvHD-<~F>Y8+;4w?l}AHsU2qyMNgymGvlH!2i31Lqcrc>|Ks;CLD@cr z(hED`E6C2d>mpA{yO-U96zbRAE4jU{7p8{>XA?bQJ>|FK$j40-R^yI?haz8tUHBHc zoZN^zuu!AN>}Yd^ze)Cga`k!z6oq)?n}DaT+r7QsiqZ{(U&!UDCG|Vb83vyryXOqi z^`P62{`BJD7Ji8?!V3h}DokG&)|LS5-`u$U=#kBP;6bl1o{^6G2{%nId&=-LP}RV3 zzim5QX`gIA+O#>SRoG42w&RRDpKB0sxKo&47t~JFmDarD+zq>79@#EJG(_ttvgelk zwBuA-6T;lT{b<{Zkqsiiwily6CtI#1`*$2#auoD{c>ie0i5-X1zS(i;x^E%m!Ji7B zu4{l&O~k7vHxuJUSga@VWfS;qI}rLA|<^>!Vb#gQbfafDLMr&e`WP`uXm8` z2xO}7?}7o1QVgNZc%uM@H<;HRDTgC63BbW7@xM6~ zyNV;RKc}-g>>&+LXnlQa|Ilqnq(~NZvly!*qPWka)qt~E{^p8S9X5)D)>RzwCrk`o z{gD8e&}*Q1zcaM4;;3IhQ~lAvgwXngP+X)|SKk_e{XSB5q@JW9r_hApde{B+&i)V* z(pP^X0;3)T7<)RjSx8gJ4sxNiHDaNBh&lcPT-T2e*C*)T-s|db-mH~F5WUTtAt(*o z<2F;KIJSxJqd=-cp4iQc8OlJ~1`ko<_F;sU4%_`e;mj2VY6K00pF1fLxN&1M&a`RJ zxxT%Z4E*iHJB&R`ABaTS!8o52x{rWP@ID1^H$ej~kVX`Q+nw0VRB_Zuwhs%EN>Xnjt?@H&i$bdl4LB`8RZq4hKd(Z7mpAlX4wCn6vo z3dir)7RR=Wnh>{&BgS7_gdaF1)M^NA6j7vue2APxI*9@$GKe7#21tloXydP+lSO~9 z5L87g@^zYbu$GEpP-oO*7vNBg0UJAc&Wi;F4R>mL&aw+7WY9I(2hK|$&`P{9VgsyU z7CZxox}dDb)yvml6olm)45E@9M^p5P*wS{ujIU5&@$77Z<9C>J;1FZVMW>U8|CEAt z`Y_9`Iy48JZMZB(%SoJkO%Ho6?rzlMgGN~MD7%o>iUSg>dIMm{hvkljw&Ad8zPo-z z>lE5Xy2;;lF`@P;t%L&bg&d%cDed|@enjNVn{dGUt-8%U@jklI@ySO=&3Ctq{=__d zziU+D-O~fjjtk6pU(*9;FwRf$*WdLnteLL(Qh)ou$?X*_`ihtEqJPVk6#pYGnNQKr z*yp-fMh~IXO)1ykQ3VUgkt5UUTYEV6hhjp6CFt!*7@K~U9RHzp5Cw0(^k9w|2ZZ%+ zH4yD#uDYNtfNG`JKEwokkV)&KS*MT#T=!-yhsU5JsB(ZtVRo*?FIX2*GEfM`T-E>A z&vD>cDC|CTP9*I?sL-wMc8&v(%3rJ%?Zor|gCTkEnEQONm>-HeF)(x&vlzedEPp?3 zD^(0k=+l>ws>p&1?VKOt6<5APg&ay7p)iA+p>u_|ubthG8bsXlK4>fIA+%F7bXB() zX@?XB`rbO0SklV$rjc?m7RSn`=rsFDD(_-00`Gz{QA<#KNcl3BA{LWSJtKf-#5mHh z_zCQZpmR773BFsQ;UfflMp9@&(PDyyYf2w#fKCS~q|IR%b4Nj0)kpBo{9f9lGyEa4 zP7^VyJHQ4T`CS94S+7WMf!ehr#nI?EiH6XETOmo$)N3C$ngU1YpfS}aG&=TI?DijFa5U%>_S1C*6-|D)Lr|Zv`*ef9EeJEyw!Y|1 z5T4j**G4HoK2es)HXS=a=s-EHX-aS$bsRLW{d!1%F2FehQK3_W_^@4lTY$OZhygoQ z%eFFNrZRicC1j42tdNpb9ed-P! z`}JE+^c}vFt!dYVH&b@_*WYF>NPR1Vt}Crq}%=Cvp4 z)}Y%BGgq87*)M>n5w0*e(6j&y3$~mXkcc&hUz-!q#}EG^A+!PKIrZx{P@@A;9x%iXyHh2EpZV^2Oh#moEYKaM;wlLMuKn zxq7VqfYM9O%BS}F4GwIRPB)lrLz`anNu1HrN{COctzjt|_L|yZmhZ z$vDKS7bgjvF@ksAWdzS3H#C74YV8YPz&8OPW6jxH*!W!-^&@_mwby1NaehX0D~|n0 z?MYm0-5uB_gJzbt_oA+g^#R=HOsRP%oR2&ucGludj}5~Rgo=GU zGEB!l(CdpF3zw61d8tAa!hk}+`3ok&u0iPA1_dEO7|~lqN}SgNsu-vINZTtOfEe{r zZ;WV$@?Cisl>B0^wAQ-$Z|AfEJ6otDs3i7!*}o{LrB4pQ#GO z@{U1^AP2)6A)`R3^}}$$V@zz5-Vb|3jv6f(JHXH=G^&`aoDRflbdM=L67>nVT_or@ zAjsDsLYHT_7JVM>gs%>=zlxmLd=bS}hzQ9+--K)0slTiEE*IJ8)JOeS zDb_js?0E@QrWXBTs4V)VHshnDpr*!Mrn;eUzsppMmRWN}W8`5%+ehEA2OsJ@vsggD zJIW6YONNnc$yrH;SLYhIGq!4W4t1O5=*I@#{R%#~(2w3K@wPJLq(vXyh<}&Ld0fSJ7WBpFmnkN) zRN<{yiV205#AHF9sx^gTOj^o}^sR=476;sZhs?l-tA2_-uoV;2x~i)Kv3_W%O4Ugc zW{DjAM`U|YNhsv;@OaC%#y8|Y4N(-BBCR9M0SPj550f&b}kMmO+t1Z<{G8f)?R zVxR1#M}nHr9bq(BZ%5sQ7rFq~CE~?+USfaOg%V@IfcSnm%0Ms1--xXJwi9Zp`fr2Q z8i#0f>wTgjSa^g5*|-Xe(XV2)Nuzs@5)E69P=QHBCML$vr)80K*dG8=VM)i0Wr>EN zsp&)|9A+a;R2%)P%)&8lktcg77+%g78XVKp+1hmBkHyg+-_=NU zeut8UrMl`AgJU0#T=;c{9~eji1vcw8lC<<&Vtdj%i4pI?^iJ}{dkDSz%lA-v_rtgA zU>@f1t7r|d#ZdhnLjQVG9gecB4J8@7hLD|J_&2&YzQBR^-t^uJqFXz>6V0WN3c^gS z>OtZ(qdDzCeE^o4arrY%R>jc{vDX&`KZ-u>6JBjTk3dQzoD))LZJ4UME7Tb&0JRdR zK2fO8a!tWG6|2#XmWpH3oGJ81Lvqh~4b&{O!93yk9CxHTdy}Phv{-SD4}RUhwrNdy zXXo(7;pam4q29-oPrd#WLa;@it~c3?&Y#Yq?H;-_$U=r_x??JiY;}GCL+a05Izn{M zj059n^gom)KB?kf?{Gc|J|Y*|fMGYqtnCRHi1~uEf>^jpS|-QcIwfbCr(lGQ+nunT z4)b+WzeN4pY1mI#7m*ZzJH-y!E_S4bCC48q32|6-0lSmq_m}iGV}oWzT~uQH2PH@G z85_4}c%i;gdi~OUXnUSEDg9w!GHl_A=&UOEUw z7{Vc~UpPB4(yBpD;VUhak8PZOucX|api587UZ zQDZuRC{ko#OHpU|--LH`majrisZmxINj(6CmMPf(rqFN?JBC>ZG9BBaI>WE#@Fsi0 z%cbzrJ>l)7@G!RU4sRHob?&O@^uP6ABE%cyJVA^%P-LVYg2o&ecVo1X0@ImN)Bj|EET?&0cYr%+!2-4h4(4mxKX zI^TJEMqrM;*V_0@YXLNO=w|3-3dLEpZq9^Oq@gO!=!_RHWl_%QCh|=9MUAqfe%%54 z4BA;$(WZ-O>_GZvqcJL<`DPkwi{dQ3fUUi`?r`~I;>_VA?}4_>^8?mnj-Z;hv( zy8+*m$DN1O;olaY$8MPpz5XuRZ0NlndzIs!+iUPK`jmj(=FTGxHOUTt$1EK*@w399 z1D@AAxe7CLT~0!kB`l#bwRZ#f;K9OMvqHej0W+b}64HQ;XZV;#LyaQ@Zl^=-_13H& zRpibT2!0Q8r~LKulAOWnbbq)_s5JR|!hdU4n6wAiVJcJ(P{6ll=>T!om%Wy@8#sIp zTEMra2MXTdeI`Z(q5;7hGOTNzy1y@TGSoq zi~P4geOpn!e=Avl==FCtpoF8tPO3OE1jmGoNu!&RM(m+@qmFVwls>&t3 ze}klduaorYR!|F$lp|!z+HFLV);cATNvObivd)xh3*vvIH3c82uXhDq<#_zjW>Jhj zH+LSRG~W|~1(r^{t+^+d-(Y5RoADdWOl~uNgIT)UjNgiqL(0jsp02lILYhye!o zd6Ah>O2jQMGV_%enRSuZ>f_$>BIJ=5A#ZuM4hMe_`JxyFcp%VMxS2j@7} zTy4O=B}V+qh=KVm6aLLhC2Q$qtr(0X6WL28d+B7a80D1wMmZ&daw>_4k@Z28QAFiP zyDX!DR7N9Wsi~tfO3_D|qN)xVNmL^d5h`I45dqpH5fLhH5)lDvmWT*Yt3-n2`%#0U zVe1Ir=d3qefL;Dc0gX^w_G!n_L_<=A({Q?8Z;L>yKzrf!2Jiy=nDu>v(ZME+$+gW`llIu<%W9Nbb{$%k@bJFfZ1RN=he2DltsB5Eq82Ff@^2 z3>g|>5(5(>nP5*}SRebVl$n?k|77$273AzeIK0ZY=hOnKJd`q4x8vd^>EzB zkH(Jj@!0ppi%CNajb-Dhm+;{}**`h(afa|2H=gg*zjYw#9Y21O^{;)NlcXhQ(BKkWimX2apf2a(*n_9D?;>myojKm5#S zyw;e}c&#y~T|1~b#g;^Fh1aRp2WH&n;Eh|F zH3_0g2BEeEL^LW1UX8H#cmvHX;(wgtf1KifoZ^3+pG ztN7EKQKW?4Wc=w(#((v35q~0xKN0WvyBkGSe~~rgTV#6}cTD8zrBJTQ-0Z&Hn=LX> zxks~w19EH3)YzG+u`|ceKWf;_)UcVUVKb|S&8J1%)=i7n=uWdJjG`$+Ce%o@K@w`U zC}$)Q%~e9MXrNGfMFXX3u5W!cEu={iwkqG9Vxnom^=( zxpFh4<%~vU855xs7Kb0caYC~*QnF*4*9+UuLw1S9j)j=XrKCHb*(H67kv<6*u}y2^ zf}o8R2PVjTK7}1c-c_YQ2apm|zB)~_03V4Z8YvaVM21?|_sEV?PK>KWA zT4po`Jura24+1M?#-RjAdrV*$fPI8BB3`>6~$7Sd|v#oED3@{jNkK zDi$uiG$NT%blW###dBDS7BqV)7H6RFsJa|B;a9Q6@!ooRbu866+YSitFtJUvP^2;G zbbcbuauK!#w|d8+p(Vw+SjooiTN{Ko36Ps(U$R47Du&ChD}|52&b05&cRC*+A1cy| zwOxrOG(;c?L>!3;h^A?&h^NXp#1J=ZBLR+wYGKED3ir{HdO~EPN5qblIA=`@J_Wnl zsL^4YC&)6-7$;ZU0=dSny+z9O0=x)$2IED@5(=u>QO@zr=doaC3w<5Bk`J7(?L#=u zw*4gI>N7bSWOc6NIeTv34h9J;EM5wUe^&rmUf1`pR=$n5S?%7to2 z`togN7hfEAP-d$jnz}H>Rv77OQx^tem8P6L?90hjoLjqaHluQo78q4CvkLB+a}g38+~qbV5sQUY8HL@; zlzl0CKUt-1VQb?CqiWl*H6FY5sjLe7o`Hl{wm9&iJ+GF4Ey78cr}A1-*=gD{Olz6$ zW$I*lp6LbGN&91%nwTzNTFmrbrW=^P%e0y4VWy{<_PAd9+n?!JrZbt|!1PY0e`C6V z>8ng@neJrT!t?~wvrNNokl`7bPGmZr=_022OmAm;FVjbvzQFVirrVhAVfqEr@0gxt zs#_|<@5eNXX&lp8OcyXsXPVFSHl{U9Utsz!(@&YUGxbkr`7#~GG>+*krq?jNk?Czr zYnVRH^d+XXOjV((%+|`OTq?ThUO$1GeW5jwXEhcU*^C+a`9-C0nNw6^TuF|NCD}RICE10U*~UoeO1eubw8c*NpK|4i<)Vy| zyo_b}*~Vd+MfO5lcF8bfW=5g0s4#z(aap#}ifH8(8j}jGwv0ksUIwKkqc95w0Qq@0 zXV~(J3XLg6S=k~LnzkS}+gOlMmRDde;7H5p{~;74a(v8KZ9W3{Ux|PB@g}h$)_H}Q zCD{epNRF5Egy<OmfI<1#z?ENz;3mPl7b}9S(uzmNfY+1*ahcX?z%5_RPMOg ziQot$JK~5g6fe@4&Bsq-sQ7LJ=}yI3luL5&Hjw;D6Mfvf4ZxpXRFt2cQRt4xd|L@g z+Ks0}UL~tMct(Cv<_d;Xj=IQAVHE(dNDgS1bV+k}GRPm|yA34Yoeafy8%VwiMN@pY z0r*|g1>7ZF#P?1YaF=w=v=?TII>wDcUO{m_7j03JA-9<+3+LNpNfP0A!Ce4^Mdck~ zxQ%C)WM{hp`17+-Q&F+Avy|z4055Z8%z_6*(;$kmFp>VVA6|B?!WV3bL|OkMSH`P5 z-pq`=eAHrFk!TJx5t6YWyP&9Km1q`K0AoWqI#ezb@=DO;qFu_!Pe52J(MGMLY9=1= z%~>}V5eolegSnB3dY>P3WY9vIYKTfnQzN3)=OT5|(AlY8b zN7I@wA}IVtUXou_?hsA(-793I*T>wGZi*ZDB9x@UtUO4!sDvZ@M|Y9|^EpKnlYHyk z93P+Azd81TW!WWjbGr4nuv=3R59O{KUp1|;TT`@iBqx%X%q~jLT)VB+K}ti=L?r(H8V;) zO1dai`KcKtHuOwIXiFdcJ3UR)Wbo~4Qu3@;w5sSLQEh1?QJ7Ic{akiQNl^(bb>&l! z4{sI}t;jBv61Zi0!o--^%O+2XjvYT~QuM?Lu@j=r(`QVG9v?eldcw@hV-qJ$oVZ%k z7MB#cL;0gG_&_zrKS-ji%kcV7>$wb86Mb|cYFi!#AYOeSGAnDW(cRkt$dvxMec4mG z`%!9AmKT-eVQAJ}f7*?`YcXcKzFW%(I=^VSDB)a<2vcpeTN9;#F@C@pLj~#O70OOg zA$~c=VQxQ$88P%D=;g&Qckvn)X&uI?74-*|f4Lk({$VsYmgF!->XwMX1RNAE7}4yVHovW?Zw4KC1@eJM*Ng}tn$r{udjrjnVvP`Kd5XS zJpb9;O%|-^Io~~2p=59IE?MbF;?yq z824a)st-Ti2N(O`a>gpYm5fz<)-w)e|2O)$&v>QleE1FKW93~ub&Qq&jf`oIPR}03 zQahk&%|7^JAN$zJBj)qU{ue&D)dxEntNi)dhu^_i#pgF4zP7n*c!7+SeVq>u^T7tj z*kvc4em?vNA3Vqh8yTzgj_~0}`S8d1@MC=V6Mgt`K6r``Hu<BeeePw zoaTeCW31$r?t`;@?C1L6d>>rQSk;$uA6&y&mCyBzRe9OSxF6?Voe#g6G49V0kCX8r z#=0%C{6K9go+!qOZ}H*h`tU0m4`=tA7!PFJ%-G1dgYgi?5%0+GM=~}sR_@aoV}H1K ziWw{U+ZdD5nx1kW`!$SJ{N7-!+M_zgO8(7^drR-MR>mqm+PgBoNcm(5O zAO3pAqnY2xSo!Z{Y-GOSJsI9G#&L|J80Rv+l<|7TbaaHCTE?n)w~~QT|6UR^`jYSji`y@c<6b*MHyk&9{B>t>3=wK?Ij))!zA*|8fo=dt$}2 zbm_7TYj&0rpSE;qW>$7)K4@`<70NTV25hxukuuHg&X$XLvD;wj(wq#d%^R=8q`jy_ znZVzC1(q(&&RCYG!nc;@<=B>vcl#?btIH@{!H;$Gi)|&)#w=Z0f(cYfUM4HrmM*np z4x6{UFgr`wR9s4!u`s)ooog6u(DYoJ3WF=J)U+v6G;Ju}r@~+;e%D?vZ59=0i^)5o zXxO9jG#Z68IvPKE$B*i0^p%%t<3Opr!z*nH{D5`sO3*Q&QKK~NHqaaJyA{8YaC9qP zE(L!ye$n`i!!HuQE8%DgJQ#`hTk*RAzx0(kHqz%_0=M*}uUzJXNy3+C>9$qH*+n_Z znwAb_8q}Yd6x#AKjmzyBC0T-(PC_eO?yx1%si!2V`hGl)m|dvnoeaSqvX%sv;W@C^Dy-%l?6q?6TaJbZ?>B+qyJ~VkUx1P zHajGdm1ix^&&U+IHfXeqRXVeCjeijpDR+-Ok0gwqD5ZP&|1nDGnMK8`{!D0;ZhMvu z>H(X*q)=p2dZI;3pSNH^l86QPGGE=LqATv+V=DiuT+0l}R!~bXDk#hoT5@Y1m5Owa zkYr8q&Qyw@FaO%>yVyuC$SBNM4#mb_2-VkKw?d`xJaYYmvVo%B6N6y~1VLxjX zG$p7Sc}nM>T_RMFs$3{O=Jrq-dKG_fTkyx7&i@#k+unZ_IZF2*-2! zEU#*>srJk`Y?u+=dvIpa(u~rKJhfh->`j?Utr*(Q1!z}{3E5DA<`sLI2hBL0nvEIx z8CI(o*O*~5%C5wlZ!RgxSjBQ>Czd=^^^(loRbGyT4Wm+^8s{#%5j}`88SR)?xak>% zMTM&hpmG(OE^9HWG`LIIx zU5NkrTCApeT}|uiuMCUkG&A$9W~^goN|P?;wDceh*dA0gi)fkCZI#WT8t|CYIEBpJ zYi!vwN}%dQ=P_R@{S(Wi`-%QCUn^z)=HDyn!on4WMWuzt?6S=4VyPk(_RIdn{xVdH zE_UU>m;Q?(llT{)5$>Vkt`IFSFo^y%_g_E|jkSYBDD=-?=dT6mz}9I!X)A9)&j2kz z3+f3QJq4fAM?CrHdT2f9C;rH&r>-ac#GkMy?UH?+_#;c~w+zAU7jgbKpD2_LJMunX zL(RbxRcO!8m#+dN6?JMXOa_C2m9BvB!#=ng7(#GA_xj-bd@!8@_O?%_hrRLNeDDK4 z_znNA_TTiuYMf7bMo+LL8ttFrS2v-&HzoROMmC{5CVOOl9n953I2TyeBC<#ISJm2V zZLF3hWJ>D`CA8#}T2hpmZG{rKJO7lwMt&jxyR%2;#+m+Fl$X5)d%CuFkNe<32PHpM zQRb&IZRC9rV>H=56%Ug19;O_W_66HFotOUI%5?iz9Db{$4-Sy-mH*A*5-WccReXhi z{(${qgRgz!c@N`UA9IokjxmZhgmQ@TnJAUf2>d8-df`VEn)05i6_p7pV?@b}DCy6L zM`c~{$X{|xl==_y*MJ|H(R`8Sc=RLlq4<&cWsJ>?XE06$B{%cfd_L2~pydA&{3z^v z{K%gI{EYY&<2MMu68tEx<@ixt*D}2wl*}veBY)Q6NA6LNM2&uu@zbCb&*$)?aQ=ZG z*?Sv5iq~HJi2oUW#9smd(wrv(LLvF6XTwgJpRG)dyCg1V+RW70D9u%Wm(F+t(^jU& zCU(!XnW=F%n=@7YWhLVcOr1Gg{OLlXv7_#{DnU>s#9aWETpEin>cmv zAGythA0$Z|MtITijpRc4TmZ?~5k@AEEL&Z3%9BvAyT&jJ{!oc6LY^(d z|FUl4sfz4>aG=#C0XT<3bSjvWPd>6nM<-~Vn>U)IL~UHGe1f6Gpes3nmi*VqjM`t* z?WCgp7%LjVSkXa@6*cK&(|4KHG2PCzk!ds27N%b_{f?>f|7XU(F%4|yd}eB7 z8pSk@X#!IV(^RJEOv{-1asE^?u3@^K=?117nQmfQ%e0PZGt*Y4?M!w1WqgfHW0+c) zrZP=qn$9$rX))6>rsYg4nbt5}&vXORjZABqHZyHys{C(ftQ}yvGBq-dV`^cV&eX>A zR;HCqH!y8v+RAjky--WR#+?P22QP+hdO@yTn^}^l&CjrD;ALg3!XBL>NhwQU&q{`{ zTPWXTM!{W)U;x6sa7P^YV=rMe3-xbi_A)IcqXg|p3FsWcE!>h<$iFko2+-K&3!jC)}kHU{^vJ8I^TbSFIW2Y*;(LRD=TQ=Dt`2&q>RhT8n;ULOE?S97-I?^BfYG`L&loLaz#PG6*PmA z&wSB-!#&#cLKrOorbsTve`+8XV5CA9e9RPmB;qN08KTtg((8J@>XhD$xQ$BgXFLJTP0GvV_x&=g>jp&9)YQNk3%S)5Lylow{u z<)HK7t{8N#=;t+U4&<;BI05FAv(kUN@Rj_L;ZUzf;mEYZn8PLgkbGqLG{%*W3}0lw zFp%-^xR>#v-cl9_880~wk$NlXkBldcNomxh;!C3yWg_j#_;)ooBbM}}GNtzv{EdT5 zv+#eFS9-{V{>EVTM0V)U=r$pn(zZpjXjdTg0{o|ut$MPNE796Q$X7mwkGLIU8pG7Y z^hU@t8q!W>`!@?s+YID~d{!V|qP5v#-bW^qzX0X*|9?mV#y|W;LBApY{>b~Ii3KzA z|Ma&GGh*MruJ+erF0KCXy}bYG&)bLFHP4?v=FtDmpK@>f|9l}RUweDSx;yT?tFr2D z$34~e-dA(~-yV4Ip@$z?|My29d;EzfpW5*BGtWNv{0sls_~J`1|MQhsU)%Jr*Z=*- zn{T~cyLrny@4ol`*1Gy_4cm9@+|}5$`-43n?%mhC|G-BdfAZ;PEeAh8^u?ElziK^l z^w`(me0$v4cEa`D_dopD{?o}*KmT(2*N!u1&;9oM`A*HxKOiuuM^9aFNN8BE-g-ly z3;Om8?|)&$fPohc8hr5(Ur}Q;7a$jCD%y#|2hBv74rAv7NF+1>}P0xNY8r40TOB( z7(*>5o{fx2ze!ImW4W9GB{^f#Y0}fkm~@-;G&2sCP-|gKx zyq@uJ#v2%qV7!rWB;!qtM>4Kud;Wt_w~jqxnT>5OMH&Sk8|b;XS5GQW(m8V8m$Uc~%L#%kPG!}uEJuV<`A+8Y?F z4bB@G`*8!XiLpQ9I>rHvn;8c(R^!zm#;wfn!ML4qPsZ8_nSVOQ2FADmQ9NpX8_L+o z{4mBbjC(OQG49Pcm9d_2I%5OlV#a+Kt8w@RjMX^2FXM8y-;Z$(<8a0s824wqiE#wu zI>rMSH!~i{xRvomjN2IxVywBOyaqEiFus_vk?|15F^r9jO^k;!PGvldaXRDSjEfnM zU|h~Pl5q{=k&HJmzJ&26#-kY5F}{>>Gvm>WTN#gG+|D?fvFW7*Ajv#dsp) zIL4PTwlJQ=IF0e;jB^>sF)m{~nQh`k+F$!3u7~5C*v86 zI~XT0HheGBpUBwAcqZc*##b>mF-~Hf%6JyzbjGt87c)*~T+Vn7;~K_u8E;^m%6Jpw zd5r5AFJj!xcroKv#@8@zXPnJg`$4961!Du_e8xt`YZ=Ed_TvGFiE$ufBhROMGEQZF zFynN_A&iR|hcPZ^Y+zi&m_7|j&j!Z*7;j?SpK%@IfsC6O4`%FSJce-x<9Nn~AEi95 zWNc(SgK-Sw6^t#6{dho?#yF61F5{kz%NPeUu4Ej-cs=7V#v2(AWL(QQo^dnd6^vUM z`|$v+opGQVu(iwd^<->d9L(6rID~Nw<1of1#se9rGLC1Q&e)F!c*TqZ8J9Ee$+(7b zFyjr3Ll|#j9LBhg@j%ASjN=(Q8T;{ov4e3iW8F_O{UMAa7>6;AVmy#>9OHP#sf_)2 zK$*@sm~k=V5XR+<2Qsc<9M5&scYo z)5|!5aXjNF#(q)KeH`Op#unwCahkF}M%vF+_8FHc`;04<{TOL~y|T}Eqq5JqR@t8@ z?Kdj>j9Zj_#!h8FPTKEKe8##{GW~v2BtL?22;(TlH%We+;xo1=oFMsW3R@)3RXADV zGKEtmu4Ei|tHkRW4`jTNvD6xC(4vx7ScC32Lr|rMw6G>KlXaY=g{FtrLFu8@P)SJ} zO<3weX`cf*2?JA&$G}83Y zz5;rz@Ilg>n37f-m*m5Sq|zQ~)al7XO6ak(JJKf8V|AxXhLyR^`p`|CA<5j@^W`A|8D)~0J} z9z^9OT1#~6yQ!Q+Ycn)8FQM`hja3CT52A8IIFbF6tLay{_1jc#qOsbb=2cXF2+w2t zRF0y-#K9x60 zuL_^aT{MugPvwuW3ZKd$#Yfqv@<{Si>9=Y(0h`_aTOn=YD|t{kjYe#_nj>`bZ-LuC zDz_9rb3YYI=vm-hBh{;BY(oJS*eYTilZov@N0 zm3sIDsfAM1KGZikFtc_g!GVP zrgP2|iu&ux*8-7GbKG*4?NO3;HHR5+0tbeBKbe_P!3Ny^FWj<=MP+1+kQIeFS~DW@6k`ezm8M5fa_9y0!(bgFoz zvV>*4lHK)2#%sPio-$s^Uh$yv<_TBE>neA=RlHPw$@X@-S3C_io>;=y@p~DraRpQrz*B@=tP?Lm5u0 zn=ivj;oPNmo61@D;ZO^pN~jEHfxG<3a6I)%hLhk=hsK{~Gr?yR@%ro2qZKz4&B5)!mM$^r&%!^xy22ev-~YcfFAO z=|1jLefU?q%ZKz|wVHC=O{Gos+mdhbDhCwa9It+#aH>1~p7Fly>8V`Mqx8nAy;pkr zF|rtF?SArHjT~*`3p%`x!)$B{m;4qsFfjg{v61n=7{@T)z}Uq2KE|nx_c2aq{0ZY? z#s?UeGk%eA4dcy>H!$ALcoX9<7}qgY>jce=_b|Ve@m9v|j2ji7*EL2l)&itF9%CHA zcm-p%ZZni|4D&M?t93m;#wO;g@n0(A)yz+4{5E5?4ye`%%b2g~jaml`Wc!uOSL2%X zjPGK;S|Q|U67R5my9DAf5te9@ovU(jNfEz zVO-BRjq%5fa~VI!xQy{Dj4K&`#dtmA2N-W;+{(C?@jHwg8SiD>!uSYdC*wnmI~X5k ztm`4ue~@tm*KO-C}eFh5th=k_v$aT@cJ8S8jm zZ7kzl=35!7b@WiiWz2t&aV6vD8LwyjD&vieRli=#_$}r)GJaS2$MI3?t}V>3WPU31 zFK6szzFLP=>-=HN?_j=~Ul`c^IOgkm%KWi0PUH48f^h`%Ut=7_Sk22cw%?2Sam=5~ zSgl(}F}5)OM#eSlehA|<=4UY0F~2wCT;{VH&b?1T&-^mxKg76_@zsnY*gpf~^~_iE zZH?s<&HRnbm%X*-UiTi){95LhG0tW8S1@j5{_Tv79DX0hHEe$x;}*7G#n{PsKI161 zKY?)v^H(vhWB(%=>vS@Imou(q{s_hq%$M3ToG)d3FZ0ztg3*lQm|wuy!nlHQImd4* z<22^q$+(#L@r-kszm9PP^J5s7G5-n1m5im<4*PHz+nK+S@j}K?oZbr<*E0WM#*K^@ zFm7S|2;&%b-R(-l+KOe}Bfg%ui#S%KQr%moZ;z6Escjo0!7`CF5Gg zk26l^@CGn$Wd60vJ@bb#Zee~FV<+SH8Fw&lV5|#~^4-KZf^jY5D8?T!j$^!waW02H zkg4^me>dYab|1&MgZbr*)0sb+u`X1~b1maCj_)AG5zN1VaTMc1#^r2(FylDp zFJ)}v@GfI)Vg9X**Ry*g<22?kV_eDniy7xKKb>(L`#+I!8S|fHT*LSl#?9>CC5$&R zKaX)O<08h5i~|_AFh0uI$+(7b2jiz1>%ydbUuPV__$9_sjAt^AV_eKw>SgJqs(j=; zHv{u`Z@diJU2mMls~u{doz1IL3g+r@! z&^~zMn|%1BCH3Z$meU(6Ew>7Pl~;O6+bOkynO=H8X(IpUgRgv`^{8mXUimNAU({+H zt=o~_fzGqaN9v=N!3R2B>hVXe(~wp`K60HV(=BI;OEjdcp;s{>!9>I8PE>PN9u2ux#KIbTCG&}Gu`o*d{25L z&U434;v3!hEODWa|HbZdDfw#kO@&A2R=nfqDd*Du&F*q2^)XcXm3`8`&}mq2oQXW^ zihcQA-P0LZZ~OA>4w=aCJozp0a(Dhooa-((5*OfXuD5@M?);N{wd$z+$GzlT?8~!9 zWTfn?aw{=u#pNTh-CeFFUg_l@>DjZrFs*x#E&0fGs64kk<+`C-b*6P^TBlR1ta2Ti z^{bxpqp)g+B&Po=Jkr1ByUU~G7l^Y`WJ9ilc;YA5X*~5(u3LJ}MalIiZ$9}? z^;SMoudP^FmtVOKs8+M(`Z~1>N?vlE!&6@+R;%xF{XH5QYt?Sc z^|R$}dCB#z74G^W*Off+SL;5?gm5%k4<$djKDNT$j>~mLwVF=r>a^~tR@rIYn%3t$ z^--=5s?~Jj)4G!ijWD%?^j|)5UCWy<>zjv9xWHZhO#hX8TK`nLE!4U)-K?Paa{WO0K>B>@lavo? zeZ-qj>m}ZNlBkN2T2Js`T1Tf_1yp#d{?P4Lw3k70#er>jl)F$QH(fWerkT zxtBQC9UqD5Mg{puY<0H}65HJUr(Ey%g#TyvFICR=*VJ4ph`jzfbb-GJ!jKt#!>$#= z497c8d~ciC{P>us!ibmg%jTE2K6hQiPopyBJRs}M-zNrbKX6yh-_C@`=O+mFn&Dtg z_Jd=lFZ;|daoD35j=W?p&1p^k5B03CS~OzNKhEx0UeIX$qTm%*i61$r-#d)XjMPrCSFMz1Ot&?o*+Ax39Y-)OBmagORT!T|j{j{POb!Pwm;7vE+-FU%qZv zSVGV*%lp5(f8J|vpBq(uU;2ZWQux}?u)E*6@VR?mTlC^nSM`|m`t0jlmwr(m^3wTs z)4_W;HkS`vF+3Cded3ZQJiKdh#V6BeeVsAv#e-7~Q{F2%_09dZ@FjJaP-74$Ng|gYUbZ>YI>o6+pK$|#_BFCDoh$!IDn*W znlRGzN?>Zq#b-X*|KO;1KD;*P;j!`099n%g`=9d%PfBN?UOF9O{{Z0F{-@otNT>AXY8Ry@=;KmGS zI=}8SxO#cRBIA$;uW(EXeoU8F{NDT7D~+!0BOiOhxjeiuIQ)sxCnwz0_iD@gd!P9x zao!r5EgRk`d+=BPI@?9}XxF!IvhO_fV!zD?kA796&rY5lRocJxbiua!XI#Cn>7h#& zzI^o4OTOLs_zVA<3U``mR`Yj1w^t5dv!fs+ttfEojE3u@J1n|BKMY#3;cQg<&mT^E ze(Zn^H+}l(++mHoNYL`E1ZAE3w&I$T`d1b| z*yqi1E$7Wq#(f8Ne73q^+Vg`_-v01#@e`j|cAP_Ul)J!h4#Q#os*l`sen>nvc#cD9{f*8N2A4MSbfd zANkA`wa)eMN2T#e7rz=kDE!yx-n z>pyJVv9QXp@U11yAHRPtZT#)E0Rs|~112}64EU$EW606E{NX zfT?qjPY;2=n&Hcz=LIKTe`NX_ua2Gg?`Mmi{cu|0%~5asT3SE5x$(gA){c#@E{|_| z<==}M^FyC_;vucxa_!W+-=FpKq=WNPoQH1OF?7(G;I)afZftq!vs;so=pKLmF}qed z4y$D^y*vBj(xpf>PyuxPd+hy;=_-;_|;c_=RZ1ipxl4e zhRYFkzsDX={ppo2c8z&uYTV^1JFU&j3r_Ud_}JAQCj+)Wb7bCzD~20Bd(nDF!j^*< z>{PI zM~z#zmSpqwg{4{Ne);I8sVg_MjqA5MC;8{tu|L(Gy0@3UZ{CB+){Xj+>88GZQ$i|l z+A}oz`OAN7`uy%U#=kS&oP6ff{2&KDpAdBP*6$ygw>_g_*-I^--*xyzY;8tv`-AU2 zx~K1rpVU`JivnZl>zs7+&L>Cp|2bq@(y4tfJYV|k@b{m){n}^tj4Lr*wkF|;_iOuZ z+c;-Ja?>lZPrke5{6AMt7@9nG!iRmYeB=J}#gh(R_s$)U^qc4tsi&%li9zWFZ?e(|K-fR)g$^|^2&kXZx47UaQo;zJ>K5!`qx!o%np8HxBnMA?!Efk@#Tve z?%kL+ZsPQd10DUo*?PY3Z=FHoh0Cx0I^OIX?9t*+TYucQJLt3Ls^81kvX1@x zi#g91>NY<8Wa53c#s&BOws@y)&&Lh5(+e{XF5YwPo0qkn@0*`-_4a{>wmkIa6LWrg zI`#OOFK$|s*>m($;|@PDjKb3lRqx#}WzprO$Ksy-VCvi_5B!hz-UL31qHXuC4oS!c zOh^bx2oUzL4-gcBBFKKz2w*MS(DqCS5 zZL^qDyVsd>y9(y4`j9z$e#u&UT3GA$4Xm}7li=dzE4XwRD7g4c5L|s02(BFs zf~#+);O1)--2C1Z-26`oZk;X*?wwp6+yipTPeCj(Cmo82vcKa4Rs{E_DU zJi4ZxCQkf!2lLs#Z&fYBv&#>->mP7q8lh|t{%+5&5tM@i&EZcUeGk8Hwz=8;`t17F zJ*F;cc3bcLt0p*OY_pr9r8sTzQ+3f$XKMx%@CF&ZTQ?VPj`g$!l9~0|2MZ}4!|BQu zMBVf6rV@=S_dLltGk85w>+;G*qUrIwn}``%i?$N2%irHYG(PRNi)cA;U^h`aYw;c; zo74IQqWP2Z7m3!q@Rx{zH?F=+G<@>nKBCb%X8ih=!P>oK+Q@D#>jM>dDW)wf9EOtgn9NR1cW&2JP1b=Wy!& zU~iIJ6~36$68izCR^90>^0ySFbE;2$&1tM0x}W^b;!e)M^?z`xpP0hihpt;LrzYdB z%smUo_?~;F3LI$U?qLvf& z^B(yd7iV%B%s+Bg-5&8i`I|3n=TvXLz^S=7`XKomTy}A)F8s=Ad}{0m3po zS5D)hF&~nD)x0cDW9bD>lPTmQ9{z=Goa%uVPUFXZCLaH+37onQ;yE)sUf^V*A91Q? z)p1(Kdmf_jM&Hq#8RjLNS_G{kpjjBTk2TIo1x~GzZL)-NsciU5%V9 z@+hZz+a*p-L3=(vsS83lwc8ePW<_q~)VP;$8uGrB-94{znz#5LrS!D55~tZi&zTXl zMP~m>PD_W=^8VkNI1SmIkMa5#Kb})_d?}|fbStO&#Y#@qnNytFR!y9NJ^?j!T$ZPX z({weO)AI2qPPVF)6YY=FXl&p#wD;k^=UA06iZkQQ$2i&fb)4E8Ih=-DM>wl~tK+nO z;Qkq^g8PUD9uoCfg)PHRy$XW-qloNDoo%($+f)A5>h<2Vf&(VW)!XE>`S z7Rv6{pK_YszR0Pb?Qxur(|$Wp=G0l7nnDAox_+1J?(-IB#?;fCs>rLHY>v+tbi8i# zNSSRTIoX%#oQ5?oaT#2*e#EK0vyfBQdkv>$>^_;AgPa*d z&vBYPZ_EBabo!ExH@`H7(>Q)1XU3V;oQ6d&b7q}d z?9Zv%JepJEG>y}ezJSyEb1bJ}ayn;*aTBMi;RR0hm;z4glLt7p`ww&KE}WA0d;H94 z>fgYrnjoB{^flosnG3pdsv`$+vRR>==Fl0O#-0l~4Xu`QYR{%~YKk{;>I^S%8VBcd zVtn8Rj${8h5#WMfuTs`Ewe!2XU&{NKW;NNu1^rb2wT5 zC9->+fm8FvT27tUcFw@?S2&HEi#aXtz9aLeBb-%^r#ZDeZcR39cJ^1{q zYP>(EWmFKSs^19C7V|UYn{PV<-|T+S?ak2BZ3YdCYxhRz{IAy5wR!$TXk5aQF%z$x z3Y{;G$iMh#W2pN_=f}oQI2`Jke^mFy<{P1}59%72wB%0c7ayFh-a6~|&<^VHf7NC( zv3ynk0xw4w@$jk3rj9QmimmuZ3n>4M!t>zY_Y^XQN$R zlO4svfA#ror=hd>+q;iH@!F4FMV+%-;YWR3L^&Tm;=)DCRo6y3i_@2^srOpmUL3t7 z9zICPGZKNTRRsm?kZk5)Az>AX+6a~ z9^GpL_qG>Ze|CH>%)Os@S6@&%Z)R69diDsvERSyDh&~JMrnhSf{VbrSS7x|MT%MZn z)STxnp>qBBiesOfbg8JySuFnUYNw`0Rbq#)=k~t&Q%CWm3l$$-TF^$!m155h-r89l zIdb%!@2h)?j_oU=)^6|;UvKyO)F-zM5IZk;v4izuUvb2fLlO&0{KUD=$*%K~2Z<47 zt8Whr=q-llM19$RXo)NB(B*g5wfQw#61}5mpK1HbAkky^62Gh-eZ}>Q(nB(nhKiL1r8AZ<93uv-+;MJs zcWdaM{-cL{J8i7kaeK;|x|j~4@6s*xmv#;lm#%!`>TA10#cJbr>zJ@nV(-Y3%Wc0O zBfdA%VZrx@M~TNi`@{146@Rg;O`i>OP7D{{d$-@5)LEm%h-WjO?-Sfwv`+uoojvNI zoX0+5)3!hN_hP+7<5vwQww^@!(%d`-1$7fYD_k(_ilL3zOH<^vc3pq5%jRyMB&vsr z+O(~7`4nS1f4gmXl_;j}d8T{K%F*J_&;Ag8v~8$Z8TqW`c-~;~H8;~&IUC1_Cl`L) zP?aAjzI1J2cilIk;z;W&&$N5PMLhp`)`1?GqIm6vE>}FgMu;!B%Xw^5*Fj?byQ8Ki zKR-bHDNDc;U_e96X+L1NU@ z^T(FVz8EUEzae7g%Iy9#$Bq=&hyHHKuj?mPcJr|wt?DN(UHEPWlAH(P5oB2 zQOzGFUK64!R-GIp{&ek=d8%9w@s`WJC59k;;oY*YGD6-PEfzf0_w!*R28a$9|9UB8 zV>j_vm%vv)Jw8U%p88;-6AKZ~FW2?{cvpY%$Nq2k{&96b@zcZ&HM3Uwiq_b6zl6@} zD*pWZsFv;@AD8=G8#Yp0@w9kF_0C|?OBM58V&*8(e_N$FcFwKP z$NO&Y6t`_S@{!P8zvph~i%fD}8#zq$eZ9TIZ@wdxel$XyrgPa?&{`6^MeMooQSeyN zT|KU?^^FiQy3;os$4`*N5vijVxkir`fAD*E-m~L_#ey?$3cEiWAqG6xZ}f(cKB9Ve z$F`ZCW5v7S3ER(w4iP*4-hK1em(fnYU$Jrbg1+L`K7$s|{H~37c(`-F`uzIP;IRWT zt>Y()i>6#FeC2XK@q%vJ)9a@976+}G@YDDLvGPa~hrNemOMIUe zC-a`|^x+Iqzq07=!m3_k=V|_KAD&AbtlL|ylw;k9c=ieJ5} zQ6KEsQ*8Ka)suhi(1^d!KQ}7r*i3PLqetO$jx$7$g8UQTJUvZ(Z~l=shHuoO+Xr>+ z<3F7!cIff*bAAIt#qk>!dv!b3U3@C_>`d|HK4SmEadEFV-3}e%QtwbWwVU`|+WIxq z%O4Tlev7`Vj(bELeEH0W&gaL8y94Ss^p71VuF3l@v%d9c@mlhsfx$O4;y>M=3AA*@ zzk8Ck^=)CD>7La7rce@)eNPH(THm#4{XOZxcg8YR^gZeE@zY+@PlVg8$HZ&B?ny3P z*H{m=z9%{CnACLa_q&qmlJHjR<9DS$g!fiwRNR%8y<;sMvg@vNLHlC9f9hQ+^%vpO z(ev+0DgNhH?HYYo>cThBBH-_?wB^~RpTGI#j`Ue)<2m88JJNUS-(9JzxFc;@*QH0p z?mJTOfa-|1pSUBvnVgnU_ShY%^XYN;yCeB8yq!Cs&mAe%l(_SN#~tbDM-v}QY`87C zztU>+yxQB+Z=VY^Q!nt-@*vMPbnT&YNh`?J? zUiULYrn}yff-18QKHG3pT9mbCUEOy#rA~$;{)Qtrr8|FY8r-?^ru1R-a@}8hZ%PZ! zt7reZ;ii<}Z!QoLZc5X(#I_zc|EA=hHx7R{C1b#mP5lPklpLn7zH!P2{zd_RH>ESf zRL}3YbVC{#yQ1Uk-`;Zb+8jzqwr%c0>Agz$@#H2H%kS{$!qdEAWQ&b(YY6R+}5rP2YVx58Y^z zq>=Tj!+&j(PWh_03#Xc-(f2Ts`lv}Nxw4|&yJbz%zRkil(@Ra#w5n3;FV8kf@9s7o z?33Cg`92$kzb47sIsIcct4aF)!#7vIIJQYL=4}wB^}~L?HA&9Cx(va&Nz$wn?l?7G zmpadSbatqG9Xp&^hR;;g>%cUO9^Sh$Dhr+E=}(Euhf&1u1nkRjyqxvzAhd7Ve-15p4TPU zHTx3My{=1!_3n>Z9Ii_pbqzkchHKKXkrP&2KYvY%s#)K=;N&%_WBehX_(RvEQ2$)F zsc&49vXbYV9GiVjGMO_+PuYe2vFm+e*I$$TmkA?YfBc$sqx z6w}RpLCyGU(hsIB)$@j3lQc_&CvNt*Che&h68o0-HObj0Qn%jensj?$-{6>QSEb)N zn5!55c2&y%>Cz|5YOhN3RnPU${Pe1{>*kcB2j9CYnI08ZIF((MN{;uak9zg0^k?LH z^;bKtN;;=VVP3{nY4i&1*gqe?D*Y6`=DioAuS)X$(5uqj4e$TjYsyvWk9Lh=uA{C> z)18Xu-RpN%>d^Gl#nzp#N=FWRp6}icZmod7tI{hozF)HQN~1K&X>g(CmquyEfO8*C zsBM%ID|>CK{;W|tzq8z5X~N3#bvcdFGV_~1k9xjQ$_Nv>J7qRX zPkL8OIlsD5TB=(Rd?KMydil$%$3E9JN}sJf_S2a;jnb_%OY}{X8>N|-OVxcwH%gnj ze%)*7z(#5Ife&^*Yl0)%@g9CoLA{|XD z*>&dYE7EVJPv$-U=@n^i-yUalA6${V$GqV+=8Y>-_nOrqJ@c3g|+_S%J#S`Qd7Uz7oYgo73olV|62j!SER{ama84(m2Fa)$D7bwM4p=|))~5}U=g3EQ-1x9T()1U~ z9rrg#PKU1S4k&JrUTc4$@3_|*qC<7hGnek&>)>LE%TV--XOIP6!6y|8M+>N%JF)=G^2Xm*v3os zQfjp{=C7aXr4ObJT6VRzUh2F)r`-9=dTD_r;CA;T^-|wICu^p?UoZXqUc<6AZ`4aK zJn0|xZehLjny1B2c&%RAm$NNn&YpVdyZ%{ES8b`6+WW5e^j%*sZTzN_-!mSYxV2pzRxkCO61=^wR4;kf498!+ zRA%~f^VR|N(lGVEev9l;FZB*9^i%s|Ki}%543+TVt=4c`@2aeKtx`^}w{HG<)hcD} z`*p?DOIFEKw_&dH1*`PJ$*+P?5s(H27 zrC;B%N(U|tN*-Kkl?qj{ZtDxIlJ4osg703nN)fKYDCv2t^pigAtW^9yN$!cUr%-x=JODSuy-c9Z&fqWLH;@jx0-2z_kOp$zEwFpL z1Xd6I41En9g36(npl6^F&k1ZW)D7~2oS=Ff_dWC}bO74DM_^l_r=TP#3Yr5=f<{7p zA=(^X5ZK-41?CRk0E5AvP;2Na+>e4&AT2ZsQbU1IE2tj(x4tN_jnGrjN+=1^LkpqV z&=hF;UV%-7LZK1RV5k?=3G#$mL&IJY*Z`;()CKAYsUTO#0lI}S58Ld0>sI5p2!nAR zNdK@=c#YkDt({GWP#m_6`V`q3h{sC~WwTG$gky||2fy)Y+x<7vo@%@OX4ns=O$Sk2 zwz%!nr}*tRTNv_FJ?X##hdVIzefuCSYziNOFt#ns&L%&K!?xL{OYzz^Ul^@2T4ij6 zUlHs9X!jbhSjX5$(7I^67mSDQc~E!s5H++5ItLBJi|~zjg|;;o!n}l+G#|l2j5Meo za>h&iBcUir+|1Z-n*|oV1$_wm60+j_--Lvh(bgePs1py}fx0WxBF+6MzWG(Oc?9Ph z;xMii*dY82b8627{yM602l_5{+WdOrSEDTOGvFnJX1}3Bczi}jn;%w27}2i~{~-K) zPHI%o;S@i{OBO}|>+cuP{BBVe#tc8W4N4?c4opYK zB&Q@t_f!vo$#n3ezM=T>e3SqGTbtnQz?_FVsD*aUtX)iN)-D(v>TVF+9GM$zx1r7k z0bg?6DZHb>N7q3uI10>h15W=GH#X%$8>R|wiwF81RyUK2p|#FgE8q)vRl)7Z&usJS zMsYQ^Wljhmh=r3&Ak}CG{6;D|BmCI|{sO+F*DJ!Ec?G*Muc7U%Z7lA(ZcYx&Dbw6-a4p<+;jDORY3-Ez;aa%u!dYfwEeYOdvZdR?Z5NKd7-|P(3)jMJ7tT5r=}x;J zu7%q!oOU8(KR~wlTDa}PX{O`1ULjk!7H+$6#z|;{D6=hG3%6aktQm}TL78pgTDa}P zna1K8gx9fc;aa%u!fC>gKgbr&-ran@&C2=i;LJK)Xvf+dme09%4C(+{GnU#K#&$cm z+{Vzpf?XeIV`#s4J1ZKhR*tiG^Y)MSA^5v7|5SJ89|K0XGXG!~<{$235jwcA4ykUe zLyRly0KX35o)!ULO7FFsw_`PL$ETf{p*wzC7wQ>`ybW<=**HjnQ9>+RG zwB!5h5JpX5kbeqq@3xOaXy?S*ZE&}`T3TzJF>u?`sS3b2heZ&X6h|Ky)(7eMBb^RN z$0bI^_YJ}Ry-FGs*4}M@Jg@Je=wBA4zNt^fxU;}P=#$VTii7+PdvJFa{BA4p(tdll z{V}{QFQ5*QCx47V{up=shx%9rs+UYB7L@MH+6tbmwbjYg%7A`NX~ec>8e9Vg`{1{@ zMWj2@g^i5yWxe-0GT#d-<`U77@7sd?sk9&UM`7*V_Qwm}F3cO}(i`W}I~aDj${?Rh zoW~fP#|YHfP)`d_8~L+hu-`Bnb1Nn8mTm`JH(Q1g+#F~umB-H|Xg|J~8*sWYU!?1c zbbXPo?@(`RdkfNTi!w*FVQs_RtS%O3gRNdI^Y9zicmy0Np-lKOgAS;FCybNiHyw&4 ze}?qQzlEQC-2E_^JJ`kL$=fZJ73DAK1B-Ylzm9 zUo%{oTe!1YKCt|Oe!BCMyxT#mL&aQA~dLvas-E!yoTw`8~9)gNsE*AxF_AB(ra zOGoiiOlb%czL>E+h=<7Y5bmHAXzW0Jvft@sL8xZV6o%@D+Cebtr+r(Chru1b@TdQ<+34Wl$XfX@ zX9t~Nu=xuC9xMQTEdYHw0N2ZaWM3;vV{UI!8C=_7e!Ss+9=BtG_CDw*hxHhB*kWm;>UMW5<3UH|7)J!F+<$w=Q9bD*!h)wVi%8lMevp>)jMi2{D`!zEen?{Ya%7F?SHP{#p7@0Y`` ziwo-#?r-(A_?W#-?G2tf6_2wO(iOL24i9~f&j7?$&~@lMeI~#*bQ|Vfkj?E!bBM1n zr?9w~`L$f{LVH}# za4y=Ty|oYL{YEFZL$tpLjJLrUZ!y;T4fMdZ&x>`9Y0tU_d$O*(o7)zz0}Yjh=BnYC ztMYc-4#&5}@o3Mx(O>Px9=~Dktb6J!tb5GMtb6cFth=y>@lh3JqcUV+U=q5!A&e`+ zxUlYM3*FHcx)1GQ@oeYVJO{S*iQc<$4Tc=|@iWeZ&K|6DY8%!$21H-zj5gCb+|Sz4 z(!ng(tt;YiVeP_Ex0G+YIQ`nmW!Qsdl{Fs=?D8k_`^tX!VVEw#9?WyMo0j%jv5)Qp zY>Y<)*nAL@ri*U4= zKIeF7zNUVLccLL%zWivs9*^IC!smZF`t2`JM-bUW+Q{}Bg#5)EMjk(5orMpXZ8WBH zYoYeZKg*#0(Kh*K8GcPru{K}f^9juzQV~CILufy^#(JYJs13>2FW2Vl7o}Bk2KQOc z;`;_{b=TgRwNGt__S}}Wf74wncsMYRWGC&z>U}AW`x3IX8&5hmScT){eqcL?j^AO7 zfYvE#cq*UCZ2Q0Yk+DCaeYQLVVEj$(h--=u#<>m{=e${f(4KX$*vj4pW%rQ#Ha}Mw zXJRnUpsarI_uJjUB9D{pal9vv$F=Exe>3p&i+QwPYKvp6f-mML=ySe^!#5eD5Jq{y z)q%MVby9Qg#`Txn$qo;#kL>G=y#d+I_rvO}TNCa@LI0yLaoGRTzX@|5>HKAvme3ma zInlN}y>WfV{Mt6hv(@oOcX3UE4%q6rqZ{iO+@5vZt+L{5HGh_s+dk?Mecum#pIV1`}Lx0z9+8vD&~`X|C&$7gis%$_LJeSAxo!sn8Bo7`t$jBe>vR;1XNe<@+SIu)p^Z*o2b2iA6|n_BR7#+cU{V;(rvTjw{h&G4?N-mFuM7at$IhP8c@ ze?l`mnrQAseGp)NU7c7PVGF}&WwV1x_D2(A-Gba$P~$T!F!fn{?%Tvv5t+;-cr&v+ zDzGsN(S~Qr`L=fp?oP}-rWJEX-*HFZ@xyi2F-JM4NK2mkxG}e6+^ge#&J%r3#oB%4 zj(Js^xh?WL=kNKAq&TQ;BhH8Qodt0MdmXa1ZNGnL!?y9ox&qIbaMRe<@xI*_bpc1p;>1Yeq^ABuahfPkG#0hTywV+Y9P7kd ze+)mGi#ULtTv(@6^eM~}JE3iK8tSce<#nvg@rK?X{~pD2j3|iGC%W3*L$&2`Akx%9 z^h|@uKZBxRH0tqlfO_KfwFKnHw~^1Q?Q5R_YGx0ft}!w`&dSZ-;e47yQ_Tf*V+y2j$5&6YCG3~^@4^&6QMbf4oZMlL(f95LI<|7Sg3N#y925o?{px2=?=rB|Z)j`)G=STeIvmRI*+KcsOeelckeOW&=paJ;yozFt*>E<3jl_Iw z6dTRPu(2$ZiA-V|HV(fzFoDr8B2C7xVuaxv`lqousZnvsgJR<2+0ul#VdJ7x<5otc z>Srd!=;O6f$*FOvaY>1M*My`5L%cp!A2T&ERlh7bDm5v2PO9F(_f6EN=#%53;^S89 zC(oRVC{y*ae^PUhNjNHbLQ>+=xMgWL7_m|sJd|x$YFuJkQd&wxTmn!3{=P{o^@*u1 zgHKIF&M3i$L`7-d54|!fJ`MSq7?%>AjO_EwrO0uo$EE&5j?$ca8|QIne@!jIeXu4~RW2f`!omB}B=M4e3x@BJat`Q9R4G;EyCF zpr+zeW-a}vQa+NFutcBy@Av;hfo+G+i$c3y60e`AH|P^%^oh}N`sPZRm6mEqvpb2+ zJLbg3EroxJl5oEVi!moPIWBRTtx$7Y)El|(R~)(S*BrT;tL}f4#d-SV6k7+C8zFi{ zs(wP!oVbLvc-}X7>UR5h*PfIf9UGOnOm3HUJLg2l>SNO4^)Zvu_0eg~eLo!iJC#Q? z=b`<)**C`4kmg`0P!347YxHwkHhMVkH+phBtVzRvqJBx*vKdLsmf30(ezufssn|DJ z+D$E3sZluZSH0{|YF>7<2qxFNyyI_8*3P@dxrYDW8imd8ZvpQ&3Iw6i&Q=7w27*0y z4McI>&*%LH5}{9~uA&UMbLn~ggJT`8JoN5>ZL872Hp=rdo1Z=DodVi&6jm!dp|DQj zU4`u*lfw^Cs8JZ9(4cUKLZiZi3e5_CPGM1K{jLW+=IVoD7k}@@h^|tek zh)vc<#lVv_k?)*UDXIDd>N4X}Cdb9=dFM%Q)qJVe&zTXIk{X6X*pH6ksqqt{45?|! zNDs-Sr?TJ3Z$?tmiZsLIv_yWv!Q2DaV|JPL%!^A-O^b@3oA^XrB2wJZYHA7}c$Vpt zwaFL(6I0mZbp+`$wMtR7|PT3{w-ACe3HhBYvgS zNy(G-QIu0#IvXf7MrsVjVLZ9{xX(&?lruLeovlHskt|Ia^f8m;(^6u2+1Uy@az<22 z>ZIi4B;;x)<;u=IN z-?+q>Ifl4IewNvXP7(1bK?oB;akOQ>|tsMa3xlC#9oihNDc;m`!SF(uGrz>=+&um!ii-PCi47{Z4hK zjgCm7RzvLrp}JAbEn6Rp6((Wor<@g5<`iKYU2R@${ex$Q=V0x9UrOPTs02Oo^=K<3 zWsnQMh}*n?EKiu+Tqgx&H`hraxti-FpIrQqL#<{^m>Fe|=M#weJf$}$HAZe6j4dEH z?-8pEdKSgg3fIdiuM;MtJ>xo?qG!)=dvaWI3J=Zm{sQ-V1RaDTn9p88yTmz(i@Lko1n$>S4wBrq?u%YPQDYg)R>ut+er!N-Z(Rf`f=?113vTFy;d{R;#1?s zuS(TNB+ZYD(NBntN@iW1ZDvGL^L{p-(wUUFGA=nOF##P_hwb`=j#17N z)jQrkMg5^;P_f3REnSMa5@W-h=cDQC$&b0w5f~g&Fb$U{dsHrGJ74}Wg2hrFva9X+ z6oO))Sq}Q5MEl9DG(dQi^}xt%0+l zoaBvWT=Esy#TKRPR9qCww&R~D1pd>W|22OH#QV=P!vB2S6mN?{{^z6mTRa|!tGOos zC*oC3M{`|gFgG{6F5A4>&V%-}ygtQNFE&y@d%O9-e=v$t9=@)`7W}_^zbzllT=nq$ zn!l0jLt87;a9n2dasNR>lPt$yrPK>bFvamM~PMIW^!I!3>A zS!~?$74Zp)NruO9`A=K_z^HjTmq|H1I%l<;pO{FgZwa{SpZIdwS;<;d** zZ;pR$Ha}uE-WQsEcG1~Dw)pJwvv~0Hz_$KW?GKh4cqe+TeB|8+<_~+7aXeUA-}%4F zb;`C+i8n-v_kWgn)P?62|L1SQzu6of*jg!@t>kpRXtT{FY_#q79n$hTJV+WhZ%I_l zV!iESttKTkMx$X53-@3cit}ONQt{DbaU4FuA)f!=Z7Rm5LbN7J2mYYg7H~Y)I+4E? z`~#|iZ3W+GkF{)MgLvhW+w?5>9z@~knecEt6IO*{eIsal$KU?_eR_}I-xuo|M6723 zyFx{L)Nhl{26o?JcA~G zdKTRl&!H**^h|mWMCGzyCt<&ag4R+9UGRP%%0hI8j>9H;LFZuGuZg0yQ6*4MtWzSs z+?BDhu<3dCAPlliNXvfB)6?)f4aFi1@glSaHa!;~&|S_mJs*!(Y}4 z#A7`en+Sj6aVQoxu@*{)P0!Z{;n_OX13hPd3!-|U=k1T+c{}Bep1c2m=k8?F^Y=tN zeqThY$X}2O=akq8^@L4yz%%?{*z`<) z21I$IXZs&0Ha+7Xs8;d}KCRgFoWBc(d!8;>F-*4Uxxa|#{^U>3|4-ogKiTviz@iY@ zruP8OKvwwE`v9Fr$u_+ckPFqqzY4rK8sX7?=pBLaW0bsswlzt_lCfCZgfPTvs0cQ_ zOJG|YMZ|+;HUR#_w$Mb_^sa$zjS}%~=s5g2VOwC+y9ln5oG!hS@Ek;WqjwV)VJM<@ zs{=1Xw7!aH9EbNzsl9;}(0(Cz9#5|}7Ht{W}8ny|vlBir@pGdj> z)!;OU{Anfja>X`)3m2fR<5(S7^r+JJ!OtKHZw4YdxA3*n;50oG2mem;v_aI{zQ7G zmf|OlSL})4mk_moGZ-6jN z_6gQNjuUWx!I##cUBcc6u2|1l80>iP%+shJ*yljMXOMp!8vxGPgs}_$^ls%|h|;C^ zCod{C%S8Sm%ELr(&=#~U9IFQ3f_QmBaU1#!{59Y=5cR2A@W^)bS@_q0+8wgL38e4Y zpgJdRhm6QW7I*;Sc>ot@;aUcN9k_0noaa5@Ul4_H*^O%oWS;22!ayrT=@O04qd&u+ z_{@u_BaAR)!?LT%<(8) z@N^#f3vA-NBH4}v&lStp1){E0wu#SG;=CaI9#Hp|Y@Y_Zyp47Y|3L6O6c76Xxc425 z7qE%_s^zk)!2*bnjo|oq<@%fm{svVed>#1Kd+7TZWA}r#@1uTD7GmEIk#E>q@Cc-u zg#Hdr`3U)k9R_ZOdcxiYo`R?i)PZq_zViV6m zRIUqP&o5*<1e^g;9*B=AHgT6??*a1^n|K16fplxZktdXRz#S09V+1>YiMmCY8Q|N{ z9@y2OqgieP#KkAke&8Pqw)zTbz;*;rLDc?FgAEYPRT{xDr{wrIf}cZFmgC@M#kPW~ z({dQ1TCs`w5QQ%SFF-U;Bj$c1kB52SZHU4UHQ&nd=s+_>?Us137Ht*zB>J6^&u;)Y z6RLv07Tg6(fOKO{~_R7i1M5PhFzD-McfFnFw6(QPat2|he4qU`(QhQ zQ=zf2XMm-U4t5#1>ITjQ>^0y%h}r{j*G;q``0oL4K~#sg!O&ZB9yFlWZMi*ogKtBW zw`wrsj_gkq@5(magIxttzgPplrr1WX?LD*^q!j>8gNk6!0FOeHZVjknSYH8q02r;< z8Q?+1HiJ_g1U|OR0KaX8@0vn9wV-nRFG zZ+Kum1^oAeUt=BGMA)@pK|6sp!7c)Osjxl`b`WTSD4)c__E>vHVZe@97k3!8FKCAL z!6vGGkT=u=afV_OUHt@>iZCAFIw)Wo>K}X;qVT@{0y_c?fPW46O(&&{U_t=WLVq!U z+aLIu{#3hi(FkgnvBf-Cf|< zCgOIe2L4%KFxIVA)3M-ji25vXKGw1|!aoxH9l8Yj61cK2>Ulc8YYkl84{NDmuK}O$ zFWY-T7pz~afIxu9Yz)r)TXn`(J_+bLO2+>^S5*URw zE>u5OaOnv7*eviUMD5=S?!_82UWcG_2);iHYrtH<1c>U;05*(5nc;80E{xWTiK4(V z;ZNKQ?Ss7yJg&uhF4)95v*q&=0med)&1@C5kdS{VX<1yS2O2X;(E zAAiJw1%gjQ)aEyWd5TT6DmGD*B!|Jb0I>JdP<9+!1D325*jU((PvE-`(=jH%HiN~h zQ75p=z>ZJKb*lz9Ky)5Af<}nSNL;i=9$R$a35fDj3%;-p>kJXkUhodI4>o;S*Lx6M za}R<)uSdSge*?lohhY=5AbuYM?EN&_8T>V%7OI7v1-=8(J;rMA$g?=_@UH={L6o;9 zu)`)fKfd4|s1ad^Zz=x!!6Oib56nbgfC8`v4Bt=6jzLrwS_k(FL}BW{37b);2%`hn zLSe8o!GjQmC+^&WI)r}~m`&h%NZ&!@h%tvq-#*{1ISp!LV(Po(c`Ae%_vFF-bNonjMdT`l<&X>B^$L|S7_Hj&nG zlTD=c(_|BAeKgrbTEk2>k=Aii8Huz;ll+OaK9~H7w1$!ViN_S1)+|~T8?%>(Y)BKn zP)5t0$QL}+5Ak<(#54%|=zH#-!fAeR8!M$J#0RdFS73zp88S%SCs0rCp<>hN6&N@+H90K>%Nv#^DY13` zH?a-t&X2>9DOloxcOh3PZulhYA5TLn`WP)1F5!K~W%`uno%Xw%SBK2duhho}#?$|y zeWFsPCaz3cp-=7;m=-rKIvQ{5hW1&CRXqAWfrFdl89Vr&QyDwBMV`hEZY~@SA3NAq zZ*V+#G9KnOqCdc2n-iI%%Zbe~g3S$!XR~b!4v(aL-8d#_~m8QEFc#_XzWQ?@zVl5NdqIjWq%9CeN+M~fIKzAVI8m19DDmKHz-x58LaR8dt?U16%IsW4a6R#+

;%#yt&MJ3fGH6^trbtO$DE~UPuL8T$3VWp9!v8CyynW&{A z)KCp-rw%paQs!G0R2EVeRu)+niyF#A?G&MAYEUb6s1X;`Mi6Qu47Cu88puTHi%{|! zl)DaPc0qZAP}VS%GZtmcMEQzPwi=YH4rOvdd4eiK&>A8uV=L1uGb{I27FAYP)>PJ3 z)>Sr9IV}Ri$1dh#^fd+UE##n2tGd3ArvVF6IvO}`NvLmx& zv(vLPv-f5fWmjj{WY=cbWjAHJ_zXZM(?Y|`!7v7F1fzB zLAfEhVY!jHvAOBFnYnv&i*l>c3Tt@_bV2J2$_r82UOL*{-n^o`>b#n~+Pu2FraYH? z-~6Ebko>Ux$o$y+^!&{Hz4=A?)%i8~wfS}VP5CZpp+RV!VQ87LXqA}-dkcyRstalg zY76QLnhIPBeG7vMLkhzRBMV~-(+e{T>Ez;?i~dpd|A9VhF0>R{3t5q>D6mLfq$$!C z>52?R8AVw|#-gesQ<1sIQe-V+#j4`KVs){mSX-2I6?&{0 zz151IswxXCQ^f)7Wn+ZM5f?meZ!vZVS7@xG2x=KT3MrBr|v9hYtRB5iXR9dM$ z;tEaIVP;er1C45<#;7&wj0TKgSwdpSCLm zb{cT60MMYd7NMoqp_PVUG>^o1z8B*pD|SJB`=Z8!Q0F12^|0bd)O##yJ{@(RiP|@z QpQ}m{$^YH{TWjF|0d~C~PXGV_ literal 0 HcmV?d00001 diff --git a/testsuite/resources/Stair3/documentation/index.html b/testsuite/resources/Stair3/documentation/index.html new file mode 100644 index 000000000..ae5741b2d --- /dev/null +++ b/testsuite/resources/Stair3/documentation/index.html @@ -0,0 +1,91 @@ + + + Stair + + + +

+ +

Stair

+ +

The model generates time events every second and increments the variable counter.

+ + +

with the variables

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableStartUnitCausalityVariabilityDescription
timeindependentcontinuousSimulation time
counter1outputdiscretecounts the seconds
+ +

The plot shows the trajectories of the output variables computed with fmusim.

+ + 
fmusim --interface-type me --solver cvode --output-interval 1 --output-file Stair_out.csv Stair.fmu
+ +

plot

+ +
+ + \ No newline at end of file diff --git a/testsuite/resources/Stair3/documentation/result.svg b/testsuite/resources/Stair3/documentation/result.svg new file mode 100644 index 000000000..f2fff424c --- /dev/null +++ b/testsuite/resources/Stair3/documentation/result.svg @@ -0,0 +1 @@ +02468246810time [s]counter \ No newline at end of file diff --git a/testsuite/resources/Stair3/modelDescription.xml b/testsuite/resources/Stair3/modelDescription.xml new file mode 100644 index 000000000..c83849dbf --- /dev/null +++ b/testsuite/resources/Stair3/modelDescription.xml @@ -0,0 +1,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testsuite/resources/Stair3/sources/buildDescription.xml b/testsuite/resources/Stair3/sources/buildDescription.xml new file mode 100644 index 000000000..0cdb4c297 --- /dev/null +++ b/testsuite/resources/Stair3/sources/buildDescription.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/testsuite/resources/Stair3/sources/config.h b/testsuite/resources/Stair3/sources/config.h new file mode 100644 index 000000000..dcbdb2d67 --- /dev/null +++ b/testsuite/resources/Stair3/sources/config.h @@ -0,0 +1,29 @@ +#ifndef config_h +#define config_h + +// define class name and unique id +#define MODEL_IDENTIFIER Stair +#define INSTANTIATION_TOKEN "{BD403596-3166-4232-ABC2-132BDF73E644}" + +#define CO_SIMULATION +#define MODEL_EXCHANGE + +#define GET_INT32 +#define SET_INT32 + +#define EVENT_UPDATE + +#define FIXED_SOLVER_STEP 0.2 +#define DEFAULT_STOP_TIME 10 + +typedef enum { + vr_time, vr_counter +} ValueReference; + +typedef struct { + + int counter; + +} ModelData; + +#endif /* config_h */ diff --git a/testsuite/resources/Stair3/sources/cosimulation.c b/testsuite/resources/Stair3/sources/cosimulation.c new file mode 100644 index 000000000..782edf1b2 --- /dev/null +++ b/testsuite/resources/Stair3/sources/cosimulation.c @@ -0,0 +1,691 @@ +#include // for calloc(), free() +#include // for DBL_EPSILON +#include +#include +#include +#include "config.h" +#include "cosimulation.h" + +#if FMI_VERSION == 3 +#include "fmi3Functions.h" +#endif + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#ifdef CALL +#undef CALL +#endif + +#define CALL(f) do { const Status status = f; if (status != OK) return status; } while (false) + + +ModelInstance *createModelInstance( + loggerType cbLogger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType) { + + ModelInstance *comp = NULL; + + if (!instanceName || strlen(instanceName) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, "?", Error, "error", "Missing instance name."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instance name."); +#endif + } + return NULL; + } + + if (!instantiationToken || strlen(instantiationToken) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Missing GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instantiationToken."); +#endif + } + return NULL; + } + + if (strcmp(instantiationToken, INSTANTIATION_TOKEN)) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Wrong GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Wrong instantiationToken."); +#endif + } + return NULL; + } + + comp = (ModelInstance *)calloc(1, sizeof(ModelInstance)); + + if (comp) { + comp->componentEnvironment = componentEnvironment; + comp->logger = cbLogger; + comp->intermediateUpdate = intermediateUpdate; + comp->lockPreemption = NULL; + comp->unlockPreemption = NULL; + comp->instanceName = strdup(instanceName); + comp->resourceLocation = resourceLocation ? strdup(resourceLocation) : NULL; + comp->status = OK; + comp->logEvents = loggingOn; + comp->logErrors = true; // always log errors + comp->nSteps = 0; + comp->earlyReturnAllowed = false; + comp->eventModeUsed = false; + } + + if (!comp || !comp->instanceName) { + logError(comp, "Out of memory."); + return NULL; + } + + comp->time = 0.0; // overwrite in fmi*SetupExperiment, fmi*SetTime + comp->type = interfaceType; + + comp->state = Instantiated; + + comp->newDiscreteStatesNeeded = false; + comp->terminateSimulation = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->valuesOfContinuousStatesChanged = false; + comp->nextEventTimeDefined = false; + comp->nextEventTime = 0; + + setStartValues(comp); + + comp->isDirtyValues = true; + + return comp; +} + +void freeModelInstance(ModelInstance *comp) { + + if (!comp) return; + + if (comp->instanceName) free((void*)comp->instanceName); + + if (comp->resourceLocation) free((void*)comp->resourceLocation); + + if (comp->prez) free(comp->prez); + + if (comp->z) free(comp->z); + + if (comp->x) free(comp->x); + + if (comp->dx) free(comp->dx); + + free(comp); +} + +static Status s_reallocate(ModelInstance* comp, void** memory, size_t size) { + + if (size == 0) { + if (*memory) { + free(*memory); + } + *memory = NULL; + return OK; + } + + void* temp = realloc(*memory, size); + + if (!temp) { + logError(comp, "Failed to allocate memory."); + return Error; + } + + *memory = temp; + + return OK; +} + +Status configurate(ModelInstance* comp) { + + (void)comp; + +#ifdef HAS_EVENT_INDICATORS + comp->nz = getNumberOfEventIndicators(comp); + + if (comp->nz > 0) { + CALL(s_reallocate(comp, (void**)&comp->prez, comp->nz * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->z, comp->nz * sizeof(double))); + } + + CALL(getEventIndicators(comp, comp->prez, comp->nz)); +#endif + +#ifdef HAS_CONTINUOUS_STATES + comp->nx = getNumberOfContinuousStates(comp); + + if (comp->nx > 0) { + CALL(s_reallocate(comp, (void**)&comp->x, comp->nx * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->dx, comp->nx * sizeof(double))); + } +#endif + + return OK; +} + +Status reset(ModelInstance* comp) { + + comp->state = Instantiated; + comp->startTime = 0.0; + comp->time = 0.0; + comp->nSteps = 0; + comp->status = OK; + setStartValues(comp); + comp->isDirtyValues = true; + + return OK; +} + +#define EPSILON (1.0e-5) + +static double fmiAbs(double v) { + return v >= 0 ? v : -v; +} + +static double fmiMax(double a, double b) { + return (a < b) ? b : a; +} + +bool isClose(double a, double b) { + + if (fmiAbs(a - b) <= EPSILON) { + return true; + } + + return fmiAbs(a - b) <= EPSILON * fmiMax(fmiAbs(a), fmiAbs(b)); +} + +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected) { + + if (actual != expected) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = %d. Expected %d.", f, arg, actual, expected); + return true; + } + + return false; +} + +bool invalidState(ModelInstance *comp, const char *f, int statesExpected) { + + UNUSED(f); + UNUSED(statesExpected); + + if (!comp) { + return true; + } + + // TODO: add missing states and check state + return false; + +// if (!(comp->state & statesExpected)) { +// comp->state = modelError; +// logError(comp, "%s: Illegal call sequence.", f); +// return true; +// } +// +// return false; +} + +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p) { + + if (!p) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = NULL.", f, arg); + return true; + } + + return false; +} + +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]) { + + if (nCategories > 0) { + + if (categories == NULL) { + logError(comp, "Argument categories must not be NULL."); + return Error; + } + + for (size_t i = 0; i < nCategories; i++) { + + if (categories[i] == NULL) { + logError(comp, "Argument categories[%zu] must not be NULL.", i); + return Error; + } else if (strcmp(categories[i], "logEvents") == 0) { + comp->logEvents = loggingOn; + } else if (strcmp(categories[i], "logStatusError") == 0) { + comp->logErrors = loggingOn; + } else { + logError(comp, "Log categories[%zu] must be one of \"logEvents\" or \"logStatusError\" but was \"%s\".", i, categories[i]); + return Error; + } + } + + } else { + + comp->logEvents = loggingOn; + comp->logErrors = loggingOn; + + } + + return OK; +} + +static void logMessage(ModelInstance *comp, int status, const char *category, const char *message, va_list args) { + + if (!comp->logger) { + return; + } + + va_list args1; + int len = 0; + char *buf = ""; + + va_copy(args1, args); + len = vsnprintf(buf, len, message, args1); + va_end(args1); + + if (len < 0) { + return; + } + + va_copy(args1, args); + buf = (char *)calloc(len + 1, sizeof(char)); + len = vsnprintf(buf, len + 1, message, args); + va_end(args1); + + if (len >= 0) { + // no need to distinguish between FMI versions since we're not using variadic arguments +#if FMI_VERSION < 3 + comp->logger(comp->componentEnvironment, comp->instanceName, status, category, buf); +#else + comp->logger(comp->componentEnvironment, status, category, buf); +#endif + } + + free(buf); +} + +void logEvent(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logEvents) return; + + va_list args; + va_start(args, message); + logMessage(comp, OK, "logEvents", message, args); + va_end(args); +} + +void logError(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logErrors) return; + + va_list args; + va_start(args, message); + logMessage(comp, Error, "logStatusError", message, args); + va_end(args); +} + +#define GET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Getting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef GET_FLOAT32 +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + GET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef GET_INT8 +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef GET_UINT8 +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef GET_INT16 +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int16"); + +} +#endif + +#ifndef GET_UINT16 +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef GET_INT32 +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef GET_UINT32 +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef GET_INT64 +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef GET_UINT64 +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef GET_BOOLEAN +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef GET_STRING +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("String"); +} +#endif + +#ifndef GET_BINARY +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index) { + UNUSED(sizes); + GET_NOT_ALLOWED("Binary"); +} +#endif + +#define SET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Setting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef SET_FLOAT32 +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef SET_FLOAT64 +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float64"); +} +#endif + +#ifndef SET_INT8 +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef SET_UINT8 +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef SET_INT16 +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int16"); +} +#endif + +#ifndef SET_UINT16 +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef SET_INT32 +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef SET_UINT32 +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef SET_INT64 +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef SET_UINT64 +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef SET_BOOLEAN +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef SET_STRING +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("String"); +} +#endif + +#ifndef SET_BINARY +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char *const values[], size_t nValues, size_t* index) { + UNUSED(size); + SET_NOT_ALLOWED("Binary"); +} +#endif + +#ifndef ACTIVATE_CLOCK +Status activateClock(ModelInstance* comp, ValueReference vr) { + UNUSED(comp); + UNUSED(vr); + return Error; +} +#endif + +#ifndef GET_CLOCK +Status getClock(ModelInstance* comp, ValueReference vr, bool* value) { + UNUSED(comp); + UNUSED(vr); + UNUSED(value); + return Error; +} +#endif + +#ifndef GET_INTERVAL +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier) { + UNUSED(comp); + UNUSED(vr); + UNUSED(interval); + UNUSED(qualifier); + return Error; +} +#endif + +#ifndef ACTIVATE_MODEL_PARTITION +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime) { + UNUSED(comp); + UNUSED(vr); + UNUSED(activationTime); + return Error; +} +#endif + +#ifndef GET_PARTIAL_DERIVATIVE +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + UNUSED(comp); + UNUSED(unknown); + UNUSED(known); + UNUSED(partialDerivative); + logError(comp, "Directional derivatives are not supported."); + return Error; +} +#endif + +Status getFMUState(ModelInstance* comp, void** FMUState) { + + CALL(s_reallocate(comp, FMUState, sizeof(ModelInstance))); + + memcpy(*FMUState, comp, sizeof(ModelInstance)); + + return OK; +} + +Status setFMUState(ModelInstance* comp, void* FMUState) { + + ModelInstance* s = (ModelInstance*)FMUState; + + comp->startTime = s->startTime; + comp->stopTime = s->stopTime; + comp->time = s->time; + // instanceName + // type + // resourceLocation + + comp->status = s->status; + + // logger + // intermediateUpdate + // clockUpdate + + // lockPreemption + // unlockPreemption + + // logEvents + // logErrors + + // componentEnvironment + comp->state = s->state; + + comp->newDiscreteStatesNeeded = s->newDiscreteStatesNeeded; + comp->terminateSimulation = s->terminateSimulation; + comp->nominalsOfContinuousStatesChanged = s->nominalsOfContinuousStatesChanged; + comp->valuesOfContinuousStatesChanged = s->valuesOfContinuousStatesChanged; + comp->nextEventTimeDefined = s->nextEventTimeDefined; + comp->nextEventTime = s->nextEventTime; + comp->clocksTicked = s->clocksTicked; + + comp->isDirtyValues = s->isDirtyValues; + + comp->modelData = s->modelData; + + comp->nSteps = s->nSteps; + + comp->earlyReturnAllowed = s->earlyReturnAllowed; + comp->eventModeUsed = s->eventModeUsed; + comp->nextCommunicationPoint = s->nextCommunicationPoint; + + if (comp->nx > 0) { + memcpy(comp->x, s->x, s->nx * sizeof(double)); + memcpy(comp->dx, s->dx, s->nx * sizeof(double)); + } + + if (comp->nz > 0) { + memcpy(comp->z, s->z, s->nz * sizeof(double)); + } + + comp->nSteps = s->nSteps; + + return OK; +} + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent) { + +#ifdef HAS_CONTINUOUS_STATES + if (comp->nx > 0) { + + CALL(getContinuousStates(comp, comp->x, comp->nx)); + CALL(getDerivatives(comp, comp->dx, comp->nx)); + + // forward Euler step + for (size_t i = 0; i < comp->nx; i++) { + comp->x[i] += FIXED_SOLVER_STEP * comp->dx[i]; + } + + CALL(setContinuousStates(comp, comp->x, comp->nx)); + } +#endif + + comp->nSteps++; + + comp->time = comp->startTime + comp->nSteps * FIXED_SOLVER_STEP; + + // state event + *stateEvent = false; + +#ifdef HAS_EVENT_INDICATORS + if (comp->nz > 0) { + + CALL(getEventIndicators(comp, comp->z, comp->nz)); + + // check for zero-crossings + for (size_t i = 0; i < comp->nz; i++) { + *stateEvent |= + (comp->prez[i] <= 0 && comp->z[i] > 0) || + (comp->prez[i] > 0 && comp->z[i] <= 0); + } + + // remember the current event indicators + double* temp = comp->prez; + comp->prez = comp->z; + comp->z = temp; + } +#endif + + // time event + *timeEvent = comp->nextEventTimeDefined && comp->time >= comp->nextEventTime; + + bool earlyReturnRequested; + double earlyReturnTime; + + // intermediate update + if (comp->intermediateUpdate) { + comp->intermediateUpdate( + comp->componentEnvironment, // instanceEnvironment + comp->time, // intermediateUpdateTime + false, // intermediateVariableSetRequested + true, // intermediateVariableGetAllowed + true, // intermediateStepFinished + false, // canReturnEarly + &earlyReturnRequested, // earlyReturnRequested + &earlyReturnTime); // earlyReturnTime + } + + return OK; +} diff --git a/testsuite/resources/Stair3/sources/cosimulation.h b/testsuite/resources/Stair3/sources/cosimulation.h new file mode 100644 index 000000000..fda1ebf99 --- /dev/null +++ b/testsuite/resources/Stair3/sources/cosimulation.h @@ -0,0 +1,5 @@ +#pragma once + +#include "model.h" + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent); diff --git a/testsuite/resources/Stair3/sources/fmi3Functions.c b/testsuite/resources/Stair3/sources/fmi3Functions.c new file mode 100644 index 000000000..b4ad5fbb2 --- /dev/null +++ b/testsuite/resources/Stair3/sources/fmi3Functions.c @@ -0,0 +1,1446 @@ +#if FMI_VERSION != 3 +#error FMI_VERSION must be 3 +#endif + +#include +#include +#include +#include +#include + +#include "config.h" +#include "model.h" +#include "cosimulation.h" + +// C-code FMUs have functions names prefixed with MODEL_IDENTIFIER_. +// Define DISABLE_PREFIX to build a binary FMU. +#if !defined(DISABLE_PREFIX) && !defined(FMI3_FUNCTION_PREFIX) +#define pasteA(a,b) a ## b +#define pasteB(a,b) pasteA(a,b) +#define FMI3_FUNCTION_PREFIX pasteB(MODEL_IDENTIFIER, _) +#endif +#include "fmi3Functions.h" + +#define ASSERT_NOT_NULL(p) \ +do { \ + if (!p) { \ + logError(S, "Argument %s must not be NULL.", xstr(p)); \ + S->state = Terminated; \ + return (fmi3Status)Error; \ + } \ +} while (0) + +#define CALL(f) do { \ + const Status s = f; \ + if (s > status) { \ + status = s; \ + } \ + if (status == Discard) { \ + goto TERMINATE; \ + } else if (status == Error) { \ + S->state = Terminated; \ + goto TERMINATE; \ + } else if (status == Fatal) { \ + S->state = StartAndEnd; \ + goto TERMINATE; \ + } \ +} while (false) + +#define GET_VARIABLES(T) \ +BEGIN_FUNCTION(Get ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +if (nValues > 0) ASSERT_NOT_NULL(values); \ +if (S->isDirtyValues) { \ + CALL(calculateValues(S)); \ + S->isDirtyValues = false; \ +} \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(get ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#define SET_VARIABLES(T) \ +BEGIN_FUNCTION(Set ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(set ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (nValueReferences > 0) S->isDirtyValues = true; \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#ifndef max +#define max(a,b) ((a)>(b) ? (a) : (b)) +#endif + +#ifndef DT_EVENT_DETECT +#define DT_EVENT_DETECT 1e-10 +#endif + +// --------------------------------------------------------------------------- +// Function calls allowed state masks for both Model-exchange and Co-simulation +// --------------------------------------------------------------------------- +#define MASK_AnyState (~0) + +/* Inquire version numbers and set debug logging */ +#define MASK_fmi3GetVersion MASK_AnyState +#define MASK_fmi3SetDebugLogging MASK_AnyState + +/* Creation and destruction of FMU instances */ +#define MASK_fmi3InstantiateInstantiateModelExchange MASK_AnyState +#define MASK_fmi3InstantiateCoSimulation MASK_AnyState +#define MASK_fmi3InstantiateScheduledExectuion MASK_AnyState +#define MASK_fmi3FreeInstance MASK_AnyState + +/* Enter and exit initialization mode, terminate and reset */ +#define MASK_fmi3EnterInitializationMode Instantiated +#define MASK_fmi3ExitInitializationMode InitializationMode +#define MASK_fmi3EnterEventMode (ContinuousTimeMode | StepMode) +#define MASK_fmi3Terminate (ContinuousTimeMode | StepMode | StepDiscarded | EventMode | ClockActivationMode | ReconfigurationMode) +#define MASK_fmi3Reset MASK_AnyState + +/* Common Functions */ + +/* Getting and setting variable values */ +#define MASK_fmi3GetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3GetFloat64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetBoolean MASK_fmi3GetFloat32 +#define MASK_fmi3GetString MASK_fmi3GetFloat32 +#define MASK_fmi3GetBinary MASK_fmi3GetFloat32 +#define MASK_fmi3GetClock MASK_AnyState + +#define MASK_fmi3SetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3SetFloat64 MASK_fmi3SetFloat32 +#define MASK_fmi3SetInt8 (Instantiated | ConfigurationMode | ReconfigurationMode | InitializationMode | EventMode | StepMode | ClockActivationMode | Terminated) +#define MASK_fmi3SetUInt8 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetBoolean MASK_fmi3SetInt8 +#define MASK_fmi3SetString MASK_fmi3SetInt8 +#define MASK_fmi3SetBinary MASK_fmi3SetInt8 +#define MASK_fmi3SetClock MASK_AnyState + +/* Getting Variable Dependency Information */ +#define MASK_fmi3GetNumberOfVariableDependencies MASK_AnyState +#define MASK_fmi3GetVariableDependencies MASK_AnyState + +/* Getting and setting the internal FMU state */ +#define MASK_fmi3GetFMUState MASK_AnyState +#define MASK_fmi3SetFMUState MASK_AnyState +#define MASK_fmi3FreeFMUState MASK_AnyState +#define MASK_fmi3SerializedFMUStateSize MASK_AnyState +#define MASK_fmi3SerializeFMUState MASK_AnyState +#define MASK_fmi3DeserializeFMUState MASK_AnyState + +/* Getting partial derivatives */ +#define MASK_fmi3GetDirectionalDerivative (InitializationMode | StepMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetAdjointDerivative MASK_fmi3GetDirectionalDerivative + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define MASK_fmi3EnterConfigurationMode (Instantiated | StepMode | EventMode | ClockActivationMode) +#define MASK_fmi3ExitConfigurationMode (ConfigurationMode | ReconfigurationMode) + +/* Clock related functions */ +// TODO: fix masks +#define MASK_fmi3GetIntervalDecimal MASK_AnyState +#define MASK_fmi3GetIntervalFraction MASK_AnyState +#define MASK_fmi3SetIntervalDecimal MASK_AnyState +#define MASK_fmi3SetIntervalFraction MASK_AnyState +#define MASK_fmi3NewDiscreteStates MASK_AnyState + +/* Functions for Model Exchange */ + +#define MASK_fmi3EnterContinuousTimeMode EventMode +#define MASK_fmi3CompletedIntegratorStep ContinuousTimeMode + +/* Providing independent variables and re-initialization of caching */ +#define MASK_fmi3SetTime (EventMode | ContinuousTimeMode) +#define MASK_fmi3SetContinuousStates ContinuousTimeMode + +/* Evaluation of the model equations */ +#define MASK_fmi3GetContinuousStateDerivatives (InitializationMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetEventIndicators MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetContinuousStates MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetNominalsOfContinuousStates MASK_fmi3GetContinuousStateDerivatives + +#define MASK_fmi3GetNumberOfContinuousStates MASK_AnyState +#define MASK_fmi3GetNumberOfEventIndicators MASK_AnyState + +/* Functions for Co-Simulation */ + +#define MASK_fmi3EnterStepMode (InitializationMode | EventMode) +#define MASK_fmi3SetInputDerivatives (Instantiated | InitializationMode | StepMode) +#define MASK_fmi3GetOutputDerivatives (StepMode | StepDiscarded | Terminated) +#define MASK_fmi3DoStep StepMode +#define MASK_fmi3ActivateModelPartition ClockActivationMode +#define MASK_fmi3DoEarlyReturn IntermediateUpdateMode +#define MASK_fmi3GetDoStepDiscardedStatus StepMode + +// --------------------------------------------------------------------------- +// Private helpers used below to validate function arguments +// --------------------------------------------------------------------------- + +#define NOT_IMPLEMENTED \ +do { \ + ModelInstance *comp = (ModelInstance *)instance; \ + logError(comp, "Function is not implemented."); \ + return fmi3Error; \ +} while (0) + +#define BEGIN_FUNCTION(F) \ +Status status = OK; \ +if (!instance) return fmi3Error; \ +ModelInstance *S = (ModelInstance *)instance; \ +if (!allowedState(S, MASK_fmi3##F, #F)) CALL(Error); + +#define END_FUNCTION() \ +TERMINATE: \ + return (fmi3Status)status; + +static bool allowedState(ModelInstance *instance, int statesExpected, char *name) { + + if (!instance) { + return false; + } + + if (!(instance->state & statesExpected)) { + logError(instance, "fmi3%s: Illegal call sequence.", name); + return false; + } + + return true; +} + +/*************************************************** + Common Functions + ****************************************************/ + +const char* fmi3GetVersion(void) { + return fmi3Version; +} + +fmi3Status fmi3SetDebugLogging(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]) { + + BEGIN_FUNCTION(SetDebugLogging); + + CALL(setDebugLogging(S, loggingOn, nCategories, categories)); + + END_FUNCTION(); +} + +fmi3Instance fmi3InstantiateModelExchange( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage) { + + UNUSED(visible); + +#ifndef MODEL_EXCHANGE + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + + return NULL; +#else + return createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ModelExchange); +#endif +} + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) { + + UNUSED(visible); + UNUSED(requiredIntermediateVariables); + UNUSED(nRequiredIntermediateVariables); + +#ifndef EVENT_UPDATE + if (eventModeUsed) { + if (logMessage) { + logMessage(instanceEnvironment, fmi3Error, "error", "Event Mode is not supported."); + } + return NULL; + } +#endif + + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + (intermediateUpdateType)intermediateUpdate, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + CoSimulation); + + if (instance) { + instance->earlyReturnAllowed = earlyReturnAllowed; + instance->eventModeUsed = eventModeUsed; + instance->state = Instantiated; + } + + return instance; +} + +fmi3Instance fmi3InstantiateScheduledExecution( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption) { + + UNUSED(visible); + +#ifndef SCHEDULED_CO_SIMULATION + + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + UNUSED(clockUpdate); + UNUSED(lockPreemption); + UNUSED(unlockPreemption); + + return NULL; +#else + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ScheduledExecution + ); + + if (instance) { + instance->state = Instantiated; + instance->clockUpdate = clockUpdate; + instance->lockPreemption = lockPreemption; + instance->unlockPreemption = unlockPreemption; + } + + return instance; +#endif +} + +void fmi3FreeInstance(fmi3Instance instance) { + freeModelInstance((ModelInstance*)instance); +} + +fmi3Status fmi3EnterInitializationMode(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime) { + + UNUSED(toleranceDefined); + UNUSED(tolerance); + + BEGIN_FUNCTION(EnterInitializationMode); + + S->startTime = startTime; + S->stopTime = stopTimeDefined ? stopTime : INFINITY; + S->time = startTime; + S->nextCommunicationPoint = startTime; + S->state = InitializationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitInitializationMode); + + // if values were set and no fmi3GetXXX triggered update before, + // ensure calculated values are updated now + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = S->eventModeUsed ? EventMode : StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + + CALL(configurate(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3EnterEventMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterEventMode); + + S->state = EventMode; + + END_FUNCTION(); +} + +fmi3Status fmi3Terminate(fmi3Instance instance) { + + BEGIN_FUNCTION(Terminate); + + S->state = Terminated; + + END_FUNCTION(); +} + +fmi3Status fmi3Reset(fmi3Instance instance) { + + BEGIN_FUNCTION(Reset); + + CALL(reset(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues) { + GET_VARIABLES(Float32); +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) { + GET_VARIABLES(Float64); +} + +fmi3Status fmi3GetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues) { + GET_VARIABLES(Int8); +} + +fmi3Status fmi3GetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues) { + GET_VARIABLES(UInt8); +} + +fmi3Status fmi3GetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues) { + GET_VARIABLES(Int16); +} + +fmi3Status fmi3GetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues) { + GET_VARIABLES(UInt16); +} + +fmi3Status fmi3GetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues) { + GET_VARIABLES(Int32); +} + +fmi3Status fmi3GetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues) { + GET_VARIABLES(UInt32); +} + +fmi3Status fmi3GetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues) { + GET_VARIABLES(Int64); +} + +fmi3Status fmi3GetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues) { + GET_VARIABLES(UInt64); +} + +fmi3Status fmi3GetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues) { + GET_VARIABLES(Boolean); +} + +fmi3Status fmi3GetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues) { + GET_VARIABLES(String); +} + +fmi3Status fmi3GetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(GetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } else { + ASSERT_NOT_NULL(valueReferences); + } + + if (nValues > 0) { + ASSERT_NOT_NULL(values); + } + + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char**)values, nValues, &index)); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]) { + + BEGIN_FUNCTION(GetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getClock(instance, (ValueReference)valueReferences[i], &values[i])); + } + END_FUNCTION(); +} + +fmi3Status fmi3SetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues) { + SET_VARIABLES(Float32); +} + +fmi3Status fmi3SetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues) { + SET_VARIABLES(Float64); +} + +fmi3Status fmi3SetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues) { + SET_VARIABLES(Int8); +} + +fmi3Status fmi3SetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues) { + SET_VARIABLES(UInt8); +} + +fmi3Status fmi3SetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues) { + SET_VARIABLES(Int16); +} + +fmi3Status fmi3SetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues) { + SET_VARIABLES(UInt16); +} + +fmi3Status fmi3SetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues) { + SET_VARIABLES(Int32); +} + +fmi3Status fmi3SetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues) { + SET_VARIABLES(UInt32); +} + +fmi3Status fmi3SetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues) { + SET_VARIABLES(Int64); +} + +fmi3Status fmi3SetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues) { + SET_VARIABLES(UInt64); +} + +fmi3Status fmi3SetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues) { + SET_VARIABLES(Boolean); +} + +fmi3Status fmi3SetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues) { + SET_VARIABLES(String); +} + +fmi3Status fmi3SetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(SetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } + + ASSERT_NOT_NULL(valueReferences); + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(setBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char* const*)values, nValues, &index)); + } + + if (nValueReferences > 0) { + S->isDirtyValues = true; + } + + if (index != nValues) { + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); + } + + END_FUNCTION(); +} + +fmi3Status fmi3SetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]) { + + BEGIN_FUNCTION(SetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + if (values[i]) { + CALL(activateClock(instance, (ValueReference)valueReferences[i])); + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfVariableDependencies(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies) { + UNUSED(valueReference); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetVariableDependencies(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies) { + + UNUSED(dependent); + UNUSED(elementIndicesOfDependent); + UNUSED(independents); + UNUSED(elementIndicesOfIndependents); + UNUSED(dependencyKinds); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(GetFMUState); + + CALL(getFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState FMUState) { + + BEGIN_FUNCTION(SetFMUState); + + if (nullPointer(S, "fmi3SetFMUState", "FMUState", FMUState)) { + return fmi3Error; + } + + CALL(setFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(FreeFMUState); + + free(*FMUState); + + *FMUState = NULL; + + END_FUNCTION(); +} + +fmi3Status fmi3SerializedFMUStateSize(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size) { + + UNUSED(instance); + UNUSED(FMUState); + + BEGIN_FUNCTION(SerializedFMUStateSize); + + *size = sizeof(ModelInstance); + + END_FUNCTION(); +} + +fmi3Status fmi3SerializeFMUState(fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size) { + + BEGIN_FUNCTION(SerializeFMUState); + + if (nullPointer(S, "fmi3SerializeFMUState", "FMUstate", FMUState)) { + return fmi3Error; + } + + if (invalidNumber(S, "fmi3SerializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + memcpy(serializedState, FMUState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3DeserializeFMUState(fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(DeserializeFMUState); + + if (invalidNumber(S, "fmi3DeserializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + if (*FMUState == NULL) { + *FMUState = calloc(1, sizeof(ModelInstance)); + if (*FMUState == NULL) { + printf("Failed to allocate memory for FMUState.\n"); + return fmi3Error; + } + } + + memcpy(*FMUState, serializedState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetDirectionalDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetDirectionalDerivative); + + // TODO: check value references + // TODO: assert nUnknowns == nDeltaOfUnknowns + // TODO: assert nKnowns == nDeltaKnowns + + for (size_t i = 0; i < nUnknowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nKnowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[i], (ValueReference)knowns[j], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetAdjointDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetAdjointDerivative); + + // TODO: check value references + + for (size_t i = 0; i < nKnowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nUnknowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[j], (ValueReference)knowns[i], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3EnterConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterConfigurationMode); + + S->state = (S->state == Instantiated) ? ConfigurationMode : ReconfigurationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitConfigurationMode); + + if (S->state == ConfigurationMode) { + S->state = Instantiated; + } else { + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + } + +#if defined(HAS_CONTINUOUS_STATES) || defined(HAS_EVENT_INDICATORS) + CALL(configurate(S)); +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]) { + + BEGIN_FUNCTION(GetIntervalDecimal); + + // TODO: Check nValueReferences != nValues ? + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getInterval(instance, (ValueReference)valueReferences[i], &intervals[i], (int*)&qualifiers[i])); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 intervalCounters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + UNUSED(qualifiers); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 shiftCounters[], + fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervals); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 intervalCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 shiftCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3EvaluateDiscreteStates(fmi3Instance instance) { + NOT_IMPLEMENTED; +} + +fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime) { + + BEGIN_FUNCTION(NewDiscreteStates); + +#ifdef EVENT_UPDATE + CALL(eventUpdate(S)); +#endif + + // copy internal eventInfo of component to output arguments + if (discreteStatesNeedUpdate) *discreteStatesNeedUpdate = S->newDiscreteStatesNeeded; + if (terminateSimulation) *terminateSimulation = S->terminateSimulation; + if (nominalsOfContinuousStatesChanged) *nominalsOfContinuousStatesChanged = S->nominalsOfContinuousStatesChanged; + if (valuesOfContinuousStatesChanged) *valuesOfContinuousStatesChanged = S->valuesOfContinuousStatesChanged; + if (nextEventTimeDefined) *nextEventTimeDefined = S->nextEventTimeDefined; + if (nextEventTime) *nextEventTime = S->nextEventTime; + + END_FUNCTION(); +} + +/*************************************************** + Functions for Model Exchange + ****************************************************/ + +fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterContinuousTimeMode); + + S->state = ContinuousTimeMode; + + END_FUNCTION(); +} + +fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(CompletedIntegratorStep); + + ASSERT_NOT_NULL(enterEventMode); + ASSERT_NOT_NULL(terminateSimulation); + + *enterEventMode = fmi3False; + *terminateSimulation = fmi3False; + + END_FUNCTION(); +} + +/* Providing independent variables and re-initialization of caching */ +fmi3Status fmi3SetTime(fmi3Instance instance, fmi3Float64 time) { + + BEGIN_FUNCTION(SetTime); + + S->time = time; + + END_FUNCTION(); +} + +fmi3Status fmi3SetContinuousStates(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(SetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3SetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + ASSERT_NOT_NULL(continuousStates); + + CALL(setContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +/* Evaluation of the model equations */ +fmi3Status fmi3GetContinuousStateDerivatives(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStateDerivatives); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStateDerivatives", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStateDerivatives", "derivatives[]", derivatives)) + return fmi3Error; + + CALL(getDerivatives(S, derivatives, nContinuousStates)); +#else + UNUSED(derivatives); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetEventIndicators(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators) { + + BEGIN_FUNCTION(GetEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + if (invalidNumber(S, "fmi3GetEventIndicators", "nEventIndicators", nEventIndicators, getNumberOfEventIndicators(S))) { + return fmi3Error; + } + + CALL(getEventIndicators(S, eventIndicators, nEventIndicators)); +#else + + UNUSED(eventIndicators); + + if (nEventIndicators > 0) { + // TODO: log error + return fmi3Error; + } +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetContinuousStates(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStates", "continuousStates[]", continuousStates)) + return fmi3Error; + + CALL(getContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNominalsOfContinuousStates(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetNominalsOfContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetNominalContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(instance))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetNominalContinuousStates", "nominals[]", nominals)) + return fmi3Error; + + for (size_t i = 0; i < nContinuousStates; i++) { + nominals[i] = 1; + } + + return fmi3OK; +#else + UNUSED(nominals); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfEventIndicators(fmi3Instance instance, + size_t* nEventIndicators) { + + BEGIN_FUNCTION(GetNumberOfEventIndicators); + + ASSERT_NOT_NULL(nEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + *nEventIndicators = getNumberOfEventIndicators(instance); +#else + *nEventIndicators = 0; +#endif + + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfContinuousStates(fmi3Instance instance, + size_t* nContinuousStates) { + + BEGIN_FUNCTION(GetNumberOfContinuousStates); + + ASSERT_NOT_NULL(nContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + *nContinuousStates = getNumberOfContinuousStates(instance); +#else + *nContinuousStates = 0; +#endif + + END_FUNCTION(); +} + +/*************************************************** + Functions for Co-Simulation + ****************************************************/ + +fmi3Status fmi3EnterStepMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterStepMode); + + S->state = StepMode; + + END_FUNCTION(); +} + +fmi3Status fmi3GetOutputDerivatives(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues) { + + UNUSED(nValues); + + BEGIN_FUNCTION(GetOutputDerivatives); + +#ifdef GET_OUTPUT_DERIVATIVE + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getOutputDerivative(S, (ValueReference)valueReferences[i], orders[i], &values[i])); + } +#else + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(orders); + UNUSED(values); + + NOT_IMPLEMENTED; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(DoStep); + + if (!isClose(currentCommunicationPoint, S->nextCommunicationPoint)) { + logError(S, "Expected currentCommunicationPoint = %.16g but was %.16g.", + S->nextCommunicationPoint, currentCommunicationPoint); + CALL(Error); + } + + if (communicationStepSize <= 0) { + logError(S, "Communication step size must be > 0 but was %.16g.", communicationStepSize); + CALL(Error); + } + + const fmi3Float64 nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + + if (nextCommunicationPoint > S->stopTime && !isClose(nextCommunicationPoint, S->stopTime)) { + logError(S, "At communication point %.16g a step size of %.16g was requested but stop time is %.16g.", + currentCommunicationPoint, communicationStepSize, S->stopTime); + CALL(Error); + } + + bool nextCommunicationPointReached; + + *eventHandlingNeeded = fmi3False; + *terminateSimulation = fmi3False; + *earlyReturn = fmi3False; + + while (true) { + + const fmi3Float64 nextSolverStepTime = S->time + FIXED_SOLVER_STEP; + + nextCommunicationPointReached = nextSolverStepTime > nextCommunicationPoint && !isClose(nextSolverStepTime, nextCommunicationPoint); + + if (nextCommunicationPointReached || (*eventHandlingNeeded && S->earlyReturnAllowed)) { + break; + } + +#ifdef EVENT_UPDATE + if (*eventHandlingNeeded) { + eventUpdate(S); + *eventHandlingNeeded = fmi3False; + } +#endif + + bool stateEvent, timeEvent; + + CALL(doFixedStep(S, &stateEvent, &timeEvent)); + +#ifdef EVENT_UPDATE + if (stateEvent || timeEvent) { + + if (S->eventModeUsed) { + *eventHandlingNeeded = fmi3True; + } else { + CALL(eventUpdate(S)); +#ifdef HAS_EVENT_INDICATORS + CALL(getEventIndicators(S, S->prez, S->nz)); +#endif + } + + if (S->earlyReturnAllowed) { + break; + } + } +#endif + + if (S->terminateSimulation) { + break; + } + } + + *terminateSimulation = S->terminateSimulation; + *earlyReturn = S->earlyReturnAllowed && !nextCommunicationPointReached; + *lastSuccessfulTime = S->time; + + if (nextCommunicationPointReached) { + S->nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + } else { + S->nextCommunicationPoint = S->time; + } + + END_FUNCTION(); +} + +fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime) { + + BEGIN_FUNCTION(ActivateModelPartition); + + CALL(activateModelPartition(S, (ValueReference)clockReference, activationTime)); + + END_FUNCTION(); +} diff --git a/testsuite/resources/Stair3/sources/model.c b/testsuite/resources/Stair3/sources/model.c new file mode 100644 index 000000000..0126621f4 --- /dev/null +++ b/testsuite/resources/Stair3/sources/model.c @@ -0,0 +1,105 @@ +#include "model.h" + + +static void calculateCounter(ModelInstance* comp) { + + if (comp->nextEventTimeDefined && isClose(comp->time, comp->nextEventTime)) { + M(counter)++; + comp->nextEventTime += 1; + } +} + +void setStartValues(ModelInstance *comp) { + M(counter) = 1; + + // TODO: move this to initialize()? + comp->nextEventTime = 1; + comp->nextEventTimeDefined = true; +} + +Status calculateValues(ModelInstance *comp) { + UNUSED(comp); + // nothing to do + return OK; +} + +Status getFloat64(ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_time: + values[(*index)++] = comp->time; + return OK; + default: + logError(comp, "Get Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_counter: +#if FMI_VERSION == 3 + if (comp->state == EventMode) { + calculateCounter(comp); + } +#endif + values[(*index)++] = M(counter); + return OK; + default: + logError(comp, "Get Int32 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_counter: +#if FMI_VERSION == 1 + if (comp->state != Instantiated) { + logError(comp, "Variable \"counter\" can only be set after instantiation."); + return Error; + } +#else + if (comp->state != Instantiated && comp->state != InitializationMode) { + logError(comp, "Variable \"counter\" can only be set in Instantiated and Intialization Mode."); + return Error; + } +#endif + if (values[*index] >= 10) { + logError(comp, "The maximum value for variable \"counter\" is 10."); + return Error; + } + + M(counter) = values[(*index)++]; + + return OK; + default: + logError(comp, "Set Int32 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status eventUpdate(ModelInstance *comp) { + + calculateCounter(comp); + + if (M(counter) > 10) { + logError(comp, "Variable \"counter\" cannot be incremented for values >= 10."); + return Error; + } + + comp->valuesOfContinuousStatesChanged = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->terminateSimulation = M(counter) >= 10; + comp->nextEventTimeDefined = true; + + return OK; +} diff --git a/testsuite/resources/Stair3/sources/model.h b/testsuite/resources/Stair3/sources/model.h new file mode 100644 index 000000000..8dabb0cad --- /dev/null +++ b/testsuite/resources/Stair3/sources/model.h @@ -0,0 +1,250 @@ +#pragma once + +#if FMI_VERSION != 1 && FMI_VERSION != 2 && FMI_VERSION != 3 +#error FMI_VERSION must be one of 1, 2 or 3 +#endif + +#define UNUSED(x) (void)(x) + +#include // for size_t +#include // for bool +#include + +#include "config.h" + +#if FMI_VERSION == 1 + +#define not_modelError (Instantiated| Initialized | Terminated) + +typedef enum { + Instantiated = 1<<0, + Initialized = 1<<1, + Terminated = 1<<2, + modelError = 1<<3 +} ModelState; + +#elif FMI_VERSION == 2 + +typedef enum { + StartAndEnd = 1<<0, + Instantiated = 1<<1, + InitializationMode = 1<<2, + + // ME states + EventMode = 1<<3, + ContinuousTimeMode = 1<<4, + + // CS states + StepComplete = 1<<5, + StepInProgress = 1<<6, + StepFailed = 1<<7, + StepCanceled = 1<<8, + + Terminated = 1<<9, +} ModelState; + +#else + +typedef enum { + StartAndEnd = 1 << 0, + ConfigurationMode = 1 << 1, + Instantiated = 1 << 2, + InitializationMode = 1 << 3, + EventMode = 1 << 4, + ContinuousTimeMode = 1 << 5, + StepMode = 1 << 6, + ClockActivationMode = 1 << 7, + StepDiscarded = 1 << 8, + ReconfigurationMode = 1 << 9, + IntermediateUpdateMode = 1 << 10, + Terminated = 1 << 11, +} ModelState; + +#endif + +typedef enum { + ModelExchange, + CoSimulation, + ScheduledExecution, +} InterfaceType; + +typedef enum { + OK, + Warning, + Discard, + Error, + Fatal, + Pending +} Status; + +#if FMI_VERSION < 3 +typedef void (*loggerType) (void *componentEnvironment, const char *instanceName, int status, const char *category, const char *message, ...); +#else +typedef void (*loggerType) (void *componentEnvironment, int status, const char *category, const char *message); +#endif + +typedef void (*lockPreemptionType) (void); +typedef void (*unlockPreemptionType) (void); + + +typedef void (*intermediateUpdateType) (void *instanceEnvironment, + double intermediateUpdateTime, + bool intermediateVariableSetRequested, + bool intermediateVariableGetAllowed, + bool intermediateStepFinished, + bool canReturnEarly, + bool *earlyReturnRequested, + double *earlyReturnTime); + +typedef void(*clockUpdateType) (void *instanceEnvironment); + +typedef struct { + + double startTime; + double stopTime; + double time; + const char *instanceName; + InterfaceType type; + const char *resourceLocation; + + Status status; + + // callback functions + loggerType logger; + intermediateUpdateType intermediateUpdate; + clockUpdateType clockUpdate; + + lockPreemptionType lockPreemption; + unlockPreemptionType unlockPreemption; + + bool logEvents; + bool logErrors; + + void *componentEnvironment; + ModelState state; + + // event info + bool newDiscreteStatesNeeded; + bool terminateSimulation; + bool nominalsOfContinuousStatesChanged; + bool valuesOfContinuousStatesChanged; + bool nextEventTimeDefined; + double nextEventTime; + bool clocksTicked; + + bool isDirtyValues; + + ModelData modelData; + + // internal solver steps + uint64_t nSteps; + + // Co-Simulation + bool earlyReturnAllowed; + bool eventModeUsed; + double nextCommunicationPoint; + + // solver + size_t nz; + double* z; + double* prez; + + size_t nx; + double* x; + double* dx; + +} ModelInstance; + +ModelInstance *createModelInstance( + loggerType logger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType); + +void freeModelInstance(ModelInstance *comp); + +Status configurate(ModelInstance* comp); + +Status reset(ModelInstance* comp); + +void setStartValues(ModelInstance* comp); + +Status calculateValues(ModelInstance *comp); + +Status getFloat32 (ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t *index); +Status getFloat64 (ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t *index); +Status getInt8 (ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index); +Status getUInt8 (ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index); +Status getInt16 (ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index); +Status getUInt16 (ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index); +Status getInt32 (ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index); +Status getUInt32 (ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index); +Status getInt64 (ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index); +Status getUInt64 (ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index); +Status getBoolean (ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index); +Status getString (ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index); +Status getBinary (ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index); + +Status setFloat32 (ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t *index); +Status setFloat64 (ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t *index); +Status setInt8 (ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t *index); +Status setUInt8 (ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t *index); +Status setInt16 (ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t *index); +Status setUInt16 (ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t *index); +Status setInt32 (ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t *index); +Status setUInt32 (ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t *index); +Status setInt64 (ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t *index); +Status setUInt64 (ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t *index); +Status setBoolean (ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t *index); +Status setString (ModelInstance* comp, ValueReference vr, const char* const values[], size_t nValues, size_t *index); +Status setBinary (ModelInstance* comp, ValueReference vr, const size_t sizes[], const char* const values[], size_t nValues, size_t *index); + +Status activateClock(ModelInstance* comp, ValueReference vr); +Status getClock(ModelInstance* comp, ValueReference vr, bool* value); +Status setClock(ModelInstance* comp, ValueReference vr, const bool* value); + +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier); + +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime); + +size_t getNumberOfEventIndicators(ModelInstance* comp); +size_t getNumberOfContinuousStates(ModelInstance* comp); +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx); +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx); +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx); +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value); +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative); +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz); +Status eventUpdate(ModelInstance *comp); + +bool isClose(double a, double b); +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected); +bool invalidState(ModelInstance *comp, const char *f, int statesExpected); +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p); +void logError(ModelInstance *comp, const char *message, ...); +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]); +void logEvent(ModelInstance *comp, const char *message, ...); +void logError(ModelInstance *comp, const char *message, ...); + +Status getFMUState(ModelInstance* comp, void** FMUState); +Status setFMUState(ModelInstance* comp, void* FMUState); + +// shorthand to access the variables +#define M(v) (comp->modelData.v) + +// "stringification" macros +#define xstr(s) str(s) +#define str(s) #s + +// assert size of nValues for scalar variables +#define ASSERT_NVALUES(N) do { \ + const size_t expected_nValues = *index + (N); \ + if (expected_nValues > nValues) { \ + logError(comp, "Expected nValues >= %zu but was %zu.", expected_nValues, nValues); \ + return Error; \ + } \ +} while (0) From 94e3de3cc46dd3121da76bcb66fbef6add0e4968 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 19 Dec 2024 00:03:06 +0100 Subject: [PATCH 09/32] fix switch cases --- src/OMSimulatorLib/ComponentFMU3CS.cpp | 47 ++++++++++++++++++-------- 1 file changed, 32 insertions(+), 15 deletions(-) diff --git a/src/OMSimulatorLib/ComponentFMU3CS.cpp b/src/OMSimulatorLib/ComponentFMU3CS.cpp index a02579335..057331bb9 100644 --- a/src/OMSimulatorLib/ComponentFMU3CS.cpp +++ b/src/OMSimulatorLib/ComponentFMU3CS.cpp @@ -973,16 +973,20 @@ oms_status_enu_t oms::ComponentFMU3CS::getInteger(const fmi3ValueReference& vr, switch (numericType) { case oms_signal_numeric_type_INT64: + { if (fmi3OK != fmi3_getInt64(fmu, &vr, 1, &value64, 1)) return oms_status_error; if (value64 < INT_MIN || value64 > INT_MAX) return oms_status_error; // Value out of range for int value = static_cast(value64); // Cast to int break; + } case oms_signal_numeric_type_INT32: + { if (fmi3OK != fmi3_getInt32(fmu, &vr, 1, &value, 1)) return oms_status_error; break; + } default : return oms_status_error; } @@ -1087,20 +1091,22 @@ oms_status_enu_t oms::ComponentFMU3CS::getReal(const fmi3ValueReference& vr, dou switch (numericType) { case oms_signal_numeric_type_FLOAT64: + { if (fmi3OK != fmi3_getFloat64(fmu, &vr, 1, &value, 1)) return oms_status_error; break; - + } case oms_signal_numeric_type_FLOAT32: + { float value_; if (fmi3OK != fmi3_getFloat32(fmu, &vr, 1, &value_, 1)) return oms_status_error; // Convert the float to double and assign to 'value' value = static_cast(value_); break; - + } default: - oms_status_error; + return oms_status_error; } if (std::isnan(value)) @@ -1549,19 +1555,22 @@ oms_status_enu_t oms::ComponentFMU3CS::setInteger(const ComRef& cref, int value) int64_t value64; switch (allVariables[j].getNumericType()) { - case oms_signal_numeric_type_INT64: - value64 = static_cast(value); // Cast to int - if (fmi3OK != fmi3_setInt64(fmu, &vr, 1, &value64, 1)) - return oms_status_error; - break; - case oms_signal_numeric_type_INT32: - if (fmi3OK != fmi3_setInt32(fmu, &vr, 1, &value, 1)) + case oms_signal_numeric_type_INT64: + { + value64 = static_cast(value); // Cast to int + if (fmi3OK != fmi3_setInt64(fmu, &vr, 1, &value64, 1)) + return oms_status_error; + break; + } + case oms_signal_numeric_type_INT32: + { + if (fmi3OK != fmi3_setInt32(fmu, &vr, 1, &value, 1)) + return oms_status_error; + break; + } + default: return oms_status_error; - break; - default: - return oms_status_error; } - } return oms_status_ok; @@ -1621,12 +1630,20 @@ oms_status_enu_t oms::ComponentFMU3CS::setReal(const ComRef& cref, double value) switch (allVariables[j].getNumericType()) { case oms_signal_numeric_type_FLOAT64: + { if (fmi3OK != fmi3_setFloat64(fmu, &vr, 1, &value, 1)) return oms_status_error; + break; + } case oms_signal_numeric_type_FLOAT32: - float value_= value; + { + float value_= static_cast(value); if (fmi3OK != fmi3_setFloat32(fmu, &vr, 1, &value_, 1)) return oms_status_error; + break; + } + default: + return oms_status_error; } } From b5b32fe6a97368c31bc641840a8de3d46926b452 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 19 Dec 2024 12:57:32 +0100 Subject: [PATCH 10/32] add support for multiple numeric types --- src/OMSimulatorLib/ComponentFMU3CS.cpp | 102 +++++++++++++++++++++++-- src/OMSimulatorLib/Values.cpp | 21 ++++- src/OMSimulatorLib/Variable.cpp | 1 + 3 files changed, 118 insertions(+), 6 deletions(-) diff --git a/src/OMSimulatorLib/ComponentFMU3CS.cpp b/src/OMSimulatorLib/ComponentFMU3CS.cpp index 057331bb9..203098954 100644 --- a/src/OMSimulatorLib/ComponentFMU3CS.cpp +++ b/src/OMSimulatorLib/ComponentFMU3CS.cpp @@ -987,8 +987,50 @@ oms_status_enu_t oms::ComponentFMU3CS::getInteger(const fmi3ValueReference& vr, return oms_status_error; break; } + case oms_signal_numeric_type_INT16: + { + if (fmi3OK != fmi3_getInt16(fmu, &vr, 1, &value16, 1)) + return oms_status_error; + value = static_cast(value16); + break; + } + case oms_signal_numeric_type_INT8: + { + if (fmi3OK != fmi3_getInt8(fmu, &vr, 1, &value8, 1)) + return oms_status_error; + value = static_cast(value8); + break; + } + case oms_signal_numeric_type_UINT64: + { + if (fmi3OK != fmi3_getUInt64(fmu, &vr, 1, &valueU64, 1)) + return oms_status_error; + value = static_cast(valueU64); + break; + } + case oms_signal_numeric_type_UINT32: + { + if (fmi3OK != fmi3_getUInt32(fmu, &vr, 1, &valueU32, 1)) + return oms_status_error; + value = static_cast(valueU32); + break; + } + case oms_signal_numeric_type_UINT16: + { + if (fmi3OK != fmi3_getUInt16(fmu, &vr, 1, &valueU16, 1)) + return oms_status_error; + value = static_cast(valueU16); + break; + } + case oms_signal_numeric_type_UINT8: + { + if (fmi3OK != fmi3_getUInt8(fmu, &vr, 1, &valueU8, 1)) + return oms_status_error; + value = static_cast(valueU8); + break; + } default : - return oms_status_error; + return logError("Unsupported Numeric Type"); } return oms_status_ok; } @@ -1106,7 +1148,7 @@ oms_status_enu_t oms::ComponentFMU3CS::getReal(const fmi3ValueReference& vr, dou break; } default: - return oms_status_error; + return logError("UnSupported Numeric Type:"); } if (std::isnan(value)) @@ -1553,6 +1595,13 @@ oms_status_enu_t oms::ComponentFMU3CS::setInteger(const ComRef& cref, int value) { fmi3ValueReference vr = allVariables[j].getValueReferenceFMI3(); int64_t value64; + int32_t value32; + int16_t value16; + int8_t value8; + uint64_t valueU64; + uint32_t valueU32; + uint16_t valueU16; + uint8_t valueU8; switch (allVariables[j].getNumericType()) { case oms_signal_numeric_type_INT64: @@ -1568,9 +1617,52 @@ oms_status_enu_t oms::ComponentFMU3CS::setInteger(const ComRef& cref, int value) return oms_status_error; break; } + case oms_signal_numeric_type_INT16: + { + value16 = static_cast(value); + if (fmi3OK != fmi3_setInt16(fmu, &vr, 1, &value16, 1)) + return oms_status_error; + break; + } + + case oms_signal_numeric_type_INT8: + { + value8 = static_cast(value); + if (fmi3OK != fmi3_setInt8(fmu, &vr, 1, &value8, 1)) + return oms_status_error; + break; + } + case oms_signal_numeric_type_UINT64: + { + valueU64 = static_cast(value); + if (fmi3OK != fmi3_setUInt64(fmu, &vr, 1, &valueU64, 1)) + return oms_status_error; + break; + } + case oms_signal_numeric_type_UINT32: + { + valueU32 = static_cast(value); + if (fmi3OK != fmi3_setUInt32(fmu, &vr, 1, &valueU32, 1)) + return oms_status_error; + break; + } + case oms_signal_numeric_type_UINT16: + { + valueU16 = static_cast(value); + if (fmi3OK != fmi3_setUInt16(fmu, &vr, 1, &valueU16, 1)) + return oms_status_error; + break; + } + case oms_signal_numeric_type_UINT8: + { + valueU8 = static_cast(value); + if (fmi3OK != fmi3_setUInt8(fmu, &vr, 1, &valueU8, 1)) + return oms_status_error; + break; + } default: - return oms_status_error; - } + return logError("Unsupported Numeric Type for var: \"" + std::string(cref.c_str()) + "\""); + } } return oms_status_ok; @@ -1643,7 +1735,7 @@ oms_status_enu_t oms::ComponentFMU3CS::setReal(const ComRef& cref, double value) break; } default: - return oms_status_error; + return logError("Unsupported Numeric Type for var: \"" + std::string(cref.c_str()) + "\""); } } diff --git a/src/OMSimulatorLib/Values.cpp b/src/OMSimulatorLib/Values.cpp index d0395829b..868aceb49 100644 --- a/src/OMSimulatorLib/Values.cpp +++ b/src/OMSimulatorLib/Values.cpp @@ -1785,12 +1785,31 @@ oms_status_enu_t oms::Values::parseModelDescriptionFmi3(const filesystem::path& if (strlen(it_->attribute("unit").as_string()) != 0) modelDescriptionVariableUnits[ComRef(it_->attribute("name").as_string())] = it_->attribute("unit").as_string(); } - if (std::string(it_->name()) == "Int32" || std::string(it_->name()) == "Int64") + if (std::string(it_->name()) == "Int64" || + std::string(it_->name()) == "Int32" || + std::string(it_->name()) == "Int16" || + std::string(it_->name()) == "Int8" || + std::string(it_->name()) == "UInt64" || + std::string(it_->name()) == "UInt32" || + std::string(it_->name()) == "UInt16" || + std::string(it_->name()) == "UInt8") { // start values if (strlen(it_->attribute("start").as_string()) != 0) modelDescriptionIntegerStartValues[ComRef(it_->attribute("name").as_string())] = it_->attribute("start").as_int(); } + if (std::string(it_->name()) == "Boolean") + { + // start values + if (strlen(it_->attribute("start").as_string()) != 0) + modelDescriptionBooleanStartValues[ComRef(it_->attribute("name").as_string())] = it_->attribute("start").as_bool(); + } + if (std::string(it_->name()) == "String") + { + // start values + if (strlen(it_->attribute("start").as_string()) != 0) + modelDescriptionStringStartValues[ComRef(it_->attribute("name").as_string())] = it_->attribute("start").as_string(); + } // TODO check start values for other dataTypes } } diff --git a/src/OMSimulatorLib/Variable.cpp b/src/OMSimulatorLib/Variable.cpp index b693e8ab5..0007b58b9 100644 --- a/src/OMSimulatorLib/Variable.cpp +++ b/src/OMSimulatorLib/Variable.cpp @@ -173,6 +173,7 @@ void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) break; case fmi3DataTypeEnumeration: type = oms_signal_type_enum; + numericType = oms_signal_numeric_type_INT64; break; default: logError("Unknown FMI3 base type for var : " + std::string(cref)); From ed25ed3bec144bbccb1983d5296673298ed19404 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 19 Dec 2024 13:02:57 +0100 Subject: [PATCH 11/32] add reference-fmu test Feedthrough --- testsuite/reference-fmus/3.0/Feedthrough.lua | 82 + testsuite/reference-fmus/3.0/Makefile | 1 + .../binaries/aarch64-darwin/Feedthrough.dylib | Bin 0 -> 89552 bytes .../binaries/aarch64-linux/Feedthrough.so | Bin 0 -> 75776 bytes .../binaries/x86-windows/Feedthrough.dll | Bin 0 -> 138240 bytes .../binaries/x86_64-darwin/Feedthrough.dylib | Bin 0 -> 88848 bytes .../binaries/x86_64-linux/Feedthrough.so | Bin 0 -> 71152 bytes .../binaries/x86_64-windows/Feedthrough.dll | Bin 0 -> 170496 bytes .../Feedthrough3/documentation/index.html | 353 ++++ .../Feedthrough3/documentation/result.svg | 1 + .../Feedthrough3/modelDescription.xml | 129 ++ .../Feedthrough3/sources/buildDescription.xml | 13 + .../resources/Feedthrough3/sources/config.h | 165 ++ .../Feedthrough3/sources/cosimulation.c | 691 ++++++++ .../Feedthrough3/sources/cosimulation.h | 5 + .../Feedthrough3/sources/fmi3Functions.c | 1446 +++++++++++++++++ .../resources/Feedthrough3/sources/model.c | 696 ++++++++ .../resources/Feedthrough3/sources/model.h | 250 +++ testsuite/resources/Makefile | 1 + 19 files changed, 3833 insertions(+) create mode 100644 testsuite/reference-fmus/3.0/Feedthrough.lua create mode 100644 testsuite/resources/Feedthrough3/binaries/aarch64-darwin/Feedthrough.dylib create mode 100644 testsuite/resources/Feedthrough3/binaries/aarch64-linux/Feedthrough.so create mode 100644 testsuite/resources/Feedthrough3/binaries/x86-windows/Feedthrough.dll create mode 100644 testsuite/resources/Feedthrough3/binaries/x86_64-darwin/Feedthrough.dylib create mode 100644 testsuite/resources/Feedthrough3/binaries/x86_64-linux/Feedthrough.so create mode 100644 testsuite/resources/Feedthrough3/binaries/x86_64-windows/Feedthrough.dll create mode 100644 testsuite/resources/Feedthrough3/documentation/index.html create mode 100644 testsuite/resources/Feedthrough3/documentation/result.svg create mode 100644 testsuite/resources/Feedthrough3/modelDescription.xml create mode 100644 testsuite/resources/Feedthrough3/sources/buildDescription.xml create mode 100644 testsuite/resources/Feedthrough3/sources/config.h create mode 100644 testsuite/resources/Feedthrough3/sources/cosimulation.c create mode 100644 testsuite/resources/Feedthrough3/sources/cosimulation.h create mode 100644 testsuite/resources/Feedthrough3/sources/fmi3Functions.c create mode 100644 testsuite/resources/Feedthrough3/sources/model.c create mode 100644 testsuite/resources/Feedthrough3/sources/model.h diff --git a/testsuite/reference-fmus/3.0/Feedthrough.lua b/testsuite/reference-fmus/3.0/Feedthrough.lua new file mode 100644 index 000000000..801ee715e --- /dev/null +++ b/testsuite/reference-fmus/3.0/Feedthrough.lua @@ -0,0 +1,82 @@ +-- status: correct +-- teardown_command: rm -rf Feedthrough3-lua/ +-- linux: yes +-- ucrt64: yes +-- win: yes +-- mac: yes +-- asan: yes + +oms_setCommandLineOption("--suppressPath=true") +oms_setTempDirectory("./Feedthrough3-lua/") +oms_setWorkingDirectory("./Feedthrough3-lua/") + +oms_newModel("model") +oms_addSystem("model.root", oms_system_wc) + +oms_addSubModel("model.root.Feedthrough", "../../../resources/Feedthrough3.fmu") + +oms_setResultFile("model", "") +oms_setStopTime("model", 10.0) +oms_setTolerance("model.root", 1e-5) + +oms_instantiate("model") + +oms_setReal("model.root.Feedthrough.Float32_continuous_input", 3.1) +oms_setReal("model.root.Feedthrough.Float64_continuous_input", 3.3) +oms_setInteger("model.root.Feedthrough.Int8_input", 4) +oms_setInteger("model.root.Feedthrough.Int16_input", 5) +oms_setInteger("model.root.Feedthrough.Int32_input", 6) +oms_setInteger("model.root.Feedthrough.Int64_input", 7) +oms_setInteger("model.root.Feedthrough.UInt8_input", 8) +oms_setInteger("model.root.Feedthrough.UInt16_input", 9) +oms_setInteger("model.root.Feedthrough.UInt32_input", 10) +oms_setInteger("model.root.Feedthrough.UInt64_input", 11) +oms_setBoolean("model.root.Feedthrough.Boolean_input", true) +oms_setInteger("model.root.Feedthrough.Enumeration_input", 2) + +-- need to implement fmi3causality table in fmi4c library if inital attribute is not present +--oms_setString("model.root.Feedthrough.String_parameter", "test me") + +oms_initialize("model") +oms_simulate("model") + +print("info: Feedthrough.Float32_continuous_input : " .. oms_getReal("model.root.Feedthrough.Float32_continuous_input")) +print("info: Feedthrough.Float64_continuous_input : " .. oms_getReal("model.root.Feedthrough.Float64_continuous_input")) +print("info: Feedthrough.Int8_input : " .. oms_getInteger("model.root.Feedthrough.Int8_input")) +print("info: Feedthrough.Int16_input : " .. oms_getInteger("model.root.Feedthrough.Int16_input")) +print("info: Feedthrough.Int32_input : " .. oms_getInteger("model.root.Feedthrough.Int32_input")) +print("info: Feedthrough.Int64_input : " .. oms_getInteger("model.root.Feedthrough.Int64_input")) +print("info: Feedthrough.UInt8_input : " .. oms_getInteger("model.root.Feedthrough.UInt8_input")) +print("info: Feedthrough.UInt16_input : " .. oms_getInteger("model.root.Feedthrough.UInt16_input")) +print("info: Feedthrough.UInt32_input : " .. oms_getInteger("model.root.Feedthrough.UInt32_input")) +print("info: Feedthrough.UInt64_input : " .. oms_getInteger("model.root.Feedthrough.UInt64_input")) + +print("info: Feedthrough.Boolean_input : " .. oms_getBoolean("model.root.Feedthrough.Boolean_input")) +print("info: Feedthrough.String_parameter : " .. oms_getString("model.root.Feedthrough.String_parameter")) + +print("info: Feedthrough.Enumeration_input : " .. oms_getInteger("model.root.Feedthrough.Enumeration_input")) + +oms_terminate("model") +oms_delete("model") + +-- Result: +-- error: [configureFMI3Variable] Unknown FMI3 base type for var : Binary_input +-- error: [configureFMI3Variable] Unknown FMI3 base type for var : Binary_output +-- Loading FMI version 3... +-- info: No result file will be created +-- info: Feedthrough.Float32_continuous_input : 3.0999999046326 +-- info: Feedthrough.Float64_continuous_input : 3.3 +-- info: Feedthrough.Int8_input : 4 +-- info: Feedthrough.Int16_input : 5 +-- info: Feedthrough.Int32_input : 6 +-- info: Feedthrough.Int64_input : 7 +-- info: Feedthrough.UInt8_input : 8 +-- info: Feedthrough.UInt16_input : 9 +-- info: Feedthrough.UInt32_input : 10 +-- info: Feedthrough.UInt64_input : 11 +-- info: Feedthrough.Boolean_input : 1 +-- info: Feedthrough.String_parameter : Set me! +-- info: Feedthrough.Enumeration_input : 2 +-- info: 0 warnings +-- info: 2 errors +-- endResult diff --git a/testsuite/reference-fmus/3.0/Makefile b/testsuite/reference-fmus/3.0/Makefile index 631db1d5a..fe3755470 100644 --- a/testsuite/reference-fmus/3.0/Makefile +++ b/testsuite/reference-fmus/3.0/Makefile @@ -4,6 +4,7 @@ TESTFILES = \ BouncingBall.lua \ VanDerPol.lua \ Stair.lua \ +Feedthrough.lua \ # Run make failingtest FAILINGTESTFILES = \ diff --git a/testsuite/resources/Feedthrough3/binaries/aarch64-darwin/Feedthrough.dylib b/testsuite/resources/Feedthrough3/binaries/aarch64-darwin/Feedthrough.dylib new file mode 100644 index 0000000000000000000000000000000000000000..f814735277fe4542de2c7b57e8cdc5a64b347849 GIT binary patch literal 89552 zcmeHQ31F1P^`G5MU=vUgP?00qaE2QcAyL#^ARu0V77thgEF=;V$YDW1gYf|I$Y-&l zQVoilAhxlh29<(BD^{)XqIi}ox*Sz3RufIk|M%wD%zpdrCLmD$WEZ}C-<$KzdvD&% zyt&@{>EFM!X3WO$Yk}u9Jn<2X-ND+B6FVEvcKEv86Glv&z@1EgcvQ_zz>#oK4|%%X z`JQ?C4Z+OmRh%mPTJIEZg6$2#8H-?rI_P%izK*&-B6m<(+U)c)TU?RIm*0mo~W}y`1d4h60=MbJdHO9b^IoJLI?3%k3`6 z{%vOVba!UIzPbV#TLb5ycip$4K?n-_psTlq+;Ybg; zl7zV3GjkeBNw9T#QxI1CY<}e=nNvI_z9m&4q`TsU=EjKb3!T*|GiN=mS5FKi>4Cyc6(HT70Vz5qdLk^PGwKo>JBW902~)Z0M`S1e;_GZIDU{$+ z;P5X@fiMNa6bMrwOo1>3!W0NoAWVT@NrC#!?ESh0_OiMnW|S1gR+kpJtJxklkQr

M;Pgh9gMruW;oguez3b0 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 OEtT^<6N&rO^8XKBf?g&7 literal 0 HcmV?d00001 diff --git a/testsuite/resources/Feedthrough3/binaries/x86-windows/Feedthrough.dll b/testsuite/resources/Feedthrough3/binaries/x86-windows/Feedthrough.dll new file mode 100644 index 0000000000000000000000000000000000000000..1b8ff7b950057cb583103be2575b0877f9c2d64f GIT binary patch literal 138240 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

TNRkZ%G%V{ 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%0AWKL+>AX{qOy7 z{6aGGXC4^(`y|*^AHX(~5u(4ZlE)YO-Ec!IwN2lr`aA7cBTs)nfa4dESp(m}f#840 zfFh`U7$--F{vPIK`g+=07_YE^$bvGj~7N-#yr$Rg3Kk zc-pG%&k{bgv%s=C>AoZ#9@74-Zvd(FW}PqC&H$@Jb>EZw6U@*5b$cKZ`>Tw5AZRPq z+2r+Y$tlAPE%mJv8CT~0S&g!e#HoAej^ODe2@H4B(x-Qm9uK~0iR-b|J~h4%!b%Q< z?1M0FTH+hmf%JHt&JUdOcx3Je zw&H;Mfvq^00D+nsQ3Fl8tc>4h7{>mpOVN}pa?f{GG3iL6izIRCbtLW%^>-|-` zz?1a}>2Iar7Aj`iU-fIQXgDD{zhhTM7S0Q9lx4B|NWbGsJ$}aScUob$L<(XT@Dy#M z5p5F#Yf2x?B6ZV1oZ5CPPm1kU_ymo%-^zvkaQ)%HKj_?blM<25j1-H`{eqvO}J!x`QG^^*iL5s+}Cvo|g2=GgTkt zDOyud3TuiRk)oM}DMXav9C%fI4`zllVsXIqY!9j*g+d62Jv(%@W7sBQENY*cvi9*Q zYL9q!B#zBwhdmqGYY6f!Od;Qyb0FXUzH86q`&mj3V<|bLHZe(+fn2otDs<{0H&mo0 z=Ly`@E72!X(`Qn#arlw@jz|Eyf@qWK|LZp4=kt8;#lBm;J2vUo!JmbCe|xXr&MZGJJ3hU(watgc7eJiJVl zqRD_#n9WZ_inUJS0RAqeAJe9Y=dFYRvJNhYGID>bfnP7aZjpNb@o}0R8pg*@P6yBV zcO>yVr19}3kYYVPKE_ito)bgP&yixyb3F)Sb{GInu)_u-?V~9v>=5rNp%Gb`UfAv& zUgiSa=5&zY)c(mSN|Mx3GDaQhM#}0HU#=MiLpFWL#5f-rhP?Ar$osc=nxMXY`<}`B zBQ8}<#}fO!dwGh5yf-0b5P8QSyVL0jM@!DPaTBt8`q&h*!<)rqI`~w`EWEma{Vxj5 z!Ie!+;yY-i$i73?>kVgV*}h4IT2B8P9v5K9?m;funW7p_9LpS;mDD7DWKL?5M1NO< zVlG^Vqa)B%O)*t9Z>38D&ws;AzT)J8*E>r?@$^;%~MPtn?l zmLnv+zVG4JvW=1s10Rc=oZ2Ze0E_teF9WjO!^r_<1 zaQY+(-n$szc>e_{vYcHn=hsQ9?oXyFjS7_N--KR zHf^VfmYkpBiG(`g=A`y#QvxwhNclaSGG;PX-@}2I8)jzpDVCFvVlpNMg1A_upyo*h zgIEVHCG=T_Gmp%QJ{gnzNe}b;OS|F!MBdqG{HM`i*^;vs&mGhWH|-h!Btz@(wb0bm zn*TPWq~af662}xQ8##z=^r#t>xkA9~<2=2lkMs1JKhA>)e4J+z6{KmYKtwqE{zHS^ z1dr9=Ai=o!PqMVX^7jR5HTg%Oe^EJ4or0;cdfSaj@*mRs9Q=(xtDSsbfEDX^ao&?m zYV5KQMxJ&O00c%a+n{IJAajD=IHGCTX_xPeQLfFgbg$!C#A4>nz%;L8vwGbz)XO{= z@jR&ee8q#t&sShKGLffEe&ib=eR(`Z8-*wZvQzqwljN8Qr@Hy@(%yH59A1*X5n;9$ zn*YJ6!9OgAIYuhyL@o>#GoAY|@nPM8{DzzvAK9M)A7nyK6O7PU@3+iQG5Z0Yi**?DY_i`NHG~%#cKPBNa(Q`h>^&&ialCNRYGoIsUHsaVbdb;6& zhkVX3;?lnNn8c5Td>S~8&ki^6WKB;tYcJkL&~9jW%Zxl;ext5@cFOMsLY{;pZvN)a z;PcciT0hW%T03MvFdd>)e|CLRKQN?u>T)2pp42VkDVjMY=Bd+>VzML+B+Asq*O3=| z@OO^?#>~~qhs?(YD<3kA4O&$!#C`q^*+_v{JDR<9xUtVYW^q@zE-8Sd7=2@qlIZJ* zTB*yC#J-S7Nq8SymvjY^dSofQx~)rEiKK3sl#QhEf(%S$gFzm~xB3p1W5d?OBEA61 z(JJ0gCH)-adwe=SMGVr7ZDLfng!3aj}CX0<8C-@*J8=xSXk zXf^yLeP72tyzj5h*7P288oV=26=D8S20x~HTO^79A^9v~z+vsPAP=FnPoKQDChgNe zu569y2B3%VN3_g%6~hk5d<`x{^iFM14bm0}iax6)m%cQd8IV9N^+>MgNbcrHF0@91 zj*lZj1u@W%TQ6>=6|+&_=sS~YYKQo57#}(ZA!Dp1=XemJ9@Cs8^dULK&jnIzmo$71 zl%jPu35WPmk~d9CEJVvlOe;LSV8oqm@(T{)uSx9>d{|?djha%=<{S@}r-hSP9+E$B z31iI4ANW0Qf6PGZ43>2tw)cHgi2pTv z#{US^@8{tWR!bU34!>-EKy$^^-Sx-N6QSE|)gb4FpTo7P1{#uh9a49_j%l#f6U3`{ zil*C%?wahuO1D`Y6kPWWNLt!Fd^G58$*BRE7$bjrFdw^2W8~K*PH>p&L6H9W^H-2p z|92oSPiViD*VPyfA+Hr66Y^S!u7ZZZy&Ax zhBW^y9{$?vIbxZQ9enNO9?fKsK{Ci$og{-Ht-Y#%)Ozj3dsV9y5X~B_>`M^09&^w2 zu&c+8WD4@#G1^R%&lGgN;0JR4Wj&3ZNqgb4F zba^%)uhqlUU}i!+|)AYnA``g2{hlw>)+>r!+L$x z&Qml6ORRsXLpC*&214U|BE$YJ- z3kt@kpun^W6aKpbJil&E?a?K>@4_>Z4j`qWlN^t*QOLT!SN#)A+Z*bK(+5v;#K77> zD#%)bynWOSq7{CFNN>x*?YIr}09!wzmA)A;ETANZr9j!EUO!Zn7ju+#MwIU|HDC`7 zE=P)bGSCr$4Z9&Qn`5gmV!H|0bbCX(ouHS_{0!B10OfOxQ8oy4c*EZ1cpwx9;}o8S zuqwiCcJFc*5YHlfJ`Y2L>ln_>BJbfqO-|acv8?so>MCAkJ9}m~EsEOPnKscQDN$xJ z-Miemgt9rmiy$&nZ!v{B-6gbry2INQY=^Yzk43ZIS_G+oqjn&kP#vc+wDNE?D~tzV zJ#9u`{w+2sWAhE!fOR4_-=_gbR{r6HJ?wSS4U-y74R|H)I&lw(`{m+(g}AR|caA6+ z6xFKz=dgZ9w-FrD#p5MYTEo%{e8|?wnGO>0yf(Nejb`Zrr@#mRam}b1vN?nX5@VBGmSHvW2Hw;Xn`M z)eCtY!YK9h?t+}fMoSMxwa`ST#l^6Av$0Dh8(NXo<<6jH>QbPUKuG&x^LrK|ue6g6 zbfW5`=m{8tNM@F(IFjG*J+<4}IGW0>-WtR0qAjWm1D12FX}>Tk!t=OLeLtFy_4-^* zNnq5Z4K&Cx`9)S9u71wfV3ao5m^N9BCDJ;2NkbBk4j_IOqi)i2^d#k=81)V_O9Py+a6r-Nca@6;$XHy`w6;GzL@d3O}i&8{lKNaU63ZkiBKUXWpwp3Ln0)tVY z0J9;qOTT*c*-Y{J`GK$wSRShwkJOT$f6~Ad$4|aW-8w=)_NeL&B(TZdh{?S7n~H+D z*X ze&kv^T(|=!Mf>g(ZD>Xz$TyYO?Pr$s^PZ!T#_tq_gW&0$;K{ou*hnwxvwA*-I%7Dt z`2-prS;r+N@$BiZia9)l^Ymu}1JX&)W>a0B9?(cc_VA4neH>!FmN#@72CBxRSQL{v z$$1M$b(s#;8~Q?#)9Be!H*%@BVfDwR4m8#^=YL4D;Nw8XK+NcV7?*rEMNi*o^xJ)~EF)cdB1<4CLJ;wMF3gNS58XH8 zj|1AUyYZ)3jz4oj)^Nw4X}d5P>__l6flerjsa0 zrV$O!EOiNTkT^~K2gWzNi^N<_mi;47hjdk$$Jife>9o~H<}r+)z|Z<*EwKS)CDvaq znol54xG)YB=vXnkXqi!s2|N0Xrd65Gsm5rh&L&gZm_OyawY#y&6B}{+7RJi9IINNGjX$Ef?~HUHump zC@iH5SrUl*&Xxrj0WtM`%0~N=k~+^D(S1P>SN~J%UHIgkQ~@=Hvkb&yK-Q1P7~hzD zAs@(wtzJPExu>#;EDWHe@(gxoi3k>;9Be5~Sy(`gcylR7nB4%?aENXy-&oSm`d7Ba zgu4KE1UUncgEo=y2nr#BwvO-!3L#=;B7#ChLNLe$MO4VJ+T7G6VyQj}AUdp%<^Ysw zbyq8khlZ@~q~JyuP5a96L$!D#P3=60xwi}g896K@JrY1PEoKtY0$`MqW0VqzQW^G! zI%0^%$hcIHhN&%0OL@iZTCkP!c{jhCF1wpMX($Cc6rfqED4+$C3apR?LLJ>GfI5X% z5{e!Tg%)h3eEK@Y`!5zEVe?aNfM)x1v-N=7@5dRIWI%I9QzrbVBmej8)J z2Mb#Yd-KAb;pZ2I#~(A$!(`#UXv@H)jUaJg($nm>ll{^Peqhq`>~|aceUbh4u-{kM z?{@b42lm^`e&4|FVqcwWh3`nEth!q9tgP{s*7=sXs?IH`4EX%6GfsC+x-#He8mMz! zQR1iYROL(*m|t04Qg`x6t_r`as=CfqQdwDj1&Wnb*SapJlCD}`nXlGYRqAt1(ifRI zeKq^_d6>UfG@P*nl2vf@e><;t&K<~!b1QnifIJeT{b>R8lN zW-7zfd?S@Jrx%q~tn@7_swt^0SpiyWlgPB7(FLmlB^5?0SAfc?N)rCMKov=4cr`F7 zSm39ceM|r;YTJ#>EtnZroiSrM%nnS6t~!#y7k^?c}Ms)Me!PmIlffR+pEfb5lH3 zFnVKuL){HV-ikV_Xv)sIAeL*1uXY9KtMe&8^!a^tG!%>eNSRYxj)p^5HOcQ<5%AZs zaT#6TqQZp>rz&hv{-GR`{T%iukN4KYy|6>7j_ix>%x*-)w3#x7hnW7#sFP0;xn@q6 zQ9LA?n<9BLQHTqeLh~xCOD`qyNd{#Qr4eLw;Lhpb5vX0n@DQg%M1c;TiDOMNOrT#O+(gCPee|3m4Z>yP!lOT(+X(WIdcnm|yGj zC4j{~jAIyke9L6iVgNuSqGhbY(V1hBjNuG5lg27}Pz!SoDrXfxzoeoPbGEu_Hhn7v z4$K2rRAbDhen3_`bquveUPUb?h7dqWWgaTH9R0)PK1!Ig?2_t=D(HA3l4Z-De z@&NBg5(=Ii3k+x_UoG@A&sSQpqNGw;RJ|MD!}3vRa3Q<{zOdUM0SP`fqp3uw%)Tl1>22-caEZ3(01Wi>8Inf3CYFwM~I$EjMa?mthe?>k(Rj`0J``TyhXl`4xUYn{TrD zAXX|>n37F3MT=?TlIlx+Ra2FpoP5gMQ)f({KkbBh^JdLFVS3)I`6tXh^_2N1%sXY? z$usBAoOw!a-bwY!d9~FvkJZmJ1p>5&3oLRwo2oDxtDyW9%UmV84jh7CHr17AApnD9 zMeO3u*h{G7Iha{WUZ_&XR7E|5F*nE_&rQ+7|Jkfm6hmM9?N!UHStxHPyAOt5s5VTI44; z{Kc=n{Wki0^80^Z{$A5#{X5Rkl5^)NO0GwPDMWGX?xE#3o(Z!*{hgc}3Ks8f+}IUI z0Do@wtNp;Gri@b@a5WGn_Lm6A2t~;b^2qEU!wZ<-5%yOT4O;<5jV-SM!1 z-A9W%J#wOSayHT(PZQal9*E*E$bRh~TLQKOYzf#Buq9wiz?Oh50b2sL1Z)Y|60jv; zOTd_C16XymVhk*TLQKOYzf#Buq9wi zz?Oh50b2sL1Z)Y|60jv;OTd_C16V+ zNdhj!cyR@B9fC`LKmb1n0B`amp8gJ}A2*!>pyi^F0|y5<@XZp(TwKd>HQ@RsuC2JX zVrsrKk)i-6*0mrHJQHifVl#8OJx3uBcH^f9;O;;q&Td4NIB<#!HH`7v=H1eHpfJf}ywHEn@7$VB-? z8d9$z3S#RhXS5lblE#lT+MLFZ@>9ByDRw6%$M0fU?;#oK4~ls|&9CfCQ_|Q;OtCcM znK;TvRQ?MpAG@2%2meOlHhj7!Lur4WNW+m!kEG+cC7h$1CeKHDFr7}0R5qof*gKRp z_%|l&&*?Y%GX1tj2wl(hoE&~A&_C1X*OssYh!h-bn~C$C-cASl_XvGo`Yh$cbasZ2 zvN{7L@qHvP^#J`w?`L6fp`<6BmGe}F`K+DI8S*^6JYS8kY8j4;!8s~QSB8?7`Y@lz zGQ{yb$_uEy^&zUU?FRad;g>|pd3Z82!NW6|AoFL`D9bC#(59K}7&GN9M91G}GWaL` zwueZhJ-rZS23Y<$6D)t436=*kXDN-Nkl}wQL+~Mzwm1&aKzQ3IU#*`G#JO*jGA{Y3 zrl->8DleqXQ`V&Gj$qL=Kxs=i3+TS|`O5R@IB!W=m$68RWG0_3^l0W{<=sp=UQ3CL zI#+oRRK^}5X5zo0-{=O=il)$=#ngEaSyrWIW$E&gs&b#Q?V!b_%YDlNIGoC}(pMT_ zC;Gf{5Cjn=46#p$=lDNKdI{yfDa&|z*6mpk%MK=-*EQY$ZI;meEl7^yQ&h-wCp8h% z@VByz8tzx#MYdK57nS1tTV(zv{YLL6jA)7*Mx!Zi9<3>Ncr;V)pN~dXoZ^e$E$sJ2 z_WNu4ZEs}?iC;}IUKyQGjNZ{qxi^jm`Y56A96d|fHkvE|WaZIB8 zx-rP|$An_tIfg6NV~B3W_sEd=TcRS019I$m6YN5x=PUP*ruO~k=*7xYW7s)b+s3dK|H~L9O&mX_v}M&P1E@EKW5`ka zT2MST#c@psr#i{&usmgwM~OS=z%=EaG#qE8yfBJ)b96A1Pw72~AB1;()?%NsVeArl z)R(e#Y+=o^I}bPC7PVvcxPFtf+eA9XYfpC<#L`;RgK5Bmds{|Z2Eu94^a3~k z*9!c>bgBb)%H?PW4RJ?nT5N1AttXS>vTNEM#RWl!yCw)sJ!vldxe*u3paHZKQ-&j8 zZggf5{ry3}ZaNAde;)`qb_$0-7H~0rYaD+A0HIQWS^vKC|?SyGg50;cvTeut-@DB#?8 zIee;w-{bH?0lRi^_yU!{3Ah3<)mQLmp8qldw+ncc$gjN5)0+ew6!0wqjtcl5 z0q1_e^KTGvyUO8BfT=$IAt*(8UZg93<>{{r*d<{4{3G%27I0j^#RAU40a;961$=~n zqXPaeV5%>7C&z!PNRJ74zJT2y@^ti*iWB*jKXMpTZw9w+<1m>Cr5F5`!_=$XdA=#2M)h2;DYBk{HaXe%Hi>-oAPJ>n8UdO zj*D;K%oT7@;9nwOWi!uTCE()gI9xAacO!>eWcm#p{<(nTFL8L2fMYLn_%#V{;xOho zjJ{Y8hYyB;iC*Oi4j&=lwh|6c6>zSP!)FLMR?Xpsviubs{*i!PS8;f`fTPPf91w8p z?>O8d;DRm=-zVUnS2+Bffa6$O(cfPL9DS9;V=%-K{WXts_(TC`zsBJO0&WxdFBWi2 zz;y!dY2x`q0`)Ur;YKYPcDmhHw-XgeN(DSB%mGgM|Ujb!;cEq~Ji_5y1RQ*j!}kd|x`D$R zWPYJPF9S;ll*1+`-`^1suGa!zar0`#F5NOuvQ0 zX9+mBo5M>5TqEG02skR>Rsk!*9`6&d`(a-GF#%`4$l+&Y`8zrMvdn)khhsAR0SXGQJnu)QU7-Uqxtcl|4lc+^G)ytCb--LUv7f0HNiKS;G0eGFHG>S zOz=Y{_;C}w$pi<%)@ocKTn)Gyajn61EiN*lFs^1?5nR-TwcrZkqB7Uu8csQ6S6uLC zz#oxf63fz3O=MZ3)gin*fx9bMSRQt3av2!X%#I5!QFByiaTdM?EivJ`;8E6|2c8D+ zL$WI)k(87ZG9z;H~mE)$DSECFT0 zAjc0UvZOj!*qk91^YUO~ORtGUlI$apDT~SbA>AW}$RuvW(cCf1B?t4C1UJBUr_o(xk-ggGq; z2wHd)5g_73P|zYGi58wyppmp7GC>Q%IsznFKKc?0Z*!$ceDa8nwZ;<;e0TodB~;O?4pl9Och z!S5*iDE*`H>yO`Y_^E3EZU%C|&TufpAq*8b5jQ8{cQPYR0X&WGPiL3_cm{qW@f(d_ zB7S4>8;9Rn_|bJXe&^yh0l)L`n}i?bovvgF#D53hPc`AD;XVbw87ACJzMlm+oA1*A z=izq=ewX6+_<;BRm^uB}veQOXA9Kmig}p8+x?=axhKplXe>9?a?xJ~dH%}N;_QcrO z3l?TQb!qv1y&rwy<&*E|TRw2$Rx`JB67Iy-LpH8V#h?&$a0>-Ya- z*}%E=pS}3nH$Q%oRyFVL87*Ib8&`Hj-sZQ4-FWeZjg!iYKK$XCR}cT?$cCYhe!cam z*oXT7_m?$gYlnY4qIl-C>%BLC_SpLGijNxi-r955Z5!PGA2)7jxKmp-XyC++gHL?r zs(#~QFSzNJM>c#sr)m^I}h|==b1~&t8Q+V6KRl3l2^G6nc@ZBjKq|*h3>D zycoYo@i#}2Uy8~cDSlQIIUZEZNb#SEB0n#Re5&7e{6eqGfrupknkaHcAih0R2*P@l z_)|a&t$W1&B^s7KS}!f}CJJd<5-EslHsi1L%J2k)>1xG~;(yB(X^_Bb+MQ^S2tVi^ ziBR?HR>&j#lT?v#eavze3A^>u>TZ?z^%7`*;rNT^N`#7kG2?rkFY#Y+{3%_f{MGkM zgp!lV@xSNzN=`DTySq}xKN<1pif8?w|C0>=Ac6KS%judf5lYT4jK4R>ice(uzuYYG zWG}kzV*D*@WcWNzx0>ZlyIA54`JAswk4XF{5@?BBF4~n6F@fzlk@fF(x5Qt-@n2*) zTOX1LHj_4h(>vl%~`<-E`N@|R1*bcE^ph||q{ScX-- zTg7%OyiMWlzb{alK)1s#Lt&NTg3YBdO#xXXM6(7-^%r67vuM`e4YJ&0^^Tm{H1vkQHU^I zsceTn+-^T7(b|0+zjcK~C_Sfgy0<NdcT~BcQ zgjF)E;y=aq%;tK*=GIm){=<-R-^u=S%4Jf{$B-+o^z@v(g8cL%J;S4?r)%lcQd82i zTpm}ByGVC=Qd1`97Ua89GZy5!BrP%}J+n9?J=>k1k?X$Nr4{L({LI3oTAnM90D`%$ zd;%28&U25M>eA=BJVow;d=Z@E(vw{aygAbga&p}HIRZB=A1dYR?hM_PQjq1!brfeV z%*fAig%T$h%yH*=b2D@$%)~e+bD=BCo9oJQ6uUCLMvN&QmrKUVl;Rxu$m+CwH&TQC zLKLMbl5!Ng^=Kqwb1ZS?>qhKUmnRQa&?WC|SCLB>Qjp;(xdj>en9*7~**bG^dgj8# z>Dd|XTnl|%q6$vS*T<{-G;;v=qsEyj!4ODDfDKGc!4LvL*+dG4CKVLqx-w)*K+ie4 zN0k9WlaL#aQD|_6%*7%B6q(8prKf@{6+t8+^~Zfse@S4CnGy^IHD(g)FS&xUP5Ogm z)*nHW{zMGwk5Ev5WNn5wZ-L7*Gkb1^$4&m7>?(BSXSwn--L4{K#Qo8xq@>N!RZ&B@ zB}_gRL?FOcLsC>lvJ`C&)fZ_&CMk-*Cc}e5@tGO9C^D+$YRp=?6455fJ z;GBi-Y$R=oD{z*Gu$~fNj%z}PMh}yVxZ!dgP}GYeN_H1zdR)3ol$W$xT47dXf-;Qm z&i590i&EWrq5%>anp}`qm~v3E#_vZ!_Ulo`~F^)9r?P9{LF`y9uv`Bt#fy!edBdTq8|* z9#RR~coSZkh6qU}Jf*EJrwOlYL9|&WJPd7I^Gx_746LTjH{p*o;TM|lC_v*XG~sOq z_V=6LE%3Vqez(By7Wmx)zgysU3mkk4d~X~0A7|?SE+b3>wmr>TjW7)y_cT9cglXWm zr};i3Oarz(&9@j~8mR4QUT%bGfVQXkN+V1IvpvljMwkX&1#(*Si( z^C%TYZvOi*n6L z*jaJz3%GYybbXq@S#5eh6y;%bkD@$0&}17_g4}D{86v(<#2>qY!0>%eU#oNLH|IIG zw#7MPb~<VbDu^`&FT9>Khjx#?#aOW z@7xy%__JW_om~eY9CJB%jr57X`6>|UCJlUWzIdl^S(~%m(Uxudw&r_V?-JUJGKXo8 z$Q-6cbaVL6rtlu{SA~SvhlDqVgsVfsH6h_T4(}|f$DK%eXNg!bCM|ZB{56PuSKVgU zmNd}4RJ69_Z{|RwIq-oIs4e+W+)Jj~k|s;&b4$o?3OQ>_TCKr0Ymg@wLKj3C3zJ`Ud54XOX#4C(xSHHF%DI}wmp)=d~b_4oP``mISS#GlMr4x$R6NT;gh4N zf+u_p=Z5gAz-`Y}Qi)S0%POhB=?+LLaEYYy7Rcu-skrGj+gC}2%~&dG#!^AkZFwaX zGu`dD`csGwih*atwPN zjvXgqua>R{w^V+*!<5Pcx2RH~og&!z2;1tlxGQ&jZrHV=>m^XEyi2TeowK6f3{ofo97Epl%8WLhX^d9i5Fa_wufsy(iU8Mr4r$u5-BZe zF$7msPl?1ug(A43dP*d&8s>`PDUn#}6pP7I*4}O^!%wi6*&&|t4t8A)e_X0kXyu=npq_P)7fSYHwt; zQl+9Y+EZk-*MVe|TBrlbD0M5=jLtFJx~Ed%VAuWsq7gPS`bdSU`?ML3vb2ee#_MOa zToR$AD*Br1we5K^{>k>mw#+<`$kb(0WK-F$Gh6*QrOd(3@)71NZ@Mug%e_UG`y6PN z8#xyTlw}$ZgklcB(xy^AN@TgOKC0!4hy_R0+g#G+ zV$_PFyYK*`H-X<;(gV%e9;p;M*x9zDFEg_J`X58G-A`ou=yqhAMr`fKwm&S}>E?1c zODS})vpu}hlb8?o8X^GPp+q}6QJZ%&gJU2)lfB8lpgYLJtuJ`S6`r=zsp&2-6tomy@GKZ1KA2N6~M0NUwP(8gIi5C#zJNG3p{aA1mDOIDJgZf?vyk7|O!PVmbgvoO7TIV$xu( zfyrhkc>-hX4$1mGXvB@IJ5?&GA3a`V{e%PQM`^BeApI!KgslDOZRpDk6<&ppwJW33 zeJM4tGJc`6n>sPOfs0~RB}eN|q4_pax>Tjq{HZMGfucSQ(l2S=ApKm(tmvyMQ9Z`c z5axF--zKJLzIc_c92?ijnT?9B22*ecG37()US%*u5-KNq2P{-f9<463-0a8KpjT*@ zC83 zN%mDW-pNEOPbw^J>!Ook!Rtf4#}IxYxB%P z7a2ki^7Ql)^k9ZbyQox}2cX4=PaJMrxmb2=hucNbQA zv#l&aCYoOWQd)@&dA4D&E_#A--(4TV##?W$*eh1B@tW_FLc+`NRU|>;QAg`B-4!We zW>`{1N%O3i%W#U3To*m4Mt74M@rD}9&1(F-T&dBwy=tr{HQtvh9=P%}DgHk=V4_+1 z2}=1W^NMH&tbq<@2b^gZ+FYW%`v2&Fp)Jz;Xvz%-EHzR|g+KN1lD~u+QA~B~ZO>6- z>n{^4is22>8|HTIbS3pSH$c?O_Vvm%q;$^%QJN;M;Yv?2D_yLl9yFy3(DE3T zK30iu$%4{0?}P}JHm0EUw&#Vlu@>7vnv>;smZ0U(V#2zB7tC$+GuN?c4q7HQpw%}r zk*dUtO!PkBOf>#lCPtVu@y)V>ory2d&KjAxS&47SMoApyO^R3&C_C`TR-}#o zg3$J~p~RGl>x={!!v4p4Cmldmq&0k%Ghm zx5+#Yu&ttztx<+yUXGp6eofdPD{Z@e$xte~&9EWulb&JDh+D~R$umUl$Fq5^CnqX9 zoxZ>Omw$ru75npyCUf`rpQ|_z7nZtgKCfKml9V&_DZ=|IL+E(q5ma3r%acH}u zInO1-EJ57~+URn#(hfu7pZ6n2RTbXL^kZL?Z)LKD*y+Qx+&9WuainT5Fnt!yUU>>; z&|BpU8diPBf7i#qV$~1K{q=)O!mY}O6?P_FMLyEDGieD!FT-NFO?tU`%i2z79DLrr z*e3NmOP952-fq>%verV)Wn1~I!g9yn!S$GYoG2WDc1*F~XIAA{Qbn+Itwseh@4{Ae zy%sSo=_Mh(MjY+%(H3Y*O_`&i*0Gzok$9u#Jwn#M7y$-Kgh4V5-X^Vy~sNY-K&HS4;Olz5PB4+BZPLVZ0Sr|3*llt9 zk>W&&&rA9D`|6T?+u-z#Wsc8%^<|DG+jA*R&hlmOBSetvHI0k33#a*hnno7eg*|ZE z>4RmK#rr*r$Ywj@E%M2_ey7jdM7!Q3e`m7qweqxhnAz7_=BW48l{wy|wCZfnEvuhi zp3*qI+<`RVjOA&=kS>+_$VD+1krCoK1yKm(8ah=N?C7V}l~q<_TFap~%PL>s5bWGV zDClT2=|zqiEziPpEFKasY{Ui8Cl|etNmS`>kwxEkn5Q}#@h_#`hq-I-v^wAGWoe(o zi0}ttqta!5!=1KEonRT>^sngm<8ru@&=on|jZ+?mJMES3gpzM1cS6axmM&|J)tBLa zh&wF?D#V@Ukx?+2c92$D$+9L*??%D8mhJ#u|4S{gh|xQ#yE$qSH6{jQNlnn8@LNr| zQme%dBdH?QI{cj3VBNV19tc_Hx-*0_OLC}K12{q~5dK55vXU zR-OYXxQp`&y}14~pCPeb3@pN0^Rf6(+GE3%W-_Riv_T^((kCAV0x+PcogxL)PELUa zf#E5w#Dib@$V`+Qr3-zfVP%%DP^b|k7z9;Su1i+Xw_}A zz;@l7#4>!d3R`eIOfZxHSE*v3$@_|LT!D7P}$O`3;?Q&_h^S%?ItvL2_8AeK5_Vtp*6xXJT33b0-*8Tc(9B)$HulG6LEM4{{>OL*O z<4)H7R#o?hNUW@xgcWuFNJ_DE*?P^kaxXOlrOP&I-b7Bj1yeu_7xofR$Em)`LjbC= zSlQpdCRx{M`ZR2x+5XcG44Hn`BDlzhpf|whEC5wYPe1hN^FQu*y(`D9exZnk@h)`^|lpDXoy6e`dN;3I!5?uoIE+h z*xNCyHA-SW`qo-Uqx6DC)}xX2(8mfLsG(Cu)p8)w_ElZP@f^0?NCOM8{z=*{^u_Pnc6e zLIVLM;dL5y1&uBx?8m#8y?5w&cMnnHI^Dagi%oW1fu^}Ly!)B@j`QxLks-sor|#)g z?>+-lVEE>E0?IcN7Dn*RsBQQ0Qo;|I9~u&N=R}aOAMd{RuZNy@U-b9?N!$H_*JQ^B zvpdJT-+Qa$ygLaQGQ8XUZKrzog*uE`G4>Jy%DZQ|BKT%h?><*b=x>(LE0To$c=y(K z4n6N)Ao`O|Z@Yi-m`Y-2X6JbKkFR%}cP~bU4DT-A-KpMPgyk!E_q7C+cY7AJ$Gg*| zgtN^OMn;mbAMgI`%|p+-^Dq|uAB?*P7Me=JKfiOl``EgU^X}UVOy2!?bEkUu+I->N z_YhFty(Yaq-o0E(xXdhJb|eY=@$Rl@I}Wv3<%(VZ6Yox<3ArkXBd+Ki?>^_%j`Qwq zm>C;w_dEaURPTPCW{?$QYX~TtK6hDry!!zu;X1PfJ(7g|c=su_hn{!eAx2A`J~CNA z6LM7&BQEV6@4kFn$9ebHm>C=1{oQAs>fP_t463I!Q|Yq z>3`<7$Gg9j61EXgrBWS9!hXDa@zz7nyI*_bf8yN_XPN9+nASPoecwwR=iSN3km229 zab(2U$?f>voB^1X!@Ex=pnUU$R0Kj-tD~-&94;k%P7_Hb;e$C5B<#n#E3lz=sExa? z5p#h~ADPr;nCy7#?9TD-?JsnkcNZc23FsG$B_d@we%n z`2a~qa z*_~FL-Kq23pbiaxZaFS9KT;(DD#(qgaRnU*73KgvtbT~=*wbND7Za3GaC&jNigKv;pqTt@3~uSX)p~sqpSOZS;=I+# z=FGNEv9|J-_Cco_Cr=(KYqZ!!C8UF;N~N&FR$*0c=o2AT?jU+k7v#q9o@%VdcB1!G z(L}Ri?4tyf_uT71KpKY*i^}Hx|L#4z#rlaH5&TcR$4^sZmD#70JHdPY^_PzGo?Xbz zmXD7RS@K_v)y_`zo&}g3!+RDJPzKGIjKIP7o-+=Wwr2xPUR7rGNuA(5>mThn@3{-P zF}&vwSWWCi?-@#y_=>To6Ho>{abkyf&%-r`NY9mv3Ad5iaY>!vJ&PXcIPb|uZVd0) zhxLq3^qzmE2=DopfbyO%CUl7R48Xq1Au;YrFlV;y+)nVG5f62o_l!br4DYGg*{R;M zo+h9bW1k|RyyuZWbcpvn`0^p*J*}8l8JXRDPA7QJH}`j(_xu;RF}!C5cAh)2?O8NU zcux@l-pM(e^y;G-dYMvpT_hHdb|<_tYUbhW8|6Y}tw4GlFL4cqbPD z;&)e+|zO1vj({_yyq~CEj!VBzQKeQ-t!{?VbV=8O*Up6z14 z@DONwuEiwX$n2DaPVkB%)TQUuMt@PFxQ4+5q-yQXWu&DWM3(xN{=KP-Yw8}5u?h@q&UfK;GEdX|zhdkr0`SNlL*<*5L~BNGNmg-%l>#W! zj4km*6@nJMrEb_yh>?O_^XsghQCT_04&%Gf(s`8>)ijh{Z?^j(9Zzn197! zvm?$@jySQJGATJ+lEcXy&)dx$195hVq&IGs4B~uGw+gh6kzYY&6l6359WFZ;vl}*J zLBJ@_VjR>kI+v&hdL^QPHYfurvmq_5c@6#{-;HD=bH4Lv(WPSS^#ow4R|c8$?LzE& za$&sUar_p_`zs{Ozq_2?v`BBY#aS&%MnyUbU+SC*QT{(7hOG936&WTpo39Qr!p*m% z1huyswRfZWbexD}7y2agPCXajE zWZkHbMl67o@K-I(lGu>(-r1BQkJQu~@0v`n7A-?xP2UNn*Zv`%pHy!C82=cF7xGz$ zbXBTzhZN(48D1JyM=y;^q1dfdTqmQ2jq<$1!;l`X{w)$4a(eGN$O}~$FC?VHZ1mEq zSHT45aa2MnpyTP4g?PQ<#pD3tZ1c8?T$+wXt+TD@D+Y;p28Y z-BzAN-!SoZ+l*FHYw5aKqpk&bdW~dwFA-I3YR$lAR(mm)YqrFaIH-NadZo5wKV9bv zNC{WHFkJP^4b@|fH{W)l3?xf}c#Y<%^cu}E!PjUGBO1;@##6-OIgmsF_4>#X3WVo+ zmKw0D6TUc6ULEO_uU)p_jlr2kziY6@V)T#ma2&+wAEQpb-h~$7ldr838#0)sDH&Sk zRscToD>@FN;#H%*#UiVi!W!)%=H1i;0+p!hCnjaBXrjfuvDQChAXURiM}U9Zlx$(t zDOr*l^wRK=MjfzhU4&WHKWLpn&CjkqA=<3UGJrvDOzt>#oms?L5k*AQCPd7IW-)t? z|1FyIGK+XJqKE_0q!trr!zK$OiWwPd-jK|!G>bSXqKE_001I;Vx#zId40sC^$iV5)slr;=SEMNFULVJu@R`Gcr^c+a-NB9_+N zgntx^TDWPD9&ui1TluVH4w;=kAh97LMf;ESI!zailI^)!I#Q@Fi^p13T@dL7vQ8jt zg2*L6)(9ldaw~SM$T+G6a$^u#4CF?EjMwxN5TLg-mz2otV4&1nGrjBA`nqpXl9rw; z%1rNJEGKNCwpO(NIE?bE-PVE6^r&3y5FMeh7CtXt#x5EZyocPPEKl{QJdtfv1JSP+ z=}SUM-zV-<`eNB3>P+S_#1{RP@(Mb#%^w#;Z>zAvSC*4x@kq!hvNvXX&tfG3bC?Y$ zizKT-*Zft-AQ1FBITx7@zIx58_->SZ9y8yGOg`kjJ=x1d)S7P=7!M1HkI$A$OiL&JOX-jrh+oi{<1r1%JWS{gD-d9tcS5MeIN zmBUPh`OkX~K-JU3RXsjj)$X!Hx`e%Ay4@Q7a0)aW&r`ee4h0RDh1k$z*6{9o4#0+q z;Wj)e+=hKbHPB^Eq;@8J#MN$VzK_aaSo6EP4?x$>F7FG>8qVwl4Mp9KwxIYF)naRv zsXGZK#7IqijN%C#!T8nMO`i$~d9nD#;l(`##oZKay{<(vwAeaWG$XRr+t5d7qk3Ce z$Ea0k!ipYU5nQCb+3RP{-aB`7RQ6uS(gw2kp52taH+uiZ>_uwnLSL!B7zu9a4;xXp z_2ZuoAYbk4W|JbDe^#V9ksO(cWg^+tac_GYsV6t3S^+Wh=(p`esGW4UR6EJ6c9hRI z=qbim3eSkMLl4qKKjlItcd;@#5)2#mNe1#AMuB1pg8Lnx~h5hav{(<#Oj zur3Z*4CKyn?4Sod>wJzKrOS5UK~D#y;7*Phn=sfB1B>${Rt_u(D+U(BWs2xKHAa zvVw0K3O)itxPtdcY>0woz|w+Yw(ShZdQUEvbLmmSCen|RJ(`oH%=oK%QL@3sO<@jmCStOuL`=3fup*y(Z1WuJsbu|>EKpARY>C4UeYVU=Sggc6(<1; zJ=e+cT%`nM5{OLE`exUqNFDj5wM<7V<+7Em?q70}$T9d4R@wWxn{thA;v+}=E%Y+S z_7d0jn384NHQTDQP%4zF+{>l!0pW{2CFCM2Yiz5I52uokPqiATQh=PKgb%$7o<}&pEcPtnqdS+=i{@t64q%G|J(m_)aZG ze5)I&*ZLpA@eFmEKqQUF#X0FuQC#6kza_CDNk7ldU|7N{`YPLVNnX;XdC@+6_6l8= zRA&~=)haRBGTTn?1D&_aifOTaDXlf9m6g$=4Hc{ShE55J6W`t0uIc@$9MM9-qh*BN zqRzL_SB#A4xM6gJPZ{h8eV~1(CuD6hiJEqww}E`9F49E%HJN`?Gu!Wi_o(sFos_!rGeVcZNNPQ* z+=1^+y@ZvvHsq07d`!^kX=!=L!8;llzoyfs5q*6MtK2;U0}!vGpN$MdZ2=53F;Fl1 zq2^vxm&JUZWZ=71s7;Y%G)ft70EEeSUDmxiG&v0v4R$}_%0K|ioe`9IUkX|gNzif# zGHsI87Sae16IA*-mTl#Wq&m%4X%o&jYa!pmNVCTCeG~4J#C>hjEMXpsUz;?K@9Rmo zjY2G~JGLQue@Mr|1y!3GqTVX0wEnEp^UWGYk!zD^!YNe1N4j1rn>C-XJCibKO9rWw zY=kXUjGdxo5|MY7P%A)I#y7siI}4oUN&RU@kUq;zAAI`+Yk){wjtqvOsTX%GR9oA4 ze@lMAsywZ~ZMID6a?ZhWX&KBqf~A(h$W5WZ=j3sx#6qzB8(`DgHh^3 zqKGh}ID=9AAyGsaQBDd*X$^@Y!iW;9qTv3AJh6jnc^$+^OT81TB&Q>zO>z@gx2b!u zKM!^hlrsZaXtPuV;icl7#u=2P@?%lxsFh=X!ZM>#=wl93!$HwF!^Pp7@j{|WJCub$ zMgE|h$tAd`&BZPqD8x%mE=}c>&bDE12uYqAVX-zsKKU9ASv=y~Yi%vPsVivv-gaHj zHCVaLwq3L}s3CLpP6>_y+Lj2u)|ReWw%ck<_AcE`-hh&j zUlha;ya}yvqbT8X9F2Ms$%WZzNR0hg5WGlAeC@B5Nc?F*JllM%sjR1>;+jV}rUW@L zU)pZbTHs@mXc4g&7GCQ1P{qK2sqJWsMnO&BZ}0av>98IBfLXRl2bpQVW!)0O8_@!f zqJ~~901iPqR_5rq=?)@HMgktCb;iIC-3-F#L2?frL^nJ((Hz`_o54^ z80(ch{tb($#}Qj_el*XYqj_#AAZwVmn^dwDW2Z5f9>$f?a#lpH?j}74n)NJ3LnCK$ zBXRz(O?C$G4%>=u@URwozlc&Oc$-m;Jej}cS-N{ZO0>@B-GTk5YIvG>S5(L>5Bzm# zV8^2YwXOUN0x+N_InIi%AJVET`DO*3v+=HXmLKLUpWEH(i*focgzi(&l244stD&5k znDbH`F=uF`YJY~C#-a_S%NjIW+08=UuLvoviE*ymLcU4-gTPN|Lpl+VK=2JoB7wKD z?Zycd)4-%|I%Ps;W+5V@;-poVQ`Tu<0)pV02QGPh5*Rw$AV1HBPhQ;vipgV_?`{&B zygUpBclw^S3$S*+02PQEnC@GJjt-!r7y#pQyKT6m#5O#o(l$J;$~OG+jke*g8r$%^ zdfRYslWq92R+HsdIl(ik##t)lYkHxxd=;gHLH2wxZ1!GJyJ{p5n9^&ts}gZX0|jS= z12$hZ9zkcts#yeltCB>hf?_+%*9t|YuxY+Jd5r3zei#FRU0C*`|B4O@36c(G6Wo<^ zh?pSb;G5vFzQIAJ|ASwmnP6SE#RO*UO%}f+QRuz8y+lbwtoR8UP7kHPbDM9tD=`c6~yO}+h~{~XQNmBNVVjb(q+GB zde?HtFD-V&KrD^A6m!IPT#!vJ5=}NuaA{~Jx@)jI{KyDF>b~XD0ubUxVB$Fn4>D(s zq_9r_`bMz~5x_S{#U`M?OaKbfAQeF|Rz;9D{tzTURNC@GkN^dXWsm?RtcIebp1Mc0 z$})0)VpMm8^chHXCtBpLm4siujlc`ZbnmOhDdO*)4^bjmWZFm;hA@2To^MH7HDk@6 z+Ew4#MY`&XyQCz4ELJF~?lE$0A_*ADq5-3HWH{Kx0aYf3rId7ei5#JdV~_D!RQaRv zh;gdqkwaF&^I@joAxU+dE`0@((iLHAy7el{v*ax3knFAK9h7 zjAWPJ(tf366erk=WJ8qe%FodkQf^PmvM*SwyNVKo-P+eq35g42lUU@w+7&Ku(r;)l zv-8|zPAWRvJ}p<4K_+^8G;mjXse4b*#w3g+Rg+x{ygAbga&pkFYL0xgFV;qm+BnTo z?A9ZpDY|I)M66VoCl7k+E^W4}$fZ+*&F!Bi1{br{*rG_A=*fW_puIe)$e!md(#2>5 z?eC1V>C+Qr>>}=dk$A}XCc^MWB{eRQQl(lo$g8XcEj#oBEhNp*PApzy& z^1zLgU77B@j9hJo>#AfPM+l=9$;ty>-JS0(@D`=I^ISsY}+>8QB zHn(VIc0{T-Z-L7*GdomRekcM7&fvIVa`MA4!un(dVIlC&^y(OknRAd_AgrVX>wl)# zgQ*E}otNj$r(B_+XHl`*(IO;_8kZBC@=!>1ESC6axLt*I(a4H+2W`#-`^bol6EQS2 zCuJ`bX~~o_Oo9rsIeD6Gd8mO!BIph3RWg`H)wNyQoMEdc|-QGqZe*0~0it$5Y_ZtVABGrWP!A<*V##*Ni!H z(ph5@r;Iv%^5pU3PESl8KjrjEXPr6a^vP#V9y4yrxN&EWOdh>VyU0^OBWv@Rm*t>r z?8u|6bP3VxBc~|(oP1Ojca}ZF)Xt-jvJ&h@YmR`-U-bC0H!%7Ns`@zv9yg}A;eCb{ z>{EjAF2&sU@(7W03vz`27HPPn`s6Kg2y>D~=nOH$R!Nyez*h?L@yoUkF$4^u@h$~T zQid4rG~}eBAx1fv8Yg>}(GV5EMkrED#*4g#g#{kbSWClL|CgxXcMCr&d$#TK3Cd4m zj*mNMDE6gF5g{IH)k(N-0$d2#3RnW@o*f9R1N>7emLCC6o*M`>0={%nAkYT*uZshL z{#`Zgol63N@qpFXVVei|m&*cyV!(SY2S4E2E5HwUV>5qL-4eM0n z0nf)e**w7RSnezaycFxb>i|E*e7_p-7OV|40#3mmP8(p4#o)(5qI$sbfOq7AAMgrn z(-s5%6T6%105{-$8`XgK6oMac2hJ+A0UlQbe(dC>0Mcpb#{lO6z6@9l_@WMez~jB( z2Yd#w5%3ehHo$#={c()&u&clixCMI+^8l~F?qxCHKEQQ=pIr@pz^%)`4|s10_yL!d zf*)t(F1-Q#fM@x@4|vRt;0OHoP2dN7_ZIL2K83R_jes}b0e-+d99`^>(U~3il0TUhoKVUB29;K`4H|42>CdIJ1__iqG0U=!YZPz*Tm zS?~j1_B{9j|MUX*0UKWgKj2Ut+3k;0W?8R*AMk#_d4RhCivd5Z0Y6~uHt+*h12zKA z-wuAj<#>5#|6ZC_^D6iO8*9N2*!mjy0UyC%XF81PQOb%0HP)quym1Af2__236QA0KS!k3F2L{tAA;LGOYea4TRj zU}gjO0d4PrAMh!_M!-3L13%#Czk?qunY|mq5BL<|Jirz2gCFq5kHHVP`V;U2_WTt5 zfC0cZz`H*KKaL-71RM`|!sp-zoDEnEcpcz6z@A@#pTdBRfDZ$<0ml9d{6}e8@t5ES z+~fy8;PcJk2i*J>_yOwys{y|PYy|Ay0)D^~0sCVQ<1)bUfYpHW0K0wzen7eyXfapM z)?$j|V~#(vTlY$=k`4t8hgh__3j%?9ir6cDO0WLs+j?Bpy+k|jxU)|kGjs@{i9Z>? z!s&9mjBs=j{xbX)0$&5DE|RI^_gV_J;IQDVIeNw45Iec&VR6G^k+ev24bUIV3ddh`?!0i@#g+Xrs{Ux+*r&{C>HstRGeJ9$yWGy@)o71Ax z6G5Mcw(@%m|5pZoD(I(O6rHYvz7O;tE&SgY{A)meZ(elzCeR14gKR*2lEg7 z323W-w#eUO$lnY4kDy1*KkQb6HvW8z{E3GAM9{xN+b;;eW~C-wS%n ze&~JUG_5i#5U92AZ!!22K|j+Kot_H%$Do&5@_%(O|DaFAy7y}q`89_8HK2b5I{9fZ z|1Ac66X;veXP#`4KfsXR0QwGhATZZLPci6wLI2O9Kwykn{vsh>`ak;qo{Iy4bTd76 zu91Es=+i+*6BpFa8RSm|{an!Znd!0rHu!bWkIxMR=3D3&8T2)vUkds<3;kw;z6tbq zK_6kJX9m-60R0ot@#2o4eo}przrCP;40?C7ePRQK{Jt2w?94-(YNp3MY1l6j^eZst zs4~lsy~E&71^wgw&~@U+Smg@~|Az+u8qiO~80KU6sZsuM?-})D6X^fM7$zFM0rY#9 zM5pfs{c?<5qVe~|*z5Rfqtg>XfB(AZ^iXpY&jKdMfDi zAC6AfLBDQ&bov_5|GXhOeG}-LAB#?J0KM@EoDQGmiH0p0E=((V`TIgRIbRG0RJQKbBUPJOX1p?1m_#Zd; zH-X*=`g#lfUW48M`uu0HuWHF(eDhQS|qp`qU<(2v;?2wY&{ zpJebifIbQI$!7Z1f-KvA&|RQUHPf#P()(iWbmM;b6G4A+Km4hn|7}0~I_N*`hkp&| zcFeKPH0zfi)Nd2$XM%p4#Xf&D?9%}H2F%T>%>1VQX)oxf;-g)sTlj|>{CzR^J9Arf z|4Ib?70~au$iLIDe=6t`w@0Vzpl=8LF$@0#2LBq+XYPp3zX|kR`=K|0KIhdy;1i4d zzZvrPg5GCmbb4RRU3Y&F!wG5J=aW+l>;o&KN0koKp$tO=LPvwLH{f0Bg}Nu_)G`=W6*Cl(_?Qi^jiaZ z%3lM4D=qYe27MFg_kcdkOivG{-vIiab|k#e+>Dlpr45~glKdf^yB^>2pnzJFD0n|8qniGKh8|QFi777 z`VpWHG}F_9^ajwogO0QH!Tik*()WTM2Rhz`8Kf5m>3y;GaRTVk?3W1oJkV1t{+Vp} zXDaBc-VX#EX8XkbLD-Ly{Qdgf0>4|}cMJS(f!{6gy9Iu?!0#6LzgwVih?FssAq~Cg zs=!(oT^RC;>kbZM3M4PP1eg+t>#|oQ#Pf~v5{tN459A=0PQ)d~rnu|Qbeb2?rRe|O z7bu``D~%Cx(Nu`8{;UYAp%pU$Q*v?DG67RmarI}2C2PK9&RDEQuf?RRuLK&Fw#0>} z=fqVa2H99|;BX_J#-dB?bH-hAC_KPw?I zVdUwfydpH}y3r#OMkXeV9xm}B`hNe#LFRf@z^0gSTC7G7$An&STAbl$W?G!q#qcjH zzN_JfR{UX_Do-oEo2LB0itnx|f3o5a*OcE`@$hoH86)rGv>uv0BK}CNH6k9hb#Np( zy|kK$c$=o`wV5kU!$hsdjFIrvt!Ah_sre#& zYlxjGNO;x$A}B6e!;3NLqjE7t;KS{c2RzA9?YR(we@jLDa68i;StR|dqTn|IPx3Dp zi=&#Bjxb#>;}=QJo4`|i+cOjk>n;*#?*kHk#3qRlYeBeeV*CQei!~tNzGQsa^SHq! z)>Z(c*`L<7VzfTm`p+r0^@^k?2_k(iNtAK7FbjRNhVb;YFS_g6}#^3Rz#EZ2^+-_ie-Dwi9@+=CG==C^+fAbU>QJfLM z?Xiq+V)?427{Yk^hBRHZ5@;hBKj3MJ5Nolxr9Cy0|H-Kmuk1gS@k@tD{3wL!nhO{c zp&iTQ_EmVmLkSZ9qXgRZjQ?(eM7+j$ALIM8-HvB`72|8T zTyh!zFyrrI1G8DRCmDYeBZhJOml*%V=@Oyzd6n_Uv;MDg{C61Nk1MWNI|S_?z{f=B zFFxn^bI+Cnl$@^_|HE*JSN8um;|H*wS8}>>7_d=!J&`04;!Fi@dy0Wvct2tBB>rRAi>})lKl^SOo-Bd3LEt%H0xxm= zYrPUF_Ly-?uOp;%AH7H7r!vn+QRM95_@8CSh)SOT@OI`kgX6o9{P63HDENs{@bd&7 z?Y2+KQu=2zeruM*D}8jv*WD`dYCdr@6<@}lPi|1P9Jj(d*&$r^M8NcfRiN9Y0 z?E}WY?UaZr#(ypF958_x%(EidXMn)>()@SG$YReIx8oSUl{2)9WzA%K=ED;43FGq_ z|Av_LX_`120opZ;Kg}T{(s+fgI~cz!MTV64!xRis;&75@^RTUcXKvRJjjjd@nASFF1aJz;nO^CPl%| zWjP6}tn#yfx10FYZ4t-cT`4iDT`Fb#OOqwOH#6KS@QOPKAL96@+$(Wn<B`7_V_d zsPg+3v2SjWptyec`=lZoWqVlWL7{B!)iC6xd!uWC5 zO1#qNQpPV^B=O2m+>F0vjl_$y47gp+c%Ai`Aj#T8j9<+Os(Shq<9kh!5yhD>+`h&5 z2}KgG^!bqSg||ukU~caBFn%x#u99S}OLu99%~x6F^k)2^koIu6z%#Q6OyKx`enKLD zX4=J!fBsJr@dM+F82<~~p_TEajQ`dl5rY^{XKtu{ej`~T<}>~&#-G9+m$LsB#{0`< zL~+&zw{J4Ob%n$$yS>l&uIUo5F*u$kh`O_r6N&+pO@fC9`XK4Cx=M7=K1cyIsxr zZXEvtmR}FNo$t-yD-qv}k@x#pPU1~6oWy?E;|NU~5*}SU1$Zi7js4_#jx&kzPtKAE zWzQLm-_Cx*(*~`O@!4!2ZVt4SjKAbQDMy?w!EF`er(JB7uVs4lBHf#vosg;FxffTC z8;?hM()GOb%v?NAQ>3M*XBDL9-QyxUJs(7j6BiT_zyrMWBvFd1s3;@Hg@mWfo|xiDcg#pmPuFscXEuw1 z4|3A2e0&pk;^|R5^64(ZgPcV!;$R}4+0CSf0bO&&t35OqJz1Ytm_^AW7C#^=%%DM# zcR>4Y~RKnOj4mphFgETd?6MiH@aqn>D$IPvHsjG-QvbWv)E z3#BvoaW?r3Dx!-=+AI%X=6iE<#e;e-k0BbIh%1>Oi*kaeU$gPhX_!t#8&3(MNIW`Q z0!~v@kiHNvU&s}vkjhA{APBNqBnvlbDiR1jc;^uhD|58*np-})CW~L@9`cwB+hi3? zq4zO}hZED2FPpsVS4$SJJ0W zpE+sb^z@lirp$4qrl(GvG~FRQNImAtDG76^B7$xPS-80Dx+lp5Dh$r!drbv@(grr4$W|`Tb z9EytqQqy2SnU!fF&#syuQKc9T>r=eQ5#9-4RWv=lNYBVzoSwOGae6i$W)4yll>*_< zCv)oI&&4u9J!~8L9Inz@Jef`bS-a`UP}k%F)3e1KQMElBgjp<)IWtOB;dFAYG82i1cnA}=I2$t$$thy(0g-s$N%c?J1oXOE61mx)HL zU=`-NJVoTRc#_rPcB5oD$aXd4sct1ozBoxpo??D7p6QmBS0%?Uo=J8Uy7IH|)&)Gd zstVlnFlf-D6mdU~WOH(q?V!ib308qf&(O0vstncpU&7RaImOfF6koV?gjYUr`ev^Q ze+hsgfEr0^ZB>Dg+T&F~xth_IaMv1M&QYG27Rlhv6mZIrr}&A2YHcZhDmA00qX?#o zA$kNyaVEMGbl=Pk{n#^M819dWB%K!h3CE*Mal|O^$)Jd->hXRvn_&ypQM1U1)l3vg zkYc=FfOs5BFg`#HkLRJK~S+xY*Cgc?GO_3{8OVC}#2-4UWu?sL5 z%+L~C3wgA=FbmRDNXn4IUdf^EkyJ*W8^R!(l7N;%&Vr&MErH&9;KK0Xpj^j83Z~3h zdzF{k?^V#wcm*&`v|O~zZRS_|!U_(x#HPJ1>opO>zQ*CF_|>@x1=TqSic1$y?_>b~FU60}Bq)BhZ>=CN z`x^OH@f2JLemdiz!fJn8!6eY>3e{g?@k}*t$To^!?Sm`0o+F0ZPvw6(^H1VKh)#)l*r64Yq@f%I4W>b!x1^zI7t6%y251<}l}&Lt?Qha{-{N6CB# zH&_i3bx`2;G36TxL*uKkg8x7?8-7%W=~Cw$x*s6_m*64aRs8BaL_G7?Q|53{{i92z ztFlGQsuV@>t8)`g-%@N%vy1=1e~MqhR*=m6G6WpbzeGsWw2~cwZV_=st#ATG5L!>G zO@|1s`s%vw%HDBxcXij5i>{^=df{5|2D%Fs-Svd%inx}7uK9hRIZ2z8mfKJF-9KLV zG-qbcT%LJmo@btUo@eG1-Lh6^(CKtW{Ds3h-9|j=pM(FN;YY92^}BR)Ki$j8yM}Dk zdv*<(w&2di*78O7-m&PmyRBun-E+^qvi1A7TNionvEF%))j4^p_3nG;-99okwT~@Q z_1dS#u72yp)I-s~Y+v!gHxbYF%{VxfKW831i08Id#Rvb!pED1>$DcC}e#zh8bnsm~ z-#T&Aq1AZKTs4!&XRexh@NFJ{;gI&6!s9pHS+;=MiuSD7rPIxOC{efWr!($|rXAH? zX6>8M?@HZI(ZN3W!@tbC@nhk^N}fXD1f4FCCv`n_ZAc_!;-5iRimY0p=;PG5mSUZU za>+WK_3i{+78MR8=-Q~EbqPA-AWDe*YfaEqpi#?&1l>i^v>u+V&IFx916_OjqFz^w zCVKlfQog-H#!JgjA|O-WBmIb$vFdcCBNxrPO}Gl(lm1sBx&js-SAYWi)xt5Xl5q;&Il26I!7`bTiqB2y$aT36L%Cfene77&W7a0jh zI^arY#`A}#|rYOfaA$0Ki2WJA?kc+B@zy`#nUYq9t6U{!y`udk|& zhd<(B6~CzaC_Q{t9a>CBF!`#?c%UT<9<^0z`1SaztQcRZsy+)3b(UYRW6F92eaZ{? z%?U`#R_m;Wo!Y|Zso}%JrrAn7?102PwqiFMB>4;UlD&S3 z)x%mOf5y8%)9c)9hld5!i>85R5(Cv*VcV79CGrI2gkHYb$+jR9vStRro#$;Z9o$jk{e@hYf1dTKJqXbe8x zY=03OR0LLC1pYSw%_BgD~~+x|PO$R{U$pUv&Xk+l@Zs`!N$NGI(b( zpI-Yh^*_E&>VI1I`MrZ+J6P1M{~Huq6MLH9`+G<~3wTBlJWJ!7A$T&n&!XoEo=Nc; zF_UR2?lzN=O3QS&)Ch`V#-qpe=$WU{%*UR%ZWBBMyTii>p4a0uf@{+9f9gyn*`QnM zS;CV-@XU;FhTuuCS8;iu~rXB84}Zb z{0=^KA#P;IKhi@4+M&Ky7>6q5Ek3R4Z$(v4f+FJfdt(k z!59(bIkchv>&Ezg93cVZq+TX6T}KS;&G-yJt#Pm>;Bh)^tcrmk@{(kbQ(r~~{?zgB z4ZdW8Z(4lw$`QR>s+>&V@Rbq`<#fxi%&PMaV^hlg(_f`H*dvv2DX2>j=9So( zSgxqX=e`26`LO7z{4+h4Ul$KV3{J7z$s*~#xQOj{vxF$gT?owR{|EJXV(QCkP)-W+ zKy9&DOo$j6_ZDJ@u>hMI5s7O;xz3&`ULfVVpspEz5a3Sy&m^gWJbluw@baX zwsU7^d%SZc;3o%`3@qX!KZM#_7+0fma)3NrIcbeH`fKW>J1z@21NIT)!;;dWUoz0c z7tV>4?XtLRzDK!aL1WfMs#y)-Mqny@C)YE~o$#JI9``+tR$iMBkDtC#P?v*2sy~f; zJ03hEvzBi{qXgAC4$&!~@hj}GFy5#iuo3-%A0zY>LJ^kft6E3NzABoDc+jlIW25#6 zXpd$*F#N4rj5t1Gw0uDyeCZ#DY< z=rpaJwmp&BTOC)Ua&lm_Jp-+B_r$&B1LdotnbBMKy7AJHtBp2RKGei+m&6wt9!6?E3hzWYjqTIYV!WwK}mjDtmE!NIuzSk$fv`nc@tfCOaow#6FkUdlG&D z)RMeq<=)Ft{#j5bV9Fwx7Ney%I6fw5_-G1EEn>}5lhbDH0DD081zPqhqUo&;ovu3I z9qwj{65t-UneuER)TkNHVf=hN`3lLO`UA@D%8w2-knE6{Y?CCm0#dEAHCw#3VUr03 zIXz4M%1R1b43huHJe20B6fA{ng*0icU@2H9q&e0h{vzTpA|60IfOsq7t%$cF-iG*5 z#E(kQ7I}Y%x`Z?x(kw``AdeM!tcYhLo{hKzaR=hXh!-PXig>BS3d<#*RL+`$5;#?K zj2%;FiqpiIQq?E50Mo;MX;bmc347RUwl;*YQV7FV*h+=06HZ~6(^l*hvbNBy?8C<| z_!FQBbHd@Z0ijP~odo{Z)58134N?4S!yUX2IgbezUjR=bt4aMKG63V(A?-0rL&3Qy zKi@5^Y!$K&(enh!@W1U|5v>Hm%)oq6xH_udyy|OkZ7mSEDV!v z)UbiQ!)=Sw6Zt5HqVV97_G0yAoxf!a{<{$oNKrVD{`K*)NRo*h*GfbR8! zGhl^#!N%81_JWN#sK@uRt&*PXWg9J-K%d9vIOY^Asdo^b@H&8Gv38uJ_5nO@;PZtb zun=_hfUa?gMabH%E*M9c5~`m^cE`2tV(#^FrX%-H8wn3JKSCnG)c;60EY@D{@jJmL zXt(sZjTUkBdAm+$ZxSYVDB*;Nm>f0;)tm562^)p#-%zEwFZ0aaBuB1n%a-#{`zF*b zCyI@U`p^)n|4+ei*xs}jpz#Wh+{Ip@dNd|j$l!QIFT7IV zt##=tUnN*|@+FSycJDy3F-b3JDnc7Qu`8qT4`t&8y25pbHsq8K6COG+2Cwq>7BCJX z$WT(0%>c6jBoKxx@sxmh8UajEU|Pt+P_rf>3$qs~n7UHcR+{AETygf?sDeD6zj^z{ za3ySZ+PA#r{T?RvK`?hri#@cW4gxFPL>!i9^?|CmzFj$K+@wP{MBY_Va5i_oiqaZA zPtzXA$iiD|)mpoaT6+PEria!xS<#W68aRFZrM&)fRE*x}seVr{^;^!Xej~5H4GS~s z{~4{%pJ4j+06zwGU@nG4Hefw3{vX`4J8LCg8fqzMdJMnH-+| z8a~qqp4mOav&qp*8zf($FJ6)|ttcCvA5lR&g71AKQG+YS%^$J+xdg!Py#h1nWfH#q z8Ge!>_K(r&HuI%PV~yBjXj7;o!7DV0>Y}^Um5crQAd1~ zMlM7>Q5stvvlRRPO^27~*4nV4F0Avn;)Yi`kkWDf2gd=wo$)xfS^@WeZVF(s! zoGr+Uh$ZYMmT;S!By`oDCg8oQDQpd zF79Gpa)v^T>u&HCFfK?g8aLoju_nUcTx>$SR3dM%FxD+OGQ|)bG0IQH_ z!2o@sP1;W$LElH`^(;$um6BK=)$}uB`j^n+pWCba6ny{sID>)Yn`X02oi5J6nyY*w z<-89`#?4fTZSllOd&*V`eCpOYvl@EV2aGj+qnqskiGsv4T zV12lC4k7-VeuP2Uw!j17v)r4HAy^FDgGRQl#t;bTcf8E)!DLwA0dVCsFXO5s1RgA^ z`G`xpLt(WI4Iv?`mUl_(T2W0{{$5c{yLSj0x)xc`P+vUMUtn*ftc+apNKRE<4~&c$4m)K!8#+tgRs%mcn}{F z+E96uI5I-Zh&R$yT%+Nt)dyS+M$6iq*Y;JRDYP-e?&m9-;5T6YyfMjd94)ckYUS0$ z7O*z(O{a~JmPu^fRs21g~@3p+g=doEm7|6`25&RYByzgf9 z9(F9kzy*z)C|ipO?k@gK8}?hZ8T>G{vG3ZR_;;jGlx<@VEmR-E9HSwtAOV+{I?*pM zer5*lz)miPf6t!3*2#<;IRh8jghl;6^}){Zm_FjaU_6=u4^X(Q3Mkw<{A|YKpUB$Fco?+G{z{cCMPROdq#a_BtMm@d}lB@K8S;-;LJ}rdH}Gu<6(MQ7L}Fji?tLz4Qc6j}E%yvREL^H% z1B(19`5v~-jSbPgm&I;~M$(382yKWipdFvG%`7QRMz{U=qU|I*M|MWge`t+TrKKb> zm&7+8BTORL`~GOW)}y}EqZ!}pNm{0wy2;z_Jh7Y`@n&nKcP&ThOqAB9k0x+yvbI#S zkLSEe%Q=~|omhDCMe`Bzla3o{@ zNV|zGT0NorQP1@~*W=H)`vJVojKb5|3&NcC@7t8;JJ2Pfe}d?jwzHytWbKXq@rvl5 zDw~PQPDB5@zXSSrV$nTUew+(fqx66IdD8#4IUZ&Wg)J38VLAXh^ZGb$S+C)}!N*@yGzg|Lg1HQ-B93%v%Z+Ru4Iw@%TNm_Cg;G zc!kQIp~^<1vfjsI(~j?AJl;I_@yG^V@)Zd`8-p6Cu_U~dmAOxK&ebl1kk@5KQlK+D7$OSw=;XoNEoCko;%n)?Vo2 z7kGurR#0UFP+9Ne@uTMNVm$Vq`*?IL?i`QXVMshbe&sivSfr2f&w|lTc*P0v4kzPa zV_OH!CtQkhVRX>dI&Imc8ivDdHMgXZu@8om$GM?Rt;!?|ML@O+udKFJQvO=*!tsj7 zR#96^#?U4QxBWt_kYfC4&N?A&;yT1%MEpg> z1BeF@Z$-Qn@ixTU5I>4I{JGSqKUWgcEJ(8;j}>{Wh-V|7jkp7G2jazu7b9MZICcW$ z&o#N6Z3{&-+?praLb43VbiQH*x1NwYT2wg2GhV)r^H+$9`ZV7$?1%3K8mz#Ks(v>hGR_sfieK`Gb&n#q7kzwhZInC6~vr^IktgzWw6M8LAG4jA718G z3=$2=3Mx-0%Qqj@OUeGJ+3Ov! zNIAaAfsbsfz;~Bz^%Q*H2U8o6*5@7|Z8{){1){U^*`4@49E0yAD1)M_s3`H59`LOd z?8G2z?=UIgPQ9#_j*D+*_B7qkq%Jz8^t&Gax+GR2G>~G*V~sKc;Sz zeN4TJ&x%cWsK(B2_vC*35Ju;`+>cN3=fR={e;)F+5~_*JXssgm9iuiwuOe6~GJ0OC zKt&O!9}nA&GHrKr_=9+;GT?_dYM#X2A;+U_QGmM)dVhqbrqk;P4o4V(Y??=rDtTOE zKwXK%Z@~{wOP}Op!kv5aFgPHxAN&B|{5d^3i#pM%v9+G*^Bt5y(L+@9eiZ!<=(FYg z=u;-hK%XD=|90r}9PoKUL&~5#ft1_P{5kNuhfoIiTth{#MA2^_pXuj`Pa8o7d_E4w zarR3|@BHq}`0QM-_i9Mleg}|}f#%NvpVu$o_`CrR^}V$JCVaky-Vi>Wfa*Vt&!1^X zxqm*8vdwZ%`1}XTV19l^Me9)X+n=AKu!%dJsMFheTuqPxpZ^m6HP3HiXa0%e~DG%KRiEMG^D&&2BZu{^XGui3G+BU zC*z?WN&PPH`Euj=;qxQ(hVVHJQ2mGTsn_sX_kAGc?UZxEXFJMZeuk;&(#{Iu73 z_qm4j_e#;sP&9Kc^BrC=(CqC;nq}0s? zQr?Eu?Husgjxsd=sp!)v`t9S>w(b1*$>RhW&3{1kAI9gSG?e~~F}DIKHLyyb13rI^ zGAQ~7DtaS|e*5@zZaqJIIteo1^W~)fI6gnnkaA=;ka8WGKL>oyn8Wco7Z3F$j!S&| z_?*{pe)#+sdPDe}2dKWC`PnOfhHmdDl(61RY^^V*X8jpIodtvhp+4msV}1^-+o3hC zZy?n#lrA{mOA0zG*JfFB!fy6?5j)D=()r=4$dS{ZN4EXsneNvZ!}Zio721h)(GA_N ze)A$XMGVqTC;fmFc86&jpByKGWHOX|C8Wqlys)CyOmXND1JK$qRtexFpE*uHKxb7*g(uO9B+@CRu748z$)W$o zp&;&5&fUwW&fw}i(wX|PgjZ1)|*yM>6Q76wYD`)gCC?-A!9?AOVB01sCOrmHB#|w;jC{s;|b& zC{Bdx{**Pm1$wPCWGJfHr=7sS;P0h{bM->f{Ky$n4UQ>XfV{Xft_?4OUjkA5kTuPK zY^{&a-^KgLTUpN$S&<7Z8GP7%3l>Peiemhgczop!^;bNn2jk!?$Rtf?lKMj=g$xo< z;w#7^6HRGtL8)(fc4NV9ddc_di%?k4_wj?MQr_}Rxe%ka0ID8efmQM?w@8=~Ml|WD zT@FjitCa|VXFIR=Q?p1YcKos9&R*oIq$F`YYq) zXzB}?prI6sfh;mQEK@$q-FDGjwEtcUO;S{f5{mCGu0a(}q+ix!+EuA(k2 zGQOw}C0rZ85qpV=4w|%ABLie5KQ4fjn0tZv5|A~`mg}M`LvU>jMY0=V)6(I`st>pF zYbZL+Q#%RwUVf)0No>r`2g9TW@1&6|%%ayO^?e>=`_UCGVY`+<_myf1o3sSAGhw}! zaI`bwNuIDnT|-aq+|O~=rLTln7eLUa6cg0tln*EQFU8M=2fzK!59 zVfJ2O+MAd|hZh-M)Hevzb_mlNjtO&{G3!v^>g~c~omNH~PJ1_gMle+_yA9{R=_C~H zncS{TemV{XYB)fkKxs+Cnj6EaBIAprN>LBKY)M&`3&Y(Ba4RS0Rzmf&D9D}e)R#c6 zn$5(Y@ekBVsW`#5ho&+a`j8QG5>9q43F@cwh%Id*1}8}MHGzs5bQu^fg^|kkZ^kS^ z#vRzz#3sW)v)jYAiR_*5Ok!B-k@=JXyqn-D zB{ls5bdJnYx5l%7e%}aPe}Qvh&5_a3?i{j{81j3Z>*52Hr43M4L)3m3IVMaOn1Swm zB9>3iG<;&VYTg(Q_jZR_WW9~rTcemo^Cz&@3a=dDO8~h1kAVaNjBbkBL(A)BfQ8St zU>#oNypJPpPOyG9>JY7!GmuTkWsTkHQ|LV?FVRtZZ)u1w)j5vxgqBs>i+*@mLN&vw4(gr@{vzTpA|60IfOsq7t%$cF-iG*5#9==^!tKX;ejkY2 zf;3D=g_aD-_b@$hVITPz)IO|v8YtvtQ2Q|bA|D;DM?U_@d$J9&CGb>LC?K)NI4@>v z=;5w!GpNT#(Evr?a>mTo(1X8y3vVUmjb_AkOD;h^3Za%({#Zi~p6><97XeY@ZXC`| z2G@Olf_G%Q>7w5bZukkRJ21H^Qaa+?Ly@Y0Qe60G}6}%=zR1trH!B z22pQT%|6`8hwI|9=;uPZov+VEPW#H%tOj*AhAU)JpT$FXg}5W#?$t`qAT)%ajezh3 z)s_{^M4<@W5jj?KVXy*ZI2z})sN*1-(hVNXD5!1&_o&+sXAy^EgI*b1Zv}3Inr(R1 zWO@k^0ztK)+3J8iS?vpct=@zp>V3p@{29k4l4zZ}0}u7RGEQm3)ZgJ9vRm=~x7zz3 z)B7cO-(;GNO3?=H4hh%oP%lVCs5L8r5W_2zH6OsyR+)M@FvrN}x zvDELOGBLb2Z2I)l1Rcjw2p6Aet0;&LJg-X_+Jvo>PEA4GYr(-g=`Y(+cY>LIhw?Rn zRjE<3<%1D!_L&~X3-x(4$}wYA#{L!w3Emu)BzpDxc%hD^E#c4~B3*}W6avg@;#uk7b|WeuTUYXC5$u3fuR!f{()2~KP}GJVCMb;*pg;B<+Q!_AIzKXAA$3waso zsCHFSP9XSqK#%L+aQoX*hr~>u%mlW<%uN0geaIZnxM%{d+ulziYt8#Y_3x1x$YSr3 zclUGPPI%?SD-88xv9IbdrrIkdtoL4z`mRN>oPAUbhD)^2j>)9%0gFYO6PQsI7wZZ^?Y0}~?7?iu_sV2+G)=5&dDLIev)-nt+`C%t;@ z&ktSoqv7bEy}>I>%Iy}++#*Xji1zZ>p*U@lB1!B0o`x*+*)589uOfBxAxGNLI zj!N}yRw)PJ9M@4Pr(WV@P2X^kE=MG%t0_rv)=NIq6aoRz7E8xl5q*%Nm~V3$_ymTa z0V=xcVkCx#CZZJ{zZmggE_7qKmum>ZxL4qlEOq9~7#GECQ~v>Z0ReJfhrq?({Ry)Y zV)T&PC1xC&4Ma&yGKWkO#IN+6z)?wfDOJ5FLFfG^m$0%LAb=kyd{MniwX#X-&xzLz zRLf93$gp)juhMvJAe5x8`9VZR%i^$rnOubl17`As#*?CTy_-y_UMh5fde7ZFlEn3F zp-&Wyi#9B=15|cM!PnKkqH1H>nP2EpxO#r#+1EK`AY9i<8u=G7HqV_8T|@q z9IPGxAixnz`O!}k zAfBW2cEoGD?1i^w5#c4r($}<=6!%sbdGc zciG00o*cTAb&l5Af(>%ks2pguPOUjl^$*@=0ASO!wluD03WxM1{ zx4G?mOG?zib4pgGb9^Dq%lYzBej z%!piBcR>9RQ!!^B@Y1*XeQ%QVaK@GB3bLRdQ9NFX6kXi`*;u{Lo1%UXg9v`S9CJC^ zVVYBZ(`~~+Kg!Tylw0F3(1V0O1IHPeK*jqq0vK_mIZNkXn zJRnE`aD(i{jjaGl?Vkh8BO1=Q4VfkO6P0Mq|HOX0gs=`FKb$d{-k_d*Ntp*1Ny+bT z<8OH;4=#U$vL%~~lzx?7Ad1U>%3GqzS>3RhPV!scjrnrMD zCw$Yt_Rf-&RDEiKEpG?hBt*g&FQCufZr&P-&VyVzbAJ0L3GB(1nz z^ovOZJD_6601)5>KmbSB{9*FqzNjPtl`KYC2m>nyZo~xF`K6Q8*?lO35?c0+HoS1! zkFMyiVdDMRmskqZ(3e-i{V*nN-!z#L5haM5Oge4~X{WlF%X(SEm@D7F zc>`O6q&Q95CfwVIRYky84&$RJ-0PcxS z)djc~_?9LIb?uLFZ&2j?paa)Ua@|8S)DIqZM4bjUQN->r7qQW9HaE9u_`ljG80U*@ zl_b=B&c_v(>Cw8H8{Ca3+anoT*k{bS!|1Ue6&~D3Y0e$E@#v_aJdcR7VuwX1RIk&5 zDSCM@UZ=R(+it^FViMWmR!Ek$Yw&*M%Bpc?i|=mpW=YD}JBlzRNV$@FD?;kcR?bZO zZKhcUi7lKl5y@aWdXbZ&WC);6meSxh>{MrCMmSkNdW&={?rydVccZ)6M2Fk(7S|sk zoJ9d^IAdfU)sG_KCc9mD@JcXgepe3U=GV}eo84=55C0@cIvFS1Q)Flv-`QK*4^xb~ zyLc54WtDHp+2;bs8pXB~Vt^J2_l8_bc@S89A?3E@;m_Nbf++~5$VuTXqP=y|PJ4eZ zsd~c!!fF8JmHY;sY@w@o?W*@us^5D>Xn=nru6lo4^i7nURK-jBBEwcO+!}6jGJ|OE z5FVV4E^w@P{MazM*(~ff@5*(v#Rz{$dIWwO6l6X7c6lI{(`3mnCgZZ+I`fzmix+;H z0o>7h3|{tw17JE05&!CNMoKPFj?VR$SSD?)_D`d+XpkUme5$Rc5gG6}u-PfMt<)k( z>M%^Lc)9HtUg66xsfsD;S^g`}!H zK98m<%QB7LA|_g|vYH+nh-*w}`y*ykA4W@M#YSwF(XjJGkTrBkyUqfv zFfog^-l#QIVo zK|z~*LDdaKlkx0Rbpv%xzAV&Vb)!+GB3rl8tYV4Rg(d7!AgzKg@Rd;=MnL&0P|+;2 zdJ&J5WT}sRpWofaas99s=1gK|*Zodsij!yoVPTpr(+Lu?xSQ$;y<`&8J|ojz-$`-s z&0mcsip_Ya1G18Ri+p*^?!w1K5W8eqggewE^OB@Zsi>KEX}AZuRTiv<`LKM=E2-pz^SncGjc=3uk-<1rSReid5F24&svi_Ha%+ z_3{pyY$hmJLvvWF0Xfw1c#pJ6n=4V)e`A&En*yGh`mqt9L2-ds&|9>sgSBj!OASp0 z6%d=Si#|y8q_Wgkkr$_8I?MnU9Vw;?_JlK5a6J_6(u&*7MsVm)eF>GQpJ2uJneImg zN=F#`Yk$T;0bn<)&!aN5-LJ_c0!h>!r0FCTsk+E6kK>4?j-#@`bc(8?E+zFU#G?w` z&a)Wrqhb^4;U<@qA49C)zIh!~OzKlwGihN{KfDe%Kr&qPCU2=vv?V?uk#W6P1$3c{ zF?1Uc2;&M^URiTE<2R6KJu1^YSFDWyX<;_*pbHzGxpBV@@b2Pr9~&7cRV4SEw* zO(8*)3`DH2M%)9g)6*d&2cXb}u!ixKwVYcXyRV<9&&rmikg`4q1;%jy+%Wq}-3-Nr zdBN$$wF;+c4K`zstDNZNJOB%IRhTx54qf&EjjIel07oUZ`borPf0`;PV)=;R< zONkBg)ebiwMs-2G$Ux87h>*3*;@ot9{tood1zo{iDe6BU=DKqBIaxEE*g3@W%{7b4 zPJAP5mc_-ky4WY|ZU6lk{FFD`ej{_*J(v9F;KH0> z!R6g)XwhLMZ#6`-VYsy-?m#>n@nXash?gQ>ELdtQQ8SWCkpvp8q+vj`TuAfL8(1SK z1r4QO1L_8?`dn)u5l_bRSrFJ+2m&99T6dKe3r*o^dz=P9-r$E z+BMR?>2J8%1zh%%np}Hmrgk~}Tmq;=}T(5LD>os|)@(3bOiX3?ndb$c=|4>rS>KrPL#rIAgJ?53S?tCwkY zadL?2J4j~fqoq>;K&$DLLGcT)p((c#)Q}c$hI~RgGq6%DnL+g(TDyHEr4pNytF~y7 z1!{l-Y;vwLeq!9zVk7J&GA z?vJUb5z2zdo;E^T?*XW0lqBDxj5nxO>SUX0dt`Iaz51}4y z)dPUsg57Oh6|uhgQy->^(Sm6S0%UB(cfF_yY-aGS5dsw!1YUPvCu`KkfvOietLMg~ z&Ni^8DJqjL!Y9M9ufW$r^h(D!-o74|K%Y^05S0R7AYctow6uc^_p5hv5;IF>1s9R@ z?O;wbZWh+q4E7Z_U4+VPi8dYap?PqM$a$Sj8IUH0ZhDy`xD zMZY_Y1#vrex|tDZp=J(!ss3UHUtqfM&Hdy$l@hob7QS1MXJBaz=7hz(3ZpC(l~owk zZ%%@k{OL&{IIz9zWSF>c&031BjSF&EntBMYG5vuhqhx3%$EiJz++`M_n$(tg%gtVM zo?XE984>%6KFDU445;a7yP;CPR%}nS$Ri|XngfBBIttxD0u3U#iRK>$gI4wTP*}o; zGgxzIZo9!O4|cO6@(2>D)94LlG4m|_LN}mBy?mpaO-Ba6N#0>R!zTz7l}&(ZXSZ5@ zA*_(f%5<|(L+TPKZ=6v5a|*D2ZvPCk+Wa}XxqVI>e==cOvEYz>`F$}j^8s}3SSZO|R*rGHR^0_+ z!{Kr{ADS}n9g=@0x-}_F{q<3DkvW<-HxpZu&uOBU%?0rLMb4v&=x$-M@u`Qg=!CL6 zi`^SrY;#w!t^&V8fwdZaa1th$N1{16$EhDoRnCWrC!lawLW88 zM@5varJXAcZl@+bKOLT$bg?+^3dFzt5dX4hM#KL3C8&Xmf0+{dizYE2_ORcrM^(6j zjGR3eK(e5Pz5=FI4$0l?AWy^1t`rN^=jwQD0ii#~)>BwL3mnuw(J1(DLZHe{Y7L>L z1yw1_GmS#c8wjz2PR)(>ab8JTo~;vVet~!DjTk^lsjx!3_#F7XI)>t`#HwDy1BJQN zs@}sYAOo(jEl?AHJgph;CDepBGp72b(7aOB)#S*ae)bu!8ZHF+>W2uUl3evY1TcPl znJmrKsr}FwD7kQT_a5~a4-3`vP&#PG4_%iITugwP#MLbM9tcD`_-8D5S_hv;CUT@v!K$kxvnNVs)`b^(uU>P_PuW!G4F2sx01bo-eEn zK%6gXwYxe5WfdxLvIq9l*Igj{7S%#V#+=eY>17eIJ%W|Zjcta$pqxMg4urL*{o zHc~A@nrpoXQECm=N!@%2DN?;^g)Kl>GnnRqVUpRE^O4plf9orHigKW*Yl&6<17KsV z_$BJCLS5KOS6O^6i#p>=8lOUlvjJ$nrld%QEhHP3t7D@tkmzJ1ETL=ED|r&G` z5l|Dp#>Zf=6Gp9}Wd885qFNCuSo;G|z&=8fP|{F9aOv0~*kA|`eubKqRaTwcPaOl| zm&ztv(I@W^HqlnECal*B)d!G+@7#B*M={f?A;LBysWU@OKOmo1k)|HU=o2o=CZd*B zuwf{=cBl`e(1a9f)}WZjUsTCGsox=fb2TWU&adGDE|Z*0-y~)MWdQLBiEN7w9k_Zf z{;-dP8gc~~22!m$^-HW9p|LbGmyE9b3)KP={0YHUvkt$6Ua*&3coPCaDEyWaRb~;L z&}>!jM;`Sj^hs@{B3B2-&5Gdeuv2YJ1~;kNO1!0u2hEz(@JDD{cc>%q=^qUFdi4%$ zzaew2e+#)Oz7(hScB;FI=yxL33Qrhy90g#nUjY41mii)pIc^f)FM$O@8-%;fxdUe` zpN72_pjG98TtN+B&!8} z&wioiacY6Nz&mK9P^4623r`XxyaW_irKm2#4nWVV`Q1F~g_t>lMT>N24WK5wwq^(l z47}(QF5rkTh}AYS-;s}Pc_)`>?14*61DAN5>q<0EQEjUP3PpU2Y0c{h#BhraVa*Fj z!A8*xv+XA_?1ESY_zzTNb&}ydWw}u&U*jn&Gpa){&)kNs@?clZN1&4nNL(o^gd|r_ zf<`4U?ww7ynpgm8yTRd|9D`ViJ#Hhp3%CW_FG0Jz@hpZ;2!t*9H8=@(4oboG2J>v$ zAZWPUX_NFC2msN##c(4n&V&)CUHgcX@L(HXjGwV(5}shVrfx?qDOfqx)i3ZdSxk`1mKxPG zTF3k;i6rCgU|;0k3_*4?GPEaE%6-~hI*TSUB7d6tcMLoPS#Sj4>nKUSUqsR%4ZBDh zmh7L)g?V$0$h@(K%#`LqPPY=Ucwl_;Pq27~2k_-aeDE(_H+(zXCc*)jG(LrlVuUp# z@5O{_mrgddCz)j%7jzNS%L5TKQmRqzCsrrIogzs#y$YP+eo@@%LxG4y)#*|b<7UV0 z1YD*%1%IW$8$Z&~tf5hT{$psfC#ckIO?$U#80dKO_wb`sICS3Jh@~VuPw-llRhfdf zpH#J~l=MCFMR^0@Sz^!_^kqm{)Th0`rU&Z;fbA2F^Mz`Xw`pz))yt8lyvFGZeD7{8 z2h7ZQ1H7X>Y=Sj%yGGM7`bY`nn!Aw0UI4k~`v^d5NZJtg4y0~%BbKcocELJ;bcquR z6A^lJVf7fwXD>tvVl_~tWQ8E!K}g4~9lKNkj4*hdLzANOj*mi3%gUm3WjS9`J_h3e zsqiJm8qGod5+3{up}rux$ov5@4KLn%fD^-_1y!r8lyS*iiA~H_@KGLly7~fD$0oz8 z1WU{mv&XPccF_G^B?M$<=9|47B(GeSBz2S`4FUCe= z9MLM};X({35TzsapaK-2a&^_b2`tK>N|aUag&4r+4Cy#aq29DWx0wlrrPa-rqlphm z6rUjxQ<2T(MsY9tZ2Oq`TSR0?; z#Ql4?4>ugskVU-*S=t-)a_Z(x!YQQ7*Ai%n;bw!*Z$dd@#dL1pIN{0()B0j{4tb4l z4Ln1zhI2gzeARsVw7>tSu2>3Z^3mB<%0 zX=@N>I_@~*`K5Bnx0(Y9?HkhFH1T25P#-r@|Myd2h!d}IKtmNU($Er&ZyckvQtCh! z4Q>!A?TFx0Ln6d(HHgpA(A1>vd;D%I^cIVDug~7 zBy$l{pZ<{0Rbf>hMZn`*fG*Lrhc1Y|&)HHK^<1DlK}CHd}90-=q{n1MdPx;$|mVg&+;@ zQFlRDR9}uM5UpfgOqy27BVCn<8wrto1K6ydOrYQ{^?&d_1Xlh_?eewA&0zdnSu~5X zXifoUTQCK^R-eK&h#2hs2*O~GPRk~sV3n;4ypbf!Dp55GeYR^>gL+>9=}qpU-%hDA#PDuv1=X$k zOUNK@(1#oCUY)S|K2C%1uNLcogc##Qj7DDlNQ}sOSfn87#f<~LN(TXN*vjIZcD0z` zD4PuFt5KU`gVnKJN!kn>K?#v*iq#1_o%Vl1X?@#YIsX_E-iGhTrQ5Gw@kbcpHH3Ex zP9V&=PgQNiglGp%VIv37~)8^nCckaux=fo?7a|7qdA~FWD;dIBjKA|p`N;sVU@rH25=ND+A zK{=^l>EuIk=UKe2@r8A^s4uyd4By_qB}vYzOQ;Ui8v6*|ED z%xl2-82iBDj!q=F71g}td+tr)Z}`8J9s~3Tt#0L5xF~0@dy`Jj|5X*$?3G)vbueom zkBd}a-Bo=>^+&a~KC(B`+MQ4sS$Hn_`;nv>T8^oa=)|rZj!4odEyp#H=+Mq8E{&x0 z*D_eNs8ExS$;kU-*e=07r*v2rx!UWK=qAGY+BEb!^f~%xT{IB3UCB2Eq&x+iwkeqq z!>}-_*2N#AOB6CMN~SE3&ZtDdj3oV{q}nvp6Z(Q$z}#Rx?^~?Qvl&?OnTnA~RlwiLoNT(0VxJ-=vc;r36$Co=<@6Heg-A{Wy~pU`X5r=L-sZ%g$j z6Ft6B5Qn!ZZ8u=!8GwgHD8?Ntw)Dh?G`dqiz}8v)WFoo_vQ3=~py18XSKWtX0C|HJHvoq0aK=jl z-jW-*@>Ql6ej2G(yjB~=BdapBKf+OJrR=a?-iQ3)fjoRS4-@aM%Y@?X1hsCc+96>oSjkrAlGnFd{;feOsaRhZC`AZ7b z_#zb|2Fa%nE<;eP8(jpOn<%_e@5*T>GeLr~C&5wq%~gV{Lrz3sxHnm>%XWuRZGy-@ zn~TB=9=Z})z8t{NWXuJK6scRG{jMNtp|>q zybRoCc8M$)N~!sDBRQz?;yL?3W5>V5-rhf{weo}p+is=4HFS9wY=}P>>aW2@up{0Q zGC<*K-?ca!-4$7*@P}>wbaPINy;b;OeNMn-{~QOvg(m}jo9jPFP+H7=PjH+VLQjEL zp#${&@C-3GTehfqU2q>8i&@a#WX7pxR)DE(r=`>2@xehn_%J}mrb?%)bor$)a>43> zU%fm7zX@`Z%YJmpl#mH6FM;}2Y;nm3$1go zeZmc=kH`X{;c@Z$&|qGxK|BseMc7sWhnCrl&eAL`j&X7Tb6C(N=0;_LSXn9?tFfc* z2y>58PMCx>^?(Qmn=rv>bAXR83)K%HiN3;o3y=MaVke-**?<5m%zA^yThcGjWcBr` zaXl7fT&uy#J0elJAIzT1lBMGZl@^DuFpJxN{O_SmQvoSrbo|&P)dPMFwo;I3j;Tma zl7u(PJ3@aHHsJRK%0^|nvN@_jm<5@X?{(y;6JEh@wGvDes!PEtIK(q~0AHS;gg|gK zeh6=5TPKH-oEG9DU?D_w9HChE!HehFtU7gso%}L`Pv8}`4TccYw$@iTiIkOh1XEEh zdL1-T^<`7Dl@E@?s$xcuC4XVDI-HI!!K2Qolw}=iEb!=@b=x4DNJ`iYS8(=@x*fal zP!a-ZXoMAH)vHPC_438aa!E&SD20y7ylmhyT7*_rn(jdKB6_D?s?w_Jd1n;PB+e%86x9+ zI~dmg|2VU%5=Zb@P#cRld@}C zR+-3A$mSQrVqJ^qb7WV30RK9Nqq06*tPdJ$&F-+|poGvKaX8B1(k5TAt~ zh9FX3?5f+3Lu{usUlnQI<9CEThWa9(hzbMHfkm3%Cr_g0aaG2~UEojR@x%2;40T%q zZ3+GqOG1nD%DrOc7A)9X#JcUMKR<6}Ke28{<>&gq2d2vUqy+R(bP%9!)GIndzj6&1 z2~d|$1fU`T3gsg~=VnzT!gT|Zj&QPAAaN4JqXEgLWY_E?6z!99;XEwX?W;U2i1kN| z00{8bZK*t&w*=6rG!@;aODrl*9WUI)B~Octm&6AQW46Nr{D-`~t4Nj=G}|>8u_$un77JHU@8?=7ZyIp&8k^-x-nS^~NWE6l7;x<_lFZoaUphK{g%eEv%QfR@99?N&CKSaTz1r2G|l z1#P6|I#iNBR?zF1y>egd(ChSdt?<+NCxUpD8%iGG!j>SJzd`!v z#Ja*Qb^82l`M5X++tevxD9ZNYY`R!yBwa!+)Fs|8h~Y&3Ika7$l7}`=c->ql6V7PY z>2;N>EaX6v?M=zq*ErFF9mq^`2tJlGq1c0MOg%Om{o_V5ST&Mxjv8g45+Y$KmxQS# z(lyO(P#?UCG>jhhSGNx~FCT1PzQx=p8?w@!(93)d;3lW`fj?iL+yaDi(xt}<=tiRV&8E_ahU2mbTN0b;+LbP5F)-(8ZU_AZ;V4q7kh;|eU!+JZb6d}gXAA)~9VIqxp3uzEbg*!s5R z-?H=qxA1xZU$n6*ZL7pO&jfwQ;HcY$D-&(PD>(d~-mDy6g^jIoMs0yD-z+Fp4Qr+f zp_kM4D9120xv>AV7Lad6OrAnNm(fpuzGeB0yBF+GU&5XxG@rDW&yv_ZTdeH362i5A zDp0*c4Z+44lK372-N|H92ew1fZeL+`DBE{eb`T#2(D4#bj7}X9g5m?4mPk%t;fR`+ zWywlmmht!jL|z1;z;_ny262*#idkg`elM4=!S8VSGW=czAKuE2Y@vpHTT#*+Bp(Z^ zA{eIL6lUpz?OMPZ{8S4h1V2JR^4*mMROk8@1F%sDd4jtrnJqU{#F2Y%mKPr9d(^e* zSP|fhu;JN_%~`O5vib zRVuvRqP~q|cBj@Fol59HbT-xe8RHZ`6Kfto5-YF<&3FQwGi~zttd_t9C~qt^AsT#+ z7(W>6skEq3AP6$=Il_h45>qrd61-N*yVK&$rc~1BXj@BcHi?emL`I|vCczuuF#-eJ z91i{(Q#xG5scKV%s@5V2RQ2~u&qP(zkTFVC62j+6RdiF*c~RAL6ePM?lN_b0UBE$i zs(J#x)Tg7W@^hxDzoA4hPb+pBs=`4djjFh7A5oP_OVJ1E!%!eEYw!y#kPtjVkp^W)>4hOXvONboSZGC9fa>t50u6U zqWjwQN91LVp+}+1P(I166Z7&XcrR?%!-4-!j9#N?qeVP7_%Y^Q{v@x+-%QrtfESCM zlpjNyocus{UFw}8Gy?Sw{1SA^vQav3W4>FcChvxPk9Iv|{xr=;DSv^yF#iYg?EHoD zsC-$r3bV1yTK|^n;%v}iQC|VIk3;8I) zI>9eR^ogUmf(i9tG13Kno%t7ZApDsys^^(`EjA`BH}kmA=QR&T>q z+M9z(P@QTX*AwBLf-BA{(QN1f#hqmV41>vM!lcdy0N6Gpfr$SB+NfNf3+KTD2tiw$ z6PWLFwdJ(ex(;)VGF3dBLWvYgY;?6<70MK=ck$qG9Qd!_tMbP2#_DEY)=kaB_U6jQ z^@qGdCuAm9-L{ayb!~uNHLX7+JRX2#>or1{9^B}>t}R;}^A3DX#=Pq_h;`pMYFAwM z0bC0boNW0B=kVo{bNDyy^(o#`4_j=`As?reQJITz(TKq57v;~~PjFyFHp1?0la+A( zX9>&-mkMOELaSfY`wFbeiErQrYWTNk53hJBWK;^RkbS1&*ukG@)giYh|8i?g{ggs= zdyV?hxMYg?u;+gpr%;g9(7lJH^Aw%sK4@HjZ5;c2(IY zTBVG08W+MlcoTLCI<-#()C-wFkR}nJsiNUa(SCfz8?e#{;mYM6oo37?MYr%s6^fw| z2X1wM2nLWoatRw!Z~(oiO}V{ISLB~(OAt2_yCpVmRUJ-#L;+W{xZ3EX+zkW>`rZYa z5CzR^a_W;p=`r2?i26DbvkxHI7fasNArT;j@*{OPSphtIraF49tADgEH_n%%st++i zl^b*`W^;8PFt$yeBGEv^}X>72YALSaXbSDe^19V9H-$KVXP4v&$y0c zL(Vg9Ai6$Fo-vv@%{lOl{_wm6&+uTXbn=Xk;RFPpkp%!EJY!WS&sY@4GxnV)&v={m zSYlnkaVpo?MO>o=?>I-{Y@;R0HZt0>oxq*RHKx&voiDMC46uzY32gC*;m3wAmWXG} zg@gpRtP+qt?#R_B+hKO+IV@gmA1g9-vJrj~Wcu_KT0>AC5^E^Z!$H1Ns%+F-BN2~2 z3-!?bB4(Fim(#v`#q%1$Ew?(!r5Lp3@xMxqfHOd`Ma)5+i!q303o{~YVG_1BfNUZI zt-&u7_aomMY1bHFxgO&4% z7r>l-cFZ8h!I{B`C^NV`T8y|Gb%``|Ph&>73|~5l;Ma$S5W(YAFD$xj4-q`|6*RAL zmwS+x;j~=E%r1)dXq|PPV^`634_%ER=1bl=6ERDQNNNTV$AldnMPPOli*R2kX^O|O zDWjAl39^-LBOaifOqMTzIGZY4AO(ylTmPBx#FkLvAL;u3eIB3NAqpFG)%)bkM$x0+ ztAZu^GuA?p5@D-T97xwek&XM>qx_@O*N_~tXa$CBfg7G`0?RI>CPdpI99j)1Z6}mK zDpcm7i@bv>m*w3dn{l9IS>8l%3Kn~kL^LmRNavD&S+QvjlAxTB%39SFxU#{54k83) z+9c&w(w@W1hRokEk17%Cg1`0`(4>$e#z05h*u!RIgKk?Aob>GmN2eyn!yeQ0@3Vlh z99&25=n!7ND-Yi{z;QHajlC%z{~Brz9(^I3hpo|}A~$^o;4x|n1V#_{-e3`&n)V)X z?^Q{~D$&g~)DLn>;b*wG`!zQ5@EzmMX78$vV=!mPd~1UFb_H3xy-R54Sh*@o=LIl( zR3j+}V8ivW$(c^!72GoRs0EecI~kVSk>p#jZn~8M>mW86Rc>&LBxc6nM zgXkm}BGAxYg_|S`vm5{eS8gC-ggbxe(oAXd5cHh>_y)nOlw}=nEXZ3dDcj*axP^bj z<2b1q%gHPaH#y%_iS~-*e!$)3xE~S*?Er(TK`=r70qNxiDkqX<9I(J_y@degvo!!| z$`ct&K8_$z%z7wcY2>tdBKfBlhx&956vhWya+umBr?5flP_M`*ULcQbEXdV|ph7Qz zcX=hv77&g{a6;S2b#{fBbyGUTT1!)b#K#q;dV>B@ZC>reyxJ@Izz(1|?Yg6g^wKzA z$*B=aSrJ;aiVoETUlCYY&PJIE6+e6nS_jd_Cp3u_lIO)Lt2`Q{Tu4aihac~y!iECt zd|y)Nin;=8ZBobzrv_jOuLZ(h9|~Ozt)}-8oUpe-&rMw=;K?HZ@Xl?3A`Hb<&HpPF zUNE|B5i%rhR_P$8s#R?2DBOAzpy4Jyl23eOAn_4xWJbh|%q66I#zBwNLMT+Ih`X#6 z9u0amgxz$AzT&~(j_rD@R%OBYj{7Spk;@dINThbqJh$JY~%ue?}5~LOuSA9nE^!OX_jYX98UqiR%aI>B1uT z?sYlsy-AwskO9J9<^6d&?-kL^17P@+>O0`m(*|+W*nrC$0v==)+sBX9%m0tNH;<31 zx*PvzGBYGV!VO9wfJlU(Xi$SeO&q|PWJd1DL}C@Cb%7eCR&Av)16V*4Cy`99qo}w& zwNLOe_n0P zV2hR(0Wd5B5*+b_nrdvObDXE&5l2~e=m-tcj;080wN&YPFU5M zdbE<5bh|{{;$KTe=%_3Ojb&J*ERS0K3DhuRVz`lCjIa|yIo7vQg!0o7J`(^cR>_X= zujM_H_aVWUU*r8pJdcDZ%jB8%{Aa)+-No|)p3gP!+#^mPHA_CsU?&=tYa>s~*7&Ao z$tSjuW?YBOYUNt?OLklMB&Kvc1OiIVg)*nU!keLOh#DL76;`$QYr1BTxs%#aad8|kPR(E>Pt9O_ z600ND-&lDc32mq}j{3+Nm@R)Rr4Q4Tk+*gQNK_|9Q8jJjNY`8+)cD{Qyc#n^iBT|HElatgV80+ z2o3O*FZ!DfUd{g&ZwofCgfOXNhP`4ZcrINI=P@M%bt7ga5gC zl`5cP#1t&Rp$4`vL$wrF!o1({10c7wr_Y_Cb(l7diXk7p*kiV(K3LIPh{!>c7D1lo9{2 zAH|&g#w6*)qz?WpXcJ=rHwD*ThRKUuEP$bVV03e!etqaQqQL6IAxb0;ti+4u9wZE? zEd{u`oJuTx8DDN-^&I`ps~(yBX+3eN-ecTWuMIV>Vlpu_!n6^V(9Jj+;Wa)|TEczt`55lD{cbSzG#m{7$YdeNcYStu1{>ehX?# zU(DclU~MTuMVgGgVb5ynvL!B9EzZk{b63~P&)C(C@^jj1+0%((tA(scoV@xT`N>`# zkssIUyZMP;A!}H&yLj5jCyZ5Dq(Ckt^D^J%)1utOFc~Tt=IyNt+|%4b07>=Pe239R zZ_SEluxWu#1s=!S*BkxJ2CS=>36pU$6)(fMehUdbK%PC$Vel3-X>fL6Y4&LZghf$U7J7CF}IvZS-*L8w>sC*dJFXnM7#tOBZ7~ zlMy*5vV|_q;Z5hwycI1)xu!jVh%0WGe- zzf72R-g8^{QFOR@0W!N~_(~FP0=6p`5$eanm=b7E;sK*e0d5RmDn0w3x9J(c zG-;J}bwXCSM6cE-;;5FoETM2^e^?=PS;ElBDp|n+^K&Dsgwe8vGSO_l!b6LHEaUUz zndCS5E#UVMzi@v34yBig`d^Fsi3C>p8izDlrti~Zl{?JK>C&>uk^&oMGN7PYjG^kf z^;GJlQb9BpeNL#rGf05*8JNs_KzeMn8Enu;cqB6f4nN7fyLgrLhlVx#L$$IULc?#u zlVi**$??G7`P=+a7JB=zI6GK(G>oC$Z{_esKLSmfC+UUAgjrbdt=1ma(#Vo@~pk6#_nUzJWYiFJ>sX zP}$?tXqJ8hE#6pFM%=@z;o2ivPUzFq6$(|HJZGsOg!`1+T4x|~2KP(a?Tk~*;vtHL z1tKk3p7RdYTs$hQdFl>&UK-`mmT$zPEpcHWnJMRBW@Bc9gF{1Gb0Ntv3_A#o#TZXI z?mHjF`u`Ma3I7R~i2~&~(Kr08RMNMlA}QBICbxUeJJOgbb{((Li-`px=fu7exS_Q% zGx4b;3%IBoK?BiKrE`I#vrze(5z)a#zGPFQR?~TH=<}M+QQ_jcb$AQVYQNHHpf)}y z`f@u_-4O=Sf_Nr3*(R;`X>nXD7oR0F0qc*Y`Oqa~3TM&&q=|h)WlYA|YOHFcjhWh- zHZy)j_b`*KJ!e7&o@|ZJmhEEIjuu#IkB=frI!}y>({0jofm)A6MuVlR#H$Zqq;$~N zbPPQ`?VU4HtR3BL^CqFZ0Z#{x9^yX1dFSfQ?>H*87dQo*Ir{?c=J}@t9Gldvn1|73 zs$;{PH9%m>awn#VZk}5r$_N3fc6u=`_{OK=qi_XqfSsc7XoF3IYGN}7NApd;C@{W? zpU+qG{ApAf8*%3fBEYS5l0u*|NbZbF8}v2?ymCbF`1q z9RhsO4ONz!}3j+gP&Q;0g~!#f7<_uSGMNdpz&E_ zA2!xZJ+hTLHr7l$M`+CC#)*?c=UdLA##Ym(3PZs+g~reWT_SU|nR`Iz2<{jN5HS5N_!dk^*&hDj-SP(}<5QhW6JVyYfPy&sF_zgKG+Z^mr56O~50rESO7?jz zN@n+VefJhUHif}=e4{NDN{BB6zJbgM67>@2&PYP2;<+=SUWj`e`XnH{XNg4sbOg>Nb#0UEBlrB_6{KC@G;~ zx0^FrX6oAU8|g2qOeTp@Sq}(%(ofu-b3EvzF!Idx%AOTjDJC0%)`~+QC4zZYWQm2U zMW?{oK|0N-j7`n2j8&MJv=(6Dnrr@uta5;JlPYkAt5RDM07Z^eW)I_c?s7|~=uVW5 zU{nH2py&`5`AiOS^I3>lp2zTvmuMb8+%s#XJq`^=T3?m6*h-68X-oLAnKw&XWXwW& zNejc2{vqbtDAO8sy$!0Blob5Na$f%nZC)ur7Rz}@o^_tnWfgri6cWfyKb7jl&KQTw_+JP|6snJpET~@6Nsa3Xe{1;NQHCN_=;_jS6H$FtYxXiOp zgaYcpP~QDI*a>=_jX?a1_^l_YI;=6{H4N_II%;SxIJ5BZhN0##^kXl>wA(o0b}^yY zl&eEKXlx1=HCHq`v%C%VfMS#1R~L?cEF!TtDA|rg;N?-2Ol+{m|CyZ9^rzn{sn49i zvK(=JpT)`uot3)j>mR!mF_Wn-Y213Ib@r}Cj^Ode^bE6>X;Bf0%}0r6#MrI>dhzeV zQr>d3nRT&+Mx^-o>o^s}HUE1c{>yahWB9!jG4#Fp`6gH;#m}!$jJ$a8YXqIo5bDO_ z>bLjg>R)|TW-Xs2ZH0X{{Wy8HI|KVJ<@3ExA^_OK|KyXlqF+(7^3%lbw9EC`7|)pt zrbk5OPUaoP)QlZm>?vI&7s*5yWwlfwox}ou5h!A>WdwhaRkn=a59v{27;L1F;0)*j z&a5tWJB5p-E$jY9aSuli_G#%4a>Mz=Z>AWBYIJ6nSlTD^?&MusBAR;4i34hH>AK)` ztKaILFT{npmbmbcB`)lEip?RhP3zl%7cUt8FgHe^hIW}b4_eo@5kSwnE6u!SBS)%S z?T*g6Eee-zSRxO8l}cdIa^SvsFH*oDwm>0eU|h+T5r{Cy%C*&38NqN&jCwadHgl_ zV1$x+11VUt$>>Pt4UsC4nsH&9lSe=x7f!BY+VBMg%|J5xOG90b-)w#cLve`VM${vG@?`FDta9hQ{(?O%(O+Eh|% z7*c>i%c`5y`Sz;%h8))vP5|-=gr{M!_RXJoULf{5%>K{5Iru@>w_h4powX0 z3+&!f39F-ZH$+T{#DgN~oJIX2IRuglQbBnHIVt>!-sr}{0+DM0PRgxfk_d7Xm+-w~|ayYO5t#@HDX#{zlTPkQK3h zI8#k)xUU{_o$(|h87FeLLawRHH#yoN&2ig7LYY^SnVczf;G?snEP zWv`dF>qkFBJUF)^puMoqVz2Pr(R}+7dFHX8nqnx_EoQ%fdd7Am=Nf>Y7(|M+Pv$Mz zs(KXKnaD9EI&G^Bu0jICSR-RiY3l;Ht)>8FGxZ5=ip@CgRctCQ}hrM zH9>}+ZxvU2uP5!1Xq&v4jhgE(C%!9JR5+N(|YD(XO` z@#2wXZ@@%}0UC;N$f#sq3Ej828?F9NSHq_x1~SbDG<2LyxdAn-?+d%a0jR%#WBs|<`)Kfa2Ryu(mJbWk<^U~;$hEV2QpX& zy2?ZAjI*ds-@P5ud+O4^tLdU^?3d)2otwc0{JxX=-PG&X;(OBPv~_R7NLo<$CJc}k)x8N5 z4>GO+)T-`HkdX|dmQCvkvN0>g*?Ubp5RA?6*2dK>w-iuqv@G6{qEIOH;jDxJqaHB6x{;X>V_3OSH(Q5 zE36?^3}`$S&WA#|S4F>-1E84a2EOyiz9$y1PwcqXC-YusZW8Co{@rR$B7@OJ#YUaV zOughAE8*4BwNnhaYHFB(@NJwJP(d7^Vx6M)wbGYxv3D#-+^qyF#qtjDv^2b=4| zM@bmIiEAn&@0|LXjujpmEk4J>k67}Y3s*5xF_--XcjXczC@Gh zEbe{beQ9Qc^FYyKGOl8Eh$(%8S$#V6{mY!YHXy3dJ;Du{9r}r0{T2PWQ1M6ENH;cx zGZI%SJBge^tU*AN!>wF+p}FnNcN#=!GW%M}*pP@TOcBgqS`-V(! z$$Nwt`pNZ)rB+AIp(C8WR3T1~>L^e3xtDB!h_w53lpFW2P_csuFp4tF$dbAEfe{!a zw%O9f%Z%ni$Ha`V>qv7`xSzKAo&Iy3$qb42Q-SY=O&sB*7(?1=k{y-}fqY-{3pSt( zhFUAK5b$R5n;*%d%bIy6E%sVS1t&^wA@WG(b(VE=553D7qeK@YzJTD;t6d-P6O2tz zkX0)8;M55eOBXC6W3T|xX;?O-yPwyy`vX+>vy#MvTA!78SvRiACEz7p>?0!k0*SQk zk&1NLB2}_?plM|$1?=Tdv5IIWnLR=cqZYHak@+jITjKYO?azhMoi6HamU0Yj2o`3g zNJ~%TCZ+Hg8@Z`~kyN(pC_XIBhS1!i{Fwee1SM_yJ0J=3Rp6hfzdh=I-+YZ$YL?{M zxK&m2qa%rI@F>0S@#m+U!b*Zg{269Kt>0y=UnpR>ixy#HMxr+e5JTkn2#SdeAr4VFMM~Tg}+T_bl#G zAk9+5G~MA|)aSm7p1zL_+f7d+X%YeAMuuy2AnW8F0W+Utg0)q$&XKA!{pk#jlUqzV zZs_w_Qxv7~b_sLzZz=E2btj;_-&cuBEI&tP0fjyDJ4?;)pY8E7`jVyty?9o>!S0~_ zGt^e@!xI6o0$Jt}LNp$#tsW$108CL7Yx}4JUtOx|x~GbyUh%bSKVBv<9Mc<;d6%pg zUGI_EzOqo^4O-oQDd5It1F+WW?v=Odd_6YDxz<*|v*YcuQY~1DfNKB(7WbrfaFsS~ z(i{8`@MxCT_?I4WCt(O8?qeYp=X&CiK3S*`jsD5J1WhraXX(a9u<&nWe{m2rcZw|* z7kjp0ht*_ltes;U`!x7=mLjs%lPwA_O3<`tgr}0OpE$O$;2h&S;>zLefcbItHgNYi z)o`=uK(X%P&OH>}6PbVC0pPodor)5oUrq2pX-(Xqtrp*b(pqC1N`=86LRywSi;SQGo^A*Vtk~- z5gsScS;)R6390OXv8IW=x5sP_Sss9+f4R0v8K`~tTEccAF57e(Wy{DszaY81|#Abi1v>0lg{{6M?Yim zXz|t?uAkp8^SO&@R8tByi#b!1J%sAmdAW|gq`OV4dm2nyvT1f1fiNH8QQR7^CJ6s4 z-oRVrosnt<7^QGUGSL0O(fa~B6P51Wm0J0mC7Y(koHK$<=>V#L2}l(`94OkM@BA|0 z-mTU9sR+p%=4R^xML=VFJC~ktf0ZYQ)yoK3i4D!+aL=U(uoQd@zenX*5zi)WbEq$g z84NberC2-TiS$~u^cobMq%T^X3^g^VW**bM`d9p~Qm%XH{+|vi%mKJgjj3ooE6A7* zrN)%V`^>A>Fx<6+&} zUAMAy5`DESBQ)5k6;rT!*M|>ds+VOxhhmxY!a6LvzjNH!@R~< zmBvmj(4m4iej1z7AM0SQIb2X8tO;Z{KK9p)651;jb3?oXFi4aLj?wRr1806lY-nSB zd<2sQk-0i4ssJ?K&E^Ds^g3=V*6Qm7ZfI9(;KGH*<838xJi-*! z6+XqYuK}D1JE6$D0`tubg$uJ<9JcriJg>fqJc1;5{*GTcj2|Vn@m>|QJsnS}s)1++ z6j;osm1j!vZH!-0S?pwWsQAB-)sPq2GmNiqif5!$^gi^=IVKK4bQRkPLnPnRye zhd08WqcM|`-WPf*k{uuWYL6+-A18gqCvp3qj4d@{TX!kry0v;_p0;{DX zm^9h66`P?J$En8GN&CCa*_|u1e8+6Z#)dx0?T`l&E@*aS-Pd<)Ph93>S(_+~ z^8kow8#dkMKUp$5fmQ(G`Lbl=z*zZeyeY(Oi9j}qPXg}kp_2&>74GAy*?3XH5xd3i zX*e_CIOfGT!I~g?F+vfl+l&KiW%4|Yd(HYkG62VCRGo0CM1SeXpyog3ZF=A3t=UlJ zZ#bheHZ4Oew1Ji}0y%QtYz3d*(T8a0I?|N-T`P;I4hwaRX*7MEw}Hr?4P|<5rx=ee zo}jPXe)Nj>e)EeB1(l*0KN`n!9lmBAHD1hBMlt6Q6f^pd*X6^gV+I9ehj9t*ym4`f zzOw(`XXZ@mxAz$-p!bG4DWk2mnwCHQl5hAc&)Gg>M`~-q zQFyiG&B8-rwj>@s+(rCkGlrjmqMdr=7!iwnd$3y39ovPy@|bs^wSwYsaXEA1d>@-k zh)g}k#+B+zea1%YiMatsU{t-BJ6G~Rf)d^f_2TU)+PckHG8JF&jP$S2uUUNbSnvbWG< zm)gxF#0>d#<3KpGCG%`OHq%~z@Xqm#6$#Vtx?jt93&80kxT?(wXK z{&FFTv@SBW59mYWQ@ieXOLx4X7a^|L5BtTN=K=tM zI=7hcvflz5$RlT8pAZr-2dG^Fe`HK|L z0!&8=Fh$t8&Ajo~FlP?VleZHNF0f>a-?vmj%y*VJj}q#tL9gY-C&pfriDVs65tO=) zB*4`Rgkh3@(b0XXM`5RXP6d3&vB<)_&FDLcg32qxByk#-uEhjN%bCdShVp z1|dZv9a;0m%?w&-+B`_0y$NEk$UI?K-LAt%j&2InZ;*RrjunT71_-L0wygwOMsE!A zdAFGu*iCu`>zlk7j(A5AjxRBGk}U(nx9r&{i=GLVUA*{LiH9cHsNYIjM$!@^QF9&; z)?1SbFw78o-g4BCdFiEZsH)_aW4ZDIFN|FnP;b4 z`h@Z|JY3FgDW}Xv)LKb^p6HBmi4Ee(+%6Zc*6>{{HFl>?u}G&kloRv5j0|MH3)|a- z!}AhGQBNqWc4U2)R?o@61{z|K92U)_PZG*Wt4GUW)4K^%LZYtBmZZ_mVJC)_XX~qY z<3BE-sNZ!*KVk4)0izACXx2l~t|Fd~yz{kKc@X~cVsw~o7Wyh_wQp=9XV`w?4m+~jvCpR*)~&&`+NG-%%Q59=@!=9WE*HZ6V@k7%N5-YcLV&d9s=$mWbA`-krz{Y2qY zj35&CYIWPxgEJLV1G&?55k8$9i4W82{$hO#%|px-nv`A%Hjb==yvl*WqI;lxpv881 z8X%EmJBhftpwd`xEzv-m$jg(ra=F6jm{!$8U z%E8bb{sxKG9-7kHhnj7e5lg3lh?~_SOBWZ)Y!!ROkk2NBK?xBBLeR29P~|W`1Ix%9 zzF#V#-`LbHLofCRV6%f@Sz%`81U(ErZL_TzCG{;B2LU5tOyR19PNlo@4r^^b^A>od zB|e!dPK2*T6~o0FN7O|VoPaEv;3=(cG#zE(w7OwD_)5h zAaY}~>^kep%o_^TL2|NUf2+B=$Q_@n`AX;8MIlabN>5f|s#s-!hFUAe$wDXG)M%}c zRWJ2Xt5oTY$@MFXna}>J+R#QNV&!t(==swT=2^NDPY>cFbt+f}$sdnp^1^xMsJBJB zDgbWo2Th6A#UXC+5zB_y$Qigu)fL%f*UNI8R16)lK5|R0U2B*;Q?_zO1Jc9{?yBIN zNz0qwSj8b>Gs}L#8h}AhS1@LtWxe7!#QNO9@}oalLmeEhPQ2$W*J)*>DGQW#nR~1fHTv49?(pE8v)yKN^3=~3#}lyeBZ*=+VjX;UDQL}uV+9CSr(a~EhPQe6N; zRL#kyl)y@FBXe*9yXrYvN;!!P064F0phJg}Hms|kCtWZ?s%h)YKSB9otGp)a_P(YB zs}$$5pB`5_MKheB{2|WbWnev8&qcAS?y>4?UZ1Mx^#8b?=d60HaYP$rnxPs_1p?ES zxF;cm%vj8JMQq*2%mqB9ryD5ObDW-(k`vWwrC7xgCs>r5l?93t6D{XT7nMi-1yQt@ z)^`-1{&rDzs^EQ5{|+3!Xv}}F;0Dy5myaEg{)R)EE9qa>ni!KxCsg>R!y^dX4 zuHItP$Igy6h|`w5^0*FsB+69vHS*L`6tkJ9!$Q)z9rR1IuC!X2Z$6;-O7SHVev4Tc zrho?K$`s=d0hW{Y1DU|oHTZB_o--cCU@~U@NmY5zA;|7MQu&e|p{R0|mFqeTf7y5I z-V{iuuo0MJ{;m6EhWT9g%PjL3-7hzr_jSMMW^MONl^N=OS!n*K>m^zvL%zEEy@@$6 zr|>T8lbQminkm@BCJ@auiD;lj8%<&viE^}c>zkEMN)7~M*+x`|6q&AZrW+3t-MC*R zxO0{?Vg)gT1-){i1wH*EcW@W7%N%qO*`iNc<@Sr6z!o!9CPlmVjfKOEoLtI^b;eod zWFXHnmjg~oHC2lc)B5OxAKYK&<)v_^H_^aCvH<{P}w=e}cuSn4&#y+Wb zg!!Q?DfcFE)^d3mAv`qSvBX>>=TUM=Bo=cU8NiJ$9XFsKtZrlOEbMpRK2T@Q9Lc7N zhb4;M(_}_i{Sn_1aHM<9Wmf5vjGRlX9^a+f+n(4jXI{(KD*MY)6}DLOej_uP6xFuO zgwZPeYN>_9%+q%Xb(Nl%j``NS3^z|#6)M}HEEzy(Vd5u7&OW}Y?rW+8q3Rwze{HYy z{3XeuY>HIRKLj4=d9n2T0*GRB4+)H$p5IGO#B`}Vw#On3Y$tNm}y`(V}kj&QGeKa z)BA1Yr1zPsz0|y4_La(BAyqN&Up!onru zN^>k>Q&d?a=RwKOShLNQl#k@p@}Bkp>B-M_9Z*P}J2Bn)9!Pf?oZ8RtVJ>3lUqLZN z?STw#mn5i>p?X<~L}rBc+hPur-7nfNY;*QtN;6xKHhaJ$;}TUm;RRlORgqRpT_dPL zWVukNW7Wxl5GEJDn=Ij*@V&|B*Mt8}ma?&>unedtEd$bmmfa-R1Z_6=!n7dWf|brR zOJ3)h`|`eOpMSP_-)lWI-rbnV+`P&L8+S17PuY z;*OEpv!cV#yQAJN%qO?h{epj+t!wQ9nw z>cy{z(2K_aF0F39FmK}9T2b(C84cOb-(ipAfyevKxgVYCd#|}KVD90&#)q%`*5rT2 zWXM>p19FLw@&Cc(?@Ud;uYtK&qDL9IJQOo@wGbt{jI9=1Y?INeH5iJ$=C9Nm%-F#i z9N>>(i`S{jtYz@@ScVy?u8CCmeIXi-@7M`e!JS?O)u|LP6dPM*QJ~vpMa(%cZK>6` z?fBKG`nC!P`GEMHz*C6-b=ub5inf686AO1S*FiWk#2mnYys_)V`??j^5M+LPnR&Sf zC3+Dwqy$N7Cl-!GY0>I_DZ`FU*Jro-^|LO9wDdJBxzu!DODaa0Kz>y!|{Y^ECJ z?MyXG+EFO!?j@#H_m-Nu{^mKfs|>x|*O?fVC{A4HbYq99ao9*nI6g47&ZUEQ_o~9O zS?g~mw)d(cqH12!9*Dfkc^NjjG$m*pAplcVu;?gMPN4Z1(!CZPOSMr!0}Uh=+s*#c ziCN+*ybe>aEYX{~Tf*;3nUq43b$qRfW-JQkJWyp=T9wfplc+!a&6~P<@pkwVukpDM zT$huE)FVcZE{$aq!|N!t`;4IRj+6@OMR=_E^-7fN=tTnX|LO|gBWQ|w2^76niD=I; zy-KcBpZ0ylGG7m0p+myYxGY*&Tf zr4!B!A648~0QrdHBMF$}Hs=?_%CXw*mgZX)+$mM1sEjLP3++M2H=?5X1sX*rTtrS> zz_YE=*qFLkynKdChE~6id95ru#?+RmMc!IzY%s^9KEABLU|NSwm;VjDWMlaB#)3WsFl-$Hmf<+gm1^CIk1bBk(LkmuY z3!WMq2kH7cS3;VP4FdFm)KLJ&wW_8q=9T=e5kiMFoo4_+qQ3|rAa+po$FgD9reV!v zo}mg!lS6~{yRs5nlq3zwoZ3WW_#XNy&i3hDSIXnm?stF@s*XN+fq>dUkk- zuQc2s%qvcV>1bBQrbMYZ6*y+Thkg6IB{@svefx`F0ydz}XCTVM(0uc#02l_?Fre)i z4$&tLekMJj`B4sS64L4t#DB8ug^oR|=TyXDNr;bDO8;Tyq!#lA)(FHI0pkUrB(nlV z6AEqFO&W7DPmY_qxpmfHxkob^pesddf2xu)!#@W@859ZjBAI(=X0B9UG{ zx*6KEc;Y!>SLx*$A(Mf#{e)XM40-P}Ou7*&_3sNQ)&DJI4jN*QN|<2?)ns1&W1{sq zBAYY`*^e!2VE`w;EFG)A<}V#kEwJiEXjedr#2h+;y-@6uEc5$SG82?JubhCF?j1h~tPn1Mro&I*Nd2yj=$7UL-Fleo;xIYj&HV__*8lyD&mf1#v9 zvZqDfGFP#y*c4oyYwoh1Ejzq)luKol*D@tvN%euto*ekA@e0(73gYY8`m@W<3{TL@Zpjai>CR=2Y)d9rjpB1O z%V_4VACBZ;MH8b?)5ovQAVU1EtR6$_1XuT(4)XXtmm zsLiS#^bPVMrB9djW4Mb8^QQ|woFyzKcfBb*;+lG68XqG5$MCI#3G=RW$!?2HuR%UT zr|JHnWZn;#tM1>~B0#3>c;zI#nSAt1mW5^{bPWBgl0UN~VFtSGIW}{Z;9&3*N)^Fc zK0#Y~z@x_|{;>${Q(HJuWp;Wyd{0d*&_AGLvYEmzOg1_lVH=_$|#dJA|j z=DnDA5APn{t9Y;CeHQPtbjN0r=8&Z9VbN`dUuv{9*b`@z?1Iu_H0GG4{Ha0JmeNp^ zZIIB?j0>C1sym?qyJg_IYp9H$9ddSzKOn-*+ux+*K{*DH4czOs@UC16dnZ+ z^cbFq_%(Br;29{UDu^`&^hze@G2Q?k0nY-n6pS1h^Ol?>o=(%n)Iu|uyGWos+ef!8mR4H&(`iGjZ!eMs~uu}k~R{_KB{7hK3ET=j~Y zAcr)}YZ|@z-UeS*v0j@LC|GQgXOK)<(LQqYgOq5jmBntT>wli??%FS9gp1#^M3)iK zyBvoLYC07zs8N~&*Tu7_t3(19%;`gM#6|(9rM}hbrcjgYE`ku$JfJAcx(OtS+ysi{ zWof9vj?HAU*}Z=57mdEct0ebTvi%DZ1(?>B+qIY468+s<=4H3|vgZ^eo4sgr4~bQI zV+P0SKa43(*~4={D#hYIDG;k@V?9H0n zl7Z7pO;#=!`q@5A3_OxS%<7t~0$%MO5|?fhCmm&!8_+Jn?HX#O61XnrcK6&@!DwoEz-Zg%TNq8&uQx{P zk}b?ZLZcT1qn>;#SjBS-E%YxV@HG;c0!M%V$FQ4sV~e=~f{g~AqCul0Xkk3Bn-J}p z;QV8xt{O{5^L#~#i-0?WTVyG59Z{jJeX&ay3${`C z5VR=hP|%{FLqUsz4h1a=Iux`h=upt2J}2O47R-oQs$j){#1VNZRTDv8sKzce=}~V1 z)Q%|hDgFPx9Tm>yJK8a}pN2|cw|ODc0b^<$f-e|m9$YKawFn&&X0aPl@VU%$si)P!q;^ei^f84Cts+K)DBkLG z1b>FFWVfjKXD2BC$U+jt(NA_msUq!_E=+bO0x*yl>4p3oYj!|N(NE#jtrFnsXinoy z1nis4|6ycCiyWTI#j&w|v6w(vp1jF@9Fj&1J;837MRtW`Y6P^C! z(*4AZt3>~3u4Go0>Bf^5dY6ssJ~cF10s)M&4hn}H6!_`52GAElxa5#|8KP#J`$m^q zMHw;2fx>oH&3}>krXE%b6rsYx2+O4~q50#L(kue&nn{~}#sr0f2fey+7ufo2X5iP+D5u*?iDe;0ym}!$RAqkg!sy zFn0%$yQ7yl_2{nzc}B0#pB=sa6g_q)C)4^>oB%dChTtMvX+QoR#RO;y#IJrys;&)W z!f_zKi!iwtCIZ=WK}Ph>biGNf*0mH9pC6huZKV9z|1He8b%9z$*@(&C|{F>#A%~mv^D&NahbC={wyFLIwul$ zav?}OCv=i~E8(y)85+g>ZC?v;;bh@jBM%S|u0O~_CJ#^WphxeK@g_2iMD(Xw@&2q_ z*@*SGW57{=gq8%6bsRsg7ncZe+)~LXa)Yr+8-WP#8o_SC*eRYs^Lx%p#}+WDw{&P| za_JB3p)yW9Oh3x)K6lfCLVv8vj;W0t+Vh5Z8#8^5jovKZdHFua>#02R+vSib9TvvH zt~m?YPO#{U@E@5(dRY638tj>oPn@CQkxz0$Iqq-5jB~_?YpijO*dq^&bHqk@V4Ndf zSm!CQ`XcuVa)xrc%$Xy@ zL*v74=ijZm>~;}^5#buu!Ev^e9{2`PKkp=FgTgE3hEE0Cu_?8ec6;g;XABMJBc-C7 zARFjFxjVAH1p`Img(@}D2`DOyrbA31R+~cDQT-~Jb`_{5{&SX&ez1p$7X=PrlaBr= zI+nbH*2}59bnDM*JI@DR7Zk*5UvqO_b@W}3?OpvlAi>LJfOB1u&a=Yja(7!%ZRcZq z0Iq`C&fmXnv&|n~+xb`deILgYc1`FXDT_8o8U39RZZrnnjD;Ja)8xjsE@Y#a3*kzX*$M?{yMx8 zIb}gWLCxRFzwLyIg{04j68D`9kd(sGc>J7+V87g%boafbN{`eKTew6$g+5T4Rs$OKvO z%~HmJxQ5;=$_p4Kz(Qi8|N7c%H~eb(fn?qys>G8(vDhpsteOD11Bd)jt-fD}A^*th!+KH0M*IK@I*-ohbcgX|*2T`N< zPnAEpNBILHQ{KG=KGd5kuVzA#8LVMiFV2aD3-5R6#qS4|DT+aGNzM|fF`9Fy^>df? zQ^QXh?}`DhQdNndi!k6N2YsjAR>&2Yb`ciOiF9U!PK$IpL%~RAA8yO)%;Khz&ibNGM&1p$)<4c`ZzlSW3H zE3lgZ@>B8kjjCM1?=1v~`YkKwP3}nK^EDk@Up^7w-r!SmmkjeoHOxPXv3d>t4n+M~ zQtdCzSyan;vM{RWChnJBWW_FXm_MZtR&NTQVQvK{8F_hh+1RX?J+YTTDWJ@`?N3*jUxuk zb*=3m1CAT4vlQ-ASJ(~|_@&YqZwjB&QeJFtEgv_SLVC37kbatOBC51>zJGf`G0oC) z%ACf!u!*oendU!qj>LD&+S?U4bKY+;2U3ZMXSbLONHtm$8`WCCCd>d{=P1PAqwO)$ zpeV>xn@v4>!l_ecwXI?wanZXKJ!O(v&hbeD#v${m)#}OoSj;F`o4w{sm&nZB;Uaqi zehNbk)_^nb&jO;=V}bQ8=IQiWpslx+kiw&KR;Mp9n3W3X_yNooab`{s&@qQ?+Z}*L z0?s@N^w$tb#^_Mj{WNu5_tP_o;~y8FAe7AGDv^WdTBJp-JwnNR8^2pJ-wsSm!66R4 zI!od^h(~(|A&FeM*8%JA;x8}=cycx!@$D$Jhen&PYb>sWGkNY#2q%2&!y}S;6W|vJ ztM>}?jIqETep+o}`OdvA920A3!Qx0ElSC}{Dr8y~sJv9K-WmDwSUAUgrmINeHZEtJ z;m&&io?~7W_EB`D{#t9>v1e46mh4SdkJ{)FeyGSlFo>w)-wY9wRSDlVL(oq_N=hCq z)Xi_0(ZtE-MO_VXctg!^&h1$3@ngmxUz!aFJV{x z+zNIm81=6RR>S_k5j1{sS1|gM7ub(_wDLnyaZ6{T{@=k2KeXjoQV>V9@{?d};wG@s zy5eOSwo46P2Wl4oUcd29r2}J%o9<8M&15p8{wGV4-qIyFG2kC=KKr03%qnqW@Mim> z{%6?164@s!Sa#D2E%IxQ+V18K7<(HBG(ZPOmqfgO2jt*tMx0Fh-r5e~gSC25U5Nq2 z(ST96Ub?~UHQ!8@jE*+qqRy)|#`ND!HR^UtsdDY5 zV8`T3v^CETeJYv(Cf?vRHWaOk`X41!{r#x&g4Iny!Xn)NvkU>5?Ov`m^yNTL6PuS{ zEZY|U3onj4hoQen1}x{vU*2rBK!BmuQQsEtCZ14U0P`BlHcp_aF+6E?KL` z{H%$;)oArbzINh{kZkf9?LOE85i($HLXPQN9aI@H>x$?B>RJqz=!@Zh6qBXuHr?@Q zT;xnRbzG*cc|Ko_B36l$ssH|9Q45A?#C_53Zzl`wJ*r2;+l^Mpj8s#HXi7KyFQg!? z@==;YT1sKFE?2&l7Z#-kVg*TJUTsZJ zF62Ga!=X;pwAj6c9eo65n&-lT+?a~cT_umjEVwAli<$+=Oc%92xow&JLc)q}*=MvV zr8#8VBL|_zOy(^hW+S1J^i(fb1;lcPQ;vWf*ye#Kd_^tEyy2*b$eQm!ssQY5?W%_BgtdoQ@kzSQoA?u!wEK?itXN3?>M1_;>cocI4U;W!>@bNpV^}G&|SB3 zEk&UD6LxLhuVAu?e}}Y$J<9GP3euNHd_v@0g|MdzlWT(k@gax0&4=FAf zcTgcKak;-yx!ij!+$A(r4_h>17$~FCn@f-ob_A>6VV>~3CBBGOw~JFzOiV9SZNndU zqjyX|s4ml0vPmXPSO}r!rGx5NFvC{!@yFyuY7553aUy4L zF4xwC;$^W*k`wI<`g)DlqdRc7d#L<~FJ4+8F{!;kORPM@{1l>xXAbvvbJ7{~$(T+Z zuEA6+-4uQqLUTuX>0+}~i)Hajc>b}L-{Qciuna2y2axXwdh+$Mm8Ikfb7#6$s7$Nd z%|HlfxPznd(4|H&J~o-Rbe_PdR`&-!aov+vS1S+4wsAR?U0dp=hH0_F$#iN*rE#p% z{kawyL7EYM4WHsnZAIH`{JhM`bX{9fd1y8=h6_Mg(eP_(Lk?H?${fjO3v=;(aI%HZ z9D3~9O83`VWGf9O{)}GZXY2+4j`%CQ`>}vywhL6~{K_3(<2CamVjFVLw#`_W6@QW} zso@@l8v=lLU2Ms`(z!By98`I0kl2%IEZIjd{X4h`T#SU(l3XD| z27}jTvw+Ok@d#QNCpQlcIc}#!D<;IBL7!z*Qh2xd`mfRcJjAkENvl{i4>C{O#uMgB)|Rt}_gFIeqcNYPd#>9y-kJw3L=Shpy3M z&)H65j=4z&&D_Fbl;#o_#`4d2?Ki@9PQy1WHf=!7k8(O-E}|ElHJeK zFkV?BFu=K=ft|4mnzDns!YjG>ip{&9wuB{wV@}-^p@gp%H^x~j0)|v)yM(H-KdTOj zK$S~>w~2rWUD%Irr<2lv`&js2!UflKSKV6{s^qh>dGl2~lVao3+D=;mF(S`2Uwk^5 zd|8kp+~RFdF@s89>9Krmz%85=602x^NisGq)4T`u`!eHz;abARR6y!JwDS%dqSoz?iia4U2HDLPf@hNXQ0&`T(mFL zpIFetPY`lctWrx^7^y>#1SyP~X|P$z)LM+VIf}lPa${psRS|GDdKoJLhY*)x5LxYKez_NcdpFL`v*blMxI`G36pAfYS5r7@Ii7 z{GU`+>-kOfWbv;Amgz@CxkbHtC@I%k*S51REM3TcxSx`4wv-7hzW9x@WRX=9ELC7*SU6C&`#{%==W)0p>mO z8@Y?QMM5@>xkW-IIb7y#>PrjcU~7RMIcN|68BCD^yk1J5csV&O{DUgqbsPR0V(gHs zR2tZd)FSz@C7afxeoEejjFcvdEuZL^>te~ws*rz(p)#`bi4%L8ByTazUrO&Rg@}|x z(BR5W)jt6E>#DsiUAwgh$V*sLW<=~<5BcmE+H^ywlLUl7UErC1Ps3;WJ-t%adrt@* zKPd&F*wQHol`Q!E3W(xwW`SrbEd`^9ixiBS=Q9gx+bC46Oi#?m*OL}oxr`25mNABF za5?l#n-~@$jNv?H9?m*%uP!mH8mq z60MdbIxQ7s{vqs?e7A?5Hf<_WOmH!|ejc~U^Q}-rDUrUS6X7N}EiIx|Zge61kVGLe zCqFKyOS}(YB>iqFX==g$QKBnNLtcbUF(w(A*0ohHh*!yP0>+QC^w{??yZnZ*kcm8X zEvLG|GviOiR)D)?8x`F30pU3{jMc!LV9Ij0xmJky9{))c`rIolv8Y_tS^IG@1uELORy(*Xl0j&70gDt3XMu)gNSbe8vqyc7{VI!NUI)p~LfI)#wc!iWS)*sl`bz$;tmlyxS=4&((a-C5MXz#tw1+oF&xx}h zHt$-t2xt&R{1<-r-VjbeuM+4_8(BwBY_@X4_lT1qI?W#x_#Jx#{SncASfC&M6qzCM zWgHz83GYvJOBmHFqvxpJVf5oPU(S;QcAGCc-${I!0)W1LQ}nVdX+0_JUn1=z?_BEU z!B61g>RrAfNZ8GR>JDy%Ssaj2=rN~I+qO#M?I7X;Y*u2~4;XfDnX`X*pf|ZmPa;u> zBh=cvB%T=JHJZIeO_k*_l5=f^6(AqV#p-Q(QN&6)esAN{d8$YVk8LE|ky0^^3SSyx2D z)|v!qMT{x^v2mx0P|+i*=3>A5qXn7e#+83`V(0OClmK^R@gmq&qmB6qBFBh?8y*WN zj-%5^>6DEJ6eD|{uxW4_yW4~Po9L-G@{MEe5Q<9&yZV=K1tqJ*P9h%orx<8*O<2I) zI)A9Hjv0X%EH1^fPJ02_RnS2Muhs<v^b-5_{Iu~JxH zU1!-er2O0j58>BQ0Iw(t8W9~Cu6gHiwkTWf9S|_w8RsFLJDZdog{_UGXqLEfEeu90 z8+?FY$b9x(CJVm}?^?hVT72Zhk;FCi;o_0dRDSbc*i zLzpO~+w?}An4MysZGL=?^k%)+3Jy)I-|l$Ffzj*2qXPABga#bN>YEnP%s27lMJnb* z_~e?nAEta3>!#H|M>^FI=a_iPoULck-W`K`gtddI&s2d2=qd+xvsrRc74pfS3*^sOFGee9##~3s6XO?|8;Cq(`7^0GSh)v}QEJ6e6X{{B;mFa5D63b!G;@Ehx6 z3_ zk%d&T@q}-BSqLktm30le*K12pSMLu?X>Jbj&GA!#3wQNiPWA z=3RL@Rj~OWv9u`?x{nCDMhC&L?>_0w40O;h-hDE^Vt09pn%tOk0KG^-MYLWP*gS;} zA%O7Hh~E4`hPI+^RW60}*aNl#`B4xg7nnP63mJ5`84Lgw#=}w;(ssc$hC*ww$yxrA z_v0cK;B2sr=Kb~W(@|0Y@SuU{aZ|Z*uL2#`81iH@wr$upl}D{ap$zT=e|i{a)XdK{Xsdb|67(_2A?r4fbl=FL0JsF%+9qIC-Ur54xk z04b_vPUJCB=ivr!z4c3F@HVy*h_IfiXS&``eHH2DLPAgr?OQjALzcd&j`?ECq4H~( z$6(BqhijX>0+Jj9Tz!Ot>16sw7I&?`_LTGFL*XSz!p|>^^Kr)qssju9a z5akNu(^yHZzLSM4KkdbslMMdY5ACVE@poi_OZNMXX2tTY5lA-PIJzI-t$8?s8Zb^9 z!Y4(ZeMJg_Q9Sl&y)@#DIrBk{#-O{ov=!=l4>uJUbt)H6@-=9@8C|Xtm|7_k;4FuW z5)mTZPW;jj1zRcYXmt`E&kJZ;Z9RNkTSlEqp*hY%fHiurdQVj=9GlNT5F7q0#N0%y zLJt)RJE4e_V%Egx-lEliL~1u;{kO0yT`)iNcf;-?Y@*FQja{&NKU$&`%m~{8f{6a^ zSh6Ts=(F$vYvv)=F-I(-Uq1jr_ix>0xcbHJIPkq1ao`}IK{)P9Z1 zLrD|(?ti-j&Pwe7E#jt*@7e|N)A*R`fBY1lk8;bVtL3-Hl1Ja6>#$N5t}8ZnfY2sN zCm#aWtP)h`-f67Urf?f8UvSzsI=tYz8o_luyjUa1?%$z0IiEmvKcKDu2-W@2*9+B6 z?}_S;#6K6X6jWye3NSHWRCLPtVuSlDYlQ=xEHqD5Y2 zh7;6@bs9!FTK%&B!`_>KH(8~B!%sIzHxh(mL6ERi!cwS$SS@HmQ%Ir3DqC@*rA=w2 zn@s}6jbcz+V;!8)8OBkE@$Wdej53acz^Js8rGP?K1mvJ z9Or$n@BOap{hnUw{rt{-*8A-DSss)WOGNk1UidWQEn%V=d`J`?+1aiZW0oHMtu*p? zxo^4-QiZumjR7tUY5l^)*uXa>B$8qTfcOai{ZV}earE`2B}dEHZl5j^>$bOq)zbd4 zT8KWkt~&DG?&`j)AkXfV%cG$Oc51Hhi2XQoO4D#^7qPaw%ch^!Ws5k6i}2}N(5p{S z65pWpQL86=4ZcL6Uwu?1@c?G1k3M26Y1Z~UhFhWWWeqtj!ysHXSMO(}wYol_6kZ{k zgg*Y)5v~;v27G*lRh}-grFXfjtd}!|_46 z@CNIc27D788^X3B_~kLA-j20Aa0iVbuSrBW8r zsyn70MzkjWue*=F2a8N%4I^-7NL(x4iRBEa?8K?O`Lwc-;2r43(livzv^3qi3gxcJ zhwm2B@rtywRk(v4ddK&?-%UlX)92+eT&+dNLl$<>X{R{vL4+mO6W$Qta}Qc>#bOlp zK4VGPnCD}^7OStmaq-2`=5Brd`D`qZ`>$Oi9yeV^kClBhhc zn9V43n&oc|zAIp&!Q{gFdo)vbxA;E7vP^OFpyhAvzC>cTce}1wg$)=6ZTSRovcd8< z+{tzDfo+Y)dyTv%t|q-UvR@{h)&J5G(`u=`fcEElS~~uLK3pD_?|2!n*xN(vZf4TD zR??~)awJ7;4)y*8Y;3NLTt0|KY&aUMX%rrmE;Ep(L(Yhzx_(G0-4sE2fTeNlYwUSl znCB{dHNk@|LSB6NNFI35uRcaa(Q{BtXE)%T)QUBrsl8n~i_qNq2B*#lBY^e-TDu2k zgrCG`$>^hxneK)NTu>x-0%KdJ)aRW`A`e@{6}5Lj%Lx5rDJp3m)lQsvOv5Ko!j@&O zY9x{3%7iv#Q6okS}ws|5Lv9^daWJb%K z`g?PcXPIL^&aAtJHUnZ^gU-z0upB(_9fPT5X9n#I%aFIbm(%xrYJ`opUywQyq!FpZ z{*DopH0<_uCekAHLzEpZ`VbTvQ%{J3XsD!I74%1Ff!#1uhw2fXW2v({;TdTHRV|WiyAoCr3%crp zf)3oD5@?$|_+Dif1WwXkxDFyq@4vp6D`D3RxxEkHQ1E{mxmtXUI1c;UqQM@HyzqTO z*2A2GX_<8t${~Gm8D}4{xQg?ObrJLh<#XgdoZe0m*MBiSE~nq?y#^uTh7v3v@Adu# zjT2qTec!cC+sS@9+H1y*W6{LaVy8Qv}VU9KOr-f7+Im ziOZzob4K8j?nUNAWS?pkP8gMq~SDaSSt;` z8!pn4EDdR-1DnUBVImoFfq^WXMFBZP!`7wJ)(J?A>K9B#Nt1SIg42lcL!`+*X_5<* zInv}cX_5z%Olk5QnTXJW*8c0KVC^0oF80goE$RkD;2Mg;kDisMdub~ReGWA0mIV*o9JopmM8^1Uj4kY zUeZxwlZzS9+gn81W25)8cL;NAPtv?!(|f&#Mvw4(s`Oy3L=)I^LhpHpvFGSMfci~4g5;&_I*Qh=^$tk2fGRXA+sd7X*|KCB6SNQTZ+9e3&p zDi+u`neEx`*?-XijCF7tO^kSOLce>PH?lz;H}8#utXQ@|bBa$ip2Xb}C7x-) zFZ=}zd|Z+g{>w3vwqUP*BQAm5gsY|K!4~iKPVZ}%!4l3KV0%2S&^qKCx+~(%H&Lzo zd52>nA`i_wV|HmDeFS@Sv>L-BSi^eHPHGMJdY7h&xQa9Eh%glg`8@{gN4Rk-jrq_V zH_>1fO?G_^#fjFR-|9|Sh3O78f=#%Dx&bH5VFedH+d5ZWNrAbdyt>=zh+Lv3E=AP% zMm1`xvW>QhZ+ZVDmf|354`l6utn2OmZcf~RM%x_tQ1PlSav%oe#yDuiY_yEHdZYm+ z7?Ow!Ogm7XU4v-6kl;OCO^q835WO!i$5zp2F&vose-;XG6ggXtG6bi^|yCt>t8yT6>*yOJ7F$J; zGpIwd>974HGXgfdmmS2mTwIQt2_-5{$b1qMp18#$t{+B(wK2FbBTQ_OJC6HQ5#I7g zNIzx7?gaGjc)>@O>Y;bhm!#Oq)ozCeL zox3OC`c@Q^thBG3BmMg`pcz7GZLy7gTfZ@;HXNT6rTr@i(e+utFN!+*^|bU0TZ1S; z*=b)plW@E#d+dJwP%2B%s)xhNxW1O!$i6`-^7ily7Z-?#Es&l~RMI)+G-Y}A!Lz{r zk)QO>^HHX!yJ(Fq?b~HzGb296?E;Pwfk4ECkhm}fnQ;QjLZtqXZ?t}>8AroDMlLKL za$c*u*s9I*b>`S}*l)Wm)Sk@WKMH#*+h~H4ipXO`=){<7FYfO8srcH`PEl3WXTWl2 z$8^dy90D?}$sGHYE$ypiLqp;tGwuozj`NT&3Dz>xzWh;iq%{Lu!Gv%mK{XJC@}f`ghd)Hbw{Sh5Wo5>YSx4nC3R+)wVK zteC=K59uNK_D|bbj9^;v2{yWY5uZ44^?v}>E*yu;FvR+ssCi%c#={I3dnn__$Qa+l zbbpN+fr$~?boyKfJ~q|him=vRKy#>B{?-!#>k%=MKbra!yXiEigm)-ZYB%aMX+r zT1KI{XfB$)%lmS(hxIC&ied{=ml2CSj^#V8kw$1KFa+x|-r4y;xNoR_Bd%*b9--gZ z;BN1Y6QKQ#`se9DXD!}v!V?3>k9=^Djlc6izCKHM8S6e8X}vU+Z$(KQq`I^zLd z2KK%k#Lx~+ikWibgbBIf-ku9-H26Ba{g63mpM&y)K2%tL`7G@6#=$lWrO#xJ#kunj z5KH}nLz!5M|5jgtPOGcWa))R2eJ@lYMG-r@+l%y$gJHfrBH_M;L?V3G6N&WAA`<1Z z66xieN~E`MG7+6`0+DE+iAaoZ7?D`tAR=+TenjGZaYXv~qKN2mDY|8|9&#(;q+|VY=FJYv3pP{ungJ+1<6?K@M+ZFzaQqF2k-NW zxbN#e44+Sjk@sO8uL!Rlr^5+`cl?=Q1i^@o-!hCO7};?@LlLzo-yJYL-HTYgd=>QG zo8Ei-3g}%&?>gTCdXJ{}Xd#!=G4vkeyN1kT={?prk={kB<9ws&J)X?teHYPtAA0ZO z)6+ZsJE-?X;4Al7y^)`CMD8pw6zMCrK|oDK`u7`9VlPK0g`FT&b1-ti`G`dwOHrvw zUM<$t1=t|-0#Xvp&H`Ki8kSHq$8NLH4IAz*!}876vAgl@HU07xSh0M_}4L}GnIiNyI5iNyQ* z66xb35uFjqJW!wz;7~sQ}MIn_auIQ z#qTxz_Tu*eexKua0>5+k#oQLA4Zv?We&g}G3cu<2U60=__^^zyA1Lgx_%dM&p-)-xc^>jb8@+aG?jXQceeG-?CX;H6%9k_V+%6Q9Tc-7M0V4 z&zDD|$YZ2X!4#iJI}a1>lGTei(Bs&V=RS%AFkcNh!=zQMr^0RhfA?g4~A`ve~3O+jNWkrf(@hh z=H(HjGH@U6#O&G|J_2ol&>6}o8dLiR@4HY1KY>mC z>OE+-tk_0olCc%X?_^_+{a?@E?iyO=`!g)jtiw!G5qe2QC%cPY@QG)9zt>}@9YiK1 z1D#CaNF(m=y$ylVHCX!9#c;fZ;%>e7xbu2XMkN_SEuf`!>VGxs-}{W!L=$=H$-orK zigICszv4Lhy>;@sZ)>_ zZ-GbS#B3eSl$H-8iJ`=MP~tr(@%46tI>m;WQcxd^id%`hwxBu}7vJFnZCE?^?tKcr ztsdDx@`XVzVr9ng6Goe0WW^=n(0HMaz+eLmfKuo-p7ms(Qh@h$(%k5+z+g`5{Bb-2 zp7XsYbT3~e4(6gobR=eaj*`BP^iAHee}yo1V=u-djo3`+7J4F>(@<@oclJ_$yVCns z1K%Il)5#CQWkJt*QaiV_$0;Jjr_Hm(f>?T3A_;q{iSxU1G$ zpNXq#w_5cxb_3PVG@=97&)74z(G`oO3nxC@fn!D6S#CY<(~|eC)b1ANFzCJ&Qu;${ ziuy_i&v3!!`ha$)ueDRY%Cm{Z zKXJI6+o9k)3sX=q&=}!r8Cq00?!6M984$&zZ_pWE^4B*X%`6p9qmAy!LXHnYJ|o93 z=uW7fgdA_ikiq*w5z1=|Y3YsR3s&@G{`Ws${?`dg_033DmQfo#zs$M}(og1d7&Mv3OpM z$mNmZtK;vemZ)Pz+)$Xj)8k1N&Y`0Iik_b8Z;JOxX^u1JsNuM^lvc^8y~MqwQRh&^ znt08`qTkZl51W-oG~mDp#zfDyf8Y7NGl{0Zv2+&8dv6~!`w`wZkjrXmby*>`TfU31 zpUdLeOK1wS9x=;wgtnHA|> zjkZOOMPy14b@aTh1X_T(GQt%PI_b*v$e`O;gZ&bt83YJAMRaMYUTFHr14xuxw^TRw zY7ND5iWgdFVnur=KwSRYU8R3$_rxxEH1YJMlg+S7&r1Ff{bn>!c+BZIg=V39E^%YV zg=(9B=Ssk3sKt9a7Sh3Rw%mCQj2&ZX9I_Z46~385y(~R7)b#4a-g}*II%rh<^U&2! zL13FFf{#h~q%qB6;S?uk=sOzt{?dqTL9VFdi^runPWX}=wf{LyT)>F3q8{p3iu5aS zuc>=#Y$A%X{@xA@NsIKRHvHN#A$ogKkxhR$W;7j&OuyaCxQ_{7FJvf)Y52|0?hS1D{dXxP} z!WQns?_=;NQH}V4A4n8(C|`JeQ^G<)4aebS!s{3#QgK3>9PeUcekS=4xF|LM>i7nY zW6>Jd#fU}xWLUF$qACz^?-nRwd^R=zCT^#;CMb^jp;lC(i48jrJ6a}fKYaRbyqz6#7LInD`TW}*rw=7>rT5bll3xYY zueP8x?`Zw{OPHW+A4Tbfodh4*IeSx*17U!3`B_l?>W3sZ{v+YTp&_3UJ?!{4Y{%hu zc2ii*I}RR7nt-&!P0}%PBksULjUKn7!NqfIN5`RrF$7MVw(V#=lRTSJa0Z2u_7RKn;Tn&W#6JV|9LnP-V0*`) zQwZ``R$u>m2iaaLZU2L8e;?PwHr5lOO2BrG!b=XlQ2AVr7tz!q3^%#j30FRxDKrO% z^yaF=8kV6vjdDDVp@?ORxrRpE`WLY#i}OSybz5l;j@eCPk!8d-Oa06Sx=jY#X*BY1 zAnw323#0>zEyAX3?C!Gat=M1PXxXCW!RbFWlybOrj+&|&5xs#^H8V&&>~5ye@hLH1 zA8g0=MQ^5!w>aau$3j=8H#Qy*PtxG;i1%aB|2K}<1p^wT7-C!SMgfdyvaC8>14m>M zfrCxre@iTO6(?bTPIrCWqZ*#r#>VymvD=VHku2(FF;+)Jai2%K0cW$qE$((5Hj2bH zxDSUDCWfx@a0E=~HPX`Rjcs-x35(d>cqGyq+h~o&MQRO=?TOg$qvj$QokKk-G$FX& zwYAYZ0763g8jmMp)Pn#go{Vh~(iF0TTqteLSSTNAN!yF-`tjjlGi8croA^Eoq$=cz-MpBg45DrD5G8IOMre7k-5(Urd~u*g&`9{XlM;a& zH#Xx;n+BchtNX|x+(o>Pv1e(oNTdslb49WH3FrjxJ@EDrG~fbhL_xUSiOo#zBSy0Q zvCupg#fobi@LAeetl-=^(zvOCHg-`7D$0m$EV7Phz=%kfbPciu1*ti>hY`bVT;^sbVJk=)rz$u}2Lu|8%A|2#I2kx|zN07E`3cQkci zCx~WwpmAjT6xv3*A>4N{q0TAogd*^T9H6c#o%(yfM&v9TaKL+G!{*+2AKUDC_w6H= z2inHIYZ=k%8=djMv`CBR0?Pw8^uig8b5p|g_hX==nXmdte-FkOn&qlCy&L@?)YL2u8**!2CZw6`3CDR|46 zgGCk`5Y}&OBHGJRcR@!4)yklKh*o@%N$aaQrjP?%_hzht$Dkvra)6pJJJ-_Yu1>5P zB!ptA8*u6a9C#KAySKcPNP7?~bgO&369A<07i&d3F+IRwNZvcx%&{?s7ip7+69Q4gV= zO4rrhVWb^W80ZJ(vGexJlPEdJQdnBXMku($^Qof9*h^1KT(<5j` zj3W*2{|S2{=o}72vIW85BLpvuqR^t^;fiLSC>PM_AceF!jPzVkR(&HTU#EXq-m5#o zMb>E|CUpncU?cC#keYROUK`Y|UD=*y&j~byHrxtHdZzf7;6rypCfs`3Fwnmh_kSfp zjnvi4wFumYgZxhr{ue@(i|CpVU7^agY(k3{8uJsEP*e&>8Zju}kC`=6F#|qXNxk@P zcfujCp)|z|Iag|_a;RC!qqGI~+2an&>uEIi+?1H8fDBa-Oaca z6>XXojdQbmcjQPNG^ToMv!~U)Cw!#A)1A>!0D%>Jc7AWkk=cc~1T6b=2rUl!p!I3(?`B zTaJAXO*cik!LtW~iy0XyA}d&}Bf}L7eagr%<{XUu7-dL@)E|ViB#NVRMA}a0MHc)s zK+5K+WajE;iT%VEqu=7|LoxEj6UVZuouY_qi9v9AoO}s)>g7v>D*-n3zF7BOv#-~x zy_8;ZRx|a>@8Q5X`DByXc_~zHe}VLUm+g#tkBmtn<373-#%o|K#LU?y#OsTZOb3{r zy~tXm9|eta)FLthAUI1UPmWcPe#s3>q6~!ui0jWnl*j)p?^Ye9q_}-%=S8c0BI9D+ zXV05&a-GVrTQbT$?$joDw$tvv9E`YEkA!EM=OA7m99fIkE!0ET*_v&h2S=^}h62Le zj(;{U{^ho1)tOtoQ+lJ;LdRqDPRC|mGzPsPu=i2s;foa-E%)}E^X^N9-v5OA=upq; zlZ`rOe{9lUp%;o(?-F?EK6=WxKwKweUVR!X4*D&hM>}G?S%P)eH^qE%SD14E8OJ#E z;v|7LMexq~jNpaih9>Z09sK|d_$B~kta^+Pg38t>)ke=Cn*UE5LUr)wXcl%NBT`#$t zBkD4?;xghz;<{Y&2u(j+<4)xY=psq@Ib@3UD|9v9-~CbSti_ogCx#&i75jK(n4bNh zH&=M(EfHfB5xNQgp%C!?3zJ~qVDxQ+qmUqs=xrh;-kSkcjI+O{?G?X)81<%CMz%n5 z>c-()7Ttow5^pN~kxsM4qWQ+OKsXiSH_@LNpv9u@Dr!J442tS)VQ5hGPt`?YdB>n7 zl7kV=kWnPm`f)hmF>c~+eHiwL95LE3c7UN#XjCy-c`qtV8`*10uME8vw~IvW0tDF( zB6N9%8`0I#y%`K3w(9!~R>3E)wg9hPoV`BypCL4FdOst&u|0wrx*m)e9G7E8WDiDcL<5_L!yLYoUya^4HVlKI_ZTV} zj(%WUya>vj8D}`TEz%EkC%5ScWEkAGxX6>+41N%Pa+}c)!aNb1sguT9Jigc`d+AF+ z&FGFW8f+W~i}8CRt3L0BTB`B$s8z+4Z8L_s?=ow2?@@+f%V8=oImpC}6#BF*vJU$LK-{)G+*p=j7?zVq#M7tF zmgBRLBrKbb!i~pbq={;Cc%4N!#x3$>4+SI0`8Z&vanQF zpKb8$$B~P$?u3_7JIQ+-j95?7(r=mAo8C!`c#o!ck}uw4=sjG%$I^QkzFi0NI8T_n zJ;Iqn^>--!>qB+eWLp(WGWHE6JMs88whz9*f%iW29uLv28qtmBQb+}1=G65faaz!v z_M$!jOU=0anI@~^XouMAi$()y6T+Mc^_Fu8WO<_ZvTRx#rmF6X^(F~Gtpuu%3H4d7 zDR`%1HQLkWK6;Heo8D+h9yqUonuRu)CmbK(j#O_SvebzdE7i02RO_nUD{H#DM>LN( z8@nI%KBZ>rR62$1Oghu2^h$AaW}DWy{Jr%zjewguuQ=S8@D@QJ00fh=KdM_ zS97tSupu!s0(XiXa$fAoiOWhmP!;2`=_2-IrL|V|v0#IyyTO!^wzujCK4ate3@_9- zs&8K5NZ8aDimCkW_hLznR+NU*x4*7&j zz5$cwE5lqD+X}9mf_uGJU6qqTH!4qT*c^*0Ty*8kM0D{u(Bxkis*n2m1uBXMvATK^ z$97`2BqDI{HvFS4t}@3c|Fb<76b&3=YW1S&lc(&Ie9Ut)Jc-mYx{r2cd3IY)YLQr* zcVg;b)@2vuM4oEPifFYJG-r)y%`9k|>FJMJlWu^BXy$m*8Wy2<#^MA^SOhlBXGJt; zO++xeZ|oR?aDv6f??L@TTKwi?NFUm(Mnlo5MjYh}!*x!(4INhtryU*)p5e-$=M(Wg zvfo`uNyE9K`|yH$Uy)u+ytYI~YGUkjBepY4A~Wi2s6*WhYp_=df;{Ohdb_tqV`ldi zPH1@FLSIO|Nvf?b>RpT+X}p5d3k{f5M%fADyOKoeq9(vP*)-#QB8+xLMZ<)G-4zvq zH|kV(MaA=*=xuFF8)ym{MJ{(mh9L*FfVn6B_0P%UtVp9WL>m_GRfcd#>lfZ`jI`Du zr|^{)%11eJq`r;}O`=Z~<}#Ue14J@)h-iwZS){WUg7>=MfMRb#?7yV=Ae|;o=Us#` zJ|Tkn>kpKUWc-(D8-+KSwoCaLF;%fpIq`)tR1!sB|ZAiUMi~R6ViR{&ZG- zdZf3OTFZ>ckwqul#F}KrMGclyZPthe>%HlbPTVkw6E0}{-m`h$@~-`y+7;U40!;!u z3~u1X<;6W}Sy26Qe}NA|_a8}@)9JG53tDqWCT5Lo$<|MM+n(haoJ4bs?6kKX1Bx)C z);hE6|Da)aodw5`Ve0D4^1v;^MLpVXKxTFfy;Q872iiSxQ177k?StpKPo_r}x#Cx) z6*$VExkEQYCsQcSqIL7W^D)v;muvLy6))8$?=&-cCj6pC+0(fCfGeGLR=L~tHun+S z3AU%3HWot(@%9nyn+>OZv(UEV0($p0131bI#pX->Yd8wNt>e!~kbCOik7`=DzWzl3 z{YEHH_TZ~l*`Bt>!@5lO(N0`?gb<*az}{5c_lRL~Wit(ji!6E^*44k?CW5PM#nN8I zwzu1rF>aVUFrv+stbctEcJ>l4Gh*+(2eR}TyK$|cfvjPbKzeZy-n5`Qd7Exy8`0F= zJfa280`{SjA+a`DQVrSA;#g|1NAox~!eY#*cO6HZ#kN_C{;C4a?1;}Q*qt5G48I9F z@y%F#O72J?%LDn{-5xLvyan--Ztef$CON>DZUT70e7gIbcDyxz`}8gNo;>b6tWVgP ze-684y7c<{X|rMQdh86(gZHFN57)9I_E@?PH?7I?gnMS{poyOu2OaSBeX{B>GuIVa z>uhn>+MGU3;DZMX8)wFVR|KZD))v!*jc53nM$;Nk4BSqG+H2#?UUlTo90`6ea;N+a z@{*jv>a=jUwbq)$1L1F+87J+*b({*70~B!MOdTN3`m)#3b`yusK?}HXTBPtj62geF zA(C`bM+X+g7g8}UzYu%9W4@iHub3O&`K^9sG+tNE4eM;eSEj~zh%(1Q65siKePr(9vr@tRpFN^F7tiPSBh=I4)8}aW3 zGyW~k+wsH7X#B1-;@?6u{^jSv{DB(y1N!TAl0McT=~L}Qe^^;pBk9BIB>jDZqh|HJLs_&|N5FKUM8@y9AfG5WyLeU#GtUz!k#_~G$-^=Tf^UCY4V?UM`nHi--{PH5R zP(nk71yW`Vvm{r8K+~ z7HUvp^!H&B%>`SJf^7&c*kobZZDPGy)HHp?^#;7$V8p-0DcGKaa~vzLGvMDsBmU*5 zza8A_BBQA|h1YBq9RTA`uawc8LTj4WkA{!`2bL&slG{0K5D% zBbuSM?AwW>iH1zK*Ko2??@UCiKzrf!2Jj;LTJ(LR(ZOboZNRcfW@ATh=WY7YVZH$& z>+$;07K46twD3)D$m-jU%k@bJFt5~)&dei54l&HQ5Eq6yFf@~43K<$ExbjK+@g3D^(C3rIr@ zjb-z<&*8&;vVZd6;|vKSZamkm-*_PNpJDuD>0kPwC{thFBs(rQB?{+7BbuqpYWH_p zS#=A)vDPg-jjm?l57yd+-T0*TLR@gQ@C=!p2tur8wS+J|hnK8bMMvSD`t1jzQ}_tYWma0$S3t`K;N?raP^a+4 zXQJ+$L#MF)=v|2o_+sBrb^*)maQF%w>hIr&ME9(ZXt~4iv!L->X+h()(vpXNt0>Ef zu4CH3v>lWi^Pa7^W8-;RaN`Ub2yhF&5?d0v6<)1cADD5QgEwwzR$4`q3_@)Sh-g%- zL5*1cA|>=D<4?|qtj~X@$HEb4Y*et4H3u)1|ou@@B_NQ4CM$wcZ6V^zyP7-RhC}$)Q&6PD;G*BqL zqJdI1H?+Q*=h37HTa_QkHq*4==8j)CpX!pYNIowu0`>vB!rYbIiDzbnItiiJxrjfkv?Zu>^8 zcn(X^f@Uw<=6ytXR9^#|@T=11d3`OtdKT%tE2MXr*k;%$(wKC5?b56mVcT%4cPbiM zQk>%-u1oOTyH0pxh1@**vpnKbF{>t{CXBlhABNbd;p!JSvB?aDBtAp)@y@nl#L zP4glVPnB_qA#T`40z8jyf*r3LH_7=kF(6`3cB<0!CLD}NLhxUS60=5Vz|5rV0D@Y}&X)iNvX8JMHE~b6x%L;ggGo8XThiM_x z8m3P&-N5usrtM6>V%qCA>F)rhmoUAW>3pW;On=MtDW)5kzQMGa>3dAQOwTZlsgmIh zW}3p(%Jh1sMNIEx`fH|7GJTHeMyA`D9$@+*(=V8Q&oss%!%t*7l4&Ya8`B$@7Ba15 zdMDF|n66{Gk?EUEKWC~rWq21by@csyOl?eWV0tUl+nGMZbRE+dm~LU(%v2N({7ZFc zHB|2uZFwS0;LZ@L?58{_`3i^9)qj-!y|!H1Gd_HN`&0Tz^QRw>bkjQNF4VtJJjd=d zmf44CMHLl-l~G-3FL2rmjpg(6OI>z{@#?9@q}yG_#V)6DdA@_*$CJewa5ufQBHuaj zGGmFuSYF{Y=9iXMEQiaYiYntWa%`-!7ul=q@Kt1nfjkPqWI1G zB@S3HFITPh_jMGrp52Eh;Lhwihm{%&*EXL#(TQ6yfv4)`$v=IFP9lkU1jzvQGaCp!>74dow4X&~B@>ezR~a))WnL7ZS4Ts4n~S<}NPpt^6wy>d9#;Ee*OIJ? zB}>rQY8mBdYI5bPu5)=`%rAZEBnakl6BN4RCv*%@HQDG7G9oSVKI<7hYu!i~%5#HoUGCW|a z=439aFGq_o%rC_ma=$%U-2xc=iI;`&{RYy#3Ptpp$koc%6?oJ-?(BV{B)I z7;YCJBn;onDlkl<_EH5fK8B-1<!Cr;>X0;cTl;xMo7|gaWxAF)|WD2UHc$ELnl5$st z%Q3g4%q{{*ub>P?ZlX}xmmuVdsyR-3rA9ei71Uk;$@XGSNtvru^bo>d87}WFG9&IFD!v{E2=ocKXxY>FrQsPF)4LiTNL6m`#0NFw%A^EZP9uC zEkCcRh=+1_9$z)B{Jf@U=SWT@F_~SIo@-rBj9hyrQ?phGu?E`30#_BLY7kCYnX8x<7OnzUR7051xr2oJiMP|J+{9RF z?KCYf1Q&+bFAm|ChTzH&T+LYJ&*~6o~J|j z>qGDhA$S90C7)M9_?trbuZ8d%LipQ5_{|~s%@EuY;{Kfw+!lgA48iRo_|p*V4Z&Y9 zR`Ti$!QX}0?+U@+hhXikkn$dajf_?KG%;4?C6#f1&cB=xejeism|x9!Fypn1u}mYL zO(FcY5Pnw(KXIRo{|I((W;}>-9%CcpTE;^euV;J-#Qs{w%KuG_ zRrzXRtmMVIha7TP|A*6+~vU_I9-)jo!nf5QPO4{Q<_&!R<(^Bwj=B|dG@ zqJlzuK`Cfuz5~hywg&8Q7Lu~T@6K6_d4u0z(W0V!hcg&2!=$F7N}0glQUw+*vga=@ zQQGxPm{?&#!b=VfwmgQ56Q5RV4+ih*-1;de735CFS-)VN-D_ zVa9U%a(1p^utC!oZ7K||zFO0!OwqJqc%KS`Vffv6v$R=JNqQ|Y#MF{ukIK_n6w>5m z{OBD&s-wwQkI^Q8QhA0~+7$Q!>)O?z<3LTLHSKQDTkyLRzf0igPP~i(e=L5<_)Wks z3BRl1XbL>I1n+m^cME=b%Zi+&&m9G~^yDpD9D+&0qqIEdib{J$k+P=cLD>LRodaXJ zk^Ym*+3R#P4T>8fx#nLZ$Ema{ZCy0@CkcPsu+-&cU`}ziHd)%f5!hF_1#%qWzR1Rs`i>{&y2%| z8{vHb7gQ|DU!Gs0^tsC3l&RE;q3xWDcExD5W09?-GSEC|#%a`Sq?hJ996?-TzSAhX zl3>22sw#g4%axtjN>J6S3W`?*ITkjIO2K5jcJZy~L5x{w$AZGm%P+4eUr`2?l+Xk? zDp94`YY|^Gw_-hCfS`Z=@elUA1sVUp_S(+5x*DAFV^eAPT1OJ!fy&SYa ztI(=6JKl<5vKVhwf?uj#3N!hWQU5vj4s8W|EYOPKPP)DfZ*q-*d{`>{F30~;ZK9@n zT}|uhuMCUkG}B8R7VIM^kS0CMNi{1B*dA0{^J$xb-zu9!^%pRwaSECH*C6caRZsxM^V{tkXz(s|`e%PW?b8|~Ev_DZQj685Wq!v11Ziyn66z?c4u zA(QwQp%Lz-g#$%KM$w<<|BHyCv38UQh5m)>!nFt;*gCB@9UX}19ic^NQN3ZKx8PIy zh$kOiFRd5-#2*>;*7c^J_!IV|U9ztee`JaMmLd54BF_KfV?yb0A@55y)Eqpfa#v}o zd=(g}Xi#HeG8h7^bOnTe8-nYBAq4;PPze522&Q`ng6-371;O~&A^0~T_?7UU_Wu!r z)i|H>jGkyoG}^DpuYN*#Z(A6y8QFyLnCy{xAA&%7NnbHZzVg3wq{PY}MHOG+{vq*>{E*|# z<}Wa}v3l+Q$|j3(koc@vKxRcOk4s#a7csEiRMGoqwFBOaA?#Up>o zEm7(}$X^3~WJdEvn&Z)r%!lDe=9e?JFivNj14?eLXY)Bs7l4xg3-P0{OYtLr%J4Jd zSBc+X{HpMyxYpoDab3mq9#ArO<469i#*f^i9*G+LB;!AUQaqo=kHYy2eq`@e{3u@g z@FV{F_z{001W0q9LcPCSZ2@36#b0qD~M*LXXjVW5jqz!lBG6Qn3HlrKh0%Jutgzy_e_$?v)_7HyN?CDxbd672TGFvOpFDGi6gMXtrf-o~V@K0glXU?`N zNN!9e<%I&<$EKw8ES(ta9g*qV&a|27n@n4nzQeSQ>4!`|W!lNKi>dCY^tV4#BhztA zQPn+W!lNK zi>daRjHiyNfoURBBU2O86sD<6ZA|l+Rx(xo*DzkgbRE+TOq-duG3{g;`MHc&9MeRm zDNJ*jRx+LAD%Y~Hv0*Oe!3&_9o?GnFrdO3{bMl=Uc!l{Zu!o^SQpyt8bC4nImdiJp zQE*o!7=Umu+z|)3CaHo zLI@++n8Nd8OSY!v;73n(_JqR12`hxZgbVSEGiKv4(#r}wWUSe2SCy4rMKdV*%n|K3 z+@nn|htXVMisS7tKBJVh@h&lbnRXa+xTGJFj|`v2xbl(Vi|iK$G9Cf< zGCtH>$^s$dCC4FBZzcVa@uV>+je1mkX|$qDq&*q`p5_+BlAau<^q!5s36NDe@&*nM;`s{@7DhQu|GWi#FKwq_ot`+=jlH`^OyC{KKJ|!e|_<#4S#$2@2~u0bQ&_8mKSHSgZD_szHV?Qdy4@b)|JzW09H!4D37_|eCov>!fl^wZBi zKj!T??)&1)ufFd5=ES$({p;kZuG44Ee*eR{ZY?Z4A~LF1Z(VduY+QUFy`k>~{rV>i zxG-_xpo<0%xp=5?*zge}lP(!$8a-z0xa9E@QZBu0;-t$bUy*v{RcTlwxyGEo7z^e_ zONvWwU0PaJUQu~lmBZ;;w!C`9?Kj?Z^DT?=ewu&Bop;^6^8a-D|4)bizbt>tv~+96 z^cl9ynX|I8XJ4Ch-SuMlOV3)y1_`xwjA_nG&w9oeNT_XK+>h}l#{C&LFjo6mni-Q0l%5vGqywg> zjqyMUwRXm8pOKfb+Q-w$m~^l7bTP*IhkU-5`E@Zv9b>hR%fQ&k{6xmX7#kT6XKZ3T zf^iDtk&IIrCowiNzJ#%j@hHYQjMYRtmoe#d>B(a}Rzj_q@i@knjFTBxGoHY>hVf*^ zwT!P|yoPZqeJpbjHn$t&Ce3PiNf5cn0Hk z#+i)0jAt_LWIT&;7h^T9(|(Zoe=YNMjMX^Mz<56M6B(;Ddoy0cSjTuBV_di@9yPy>WxRp;af}-n z$1`qW+=p>HV?E)|_-jA_??e}MFWSqb_h4BE!X2yw(a~Ka~ zoX2<&<4VRCF|J`enDH9MLm01Pd@{CXW;~j44&yP5^B9k1T*-JG;~K`vjMp-rz<535%NTEBJc)5LomC^;7Z1cjIUyBVw}b}mGRY#ZH(!POL}q{n;91~wlJ<{oX)tG zv6b;U#u1Z+xHscw7^fpHw;7RG}Zw=+&-+{rjh4e%mmdLtPd824suWE{;n zg>ejHGvheMIgAG}&SRX$xSDYo4;X71M>Af_IEL|h#&L`{F&@OYnQ90kvGlF^r3qd&bqu{YYuQR=H=qR=H=q zUb$zyNx3&k_sz;Z<2L1@zM__8C_z`>E1?t>QCYtN2qSf4$-}-lX_u$!}JC#%&5)CEu&CP2w(vvn1B_=Je-C zoX9xxPKiy72Qf}%EVafOw5X&N)}Z^%7gXsXZLG;GU>zrEq3NM@P=a?2fd_^f>(KlHrvK?KthPk+_KCyNuIW%sS+J zXlUuNbG*vf-+V}do~7)Lb|27F%?q2mT)+<3QiAc z&goeyRtIPwkdlk!m$CU0P9MpeBu4B1WRuqFrNqb=S`Vi^26M1(ARj6x$=Wnc&4Z}C zBx@OdeK(bpWG!7&^AajA$yilT^B^iWgfrMbxtc!1uivI}ldMhG)Vzwy58>{Iz8tiq>qNbynjsXUVWRQes-ZNL`4{|-o-_(~pBPLmN^uI31x{G03dkIF5@ zPx(jXm(s`01Y$$s%?rvelGik`Ka3TJIpsh-lhj4J0; zUkR&vLG_lf3ZLpPs6GdmpT#2Gfp}3p4~{3*_h3x*z9*LTL#2z_fna`_$p3)< z)IJ3B9U=ZvdqMf4{3{UYoPiQ0A8JQ}^HH`Z0Uu?%LM3jYa3I?k@==zs+mIfT%rwrK za#4Q+`C2COX|`X^vOUVwuH*1!dy?+2FLM1Y5I^dVD70L*FWZx8{(PbShuSMu-(>p` z;FpW^2e%JoKPRZ1ko@Mrq-Xh-^*Ydw1=oXg(bmd-QrznqS_*z_lE6PeE7c*yt%(y8K=!xEP9 z%JSD68Lv71c*=NX1;vBPTOeE+uNnS$t9YsWlI`uZpm>&HED@-=GJLDQ{K)XL{q2AX zKhPdh_<`~!!%z3OcQX7yd})s)m0k<}2e)qy^t==gm9sJ)+5UJ+`Dgmep$sR-&zIq3 zbM8{RP37$T;ZO^pN~jEHuD|@qa02y7hGX@oKiJ=%`C2Agf}Zie7Bxve(%+dunB*|u zpB_p-nW&N>Q~7<+Ee^Hs@DwYM_7nf`Q2`*Z!} zNZPmf^Hti<3W^W;e}jLWUD{W*P1UzqL42~G<8Mb)dek^V`fmwJKS^hvzg|fGv=H|> zA^hw7-WIc2K`hILDv$5-YY%*I9Uv| zngluTkfUu)Gx9nIv$ZwMZ)1aXj6Yz!f$`rMH!xnuxP|er7`HRt&$yHEyNtB~GCl_w z8yG*!*vNP@;}pi*8Jih@$T)|wS|`Y3{3i1&8E<7=!?;=TS?@oZ@fzm;f$@6AOBtuI z{b7t7m|wuy#PSVe+`@b{{%dD^7xOzAzsfj;-K%v%-Gx$Ks@~X`AIbI;nXkq*CdT(O zKZor{F-~Q^YM*nNuhtc9%zujQ=Q4hnaWP}n9#=E|JM(K9KhHRY_5Ny{xR&`I=I3$v zy&11(zFMa#X1;49jBA}opCku)w*ai^GlhZ%lu0iw=ut1x##?eVeDmo7UQ+-emvtY z<~tbIu=`lXx`4&t?3Y@{jAAT6ZmGel7FWy66>* ztC_FXA!|9lam=q}zM5aGzhSKLcYE^VNKN z4aX;$`Kip8y|w0F_r8?*Hs)6|R_oALG0tWFJ&ZSS_9xToXh+hm3x-waK^>VFJxTJ_zlLjjGGv*WxRp$dd8a=Z(_WcaWmsxjMYA( zL5$m&e-mS+*FVbG%lvJOwTq?vUT2)h_!-72jDN4}b9yggY-9dojB^>^%(#K=Ph?!o z{M#9;eJWol+ZE5Tpl`Ch~tN_{s-bk4i@DmH%@6MXlD+ zx*h2q=sc@@q&{jfe4x{%0e|E=4QU1BBiCsP{BowaBtyzdPIBF*5L#~eNIe<(7mNev zJ|v(12lMHaa!;)KL8S*SI*(d!AorVp@1<13W zIF#ShJ)MCKwlB}_kckX0klzw7@#mk!#r|?5aT(6$2K!g;&p*jmtB%Tl+}qs4zC3$G zM#{b_w-S?9Ts{)J{N-BWWkLRtp4}dVY2AZt$w#h3mH6c;*A3OGGp#$*I-Oc&mFv(X zZxvsuUk#KWg;hHwG5uHJk^Z&RUmhjDOq`V>8*&{a5I?z26R4MR-7;`4O0GWz^T~gz zxAKvCZMCXR>%^3PwR%pN>TABg{K|DewVEy0*Qs4l@{;Quf%+=3T78%6@5#_ut9Dzi zpDpprORje<_16!%t`vyBTK7>Vgp<*FDEZ0tv8DcYT&^ps)pS}{r*%iQ%1-Onv_2Q8 zk8*ubt)>&7)}2&ngsB~*|MHRRTETo--vWHXW&ZLf*Z=6heB`>Y+I=ARBLtTpxlW{Z zDG;B+54KPK2igOj%mQ(&tm3q3y$q5g*EfFLA4+ovRk=LKb&J7nq7z&ba*|k)d zX`1=?m(J-ekB|Ff9P#r1wfXt2Pv6w^&FBI-4=DV{50j#{AGp8h*QXQGO0B}ZW;nRU z{>Zp#i{B5+82;FWmyEiW=CtPUM|(Hc%^x}VFK2cvDQk9oSoT+6RTw#F+*dg2se(O; zPk)_sN9$XaUw^W6=+(!cSR@DHpO&9%dh6D>*NQG1dgb_t@QfRhx(?hnf9AHP4|?N{ zpkIw&uS5M&2aC8WKIxHJ*+(O_ zRmn|fziSzOeU3^0>bEEQE$G*O+J|@DeC2z;AGokNwEZ4akkw}1De zqvkz-iq7l zYyLcb;JVx1d+mN}$z5UPrwvccAGE^t^shAS@XMR0xN7hD&46p(T6)zhbsyjVq;7gf zc5&P@hkkhYHzPmk_eF8aDC;Y~|H`szW7D4S+;6TcKKNA9vb*YUn~f4wc=mJm4JY(} zUGPZXf7ED2{}^rDe_+S^ca>f9=fT;pzV&hC6CX^q40v_+o|fCz_WShxHCLIhJ#x+S zrz@6cU-J1&F;vP7m(F`W`ao{nGkY(|pMSr5@U4yC-S1lFwT|0AW1Z#6DBbR>du>_g zZQg%uUc;HgFI&UD-f*{Zq$8=Sb=B!jpS~EC(A&H??e=SLetO?T%aLo#%JjodOq~DO z{C--uigQmzb;G~@=kKmn}WG#_BFXC);r>x_@CU4P1H z7<$$BeQlrp^`U}=hGTnw=Ph~vlB=seedWIA*4#M!%88G=dfz_l;f@)}%TJd-cFY_* zV0+iE;|!gPPV_BpN}A?5z59uWV;wKu*&TIna{7i6*VyE7s~0?D_?=Je75$j<{k6u4D&WFYbvvngU=Mpnd?yR!$rpzRoXq#-XAUY_rB?zv~X=bU@y z-g{>@3+{I=^;c}q5>nIy|=%c<@Y1Y{=9$r{FsdOiND%j+j?j0Ovmj_ z3(oA`{h-O_fW!|E4*%ommQK?)2?0(IKL60$txxjtOM{Ldxah+-oph;m^|asb&s+1u zjjSml-5Ldsy)noR@iN74_d;xkzH@odu9B|)pJ&Bq{UpRK@Z0rp-hq)-l_zEz>heow z_W!>4^NE!)_Md*bi5&=@61aN*h`7+Y~e2pM_snrn)68# zOC4}cy5|?P;gq7ra(_akyTgIrE1&F0cI!|&uDx^Ok~3m$+vq@197pn6K}H ztaG1iRn-(<_^xwtU_hVIM-r=M#@@2d|72WUZKFe(mqYaZ+9-Z0NPK_D-g7QLH*#O8 z{iNT8km`_~zmIv+ym7bO(fcp|vcqodpVL2h_x7G+t%GKqV#}IlTu-`sw6;UHqn3;)~_awz=U>4j&{ue^AxXL)#(apTt?A9bB|`oP*Q zVuMk*R`*_TWLt-3_w0n>cYn^!nU~dOfA-QTnMb=ND0(d(^6CC^*Ms?EdW`zMxaYQg zd!H4}?a_Kv*B(E)^1D8KrtN+1?XTY7;x_21=h0zxzXe=Bv9fV=^Wzqt&uVt_B|G+f z8-K^fYrk|64JteswB+2py3T>WT%MEO?Z#=_h;a$OdE}Q4d#mG_V;3wsKKpIhv9-Rg z?Tb&e`O@Pn%R`-xT7UV&AD_K>VWjP+KUiEiyl&j}?kN+$U6&u$&417vmTTO8|K^!% z{c|g)`4Kap_C7shuIloh>DH*X@UoencHD`I%T`tW6J354x^B<9^6Ad-D;FX6u=*u??bk6Z^6KXo#^l7=vg*6H7X8dzh{J?$NhfZg|ZKxHhe5>zccbAKy+rU3B0r{@Bsd_q9T+ zPfx~nsdjLGuX+5&=&6@GuZs-so3Y8+;N%}Rp!u$i4}#l&J*nNouIJYz>C;mByMFO& zm$cxYV;5Oo^ZiIArfK@m0;jSO=0TRWjI(rPoRtgXtg-&d`VD5$xGl4=>B1V>^kR){ zdDh4-m|5C|FiZP)n59EBvvNpcR*p-VRg*Mk<+PnyJC!hN#eQb({4;CpY+#LDYFT4f zE6&E%owI4$g|lfkn6qs*nX_%KiKT2#$943+75m}i{z~lc-iE$0ia3tGG76+`i<121c^dW_ zO^>T!(`I}w(e%G@vB{EH_sV{o7rUQJ^R*Xld3=81mVPM4>4jS~jIX#~M#q}`-mdAp zKmOVvf5~RWSW$S7s0^EGA@%oY^{ynCASa$P}(To7{$gr8z{!o{_o4pk;1( z#ESF_BC8%}<%{mZSp~$Z0%ai)`4GuI-n)a`X=@i15f!Hg78CVzEK7*m$Ri@lN>-MV zyTZ>`Jpaaa%SEQ0xGGZFdGKenKgd5*r1}rGliZ4sX(A0#UyD>JTYOIbhWuoa%9E!> z>Pvgeg8zgHoPJ+&K9Q3U7R8m&mf;ntVxa<`ykd&3!9U znd?<9`Zt;@QtAG)$e`=(#orxEi%k)!FF7j`^|P14>!+oP)K*;*SytcsEAp?pwpOHa z)isepxBBfPf33}jA{E!Ji`2h2;A`?vIsKtXcKf&oaePwd28dLB zFjZt)*m99U_Jty~**{Be-}@q~R(l?y^i*dBkyQ>Fktu$wC3Y$mX=r*%+JB=?q&B1F zcVc}E8YD94=nRqiz%?S3TS`SL&YcvgYE&oEyO~!d9hc@DB(maugh<1|l_J^v9U{^G zMC$dmBDF5f#PPT+wy(&Poo|a|mlumvJ<1fReR5c2*^O$E#;@&vp!8A}brq@ZFixa? zf1*e&zgeU)zg(pEv-2XA{8Ne1t$w8AgBA}IsZEIxX^eSaWZ95B$=&#SkriLu5~&>L zaFmWy{nAC^@UbF;^0XqAH6Kdu_MeMP8GcHnBJ93MHonABj!EM6#cgMQRs* zBvRjOugI!T&x(&K{2D(8C1|6+@u z>G-OT`is;Lnj$jg+yar>sUM3>JHAJxvBx=)`lWRuRR;SiG5xtML@F&iiBzoWCo;%t zgh)g3WRb?JQ6ja&l0~NISBg~BZWgKRpDWV%?rxE)U57-fubq_kJ6si6(WzFXVla1{ z(hmwzNSxeCq%y3lNH#W5WL4lOk$T@LBDIZXiBz3W78z8qQlwhDS){&Oj!29TA}cl@ z6j{a}7iqkBNu+k(9g%9Ary}(q+Ml5Os9ZfoYS;RSRIolGm9vM6tU5McB7>BORH$4$oqqhqJ{A9D9(;3U3x z&aJoZ1=@dec|g?QLxIjYN7O&9dK9?5Yb)>g=}!ZH`ucqNnz1(nn<@wWbvBjp#q&Gm zx?0-shfdz9XuidYw-|n^c;1NOz$VH*MqzFf{@VxEZ~ij8jwH#Qk)KO=-%P?rx;*u;Nl+Y*z2j_e@go zV{ciHs2u6a7w^m1c7AX(zT>TjyYgnVATZUaJra8JZs6xX^s}{1u;laJ zX@6tAwk3aK&zyPNF16y-)^>T{w721yOr528(8rn|IelS`>ns<(-}IDYJ9%6F z;>M;ok1O5y?)vo##q5^+z}mg`TUR#YJMGJz%Go>*jG1}lr@${d@SS%Y+Sl2l6F)@r z+j~{b9|dmf(`b@9s41^*v0&qx;|~0yf`#oh#m)JGY1~(dZGr{6+_#v)<`0 zyzN!Xe+AojMry+dVF~(1V{~onSjLp(`I+w4lDHS35o= zGyLaHGdl3f_J^D+2fOpVe|*dSt4MD?n`^(^!QYNQGk^W=3F|!hk3XHdwRM-9fwP`2 zcDx=T@NN;~&Nca@EAP;2x<^`@4*Zg-$pNYHJ^0ex9iwJV>Cb!3U3X!Yk1_C1&wky1 z88LuwzBX}Tb!1cCea7mV+v|JsGv>~_zimSxU#?$k>>u2hZx>d0r^#>q`MrHCCjWM* zFaO;Se;97w_2i2j+bc_6{(xr`#0u|Bd^-Cw;bg2*q*QZ;Llxc zSzBIzqW0LD<0xN}okLf@*8C57lY8FPI`VCU@?94#?!>>bs`a;V%AUL`X$@UI`N)>P ze9)_m=XD$3_otHKwD^y8hj zo_bzCF@Qh+i{H|&4oco|X~@PZ*P6iG$+wzBDBAMQzw~fQ?%Iz3xlZAEj{h_8{hvlI z8lh>!w=PZ@o;<~hkBs~5RF`h8d58Ob&lMl)!`G+GnZCTaA0Iya@^{n6-3pZ2Uw1xr zZbqlk1N!hw0&f~}syp(ft(zH-ly&51O!-Z><_#skG4!k3@!t4lvZG@Y*6cC{cDNF5 z-)fn_m+otPXp3iEVBwcPdd2wh{J-pchTBK@@o#s|JkZqsdEhWxuNy-{d-3nbTGuJB z_vib@oHJhfs4c&wZ2f2NAMMRo=D)#W-}L8Ooou!(Rp`U7>^R?1F{vm2fD12~f4o0` z<-xZT6lyqPCb0`~UfbKmRmW6$25d5c?reH5^~HGkd4`_u1__UBb6 zzaC=60{F|b)a?#_*onW?>5F!k7Ifslk6T(fcCI^bjB@%taBM67>ZbWgKd2uDzBw-C z!aED zEN}}GtQUp#$E%&3|{0Ozp^4!J(-#T>TwQu|f@b=1qO^lxf@DVM}EFUyj z;Ct)(PPL8b$6xf=GjYWre?IrzPHw{wy?L*Hb?mn^pgphL(7Z{i^8o%?NbK4Rf!+D$ zH+@!}zJqr9+wA2VCU@Z1wC_4?^skQmpV+$?4myWi9JEeea(IO+P~(%``5Z4{^q0$ zedE6y%}=`LkoPakQM^NL&apGgM(}$l9d^{7QSx?QSG&Y~KZI}E=IXyZItTKDmQHhR z{hbg0p6>i;{^Rz1r@VpD+w1BByW7-Qb z$ZznfS=uS83%@Y?*VLNE{rCq72fFw_3gZ9i{*1Sw75+UJjE(EL#TCy5m&aV8SH^R} zyKYIVx+Twr-M{LK6cNvbIfF)Q(+q*zuFa4KZJ!G^tri*&G=45vtQ%VQ-OXo0#cl5M z#z&tCe{g#jq?9}pW`1eh(fz|`!Zp>F98cXdLH9fNeZNW1ghbB^^FQqOOn5`wKm&)r zXTs_gbyv^){#5v(rTzl;l#J3JMRd^6jn7hyY}7Pu3j)yENRrZNxiUU z?TS0g?mrP8T5nv{>9;4syL_tV>7ge=)!qYckBXiMZJxV#dSlZQVNK8Tfidqr5v=a) zzj{UUL>Swmde@RMPlRLEXGaA0c_N%ki3#fM{Y1$2IoExp?GwSTG-Kb2+Q-7ww2h0a ze|;>p&>r^G9)2u5{bOafmZgt{{SmX&f2BVbCSO*LyT0_X5bIf$%f&txMy!r%JaE!u z!83ax{vHc@ufr=lc77~aj9l>OWHb2dIs82q&h=DmT6g=A&?Rbi^XFjqox)ky2|-s3h8 zgpDQLqds?gAXqmGQ!lZ4Ak=s1;2-(mzHp;yRr!<~_l2A*x4)fv_P#Jl@vly)-`^KL zeEjB-eS7Z<6>o8~t%~jog-6@egnxQp_%m#Y^2ECPg4!yKo0xK6=r>z6;Lkbtg)1Qo z_il-}FG%-8?+eeCes#U=oA-r3obCnN_PsBRw923OyyJbLY2B4uja%Lq4j*#9?BfKt zio@T1;geCnO<#Zap3v8-Tb|+fd%~#B7xoW6drycfZM(AkhkL^1^|`7yC;mkvqRaw-#uYvtJ7^~bh#&tn>@AMZtr`7o4Db4O_SqG z8za1HnZP}{D>N?68MOY+UBRN@+P==+Nez`s=%b zTmR2o`+s&<@Tpu7;G1(-h*<32+3Tab!aAE7CwE;<*Yy7?sixBM$u`+ z)i!s9FaEe0HqZU8kak?jc{tt`)E0+2R&sZRsBRfwFMm)gj6D7SZ* zf?m~yvpWrTUNZX0_qBp^pSRXM+FvUKb>fOGchw432kvh0DyS8(_I;c@(Z5#c=%V-GI@SuwPg*bevQ@2ceL`@`{HC?Sxr&(% zZ`#)iF5VpeY6Wep1MgWrtPw_)FCK93c8#Db7yAEorAGLAMAw=3&(;Vnmt+=O|6C(X zHh9(h9Ig>M{5dRW#8)-K)xEVd7k*YFY<|}>d{17Du+7=v!ELJ%wq|~iGJa!?@N1{E zWo4^t1Q+)u&hATUgym;ic&wgRBg{`6w8}cJM&NqXtJX%=2#)QOroAzxM)>~p)2uz? zYJ~nj*)^FKTqF3t>A$v#P$M{3_QGF{P*m~fsx_T!gr3TGZiKa|5!wakc_=-xU)*Yh z6a}~cNn^N;&lJXIMj^B9=a2uqZxqtDUY~vcwo!0aFP&h0%_wXhwm#qcSEJBxTd#>j zP8fy$=l6}B^Sx1+GjPp{yb7aG`DxqR*S|ChyKi?*=vHbJ@)S{aOLC2ZdRb}iub&!) zP+P9Au*oP~(IkDo;{&6xTrtR|^>Vmxm3P?wu2DGh@J+jRiALdx%lxgoXBmb1f|?Vf zryGS8NeTKplZ}F<|1S@>j57*{Bbyx^KHMlMEC=Eb;oe;O<&glR;5oI`?hlnl;bw<< z^^tx?!N$^JNszZu=(Av4Z(nzW7dNAj!Z-^{8zbGvz-A)ebBv$aot|TvHtG3=Fj(fd zb@J~H?%N`LKci}kv>w1HGw8L?Z%ncMuQMn`O6S!WR6C`7sAayopZyo*=WprA9x=mT zpU*Hke^D~EGLvPd$fRiW+a}H=Izl#huoE-Fg2fD=r#$%0R z9Uvd51@ymTGf%a8HGcar80VSv4;zIKGTW~*v*{3u!?aPKB|8Wb<0Xf@nWtNUWAumz zzbR_k{WsE{a`w|-d9%Ijz;y2Bg;YBFu3+M*qyqvK+oAEn~A8~9Mln(s`DGE5|3AKjW zLfxVMP%tzBnhC{2E13+=u`ZB5L_f|LG)v0I2d(iy4T}QR@HTEnUkCN+ zXw!}GU7%YzmIk*LZ5qEH%8W%E^F}$v4RKVgY?~0%6(S`f=qPQ>~vjB=qsf?I`Q7jd1dcC0Q;E+(? zu)zZ2wW3l+n$&r#q1LK^siB3(G@eV7HS;!JL_7RA0C^U_azJsQ^t z@z;2z<9z4F$LL}skrx{0{c-+e{{;&cL{6s*fqt}wREG(=2;boY#r)(q@Ow+lPno%2 zs1&Zefu9tv0)ACZkxsId@3aUDmWFgBw=YgCW8RU-qb>Y2QW)=83+6^)q;uVa!uU7z z>q&mW@H1-@{^XY)Z^6dkg&z6X-sHzpELa7#FDZI)+)%+=bo(YqW5P?f_!74geLUY8 zVW!K!lccv`mY#5HO_5kIH64?Xm=NKs><*KuD=fsmA^VB>CjbAhHqP3DS@*C|a+Vyk z9E8(~FVJog(p=k2-BiihSu#6+Yi8HOS}X2fiv4feu{WZ>G*q1m=(esyD-+HE9L`ZELdxXP6&VYia&=h19lCyXRiKs%(aJ; z(a~V9Zf#}3taLb$sEzT^DDild-ptK8STlzZ8>4lFrM8jELfIN$YVLRq=|(y-El$ca zXt{h`1GibYigEbOqmY;38o15E(H9b}gG})?aGQlQzQfp}sV~DdaGQlwjK@#~nc{2U zHVa2z#Iz1Fg=^q83#Sgn7!H}jHE^4SQ(?jNMaUGcf!i!x*#yS;i7&%7aGQnGV}W#6 zl-U$t1GibYs!^B&j(!=gf!iz`jd&L!Q+(#`7w5Z5KHp8PS<`Dy%<+(P&ebDP2apaO zxiy-Kxm#*uXkY%eue326<~;`MOrSFPICD4WWX+r+8#5>L2d5tPTF%psdFt$$XCxSE z%RK#Um}f{c1J~4sHPzX%rjfR+Dg2s-I2$;83BKzFu{|rr_I%13Z}8(cej(p+$YXaq z);-FC`5tP_TIp<<3y!r4brScNBaD*5pd1w5+-)8Q=VZm4mf9O_4UJXSN-R#GeuH#U zI^+5YrBWR2ZCHDxdA|0DZg}9GH-%OX&ps?m{^W(*O?}2`1kn5e&h_q)$yv9Es zZ_M4MILPmigXmVnuU?Lq_M5xSj}hzg8tM>v@bTe8_uPhKkN{NRyvnBkC8Z!p{TPS&IU1U)yl7=wd+HO;F}gN7f|7&S+z>)|%?IOvBh|C~Q2+ zgdb06iu$+0cu9UOW?Vs1L^wYn3fs(|j-&kdIlZ z#T<7IW4CY&k+Zp|z<3iYs;HRZ~gHHD%2p?2Vp`f+JuaM0Sr z7yk4gHWMu@ELo#w%-TZDAvMXL^KxKb=xbi+(_Xl4dL_6UQJN~33We6zkzzddW#!^NmDG^s$|)E-`q z&}Y2F@>Or)SQU|qhk2h@C8zG)XcSEx(w+a`nvsxj>iRmD_laA@qM~wY}&j7^F;m!lO z9a61bfn9Cp_Mo}M3Ct}FHdW#^U2P%8g;veJ-;DU6AjCx^_lzxA4^5vhut|AzL>`gP zSMtbt*f9^CE%U&6^uW3Hz`6G5(bQlo`a8hi9)1WD($wf`aIT^{p)?1sWNdCK;)Y!Y zZia{^x2@QBsC_i-JGB2g!o9sp3Y$O_({e^y3gp2F=`~>^RyP{6op5{;9FKOr0sYo&4D#q{&wO;BFrUbenUDWR z%!k{^#L*RHqcWsnfZ}}Y5XKf^Y?u$)gb&(;PmebY&Q6vuuJxwAF(Lz>ts!5z-Eu7* zSWBHFYZ(cmPqakaX&K^SY;I^;CDpMl;;>;(A($^vzRlwFaFWU}1bsj349A+Bl-`T> zzz@>A;qSnlH`u9YUkdio{Q&<3hyYvf6B2FZIxyw!_bSZOj^kbc^0o?mUH%IYW+x<= z@=x<^q~%KUc!NBT7t4gQ;F{DD*QA!nf6E?XnJSzyR#{HRZ3-=o%bjWEdVpAPAw`0xyU0CxC3M0uS z8O<=namoVcQ*5VbpGeCM;|yK9J=)T>-x=3_1#6b@^4d?w1W+HL_LE?t^mwHonEKUx zUyfBmwz$7W8`svBwT&Fl+WLpEw%izoaZKxmJV^PvhkV^dzKk#OrEP2)XY80$g1y#M zhfQ1JzTF$RcWA0ZF@1ZqMJXI--H2KHBX3$9|4JLb-kD?dkdK@vXJ;GcjO&1N0`3M> z*;X{xT8nc)R0%uW756E-p{#OPTP5yMLMHd?+Eu$Q92)?c+7+j;W(u?e1;#GiyU;r0 z2hJ3@7Ljc#&&KW?%YY`!>2Nll8 zy!_Et5~OxwN^{o$j@^aU$nns%tgXK<<_KP_iP6DeS7lRSt+i5H;`{`E!m+chEZDE8 zlN-IH>xD-bTh<~p&7y_>I*S(EY71$kk=j!bZiIPsw`Z+FH(Rvw-)PZ_TW9gI^+;jV z2*ZheRU@X{wulzJ69neWm`j zbB`*tJFb~6YsL*@;-~5gTdj>+{@iPWdyS`t;(k1ytBmAWvRaypn7cXZ(-^;+qu!f` zxEis>ugb9k*XZUptU203^H31ijOIOD@j1+bHR)le<~7Ec2ljANdvtN^)k^2a zT12{v&n2%S`#4A}wj|W5?_gaKBFM zbI#~<3g&de9`h>42@Uc){_pw4?H0`U(Y6ui>)Q7GWR86UncB9;KeS=f_@a0h&$1v> z8|G{=)(k=-ln$2A+u>dWrg$WfcvV5#(IhtJqixXz;wAx?}WR!ZtW6lVqHiN+!q z%q#6t$5B?S@j>{}T*LxwVZ&PJ(5Em@Y=O4XqKBKxR;*)rj@RSm__ts)o+m<-KGD|f zKB_5?qmgC`M9(&e;%8A5j7DPd9H5@W`kD@k$2&^r)%1A`pNSAu%AX5J^BI3>9N)T$ z_TV!L?u);=kxwQ3jj!29&%S6gJ%4hC?I6b`?vVd8J)<)Z7xkKOrejRude4-et&PME zQZVk(>ojcdLIxh5J|9 zZiuiuo&`Y+_sQtqSXocl{*0wT-o4@O1OL8=s~_$~4M04&Z$)t$aBs>RZxW8vV*0 z>Isd8qM-TEYA6f(461;Bg8qUUN8{cj)E^oNy#+->bD?EW8nhMq9QqOZ6LOqo!8$`K zC>nYX+5qXH5@;Xv1M~}Y7qXab!QO!SL+?N{q4%J4C>Pod9fZz9cc5pGV~hp!f;vFG zp~28tXa=+h+5qK2yP*Tn&(LqsA5a}+jb}ON8O(w;VwTK`S+mA?4uyF=vu6%?I{}}5 znSwbp7v_p*LrqyT)*R34JeVhI!Ms>Y_6BRkym2?phqYn8tSxKD+A}}afpuh^SZ92D zP*>IsV^McBx1MNby;yJ72lKAJtRL&o2CzWJGXYI$Ab#^;Fr!~&8irrx2u4F0!G>ux zk-Dga_@tRpT_a;+*o@fdo&zIv(R0Ifn$hu*niy4hf-YJYji*5o}>oi(%-w;irCLuaJCVGKp*ysu4b%;UokAD$lD2_@P93M9$dS((1My!;E z7|OIu7af-rpOhFH9V@2)a^KLonmAp<;KSpPGfMC^QBj&NL(dJ5NkV>xL?=chAp2tG z5~aA4qjmp~BkcKy6ow^e8kUhfhQ}r9!s8;O;=HNR4UC)>A04L~f=WScM$dh*V^DNl zc*1-!bp#s}A0ML$m#P=e!7=d>vrYSuF}Xg(9KVc8$~y&b7~+Nhkmv*rPGfvrc+AVA zOwo!}IXo^hI)YB%i(?v`HN-tECO%x(vxn&@(b?PIv)9UCq+Hl#ysiM)p;go{}=1s@Y1i<*i_96RHmN;xJecDg3v-`@WZ1vVW%F&yo7 zdW>d>MyrX7)Wk(ZYhF~!*d(1c$?PP)*fBmTdItO(ltlD(jFg!obDPXEnMY+BWZsc! zJx7YSnap-Fd6^Ss#>w0)GgD@n%>6PeWuB2)E%UKVy96mcFPTc2Lu7`?oFQ|e%ndTP z$t;xlh0H@TPsqF=^R~=-nRba%`tCA)Wd_I$mid;C$oplV3}{poF#LC%ylyLGK*yHm02lMOa%W;u^gAANtmzFB+Q6Uh@}hU;P@mO z@tKbWUBHqO5^!NxCB#Q)5)+3?G~5q&V?XgINcz#Ox03 znHZg*OA3#f5H~M64k@l{G(1rpa%O50R0$aS;&kko)r2?Y)F$`;wS{9VSyr+Tn3C;wQ09h+i&se8MnIIOWuo&Qc1EF&cw#u$Ua?=6_NirOXXY zW(!ejBukS8P2{kcq{Jw(>})n2IVwC+H#8w39=RG#xiWM2D|=P54~R-~8RUAsU+Sy}CnZR_m|q8yFWkUK<@Jo@KV*Dl{f>U<~q!PaI?;dlNAk z)35{NLgpmbH{_yO6x+=aMnz9gph?m`Di2lDz{p6Pgha+pHX0Ql9x3l1nv9z1g)&88 z9;u?~7EVQiWk`5*q6U{Y=?pP;lj=?t5gJdehS~>0wWgRGwmufc4aKBSJ}a!qD%3Qt zn!MPOSI>-?gGDcWDTOiNu^Qy-twu;nD;0jKXp048+1#)fb&^Z=i#o|8*NZyIA(wc_ zfkvYSj}F&LGYQ0enbI4ti=E;|8Wt|56{3++Ud#Z8AgSU+iatD4n5k zbE6aD<6_bAq=F}+$;xdFn9U8gWownK4Fkn;%f ztcX)0whEshaX#eJcZ?0jFehbd66+!5P|nvRHgagln4zP3_7FdwnFiJW=HF@{DgEXB zqQC9@cX;&3ywv3*+{^i2-F|w<`^1b>bcadWXm%xCX>CkVN>15Dp-emeiJbR8?fK97 zTOi)o&;I`N@ir*renxB{K zMtGL7bpF!TvS;ok$;il&xMaJbo~)onDI)U`{y^6GEN^M|-~M0nO!5knx%=N4exMxw z3xxkU^IE1S`#rNd6Aw>b*^00B3v1ae_TPB|8W_A=?JG}F; z*{0|0z3_~k{ONi70okVK?rrgWn*8Y*^$3W{q5|*8{zmX3KEqL->A8F)p37IO5I<;I zdt$z>gw~fFhl)@Z;u+{DY~oeu0&Mg3Vzh2-0px`>T*O&;*6$CSp7}phA`PTV&;G|l zv_6cO4XI%h_d+_@^lm^sL}j6O1O`B2dBHr0*5VLNYix*HdZN9;pSTr@f=$eal3~+3 z2G1ZdPJhOhK~xX)&cPeKrM%I*2PJ(Zo8Cd-`${&wi*T%;WYaqdQwK;ky_;|+P_oU} z$(XO9p|v#MKnk2w;vvWvHt_`H51Za=@DilF(fbW+Wt-k}cq-d02=xY0{?*`}fpWUw zqQR0)?>;mcD%tc7#5TMGL3OSNy9P@(y$ewQRl}d&iTFdd>Ai?$kXR?+{SmmUjJ84V zNrXURx}a&j7I81$omh@A#7amH+kBlEtshg2L3!a%d;=N)+kCwit>ZcZ9fCjc0(2HO zy^rC6cQGhkdM_gjqP)@j8F9D|MeWvnjUcTZEE~tzMzkN|eyE7r5@=d4NMz&jUM~EJ zO`ub-&DZkL8b4Ji&dXTz9dIf%3by(BJX*J>$2%d*;ZH1qw!$`Fb4P3OjL<3g6Q4o1 zVVkc*r1gnGVOU;?JP^k~^{~y?(9znuw8_W=%1hh^MZ%`{PHG^rJ-_vG%^|Hl48nBk zZKOpU1Ly5J@<#8$ELWp%qMfIKSD`BSo3F##5RP}sr=z|QhByJT9B&~q3bq?;;uhIo z4+cj_ZCC~V2>BsQ6}TVICa9fMfaf6^0}Ws+4f2XGYA^!|fNj36%6ttLt-T6?79tEW z9@+?-sDtuh6PH2du+zW_h|(fHBsZ0DCi)i?gfK>Md$g1{J=k~_!lS%4U>Mm5PmG%l z8{xH}5poE{v7mb_y^DnRg}@0Awf`{CG7jew{z`BpMDdIQ-2MfhMPRLL-vfufFQpp{7C_Xti@=i*rF#l|3Q;@`D;Rqd zqI{~rFCg+SCp#5&G7&bIyb9+V>zjzfS7SZ^dlcAWJ;n~$Uf`+^Q9rOh0KeaW{Nvc8 zV53bKE8tJ>R0cy7KfO2kv22%twGidu9(ZvJ>K(@#z=(9Yyx^UWFc*Zs5nS=HbiPu- zq)*Ui;hzk$t&+bMr0?0F@)83-#WebmpWQTz<5FJZgDBHx(WP2BQNVbW0pirb+ z2TuA;jt4A(D4q&1@FMCKVPe2D&{o)ILElSK8z3$=AU*h}f^9CNzrgkd??Tl6?}08? zq;}{APJt-?Z14|=@_!p_a#gYwpc0}mM3rn44?`5b612P~%} zi39(@xCDC$cnqTJNEMiI8+`!B7J;`RvAp29KT&T8e*wI9M;d2{t^UG16aLj+5anMF zMq&LMm5Z1S*}RSR0A7W>VP6AVW3Ac;uzkU3Xb9{W@JA>L_EGR7tk+P$-U{x6XueAP z3~Mdi;lB%PVJD^K1-=7O9@Jn@droW*{@@vi{Lg}V2g#o})lst5;71UZWh=N}wkyD{ zST9$Ov<85)pfcDo;B|<~SPd$jr1(dH%Vb**UXX1g80{?8TMYQng=2Myrw;7f6ze%D ze(>97DDOKM_dsV)j&+9Z29`q9w#&ieEl@x3KLy_R!a91`b>I=KNn=ydcfg^oIJOo3 z!Jq-6d=kHF&9Q6nuLS#GZQN1V0iY4ehD}tpmFj^QBiqCdejHnfFrC5ekT25O1)hVb z-U2#s?03i?{?*`vj&d2nwVgPzzodah5QQ%XM|GCUMce>UKDUCWA@O{H4qZ4FggA-g zpslb&!KDzLi)_#b>*Cb#{{Zywj__zF#A2ul{$*fj55!5wg0~^+v&4B=&sGorWY89C zOzy#U05=Dqp7DFI>EOqG(HCHE1$Xz8>~hc#YuL)+PaGYHwRx~rpgIWc95&Hvpj37n zFbui?epUiWu0+3rZ3Mqxg*t(K6zsEFs#_J93DJ4X1}h*cBXQ9hX>3UW??9BF zI`E5iSZj!Q%E6ZF(Pm(KgXbZt=L=w?57D>DA54Re!X}nMbPs_zYy-zm!Cwt(Ap`6( z@E52WX`Kas-vk@})nGHMFQdGE7r4_<&MJhAj6)FJ%Kz(WwlPYnMUV+#Bu!Q)UQ>{H;- zPf#}4v~Kk~h&~?~z^+@d77qTjesCE??R+`7?^EJL)D zCVraDiJz$}z$!=!e_~j^*+lxDm{izA`aYI@u!;2D zC~Cw>r0*dyz$VgnkkGM2`mPfSL!|FHA%7x$2LRbbT7yhBk-oQqY$AQf0NKRtvQ4D5 zwd7Bv_3302X`MCML|V&DHj&m)lTD;G(PR^89W&WPTFXggB+@!f@+Z<7UGgW=I!5v* z-jHotx2PzV{MmnR|6K!O4d6NpLMaU^gx28UGtF!KZ7p#x1pDZF4&Ou9esvolB*(^h z&z08N1h((qRoUJfONHViu^c6^{e;kAT>{#B(+aT2@R;~GOls&GbK}>nV(sf zS(#atc{Y<(VBUoNLD{Nob+$G;B|9x!pIw$+kzJK-$TnuP97T?Ijxr}GN0p<_(dMM& zq~+*y%5o}ls&WiD#vGQb$o0-u<_6`ea@D!o+?3q3Tzzg?ZbfcYt|8Z$%kmU?-g(Nr zpgdKcI!~LIl9!gJ&nwHT$g9dTtnT79xUMW3oq)2Hk8`h0zvzFc3SuhduR&*}~OYQ0fkr)L>98Hx<| z4DSrT3}r?@Mo>m@hAKmy5tX6MNX|&fNXM~fSO{OB#J<~hWFH@NrkQtO2ocXfFB%{rwW~ODP%PproGbJ|_=Q%yMx~Q(mrr5pM zuQ;GMxHzmhsyMkgwK%;vzqq`(viNLqb#Yy>O^JJnUr9hoa7kE6R7rA4YDs!Yeo1*r zWy#r+>XNz=n^JewQUGcw47HPtnn^FsFD);vEInIVU0O$VWW<~ob!3D3@k8ANqh6v= zC#k59eAGoH>Y*BSV1x4eq3ppKVJLSp%AAh!mZPj^QO>#y8v+J^La@=$LasqOKbHZ|>a*}gWbJBD2bINlnbI#^e=hWrc z^;z6-J3IFdeP0Jg-u2 zdp2lye)$3U!TDkNQTfUFsrl*o`T6DfmHB7$tMlvfZ3^5A{0agJf(yb5q6(4=Qqe~9 z(LO8DHmlJtZO|tD3Ihs*3&RSd3X=;{3)2hp3(E^D3(po-7uFTp>~P;fZ)ba>uK!Qy zuj(Dz9Vt7~cIbDM?WovMwZpK(xPuibioA=IML|WXB6X3rD5WT^NMBS|R8dq_WGFHg zv0_EBcd@cKs9063F4h*O6sHyIi_3~DimQqZ#l~V*qA2k$QI-Uis7ll&+LDx#v=V(u zSxH4nRf(a*Si(vbrQYbXLFlh)^wkvfQ+;V!X+>#OsiD+Z$`tqvfhNh&TfNa!gV0OW z=%Fd-oqF`l3iL_?dL%<{^hQq%5__Q*JunTuuM9n}3cb#V9;ZNWQ=+G-FfMD+!_v^Z z$}%f3DjPD5nJi0@<(;L>3d&Mtsk5|MDOqV*`mD07ima+ELzXd%Vf6COR$}y0{kz6( z7KAx1vR#JuT7eephY>v(V|X>j@H&j*Ho4fDg8RTg5PC*FdPOyQL;%tcLk`lBIxDcj pXzY&h*bgIe0LEl$X==1JEm~U&+FM#d1zM5 + + Feedthrough + + + +

+ +

Feedthrough

+ +

In order to reproduce the reference results the following parameters need to be set

+ +
Float64_fixed_parameter: 1
+String_parameter:        "FMI is awesome!"
+
+ +

and the input signals must be applied.

+ + +

with the variables

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableStartUnitCausalityVariabilityDescription
timeindependentcontinuous
Float32_continuous_input0inputcontinuous
Float32_continuous_outputoutputcontinuous
Float32_discrete_input0inputdiscrete
Float32_discrete_outputoutputdiscrete
Float64_fixed_parameter0parameterfixed
Float64_tunable_parameter0parametertunable
Float64_continuous_input0inputcontinuous
Float64_continuous_outputoutputcontinuous
Float64_discrete_input0inputdiscrete
Float64_discrete_outputoutputdiscrete
Int8_input0inputdiscrete
Int8_outputoutputdiscrete
UInt8_input0inputdiscrete
UInt8_outputoutputdiscrete
Int16_input0inputdiscrete
Int16_outputoutputdiscrete
UInt16_input0inputdiscrete
UInt16_outputoutputdiscrete
Int32_input0inputdiscrete
Int32_outputoutputdiscrete
UInt32_input0inputdiscrete
UInt32_outputoutputdiscrete
Int64_input0inputdiscrete
Int64_outputoutputdiscrete
UInt64_input0inputdiscrete
UInt64_outputoutputdiscrete
Boolean_inputfalseinputdiscrete
Boolean_outputoutputdiscrete
String_parameterSet me!parameterfixed
Binary_input666f6finputdiscrete
Binary_outputoutputdiscrete
Enumeration_input1Noneinputdiscrete
Enumeration_outputNoneoutputdiscrete
+ +

The plot shows the trajectories of the output variables computed with fmusim.

+ + 
fmusim --interface-type me --solver cvode --output-interval 1 --output-file Feedthrough_out.csv Feedthrough.fmu
+ +

plot

+ +
+ + \ No newline at end of file diff --git a/testsuite/resources/Feedthrough3/documentation/result.svg b/testsuite/resources/Feedthrough3/documentation/result.svg new file mode 100644 index 000000000..b7341b023 --- /dev/null +++ b/testsuite/resources/Feedthrough3/documentation/result.svg @@ -0,0 +1 @@ +−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.51−1−0.500.5100.511.52−1−0.500.51−1−0.500.5100.511.52024time [s]Float32_continuous_outputFloat32_discrete_outputFloat64_continuous_outputFloat64_discrete_outputInt8_outputUInt8_outputInt16_outputUInt16_outputInt32_outputUInt32_outputInt64_outputEnumeration_outputUInt64_outputBoolean_outputBinary_output \ No newline at end of file diff --git a/testsuite/resources/Feedthrough3/modelDescription.xml b/testsuite/resources/Feedthrough3/modelDescription.xml new file mode 100644 index 000000000..b49671bd7 --- /dev/null +++ b/testsuite/resources/Feedthrough3/modelDescription.xml @@ -0,0 +1,129 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testsuite/resources/Feedthrough3/sources/buildDescription.xml b/testsuite/resources/Feedthrough3/sources/buildDescription.xml new file mode 100644 index 000000000..2d09af889 --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/buildDescription.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/testsuite/resources/Feedthrough3/sources/config.h b/testsuite/resources/Feedthrough3/sources/config.h new file mode 100644 index 000000000..9fd4f50c1 --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/config.h @@ -0,0 +1,165 @@ +#ifndef config_h +#define config_h + +#include // for size_t +#include // for bool +#include + +// define class name and unique id +#define MODEL_IDENTIFIER Feedthrough +#define INSTANTIATION_TOKEN "{37B954F1-CC86-4D8F-B97F-C7C36F6670D2}" + +#define CO_SIMULATION +#define MODEL_EXCHANGE + +#define GET_FLOAT32 +#define GET_FLOAT64 +#define GET_INT8 +#define GET_UINT8 +#define GET_INT16 +#define GET_UINT16 +#define GET_INT32 +#define GET_UINT32 +#define GET_INT64 +#define GET_UINT64 +#define GET_BOOLEAN +#define GET_STRING +#define GET_BINARY + +#define SET_FLOAT32 +#define SET_FLOAT64 +#define SET_INT8 +#define SET_UINT8 +#define SET_INT16 +#define SET_UINT16 +#define SET_INT32 +#define SET_UINT32 +#define SET_INT64 +#define SET_UINT64 +#define SET_BOOLEAN +#define SET_STRING +#define SET_BINARY + +#define EVENT_UPDATE + +#define FIXED_SOLVER_STEP 0.1 +#define DEFAULT_STOP_TIME 2 + +#define STRING_MAX_LEN 128 +#define BINARY_MAX_LEN 128 + +typedef enum { + + vr_time, + + vr_Float32_continuous_input, + vr_Float32_continuous_output, + vr_Float32_discrete_input, + vr_Float32_discrete_output, + + vr_Float64_fixed_parameter, + vr_Float64_tunable_parameter, + vr_Float64_continuous_input, + vr_Float64_continuous_output, + vr_Float64_discrete_input, + vr_Float64_discrete_output, + + vr_Int8_input, + vr_Int8_output, + + vr_UInt8_input, + vr_UInt8_output, + + vr_Int16_input, + vr_Int16_output, + + vr_UInt16_input, + vr_UInt16_output, + + vr_Int32_input, + vr_Int32_output, + + vr_UInt32_input, + vr_UInt32_output, + + vr_Int64_input, + vr_Int64_output, + + vr_UInt64_input, + vr_UInt64_output, + + vr_Boolean_input, + vr_Boolean_output, + + vr_String_parameter, + + vr_Binary_input, + vr_Binary_output, + + vr_Enumeration_input, + vr_Enumeration_output + +} ValueReference; + +typedef enum { + Option1 = 1, + Option2 +} Option; + +typedef struct { + + float Float32_continuous_input; + float Float32_continuous_output; + float Float32_discrete_input; + float Float32_discrete_output; + + double Float64_fixed_parameter; + double Float64_tunable_parameter; + double Float64_continuous_input; + double Float64_continuous_output; + double Float64_discrete_input; + double Float64_discrete_output; + + int8_t Int8_input; + int8_t Int8_output; + + uint8_t UInt8_input; + uint8_t UInt8_output; + + int16_t Int16_input; + int16_t Int16_output; + + uint16_t UInt16_input; + uint16_t UInt16_output; + + int32_t Int32_input; + int32_t Int32_output; + + uint32_t UInt32_input; + uint32_t UInt32_output; + + int64_t Int64_input; + int64_t Int64_output; + + uint64_t UInt64_input; + uint64_t UInt64_output; + + bool Boolean_input; + bool Boolean_output; + + char String_parameter[STRING_MAX_LEN]; + + size_t Binary_input_size; + char Binary_input[BINARY_MAX_LEN]; + size_t Binary_output_size; + char Binary_output[BINARY_MAX_LEN]; + + Option Enumeration_input; + Option Enumeration_output; + +} ModelData; + +extern const char* STRING_START; +extern const char* BINARY_START; + +#endif /* config_h */ diff --git a/testsuite/resources/Feedthrough3/sources/cosimulation.c b/testsuite/resources/Feedthrough3/sources/cosimulation.c new file mode 100644 index 000000000..782edf1b2 --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/cosimulation.c @@ -0,0 +1,691 @@ +#include // for calloc(), free() +#include // for DBL_EPSILON +#include +#include +#include +#include "config.h" +#include "cosimulation.h" + +#if FMI_VERSION == 3 +#include "fmi3Functions.h" +#endif + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#ifdef CALL +#undef CALL +#endif + +#define CALL(f) do { const Status status = f; if (status != OK) return status; } while (false) + + +ModelInstance *createModelInstance( + loggerType cbLogger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType) { + + ModelInstance *comp = NULL; + + if (!instanceName || strlen(instanceName) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, "?", Error, "error", "Missing instance name."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instance name."); +#endif + } + return NULL; + } + + if (!instantiationToken || strlen(instantiationToken) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Missing GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instantiationToken."); +#endif + } + return NULL; + } + + if (strcmp(instantiationToken, INSTANTIATION_TOKEN)) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Wrong GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Wrong instantiationToken."); +#endif + } + return NULL; + } + + comp = (ModelInstance *)calloc(1, sizeof(ModelInstance)); + + if (comp) { + comp->componentEnvironment = componentEnvironment; + comp->logger = cbLogger; + comp->intermediateUpdate = intermediateUpdate; + comp->lockPreemption = NULL; + comp->unlockPreemption = NULL; + comp->instanceName = strdup(instanceName); + comp->resourceLocation = resourceLocation ? strdup(resourceLocation) : NULL; + comp->status = OK; + comp->logEvents = loggingOn; + comp->logErrors = true; // always log errors + comp->nSteps = 0; + comp->earlyReturnAllowed = false; + comp->eventModeUsed = false; + } + + if (!comp || !comp->instanceName) { + logError(comp, "Out of memory."); + return NULL; + } + + comp->time = 0.0; // overwrite in fmi*SetupExperiment, fmi*SetTime + comp->type = interfaceType; + + comp->state = Instantiated; + + comp->newDiscreteStatesNeeded = false; + comp->terminateSimulation = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->valuesOfContinuousStatesChanged = false; + comp->nextEventTimeDefined = false; + comp->nextEventTime = 0; + + setStartValues(comp); + + comp->isDirtyValues = true; + + return comp; +} + +void freeModelInstance(ModelInstance *comp) { + + if (!comp) return; + + if (comp->instanceName) free((void*)comp->instanceName); + + if (comp->resourceLocation) free((void*)comp->resourceLocation); + + if (comp->prez) free(comp->prez); + + if (comp->z) free(comp->z); + + if (comp->x) free(comp->x); + + if (comp->dx) free(comp->dx); + + free(comp); +} + +static Status s_reallocate(ModelInstance* comp, void** memory, size_t size) { + + if (size == 0) { + if (*memory) { + free(*memory); + } + *memory = NULL; + return OK; + } + + void* temp = realloc(*memory, size); + + if (!temp) { + logError(comp, "Failed to allocate memory."); + return Error; + } + + *memory = temp; + + return OK; +} + +Status configurate(ModelInstance* comp) { + + (void)comp; + +#ifdef HAS_EVENT_INDICATORS + comp->nz = getNumberOfEventIndicators(comp); + + if (comp->nz > 0) { + CALL(s_reallocate(comp, (void**)&comp->prez, comp->nz * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->z, comp->nz * sizeof(double))); + } + + CALL(getEventIndicators(comp, comp->prez, comp->nz)); +#endif + +#ifdef HAS_CONTINUOUS_STATES + comp->nx = getNumberOfContinuousStates(comp); + + if (comp->nx > 0) { + CALL(s_reallocate(comp, (void**)&comp->x, comp->nx * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->dx, comp->nx * sizeof(double))); + } +#endif + + return OK; +} + +Status reset(ModelInstance* comp) { + + comp->state = Instantiated; + comp->startTime = 0.0; + comp->time = 0.0; + comp->nSteps = 0; + comp->status = OK; + setStartValues(comp); + comp->isDirtyValues = true; + + return OK; +} + +#define EPSILON (1.0e-5) + +static double fmiAbs(double v) { + return v >= 0 ? v : -v; +} + +static double fmiMax(double a, double b) { + return (a < b) ? b : a; +} + +bool isClose(double a, double b) { + + if (fmiAbs(a - b) <= EPSILON) { + return true; + } + + return fmiAbs(a - b) <= EPSILON * fmiMax(fmiAbs(a), fmiAbs(b)); +} + +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected) { + + if (actual != expected) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = %d. Expected %d.", f, arg, actual, expected); + return true; + } + + return false; +} + +bool invalidState(ModelInstance *comp, const char *f, int statesExpected) { + + UNUSED(f); + UNUSED(statesExpected); + + if (!comp) { + return true; + } + + // TODO: add missing states and check state + return false; + +// if (!(comp->state & statesExpected)) { +// comp->state = modelError; +// logError(comp, "%s: Illegal call sequence.", f); +// return true; +// } +// +// return false; +} + +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p) { + + if (!p) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = NULL.", f, arg); + return true; + } + + return false; +} + +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]) { + + if (nCategories > 0) { + + if (categories == NULL) { + logError(comp, "Argument categories must not be NULL."); + return Error; + } + + for (size_t i = 0; i < nCategories; i++) { + + if (categories[i] == NULL) { + logError(comp, "Argument categories[%zu] must not be NULL.", i); + return Error; + } else if (strcmp(categories[i], "logEvents") == 0) { + comp->logEvents = loggingOn; + } else if (strcmp(categories[i], "logStatusError") == 0) { + comp->logErrors = loggingOn; + } else { + logError(comp, "Log categories[%zu] must be one of \"logEvents\" or \"logStatusError\" but was \"%s\".", i, categories[i]); + return Error; + } + } + + } else { + + comp->logEvents = loggingOn; + comp->logErrors = loggingOn; + + } + + return OK; +} + +static void logMessage(ModelInstance *comp, int status, const char *category, const char *message, va_list args) { + + if (!comp->logger) { + return; + } + + va_list args1; + int len = 0; + char *buf = ""; + + va_copy(args1, args); + len = vsnprintf(buf, len, message, args1); + va_end(args1); + + if (len < 0) { + return; + } + + va_copy(args1, args); + buf = (char *)calloc(len + 1, sizeof(char)); + len = vsnprintf(buf, len + 1, message, args); + va_end(args1); + + if (len >= 0) { + // no need to distinguish between FMI versions since we're not using variadic arguments +#if FMI_VERSION < 3 + comp->logger(comp->componentEnvironment, comp->instanceName, status, category, buf); +#else + comp->logger(comp->componentEnvironment, status, category, buf); +#endif + } + + free(buf); +} + +void logEvent(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logEvents) return; + + va_list args; + va_start(args, message); + logMessage(comp, OK, "logEvents", message, args); + va_end(args); +} + +void logError(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logErrors) return; + + va_list args; + va_start(args, message); + logMessage(comp, Error, "logStatusError", message, args); + va_end(args); +} + +#define GET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Getting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef GET_FLOAT32 +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + GET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef GET_INT8 +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef GET_UINT8 +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef GET_INT16 +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int16"); + +} +#endif + +#ifndef GET_UINT16 +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef GET_INT32 +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef GET_UINT32 +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef GET_INT64 +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef GET_UINT64 +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef GET_BOOLEAN +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef GET_STRING +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("String"); +} +#endif + +#ifndef GET_BINARY +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index) { + UNUSED(sizes); + GET_NOT_ALLOWED("Binary"); +} +#endif + +#define SET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Setting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef SET_FLOAT32 +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef SET_FLOAT64 +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float64"); +} +#endif + +#ifndef SET_INT8 +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef SET_UINT8 +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef SET_INT16 +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int16"); +} +#endif + +#ifndef SET_UINT16 +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef SET_INT32 +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef SET_UINT32 +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef SET_INT64 +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef SET_UINT64 +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef SET_BOOLEAN +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef SET_STRING +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("String"); +} +#endif + +#ifndef SET_BINARY +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char *const values[], size_t nValues, size_t* index) { + UNUSED(size); + SET_NOT_ALLOWED("Binary"); +} +#endif + +#ifndef ACTIVATE_CLOCK +Status activateClock(ModelInstance* comp, ValueReference vr) { + UNUSED(comp); + UNUSED(vr); + return Error; +} +#endif + +#ifndef GET_CLOCK +Status getClock(ModelInstance* comp, ValueReference vr, bool* value) { + UNUSED(comp); + UNUSED(vr); + UNUSED(value); + return Error; +} +#endif + +#ifndef GET_INTERVAL +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier) { + UNUSED(comp); + UNUSED(vr); + UNUSED(interval); + UNUSED(qualifier); + return Error; +} +#endif + +#ifndef ACTIVATE_MODEL_PARTITION +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime) { + UNUSED(comp); + UNUSED(vr); + UNUSED(activationTime); + return Error; +} +#endif + +#ifndef GET_PARTIAL_DERIVATIVE +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + UNUSED(comp); + UNUSED(unknown); + UNUSED(known); + UNUSED(partialDerivative); + logError(comp, "Directional derivatives are not supported."); + return Error; +} +#endif + +Status getFMUState(ModelInstance* comp, void** FMUState) { + + CALL(s_reallocate(comp, FMUState, sizeof(ModelInstance))); + + memcpy(*FMUState, comp, sizeof(ModelInstance)); + + return OK; +} + +Status setFMUState(ModelInstance* comp, void* FMUState) { + + ModelInstance* s = (ModelInstance*)FMUState; + + comp->startTime = s->startTime; + comp->stopTime = s->stopTime; + comp->time = s->time; + // instanceName + // type + // resourceLocation + + comp->status = s->status; + + // logger + // intermediateUpdate + // clockUpdate + + // lockPreemption + // unlockPreemption + + // logEvents + // logErrors + + // componentEnvironment + comp->state = s->state; + + comp->newDiscreteStatesNeeded = s->newDiscreteStatesNeeded; + comp->terminateSimulation = s->terminateSimulation; + comp->nominalsOfContinuousStatesChanged = s->nominalsOfContinuousStatesChanged; + comp->valuesOfContinuousStatesChanged = s->valuesOfContinuousStatesChanged; + comp->nextEventTimeDefined = s->nextEventTimeDefined; + comp->nextEventTime = s->nextEventTime; + comp->clocksTicked = s->clocksTicked; + + comp->isDirtyValues = s->isDirtyValues; + + comp->modelData = s->modelData; + + comp->nSteps = s->nSteps; + + comp->earlyReturnAllowed = s->earlyReturnAllowed; + comp->eventModeUsed = s->eventModeUsed; + comp->nextCommunicationPoint = s->nextCommunicationPoint; + + if (comp->nx > 0) { + memcpy(comp->x, s->x, s->nx * sizeof(double)); + memcpy(comp->dx, s->dx, s->nx * sizeof(double)); + } + + if (comp->nz > 0) { + memcpy(comp->z, s->z, s->nz * sizeof(double)); + } + + comp->nSteps = s->nSteps; + + return OK; +} + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent) { + +#ifdef HAS_CONTINUOUS_STATES + if (comp->nx > 0) { + + CALL(getContinuousStates(comp, comp->x, comp->nx)); + CALL(getDerivatives(comp, comp->dx, comp->nx)); + + // forward Euler step + for (size_t i = 0; i < comp->nx; i++) { + comp->x[i] += FIXED_SOLVER_STEP * comp->dx[i]; + } + + CALL(setContinuousStates(comp, comp->x, comp->nx)); + } +#endif + + comp->nSteps++; + + comp->time = comp->startTime + comp->nSteps * FIXED_SOLVER_STEP; + + // state event + *stateEvent = false; + +#ifdef HAS_EVENT_INDICATORS + if (comp->nz > 0) { + + CALL(getEventIndicators(comp, comp->z, comp->nz)); + + // check for zero-crossings + for (size_t i = 0; i < comp->nz; i++) { + *stateEvent |= + (comp->prez[i] <= 0 && comp->z[i] > 0) || + (comp->prez[i] > 0 && comp->z[i] <= 0); + } + + // remember the current event indicators + double* temp = comp->prez; + comp->prez = comp->z; + comp->z = temp; + } +#endif + + // time event + *timeEvent = comp->nextEventTimeDefined && comp->time >= comp->nextEventTime; + + bool earlyReturnRequested; + double earlyReturnTime; + + // intermediate update + if (comp->intermediateUpdate) { + comp->intermediateUpdate( + comp->componentEnvironment, // instanceEnvironment + comp->time, // intermediateUpdateTime + false, // intermediateVariableSetRequested + true, // intermediateVariableGetAllowed + true, // intermediateStepFinished + false, // canReturnEarly + &earlyReturnRequested, // earlyReturnRequested + &earlyReturnTime); // earlyReturnTime + } + + return OK; +} diff --git a/testsuite/resources/Feedthrough3/sources/cosimulation.h b/testsuite/resources/Feedthrough3/sources/cosimulation.h new file mode 100644 index 000000000..fda1ebf99 --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/cosimulation.h @@ -0,0 +1,5 @@ +#pragma once + +#include "model.h" + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent); diff --git a/testsuite/resources/Feedthrough3/sources/fmi3Functions.c b/testsuite/resources/Feedthrough3/sources/fmi3Functions.c new file mode 100644 index 000000000..b4ad5fbb2 --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/fmi3Functions.c @@ -0,0 +1,1446 @@ +#if FMI_VERSION != 3 +#error FMI_VERSION must be 3 +#endif + +#include +#include +#include +#include +#include + +#include "config.h" +#include "model.h" +#include "cosimulation.h" + +// C-code FMUs have functions names prefixed with MODEL_IDENTIFIER_. +// Define DISABLE_PREFIX to build a binary FMU. +#if !defined(DISABLE_PREFIX) && !defined(FMI3_FUNCTION_PREFIX) +#define pasteA(a,b) a ## b +#define pasteB(a,b) pasteA(a,b) +#define FMI3_FUNCTION_PREFIX pasteB(MODEL_IDENTIFIER, _) +#endif +#include "fmi3Functions.h" + +#define ASSERT_NOT_NULL(p) \ +do { \ + if (!p) { \ + logError(S, "Argument %s must not be NULL.", xstr(p)); \ + S->state = Terminated; \ + return (fmi3Status)Error; \ + } \ +} while (0) + +#define CALL(f) do { \ + const Status s = f; \ + if (s > status) { \ + status = s; \ + } \ + if (status == Discard) { \ + goto TERMINATE; \ + } else if (status == Error) { \ + S->state = Terminated; \ + goto TERMINATE; \ + } else if (status == Fatal) { \ + S->state = StartAndEnd; \ + goto TERMINATE; \ + } \ +} while (false) + +#define GET_VARIABLES(T) \ +BEGIN_FUNCTION(Get ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +if (nValues > 0) ASSERT_NOT_NULL(values); \ +if (S->isDirtyValues) { \ + CALL(calculateValues(S)); \ + S->isDirtyValues = false; \ +} \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(get ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#define SET_VARIABLES(T) \ +BEGIN_FUNCTION(Set ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(set ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (nValueReferences > 0) S->isDirtyValues = true; \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#ifndef max +#define max(a,b) ((a)>(b) ? (a) : (b)) +#endif + +#ifndef DT_EVENT_DETECT +#define DT_EVENT_DETECT 1e-10 +#endif + +// --------------------------------------------------------------------------- +// Function calls allowed state masks for both Model-exchange and Co-simulation +// --------------------------------------------------------------------------- +#define MASK_AnyState (~0) + +/* Inquire version numbers and set debug logging */ +#define MASK_fmi3GetVersion MASK_AnyState +#define MASK_fmi3SetDebugLogging MASK_AnyState + +/* Creation and destruction of FMU instances */ +#define MASK_fmi3InstantiateInstantiateModelExchange MASK_AnyState +#define MASK_fmi3InstantiateCoSimulation MASK_AnyState +#define MASK_fmi3InstantiateScheduledExectuion MASK_AnyState +#define MASK_fmi3FreeInstance MASK_AnyState + +/* Enter and exit initialization mode, terminate and reset */ +#define MASK_fmi3EnterInitializationMode Instantiated +#define MASK_fmi3ExitInitializationMode InitializationMode +#define MASK_fmi3EnterEventMode (ContinuousTimeMode | StepMode) +#define MASK_fmi3Terminate (ContinuousTimeMode | StepMode | StepDiscarded | EventMode | ClockActivationMode | ReconfigurationMode) +#define MASK_fmi3Reset MASK_AnyState + +/* Common Functions */ + +/* Getting and setting variable values */ +#define MASK_fmi3GetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3GetFloat64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetBoolean MASK_fmi3GetFloat32 +#define MASK_fmi3GetString MASK_fmi3GetFloat32 +#define MASK_fmi3GetBinary MASK_fmi3GetFloat32 +#define MASK_fmi3GetClock MASK_AnyState + +#define MASK_fmi3SetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3SetFloat64 MASK_fmi3SetFloat32 +#define MASK_fmi3SetInt8 (Instantiated | ConfigurationMode | ReconfigurationMode | InitializationMode | EventMode | StepMode | ClockActivationMode | Terminated) +#define MASK_fmi3SetUInt8 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetBoolean MASK_fmi3SetInt8 +#define MASK_fmi3SetString MASK_fmi3SetInt8 +#define MASK_fmi3SetBinary MASK_fmi3SetInt8 +#define MASK_fmi3SetClock MASK_AnyState + +/* Getting Variable Dependency Information */ +#define MASK_fmi3GetNumberOfVariableDependencies MASK_AnyState +#define MASK_fmi3GetVariableDependencies MASK_AnyState + +/* Getting and setting the internal FMU state */ +#define MASK_fmi3GetFMUState MASK_AnyState +#define MASK_fmi3SetFMUState MASK_AnyState +#define MASK_fmi3FreeFMUState MASK_AnyState +#define MASK_fmi3SerializedFMUStateSize MASK_AnyState +#define MASK_fmi3SerializeFMUState MASK_AnyState +#define MASK_fmi3DeserializeFMUState MASK_AnyState + +/* Getting partial derivatives */ +#define MASK_fmi3GetDirectionalDerivative (InitializationMode | StepMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetAdjointDerivative MASK_fmi3GetDirectionalDerivative + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define MASK_fmi3EnterConfigurationMode (Instantiated | StepMode | EventMode | ClockActivationMode) +#define MASK_fmi3ExitConfigurationMode (ConfigurationMode | ReconfigurationMode) + +/* Clock related functions */ +// TODO: fix masks +#define MASK_fmi3GetIntervalDecimal MASK_AnyState +#define MASK_fmi3GetIntervalFraction MASK_AnyState +#define MASK_fmi3SetIntervalDecimal MASK_AnyState +#define MASK_fmi3SetIntervalFraction MASK_AnyState +#define MASK_fmi3NewDiscreteStates MASK_AnyState + +/* Functions for Model Exchange */ + +#define MASK_fmi3EnterContinuousTimeMode EventMode +#define MASK_fmi3CompletedIntegratorStep ContinuousTimeMode + +/* Providing independent variables and re-initialization of caching */ +#define MASK_fmi3SetTime (EventMode | ContinuousTimeMode) +#define MASK_fmi3SetContinuousStates ContinuousTimeMode + +/* Evaluation of the model equations */ +#define MASK_fmi3GetContinuousStateDerivatives (InitializationMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetEventIndicators MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetContinuousStates MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetNominalsOfContinuousStates MASK_fmi3GetContinuousStateDerivatives + +#define MASK_fmi3GetNumberOfContinuousStates MASK_AnyState +#define MASK_fmi3GetNumberOfEventIndicators MASK_AnyState + +/* Functions for Co-Simulation */ + +#define MASK_fmi3EnterStepMode (InitializationMode | EventMode) +#define MASK_fmi3SetInputDerivatives (Instantiated | InitializationMode | StepMode) +#define MASK_fmi3GetOutputDerivatives (StepMode | StepDiscarded | Terminated) +#define MASK_fmi3DoStep StepMode +#define MASK_fmi3ActivateModelPartition ClockActivationMode +#define MASK_fmi3DoEarlyReturn IntermediateUpdateMode +#define MASK_fmi3GetDoStepDiscardedStatus StepMode + +// --------------------------------------------------------------------------- +// Private helpers used below to validate function arguments +// --------------------------------------------------------------------------- + +#define NOT_IMPLEMENTED \ +do { \ + ModelInstance *comp = (ModelInstance *)instance; \ + logError(comp, "Function is not implemented."); \ + return fmi3Error; \ +} while (0) + +#define BEGIN_FUNCTION(F) \ +Status status = OK; \ +if (!instance) return fmi3Error; \ +ModelInstance *S = (ModelInstance *)instance; \ +if (!allowedState(S, MASK_fmi3##F, #F)) CALL(Error); + +#define END_FUNCTION() \ +TERMINATE: \ + return (fmi3Status)status; + +static bool allowedState(ModelInstance *instance, int statesExpected, char *name) { + + if (!instance) { + return false; + } + + if (!(instance->state & statesExpected)) { + logError(instance, "fmi3%s: Illegal call sequence.", name); + return false; + } + + return true; +} + +/*************************************************** + Common Functions + ****************************************************/ + +const char* fmi3GetVersion(void) { + return fmi3Version; +} + +fmi3Status fmi3SetDebugLogging(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]) { + + BEGIN_FUNCTION(SetDebugLogging); + + CALL(setDebugLogging(S, loggingOn, nCategories, categories)); + + END_FUNCTION(); +} + +fmi3Instance fmi3InstantiateModelExchange( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage) { + + UNUSED(visible); + +#ifndef MODEL_EXCHANGE + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + + return NULL; +#else + return createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ModelExchange); +#endif +} + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) { + + UNUSED(visible); + UNUSED(requiredIntermediateVariables); + UNUSED(nRequiredIntermediateVariables); + +#ifndef EVENT_UPDATE + if (eventModeUsed) { + if (logMessage) { + logMessage(instanceEnvironment, fmi3Error, "error", "Event Mode is not supported."); + } + return NULL; + } +#endif + + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + (intermediateUpdateType)intermediateUpdate, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + CoSimulation); + + if (instance) { + instance->earlyReturnAllowed = earlyReturnAllowed; + instance->eventModeUsed = eventModeUsed; + instance->state = Instantiated; + } + + return instance; +} + +fmi3Instance fmi3InstantiateScheduledExecution( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption) { + + UNUSED(visible); + +#ifndef SCHEDULED_CO_SIMULATION + + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + UNUSED(clockUpdate); + UNUSED(lockPreemption); + UNUSED(unlockPreemption); + + return NULL; +#else + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ScheduledExecution + ); + + if (instance) { + instance->state = Instantiated; + instance->clockUpdate = clockUpdate; + instance->lockPreemption = lockPreemption; + instance->unlockPreemption = unlockPreemption; + } + + return instance; +#endif +} + +void fmi3FreeInstance(fmi3Instance instance) { + freeModelInstance((ModelInstance*)instance); +} + +fmi3Status fmi3EnterInitializationMode(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime) { + + UNUSED(toleranceDefined); + UNUSED(tolerance); + + BEGIN_FUNCTION(EnterInitializationMode); + + S->startTime = startTime; + S->stopTime = stopTimeDefined ? stopTime : INFINITY; + S->time = startTime; + S->nextCommunicationPoint = startTime; + S->state = InitializationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitInitializationMode); + + // if values were set and no fmi3GetXXX triggered update before, + // ensure calculated values are updated now + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = S->eventModeUsed ? EventMode : StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + + CALL(configurate(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3EnterEventMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterEventMode); + + S->state = EventMode; + + END_FUNCTION(); +} + +fmi3Status fmi3Terminate(fmi3Instance instance) { + + BEGIN_FUNCTION(Terminate); + + S->state = Terminated; + + END_FUNCTION(); +} + +fmi3Status fmi3Reset(fmi3Instance instance) { + + BEGIN_FUNCTION(Reset); + + CALL(reset(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues) { + GET_VARIABLES(Float32); +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) { + GET_VARIABLES(Float64); +} + +fmi3Status fmi3GetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues) { + GET_VARIABLES(Int8); +} + +fmi3Status fmi3GetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues) { + GET_VARIABLES(UInt8); +} + +fmi3Status fmi3GetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues) { + GET_VARIABLES(Int16); +} + +fmi3Status fmi3GetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues) { + GET_VARIABLES(UInt16); +} + +fmi3Status fmi3GetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues) { + GET_VARIABLES(Int32); +} + +fmi3Status fmi3GetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues) { + GET_VARIABLES(UInt32); +} + +fmi3Status fmi3GetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues) { + GET_VARIABLES(Int64); +} + +fmi3Status fmi3GetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues) { + GET_VARIABLES(UInt64); +} + +fmi3Status fmi3GetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues) { + GET_VARIABLES(Boolean); +} + +fmi3Status fmi3GetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues) { + GET_VARIABLES(String); +} + +fmi3Status fmi3GetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(GetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } else { + ASSERT_NOT_NULL(valueReferences); + } + + if (nValues > 0) { + ASSERT_NOT_NULL(values); + } + + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char**)values, nValues, &index)); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]) { + + BEGIN_FUNCTION(GetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getClock(instance, (ValueReference)valueReferences[i], &values[i])); + } + END_FUNCTION(); +} + +fmi3Status fmi3SetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues) { + SET_VARIABLES(Float32); +} + +fmi3Status fmi3SetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues) { + SET_VARIABLES(Float64); +} + +fmi3Status fmi3SetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues) { + SET_VARIABLES(Int8); +} + +fmi3Status fmi3SetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues) { + SET_VARIABLES(UInt8); +} + +fmi3Status fmi3SetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues) { + SET_VARIABLES(Int16); +} + +fmi3Status fmi3SetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues) { + SET_VARIABLES(UInt16); +} + +fmi3Status fmi3SetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues) { + SET_VARIABLES(Int32); +} + +fmi3Status fmi3SetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues) { + SET_VARIABLES(UInt32); +} + +fmi3Status fmi3SetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues) { + SET_VARIABLES(Int64); +} + +fmi3Status fmi3SetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues) { + SET_VARIABLES(UInt64); +} + +fmi3Status fmi3SetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues) { + SET_VARIABLES(Boolean); +} + +fmi3Status fmi3SetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues) { + SET_VARIABLES(String); +} + +fmi3Status fmi3SetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(SetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } + + ASSERT_NOT_NULL(valueReferences); + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(setBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char* const*)values, nValues, &index)); + } + + if (nValueReferences > 0) { + S->isDirtyValues = true; + } + + if (index != nValues) { + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); + } + + END_FUNCTION(); +} + +fmi3Status fmi3SetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]) { + + BEGIN_FUNCTION(SetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + if (values[i]) { + CALL(activateClock(instance, (ValueReference)valueReferences[i])); + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfVariableDependencies(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies) { + UNUSED(valueReference); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetVariableDependencies(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies) { + + UNUSED(dependent); + UNUSED(elementIndicesOfDependent); + UNUSED(independents); + UNUSED(elementIndicesOfIndependents); + UNUSED(dependencyKinds); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(GetFMUState); + + CALL(getFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState FMUState) { + + BEGIN_FUNCTION(SetFMUState); + + if (nullPointer(S, "fmi3SetFMUState", "FMUState", FMUState)) { + return fmi3Error; + } + + CALL(setFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(FreeFMUState); + + free(*FMUState); + + *FMUState = NULL; + + END_FUNCTION(); +} + +fmi3Status fmi3SerializedFMUStateSize(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size) { + + UNUSED(instance); + UNUSED(FMUState); + + BEGIN_FUNCTION(SerializedFMUStateSize); + + *size = sizeof(ModelInstance); + + END_FUNCTION(); +} + +fmi3Status fmi3SerializeFMUState(fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size) { + + BEGIN_FUNCTION(SerializeFMUState); + + if (nullPointer(S, "fmi3SerializeFMUState", "FMUstate", FMUState)) { + return fmi3Error; + } + + if (invalidNumber(S, "fmi3SerializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + memcpy(serializedState, FMUState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3DeserializeFMUState(fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(DeserializeFMUState); + + if (invalidNumber(S, "fmi3DeserializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + if (*FMUState == NULL) { + *FMUState = calloc(1, sizeof(ModelInstance)); + if (*FMUState == NULL) { + printf("Failed to allocate memory for FMUState.\n"); + return fmi3Error; + } + } + + memcpy(*FMUState, serializedState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetDirectionalDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetDirectionalDerivative); + + // TODO: check value references + // TODO: assert nUnknowns == nDeltaOfUnknowns + // TODO: assert nKnowns == nDeltaKnowns + + for (size_t i = 0; i < nUnknowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nKnowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[i], (ValueReference)knowns[j], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetAdjointDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetAdjointDerivative); + + // TODO: check value references + + for (size_t i = 0; i < nKnowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nUnknowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[j], (ValueReference)knowns[i], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3EnterConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterConfigurationMode); + + S->state = (S->state == Instantiated) ? ConfigurationMode : ReconfigurationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitConfigurationMode); + + if (S->state == ConfigurationMode) { + S->state = Instantiated; + } else { + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + } + +#if defined(HAS_CONTINUOUS_STATES) || defined(HAS_EVENT_INDICATORS) + CALL(configurate(S)); +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]) { + + BEGIN_FUNCTION(GetIntervalDecimal); + + // TODO: Check nValueReferences != nValues ? + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getInterval(instance, (ValueReference)valueReferences[i], &intervals[i], (int*)&qualifiers[i])); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 intervalCounters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + UNUSED(qualifiers); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 shiftCounters[], + fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervals); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 intervalCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 shiftCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3EvaluateDiscreteStates(fmi3Instance instance) { + NOT_IMPLEMENTED; +} + +fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime) { + + BEGIN_FUNCTION(NewDiscreteStates); + +#ifdef EVENT_UPDATE + CALL(eventUpdate(S)); +#endif + + // copy internal eventInfo of component to output arguments + if (discreteStatesNeedUpdate) *discreteStatesNeedUpdate = S->newDiscreteStatesNeeded; + if (terminateSimulation) *terminateSimulation = S->terminateSimulation; + if (nominalsOfContinuousStatesChanged) *nominalsOfContinuousStatesChanged = S->nominalsOfContinuousStatesChanged; + if (valuesOfContinuousStatesChanged) *valuesOfContinuousStatesChanged = S->valuesOfContinuousStatesChanged; + if (nextEventTimeDefined) *nextEventTimeDefined = S->nextEventTimeDefined; + if (nextEventTime) *nextEventTime = S->nextEventTime; + + END_FUNCTION(); +} + +/*************************************************** + Functions for Model Exchange + ****************************************************/ + +fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterContinuousTimeMode); + + S->state = ContinuousTimeMode; + + END_FUNCTION(); +} + +fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(CompletedIntegratorStep); + + ASSERT_NOT_NULL(enterEventMode); + ASSERT_NOT_NULL(terminateSimulation); + + *enterEventMode = fmi3False; + *terminateSimulation = fmi3False; + + END_FUNCTION(); +} + +/* Providing independent variables and re-initialization of caching */ +fmi3Status fmi3SetTime(fmi3Instance instance, fmi3Float64 time) { + + BEGIN_FUNCTION(SetTime); + + S->time = time; + + END_FUNCTION(); +} + +fmi3Status fmi3SetContinuousStates(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(SetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3SetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + ASSERT_NOT_NULL(continuousStates); + + CALL(setContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +/* Evaluation of the model equations */ +fmi3Status fmi3GetContinuousStateDerivatives(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStateDerivatives); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStateDerivatives", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStateDerivatives", "derivatives[]", derivatives)) + return fmi3Error; + + CALL(getDerivatives(S, derivatives, nContinuousStates)); +#else + UNUSED(derivatives); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetEventIndicators(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators) { + + BEGIN_FUNCTION(GetEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + if (invalidNumber(S, "fmi3GetEventIndicators", "nEventIndicators", nEventIndicators, getNumberOfEventIndicators(S))) { + return fmi3Error; + } + + CALL(getEventIndicators(S, eventIndicators, nEventIndicators)); +#else + + UNUSED(eventIndicators); + + if (nEventIndicators > 0) { + // TODO: log error + return fmi3Error; + } +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetContinuousStates(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStates", "continuousStates[]", continuousStates)) + return fmi3Error; + + CALL(getContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNominalsOfContinuousStates(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetNominalsOfContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetNominalContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(instance))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetNominalContinuousStates", "nominals[]", nominals)) + return fmi3Error; + + for (size_t i = 0; i < nContinuousStates; i++) { + nominals[i] = 1; + } + + return fmi3OK; +#else + UNUSED(nominals); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfEventIndicators(fmi3Instance instance, + size_t* nEventIndicators) { + + BEGIN_FUNCTION(GetNumberOfEventIndicators); + + ASSERT_NOT_NULL(nEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + *nEventIndicators = getNumberOfEventIndicators(instance); +#else + *nEventIndicators = 0; +#endif + + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfContinuousStates(fmi3Instance instance, + size_t* nContinuousStates) { + + BEGIN_FUNCTION(GetNumberOfContinuousStates); + + ASSERT_NOT_NULL(nContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + *nContinuousStates = getNumberOfContinuousStates(instance); +#else + *nContinuousStates = 0; +#endif + + END_FUNCTION(); +} + +/*************************************************** + Functions for Co-Simulation + ****************************************************/ + +fmi3Status fmi3EnterStepMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterStepMode); + + S->state = StepMode; + + END_FUNCTION(); +} + +fmi3Status fmi3GetOutputDerivatives(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues) { + + UNUSED(nValues); + + BEGIN_FUNCTION(GetOutputDerivatives); + +#ifdef GET_OUTPUT_DERIVATIVE + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getOutputDerivative(S, (ValueReference)valueReferences[i], orders[i], &values[i])); + } +#else + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(orders); + UNUSED(values); + + NOT_IMPLEMENTED; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(DoStep); + + if (!isClose(currentCommunicationPoint, S->nextCommunicationPoint)) { + logError(S, "Expected currentCommunicationPoint = %.16g but was %.16g.", + S->nextCommunicationPoint, currentCommunicationPoint); + CALL(Error); + } + + if (communicationStepSize <= 0) { + logError(S, "Communication step size must be > 0 but was %.16g.", communicationStepSize); + CALL(Error); + } + + const fmi3Float64 nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + + if (nextCommunicationPoint > S->stopTime && !isClose(nextCommunicationPoint, S->stopTime)) { + logError(S, "At communication point %.16g a step size of %.16g was requested but stop time is %.16g.", + currentCommunicationPoint, communicationStepSize, S->stopTime); + CALL(Error); + } + + bool nextCommunicationPointReached; + + *eventHandlingNeeded = fmi3False; + *terminateSimulation = fmi3False; + *earlyReturn = fmi3False; + + while (true) { + + const fmi3Float64 nextSolverStepTime = S->time + FIXED_SOLVER_STEP; + + nextCommunicationPointReached = nextSolverStepTime > nextCommunicationPoint && !isClose(nextSolverStepTime, nextCommunicationPoint); + + if (nextCommunicationPointReached || (*eventHandlingNeeded && S->earlyReturnAllowed)) { + break; + } + +#ifdef EVENT_UPDATE + if (*eventHandlingNeeded) { + eventUpdate(S); + *eventHandlingNeeded = fmi3False; + } +#endif + + bool stateEvent, timeEvent; + + CALL(doFixedStep(S, &stateEvent, &timeEvent)); + +#ifdef EVENT_UPDATE + if (stateEvent || timeEvent) { + + if (S->eventModeUsed) { + *eventHandlingNeeded = fmi3True; + } else { + CALL(eventUpdate(S)); +#ifdef HAS_EVENT_INDICATORS + CALL(getEventIndicators(S, S->prez, S->nz)); +#endif + } + + if (S->earlyReturnAllowed) { + break; + } + } +#endif + + if (S->terminateSimulation) { + break; + } + } + + *terminateSimulation = S->terminateSimulation; + *earlyReturn = S->earlyReturnAllowed && !nextCommunicationPointReached; + *lastSuccessfulTime = S->time; + + if (nextCommunicationPointReached) { + S->nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + } else { + S->nextCommunicationPoint = S->time; + } + + END_FUNCTION(); +} + +fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime) { + + BEGIN_FUNCTION(ActivateModelPartition); + + CALL(activateModelPartition(S, (ValueReference)clockReference, activationTime)); + + END_FUNCTION(); +} diff --git a/testsuite/resources/Feedthrough3/sources/model.c b/testsuite/resources/Feedthrough3/sources/model.c new file mode 100644 index 000000000..99dec117f --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/model.c @@ -0,0 +1,696 @@ +#include "config.h" +#include "model.h" +#include // for free() +#include // for strcmp() + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#define STRING_START "Set me!" +#define BINARY_START "foo" + +void setStartValues(ModelInstance *comp) { + + M(Float32_continuous_input) = 0.0f; + M(Float32_continuous_output) = 0.0f; + M(Float32_discrete_input) = 0.0f; + M(Float32_discrete_output) = 0.0f; + + M(Float64_fixed_parameter) = 0.0; + M(Float64_tunable_parameter) = 0.0; + M(Float64_continuous_input) = 0.0; + M(Float64_continuous_output) = 0.0; + M(Float64_discrete_input) = 0.0; + M(Float64_discrete_output) = 0.0; + + M(Int8_input) = 0; + M(Int8_output) = 0; + + M(UInt8_input) = 0; + M(UInt8_output) = 0; + + M(Int16_input) = 0; + M(Int16_output) = 0; + + M(UInt16_input) = 0; + M(UInt16_output) = 0; + + M(Int32_input) = 0; + M(Int32_output) = 0; + + M(UInt32_input) = 0; + M(UInt32_output) = 0; + + M(Int64_input) = 0; + M(Int64_output) = 0; + + M(UInt64_input) = 0; + M(UInt64_output) = 0; + + M(Boolean_input) = false; + M(Boolean_output) = false; + + strncpy(M(String_parameter), STRING_START, STRING_MAX_LEN); + + M(Binary_input_size) = strlen(BINARY_START); + strncpy(M(Binary_input), BINARY_START, BINARY_MAX_LEN); + M(Binary_output_size) = strlen(BINARY_START); + strncpy(M(Binary_output), BINARY_START, BINARY_MAX_LEN); + + M(Enumeration_input) = Option1; + M(Enumeration_output) = Option1; +} + +Status calculateValues(ModelInstance *comp) { + + M(Float32_continuous_output) = M(Float32_continuous_input); + M(Float32_discrete_output) = M(Float32_discrete_input) ; + + M(Float64_continuous_output) = M(Float64_continuous_input); + M(Float64_discrete_output) = M(Float64_discrete_input); + + M(Int8_output) = M(Int8_input); + + M(UInt8_output) = M(UInt8_input); + + M(Int16_output) = M(Int16_input); + + M(UInt16_output) = M(UInt16_input); + + M(Int32_output) = M(Int32_input); + + M(UInt32_output) = M(UInt32_input); + + M(Int64_output) = M(Int64_input); + + M(UInt64_output) = M(UInt64_input); + + M(Boolean_output) = M(Boolean_input); + + M(Binary_output_size) = M(Binary_input_size); + memcpy(M(Binary_output), M(Binary_input), M(Binary_input_size)); + + M(Enumeration_output) = M(Enumeration_input); + + return OK; +} + +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Float32_continuous_input: + values[(*index)++] = M(Float32_continuous_input); + break; + case vr_Float32_continuous_output: + values[(*index)++] = M(Float32_continuous_output); + break; + case vr_Float32_discrete_input: + values[(*index)++] = M(Float32_discrete_input); + break; + case vr_Float32_discrete_output: + values[(*index)++] = M(Float32_discrete_output); + break; + default: + logError(comp, "Get Float32 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getFloat64(ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_time: + values[(*index)++] = comp->time; + break; + case vr_Float64_fixed_parameter: + values[(*index)++] = M(Float64_fixed_parameter); + break; + case vr_Float64_tunable_parameter: + values[(*index)++] = M(Float64_tunable_parameter); + break; + case vr_Float64_continuous_input: + values[(*index)++] = M(Float64_continuous_input); + break; + case vr_Float64_continuous_output: + values[(*index)++] = M(Float64_continuous_output); + break; + case vr_Float64_discrete_input: + values[(*index)++] = M(Float64_discrete_input); + break; + case vr_Float64_discrete_output: + values[(*index)++] = M(Float64_discrete_output); + break; + default: + logError(comp, "Get Float64 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int8_input: + values[(*index)++] = M(Int8_input); + break; + case vr_Int8_output: + values[(*index)++] = M(Int8_output); + break; + default: + logError(comp, "Get Int8 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt8_input: + values[(*index)++] = M(UInt8_input); + break; + case vr_UInt8_output: + values[(*index)++] = M(UInt8_output); + break; + default: + logError(comp, "Get UInt8 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int16_input: + values[(*index)++] = M(Int16_input); + break; + case vr_Int16_output: + values[(*index)++] = M(Int16_output); + break; + default: + logError(comp, "Get Int16 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt16_input: + values[(*index)++] = M(UInt16_input); + break; + case vr_UInt16_output: + values[(*index)++] = M(UInt16_output); + break; + default: + logError(comp, "Get UInt16 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int32_input: + values[(*index)++] = M(Int32_input); + break; + case vr_Int32_output: + values[(*index)++] = M(Int32_output); + break; +#if FMI_VERSION == 1 || FMI_VERSION == 2 + case vr_Enumeration_input: + values[(*index)++] = M(Enumeration_input); + break; + case vr_Enumeration_output: + values[(*index)++] = M(Enumeration_output); + break; +#endif + default: + logError(comp, "Get Int32 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt32_input: + values[(*index)++] = M(UInt32_input); + break; + case vr_UInt32_output: + values[(*index)++] = M(UInt32_output); + break; + default: + logError(comp, "Get UInt32 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int64_input: + values[(*index)++] = M(Int64_input); + break; + case vr_Int64_output: + values[(*index)++] = M(Int64_output); + break; +#if FMI_VERSION == 3 + case vr_Enumeration_input: + values[(*index)++] = M(Enumeration_input); + break; + case vr_Enumeration_output: + values[(*index)++] = M(Enumeration_output); + break; +#endif + default: + logError(comp, "Get Int64 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt64_input: + values[(*index)++] = M(UInt64_input); + break; + case vr_UInt64_output: + values[(*index)++] = M(UInt64_output); + break; + default: + logError(comp, "Get UInt64 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Boolean_input: + values[(*index)++] = M(Boolean_input); + break; + case vr_Boolean_output: + values[(*index)++] = M(Boolean_output); + break; + default: + logError(comp, "Get Boolean is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Binary_input: + values[*index] = M(Binary_input); + sizes[(*index)++] = M(Binary_input_size); + break; + case vr_Binary_output: + values[*index] = M(Binary_output); + sizes[(*index)++] = M(Binary_output_size); + break; + default: + logError(comp, "Get Binary is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_String_parameter: + values[(*index)++] = M(String_parameter); + break; + default: + logError(comp, "Get String is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Float32_continuous_input: + M(Float32_continuous_input) = values[(*index)++]; + break; + case vr_Float32_discrete_input: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != EventMode) { + logError(comp, "Variable Float32_discrete_input can only be set in after instantiation, in Initialization Mode, and in Event Mode."); + return Error; + } +#endif + M(Float32_discrete_input) = values[(*index)++]; + break; + default: + logError(comp, "Set Float32 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + + case vr_Float64_fixed_parameter: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode) { + logError(comp, "Variable Float64_fixed_parameter can only be set after instantiation or in initialization mode."); + return Error; + } +#endif + M(Float64_fixed_parameter) = values[(*index)++]; + break; + + case vr_Float64_tunable_parameter: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != EventMode) { + logError(comp, "Variable Float64_tunable_parameter can only be set after instantiation, in initialization mode or event mode."); + return Error; + } +#endif + M(Float64_tunable_parameter) = values[(*index)++]; + break; + + case vr_Float64_continuous_input: + M(Float64_continuous_input) = values[(*index)++]; + break; + + case vr_Float64_discrete_input: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode && + comp->state != EventMode) { + logError(comp, "Variable Float64_discrete_input can only be set after instantiation, in initialization mode or event mode."); + return Error; + } +#endif + M(Float64_discrete_input) = values[(*index)++]; + break; + + default: + logError(comp, "Set Float64 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int8_input: + M(Int8_input) = values[(*index)++]; + break; + default: + logError(comp, "Set Int8 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt8_input: + M(UInt8_input) = values[(*index)++]; + break; + default: + logError(comp, "Set UInt8 is not allowed for value reference %u.", vr); + return Error; + } + + return OK; +} + +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int16_input: + M(Int16_input) = values[(*index)++]; + break; + default: + logError(comp, "Set Int16 is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt16_input: + M(UInt16_input) = values[(*index)++]; + break; + default: + logError(comp, "Set UInt16 is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int32_input: + M(Int32_input) = values[(*index)++]; + break; +#if FMI_VERSION == 1 || FMI_VERSION == 2 + case vr_Enumeration_input: + if (values[*index] != Option1 && values[*index] != Option2) { + logError(comp, "%d is not a legal value for Enumeration_input.", values[*index]); + return Error; + } + M(Enumeration_input) = values[(*index)++]; + break; +#endif + default: + logError(comp, "Set Int32 is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt32_input: + M(UInt32_input) = values[(*index)++]; + break; + default: + logError(comp, "Set UInt32 is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Int64_input: + M(Int64_input) = values[(*index)++]; + break; +#if FMI_VERSION == 3 + case vr_Enumeration_input: + if (values[*index] != Option1 && values[*index] != Option2) { + logError(comp, "%llu is not a legal value for Enumeration_input.", values[*index]); + return Error; + } + M(Enumeration_input) = values[(*index)++]; + break; +#endif + default: + logError(comp, "Set Int64 is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_UInt64_input: + M(UInt64_input) = values[(*index)++]; + break; + default: + logError(comp, "Set UInt64 is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Boolean_input: + M(Boolean_input) = values[(*index)++]; + break; + case vr_Boolean_output: + M(Boolean_output) = values[(*index)++]; + break; + default: + logError(comp, "Set Boolean is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_String_parameter: + if (strlen(values[*index]) >= STRING_MAX_LEN) { + logError(comp, "Max. string length is %d bytes.", STRING_MAX_LEN); + return Error; + } + strcpy(M(String_parameter), values[(*index)++]); + break; + default: + logError(comp, "Set String is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char* const values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_Binary_input: + if (size[*index] > BINARY_MAX_LEN) { + logError(comp, "Max. binary size is %d bytes.", BINARY_MAX_LEN); + return Error; + } + M(Binary_input_size) = size[*index]; + memcpy((void *)M(Binary_input), values[(*index)++], M(Binary_input_size)); + break; + default: + logError(comp, "Set Binary is not allowed for value reference %u.", vr); + return Error; + } + + comp->isDirtyValues = true; + + return OK; +} + +Status eventUpdate(ModelInstance *comp) { + comp->valuesOfContinuousStatesChanged = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->terminateSimulation = false; + comp->nextEventTimeDefined = false; + return OK; +} diff --git a/testsuite/resources/Feedthrough3/sources/model.h b/testsuite/resources/Feedthrough3/sources/model.h new file mode 100644 index 000000000..8dabb0cad --- /dev/null +++ b/testsuite/resources/Feedthrough3/sources/model.h @@ -0,0 +1,250 @@ +#pragma once + +#if FMI_VERSION != 1 && FMI_VERSION != 2 && FMI_VERSION != 3 +#error FMI_VERSION must be one of 1, 2 or 3 +#endif + +#define UNUSED(x) (void)(x) + +#include // for size_t +#include // for bool +#include + +#include "config.h" + +#if FMI_VERSION == 1 + +#define not_modelError (Instantiated| Initialized | Terminated) + +typedef enum { + Instantiated = 1<<0, + Initialized = 1<<1, + Terminated = 1<<2, + modelError = 1<<3 +} ModelState; + +#elif FMI_VERSION == 2 + +typedef enum { + StartAndEnd = 1<<0, + Instantiated = 1<<1, + InitializationMode = 1<<2, + + // ME states + EventMode = 1<<3, + ContinuousTimeMode = 1<<4, + + // CS states + StepComplete = 1<<5, + StepInProgress = 1<<6, + StepFailed = 1<<7, + StepCanceled = 1<<8, + + Terminated = 1<<9, +} ModelState; + +#else + +typedef enum { + StartAndEnd = 1 << 0, + ConfigurationMode = 1 << 1, + Instantiated = 1 << 2, + InitializationMode = 1 << 3, + EventMode = 1 << 4, + ContinuousTimeMode = 1 << 5, + StepMode = 1 << 6, + ClockActivationMode = 1 << 7, + StepDiscarded = 1 << 8, + ReconfigurationMode = 1 << 9, + IntermediateUpdateMode = 1 << 10, + Terminated = 1 << 11, +} ModelState; + +#endif + +typedef enum { + ModelExchange, + CoSimulation, + ScheduledExecution, +} InterfaceType; + +typedef enum { + OK, + Warning, + Discard, + Error, + Fatal, + Pending +} Status; + +#if FMI_VERSION < 3 +typedef void (*loggerType) (void *componentEnvironment, const char *instanceName, int status, const char *category, const char *message, ...); +#else +typedef void (*loggerType) (void *componentEnvironment, int status, const char *category, const char *message); +#endif + +typedef void (*lockPreemptionType) (void); +typedef void (*unlockPreemptionType) (void); + + +typedef void (*intermediateUpdateType) (void *instanceEnvironment, + double intermediateUpdateTime, + bool intermediateVariableSetRequested, + bool intermediateVariableGetAllowed, + bool intermediateStepFinished, + bool canReturnEarly, + bool *earlyReturnRequested, + double *earlyReturnTime); + +typedef void(*clockUpdateType) (void *instanceEnvironment); + +typedef struct { + + double startTime; + double stopTime; + double time; + const char *instanceName; + InterfaceType type; + const char *resourceLocation; + + Status status; + + // callback functions + loggerType logger; + intermediateUpdateType intermediateUpdate; + clockUpdateType clockUpdate; + + lockPreemptionType lockPreemption; + unlockPreemptionType unlockPreemption; + + bool logEvents; + bool logErrors; + + void *componentEnvironment; + ModelState state; + + // event info + bool newDiscreteStatesNeeded; + bool terminateSimulation; + bool nominalsOfContinuousStatesChanged; + bool valuesOfContinuousStatesChanged; + bool nextEventTimeDefined; + double nextEventTime; + bool clocksTicked; + + bool isDirtyValues; + + ModelData modelData; + + // internal solver steps + uint64_t nSteps; + + // Co-Simulation + bool earlyReturnAllowed; + bool eventModeUsed; + double nextCommunicationPoint; + + // solver + size_t nz; + double* z; + double* prez; + + size_t nx; + double* x; + double* dx; + +} ModelInstance; + +ModelInstance *createModelInstance( + loggerType logger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType); + +void freeModelInstance(ModelInstance *comp); + +Status configurate(ModelInstance* comp); + +Status reset(ModelInstance* comp); + +void setStartValues(ModelInstance* comp); + +Status calculateValues(ModelInstance *comp); + +Status getFloat32 (ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t *index); +Status getFloat64 (ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t *index); +Status getInt8 (ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index); +Status getUInt8 (ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index); +Status getInt16 (ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index); +Status getUInt16 (ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index); +Status getInt32 (ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index); +Status getUInt32 (ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index); +Status getInt64 (ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index); +Status getUInt64 (ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index); +Status getBoolean (ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index); +Status getString (ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index); +Status getBinary (ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index); + +Status setFloat32 (ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t *index); +Status setFloat64 (ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t *index); +Status setInt8 (ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t *index); +Status setUInt8 (ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t *index); +Status setInt16 (ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t *index); +Status setUInt16 (ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t *index); +Status setInt32 (ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t *index); +Status setUInt32 (ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t *index); +Status setInt64 (ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t *index); +Status setUInt64 (ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t *index); +Status setBoolean (ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t *index); +Status setString (ModelInstance* comp, ValueReference vr, const char* const values[], size_t nValues, size_t *index); +Status setBinary (ModelInstance* comp, ValueReference vr, const size_t sizes[], const char* const values[], size_t nValues, size_t *index); + +Status activateClock(ModelInstance* comp, ValueReference vr); +Status getClock(ModelInstance* comp, ValueReference vr, bool* value); +Status setClock(ModelInstance* comp, ValueReference vr, const bool* value); + +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier); + +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime); + +size_t getNumberOfEventIndicators(ModelInstance* comp); +size_t getNumberOfContinuousStates(ModelInstance* comp); +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx); +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx); +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx); +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value); +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative); +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz); +Status eventUpdate(ModelInstance *comp); + +bool isClose(double a, double b); +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected); +bool invalidState(ModelInstance *comp, const char *f, int statesExpected); +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p); +void logError(ModelInstance *comp, const char *message, ...); +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]); +void logEvent(ModelInstance *comp, const char *message, ...); +void logError(ModelInstance *comp, const char *message, ...); + +Status getFMUState(ModelInstance* comp, void** FMUState); +Status setFMUState(ModelInstance* comp, void* FMUState); + +// shorthand to access the variables +#define M(v) (comp->modelData.v) + +// "stringification" macros +#define xstr(s) str(s) +#define str(s) #s + +// assert size of nValues for scalar variables +#define ASSERT_NVALUES(N) do { \ + const size_t expected_nValues = *index + (N); \ + if (expected_nValues > nValues) { \ + logError(comp, "Expected nValues >= %zu but was %zu.", expected_nValues, nValues); \ + return Error; \ + } \ +} while (0) diff --git a/testsuite/resources/Makefile b/testsuite/resources/Makefile index 2caeb1650..af76ad744 100644 --- a/testsuite/resources/Makefile +++ b/testsuite/resources/Makefile @@ -19,6 +19,7 @@ equationPair.equation1 \ equationPair.equation2 \ EventTest \ Feedthrough \ +Feedthrough3 \ fmi_attributes_19 \ fmidertest \ HelloWorld \ From c72b2157b5505a2a1d7b23618f85bc34261ea128 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 19 Dec 2024 14:46:19 +0100 Subject: [PATCH 12/32] add reference-fmus/3.0/Dahlquist.lua --- testsuite/reference-fmus/3.0/Dahlquist.lua | 38 + testsuite/reference-fmus/3.0/Makefile | 1 + .../binaries/aarch64-darwin/Dahlquist.dylib | Bin 0 -> 89488 bytes .../binaries/aarch64-linux/Dahlquist.so | Bin 0 -> 75792 bytes .../binaries/x86-windows/Dahlquist.dll | Bin 0 -> 134144 bytes .../binaries/x86_64-darwin/Dahlquist.dylib | Bin 0 -> 88784 bytes .../binaries/x86_64-linux/Dahlquist.so | Bin 0 -> 67040 bytes .../binaries/x86_64-windows/Dahlquist.dll | Bin 0 -> 165888 bytes .../Dahlquist3/documentation/index.html | 115 ++ .../Dahlquist3/documentation/result.svg | 1 + .../resources/Dahlquist3/modelDescription.xml | 44 + .../Dahlquist3/sources/buildDescription.xml | 13 + .../resources/Dahlquist3/sources/config.h | 30 + .../Dahlquist3/sources/cosimulation.c | 691 ++++++++ .../Dahlquist3/sources/cosimulation.h | 5 + .../Dahlquist3/sources/fmi3Functions.c | 1446 +++++++++++++++++ .../resources/Dahlquist3/sources/model.c | 87 + .../resources/Dahlquist3/sources/model.h | 250 +++ testsuite/resources/Makefile | 1 + 19 files changed, 2722 insertions(+) create mode 100644 testsuite/reference-fmus/3.0/Dahlquist.lua create mode 100644 testsuite/resources/Dahlquist3/binaries/aarch64-darwin/Dahlquist.dylib create mode 100644 testsuite/resources/Dahlquist3/binaries/aarch64-linux/Dahlquist.so create mode 100644 testsuite/resources/Dahlquist3/binaries/x86-windows/Dahlquist.dll create mode 100644 testsuite/resources/Dahlquist3/binaries/x86_64-darwin/Dahlquist.dylib create mode 100644 testsuite/resources/Dahlquist3/binaries/x86_64-linux/Dahlquist.so create mode 100644 testsuite/resources/Dahlquist3/binaries/x86_64-windows/Dahlquist.dll create mode 100644 testsuite/resources/Dahlquist3/documentation/index.html create mode 100644 testsuite/resources/Dahlquist3/documentation/result.svg create mode 100644 testsuite/resources/Dahlquist3/modelDescription.xml create mode 100644 testsuite/resources/Dahlquist3/sources/buildDescription.xml create mode 100644 testsuite/resources/Dahlquist3/sources/config.h create mode 100644 testsuite/resources/Dahlquist3/sources/cosimulation.c create mode 100644 testsuite/resources/Dahlquist3/sources/cosimulation.h create mode 100644 testsuite/resources/Dahlquist3/sources/fmi3Functions.c create mode 100644 testsuite/resources/Dahlquist3/sources/model.c create mode 100644 testsuite/resources/Dahlquist3/sources/model.h diff --git a/testsuite/reference-fmus/3.0/Dahlquist.lua b/testsuite/reference-fmus/3.0/Dahlquist.lua new file mode 100644 index 000000000..3e2dba94d --- /dev/null +++ b/testsuite/reference-fmus/3.0/Dahlquist.lua @@ -0,0 +1,38 @@ +-- status: correct +-- teardown_command: rm -rf Dahlquist3-lua/ +-- linux: yes +-- ucrt64: yes +-- win: yes +-- mac: yes +-- asan: yes + +oms_setCommandLineOption("--suppressPath=true") +oms_setTempDirectory("./Dahlquist3-lua/") +oms_setWorkingDirectory("./Dahlquist3-lua/") + +oms_newModel("model") +oms_addSystem("model.root", oms_system_wc) + +oms_addSubModel("model.root.Dahlquist", "../../../resources/Dahlquist3.fmu") + +oms_setResultFile("model", "Dahlquist-cs.mat") +oms_setStopTime("model", 10.0) +oms_setTolerance("model.root", 1e-5) + +oms_instantiate("model") +oms_initialize("model") +oms_simulate("model") +oms_terminate("model") +oms_delete("model") + +if 1 == oms_compareSimulationResults("../../../references/Dahlquist-cs.mat", "Dahlquist-cs.mat", "model.root.Dahlquist.x", 1e-4, 1e-4) then + print("signal x is equal") +else + print("signal x is not equal") +end + +-- Result: +-- Loading FMI version 3... +-- info: Result file: Dahlquist-cs.mat (bufferSize=1) +-- signal x is equal +-- endResult diff --git a/testsuite/reference-fmus/3.0/Makefile b/testsuite/reference-fmus/3.0/Makefile index fe3755470..b1bea8d6b 100644 --- a/testsuite/reference-fmus/3.0/Makefile +++ b/testsuite/reference-fmus/3.0/Makefile @@ -5,6 +5,7 @@ BouncingBall.lua \ VanDerPol.lua \ Stair.lua \ Feedthrough.lua \ +Dahlquist.lua \ # Run make failingtest FAILINGTESTFILES = \ diff --git a/testsuite/resources/Dahlquist3/binaries/aarch64-darwin/Dahlquist.dylib b/testsuite/resources/Dahlquist3/binaries/aarch64-darwin/Dahlquist.dylib new file mode 100644 index 0000000000000000000000000000000000000000..6cbfd408bc01e6cacfe3df1f35ac69b7b8f5f2f1 GIT binary patch literal 89488 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

0*q;tBsJOGE}0eb+C(s>|u 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 literal 0 HcmV?d00001 diff --git a/testsuite/resources/Dahlquist3/binaries/x86-windows/Dahlquist.dll b/testsuite/resources/Dahlquist3/binaries/x86-windows/Dahlquist.dll new file mode 100644 index 0000000000000000000000000000000000000000..eb11e3d25e71402f1084d34705f50b859ac776d1 GIT binary patch literal 134144 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

%^TilW=S|jNkT1kX_Gp~jpZ&_*@|l76 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

|IC4ZynKW!tn4TqJokI9$j93F_LUW-qu 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 OdPZe~ZvhQYl>Y}8_Wn%( literal 0 HcmV?d00001 diff --git a/testsuite/resources/Dahlquist3/binaries/x86_64-linux/Dahlquist.so b/testsuite/resources/Dahlquist3/binaries/x86_64-linux/Dahlquist.so new file mode 100644 index 0000000000000000000000000000000000000000..1ad73b0edce298de195f9eec19bb93df3f6e3304 GIT binary patch literal 67040 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 mMJ%zk`=jc#AW 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 AZ2$lO literal 0 HcmV?d00001 diff --git a/testsuite/resources/Dahlquist3/documentation/index.html b/testsuite/resources/Dahlquist3/documentation/index.html new file mode 100644 index 000000000..fc82fa0e7 --- /dev/null +++ b/testsuite/resources/Dahlquist3/documentation/index.html @@ -0,0 +1,115 @@ + + + Dahlquist + + + +

+ +

Dahlquist

+ +

The model implements the Dahlquist test equation.

+ +
der(x) = -k * x
+
+ +

with the analytical solution

+ +
x(t) = exp(-k * t)
+
+ + +

with the variables

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableStartUnitCausalityVariabilityDescription
timeindependentcontinuousSimulation time
x1outputcontinuousthe only state
der(x)localcontinuous
k1parameterfixed
+ +

The plot shows the trajectories of the output variables computed with fmusim.

+ + 
fmusim --interface-type me --solver cvode --output-interval 0.2 --output-file Dahlquist_out.csv Dahlquist.fmu
+ +

plot

+ +
+ + \ No newline at end of file diff --git a/testsuite/resources/Dahlquist3/documentation/result.svg b/testsuite/resources/Dahlquist3/documentation/result.svg new file mode 100644 index 000000000..764134140 --- /dev/null +++ b/testsuite/resources/Dahlquist3/documentation/result.svg @@ -0,0 +1 @@ +024681000.20.40.60.81time [s]x \ No newline at end of file diff --git a/testsuite/resources/Dahlquist3/modelDescription.xml b/testsuite/resources/Dahlquist3/modelDescription.xml new file mode 100644 index 000000000..62809577c --- /dev/null +++ b/testsuite/resources/Dahlquist3/modelDescription.xml @@ -0,0 +1,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testsuite/resources/Dahlquist3/sources/buildDescription.xml b/testsuite/resources/Dahlquist3/sources/buildDescription.xml new file mode 100644 index 000000000..c8c6217b1 --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/buildDescription.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/testsuite/resources/Dahlquist3/sources/config.h b/testsuite/resources/Dahlquist3/sources/config.h new file mode 100644 index 000000000..decc9c945 --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/config.h @@ -0,0 +1,30 @@ +#ifndef config_h +#define config_h + +// define class name and unique id +#define MODEL_IDENTIFIER Dahlquist +#define INSTANTIATION_TOKEN "{221063D2-EF4A-45FE-B954-B5BFEEA9A59B}" + +#define CO_SIMULATION +#define MODEL_EXCHANGE + +#define HAS_CONTINUOUS_STATES + +#define SET_FLOAT64 + +#define FIXED_SOLVER_STEP 0.1 +#define DEFAULT_STOP_TIME 10 + +typedef enum { + vr_time, vr_x, vr_der_x, vr_k +} ValueReference; + +typedef struct { + + double x; + double der_x; + double k; + +} ModelData; + +#endif /* config_h */ diff --git a/testsuite/resources/Dahlquist3/sources/cosimulation.c b/testsuite/resources/Dahlquist3/sources/cosimulation.c new file mode 100644 index 000000000..782edf1b2 --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/cosimulation.c @@ -0,0 +1,691 @@ +#include // for calloc(), free() +#include // for DBL_EPSILON +#include +#include +#include +#include "config.h" +#include "cosimulation.h" + +#if FMI_VERSION == 3 +#include "fmi3Functions.h" +#endif + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#ifdef CALL +#undef CALL +#endif + +#define CALL(f) do { const Status status = f; if (status != OK) return status; } while (false) + + +ModelInstance *createModelInstance( + loggerType cbLogger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType) { + + ModelInstance *comp = NULL; + + if (!instanceName || strlen(instanceName) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, "?", Error, "error", "Missing instance name."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instance name."); +#endif + } + return NULL; + } + + if (!instantiationToken || strlen(instantiationToken) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Missing GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instantiationToken."); +#endif + } + return NULL; + } + + if (strcmp(instantiationToken, INSTANTIATION_TOKEN)) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Wrong GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Wrong instantiationToken."); +#endif + } + return NULL; + } + + comp = (ModelInstance *)calloc(1, sizeof(ModelInstance)); + + if (comp) { + comp->componentEnvironment = componentEnvironment; + comp->logger = cbLogger; + comp->intermediateUpdate = intermediateUpdate; + comp->lockPreemption = NULL; + comp->unlockPreemption = NULL; + comp->instanceName = strdup(instanceName); + comp->resourceLocation = resourceLocation ? strdup(resourceLocation) : NULL; + comp->status = OK; + comp->logEvents = loggingOn; + comp->logErrors = true; // always log errors + comp->nSteps = 0; + comp->earlyReturnAllowed = false; + comp->eventModeUsed = false; + } + + if (!comp || !comp->instanceName) { + logError(comp, "Out of memory."); + return NULL; + } + + comp->time = 0.0; // overwrite in fmi*SetupExperiment, fmi*SetTime + comp->type = interfaceType; + + comp->state = Instantiated; + + comp->newDiscreteStatesNeeded = false; + comp->terminateSimulation = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->valuesOfContinuousStatesChanged = false; + comp->nextEventTimeDefined = false; + comp->nextEventTime = 0; + + setStartValues(comp); + + comp->isDirtyValues = true; + + return comp; +} + +void freeModelInstance(ModelInstance *comp) { + + if (!comp) return; + + if (comp->instanceName) free((void*)comp->instanceName); + + if (comp->resourceLocation) free((void*)comp->resourceLocation); + + if (comp->prez) free(comp->prez); + + if (comp->z) free(comp->z); + + if (comp->x) free(comp->x); + + if (comp->dx) free(comp->dx); + + free(comp); +} + +static Status s_reallocate(ModelInstance* comp, void** memory, size_t size) { + + if (size == 0) { + if (*memory) { + free(*memory); + } + *memory = NULL; + return OK; + } + + void* temp = realloc(*memory, size); + + if (!temp) { + logError(comp, "Failed to allocate memory."); + return Error; + } + + *memory = temp; + + return OK; +} + +Status configurate(ModelInstance* comp) { + + (void)comp; + +#ifdef HAS_EVENT_INDICATORS + comp->nz = getNumberOfEventIndicators(comp); + + if (comp->nz > 0) { + CALL(s_reallocate(comp, (void**)&comp->prez, comp->nz * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->z, comp->nz * sizeof(double))); + } + + CALL(getEventIndicators(comp, comp->prez, comp->nz)); +#endif + +#ifdef HAS_CONTINUOUS_STATES + comp->nx = getNumberOfContinuousStates(comp); + + if (comp->nx > 0) { + CALL(s_reallocate(comp, (void**)&comp->x, comp->nx * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->dx, comp->nx * sizeof(double))); + } +#endif + + return OK; +} + +Status reset(ModelInstance* comp) { + + comp->state = Instantiated; + comp->startTime = 0.0; + comp->time = 0.0; + comp->nSteps = 0; + comp->status = OK; + setStartValues(comp); + comp->isDirtyValues = true; + + return OK; +} + +#define EPSILON (1.0e-5) + +static double fmiAbs(double v) { + return v >= 0 ? v : -v; +} + +static double fmiMax(double a, double b) { + return (a < b) ? b : a; +} + +bool isClose(double a, double b) { + + if (fmiAbs(a - b) <= EPSILON) { + return true; + } + + return fmiAbs(a - b) <= EPSILON * fmiMax(fmiAbs(a), fmiAbs(b)); +} + +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected) { + + if (actual != expected) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = %d. Expected %d.", f, arg, actual, expected); + return true; + } + + return false; +} + +bool invalidState(ModelInstance *comp, const char *f, int statesExpected) { + + UNUSED(f); + UNUSED(statesExpected); + + if (!comp) { + return true; + } + + // TODO: add missing states and check state + return false; + +// if (!(comp->state & statesExpected)) { +// comp->state = modelError; +// logError(comp, "%s: Illegal call sequence.", f); +// return true; +// } +// +// return false; +} + +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p) { + + if (!p) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = NULL.", f, arg); + return true; + } + + return false; +} + +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]) { + + if (nCategories > 0) { + + if (categories == NULL) { + logError(comp, "Argument categories must not be NULL."); + return Error; + } + + for (size_t i = 0; i < nCategories; i++) { + + if (categories[i] == NULL) { + logError(comp, "Argument categories[%zu] must not be NULL.", i); + return Error; + } else if (strcmp(categories[i], "logEvents") == 0) { + comp->logEvents = loggingOn; + } else if (strcmp(categories[i], "logStatusError") == 0) { + comp->logErrors = loggingOn; + } else { + logError(comp, "Log categories[%zu] must be one of \"logEvents\" or \"logStatusError\" but was \"%s\".", i, categories[i]); + return Error; + } + } + + } else { + + comp->logEvents = loggingOn; + comp->logErrors = loggingOn; + + } + + return OK; +} + +static void logMessage(ModelInstance *comp, int status, const char *category, const char *message, va_list args) { + + if (!comp->logger) { + return; + } + + va_list args1; + int len = 0; + char *buf = ""; + + va_copy(args1, args); + len = vsnprintf(buf, len, message, args1); + va_end(args1); + + if (len < 0) { + return; + } + + va_copy(args1, args); + buf = (char *)calloc(len + 1, sizeof(char)); + len = vsnprintf(buf, len + 1, message, args); + va_end(args1); + + if (len >= 0) { + // no need to distinguish between FMI versions since we're not using variadic arguments +#if FMI_VERSION < 3 + comp->logger(comp->componentEnvironment, comp->instanceName, status, category, buf); +#else + comp->logger(comp->componentEnvironment, status, category, buf); +#endif + } + + free(buf); +} + +void logEvent(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logEvents) return; + + va_list args; + va_start(args, message); + logMessage(comp, OK, "logEvents", message, args); + va_end(args); +} + +void logError(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logErrors) return; + + va_list args; + va_start(args, message); + logMessage(comp, Error, "logStatusError", message, args); + va_end(args); +} + +#define GET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Getting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef GET_FLOAT32 +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + GET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef GET_INT8 +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef GET_UINT8 +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef GET_INT16 +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int16"); + +} +#endif + +#ifndef GET_UINT16 +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef GET_INT32 +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef GET_UINT32 +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef GET_INT64 +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef GET_UINT64 +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef GET_BOOLEAN +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef GET_STRING +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("String"); +} +#endif + +#ifndef GET_BINARY +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index) { + UNUSED(sizes); + GET_NOT_ALLOWED("Binary"); +} +#endif + +#define SET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Setting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef SET_FLOAT32 +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef SET_FLOAT64 +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float64"); +} +#endif + +#ifndef SET_INT8 +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef SET_UINT8 +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef SET_INT16 +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int16"); +} +#endif + +#ifndef SET_UINT16 +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef SET_INT32 +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef SET_UINT32 +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef SET_INT64 +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef SET_UINT64 +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef SET_BOOLEAN +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef SET_STRING +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("String"); +} +#endif + +#ifndef SET_BINARY +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char *const values[], size_t nValues, size_t* index) { + UNUSED(size); + SET_NOT_ALLOWED("Binary"); +} +#endif + +#ifndef ACTIVATE_CLOCK +Status activateClock(ModelInstance* comp, ValueReference vr) { + UNUSED(comp); + UNUSED(vr); + return Error; +} +#endif + +#ifndef GET_CLOCK +Status getClock(ModelInstance* comp, ValueReference vr, bool* value) { + UNUSED(comp); + UNUSED(vr); + UNUSED(value); + return Error; +} +#endif + +#ifndef GET_INTERVAL +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier) { + UNUSED(comp); + UNUSED(vr); + UNUSED(interval); + UNUSED(qualifier); + return Error; +} +#endif + +#ifndef ACTIVATE_MODEL_PARTITION +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime) { + UNUSED(comp); + UNUSED(vr); + UNUSED(activationTime); + return Error; +} +#endif + +#ifndef GET_PARTIAL_DERIVATIVE +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + UNUSED(comp); + UNUSED(unknown); + UNUSED(known); + UNUSED(partialDerivative); + logError(comp, "Directional derivatives are not supported."); + return Error; +} +#endif + +Status getFMUState(ModelInstance* comp, void** FMUState) { + + CALL(s_reallocate(comp, FMUState, sizeof(ModelInstance))); + + memcpy(*FMUState, comp, sizeof(ModelInstance)); + + return OK; +} + +Status setFMUState(ModelInstance* comp, void* FMUState) { + + ModelInstance* s = (ModelInstance*)FMUState; + + comp->startTime = s->startTime; + comp->stopTime = s->stopTime; + comp->time = s->time; + // instanceName + // type + // resourceLocation + + comp->status = s->status; + + // logger + // intermediateUpdate + // clockUpdate + + // lockPreemption + // unlockPreemption + + // logEvents + // logErrors + + // componentEnvironment + comp->state = s->state; + + comp->newDiscreteStatesNeeded = s->newDiscreteStatesNeeded; + comp->terminateSimulation = s->terminateSimulation; + comp->nominalsOfContinuousStatesChanged = s->nominalsOfContinuousStatesChanged; + comp->valuesOfContinuousStatesChanged = s->valuesOfContinuousStatesChanged; + comp->nextEventTimeDefined = s->nextEventTimeDefined; + comp->nextEventTime = s->nextEventTime; + comp->clocksTicked = s->clocksTicked; + + comp->isDirtyValues = s->isDirtyValues; + + comp->modelData = s->modelData; + + comp->nSteps = s->nSteps; + + comp->earlyReturnAllowed = s->earlyReturnAllowed; + comp->eventModeUsed = s->eventModeUsed; + comp->nextCommunicationPoint = s->nextCommunicationPoint; + + if (comp->nx > 0) { + memcpy(comp->x, s->x, s->nx * sizeof(double)); + memcpy(comp->dx, s->dx, s->nx * sizeof(double)); + } + + if (comp->nz > 0) { + memcpy(comp->z, s->z, s->nz * sizeof(double)); + } + + comp->nSteps = s->nSteps; + + return OK; +} + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent) { + +#ifdef HAS_CONTINUOUS_STATES + if (comp->nx > 0) { + + CALL(getContinuousStates(comp, comp->x, comp->nx)); + CALL(getDerivatives(comp, comp->dx, comp->nx)); + + // forward Euler step + for (size_t i = 0; i < comp->nx; i++) { + comp->x[i] += FIXED_SOLVER_STEP * comp->dx[i]; + } + + CALL(setContinuousStates(comp, comp->x, comp->nx)); + } +#endif + + comp->nSteps++; + + comp->time = comp->startTime + comp->nSteps * FIXED_SOLVER_STEP; + + // state event + *stateEvent = false; + +#ifdef HAS_EVENT_INDICATORS + if (comp->nz > 0) { + + CALL(getEventIndicators(comp, comp->z, comp->nz)); + + // check for zero-crossings + for (size_t i = 0; i < comp->nz; i++) { + *stateEvent |= + (comp->prez[i] <= 0 && comp->z[i] > 0) || + (comp->prez[i] > 0 && comp->z[i] <= 0); + } + + // remember the current event indicators + double* temp = comp->prez; + comp->prez = comp->z; + comp->z = temp; + } +#endif + + // time event + *timeEvent = comp->nextEventTimeDefined && comp->time >= comp->nextEventTime; + + bool earlyReturnRequested; + double earlyReturnTime; + + // intermediate update + if (comp->intermediateUpdate) { + comp->intermediateUpdate( + comp->componentEnvironment, // instanceEnvironment + comp->time, // intermediateUpdateTime + false, // intermediateVariableSetRequested + true, // intermediateVariableGetAllowed + true, // intermediateStepFinished + false, // canReturnEarly + &earlyReturnRequested, // earlyReturnRequested + &earlyReturnTime); // earlyReturnTime + } + + return OK; +} diff --git a/testsuite/resources/Dahlquist3/sources/cosimulation.h b/testsuite/resources/Dahlquist3/sources/cosimulation.h new file mode 100644 index 000000000..fda1ebf99 --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/cosimulation.h @@ -0,0 +1,5 @@ +#pragma once + +#include "model.h" + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent); diff --git a/testsuite/resources/Dahlquist3/sources/fmi3Functions.c b/testsuite/resources/Dahlquist3/sources/fmi3Functions.c new file mode 100644 index 000000000..b4ad5fbb2 --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/fmi3Functions.c @@ -0,0 +1,1446 @@ +#if FMI_VERSION != 3 +#error FMI_VERSION must be 3 +#endif + +#include +#include +#include +#include +#include + +#include "config.h" +#include "model.h" +#include "cosimulation.h" + +// C-code FMUs have functions names prefixed with MODEL_IDENTIFIER_. +// Define DISABLE_PREFIX to build a binary FMU. +#if !defined(DISABLE_PREFIX) && !defined(FMI3_FUNCTION_PREFIX) +#define pasteA(a,b) a ## b +#define pasteB(a,b) pasteA(a,b) +#define FMI3_FUNCTION_PREFIX pasteB(MODEL_IDENTIFIER, _) +#endif +#include "fmi3Functions.h" + +#define ASSERT_NOT_NULL(p) \ +do { \ + if (!p) { \ + logError(S, "Argument %s must not be NULL.", xstr(p)); \ + S->state = Terminated; \ + return (fmi3Status)Error; \ + } \ +} while (0) + +#define CALL(f) do { \ + const Status s = f; \ + if (s > status) { \ + status = s; \ + } \ + if (status == Discard) { \ + goto TERMINATE; \ + } else if (status == Error) { \ + S->state = Terminated; \ + goto TERMINATE; \ + } else if (status == Fatal) { \ + S->state = StartAndEnd; \ + goto TERMINATE; \ + } \ +} while (false) + +#define GET_VARIABLES(T) \ +BEGIN_FUNCTION(Get ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +if (nValues > 0) ASSERT_NOT_NULL(values); \ +if (S->isDirtyValues) { \ + CALL(calculateValues(S)); \ + S->isDirtyValues = false; \ +} \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(get ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#define SET_VARIABLES(T) \ +BEGIN_FUNCTION(Set ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(set ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (nValueReferences > 0) S->isDirtyValues = true; \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#ifndef max +#define max(a,b) ((a)>(b) ? (a) : (b)) +#endif + +#ifndef DT_EVENT_DETECT +#define DT_EVENT_DETECT 1e-10 +#endif + +// --------------------------------------------------------------------------- +// Function calls allowed state masks for both Model-exchange and Co-simulation +// --------------------------------------------------------------------------- +#define MASK_AnyState (~0) + +/* Inquire version numbers and set debug logging */ +#define MASK_fmi3GetVersion MASK_AnyState +#define MASK_fmi3SetDebugLogging MASK_AnyState + +/* Creation and destruction of FMU instances */ +#define MASK_fmi3InstantiateInstantiateModelExchange MASK_AnyState +#define MASK_fmi3InstantiateCoSimulation MASK_AnyState +#define MASK_fmi3InstantiateScheduledExectuion MASK_AnyState +#define MASK_fmi3FreeInstance MASK_AnyState + +/* Enter and exit initialization mode, terminate and reset */ +#define MASK_fmi3EnterInitializationMode Instantiated +#define MASK_fmi3ExitInitializationMode InitializationMode +#define MASK_fmi3EnterEventMode (ContinuousTimeMode | StepMode) +#define MASK_fmi3Terminate (ContinuousTimeMode | StepMode | StepDiscarded | EventMode | ClockActivationMode | ReconfigurationMode) +#define MASK_fmi3Reset MASK_AnyState + +/* Common Functions */ + +/* Getting and setting variable values */ +#define MASK_fmi3GetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3GetFloat64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetBoolean MASK_fmi3GetFloat32 +#define MASK_fmi3GetString MASK_fmi3GetFloat32 +#define MASK_fmi3GetBinary MASK_fmi3GetFloat32 +#define MASK_fmi3GetClock MASK_AnyState + +#define MASK_fmi3SetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3SetFloat64 MASK_fmi3SetFloat32 +#define MASK_fmi3SetInt8 (Instantiated | ConfigurationMode | ReconfigurationMode | InitializationMode | EventMode | StepMode | ClockActivationMode | Terminated) +#define MASK_fmi3SetUInt8 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetBoolean MASK_fmi3SetInt8 +#define MASK_fmi3SetString MASK_fmi3SetInt8 +#define MASK_fmi3SetBinary MASK_fmi3SetInt8 +#define MASK_fmi3SetClock MASK_AnyState + +/* Getting Variable Dependency Information */ +#define MASK_fmi3GetNumberOfVariableDependencies MASK_AnyState +#define MASK_fmi3GetVariableDependencies MASK_AnyState + +/* Getting and setting the internal FMU state */ +#define MASK_fmi3GetFMUState MASK_AnyState +#define MASK_fmi3SetFMUState MASK_AnyState +#define MASK_fmi3FreeFMUState MASK_AnyState +#define MASK_fmi3SerializedFMUStateSize MASK_AnyState +#define MASK_fmi3SerializeFMUState MASK_AnyState +#define MASK_fmi3DeserializeFMUState MASK_AnyState + +/* Getting partial derivatives */ +#define MASK_fmi3GetDirectionalDerivative (InitializationMode | StepMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetAdjointDerivative MASK_fmi3GetDirectionalDerivative + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define MASK_fmi3EnterConfigurationMode (Instantiated | StepMode | EventMode | ClockActivationMode) +#define MASK_fmi3ExitConfigurationMode (ConfigurationMode | ReconfigurationMode) + +/* Clock related functions */ +// TODO: fix masks +#define MASK_fmi3GetIntervalDecimal MASK_AnyState +#define MASK_fmi3GetIntervalFraction MASK_AnyState +#define MASK_fmi3SetIntervalDecimal MASK_AnyState +#define MASK_fmi3SetIntervalFraction MASK_AnyState +#define MASK_fmi3NewDiscreteStates MASK_AnyState + +/* Functions for Model Exchange */ + +#define MASK_fmi3EnterContinuousTimeMode EventMode +#define MASK_fmi3CompletedIntegratorStep ContinuousTimeMode + +/* Providing independent variables and re-initialization of caching */ +#define MASK_fmi3SetTime (EventMode | ContinuousTimeMode) +#define MASK_fmi3SetContinuousStates ContinuousTimeMode + +/* Evaluation of the model equations */ +#define MASK_fmi3GetContinuousStateDerivatives (InitializationMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetEventIndicators MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetContinuousStates MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetNominalsOfContinuousStates MASK_fmi3GetContinuousStateDerivatives + +#define MASK_fmi3GetNumberOfContinuousStates MASK_AnyState +#define MASK_fmi3GetNumberOfEventIndicators MASK_AnyState + +/* Functions for Co-Simulation */ + +#define MASK_fmi3EnterStepMode (InitializationMode | EventMode) +#define MASK_fmi3SetInputDerivatives (Instantiated | InitializationMode | StepMode) +#define MASK_fmi3GetOutputDerivatives (StepMode | StepDiscarded | Terminated) +#define MASK_fmi3DoStep StepMode +#define MASK_fmi3ActivateModelPartition ClockActivationMode +#define MASK_fmi3DoEarlyReturn IntermediateUpdateMode +#define MASK_fmi3GetDoStepDiscardedStatus StepMode + +// --------------------------------------------------------------------------- +// Private helpers used below to validate function arguments +// --------------------------------------------------------------------------- + +#define NOT_IMPLEMENTED \ +do { \ + ModelInstance *comp = (ModelInstance *)instance; \ + logError(comp, "Function is not implemented."); \ + return fmi3Error; \ +} while (0) + +#define BEGIN_FUNCTION(F) \ +Status status = OK; \ +if (!instance) return fmi3Error; \ +ModelInstance *S = (ModelInstance *)instance; \ +if (!allowedState(S, MASK_fmi3##F, #F)) CALL(Error); + +#define END_FUNCTION() \ +TERMINATE: \ + return (fmi3Status)status; + +static bool allowedState(ModelInstance *instance, int statesExpected, char *name) { + + if (!instance) { + return false; + } + + if (!(instance->state & statesExpected)) { + logError(instance, "fmi3%s: Illegal call sequence.", name); + return false; + } + + return true; +} + +/*************************************************** + Common Functions + ****************************************************/ + +const char* fmi3GetVersion(void) { + return fmi3Version; +} + +fmi3Status fmi3SetDebugLogging(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]) { + + BEGIN_FUNCTION(SetDebugLogging); + + CALL(setDebugLogging(S, loggingOn, nCategories, categories)); + + END_FUNCTION(); +} + +fmi3Instance fmi3InstantiateModelExchange( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage) { + + UNUSED(visible); + +#ifndef MODEL_EXCHANGE + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + + return NULL; +#else + return createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ModelExchange); +#endif +} + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) { + + UNUSED(visible); + UNUSED(requiredIntermediateVariables); + UNUSED(nRequiredIntermediateVariables); + +#ifndef EVENT_UPDATE + if (eventModeUsed) { + if (logMessage) { + logMessage(instanceEnvironment, fmi3Error, "error", "Event Mode is not supported."); + } + return NULL; + } +#endif + + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + (intermediateUpdateType)intermediateUpdate, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + CoSimulation); + + if (instance) { + instance->earlyReturnAllowed = earlyReturnAllowed; + instance->eventModeUsed = eventModeUsed; + instance->state = Instantiated; + } + + return instance; +} + +fmi3Instance fmi3InstantiateScheduledExecution( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption) { + + UNUSED(visible); + +#ifndef SCHEDULED_CO_SIMULATION + + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + UNUSED(clockUpdate); + UNUSED(lockPreemption); + UNUSED(unlockPreemption); + + return NULL; +#else + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ScheduledExecution + ); + + if (instance) { + instance->state = Instantiated; + instance->clockUpdate = clockUpdate; + instance->lockPreemption = lockPreemption; + instance->unlockPreemption = unlockPreemption; + } + + return instance; +#endif +} + +void fmi3FreeInstance(fmi3Instance instance) { + freeModelInstance((ModelInstance*)instance); +} + +fmi3Status fmi3EnterInitializationMode(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime) { + + UNUSED(toleranceDefined); + UNUSED(tolerance); + + BEGIN_FUNCTION(EnterInitializationMode); + + S->startTime = startTime; + S->stopTime = stopTimeDefined ? stopTime : INFINITY; + S->time = startTime; + S->nextCommunicationPoint = startTime; + S->state = InitializationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitInitializationMode); + + // if values were set and no fmi3GetXXX triggered update before, + // ensure calculated values are updated now + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = S->eventModeUsed ? EventMode : StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + + CALL(configurate(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3EnterEventMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterEventMode); + + S->state = EventMode; + + END_FUNCTION(); +} + +fmi3Status fmi3Terminate(fmi3Instance instance) { + + BEGIN_FUNCTION(Terminate); + + S->state = Terminated; + + END_FUNCTION(); +} + +fmi3Status fmi3Reset(fmi3Instance instance) { + + BEGIN_FUNCTION(Reset); + + CALL(reset(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues) { + GET_VARIABLES(Float32); +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) { + GET_VARIABLES(Float64); +} + +fmi3Status fmi3GetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues) { + GET_VARIABLES(Int8); +} + +fmi3Status fmi3GetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues) { + GET_VARIABLES(UInt8); +} + +fmi3Status fmi3GetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues) { + GET_VARIABLES(Int16); +} + +fmi3Status fmi3GetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues) { + GET_VARIABLES(UInt16); +} + +fmi3Status fmi3GetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues) { + GET_VARIABLES(Int32); +} + +fmi3Status fmi3GetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues) { + GET_VARIABLES(UInt32); +} + +fmi3Status fmi3GetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues) { + GET_VARIABLES(Int64); +} + +fmi3Status fmi3GetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues) { + GET_VARIABLES(UInt64); +} + +fmi3Status fmi3GetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues) { + GET_VARIABLES(Boolean); +} + +fmi3Status fmi3GetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues) { + GET_VARIABLES(String); +} + +fmi3Status fmi3GetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(GetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } else { + ASSERT_NOT_NULL(valueReferences); + } + + if (nValues > 0) { + ASSERT_NOT_NULL(values); + } + + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char**)values, nValues, &index)); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]) { + + BEGIN_FUNCTION(GetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getClock(instance, (ValueReference)valueReferences[i], &values[i])); + } + END_FUNCTION(); +} + +fmi3Status fmi3SetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues) { + SET_VARIABLES(Float32); +} + +fmi3Status fmi3SetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues) { + SET_VARIABLES(Float64); +} + +fmi3Status fmi3SetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues) { + SET_VARIABLES(Int8); +} + +fmi3Status fmi3SetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues) { + SET_VARIABLES(UInt8); +} + +fmi3Status fmi3SetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues) { + SET_VARIABLES(Int16); +} + +fmi3Status fmi3SetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues) { + SET_VARIABLES(UInt16); +} + +fmi3Status fmi3SetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues) { + SET_VARIABLES(Int32); +} + +fmi3Status fmi3SetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues) { + SET_VARIABLES(UInt32); +} + +fmi3Status fmi3SetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues) { + SET_VARIABLES(Int64); +} + +fmi3Status fmi3SetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues) { + SET_VARIABLES(UInt64); +} + +fmi3Status fmi3SetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues) { + SET_VARIABLES(Boolean); +} + +fmi3Status fmi3SetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues) { + SET_VARIABLES(String); +} + +fmi3Status fmi3SetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(SetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } + + ASSERT_NOT_NULL(valueReferences); + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(setBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char* const*)values, nValues, &index)); + } + + if (nValueReferences > 0) { + S->isDirtyValues = true; + } + + if (index != nValues) { + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); + } + + END_FUNCTION(); +} + +fmi3Status fmi3SetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]) { + + BEGIN_FUNCTION(SetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + if (values[i]) { + CALL(activateClock(instance, (ValueReference)valueReferences[i])); + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfVariableDependencies(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies) { + UNUSED(valueReference); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetVariableDependencies(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies) { + + UNUSED(dependent); + UNUSED(elementIndicesOfDependent); + UNUSED(independents); + UNUSED(elementIndicesOfIndependents); + UNUSED(dependencyKinds); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(GetFMUState); + + CALL(getFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState FMUState) { + + BEGIN_FUNCTION(SetFMUState); + + if (nullPointer(S, "fmi3SetFMUState", "FMUState", FMUState)) { + return fmi3Error; + } + + CALL(setFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(FreeFMUState); + + free(*FMUState); + + *FMUState = NULL; + + END_FUNCTION(); +} + +fmi3Status fmi3SerializedFMUStateSize(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size) { + + UNUSED(instance); + UNUSED(FMUState); + + BEGIN_FUNCTION(SerializedFMUStateSize); + + *size = sizeof(ModelInstance); + + END_FUNCTION(); +} + +fmi3Status fmi3SerializeFMUState(fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size) { + + BEGIN_FUNCTION(SerializeFMUState); + + if (nullPointer(S, "fmi3SerializeFMUState", "FMUstate", FMUState)) { + return fmi3Error; + } + + if (invalidNumber(S, "fmi3SerializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + memcpy(serializedState, FMUState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3DeserializeFMUState(fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(DeserializeFMUState); + + if (invalidNumber(S, "fmi3DeserializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + if (*FMUState == NULL) { + *FMUState = calloc(1, sizeof(ModelInstance)); + if (*FMUState == NULL) { + printf("Failed to allocate memory for FMUState.\n"); + return fmi3Error; + } + } + + memcpy(*FMUState, serializedState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetDirectionalDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetDirectionalDerivative); + + // TODO: check value references + // TODO: assert nUnknowns == nDeltaOfUnknowns + // TODO: assert nKnowns == nDeltaKnowns + + for (size_t i = 0; i < nUnknowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nKnowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[i], (ValueReference)knowns[j], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetAdjointDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetAdjointDerivative); + + // TODO: check value references + + for (size_t i = 0; i < nKnowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nUnknowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[j], (ValueReference)knowns[i], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3EnterConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterConfigurationMode); + + S->state = (S->state == Instantiated) ? ConfigurationMode : ReconfigurationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitConfigurationMode); + + if (S->state == ConfigurationMode) { + S->state = Instantiated; + } else { + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + } + +#if defined(HAS_CONTINUOUS_STATES) || defined(HAS_EVENT_INDICATORS) + CALL(configurate(S)); +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]) { + + BEGIN_FUNCTION(GetIntervalDecimal); + + // TODO: Check nValueReferences != nValues ? + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getInterval(instance, (ValueReference)valueReferences[i], &intervals[i], (int*)&qualifiers[i])); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 intervalCounters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + UNUSED(qualifiers); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 shiftCounters[], + fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervals); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 intervalCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 shiftCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3EvaluateDiscreteStates(fmi3Instance instance) { + NOT_IMPLEMENTED; +} + +fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime) { + + BEGIN_FUNCTION(NewDiscreteStates); + +#ifdef EVENT_UPDATE + CALL(eventUpdate(S)); +#endif + + // copy internal eventInfo of component to output arguments + if (discreteStatesNeedUpdate) *discreteStatesNeedUpdate = S->newDiscreteStatesNeeded; + if (terminateSimulation) *terminateSimulation = S->terminateSimulation; + if (nominalsOfContinuousStatesChanged) *nominalsOfContinuousStatesChanged = S->nominalsOfContinuousStatesChanged; + if (valuesOfContinuousStatesChanged) *valuesOfContinuousStatesChanged = S->valuesOfContinuousStatesChanged; + if (nextEventTimeDefined) *nextEventTimeDefined = S->nextEventTimeDefined; + if (nextEventTime) *nextEventTime = S->nextEventTime; + + END_FUNCTION(); +} + +/*************************************************** + Functions for Model Exchange + ****************************************************/ + +fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterContinuousTimeMode); + + S->state = ContinuousTimeMode; + + END_FUNCTION(); +} + +fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(CompletedIntegratorStep); + + ASSERT_NOT_NULL(enterEventMode); + ASSERT_NOT_NULL(terminateSimulation); + + *enterEventMode = fmi3False; + *terminateSimulation = fmi3False; + + END_FUNCTION(); +} + +/* Providing independent variables and re-initialization of caching */ +fmi3Status fmi3SetTime(fmi3Instance instance, fmi3Float64 time) { + + BEGIN_FUNCTION(SetTime); + + S->time = time; + + END_FUNCTION(); +} + +fmi3Status fmi3SetContinuousStates(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(SetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3SetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + ASSERT_NOT_NULL(continuousStates); + + CALL(setContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +/* Evaluation of the model equations */ +fmi3Status fmi3GetContinuousStateDerivatives(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStateDerivatives); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStateDerivatives", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStateDerivatives", "derivatives[]", derivatives)) + return fmi3Error; + + CALL(getDerivatives(S, derivatives, nContinuousStates)); +#else + UNUSED(derivatives); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetEventIndicators(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators) { + + BEGIN_FUNCTION(GetEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + if (invalidNumber(S, "fmi3GetEventIndicators", "nEventIndicators", nEventIndicators, getNumberOfEventIndicators(S))) { + return fmi3Error; + } + + CALL(getEventIndicators(S, eventIndicators, nEventIndicators)); +#else + + UNUSED(eventIndicators); + + if (nEventIndicators > 0) { + // TODO: log error + return fmi3Error; + } +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetContinuousStates(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStates", "continuousStates[]", continuousStates)) + return fmi3Error; + + CALL(getContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNominalsOfContinuousStates(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetNominalsOfContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetNominalContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(instance))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetNominalContinuousStates", "nominals[]", nominals)) + return fmi3Error; + + for (size_t i = 0; i < nContinuousStates; i++) { + nominals[i] = 1; + } + + return fmi3OK; +#else + UNUSED(nominals); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfEventIndicators(fmi3Instance instance, + size_t* nEventIndicators) { + + BEGIN_FUNCTION(GetNumberOfEventIndicators); + + ASSERT_NOT_NULL(nEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + *nEventIndicators = getNumberOfEventIndicators(instance); +#else + *nEventIndicators = 0; +#endif + + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfContinuousStates(fmi3Instance instance, + size_t* nContinuousStates) { + + BEGIN_FUNCTION(GetNumberOfContinuousStates); + + ASSERT_NOT_NULL(nContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + *nContinuousStates = getNumberOfContinuousStates(instance); +#else + *nContinuousStates = 0; +#endif + + END_FUNCTION(); +} + +/*************************************************** + Functions for Co-Simulation + ****************************************************/ + +fmi3Status fmi3EnterStepMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterStepMode); + + S->state = StepMode; + + END_FUNCTION(); +} + +fmi3Status fmi3GetOutputDerivatives(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues) { + + UNUSED(nValues); + + BEGIN_FUNCTION(GetOutputDerivatives); + +#ifdef GET_OUTPUT_DERIVATIVE + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getOutputDerivative(S, (ValueReference)valueReferences[i], orders[i], &values[i])); + } +#else + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(orders); + UNUSED(values); + + NOT_IMPLEMENTED; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(DoStep); + + if (!isClose(currentCommunicationPoint, S->nextCommunicationPoint)) { + logError(S, "Expected currentCommunicationPoint = %.16g but was %.16g.", + S->nextCommunicationPoint, currentCommunicationPoint); + CALL(Error); + } + + if (communicationStepSize <= 0) { + logError(S, "Communication step size must be > 0 but was %.16g.", communicationStepSize); + CALL(Error); + } + + const fmi3Float64 nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + + if (nextCommunicationPoint > S->stopTime && !isClose(nextCommunicationPoint, S->stopTime)) { + logError(S, "At communication point %.16g a step size of %.16g was requested but stop time is %.16g.", + currentCommunicationPoint, communicationStepSize, S->stopTime); + CALL(Error); + } + + bool nextCommunicationPointReached; + + *eventHandlingNeeded = fmi3False; + *terminateSimulation = fmi3False; + *earlyReturn = fmi3False; + + while (true) { + + const fmi3Float64 nextSolverStepTime = S->time + FIXED_SOLVER_STEP; + + nextCommunicationPointReached = nextSolverStepTime > nextCommunicationPoint && !isClose(nextSolverStepTime, nextCommunicationPoint); + + if (nextCommunicationPointReached || (*eventHandlingNeeded && S->earlyReturnAllowed)) { + break; + } + +#ifdef EVENT_UPDATE + if (*eventHandlingNeeded) { + eventUpdate(S); + *eventHandlingNeeded = fmi3False; + } +#endif + + bool stateEvent, timeEvent; + + CALL(doFixedStep(S, &stateEvent, &timeEvent)); + +#ifdef EVENT_UPDATE + if (stateEvent || timeEvent) { + + if (S->eventModeUsed) { + *eventHandlingNeeded = fmi3True; + } else { + CALL(eventUpdate(S)); +#ifdef HAS_EVENT_INDICATORS + CALL(getEventIndicators(S, S->prez, S->nz)); +#endif + } + + if (S->earlyReturnAllowed) { + break; + } + } +#endif + + if (S->terminateSimulation) { + break; + } + } + + *terminateSimulation = S->terminateSimulation; + *earlyReturn = S->earlyReturnAllowed && !nextCommunicationPointReached; + *lastSuccessfulTime = S->time; + + if (nextCommunicationPointReached) { + S->nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + } else { + S->nextCommunicationPoint = S->time; + } + + END_FUNCTION(); +} + +fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime) { + + BEGIN_FUNCTION(ActivateModelPartition); + + CALL(activateModelPartition(S, (ValueReference)clockReference, activationTime)); + + END_FUNCTION(); +} diff --git a/testsuite/resources/Dahlquist3/sources/model.c b/testsuite/resources/Dahlquist3/sources/model.c new file mode 100644 index 000000000..b9e6a1a01 --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/model.c @@ -0,0 +1,87 @@ +#include "config.h" +#include "model.h" + + +void setStartValues(ModelInstance *comp) { + M(x) = 1; + M(k) = 1; +} + +Status calculateValues(ModelInstance *comp) { + M(der_x) = -M(k) * M(x); + return OK; +} + +Status getFloat64(ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t* index) { + + calculateValues(comp); + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_time: + values[(*index)++] = comp->time; + return OK; + case vr_x: + values[(*index)++] = M(x); + return OK; + case vr_der_x: + values[(*index)++] = M(der_x); + return OK; + case vr_k: + values[(*index)++] = M(k); + return OK; + default: + logError(comp, "Get Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_x: + M(x) = values[(*index)++]; + return OK; + case vr_k: +#if FMI_VERSION > 1 + if (comp->type == ModelExchange && + comp->state != Instantiated && + comp->state != InitializationMode) { + logError(comp, "Variable k can only be set after instantiation or in initialization mode."); + return Error; + } +#endif + M(k) = values[(*index)++]; + return OK; + default: + logError(comp, "Set Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + +size_t getNumberOfContinuousStates(ModelInstance* comp) { + UNUSED(comp); + return 1; +} + +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx) { + UNUSED(nx); + x[0] = M(x); + return OK; +} + +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx) { + UNUSED(nx); + M(x) = x[0]; + return OK; +} + +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx) { + UNUSED(nx); + calculateValues(comp); + dx[0] = M(der_x); + return OK; +} diff --git a/testsuite/resources/Dahlquist3/sources/model.h b/testsuite/resources/Dahlquist3/sources/model.h new file mode 100644 index 000000000..8dabb0cad --- /dev/null +++ b/testsuite/resources/Dahlquist3/sources/model.h @@ -0,0 +1,250 @@ +#pragma once + +#if FMI_VERSION != 1 && FMI_VERSION != 2 && FMI_VERSION != 3 +#error FMI_VERSION must be one of 1, 2 or 3 +#endif + +#define UNUSED(x) (void)(x) + +#include // for size_t +#include // for bool +#include + +#include "config.h" + +#if FMI_VERSION == 1 + +#define not_modelError (Instantiated| Initialized | Terminated) + +typedef enum { + Instantiated = 1<<0, + Initialized = 1<<1, + Terminated = 1<<2, + modelError = 1<<3 +} ModelState; + +#elif FMI_VERSION == 2 + +typedef enum { + StartAndEnd = 1<<0, + Instantiated = 1<<1, + InitializationMode = 1<<2, + + // ME states + EventMode = 1<<3, + ContinuousTimeMode = 1<<4, + + // CS states + StepComplete = 1<<5, + StepInProgress = 1<<6, + StepFailed = 1<<7, + StepCanceled = 1<<8, + + Terminated = 1<<9, +} ModelState; + +#else + +typedef enum { + StartAndEnd = 1 << 0, + ConfigurationMode = 1 << 1, + Instantiated = 1 << 2, + InitializationMode = 1 << 3, + EventMode = 1 << 4, + ContinuousTimeMode = 1 << 5, + StepMode = 1 << 6, + ClockActivationMode = 1 << 7, + StepDiscarded = 1 << 8, + ReconfigurationMode = 1 << 9, + IntermediateUpdateMode = 1 << 10, + Terminated = 1 << 11, +} ModelState; + +#endif + +typedef enum { + ModelExchange, + CoSimulation, + ScheduledExecution, +} InterfaceType; + +typedef enum { + OK, + Warning, + Discard, + Error, + Fatal, + Pending +} Status; + +#if FMI_VERSION < 3 +typedef void (*loggerType) (void *componentEnvironment, const char *instanceName, int status, const char *category, const char *message, ...); +#else +typedef void (*loggerType) (void *componentEnvironment, int status, const char *category, const char *message); +#endif + +typedef void (*lockPreemptionType) (void); +typedef void (*unlockPreemptionType) (void); + + +typedef void (*intermediateUpdateType) (void *instanceEnvironment, + double intermediateUpdateTime, + bool intermediateVariableSetRequested, + bool intermediateVariableGetAllowed, + bool intermediateStepFinished, + bool canReturnEarly, + bool *earlyReturnRequested, + double *earlyReturnTime); + +typedef void(*clockUpdateType) (void *instanceEnvironment); + +typedef struct { + + double startTime; + double stopTime; + double time; + const char *instanceName; + InterfaceType type; + const char *resourceLocation; + + Status status; + + // callback functions + loggerType logger; + intermediateUpdateType intermediateUpdate; + clockUpdateType clockUpdate; + + lockPreemptionType lockPreemption; + unlockPreemptionType unlockPreemption; + + bool logEvents; + bool logErrors; + + void *componentEnvironment; + ModelState state; + + // event info + bool newDiscreteStatesNeeded; + bool terminateSimulation; + bool nominalsOfContinuousStatesChanged; + bool valuesOfContinuousStatesChanged; + bool nextEventTimeDefined; + double nextEventTime; + bool clocksTicked; + + bool isDirtyValues; + + ModelData modelData; + + // internal solver steps + uint64_t nSteps; + + // Co-Simulation + bool earlyReturnAllowed; + bool eventModeUsed; + double nextCommunicationPoint; + + // solver + size_t nz; + double* z; + double* prez; + + size_t nx; + double* x; + double* dx; + +} ModelInstance; + +ModelInstance *createModelInstance( + loggerType logger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType); + +void freeModelInstance(ModelInstance *comp); + +Status configurate(ModelInstance* comp); + +Status reset(ModelInstance* comp); + +void setStartValues(ModelInstance* comp); + +Status calculateValues(ModelInstance *comp); + +Status getFloat32 (ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t *index); +Status getFloat64 (ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t *index); +Status getInt8 (ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index); +Status getUInt8 (ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index); +Status getInt16 (ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index); +Status getUInt16 (ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index); +Status getInt32 (ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index); +Status getUInt32 (ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index); +Status getInt64 (ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index); +Status getUInt64 (ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index); +Status getBoolean (ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index); +Status getString (ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index); +Status getBinary (ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index); + +Status setFloat32 (ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t *index); +Status setFloat64 (ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t *index); +Status setInt8 (ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t *index); +Status setUInt8 (ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t *index); +Status setInt16 (ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t *index); +Status setUInt16 (ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t *index); +Status setInt32 (ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t *index); +Status setUInt32 (ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t *index); +Status setInt64 (ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t *index); +Status setUInt64 (ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t *index); +Status setBoolean (ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t *index); +Status setString (ModelInstance* comp, ValueReference vr, const char* const values[], size_t nValues, size_t *index); +Status setBinary (ModelInstance* comp, ValueReference vr, const size_t sizes[], const char* const values[], size_t nValues, size_t *index); + +Status activateClock(ModelInstance* comp, ValueReference vr); +Status getClock(ModelInstance* comp, ValueReference vr, bool* value); +Status setClock(ModelInstance* comp, ValueReference vr, const bool* value); + +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier); + +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime); + +size_t getNumberOfEventIndicators(ModelInstance* comp); +size_t getNumberOfContinuousStates(ModelInstance* comp); +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx); +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx); +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx); +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value); +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative); +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz); +Status eventUpdate(ModelInstance *comp); + +bool isClose(double a, double b); +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected); +bool invalidState(ModelInstance *comp, const char *f, int statesExpected); +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p); +void logError(ModelInstance *comp, const char *message, ...); +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]); +void logEvent(ModelInstance *comp, const char *message, ...); +void logError(ModelInstance *comp, const char *message, ...); + +Status getFMUState(ModelInstance* comp, void** FMUState); +Status setFMUState(ModelInstance* comp, void* FMUState); + +// shorthand to access the variables +#define M(v) (comp->modelData.v) + +// "stringification" macros +#define xstr(s) str(s) +#define str(s) #s + +// assert size of nValues for scalar variables +#define ASSERT_NVALUES(N) do { \ + const size_t expected_nValues = *index + (N); \ + if (expected_nValues > nValues) { \ + logError(comp, "Expected nValues >= %zu but was %zu.", expected_nValues, nValues); \ + return Error; \ + } \ +} while (0) diff --git a/testsuite/resources/Makefile b/testsuite/resources/Makefile index af76ad744..d114fa1a6 100644 --- a/testsuite/resources/Makefile +++ b/testsuite/resources/Makefile @@ -12,6 +12,7 @@ B \ BouncingBall \ BouncingBall3 \ Dahlquist \ +Dahlquist3 \ DualMassOscillator.System1 \ DualMassOscillator.System2 \ Enum1 \ From f5f51777352aed9046b7d5352678024724959f74 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 19 Dec 2024 15:02:55 +0100 Subject: [PATCH 13/32] add reference-fmus/3.0/Resource.lua --- testsuite/reference-fmus/3.0/Makefile | 1 + testsuite/reference-fmus/3.0/Resource.lua | 30 + testsuite/resources/Makefile | 1 + .../binaries/aarch64-darwin/Resource.dylib | Bin 0 -> 89824 bytes .../binaries/aarch64-linux/Resource.so | Bin 0 -> 71912 bytes .../binaries/x86-windows/Resource.dll | Bin 0 -> 142848 bytes .../binaries/x86_64-darwin/Resource.dylib | Bin 0 -> 72616 bytes .../binaries/x86_64-linux/Resource.so | Bin 0 -> 67208 bytes .../binaries/x86_64-windows/Resource.dll | Bin 0 -> 176640 bytes .../Resource3/documentation/index.html | 91 ++ .../Resource3/documentation/result.svg | 1 + .../resources/Resource3/modelDescription.xml | 41 + testsuite/resources/Resource3/resources/y.txt | 1 + .../Resource3/sources/buildDescription.xml | 13 + .../resources/Resource3/sources/config.h | 24 + .../Resource3/sources/cosimulation.c | 691 ++++++++ .../Resource3/sources/cosimulation.h | 5 + .../Resource3/sources/fmi3Functions.c | 1446 +++++++++++++++++ testsuite/resources/Resource3/sources/model.c | 160 ++ testsuite/resources/Resource3/sources/model.h | 250 +++ 20 files changed, 2755 insertions(+) create mode 100644 testsuite/reference-fmus/3.0/Resource.lua create mode 100644 testsuite/resources/Resource3/binaries/aarch64-darwin/Resource.dylib create mode 100644 testsuite/resources/Resource3/binaries/aarch64-linux/Resource.so create mode 100644 testsuite/resources/Resource3/binaries/x86-windows/Resource.dll create mode 100644 testsuite/resources/Resource3/binaries/x86_64-darwin/Resource.dylib create mode 100644 testsuite/resources/Resource3/binaries/x86_64-linux/Resource.so create mode 100644 testsuite/resources/Resource3/binaries/x86_64-windows/Resource.dll create mode 100644 testsuite/resources/Resource3/documentation/index.html create mode 100644 testsuite/resources/Resource3/documentation/result.svg create mode 100644 testsuite/resources/Resource3/modelDescription.xml create mode 100644 testsuite/resources/Resource3/resources/y.txt create mode 100644 testsuite/resources/Resource3/sources/buildDescription.xml create mode 100644 testsuite/resources/Resource3/sources/config.h create mode 100644 testsuite/resources/Resource3/sources/cosimulation.c create mode 100644 testsuite/resources/Resource3/sources/cosimulation.h create mode 100644 testsuite/resources/Resource3/sources/fmi3Functions.c create mode 100644 testsuite/resources/Resource3/sources/model.c create mode 100644 testsuite/resources/Resource3/sources/model.h diff --git a/testsuite/reference-fmus/3.0/Makefile b/testsuite/reference-fmus/3.0/Makefile index b1bea8d6b..875658510 100644 --- a/testsuite/reference-fmus/3.0/Makefile +++ b/testsuite/reference-fmus/3.0/Makefile @@ -6,6 +6,7 @@ VanDerPol.lua \ Stair.lua \ Feedthrough.lua \ Dahlquist.lua \ +Resource.lua \ # Run make failingtest FAILINGTESTFILES = \ diff --git a/testsuite/reference-fmus/3.0/Resource.lua b/testsuite/reference-fmus/3.0/Resource.lua new file mode 100644 index 000000000..dd1b73720 --- /dev/null +++ b/testsuite/reference-fmus/3.0/Resource.lua @@ -0,0 +1,30 @@ +-- status: correct +-- teardown_command: rm -rf Resource3-lua/ +-- linux: yes +-- ucrt64: yes +-- win: yes +-- mac: yes +-- asan: yes + +oms_setCommandLineOption("--suppressPath=true") +oms_setTempDirectory("./Resource3-lua/") +oms_setWorkingDirectory("./Resource3-lua/") + +oms_newModel("model") +oms_addSystem("model.root", oms_system_wc) +oms_addSubModel("model.root.Resource", "../../../resources/Resource3.fmu") +oms_setResultFile("model", "Resource-cs.mat") +oms_setStopTime("model", 10.0) +oms_setTolerance("model.root", 1e-5) +oms_instantiate("model") +oms_initialize("model") +oms_simulate("model") +print("info: Resource.y: " .. oms_getInteger("model.root.Resource.y")) +oms_terminate("model") +oms_delete("model") + +-- Result: +-- Loading FMI version 3... +-- info: Result file: Resource-cs.mat (bufferSize=1) +-- info: Resource.y: 97 +-- endResult diff --git a/testsuite/resources/Makefile b/testsuite/resources/Makefile index d114fa1a6..2cf4e5edd 100644 --- a/testsuite/resources/Makefile +++ b/testsuite/resources/Makefile @@ -50,6 +50,7 @@ replaceA \ replaceA_extended \ replaceB \ Resource \ +Resource3 \ Stair \ Stair3 \ str_hello_world \ diff --git a/testsuite/resources/Resource3/binaries/aarch64-darwin/Resource.dylib b/testsuite/resources/Resource3/binaries/aarch64-darwin/Resource.dylib new file mode 100644 index 0000000000000000000000000000000000000000..9fcbd91bb5655be8fe4e460c6850e5c0c3cd9363 GIT binary patch literal 89824 zcmeHw3t&{m)&J~n0-Jz>fDn0v4T1(x9*U4C>XHD0MWle1Rw0D2kZ4FCyFn1G!T3N? zn`>#MmVQP=-6(3bScyeJqBgeF21V-wCA@TlFDz&iCC&Fc^Vq$6_wI(q;Q#-TyKr;w zna7!#bIzQZIrI9*cVGOcGh;S}Uk5y0@VMd_yPb6LJgpET3nYFBHs(@226xZ(Fr^6KoF!XDp7D=)tTkudjHXH|S)>;U+iWD=hGa3T(`uyII5(RA!7| zheBrZ&dMq-xFN4#epX(=f&O}d z9o>!n?`2hhwQY{9caIgmT+y_`R?!4FA@SDfiy5o!YIip>`=#$TcXaP;&a~|eoN3bn z-C1KU{G6w_8=W?HqrWt{p{_q`Z0^Gv>)>x=x4!ks2)3qqD@zabN0`$o9Q!)Z@uA+S zHZ}$;dVAEtJ)5zzl*3)L$A_{txvXS*;4)T)_0K&hjty}LS6vs@=m5U`omk^OhvSLA z0&iUxcjM=H@9*Sp3^>>m1m`m6XZCpZHOE=fReK5kf$qQozy3{^rgQhTU9}w)ANdUQ z3FT>(E>HCircoJ@Pm#a!uG%fS{9)a7k2=JCf$&iIwr)$WM}AX5M{<7}?#(C%l`(Lc zyDHFyRaKPEX#l+{6}_CcgwF!K9_kG@PK#d=t}gB>&{zYFwWby0DvlLy_Y+T=OKm%w zR>XrRHm%&zzv1EP_~WckV+ zSq+Ea7l0p?a|p_q8ZXN^@HB0LET_M^|K`5PKjHRQ&)Mv>u_eSiMJGS-umpFL-!Z4* zGo+n|w1*(=>wu3fAAD>p;$t0n4@$2B@dJ*8Cn&ujO*fyW4bi1V>6BMzZEjjIp#tUQ zviM_`yQ3~IVdajGEVuJscU1+-{W;2gH_H7JlzTPNaruzVEtdPXZrbNVgsc;dP0OvX zn;+TIc^!RUzTc7Wy|#3$^q;Qk?OfC&HmSRy8|rA&inxj6dayb&&FvO?-!c06L-$Is!Wmx?!(ES;nmH+8oB#xZ;J}QvP|p z?Z~PiZ&i@D>q*}9_yS0a!a?S$oC$)SO76!i_fv#>jm$?q(sZ(w(^HqQs*6;Z(;~z0 zvLOuiC~#S&bo3A9-G5{b%I!wEQ4SmHwhO$jbFiv_!)=;pa*vhgUMfE^@_eca6C=;q z6cLtJMWb-J7+*p9fa?JV@zqh$RLz2VU>|g%o{s@ZKPUJI-gcwMf24mJ_O@_-I+s9p zd3{c}j_PxbPA>$YOT+5umciOM$f^++wxskRy6f>%-u*|i(y+~=Thofnie|`OM4n5b zyP&`JLH;Oy9%QmUi>0r^J8%t4KL}a-!~uD8xEuF@Z;zB_HEe(k9wdErjXNDO_*Mtt z?})fF2eUO{=~NSKI#e`4cRY!5Jb^eB;JF`qj_XXcPoy)?LEJ^GbK+A+`la1V@BRJK zo}%~L{nB>ey|KDq+NWq6K7(#Ogt}5sx|C@A_UyDtb~c*x2)I%9uett~^do&+hxD?6 zpVyPM-L)Llmz>J(8na#cF2&o5@~7ZU?a^N3k!11_ly3vthDV`K{QGC8QTfgWj=m_L zYM)hF0hyM+dUhJsk0A)>v?V5{X4}&#f4t5heyYcwPT#BGPxXiAnd$-3r|)vmwQ0q~ zisov`Bj}6zp`h__l;LdFxc5x7vuMi+|8*=e@z5TYemAxh9r_SF0$n}OmLM z570wz1!c69fe)hpK>4To_jk^#anS3ckAZZ9ydvI^EDVMWR6swKJCct*T-xv0B+^&j zerfx9v8Lv;W9zD^BzvGEwR=R{mB7b&FtCSqesl8!5xNTcsQ&CIx(aD=dXc|DSB*qE z0dhCid!(s!RjLYOtoH~*J(j93ky5FV3 z80n5MitZ%{qo+B2lg@Jv%1HOe3wm?9!tIi#<_GFJp^fMi)R$p-Cihr*_Ne^C$n&)- zOpH9wFyxu?+kcQ9x=`jl1#K1DGU$jUq>ol9eS|j5NqraUW9r?Aws3RW*_iIYQBUQ! z3;F1xaC$P*6QM^EoX{`uyWGZ#oTuH@o5GU(k}UFgT|;uE=$0(>R#l*56uQAZ7Tu_A zULk7%uyrrR>-B(0aC^>|;-6i}b)=&lc%{ z?V=H~ujf7S?}XClmy$kxPuJc=-HOo3t<()CoIbJ-+Sc@$P4uQVOX*J4zaD?Oc1Ii1 z$E{=|MtvHi!o;Xg!w`mOV0=jLpOuQf$`8<$|L^L&9sQ7w=ugXWwd^B4QrZvw&VJAV zePgzNoo$kbWb?qd|CK!}r)MyBIOE#WwbRXbIGozQYcZCN93%OWmXI;{8`{6GIDg=7 z*}8P1P>sq&-tg7Qb@q%p!Il+$VJ z$;b2K@SU>ibZzw6Y)!o`PpY4=UEy=g7WgnebUH%gM}Mhw$9TjvopIsm^o^1Z`X@p8 zqb{#RSIVzy*PGG5 zZbo00yQBX`wgzs;8G~_khY;O}7sMm#0L^i8;(s;0TQ7uo14xNHcU*d$p-D&HX*!@-YaPT8u) zk-S~oQ+x0%wubPMoWUMxT23K@(d!n@C}@$N)Gy*Zk5Nt<6YI;UzA0XKpW`x&jqP%5 ze1i1P=RLJ=Am`AVFdO{w44E=L#ka;@CqkmGrYajY&29@(9*FQHx4lMnHKCH3- zlhjLl2mEhu`sdq$=6a#6`#-y*q;ov_$Jy9E^v@2o1t+`y`32;_(my8pC#{$EJmkE+ z>7RGc{BiWpmMG~QkNye#yM5@Nm(e#kiS$3*{>^wNsa&YtA` zp9uZ)+ms(i|J)QMo#W9z{%_ic{#lQ{!O5Q2^v|)r z=II=d{z?71edwQA=p&x&`sYT-fn|S=us>I3xRbPZAm{B(|9soWTrd2<^*<5guia77 zIUfDvJlsC?&*kVNp2Yg6jK*KTfE-x*Cqn;}W#lJm&qK~na{W`Lv;UNl{pa1@Cq)00 z>Fhr|oh?z)IUfBJ__BTIpRwqRp6vSPLde0%tbY#Dc{XEM%yTl{qrD-tj}QCeu~%E| z0V~T`lccTr%0vfYe|h~F?9DaoJK}p-kQUK1K>mh3V1HKb#{D>S#*5qo_M8f1+^2#t zsdDdm1;S7o`p0Y!*h4am=^ilPlY77-bkOr>KnLmaB=+C*-+Z4gO@1B_?Kv~<1LJ#u z#9p-EJ}`Y+p>;r94?P$qEw4T;%8PLy7~Ed}0($67?2kGVXMmXSgWLl#`0+EO!TA(} zA9OAO4-i2=w==Xsk4&MicFk$<^a3;~g9HtG$ zI0a`Y;T)nUWrcgJveJ1tEtQq_lDAaWL_=9sx%gf%l=Cmx3&!2RkEna5O6lwf-C0O- z&nBIP)Y3T-ILk`ZRe4SXooR#pnq?VVlC%o6OA-AA%pca%c@JiFHO4s+Gl&)x&nO$T z?@iX#%T*YoY#@xPtK&@Q)r>PWIE`?whF%`@`vU3AB`yyLL-K$h~1X3dLzj~ zN5}&9;hU9>+ygPn#$};}vT<3UFfqzzDhtS?llBFojI=M1mlJrxWkGj7l;el(pZlAV zhw$|aWf^rz+8{G|XyyL7rzxEl_KZHN!We0WJ&;Ns)|tqIneM({hBMXOz!yz-PfRlJ zKdzMc+G1a7ABM=-}ww}BHHE%U3?PNy;R-a`4qW#ej((+%yzv} z%4l2Ey{YK0x97UYX$`wcXRGdsevoSSu30&q*S)kew1uCyzq+@o=ZUX-D=}8F>RwOn zT+rHT_jEQ(Rrh9{p{@F?{nfpS(@%We+k}3tRrh*oQ$cI1?wQoRo6gWG4z<6!_tzdL zzV3aBzLr(@dTNEBwN>{_>R$O7+F$G2U)}qx`-!i6y{)>(_eqq2)>hq%sC%^;HD_p_ z1y1_97u+YBg8M3Hp1kvqQ1`CDIH#Srd%W&F+s&$bVQX~7c&|3&^E0&0?Xd2h3wb!v zcFq!vbF8}8Q+w+)tL~ZBy&k=_b3bi=?cP+#!-=kYf5bS)s(U@PBVDb!XIl5tdTUcZ zX@7OE5b|)M>mKf9vFaY?_j*`$&uo6LHe+sYt?=MUU-yFh;xXQ8K~T?hyB(|jteLJr+4#LHxGybuCketG;_L0N4ZD*hh58z3|B69xq9tF~*{5}~#qT6( zffoEuk``zY^-dDR3tv+`33rUjJ4t@P`g$MA&Fh|SeLdEdRc7q&t?k@rQukW9zMk*B zXkiUH-+R%*8g%2{3*uX}_4TP8#l1UfEj{F7HSSwZuhHEbXk2&yH;hAm$Xfe;R3}>~ zXAc#|SSNJ*2883sJ#C(llE}P`-vr<_0aYEQ9lnrb`D}M$R{!It_#B( z{eIlNw0{ONMlz}HvGN=4u*6-)LS~U(9qpIEo)9jxzCPMOGnvKSiTYkq_JklUqA_G7 zV*l1S*hzD{{2;C{j;~II1Fsi*6jxa_(5=?pD3!eX+WbXgW-Nw=HUpyY(U59dW zePiU^hCbT!drkCBD|vT?;!6zP1@Ezr!Mlr0ct?Drd#O{X&g|-=aoOw9SBpbCQZDa+ zRc-b#8DH^wWIN*Zh3332%Sh|1UD$@a<~o<^Zwy{@ol9Y2@Y+o0(*6>L`{JJg-{`wP z?u@6pOLacHJ=WC=y{^Q)qz^++(jD&2=xfE&Yotqf-O$}H3E9Hl_`cegbtZKK`vcKW zG~ernw0J(r-_Q^4L-{9nBfYQ}QR%gADvXg{2&42`0>V%l`lp`yZGB4KN>y~CJ|z0C z6sEj7Yje{Io$il9r{lTnp7!gR=#jFFn!eg2X0&Rh9vO{vxPCX%O4kOQtHKy*rE3EQ zB8;9+^i4Y9k(Tw@ z4_`)L=qAzw0)PD^|t{lmk=;0xUkZpN4Wpd07Q zVaXRs=gUm!d?uv>-GII&9or z+9Ixz$7;_X?!L}K7$c9Pjh}N9<(T1YjL#th>;N0imJdD_ezzyxeTsW8aku9rrwC8s zaG!1yr4zj46Y*)>O?RczeV=xG@6Tk~o9HJ5_ja4m1-z~b#GuPiRpuCUfi7v0E@v3% zf_s6R{1`vWyGf5>9K&hgJSAbZ-R5p$&T;+eu6xcel3{rt=%3X%1m#s@_9v7Z$``Kx zCs#C=s&VU&D4VnTYyJLD%4SH`j!!m2wxF1@3H}9T6MR#$dA22+@}5^3?>cbLG{()) znJwKdPj}|(`)(_Hm(c#avW$)WwOc+m(TV80Rp4%WvvUgk)ycw!N&W_%NNo+>`R+8< zeO=$Jw+ds_iMqbqX@onn50zFLeU_VQ=v2F?OlIfFR3%K0Iikzq2)tm00PlZmU z@NIeb{A|KUXR^q??>MB(>F0E5!`qO4oKG##Z_IJfPmSw{4(bUg`bnPEsQu?~Uj-Tx z-TEUu50?TRkNelr_H$aVl6?U9RY8Yxw_Lp&;Ut?T+)e=w;)ByJa8f^#&QP-Z3F0#{E6&qdJ?{}N%BDBY?v8DVR>9k}^nWn-RbrI^I(nXgc4AE2n1m_K* z_n~w77?HOfJIAG0U`!9UZmBkwPH}?sW5%%WAgsd>7UL1F!;N9zC%oJ*h?n%4Y1og( zrSr9Mx;$X4Z60e5b+A{VXcr;&}VrG6UO*m#&2a$#y?Bi$VrYTIM>!%9iVhR)vN^2VHr z{v*k0WCJ*!Gq`fNe4%fq<_M8Cr`gODt>#0My41=!!imJ|7Us?_R$+`Z!+1v3rBMi@ zuSe=TSVu5NA3UoL@n|02N$0yfpQ52YkfZb7h|*7kxNtAE^(ga0X>Q z8qTl7aefd5r)r}qkFYVP6JB~#Iz*H3c3FR(maYwj{G-3o)YAM}unws9tApgHdw@36 zjGwKvopL*K3wC*KXKukRZ&nBDx=(uj0cSYJfZDD_NjSsT&__Tv`isFw;8Lyk^G7$raIO>Hu7ud)8dZc)xCf6*TJos$(v)@C8j_=dHqxU7c~|bJ5XC|Mj!NF zDl((k=8zW2x}W?Fb_rVN!QGAHbzL9gEEUFB|8)Hqn$K4CPX7*$2cq>gDh7u2U$#2T z`!A}UAbe^*oAUkNv<tv^HcVc}V5be2Nu8acn))lzZIxsvXz6U>OQNA>zZee*J?zC4|m0Gr!3duR@s_x&Qq5c)B+1GMafxel?0 zySy~{*u#$GW1+EPKa3UoVZOL;!v;s+hDS^LU`=L6)7ycmQKzUAf2|wmMDPUusiEovod#FUys!E6Yd7LrZ+x zrNYE03!Oo$_@my$gNKoCmYSW6^WmH7&cxV|_!f^jYgcx1;4fH{FYWhwzY>(ITvzt> z5)Z{?h)Z;^(|kAhD#w|qTd7*TO~+fz)3-)$f2YbCgSTZWObmM5X+jUbV>Y)T&|E&* z5d04DCVKI*CAgbxT?>*qz50M&ecVlZK{G|G1juat*{llveQtA9{-Z!I^c|+_&l(?$ zu&A?%fv;e*_{yC=Nyec(U_DHFK(2?Rbe-85>A4bC>u#tn?cK_>eSc=!(his}8H)V~ zL*1q{CHGjmfaY^rk}+D($-~5;>3Ig4^1Q>2s`3s!*5hf+nJ9PKb1;O{Au$p5qjXhP zPDk8VP@`x7`hcd>vBsu~^8)u3RDd_exD5R9mtNCAb&zO^IHM`NUd|~E_EXkG`vv$n z;wU#&FQ}a1?dMM_njMbF`5YSWS0`_->kiuy=Hz1arD-h~7j02f4#sEbPyw za{%NX09`0P&y%4I3XZ9bby=5J8dJAqzft38eLg8pI1hDW>e6uAu3FbcHr)f5BRPnE z4YhAIu=fVCSo){kSrzS-2-+-l_J6tuB_8$9$;905B)NVqC<_Ri8?4(|4QMACvVoiP zerL#DVPpxh&&qe!SIjw)+bJ?nH1<^O0^E^) zZHn_8Z6IT7i08?~bGY+$bFj^V|5dWw{Jjb?L+c=T9(KySyd&T5%lAj}y;r>1IJ8l~ z>E6}+0LMi*u;+_#_>m^jpu9Azp=pKAE?ynJ?`1Fa70pd6ekrc z&7XV99i#T9vEYh(EKs+TQ4(QuBcrkT9JI=tz?Il!{UgU@8;W8aAxKSBM_fR?Lo8tlA;M{!+?Gd#*e18C~orOFHq+YIoo>Xl* zt*zMzUHK&RDDBy#_Jii<&Ou!q8qXSsB%n=$jzrp(DdW%4Iy5&wVB`h$iJS)hgws!_ zCm?U&Q{!I9A@;>lA0Sv~1G3KQ@ds{U=|=qIM)(7_xYLP0L3(7G&#BP=5~^8fohwOZ|Fy^ z(}-t0UyIMx)+1lJz(swQUw|h1^;ALLkAcpU>!yhgeC^uuJfWL`ca;t=@q_q}v_#pR z!?e3}X^bPfOB@V1cs@1_({{iPhdQ++0DOv%{v&hJxU7Lk)F$$^c*eNU?JuwZ*m>h3m8+-9we2|;J5&JRc@qjQjtF4 z*c!GbLdV5Y0xLUod|3D^zwu@nf96L*N5?TwqK}j<;uEs zA3Jq+E|VHHAGXs7Sus|BulCeKo$>z*0hJ^Lhwhes{=ij1YQWWuVi0W zaq+H7h-aq-90^abo87-oL7!kz|gUcDZoLz3fuSOAiW^h7E4;Gb#H3T74&( z!u$;V8h(}qY+Cz~Mo=dlxJa`hzZ5U5f1-=4`un6y$PTy{V@28@E5~VMo2cUb3XD12aYHuy#tO@Uv>CVs4x7CjR4Rlt*K8!o`;|;YYk@_#Nor`e@ z@=&Al0C!5Wv$Q=>IGVqwG`S5@`cs|~5C-&Xq_i0f_0Cz`PJRe7<+Q=hPPQZRqxH>*%iYM1L~eW?vveby61ic$ zaxfg(m>4l7nt!Yl0iCKjwLd&54Ie$q0o>fz65H;cnt!JlLV=o4eoZu1dXE=6N!m zMT9a<7JXTo`v}G%n;YTr=-gm`BR7V*MxH)w`@D~tjc~-jJ0S$U1`nU{sAs$!0od~DW!MYmW zw^(q=1zqT+(?J67~gd503O@>zstW9b>H1|-#vBTy>;Koy6*wH z@3VB@Lv-K6bl>OczDMi6FVuZsqWjL!eNPnM(>>n8;-VanE59%&+m}~Z;96Ad^|=ZP zeXe;P*VL<~Oc}g@btkJoj{#jZg&7Q5yZ`&>6j$kSDcy^O=&NNSoBQ__->1C7$?eU4 zBEC2sl@qciqKzJL_=<>p_{u=(ik8z?CZy$hqOdBU`b2De^5pRr z`4A3BUAl-bkq_yFe27pYKE)GXDj)Eb`M{UV2fjo;CKeauaM6|Gl(%SczK6(7JVkCN zUUAh7AMph-g5L`k<(;pGgB}x$Jf0vh!&Ag%!82bu&B(iv5J_j{$^<&2E4;ltWiQ1V z53w+Ypm=8Pp}Izu169-GTI5+&ShSp15|!+*L@M9-ydqRP)ZOg-@kn4P1b3;2JjTtx zt}w3v)gb7|B|NjRU_su(;-YW?k8}kFFv3#=c^vP_$y=12&!&2A7@z0ODf0L{oTQLa z3W2!3yn^DwV(-knMIK%oG7E_dU;&|6h_nieX81gd8L>rIX#j{yGb3+NaX!xxv5C;o zJA_y!hddeFLZ$OknR$JjTrfWmG%GCPPKF5FZE7JUoA14HfvIotqIsU8D;F4%6&M|m z;8Ynl0#8AN3#S!Pfl~-^uPpX0F4pnK%f=USDg`xZPH_?RAj-UGQE>s432dH5Om#sU z3>!ImVMw_WG>nCXba|1Oi-b?89jNq6TqBH8#`#=1di<`%JOP0|TZf}?flQN>d68!c zR6J>WQtw`0;bNB$TqCv0V-92EAe0bBE)V(BvWt9Btc3-{VS!WkNxaLp{d-cvA)tr#;eJ?FfUBS)QkUXJI2 zb4QIBGy2@@k>{rYoR>2?-7^Bu1vj&w6%_{Yh9dwUTqvBVVZ#{DT>->CZ@w#Ar@BG% z`NLd6-T;UZRJ5Hz%}-T$VPR1oTE)l~)+E$5Xe?)&1kEp8$c50$@I{rP*gJu@Y-r~| zN|lH%I+$KqfMVwNw&WpC z-ULMTMbwd_qxw?Z7QAC;E24)Hp060*vfYWAHPIMF^%gBugf|pgOp1p2o8(UUn^IhP znp0f)nv+!dMxnU!Mr0F$D_@En!yCRaibRoPct_)hN;?Waly?+<=o(Jf{9q&LMV*J% zK@V8hHPm%}4Gl6*jo`n-w|t$uf7SC12e34iG3@haSU@{5@n`H2?#I8ym-tIKIO-n61{q;&vlIXD5rFg^8BhN@hDy zi2>1b%r@&eW-ot^v6+8l_R2rv(2|##&Hpme-O7+W^1$#t4NvgbwS@8w-xA^2wS>|p zm;%!qb42_Nn*x7#ly4->VeIMSZ`f1#8}nZLjrAA&jWaIz8|$X{8}n`ajr{O8_QTPy zg#WevSQM}*U{S!LfJFg|0u}`<3Ro1dC}2^*qJTvKivkt}EDBf@uqa?rz@mUf0gD0_ z1uP0!6tE~@QNW^rMFEQf76mK{SQM}*U{S!LfJFg|0u}`<3Ro1dC}2^*qJTvKivkt} zEDBf@uqa?rz@mUf0gD0_1uP0!6tE~@QNW^rMS*rm0T;?V2~Qaw+~12M&qF_P4gfzl zfIH$00><2Q3P30nec5nufNdZiH=g-;?#AQC^E#dYo^SDVurXUtJUCp$B!(7u}FoKn^&YC1>$+awiB!!{l5~K-K~rN*3<2usFMD zzHllkz=Q^mU;^o<76w}0^vXJMo&>8%c8?*3UgT2f}H$9uLtji9v^{p;u&5z z8;WI#Xe_J9BLjPVMLCNWGvumhezADxBRI2V(eX~~H980(j@A4T=QXg()%5qkr*{0^ z^*BgtH#rsR3~>rj|2P)FC1r7}>@EsuIJ7ClXE<_cl7ro|9Opzd6e3DsJ)*?n2qHF> zpBKZA99m*>irLcOfkZ3fSov*~JAZ>6Xv(}u69^2+zF;#!@{)}?=wK(d(nhD3;TRgj zF;UOjaE2P&Zi{0LdkFciLLgViSmDZq$?~)x_MknE?Kn(@F8RVne?Npk*u}|XFWKd> zWYq|?=_q->_iM`V=Cwp0{Yg;!>|PeIGdn-1Y_~mlJ{6sJ<6&PSe&uJB$g$s0{Mz?; zf-8A~cT<8mk?d&)&LG?5V0LwUnBPIi*0C2I$kn4f=nMSs8~pFD>F@6E2~k5cY67w& z&dmDSF|jC{pU=hq?O^dZ{_K4R(C;Di2OVkbGY3Cni!}l7?guG5M<1fUC4Zp5mHz}T zN5oN5FT@#-qIxOr>TH}YHZR{Z-UDHskJFTJ*bu9ZWA^B0T|FBoPp@Kc#Ko~yk5Y;| zO6c#}m4c+A49~|0%kbxTWbFXaC^v6`kG&Ev&WC%CoS){D*v9|9#s98Dz&I57t9TUo zn|KuY`}j1rvIB^Of;rfZ1wdq$?{ytKMP52CYJCURIr1R07wj4A4SOcL)uB7YB_sei zAH_(Y^^S?`bq9`_VQb>1vOD7=&)#|_eg^wEo=&1+cXqg%J>CJ?%SRp$T#rAiAh2MA z?wGPyI#Qj=pRg<^H@je=hrQl$MozA0elgBSoUqK3Q_K&$`dddJxtXYXfFxtXK9Y=} z+^=?qpDU+1QP+1+z_l+^Kq2;E_qza=4!ZBGzly$g76E2a3g_#3Jgs}h6p?@L6vUZVnYky?`|MCwU6 zm;H)jZu~vvVnYS}UH1b0-E=R4lVH^(BGES!k?5|(H1Pcg~6I z4++HD&k|;^XA}7WbK4U+v+EL>U7pLw9&q~DH;E3maRm~ogEnNHq8wv(O0*O1x{qgr zCa^DTbdVr>$c|&)SWO3^-{{ma53B7c4v4(NIm5%A=rmIufyZ9#bk*Ydk-BrMI7o*b zo0GK0(O_$^jq3cKW0Ng+i+#$#wT@%)<@R#>CPztv`M*sa?}l_>G^luCQd(?guDekZz?ewZ+T?b#K zy+{75w(*lT*{)q@+wJgev`-5DrUbw6F(s+5tMAwn+YVbLKT_xmbRm)zuppd;W9t^4U}-w`2rpZ_*8@+ae;s@mHzj9DBzhA_J1tkITG%> zN5D%YJf%*+zm)J?3EwW^9TL6|Fr`_+pGbI{guj+> z=PyNgoPEvdJy61l5_U_tmxSj^c({ablJEoxZL;Y+yiM-`eo??9wFg|X9SFMm_`01{+SY< zvRU{SNVsIFfNxgtA_3nk;ZZjV`1cZi?+pRJEa9{r0{*9jE1wteHxfQZ1;g(Y5Sa2i zZKHsbC0ybb@GuFp2?D-E`A-+{6a`-+;9n>hV_{DN9i}<3^)2c zCgE%UF5ovLeDogzJ|y9iHwBDljmNKiQozF{yy`6hPnPhMZ33Pn;k6R>Nf<{#^B*CtO3KG% z3GcW>gr6zlDbES`dI=AFR={^kxa(sA{;h-54 zep>h+k+7R85`GRGphxuDa*KewOL)ZH0#1=|swUv!5_YW>@Wm2ND;4nN5)Nz=@H`2R zdPTr1Bz&8M%OqSY;m0JrX1xgiyoAgCBH-;3-gvKocS?A}8UfcycpWYUrQcT)-gJk6 z>5@7s@5YM-+!^gV!E?6@_$eG;?ql3=JYjw#rAGSt>}6fa)Z4 zgr4?^K%z|cV08$=LcLQrwd2hhsbIE+^A!7*&mfku%Si-o}$mMIuxFAUdokS;9z z!b7I%1BRVIu0z1xgM&!r5#wab{hjkE4(`M+tlKskVG07l+O$r<|^}0m}5j~ z#KE>fYS4I9M@0g4WF$~WM*>5HjG5P~rLl!)MmJUsGk6$1!_6N?UlU^p4B7!h1OCEzRjLliNE&t zf+2uXYxq>{95NS7Ree)Td<#8>519kuM9E4w`6*c;9Vss&q(r0g0>@xp@U8Mf&cfiD zMdo_Cxj^a?YA5biV-+fJ0%|agb|By?E8+5fb6K40+8joS3)FGoLyr z=(Ex9yN^3>!{~vA@2aod18x}IInHL7$zYi0fZswqv+&TbC$n8s?y}?P@Z+)wCScBZ~x$>)syZz=kaBKaFjV;X_$M?73D9!IUp&p zA#neP(|ph#9aUvBxjTT0Wu-aEJN__oW@U6-DAD|=(cBlUm(ohxbMU$-ayXTeuL zoz?5XXV1U%*=Ke&9(+B^{+AcOPu}rwd+CDeV|QM1?d&wFfG;r|@2`||Csd!~Dj z99ezebt&)fFa5al%Z-2i)5jaX*^&Lh)7STWX6gKbjot%;R^M{u-5#UjfAiQ8=bP?l z|1q`vlB#7TLoOeD_lq^T&+qB*WS70a)80AydCzrEe*E!OYaV{=H=ZHioHBG{!<3Th zuTy-JUY`BdynYpjR>dz#d2#ghA3wEZliTavG~rO)q{|ont=LhN`faZvzkKLt+ml}# zK5)+yf1g%edibTSuisdHcvR!U*Jm%8)v&%PK7Lu}t-BBJKKHwy&u)6QdFc3a{l1Nf z&p-5+tM{b+Y3%c*zRZ8UzW$N9t8Xp2V%j(3SFj6G2mSl?Is4xJ)7ASYy>{t5*Y|x6 zeU#au+}~;MW1Hgdo%PFZ(|`Nim{T@pXN*lcYx{D0(%WD75^s2S--zVgTb|tV{7c(E zcJ!)A-*)k9r+)5yas0*yulV<= z56{1N&@-88@7M_24gW q9&+2!N1M($$Fumcf9^_r?7F7aU%b<2$``+7mtXzlRg>T4V*S5mj95GX literal 0 HcmV?d00001 diff --git a/testsuite/resources/Resource3/binaries/aarch64-linux/Resource.so b/testsuite/resources/Resource3/binaries/aarch64-linux/Resource.so new file mode 100644 index 0000000000000000000000000000000000000000..64a1afcf8fee62b86c5623e104e70786eccf242f GIT binary patch literal 71912 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 qA%mWiQ|Wo(0(xGZ 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 z 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 Gs{MatOMv$P literal 0 HcmV?d00001 diff --git a/testsuite/resources/Resource3/binaries/x86_64-windows/Resource.dll b/testsuite/resources/Resource3/binaries/x86_64-windows/Resource.dll new file mode 100644 index 0000000000000000000000000000000000000000..116f3cbe4789f8c15811cf84a18ff07b4936f347 GIT binary patch literal 176640 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

G&GY+~ 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 E6T*&)<^TWy literal 0 HcmV?d00001 diff --git a/testsuite/resources/Resource3/documentation/index.html b/testsuite/resources/Resource3/documentation/index.html new file mode 100644 index 000000000..2665f6d97 --- /dev/null +++ b/testsuite/resources/Resource3/documentation/index.html @@ -0,0 +1,91 @@ + + + Resource + + + +

+ +

Resource

+ +

Test model reads the first character from resources/y.txt during initialization and applies its integer value to y.

+ + +

with the variables

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableStartUnitCausalityVariabilityDescription
timeindependentcontinuousSimulation time
youtputdiscreteValue of the first character in resources/y.txt
+ +

The plot shows the trajectories of the output variables computed with fmusim.

+ + 
fmusim --interface-type me --solver cvode --output-interval 1 --output-file Resource_out.csv Resource.fmu
+ +

plot

+ +
+ + \ No newline at end of file diff --git a/testsuite/resources/Resource3/documentation/result.svg b/testsuite/resources/Resource3/documentation/result.svg new file mode 100644 index 000000000..7ffa06b42 --- /dev/null +++ b/testsuite/resources/Resource3/documentation/result.svg @@ -0,0 +1 @@ +00.20.40.60.819696.59797.598time [s]y \ No newline at end of file diff --git a/testsuite/resources/Resource3/modelDescription.xml b/testsuite/resources/Resource3/modelDescription.xml new file mode 100644 index 000000000..afecf1620 --- /dev/null +++ b/testsuite/resources/Resource3/modelDescription.xml @@ -0,0 +1,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/testsuite/resources/Resource3/resources/y.txt b/testsuite/resources/Resource3/resources/y.txt new file mode 100644 index 000000000..347ffd7a4 --- /dev/null +++ b/testsuite/resources/Resource3/resources/y.txt @@ -0,0 +1 @@ +a <- the value of this character (97) will be assigned to variable "y" diff --git a/testsuite/resources/Resource3/sources/buildDescription.xml b/testsuite/resources/Resource3/sources/buildDescription.xml new file mode 100644 index 000000000..7fe1ee253 --- /dev/null +++ b/testsuite/resources/Resource3/sources/buildDescription.xml @@ -0,0 +1,13 @@ + + + + + + + + + + + + + diff --git a/testsuite/resources/Resource3/sources/config.h b/testsuite/resources/Resource3/sources/config.h new file mode 100644 index 000000000..386ef1602 --- /dev/null +++ b/testsuite/resources/Resource3/sources/config.h @@ -0,0 +1,24 @@ +#ifndef config_h +#define config_h + +// define class name and unique id +#define MODEL_IDENTIFIER Resource +#define INSTANTIATION_TOKEN "{7b9c2114-2ce5-4076-a138-2cbc69e069e5}" + +#define CO_SIMULATION +#define MODEL_EXCHANGE + +#define GET_INT32 + +#define FIXED_SOLVER_STEP 1 +#define DEFAULT_STOP_TIME 1 + +typedef enum { + vr_time, vr_y +} ValueReference; + +typedef struct { + int y; +} ModelData; + +#endif /* config_h */ diff --git a/testsuite/resources/Resource3/sources/cosimulation.c b/testsuite/resources/Resource3/sources/cosimulation.c new file mode 100644 index 000000000..782edf1b2 --- /dev/null +++ b/testsuite/resources/Resource3/sources/cosimulation.c @@ -0,0 +1,691 @@ +#include // for calloc(), free() +#include // for DBL_EPSILON +#include +#include +#include +#include "config.h" +#include "cosimulation.h" + +#if FMI_VERSION == 3 +#include "fmi3Functions.h" +#endif + +#ifdef _MSC_VER +#define strdup _strdup +#endif + +#ifdef CALL +#undef CALL +#endif + +#define CALL(f) do { const Status status = f; if (status != OK) return status; } while (false) + + +ModelInstance *createModelInstance( + loggerType cbLogger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType) { + + ModelInstance *comp = NULL; + + if (!instanceName || strlen(instanceName) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, "?", Error, "error", "Missing instance name."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instance name."); +#endif + } + return NULL; + } + + if (!instantiationToken || strlen(instantiationToken) == 0) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Missing GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Missing instantiationToken."); +#endif + } + return NULL; + } + + if (strcmp(instantiationToken, INSTANTIATION_TOKEN)) { + if (cbLogger) { +#if FMI_VERSION < 3 + cbLogger(componentEnvironment, instanceName, Error, "error", "Wrong GUID."); +#else + cbLogger(componentEnvironment, Error, "error", "Wrong instantiationToken."); +#endif + } + return NULL; + } + + comp = (ModelInstance *)calloc(1, sizeof(ModelInstance)); + + if (comp) { + comp->componentEnvironment = componentEnvironment; + comp->logger = cbLogger; + comp->intermediateUpdate = intermediateUpdate; + comp->lockPreemption = NULL; + comp->unlockPreemption = NULL; + comp->instanceName = strdup(instanceName); + comp->resourceLocation = resourceLocation ? strdup(resourceLocation) : NULL; + comp->status = OK; + comp->logEvents = loggingOn; + comp->logErrors = true; // always log errors + comp->nSteps = 0; + comp->earlyReturnAllowed = false; + comp->eventModeUsed = false; + } + + if (!comp || !comp->instanceName) { + logError(comp, "Out of memory."); + return NULL; + } + + comp->time = 0.0; // overwrite in fmi*SetupExperiment, fmi*SetTime + comp->type = interfaceType; + + comp->state = Instantiated; + + comp->newDiscreteStatesNeeded = false; + comp->terminateSimulation = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->valuesOfContinuousStatesChanged = false; + comp->nextEventTimeDefined = false; + comp->nextEventTime = 0; + + setStartValues(comp); + + comp->isDirtyValues = true; + + return comp; +} + +void freeModelInstance(ModelInstance *comp) { + + if (!comp) return; + + if (comp->instanceName) free((void*)comp->instanceName); + + if (comp->resourceLocation) free((void*)comp->resourceLocation); + + if (comp->prez) free(comp->prez); + + if (comp->z) free(comp->z); + + if (comp->x) free(comp->x); + + if (comp->dx) free(comp->dx); + + free(comp); +} + +static Status s_reallocate(ModelInstance* comp, void** memory, size_t size) { + + if (size == 0) { + if (*memory) { + free(*memory); + } + *memory = NULL; + return OK; + } + + void* temp = realloc(*memory, size); + + if (!temp) { + logError(comp, "Failed to allocate memory."); + return Error; + } + + *memory = temp; + + return OK; +} + +Status configurate(ModelInstance* comp) { + + (void)comp; + +#ifdef HAS_EVENT_INDICATORS + comp->nz = getNumberOfEventIndicators(comp); + + if (comp->nz > 0) { + CALL(s_reallocate(comp, (void**)&comp->prez, comp->nz * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->z, comp->nz * sizeof(double))); + } + + CALL(getEventIndicators(comp, comp->prez, comp->nz)); +#endif + +#ifdef HAS_CONTINUOUS_STATES + comp->nx = getNumberOfContinuousStates(comp); + + if (comp->nx > 0) { + CALL(s_reallocate(comp, (void**)&comp->x, comp->nx * sizeof(double))); + CALL(s_reallocate(comp, (void**)&comp->dx, comp->nx * sizeof(double))); + } +#endif + + return OK; +} + +Status reset(ModelInstance* comp) { + + comp->state = Instantiated; + comp->startTime = 0.0; + comp->time = 0.0; + comp->nSteps = 0; + comp->status = OK; + setStartValues(comp); + comp->isDirtyValues = true; + + return OK; +} + +#define EPSILON (1.0e-5) + +static double fmiAbs(double v) { + return v >= 0 ? v : -v; +} + +static double fmiMax(double a, double b) { + return (a < b) ? b : a; +} + +bool isClose(double a, double b) { + + if (fmiAbs(a - b) <= EPSILON) { + return true; + } + + return fmiAbs(a - b) <= EPSILON * fmiMax(fmiAbs(a), fmiAbs(b)); +} + +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected) { + + if (actual != expected) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = %d. Expected %d.", f, arg, actual, expected); + return true; + } + + return false; +} + +bool invalidState(ModelInstance *comp, const char *f, int statesExpected) { + + UNUSED(f); + UNUSED(statesExpected); + + if (!comp) { + return true; + } + + // TODO: add missing states and check state + return false; + +// if (!(comp->state & statesExpected)) { +// comp->state = modelError; +// logError(comp, "%s: Illegal call sequence.", f); +// return true; +// } +// +// return false; +} + +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p) { + + if (!p) { + comp->state = Terminated; + logError(comp, "%s: Invalid argument %s = NULL.", f, arg); + return true; + } + + return false; +} + +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]) { + + if (nCategories > 0) { + + if (categories == NULL) { + logError(comp, "Argument categories must not be NULL."); + return Error; + } + + for (size_t i = 0; i < nCategories; i++) { + + if (categories[i] == NULL) { + logError(comp, "Argument categories[%zu] must not be NULL.", i); + return Error; + } else if (strcmp(categories[i], "logEvents") == 0) { + comp->logEvents = loggingOn; + } else if (strcmp(categories[i], "logStatusError") == 0) { + comp->logErrors = loggingOn; + } else { + logError(comp, "Log categories[%zu] must be one of \"logEvents\" or \"logStatusError\" but was \"%s\".", i, categories[i]); + return Error; + } + } + + } else { + + comp->logEvents = loggingOn; + comp->logErrors = loggingOn; + + } + + return OK; +} + +static void logMessage(ModelInstance *comp, int status, const char *category, const char *message, va_list args) { + + if (!comp->logger) { + return; + } + + va_list args1; + int len = 0; + char *buf = ""; + + va_copy(args1, args); + len = vsnprintf(buf, len, message, args1); + va_end(args1); + + if (len < 0) { + return; + } + + va_copy(args1, args); + buf = (char *)calloc(len + 1, sizeof(char)); + len = vsnprintf(buf, len + 1, message, args); + va_end(args1); + + if (len >= 0) { + // no need to distinguish between FMI versions since we're not using variadic arguments +#if FMI_VERSION < 3 + comp->logger(comp->componentEnvironment, comp->instanceName, status, category, buf); +#else + comp->logger(comp->componentEnvironment, status, category, buf); +#endif + } + + free(buf); +} + +void logEvent(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logEvents) return; + + va_list args; + va_start(args, message); + logMessage(comp, OK, "logEvents", message, args); + va_end(args); +} + +void logError(ModelInstance *comp, const char *message, ...) { + + if (!comp || !comp->logErrors) return; + + va_list args; + va_start(args, message); + logMessage(comp, Error, "logStatusError", message, args); + va_end(args); +} + +#define GET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Getting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef GET_FLOAT32 +Status getFloat32(ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t* index) { + GET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef GET_INT8 +Status getInt8(ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef GET_UINT8 +Status getUInt8(ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef GET_INT16 +Status getInt16(ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int16"); + +} +#endif + +#ifndef GET_UINT16 +Status getUInt16(ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef GET_INT32 +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef GET_UINT32 +Status getUInt32(ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef GET_INT64 +Status getInt64(ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef GET_UINT64 +Status getUInt64(ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef GET_BOOLEAN +Status getBoolean(ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef GET_STRING +Status getString(ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index) { + GET_NOT_ALLOWED("String"); +} +#endif + +#ifndef GET_BINARY +Status getBinary(ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index) { + UNUSED(sizes); + GET_NOT_ALLOWED("Binary"); +} +#endif + +#define SET_NOT_ALLOWED(t) do { \ + UNUSED(vr); \ + UNUSED(values); \ + UNUSED(nValues); \ + UNUSED(index); \ + logError(comp, "Setting " t " is not allowed.");\ + return Error; \ +} while (false) + +#ifndef SET_FLOAT32 +Status setFloat32(ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float32"); +} +#endif + +#ifndef SET_FLOAT64 +Status setFloat64(ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Float64"); +} +#endif + +#ifndef SET_INT8 +Status setInt8(ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int8"); +} +#endif + +#ifndef SET_UINT8 +Status setUInt8(ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt8"); +} +#endif + +#ifndef SET_INT16 +Status setInt16(ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int16"); +} +#endif + +#ifndef SET_UINT16 +Status setUInt16(ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt16"); +} +#endif + +#ifndef SET_INT32 +Status setInt32(ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int32"); +} +#endif + +#ifndef SET_UINT32 +Status setUInt32(ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt32"); +} +#endif + +#ifndef SET_INT64 +Status setInt64(ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Int64"); +} +#endif + +#ifndef SET_UINT64 +Status setUInt64(ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("UInt64"); +} +#endif + +#ifndef SET_BOOLEAN +Status setBoolean(ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("Boolean"); +} +#endif + +#ifndef SET_STRING +Status setString(ModelInstance* comp, ValueReference vr, const char *const values[], size_t nValues, size_t* index) { + SET_NOT_ALLOWED("String"); +} +#endif + +#ifndef SET_BINARY +Status setBinary(ModelInstance* comp, ValueReference vr, const size_t size[], const char *const values[], size_t nValues, size_t* index) { + UNUSED(size); + SET_NOT_ALLOWED("Binary"); +} +#endif + +#ifndef ACTIVATE_CLOCK +Status activateClock(ModelInstance* comp, ValueReference vr) { + UNUSED(comp); + UNUSED(vr); + return Error; +} +#endif + +#ifndef GET_CLOCK +Status getClock(ModelInstance* comp, ValueReference vr, bool* value) { + UNUSED(comp); + UNUSED(vr); + UNUSED(value); + return Error; +} +#endif + +#ifndef GET_INTERVAL +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier) { + UNUSED(comp); + UNUSED(vr); + UNUSED(interval); + UNUSED(qualifier); + return Error; +} +#endif + +#ifndef ACTIVATE_MODEL_PARTITION +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime) { + UNUSED(comp); + UNUSED(vr); + UNUSED(activationTime); + return Error; +} +#endif + +#ifndef GET_PARTIAL_DERIVATIVE +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative) { + UNUSED(comp); + UNUSED(unknown); + UNUSED(known); + UNUSED(partialDerivative); + logError(comp, "Directional derivatives are not supported."); + return Error; +} +#endif + +Status getFMUState(ModelInstance* comp, void** FMUState) { + + CALL(s_reallocate(comp, FMUState, sizeof(ModelInstance))); + + memcpy(*FMUState, comp, sizeof(ModelInstance)); + + return OK; +} + +Status setFMUState(ModelInstance* comp, void* FMUState) { + + ModelInstance* s = (ModelInstance*)FMUState; + + comp->startTime = s->startTime; + comp->stopTime = s->stopTime; + comp->time = s->time; + // instanceName + // type + // resourceLocation + + comp->status = s->status; + + // logger + // intermediateUpdate + // clockUpdate + + // lockPreemption + // unlockPreemption + + // logEvents + // logErrors + + // componentEnvironment + comp->state = s->state; + + comp->newDiscreteStatesNeeded = s->newDiscreteStatesNeeded; + comp->terminateSimulation = s->terminateSimulation; + comp->nominalsOfContinuousStatesChanged = s->nominalsOfContinuousStatesChanged; + comp->valuesOfContinuousStatesChanged = s->valuesOfContinuousStatesChanged; + comp->nextEventTimeDefined = s->nextEventTimeDefined; + comp->nextEventTime = s->nextEventTime; + comp->clocksTicked = s->clocksTicked; + + comp->isDirtyValues = s->isDirtyValues; + + comp->modelData = s->modelData; + + comp->nSteps = s->nSteps; + + comp->earlyReturnAllowed = s->earlyReturnAllowed; + comp->eventModeUsed = s->eventModeUsed; + comp->nextCommunicationPoint = s->nextCommunicationPoint; + + if (comp->nx > 0) { + memcpy(comp->x, s->x, s->nx * sizeof(double)); + memcpy(comp->dx, s->dx, s->nx * sizeof(double)); + } + + if (comp->nz > 0) { + memcpy(comp->z, s->z, s->nz * sizeof(double)); + } + + comp->nSteps = s->nSteps; + + return OK; +} + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent) { + +#ifdef HAS_CONTINUOUS_STATES + if (comp->nx > 0) { + + CALL(getContinuousStates(comp, comp->x, comp->nx)); + CALL(getDerivatives(comp, comp->dx, comp->nx)); + + // forward Euler step + for (size_t i = 0; i < comp->nx; i++) { + comp->x[i] += FIXED_SOLVER_STEP * comp->dx[i]; + } + + CALL(setContinuousStates(comp, comp->x, comp->nx)); + } +#endif + + comp->nSteps++; + + comp->time = comp->startTime + comp->nSteps * FIXED_SOLVER_STEP; + + // state event + *stateEvent = false; + +#ifdef HAS_EVENT_INDICATORS + if (comp->nz > 0) { + + CALL(getEventIndicators(comp, comp->z, comp->nz)); + + // check for zero-crossings + for (size_t i = 0; i < comp->nz; i++) { + *stateEvent |= + (comp->prez[i] <= 0 && comp->z[i] > 0) || + (comp->prez[i] > 0 && comp->z[i] <= 0); + } + + // remember the current event indicators + double* temp = comp->prez; + comp->prez = comp->z; + comp->z = temp; + } +#endif + + // time event + *timeEvent = comp->nextEventTimeDefined && comp->time >= comp->nextEventTime; + + bool earlyReturnRequested; + double earlyReturnTime; + + // intermediate update + if (comp->intermediateUpdate) { + comp->intermediateUpdate( + comp->componentEnvironment, // instanceEnvironment + comp->time, // intermediateUpdateTime + false, // intermediateVariableSetRequested + true, // intermediateVariableGetAllowed + true, // intermediateStepFinished + false, // canReturnEarly + &earlyReturnRequested, // earlyReturnRequested + &earlyReturnTime); // earlyReturnTime + } + + return OK; +} diff --git a/testsuite/resources/Resource3/sources/cosimulation.h b/testsuite/resources/Resource3/sources/cosimulation.h new file mode 100644 index 000000000..fda1ebf99 --- /dev/null +++ b/testsuite/resources/Resource3/sources/cosimulation.h @@ -0,0 +1,5 @@ +#pragma once + +#include "model.h" + +Status doFixedStep(ModelInstance *comp, bool* stateEvent, bool* timeEvent); diff --git a/testsuite/resources/Resource3/sources/fmi3Functions.c b/testsuite/resources/Resource3/sources/fmi3Functions.c new file mode 100644 index 000000000..b4ad5fbb2 --- /dev/null +++ b/testsuite/resources/Resource3/sources/fmi3Functions.c @@ -0,0 +1,1446 @@ +#if FMI_VERSION != 3 +#error FMI_VERSION must be 3 +#endif + +#include +#include +#include +#include +#include + +#include "config.h" +#include "model.h" +#include "cosimulation.h" + +// C-code FMUs have functions names prefixed with MODEL_IDENTIFIER_. +// Define DISABLE_PREFIX to build a binary FMU. +#if !defined(DISABLE_PREFIX) && !defined(FMI3_FUNCTION_PREFIX) +#define pasteA(a,b) a ## b +#define pasteB(a,b) pasteA(a,b) +#define FMI3_FUNCTION_PREFIX pasteB(MODEL_IDENTIFIER, _) +#endif +#include "fmi3Functions.h" + +#define ASSERT_NOT_NULL(p) \ +do { \ + if (!p) { \ + logError(S, "Argument %s must not be NULL.", xstr(p)); \ + S->state = Terminated; \ + return (fmi3Status)Error; \ + } \ +} while (0) + +#define CALL(f) do { \ + const Status s = f; \ + if (s > status) { \ + status = s; \ + } \ + if (status == Discard) { \ + goto TERMINATE; \ + } else if (status == Error) { \ + S->state = Terminated; \ + goto TERMINATE; \ + } else if (status == Fatal) { \ + S->state = StartAndEnd; \ + goto TERMINATE; \ + } \ +} while (false) + +#define GET_VARIABLES(T) \ +BEGIN_FUNCTION(Get ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +if (nValues > 0) ASSERT_NOT_NULL(values); \ +if (S->isDirtyValues) { \ + CALL(calculateValues(S)); \ + S->isDirtyValues = false; \ +} \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(get ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#define SET_VARIABLES(T) \ +BEGIN_FUNCTION(Set ## T); \ +if (nValueReferences == 0) goto TERMINATE; \ +ASSERT_NOT_NULL(valueReferences); \ +size_t index = 0; \ +for (size_t i = 0; i < nValueReferences; i++) { \ + CALL(set ## T(S, (ValueReference)valueReferences[i], values, nValues, &index)); \ +} \ +if (nValueReferences > 0) S->isDirtyValues = true; \ +if (index != nValues) { \ + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); \ +} \ +END_FUNCTION() + +#ifndef max +#define max(a,b) ((a)>(b) ? (a) : (b)) +#endif + +#ifndef DT_EVENT_DETECT +#define DT_EVENT_DETECT 1e-10 +#endif + +// --------------------------------------------------------------------------- +// Function calls allowed state masks for both Model-exchange and Co-simulation +// --------------------------------------------------------------------------- +#define MASK_AnyState (~0) + +/* Inquire version numbers and set debug logging */ +#define MASK_fmi3GetVersion MASK_AnyState +#define MASK_fmi3SetDebugLogging MASK_AnyState + +/* Creation and destruction of FMU instances */ +#define MASK_fmi3InstantiateInstantiateModelExchange MASK_AnyState +#define MASK_fmi3InstantiateCoSimulation MASK_AnyState +#define MASK_fmi3InstantiateScheduledExectuion MASK_AnyState +#define MASK_fmi3FreeInstance MASK_AnyState + +/* Enter and exit initialization mode, terminate and reset */ +#define MASK_fmi3EnterInitializationMode Instantiated +#define MASK_fmi3ExitInitializationMode InitializationMode +#define MASK_fmi3EnterEventMode (ContinuousTimeMode | StepMode) +#define MASK_fmi3Terminate (ContinuousTimeMode | StepMode | StepDiscarded | EventMode | ClockActivationMode | ReconfigurationMode) +#define MASK_fmi3Reset MASK_AnyState + +/* Common Functions */ + +/* Getting and setting variable values */ +#define MASK_fmi3GetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3GetFloat64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt8 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt16 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt32 MASK_fmi3GetFloat32 +#define MASK_fmi3GetInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetUInt64 MASK_fmi3GetFloat32 +#define MASK_fmi3GetBoolean MASK_fmi3GetFloat32 +#define MASK_fmi3GetString MASK_fmi3GetFloat32 +#define MASK_fmi3GetBinary MASK_fmi3GetFloat32 +#define MASK_fmi3GetClock MASK_AnyState + +#define MASK_fmi3SetFloat32 (Instantiated | InitializationMode | ConfigurationMode | ReconfigurationMode | EventMode | ContinuousTimeMode | StepMode | ClockActivationMode | IntermediateUpdateMode | Terminated) +#define MASK_fmi3SetFloat64 MASK_fmi3SetFloat32 +#define MASK_fmi3SetInt8 (Instantiated | ConfigurationMode | ReconfigurationMode | InitializationMode | EventMode | StepMode | ClockActivationMode | Terminated) +#define MASK_fmi3SetUInt8 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt16 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt32 MASK_fmi3SetInt8 +#define MASK_fmi3SetInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetUInt64 MASK_fmi3SetInt8 +#define MASK_fmi3SetBoolean MASK_fmi3SetInt8 +#define MASK_fmi3SetString MASK_fmi3SetInt8 +#define MASK_fmi3SetBinary MASK_fmi3SetInt8 +#define MASK_fmi3SetClock MASK_AnyState + +/* Getting Variable Dependency Information */ +#define MASK_fmi3GetNumberOfVariableDependencies MASK_AnyState +#define MASK_fmi3GetVariableDependencies MASK_AnyState + +/* Getting and setting the internal FMU state */ +#define MASK_fmi3GetFMUState MASK_AnyState +#define MASK_fmi3SetFMUState MASK_AnyState +#define MASK_fmi3FreeFMUState MASK_AnyState +#define MASK_fmi3SerializedFMUStateSize MASK_AnyState +#define MASK_fmi3SerializeFMUState MASK_AnyState +#define MASK_fmi3DeserializeFMUState MASK_AnyState + +/* Getting partial derivatives */ +#define MASK_fmi3GetDirectionalDerivative (InitializationMode | StepMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetAdjointDerivative MASK_fmi3GetDirectionalDerivative + +/* Entering and exiting the Configuration or Reconfiguration Mode */ +#define MASK_fmi3EnterConfigurationMode (Instantiated | StepMode | EventMode | ClockActivationMode) +#define MASK_fmi3ExitConfigurationMode (ConfigurationMode | ReconfigurationMode) + +/* Clock related functions */ +// TODO: fix masks +#define MASK_fmi3GetIntervalDecimal MASK_AnyState +#define MASK_fmi3GetIntervalFraction MASK_AnyState +#define MASK_fmi3SetIntervalDecimal MASK_AnyState +#define MASK_fmi3SetIntervalFraction MASK_AnyState +#define MASK_fmi3NewDiscreteStates MASK_AnyState + +/* Functions for Model Exchange */ + +#define MASK_fmi3EnterContinuousTimeMode EventMode +#define MASK_fmi3CompletedIntegratorStep ContinuousTimeMode + +/* Providing independent variables and re-initialization of caching */ +#define MASK_fmi3SetTime (EventMode | ContinuousTimeMode) +#define MASK_fmi3SetContinuousStates ContinuousTimeMode + +/* Evaluation of the model equations */ +#define MASK_fmi3GetContinuousStateDerivatives (InitializationMode | EventMode | ContinuousTimeMode | Terminated) +#define MASK_fmi3GetEventIndicators MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetContinuousStates MASK_fmi3GetContinuousStateDerivatives +#define MASK_fmi3GetNominalsOfContinuousStates MASK_fmi3GetContinuousStateDerivatives + +#define MASK_fmi3GetNumberOfContinuousStates MASK_AnyState +#define MASK_fmi3GetNumberOfEventIndicators MASK_AnyState + +/* Functions for Co-Simulation */ + +#define MASK_fmi3EnterStepMode (InitializationMode | EventMode) +#define MASK_fmi3SetInputDerivatives (Instantiated | InitializationMode | StepMode) +#define MASK_fmi3GetOutputDerivatives (StepMode | StepDiscarded | Terminated) +#define MASK_fmi3DoStep StepMode +#define MASK_fmi3ActivateModelPartition ClockActivationMode +#define MASK_fmi3DoEarlyReturn IntermediateUpdateMode +#define MASK_fmi3GetDoStepDiscardedStatus StepMode + +// --------------------------------------------------------------------------- +// Private helpers used below to validate function arguments +// --------------------------------------------------------------------------- + +#define NOT_IMPLEMENTED \ +do { \ + ModelInstance *comp = (ModelInstance *)instance; \ + logError(comp, "Function is not implemented."); \ + return fmi3Error; \ +} while (0) + +#define BEGIN_FUNCTION(F) \ +Status status = OK; \ +if (!instance) return fmi3Error; \ +ModelInstance *S = (ModelInstance *)instance; \ +if (!allowedState(S, MASK_fmi3##F, #F)) CALL(Error); + +#define END_FUNCTION() \ +TERMINATE: \ + return (fmi3Status)status; + +static bool allowedState(ModelInstance *instance, int statesExpected, char *name) { + + if (!instance) { + return false; + } + + if (!(instance->state & statesExpected)) { + logError(instance, "fmi3%s: Illegal call sequence.", name); + return false; + } + + return true; +} + +/*************************************************** + Common Functions + ****************************************************/ + +const char* fmi3GetVersion(void) { + return fmi3Version; +} + +fmi3Status fmi3SetDebugLogging(fmi3Instance instance, + fmi3Boolean loggingOn, + size_t nCategories, + const fmi3String categories[]) { + + BEGIN_FUNCTION(SetDebugLogging); + + CALL(setDebugLogging(S, loggingOn, nCategories, categories)); + + END_FUNCTION(); +} + +fmi3Instance fmi3InstantiateModelExchange( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage) { + + UNUSED(visible); + +#ifndef MODEL_EXCHANGE + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + + return NULL; +#else + return createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ModelExchange); +#endif +} + +fmi3Instance fmi3InstantiateCoSimulation( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3Boolean eventModeUsed, + fmi3Boolean earlyReturnAllowed, + const fmi3ValueReference requiredIntermediateVariables[], + size_t nRequiredIntermediateVariables, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3IntermediateUpdateCallback intermediateUpdate) { + + UNUSED(visible); + UNUSED(requiredIntermediateVariables); + UNUSED(nRequiredIntermediateVariables); + +#ifndef EVENT_UPDATE + if (eventModeUsed) { + if (logMessage) { + logMessage(instanceEnvironment, fmi3Error, "error", "Event Mode is not supported."); + } + return NULL; + } +#endif + + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + (intermediateUpdateType)intermediateUpdate, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + CoSimulation); + + if (instance) { + instance->earlyReturnAllowed = earlyReturnAllowed; + instance->eventModeUsed = eventModeUsed; + instance->state = Instantiated; + } + + return instance; +} + +fmi3Instance fmi3InstantiateScheduledExecution( + fmi3String instanceName, + fmi3String instantiationToken, + fmi3String resourcePath, + fmi3Boolean visible, + fmi3Boolean loggingOn, + fmi3InstanceEnvironment instanceEnvironment, + fmi3LogMessageCallback logMessage, + fmi3ClockUpdateCallback clockUpdate, + fmi3LockPreemptionCallback lockPreemption, + fmi3UnlockPreemptionCallback unlockPreemption) { + + UNUSED(visible); + +#ifndef SCHEDULED_CO_SIMULATION + + UNUSED(instanceName); + UNUSED(instantiationToken); + UNUSED(resourcePath); + UNUSED(loggingOn); + UNUSED(instanceEnvironment); + UNUSED(logMessage); + UNUSED(clockUpdate); + UNUSED(lockPreemption); + UNUSED(unlockPreemption); + + return NULL; +#else + ModelInstance *instance = createModelInstance( + (loggerType)logMessage, + NULL, + instanceEnvironment, + instanceName, + instantiationToken, + resourcePath, + loggingOn, + ScheduledExecution + ); + + if (instance) { + instance->state = Instantiated; + instance->clockUpdate = clockUpdate; + instance->lockPreemption = lockPreemption; + instance->unlockPreemption = unlockPreemption; + } + + return instance; +#endif +} + +void fmi3FreeInstance(fmi3Instance instance) { + freeModelInstance((ModelInstance*)instance); +} + +fmi3Status fmi3EnterInitializationMode(fmi3Instance instance, + fmi3Boolean toleranceDefined, + fmi3Float64 tolerance, + fmi3Float64 startTime, + fmi3Boolean stopTimeDefined, + fmi3Float64 stopTime) { + + UNUSED(toleranceDefined); + UNUSED(tolerance); + + BEGIN_FUNCTION(EnterInitializationMode); + + S->startTime = startTime; + S->stopTime = stopTimeDefined ? stopTime : INFINITY; + S->time = startTime; + S->nextCommunicationPoint = startTime; + S->state = InitializationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitInitializationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitInitializationMode); + + // if values were set and no fmi3GetXXX triggered update before, + // ensure calculated values are updated now + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = S->eventModeUsed ? EventMode : StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + + CALL(configurate(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3EnterEventMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterEventMode); + + S->state = EventMode; + + END_FUNCTION(); +} + +fmi3Status fmi3Terminate(fmi3Instance instance) { + + BEGIN_FUNCTION(Terminate); + + S->state = Terminated; + + END_FUNCTION(); +} + +fmi3Status fmi3Reset(fmi3Instance instance) { + + BEGIN_FUNCTION(Reset); + + CALL(reset(S)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float32 values[], + size_t nValues) { + GET_VARIABLES(Float32); +} + +fmi3Status fmi3GetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 values[], + size_t nValues) { + GET_VARIABLES(Float64); +} + +fmi3Status fmi3GetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int8 values[], + size_t nValues) { + GET_VARIABLES(Int8); +} + +fmi3Status fmi3GetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt8 values[], + size_t nValues) { + GET_VARIABLES(UInt8); +} + +fmi3Status fmi3GetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int16 values[], + size_t nValues) { + GET_VARIABLES(Int16); +} + +fmi3Status fmi3GetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt16 values[], + size_t nValues) { + GET_VARIABLES(UInt16); +} + +fmi3Status fmi3GetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int32 values[], + size_t nValues) { + GET_VARIABLES(Int32); +} + +fmi3Status fmi3GetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt32 values[], + size_t nValues) { + GET_VARIABLES(UInt32); +} + +fmi3Status fmi3GetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Int64 values[], + size_t nValues) { + GET_VARIABLES(Int64); +} + +fmi3Status fmi3GetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 values[], + size_t nValues) { + GET_VARIABLES(UInt64); +} + +fmi3Status fmi3GetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Boolean values[], + size_t nValues) { + GET_VARIABLES(Boolean); +} + +fmi3Status fmi3GetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3String values[], + size_t nValues) { + GET_VARIABLES(String); +} + +fmi3Status fmi3GetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + size_t valueSizes[], + fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(GetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } else { + ASSERT_NOT_NULL(valueReferences); + } + + if (nValues > 0) { + ASSERT_NOT_NULL(values); + } + + if (S->isDirtyValues) { + CALL(calculateValues(S)); + S->isDirtyValues = false; + } + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char**)values, nValues, &index)); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Clock values[]) { + + BEGIN_FUNCTION(GetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getClock(instance, (ValueReference)valueReferences[i], &values[i])); + } + END_FUNCTION(); +} + +fmi3Status fmi3SetFloat32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float32 values[], + size_t nValues) { + SET_VARIABLES(Float32); +} + +fmi3Status fmi3SetFloat64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 values[], + size_t nValues) { + SET_VARIABLES(Float64); +} + +fmi3Status fmi3SetInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int8 values[], + size_t nValues) { + SET_VARIABLES(Int8); +} + +fmi3Status fmi3SetUInt8(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt8 values[], + size_t nValues) { + SET_VARIABLES(UInt8); +} + +fmi3Status fmi3SetInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int16 values[], + size_t nValues) { + SET_VARIABLES(Int16); +} + +fmi3Status fmi3SetUInt16(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt16 values[], + size_t nValues) { + SET_VARIABLES(UInt16); +} + +fmi3Status fmi3SetInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 values[], + size_t nValues) { + SET_VARIABLES(Int32); +} + +fmi3Status fmi3SetUInt32(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt32 values[], + size_t nValues) { + SET_VARIABLES(UInt32); +} + +fmi3Status fmi3SetInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int64 values[], + size_t nValues) { + SET_VARIABLES(Int64); +} + +fmi3Status fmi3SetUInt64(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 values[], + size_t nValues) { + SET_VARIABLES(UInt64); +} + +fmi3Status fmi3SetBoolean(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Boolean values[], + size_t nValues) { + SET_VARIABLES(Boolean); +} + +fmi3Status fmi3SetString(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3String values[], + size_t nValues) { + SET_VARIABLES(String); +} + +fmi3Status fmi3SetBinary(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const size_t valueSizes[], + const fmi3Binary values[], + size_t nValues) { + + BEGIN_FUNCTION(SetBinary); + + if (nValueReferences == 0) { + goto TERMINATE; + } + + ASSERT_NOT_NULL(valueReferences); + + size_t index = 0; + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(setBinary(S, (ValueReference)valueReferences[i], valueSizes, (const char* const*)values, nValues, &index)); + } + + if (nValueReferences > 0) { + S->isDirtyValues = true; + } + + if (index != nValues) { + logError(S, "Expected nValues = %zu but was %zu.", index, nValues); \ + CALL(Error); + } + + END_FUNCTION(); +} + +fmi3Status fmi3SetClock(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Clock values[]) { + + BEGIN_FUNCTION(SetClock); + + for (size_t i = 0; i < nValueReferences; i++) { + if (values[i]) { + CALL(activateClock(instance, (ValueReference)valueReferences[i])); + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfVariableDependencies(fmi3Instance instance, + fmi3ValueReference valueReference, + size_t* nDependencies) { + UNUSED(valueReference); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetVariableDependencies(fmi3Instance instance, + fmi3ValueReference dependent, + size_t elementIndicesOfDependent[], + fmi3ValueReference independents[], + size_t elementIndicesOfIndependents[], + fmi3DependencyKind dependencyKinds[], + size_t nDependencies) { + + UNUSED(dependent); + UNUSED(elementIndicesOfDependent); + UNUSED(independents); + UNUSED(elementIndicesOfIndependents); + UNUSED(dependencyKinds); + UNUSED(nDependencies); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(GetFMUState); + + CALL(getFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3SetFMUState(fmi3Instance instance, fmi3FMUState FMUState) { + + BEGIN_FUNCTION(SetFMUState); + + if (nullPointer(S, "fmi3SetFMUState", "FMUState", FMUState)) { + return fmi3Error; + } + + CALL(setFMUState(S, FMUState)); + + END_FUNCTION(); +} + +fmi3Status fmi3FreeFMUState(fmi3Instance instance, fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(FreeFMUState); + + free(*FMUState); + + *FMUState = NULL; + + END_FUNCTION(); +} + +fmi3Status fmi3SerializedFMUStateSize(fmi3Instance instance, + fmi3FMUState FMUState, + size_t* size) { + + UNUSED(instance); + UNUSED(FMUState); + + BEGIN_FUNCTION(SerializedFMUStateSize); + + *size = sizeof(ModelInstance); + + END_FUNCTION(); +} + +fmi3Status fmi3SerializeFMUState(fmi3Instance instance, + fmi3FMUState FMUState, + fmi3Byte serializedState[], + size_t size) { + + BEGIN_FUNCTION(SerializeFMUState); + + if (nullPointer(S, "fmi3SerializeFMUState", "FMUstate", FMUState)) { + return fmi3Error; + } + + if (invalidNumber(S, "fmi3SerializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + memcpy(serializedState, FMUState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3DeserializeFMUState(fmi3Instance instance, + const fmi3Byte serializedState[], + size_t size, + fmi3FMUState* FMUState) { + + BEGIN_FUNCTION(DeserializeFMUState); + + if (invalidNumber(S, "fmi3DeserializeFMUState", "size", size, sizeof(ModelInstance))) { + return fmi3Error; + } + + if (*FMUState == NULL) { + *FMUState = calloc(1, sizeof(ModelInstance)); + if (*FMUState == NULL) { + printf("Failed to allocate memory for FMUState.\n"); + return fmi3Error; + } + } + + memcpy(*FMUState, serializedState, sizeof(ModelInstance)); + + END_FUNCTION(); +} + +fmi3Status fmi3GetDirectionalDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetDirectionalDerivative); + + // TODO: check value references + // TODO: assert nUnknowns == nDeltaOfUnknowns + // TODO: assert nKnowns == nDeltaKnowns + + for (size_t i = 0; i < nUnknowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nKnowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[i], (ValueReference)knowns[j], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetAdjointDerivative(fmi3Instance instance, + const fmi3ValueReference unknowns[], + size_t nUnknowns, + const fmi3ValueReference knowns[], + size_t nKnowns, + const fmi3Float64 seed[], + size_t nSeed, + fmi3Float64 sensitivity[], + size_t nSensitivity) { + + UNUSED(nSeed); + UNUSED(nSensitivity); + + BEGIN_FUNCTION(GetAdjointDerivative); + + // TODO: check value references + + for (size_t i = 0; i < nKnowns; i++) { + sensitivity[i] = 0; + for (size_t j = 0; j < nUnknowns; j++) { + double partialDerivative = 0; + CALL(getPartialDerivative(S, (ValueReference)unknowns[j], (ValueReference)knowns[i], &partialDerivative)); + sensitivity[i] += partialDerivative * seed[j]; + } + } + + END_FUNCTION(); +} + +fmi3Status fmi3EnterConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterConfigurationMode); + + S->state = (S->state == Instantiated) ? ConfigurationMode : ReconfigurationMode; + + END_FUNCTION(); +} + +fmi3Status fmi3ExitConfigurationMode(fmi3Instance instance) { + + BEGIN_FUNCTION(ExitConfigurationMode); + + if (S->state == ConfigurationMode) { + S->state = Instantiated; + } else { + switch (S->type) { + case ModelExchange: + S->state = EventMode; + break; + case CoSimulation: + S->state = StepMode; + break; + case ScheduledExecution: + S->state = ClockActivationMode; + break; + } + } + +#if defined(HAS_CONTINUOUS_STATES) || defined(HAS_EVENT_INDICATORS) + CALL(configurate(S)); +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 intervals[], + fmi3IntervalQualifier qualifiers[]) { + + BEGIN_FUNCTION(GetIntervalDecimal); + + // TODO: Check nValueReferences != nValues ? + + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getInterval(instance, (ValueReference)valueReferences[i], &intervals[i], (int*)&qualifiers[i])); + } + + END_FUNCTION(); +} + +fmi3Status fmi3GetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 intervalCounters[], + fmi3UInt64 resolutions[], + fmi3IntervalQualifier qualifiers[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + UNUSED(qualifiers); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3GetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + fmi3UInt64 shiftCounters[], + fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 intervals[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervals); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetIntervalFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 intervalCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(intervalCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftDecimal(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Float64 shifts[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shifts); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3SetShiftFraction(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3UInt64 shiftCounters[], + const fmi3UInt64 resolutions[]) { + + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(shiftCounters); + UNUSED(resolutions); + + NOT_IMPLEMENTED; +} + +fmi3Status fmi3EvaluateDiscreteStates(fmi3Instance instance) { + NOT_IMPLEMENTED; +} + +fmi3Status fmi3UpdateDiscreteStates(fmi3Instance instance, + fmi3Boolean* discreteStatesNeedUpdate, + fmi3Boolean* terminateSimulation, + fmi3Boolean* nominalsOfContinuousStatesChanged, + fmi3Boolean* valuesOfContinuousStatesChanged, + fmi3Boolean* nextEventTimeDefined, + fmi3Float64* nextEventTime) { + + BEGIN_FUNCTION(NewDiscreteStates); + +#ifdef EVENT_UPDATE + CALL(eventUpdate(S)); +#endif + + // copy internal eventInfo of component to output arguments + if (discreteStatesNeedUpdate) *discreteStatesNeedUpdate = S->newDiscreteStatesNeeded; + if (terminateSimulation) *terminateSimulation = S->terminateSimulation; + if (nominalsOfContinuousStatesChanged) *nominalsOfContinuousStatesChanged = S->nominalsOfContinuousStatesChanged; + if (valuesOfContinuousStatesChanged) *valuesOfContinuousStatesChanged = S->valuesOfContinuousStatesChanged; + if (nextEventTimeDefined) *nextEventTimeDefined = S->nextEventTimeDefined; + if (nextEventTime) *nextEventTime = S->nextEventTime; + + END_FUNCTION(); +} + +/*************************************************** + Functions for Model Exchange + ****************************************************/ + +fmi3Status fmi3EnterContinuousTimeMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterContinuousTimeMode); + + S->state = ContinuousTimeMode; + + END_FUNCTION(); +} + +fmi3Status fmi3CompletedIntegratorStep(fmi3Instance instance, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* enterEventMode, + fmi3Boolean* terminateSimulation) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(CompletedIntegratorStep); + + ASSERT_NOT_NULL(enterEventMode); + ASSERT_NOT_NULL(terminateSimulation); + + *enterEventMode = fmi3False; + *terminateSimulation = fmi3False; + + END_FUNCTION(); +} + +/* Providing independent variables and re-initialization of caching */ +fmi3Status fmi3SetTime(fmi3Instance instance, fmi3Float64 time) { + + BEGIN_FUNCTION(SetTime); + + S->time = time; + + END_FUNCTION(); +} + +fmi3Status fmi3SetContinuousStates(fmi3Instance instance, + const fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(SetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3SetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + ASSERT_NOT_NULL(continuousStates); + + CALL(setContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +/* Evaluation of the model equations */ +fmi3Status fmi3GetContinuousStateDerivatives(fmi3Instance instance, + fmi3Float64 derivatives[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStateDerivatives); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStateDerivatives", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStateDerivatives", "derivatives[]", derivatives)) + return fmi3Error; + + CALL(getDerivatives(S, derivatives, nContinuousStates)); +#else + UNUSED(derivatives); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetEventIndicators(fmi3Instance instance, + fmi3Float64 eventIndicators[], + size_t nEventIndicators) { + + BEGIN_FUNCTION(GetEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + if (invalidNumber(S, "fmi3GetEventIndicators", "nEventIndicators", nEventIndicators, getNumberOfEventIndicators(S))) { + return fmi3Error; + } + + CALL(getEventIndicators(S, eventIndicators, nEventIndicators)); +#else + + UNUSED(eventIndicators); + + if (nEventIndicators > 0) { + // TODO: log error + return fmi3Error; + } +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetContinuousStates(fmi3Instance instance, + fmi3Float64 continuousStates[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(S))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetContinuousStates", "continuousStates[]", continuousStates)) + return fmi3Error; + + CALL(getContinuousStates(S, continuousStates, nContinuousStates)); +#else + UNUSED(continuousStates); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNominalsOfContinuousStates(fmi3Instance instance, + fmi3Float64 nominals[], + size_t nContinuousStates) { + + BEGIN_FUNCTION(GetNominalsOfContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + if (invalidNumber(S, "fmi3GetNominalContinuousStates", "nContinuousStates", nContinuousStates, getNumberOfContinuousStates(instance))) + return fmi3Error; + + if (nullPointer(S, "fmi3GetNominalContinuousStates", "nominals[]", nominals)) + return fmi3Error; + + for (size_t i = 0; i < nContinuousStates; i++) { + nominals[i] = 1; + } + + return fmi3OK; +#else + UNUSED(nominals); + UNUSED(nContinuousStates); + return fmi3Error; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfEventIndicators(fmi3Instance instance, + size_t* nEventIndicators) { + + BEGIN_FUNCTION(GetNumberOfEventIndicators); + + ASSERT_NOT_NULL(nEventIndicators); + +#ifdef HAS_EVENT_INDICATORS + *nEventIndicators = getNumberOfEventIndicators(instance); +#else + *nEventIndicators = 0; +#endif + + + END_FUNCTION(); +} + +fmi3Status fmi3GetNumberOfContinuousStates(fmi3Instance instance, + size_t* nContinuousStates) { + + BEGIN_FUNCTION(GetNumberOfContinuousStates); + + ASSERT_NOT_NULL(nContinuousStates); + +#ifdef HAS_CONTINUOUS_STATES + *nContinuousStates = getNumberOfContinuousStates(instance); +#else + *nContinuousStates = 0; +#endif + + END_FUNCTION(); +} + +/*************************************************** + Functions for Co-Simulation + ****************************************************/ + +fmi3Status fmi3EnterStepMode(fmi3Instance instance) { + + BEGIN_FUNCTION(EnterStepMode); + + S->state = StepMode; + + END_FUNCTION(); +} + +fmi3Status fmi3GetOutputDerivatives(fmi3Instance instance, + const fmi3ValueReference valueReferences[], + size_t nValueReferences, + const fmi3Int32 orders[], + fmi3Float64 values[], + size_t nValues) { + + UNUSED(nValues); + + BEGIN_FUNCTION(GetOutputDerivatives); + +#ifdef GET_OUTPUT_DERIVATIVE + for (size_t i = 0; i < nValueReferences; i++) { + CALL(getOutputDerivative(S, (ValueReference)valueReferences[i], orders[i], &values[i])); + } +#else + UNUSED(valueReferences); + UNUSED(nValueReferences); + UNUSED(orders); + UNUSED(values); + + NOT_IMPLEMENTED; +#endif + + END_FUNCTION(); +} + +fmi3Status fmi3DoStep(fmi3Instance instance, + fmi3Float64 currentCommunicationPoint, + fmi3Float64 communicationStepSize, + fmi3Boolean noSetFMUStatePriorToCurrentPoint, + fmi3Boolean* eventHandlingNeeded, + fmi3Boolean* terminateSimulation, + fmi3Boolean* earlyReturn, + fmi3Float64* lastSuccessfulTime) { + + UNUSED(noSetFMUStatePriorToCurrentPoint); + + BEGIN_FUNCTION(DoStep); + + if (!isClose(currentCommunicationPoint, S->nextCommunicationPoint)) { + logError(S, "Expected currentCommunicationPoint = %.16g but was %.16g.", + S->nextCommunicationPoint, currentCommunicationPoint); + CALL(Error); + } + + if (communicationStepSize <= 0) { + logError(S, "Communication step size must be > 0 but was %.16g.", communicationStepSize); + CALL(Error); + } + + const fmi3Float64 nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + + if (nextCommunicationPoint > S->stopTime && !isClose(nextCommunicationPoint, S->stopTime)) { + logError(S, "At communication point %.16g a step size of %.16g was requested but stop time is %.16g.", + currentCommunicationPoint, communicationStepSize, S->stopTime); + CALL(Error); + } + + bool nextCommunicationPointReached; + + *eventHandlingNeeded = fmi3False; + *terminateSimulation = fmi3False; + *earlyReturn = fmi3False; + + while (true) { + + const fmi3Float64 nextSolverStepTime = S->time + FIXED_SOLVER_STEP; + + nextCommunicationPointReached = nextSolverStepTime > nextCommunicationPoint && !isClose(nextSolverStepTime, nextCommunicationPoint); + + if (nextCommunicationPointReached || (*eventHandlingNeeded && S->earlyReturnAllowed)) { + break; + } + +#ifdef EVENT_UPDATE + if (*eventHandlingNeeded) { + eventUpdate(S); + *eventHandlingNeeded = fmi3False; + } +#endif + + bool stateEvent, timeEvent; + + CALL(doFixedStep(S, &stateEvent, &timeEvent)); + +#ifdef EVENT_UPDATE + if (stateEvent || timeEvent) { + + if (S->eventModeUsed) { + *eventHandlingNeeded = fmi3True; + } else { + CALL(eventUpdate(S)); +#ifdef HAS_EVENT_INDICATORS + CALL(getEventIndicators(S, S->prez, S->nz)); +#endif + } + + if (S->earlyReturnAllowed) { + break; + } + } +#endif + + if (S->terminateSimulation) { + break; + } + } + + *terminateSimulation = S->terminateSimulation; + *earlyReturn = S->earlyReturnAllowed && !nextCommunicationPointReached; + *lastSuccessfulTime = S->time; + + if (nextCommunicationPointReached) { + S->nextCommunicationPoint = currentCommunicationPoint + communicationStepSize; + } else { + S->nextCommunicationPoint = S->time; + } + + END_FUNCTION(); +} + +fmi3Status fmi3ActivateModelPartition(fmi3Instance instance, + fmi3ValueReference clockReference, + fmi3Float64 activationTime) { + + BEGIN_FUNCTION(ActivateModelPartition); + + CALL(activateModelPartition(S, (ValueReference)clockReference, activationTime)); + + END_FUNCTION(); +} diff --git a/testsuite/resources/Resource3/sources/model.c b/testsuite/resources/Resource3/sources/model.c new file mode 100644 index 000000000..c6b3c820e --- /dev/null +++ b/testsuite/resources/Resource3/sources/model.c @@ -0,0 +1,160 @@ +#include "config.h" +#include "model.h" + +#include +#include +#include + +#ifdef _WIN32 +#include "shlwapi.h" +#pragma comment(lib, "shlwapi.lib") +#endif + +#define MAX_PATH_LENGTH 4096 + +void setStartValues(ModelInstance *comp) { + M(y) = 0; +} + +Status calculateValues(ModelInstance *comp) { + + // load the file + FILE *file = NULL; + char path[MAX_PATH_LENGTH] = ""; + char c = '\0'; + + if (!comp->resourceLocation) { + logError(comp, "Resource location must not be NULL."); + return Error; + } + +#ifdef _WIN32 + +#if FMI_VERSION < 3 + DWORD pathLen = MAX_PATH_LENGTH; + + if (PathCreateFromUrlA(comp->resourceLocation, path, &pathLen, 0) != S_OK) { + logError(comp, "Failed to convert resource location to file system path."); + return Error; + } +#else + strncpy(path, comp->resourceLocation, MAX_PATH_LENGTH); +#endif + +#if FMI_VERSION == 1 + if (!PathAppendA(path, "resources") || !PathAppendA(path, "y.txt")) return Error; +#elif FMI_VERSION == 2 + if (!PathAppendA(path, "y.txt")) return Error; +#else + if (!strncat(path, "y.txt", MAX_PATH_LENGTH)) return Error; +#endif + +#else + +#if FMI_VERSION < 3 + const char *scheme1 = "file:///"; + const char *scheme2 = "file:/"; + + if (strncmp(comp->resourceLocation, scheme1, strlen(scheme1)) == 0) { + strncpy(path, &comp->resourceLocation[strlen(scheme1)] - 1, MAX_PATH_LENGTH-1); + } else if (strncmp(comp->resourceLocation, scheme2, strlen(scheme2)) == 0) { + strncpy(path, &comp->resourceLocation[strlen(scheme2) - 1], MAX_PATH_LENGTH-1); + } else { + logError(comp, "The resourceLocation must start with \"file:/\" or \"file:///\""); + return Error; + } + + // decode percent encoded characters + char* src = path; + char* dst = path; + + char buf[3] = { '\0', '\0', '\0' }; + + while (*src) { + + if (*src == '%' && (buf[0] = src[1]) && (buf[1] = src[2])) { + *dst = strtol(buf, NULL, 16); + src += 3; + } else { + *dst = *src; + src++; + } + + dst++; + } + + *dst = '\0'; +#else + strncpy(path, comp->resourceLocation, MAX_PATH_LENGTH); +#endif + +#if FMI_VERSION == 1 + strncat(path, "/resources/y.txt", MAX_PATH_LENGTH-strlen(path)-1); +#elif FMI_VERSION == 2 + strncat(path, "/y.txt", MAX_PATH_LENGTH-strlen(path)-1); +#else + strncat(path, "y.txt", MAX_PATH_LENGTH-strlen(path)-1); +#endif + path[MAX_PATH_LENGTH-1] = 0; + +#endif + + // open the resource file + file = fopen (path, "r"); + + if (!file) { + logError(comp, "Failed to open resource file %s.", path); + return Error; + } + + // read the first character + c = (char)fgetc(file); + + // assign it to y + M(y) = c; + + // close the file + fclose(file); + + return OK; +} + + +Status getFloat64(ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_time: + values[(*index)++] = comp->time; + return OK; + default: + logError(comp, "Get Float64 is not allowed for value reference %u.", vr); + return Error; + } +} + + +Status getInt32(ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t* index) { + + ASSERT_NVALUES(1); + + switch (vr) { + case vr_y: + values[(*index)++] = M(y); + return OK; + default: + logError(comp, "Get Int32 is not allowed for value reference %u.", vr); + return Error; + } +} + +Status eventUpdate(ModelInstance *comp) { + + comp->valuesOfContinuousStatesChanged = false; + comp->nominalsOfContinuousStatesChanged = false; + comp->terminateSimulation = false; + comp->nextEventTimeDefined = false; + + return OK; +} diff --git a/testsuite/resources/Resource3/sources/model.h b/testsuite/resources/Resource3/sources/model.h new file mode 100644 index 000000000..8dabb0cad --- /dev/null +++ b/testsuite/resources/Resource3/sources/model.h @@ -0,0 +1,250 @@ +#pragma once + +#if FMI_VERSION != 1 && FMI_VERSION != 2 && FMI_VERSION != 3 +#error FMI_VERSION must be one of 1, 2 or 3 +#endif + +#define UNUSED(x) (void)(x) + +#include // for size_t +#include // for bool +#include + +#include "config.h" + +#if FMI_VERSION == 1 + +#define not_modelError (Instantiated| Initialized | Terminated) + +typedef enum { + Instantiated = 1<<0, + Initialized = 1<<1, + Terminated = 1<<2, + modelError = 1<<3 +} ModelState; + +#elif FMI_VERSION == 2 + +typedef enum { + StartAndEnd = 1<<0, + Instantiated = 1<<1, + InitializationMode = 1<<2, + + // ME states + EventMode = 1<<3, + ContinuousTimeMode = 1<<4, + + // CS states + StepComplete = 1<<5, + StepInProgress = 1<<6, + StepFailed = 1<<7, + StepCanceled = 1<<8, + + Terminated = 1<<9, +} ModelState; + +#else + +typedef enum { + StartAndEnd = 1 << 0, + ConfigurationMode = 1 << 1, + Instantiated = 1 << 2, + InitializationMode = 1 << 3, + EventMode = 1 << 4, + ContinuousTimeMode = 1 << 5, + StepMode = 1 << 6, + ClockActivationMode = 1 << 7, + StepDiscarded = 1 << 8, + ReconfigurationMode = 1 << 9, + IntermediateUpdateMode = 1 << 10, + Terminated = 1 << 11, +} ModelState; + +#endif + +typedef enum { + ModelExchange, + CoSimulation, + ScheduledExecution, +} InterfaceType; + +typedef enum { + OK, + Warning, + Discard, + Error, + Fatal, + Pending +} Status; + +#if FMI_VERSION < 3 +typedef void (*loggerType) (void *componentEnvironment, const char *instanceName, int status, const char *category, const char *message, ...); +#else +typedef void (*loggerType) (void *componentEnvironment, int status, const char *category, const char *message); +#endif + +typedef void (*lockPreemptionType) (void); +typedef void (*unlockPreemptionType) (void); + + +typedef void (*intermediateUpdateType) (void *instanceEnvironment, + double intermediateUpdateTime, + bool intermediateVariableSetRequested, + bool intermediateVariableGetAllowed, + bool intermediateStepFinished, + bool canReturnEarly, + bool *earlyReturnRequested, + double *earlyReturnTime); + +typedef void(*clockUpdateType) (void *instanceEnvironment); + +typedef struct { + + double startTime; + double stopTime; + double time; + const char *instanceName; + InterfaceType type; + const char *resourceLocation; + + Status status; + + // callback functions + loggerType logger; + intermediateUpdateType intermediateUpdate; + clockUpdateType clockUpdate; + + lockPreemptionType lockPreemption; + unlockPreemptionType unlockPreemption; + + bool logEvents; + bool logErrors; + + void *componentEnvironment; + ModelState state; + + // event info + bool newDiscreteStatesNeeded; + bool terminateSimulation; + bool nominalsOfContinuousStatesChanged; + bool valuesOfContinuousStatesChanged; + bool nextEventTimeDefined; + double nextEventTime; + bool clocksTicked; + + bool isDirtyValues; + + ModelData modelData; + + // internal solver steps + uint64_t nSteps; + + // Co-Simulation + bool earlyReturnAllowed; + bool eventModeUsed; + double nextCommunicationPoint; + + // solver + size_t nz; + double* z; + double* prez; + + size_t nx; + double* x; + double* dx; + +} ModelInstance; + +ModelInstance *createModelInstance( + loggerType logger, + intermediateUpdateType intermediateUpdate, + void *componentEnvironment, + const char *instanceName, + const char *instantiationToken, + const char *resourceLocation, + bool loggingOn, + InterfaceType interfaceType); + +void freeModelInstance(ModelInstance *comp); + +Status configurate(ModelInstance* comp); + +Status reset(ModelInstance* comp); + +void setStartValues(ModelInstance* comp); + +Status calculateValues(ModelInstance *comp); + +Status getFloat32 (ModelInstance* comp, ValueReference vr, float values[], size_t nValues, size_t *index); +Status getFloat64 (ModelInstance* comp, ValueReference vr, double values[], size_t nValues, size_t *index); +Status getInt8 (ModelInstance* comp, ValueReference vr, int8_t values[], size_t nValues, size_t *index); +Status getUInt8 (ModelInstance* comp, ValueReference vr, uint8_t values[], size_t nValues, size_t *index); +Status getInt16 (ModelInstance* comp, ValueReference vr, int16_t values[], size_t nValues, size_t *index); +Status getUInt16 (ModelInstance* comp, ValueReference vr, uint16_t values[], size_t nValues, size_t *index); +Status getInt32 (ModelInstance* comp, ValueReference vr, int32_t values[], size_t nValues, size_t *index); +Status getUInt32 (ModelInstance* comp, ValueReference vr, uint32_t values[], size_t nValues, size_t *index); +Status getInt64 (ModelInstance* comp, ValueReference vr, int64_t values[], size_t nValues, size_t *index); +Status getUInt64 (ModelInstance* comp, ValueReference vr, uint64_t values[], size_t nValues, size_t *index); +Status getBoolean (ModelInstance* comp, ValueReference vr, bool values[], size_t nValues, size_t *index); +Status getString (ModelInstance* comp, ValueReference vr, const char* values[], size_t nValues, size_t *index); +Status getBinary (ModelInstance* comp, ValueReference vr, size_t sizes[], const char* values[], size_t nValues, size_t *index); + +Status setFloat32 (ModelInstance* comp, ValueReference vr, const float values[], size_t nValues, size_t *index); +Status setFloat64 (ModelInstance* comp, ValueReference vr, const double values[], size_t nValues, size_t *index); +Status setInt8 (ModelInstance* comp, ValueReference vr, const int8_t values[], size_t nValues, size_t *index); +Status setUInt8 (ModelInstance* comp, ValueReference vr, const uint8_t values[], size_t nValues, size_t *index); +Status setInt16 (ModelInstance* comp, ValueReference vr, const int16_t values[], size_t nValues, size_t *index); +Status setUInt16 (ModelInstance* comp, ValueReference vr, const uint16_t values[], size_t nValues, size_t *index); +Status setInt32 (ModelInstance* comp, ValueReference vr, const int32_t values[], size_t nValues, size_t *index); +Status setUInt32 (ModelInstance* comp, ValueReference vr, const uint32_t values[], size_t nValues, size_t *index); +Status setInt64 (ModelInstance* comp, ValueReference vr, const int64_t values[], size_t nValues, size_t *index); +Status setUInt64 (ModelInstance* comp, ValueReference vr, const uint64_t values[], size_t nValues, size_t *index); +Status setBoolean (ModelInstance* comp, ValueReference vr, const bool values[], size_t nValues, size_t *index); +Status setString (ModelInstance* comp, ValueReference vr, const char* const values[], size_t nValues, size_t *index); +Status setBinary (ModelInstance* comp, ValueReference vr, const size_t sizes[], const char* const values[], size_t nValues, size_t *index); + +Status activateClock(ModelInstance* comp, ValueReference vr); +Status getClock(ModelInstance* comp, ValueReference vr, bool* value); +Status setClock(ModelInstance* comp, ValueReference vr, const bool* value); + +Status getInterval(ModelInstance* comp, ValueReference vr, double* interval, int* qualifier); + +Status activateModelPartition(ModelInstance* comp, ValueReference vr, double activationTime); + +size_t getNumberOfEventIndicators(ModelInstance* comp); +size_t getNumberOfContinuousStates(ModelInstance* comp); +Status getContinuousStates(ModelInstance *comp, double x[], size_t nx); +Status setContinuousStates(ModelInstance *comp, const double x[], size_t nx); +Status getDerivatives(ModelInstance *comp, double dx[], size_t nx); +Status getOutputDerivative(ModelInstance *comp, ValueReference valueReference, int order, double *value); +Status getPartialDerivative(ModelInstance *comp, ValueReference unknown, ValueReference known, double *partialDerivative); +Status getEventIndicators(ModelInstance *comp, double z[], size_t nz); +Status eventUpdate(ModelInstance *comp); + +bool isClose(double a, double b); +bool invalidNumber(ModelInstance *comp, const char *f, const char *arg, size_t actual, size_t expected); +bool invalidState(ModelInstance *comp, const char *f, int statesExpected); +bool nullPointer(ModelInstance* comp, const char *f, const char *arg, const void *p); +void logError(ModelInstance *comp, const char *message, ...); +Status setDebugLogging(ModelInstance *comp, bool loggingOn, size_t nCategories, const char * const categories[]); +void logEvent(ModelInstance *comp, const char *message, ...); +void logError(ModelInstance *comp, const char *message, ...); + +Status getFMUState(ModelInstance* comp, void** FMUState); +Status setFMUState(ModelInstance* comp, void* FMUState); + +// shorthand to access the variables +#define M(v) (comp->modelData.v) + +// "stringification" macros +#define xstr(s) str(s) +#define str(s) #s + +// assert size of nValues for scalar variables +#define ASSERT_NVALUES(N) do { \ + const size_t expected_nValues = *index + (N); \ + if (expected_nValues > nValues) { \ + logError(comp, "Expected nValues >= %zu but was %zu.", expected_nValues, nValues); \ + return Error; \ + } \ +} while (0) From 6e5c87ef6b9019d173caa1cc867c6a9b3563583c Mon Sep 17 00:00:00 2001 From: arun3688 Date: Fri, 3 Jan 2025 12:44:28 +0100 Subject: [PATCH 14/32] implement fmi3 initial attribute table --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 7efd72686..a35b43125 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 7efd726863a9eb0317139bc15128d735e86c62fc +Subproject commit a35b43125ec8c9dee06a3eeedb646457f4dec38c From 2cdbdbfba8dd4ef369372c6b7c81d4837c6e50c1 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Sat, 4 Jan 2025 12:06:34 +0100 Subject: [PATCH 15/32] attempts to fix memory leaks --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index a35b43125..8beb8a326 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit a35b43125ec8c9dee06a3eeedb646457f4dec38c +Subproject commit 8beb8a32687f76a74bd1139a26f6c994b194d3bd From 320f82faf1a7719f8d93edbadb6e02d6c47585db Mon Sep 17 00:00:00 2001 From: arun3688 Date: Sat, 4 Jan 2025 12:21:43 +0100 Subject: [PATCH 16/32] do not free memory multiple times --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 8beb8a326..4a440181d 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 8beb8a32687f76a74bd1139a26f6c994b194d3bd +Subproject commit 4a440181d01140dca15eda607f2eeb859f9e9222 From 6e07b64ea13acd2819f9022ae4c84984026dcfa2 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 8 Jan 2025 15:22:27 +0100 Subject: [PATCH 17/32] fix memory leaks in parseModelStructureElement() --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 4a440181d..bd07ff661 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 4a440181d01140dca15eda607f2eeb859f9e9222 +Subproject commit bd07ff661717c1c85eb7ef1afc9c048d93bcedca From 4acc0286b6ec067d004114272877e0356a550ce3 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 8 Jan 2025 15:31:31 +0100 Subject: [PATCH 18/32] expected output --- testsuite/reference-fmus/3.0/Stair.lua | 2 -- 1 file changed, 2 deletions(-) diff --git a/testsuite/reference-fmus/3.0/Stair.lua b/testsuite/reference-fmus/3.0/Stair.lua index 3884505cd..b4a85db48 100644 --- a/testsuite/reference-fmus/3.0/Stair.lua +++ b/testsuite/reference-fmus/3.0/Stair.lua @@ -34,8 +34,6 @@ else end -- Result: --- info: vars: time --- info: vars: counter -- Loading FMI version 3... -- info: Result file: Stair-cs.mat (bufferSize=1) -- signal counter is equal From 331353e43ce9e6abb3a3193bf53251d1229a9ad5 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Mon, 13 Jan 2025 11:52:27 +0100 Subject: [PATCH 19/32] update 3rdParty --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index bd07ff661..7a294362a 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit bd07ff661717c1c85eb7ef1afc9c048d93bcedca +Subproject commit 7a294362a49f81a1d9978731f00b97c0fe4d7209 From 41ff063efa6b368e6077a3ea891d5d32c57d3eb4 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Tue, 14 Jan 2025 00:08:34 +0100 Subject: [PATCH 20/32] fix variable indexing --- src/OMSimulatorLib/FMUInfo.cpp | 5 ++--- src/OMSimulatorLib/Variable.cpp | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/OMSimulatorLib/FMUInfo.cpp b/src/OMSimulatorLib/FMUInfo.cpp index c1ffdcbba..5aae67546 100644 --- a/src/OMSimulatorLib/FMUInfo.cpp +++ b/src/OMSimulatorLib/FMUInfo.cpp @@ -65,7 +65,6 @@ oms::FMUInfo::~FMUInfo() if (this->author) delete[] this->author; if (this->copyright) delete[] this->copyright; if (this->description) delete[] this->description; - if (this->fmiVersion) delete[] this->fmiVersion; if (this->generationDateAndTime) delete[] this->generationDateAndTime; if (this->generationTool) delete[] this->generationTool; if (this->guid) delete[] this->guid; @@ -104,7 +103,7 @@ void oms::FMUInfo::updateFMI2Info(fmiHandle* fmu) this->author = allocateAndCopyString(fmi2_getAuthor(fmu)); this->copyright = allocateAndCopyString(fmi2_getCopyright(fmu)); this->description = allocateAndCopyString(fmi2_getModelDescription(fmu)); - this->fmiVersion = allocateAndCopyString(fmi2_getFmiVersion(fmu)); + this->fmiVersion = "2.0"; this->generationDateAndTime = allocateAndCopyString(fmi2_getGenerationDateAndTime(fmu)); this->generationTool = allocateAndCopyString(fmi2_getGenerationTool(fmu)); this->guid = allocateAndCopyString(fmi2_getGuid(fmu)); @@ -150,7 +149,7 @@ void oms::FMUInfo::updateFMI3Info(fmiHandle* fmu) this->author = allocateAndCopyString(fmi3_author(fmu)); this->copyright = allocateAndCopyString(fmi3_copyright(fmu)); this->description = allocateAndCopyString(fmi3_description(fmu)); - this->fmiVersion = allocateAndCopyString(fmi3_getFmiVersion(fmu)); + this->fmiVersion = "3.0"; this->generationDateAndTime = allocateAndCopyString(fmi3_generationDateAndTime(fmu)); this->generationTool = allocateAndCopyString(fmi3_generationTool(fmu)); this->guid = allocateAndCopyString(fmi3_instantiationToken(fmu)); diff --git a/src/OMSimulatorLib/Variable.cpp b/src/OMSimulatorLib/Variable.cpp index 0007b58b9..7a86bfdda 100644 --- a/src/OMSimulatorLib/Variable.cpp +++ b/src/OMSimulatorLib/Variable.cpp @@ -113,7 +113,7 @@ void oms::Variable::configureFMI2Variable(fmiHandle* fmi4c, int index_) void oms::Variable::configureFMI3Variable(fmiHandle* fmi4c, int index_) { // extract the attributes - fmi3VariableHandle *var = fmi3_getVariableByIndex(fmi4c, index_); + fmi3VariableHandle *var = fmi3_getVariableByIndex(fmi4c, index_+1); cref = fmi3_getVariableName(var); description = fmi3_getVariableDescription(var) ? fmi3_getVariableDescription(var) : ""; trim(description); From 7acd2439f7c56a1534c8b1f8e44fe00f8a1928fb Mon Sep 17 00:00:00 2001 From: arun3688 Date: Tue, 14 Jan 2025 00:08:59 +0100 Subject: [PATCH 21/32] update fmi4c library --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 7a294362a..6de8220ba 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 7a294362a49f81a1d9978731f00b97c0fe4d7209 +Subproject commit 6de8220badb07cc65f9b1993714695e45f0c0878 From 270ed45c016e88cdcc04aa018d6c615ea03d0236 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Tue, 14 Jan 2025 00:30:32 +0100 Subject: [PATCH 22/32] fix fmi2_getVariableByIndex --- src/OMSimulatorLib/ComponentFMU3CS.cpp | 2 +- src/OMSimulatorLib/ComponentFMUCS.cpp | 2 +- src/OMSimulatorLib/ComponentFMUME.cpp | 2 +- src/OMSimulatorLib/Variable.cpp | 2 +- 4 files changed, 4 insertions(+), 4 deletions(-) diff --git a/src/OMSimulatorLib/ComponentFMU3CS.cpp b/src/OMSimulatorLib/ComponentFMU3CS.cpp index 203098954..4a29bdb41 100644 --- a/src/OMSimulatorLib/ComponentFMU3CS.cpp +++ b/src/OMSimulatorLib/ComponentFMU3CS.cpp @@ -464,7 +464,7 @@ oms_status_enu_t oms::ComponentFMU3CS::initializeDependencyGraph_initialUnknowns for (const auto &it : values.modelStructureInitialUnknowns) { const Variable &var_oms = allVariables[it.first - 1]; - fmi3VariableHandle *var = fmi3_getVariableByIndex(fmu, (it.first - 1)); + fmi3VariableHandle *var = fmi3_getVariableByIndex(fmu, (it.first)); oms::ComRef name_fmilib = fmi3_getVariableName(var); // std::cout << "\nDebug: " << var_oms.getCref().c_str() << "===>" << name_fmilib.c_str() << "===>" << var_oms.isInitialUnknown(); if (var_oms.getCref() != name_fmilib) diff --git a/src/OMSimulatorLib/ComponentFMUCS.cpp b/src/OMSimulatorLib/ComponentFMUCS.cpp index 45705fe75..257b9bb58 100644 --- a/src/OMSimulatorLib/ComponentFMUCS.cpp +++ b/src/OMSimulatorLib/ComponentFMUCS.cpp @@ -462,7 +462,7 @@ oms_status_enu_t oms::ComponentFMUCS::initializeDependencyGraph_initialUnknowns( for (const auto &it : values.modelStructureInitialUnknowns) { const Variable &var_oms = allVariables[it.first - 1]; - fmi2VariableHandle *var = fmi2_getVariableByIndex(fmu, (it.first - 1)); + fmi2VariableHandle *var = fmi2_getVariableByIndex(fmu, (it.first)); oms::ComRef name_fmilib = fmi2_getVariableName(var); // std::cout << "\nDebug: " << var_oms.getCref().c_str() << "===>" << name_fmilib.c_str() << "===>" << var_oms.isInitialUnknown(); if (var_oms.getCref() != name_fmilib) diff --git a/src/OMSimulatorLib/ComponentFMUME.cpp b/src/OMSimulatorLib/ComponentFMUME.cpp index 7e9f8e906..8a9febbe5 100644 --- a/src/OMSimulatorLib/ComponentFMUME.cpp +++ b/src/OMSimulatorLib/ComponentFMUME.cpp @@ -460,7 +460,7 @@ oms_status_enu_t oms::ComponentFMUME::initializeDependencyGraph_initialUnknowns( for (const auto &it : values.modelStructureInitialUnknowns) { const Variable &var_oms = allVariables[it.first - 1]; - fmi2VariableHandle *var = fmi2_getVariableByIndex(fmu, (it.first - 1)); + fmi2VariableHandle *var = fmi2_getVariableByIndex(fmu, (it.first)); oms::ComRef name_fmilib = fmi2_getVariableName(var); // std::cout << "\nDebug: " << var_oms.getCref().c_str() << "===>" << name_fmilib.c_str() << "===>" << var_oms.isInitialUnknown(); if (var_oms.getCref() != name_fmilib) diff --git a/src/OMSimulatorLib/Variable.cpp b/src/OMSimulatorLib/Variable.cpp index 7a86bfdda..a963470e9 100644 --- a/src/OMSimulatorLib/Variable.cpp +++ b/src/OMSimulatorLib/Variable.cpp @@ -61,7 +61,7 @@ oms::Variable::Variable(fmiHandle* fmi4c, int index_, oms_component_enu_t compon void oms::Variable::configureFMI2Variable(fmiHandle* fmi4c, int index_) { // extract the attributes - fmi2VariableHandle *var = fmi2_getVariableByIndex(fmi4c, index_); + fmi2VariableHandle *var = fmi2_getVariableByIndex(fmi4c, index_+1); cref = fmi2_getVariableName(var); description = fmi2_getVariableDescription(var) ? fmi2_getVariableDescription(var) : ""; trim(description); From f61cdc1b67ee5dab61e3979b46f184f97ff8fa37 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 14:39:42 +0100 Subject: [PATCH 23/32] fix deleting directory error messages --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 6de8220ba..9b744e3c6 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 6de8220badb07cc65f9b1993714695e45f0c0878 +Subproject commit 9b744e3c6d26430b9815c0fbf68ac010eba9bf35 From 4642c5ce7fc572475ac35657a86b6c2d0700852e Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 14:49:23 +0100 Subject: [PATCH 24/32] update fmi4c --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 9b744e3c6..1f81c9932 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 9b744e3c6d26430b9815c0fbf68ac010eba9bf35 +Subproject commit 1f81c99327afbc596a5d23d2b3b1391916f56c71 From 4383454a782007cbca34024d270066b6a01ca667 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 15:24:59 +0100 Subject: [PATCH 25/32] update fmi4c --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 1f81c9932..5c6c94dd2 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 1f81c99327afbc596a5d23d2b3b1391916f56c71 +Subproject commit 5c6c94dd264b175f94267fed37a3a9d5c60a9e14 From 98e38312167ac132f79dda3948c60a8ffc9ce61c Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 15:41:48 +0100 Subject: [PATCH 26/32] update fmi4c --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 5c6c94dd2..a6d019472 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 5c6c94dd264b175f94267fed37a3a9d5c60a9e14 +Subproject commit a6d019472e628cf7b91bd5736452ef287b15cf8b From 42e4fd4e1e32e71b05de2534734bca0928ff46f1 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 22:25:59 +0100 Subject: [PATCH 27/32] unpack the fmu in temp directory and load fmi handle from unpacked location --- 3rdParty | 2 +- src/OMSimulatorLib/ComponentFMU3CS.cpp | 8 +++++--- src/OMSimulatorLib/ComponentFMUCS.cpp | 8 +++++--- src/OMSimulatorLib/ComponentFMUME.cpp | 8 ++++++-- src/OMSimulatorLib/Scope.h | 1 - 5 files changed, 17 insertions(+), 10 deletions(-) diff --git a/3rdParty b/3rdParty index a6d019472..3d22abe33 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit a6d019472e628cf7b91bd5736452ef287b15cf8b +Subproject commit 3d22abe3381580db2d9ed0764924ee5b4c361cc6 diff --git a/src/OMSimulatorLib/ComponentFMU3CS.cpp b/src/OMSimulatorLib/ComponentFMU3CS.cpp index 4a29bdb41..4588ea1b0 100644 --- a/src/OMSimulatorLib/ComponentFMU3CS.cpp +++ b/src/OMSimulatorLib/ComponentFMU3CS.cpp @@ -38,6 +38,7 @@ #include "ssd/Tags.h" #include "System.h" #include "SystemWC.h" +#include "Scope.h" #include #include @@ -134,10 +135,11 @@ oms::Component* oms::ComponentFMU3CS::NewComponent(const oms::ComRef& cref, oms: } } - // TODO check for fmu already unpacked or not and read directly modeldescription.xml from unpacked resources + // unpack the fmu in temp directory + oms::Scope::miniunz(modelDescriptionPath.generic_string().c_str(), tempDir.generic_string().c_str()); - // load the fmu and parse modelDescription.xml - component->fmu = fmi4c_loadFmu(absFMUPath.string().c_str(), tempDir.generic_string().c_str()); + // load the unpacked fmu and parse modelDescription.xml + component->fmu = fmi4c_loadUnzippedFmu(cref.c_str(), tempDir.generic_string().c_str()); if (!component->fmu) { logError("Error parsing modelDescription.xml"); diff --git a/src/OMSimulatorLib/ComponentFMUCS.cpp b/src/OMSimulatorLib/ComponentFMUCS.cpp index 257b9bb58..ee95f5931 100644 --- a/src/OMSimulatorLib/ComponentFMUCS.cpp +++ b/src/OMSimulatorLib/ComponentFMUCS.cpp @@ -38,6 +38,7 @@ #include "ssd/Tags.h" #include "System.h" #include "SystemWC.h" +#include "Scope.h" #include #include @@ -135,10 +136,11 @@ oms::Component* oms::ComponentFMUCS::NewComponent(const oms::ComRef& cref, oms:: } } - // TODO check for fmu already unpacked or not and read directly modeldescription.xml from unpacked resources + // unpack the fmu in temp directory + oms::Scope::miniunz(modelDescriptionPath.generic_string().c_str(), tempDir.generic_string().c_str()); - // load the fmu and parse modelDescription.xml - component->fmu = fmi4c_loadFmu(absFMUPath.string().c_str(), tempDir.generic_string().c_str()); + // load the unpacked fmu and parse modelDescription.xml + component->fmu = fmi4c_loadUnzippedFmu(cref.c_str(), tempDir.generic_string().c_str()); if (!component->fmu) { logError("Error parsing modelDescription.xml"); diff --git a/src/OMSimulatorLib/ComponentFMUME.cpp b/src/OMSimulatorLib/ComponentFMUME.cpp index 8a9febbe5..2eae05661 100644 --- a/src/OMSimulatorLib/ComponentFMUME.cpp +++ b/src/OMSimulatorLib/ComponentFMUME.cpp @@ -38,6 +38,7 @@ #include "ssd/Tags.h" #include "System.h" #include "SystemSC.h" +#include "Scope.h" #include #include @@ -133,8 +134,11 @@ oms::Component* oms::ComponentFMUME::NewComponent(const oms::ComRef& cref, oms:: } } - // load the fmu and parse modelDescription.xml - component->fmu = fmi4c_loadFmu(absFMUPath.string().c_str(), tempDir.generic_string().c_str()); + // unpack the fmu in temp directory + oms::Scope::miniunz(modelDescriptionPath.generic_string().c_str(), tempDir.generic_string().c_str()); + + // load the unpacked fmu and parse modelDescription.xml + component->fmu = fmi4c_loadUnzippedFmu(cref.c_str(), tempDir.generic_string().c_str()); if (!component->fmu) { logError("Error parsing modelDescription.xml"); diff --git a/src/OMSimulatorLib/Scope.h b/src/OMSimulatorLib/Scope.h index 57cd11d19..d7db2fd18 100644 --- a/src/OMSimulatorLib/Scope.h +++ b/src/OMSimulatorLib/Scope.h @@ -76,7 +76,6 @@ namespace oms const std::string& getTempDirectory() const {return GetInstance().tempDir;} const std::string& getWorkingDirectory(); - protected: static oms_status_enu_t miniunz(const std::string& filename, const std::string& extractdir); private: From 6d2cd8cd102bd3c38d26c15e8d15b31c041c413b Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 23:03:05 +0100 Subject: [PATCH 28/32] fix memory leaks in parseModelStructureElementFMI3() --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 3d22abe33..fc2835fbd 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 3d22abe3381580db2d9ed0764924ee5b4c361cc6 +Subproject commit fc2835fbd26b358023c5061db738bba3dc08b6e9 From e390b5d45111cf8df9236b43152348e980dd3d8f Mon Sep 17 00:00:00 2001 From: arun3688 Date: Wed, 15 Jan 2025 23:29:54 +0100 Subject: [PATCH 29/32] fix function call --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index fc2835fbd..a9acdc099 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit fc2835fbd26b358023c5061db738bba3dc08b6e9 +Subproject commit a9acdc099fd858f6c4158dbc68b6b9f6ab5a0d8e From 9a28dade6a66191ddd95b4c60f060b0736571195 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 16 Jan 2025 00:06:02 +0100 Subject: [PATCH 30/32] fix fmiVersion --- src/OMSimulatorLib/FMUInfo.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/OMSimulatorLib/FMUInfo.cpp b/src/OMSimulatorLib/FMUInfo.cpp index 5aae67546..193eca2ac 100644 --- a/src/OMSimulatorLib/FMUInfo.cpp +++ b/src/OMSimulatorLib/FMUInfo.cpp @@ -65,6 +65,7 @@ oms::FMUInfo::~FMUInfo() if (this->author) delete[] this->author; if (this->copyright) delete[] this->copyright; if (this->description) delete[] this->description; + if (this->fmiVersion) delete[] this->fmiVersion; if (this->generationDateAndTime) delete[] this->generationDateAndTime; if (this->generationTool) delete[] this->generationTool; if (this->guid) delete[] this->guid; @@ -103,7 +104,7 @@ void oms::FMUInfo::updateFMI2Info(fmiHandle* fmu) this->author = allocateAndCopyString(fmi2_getAuthor(fmu)); this->copyright = allocateAndCopyString(fmi2_getCopyright(fmu)); this->description = allocateAndCopyString(fmi2_getModelDescription(fmu)); - this->fmiVersion = "2.0"; + this->fmiVersion = allocateAndCopyString("2.0"); this->generationDateAndTime = allocateAndCopyString(fmi2_getGenerationDateAndTime(fmu)); this->generationTool = allocateAndCopyString(fmi2_getGenerationTool(fmu)); this->guid = allocateAndCopyString(fmi2_getGuid(fmu)); @@ -149,7 +150,7 @@ void oms::FMUInfo::updateFMI3Info(fmiHandle* fmu) this->author = allocateAndCopyString(fmi3_author(fmu)); this->copyright = allocateAndCopyString(fmi3_copyright(fmu)); this->description = allocateAndCopyString(fmi3_description(fmu)); - this->fmiVersion = "3.0"; + this->fmiVersion = allocateAndCopyString("3.0"); this->generationDateAndTime = allocateAndCopyString(fmi3_generationDateAndTime(fmu)); this->generationTool = allocateAndCopyString(fmi3_generationTool(fmu)); this->guid = allocateAndCopyString(fmi3_instantiationToken(fmu)); From 4d6238278925b52659864f1a5c76e26e6ba6ae53 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 16 Jan 2025 15:46:12 +0100 Subject: [PATCH 31/32] upodate fmi4c with master --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index a9acdc099..93d23da94 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit a9acdc099fd858f6c4158dbc68b6b9f6ab5a0d8e +Subproject commit 93d23da943534ec7df26dd8e9d046a88bef3846c From c9356c52b92e0bcb582db50548aede923bf8aba2 Mon Sep 17 00:00:00 2001 From: arun3688 Date: Thu, 16 Jan 2025 16:01:14 +0100 Subject: [PATCH 32/32] update fmi4c with OMSimulator 3rdparty master --- 3rdParty | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/3rdParty b/3rdParty index 93d23da94..a02920206 160000 --- a/3rdParty +++ b/3rdParty @@ -1 +1 @@ -Subproject commit 93d23da943534ec7df26dd8e9d046a88bef3846c +Subproject commit a02920206760dc51dc7ca33b908d3330916184f4
+ +

VanDerPol

+ +

The model implements the Van der Pol oscillator.

+ +
der(x0) = x1
+der(x1) = mu * ((1 - x0 * x0) * x1) - x0
+
+ + +

with the variables

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
VariableStartUnitCausalityVariabilityDescription
timeindependentcontinuousSimulation time
x02outputcontinuousthe first state
der(x0)localcontinuous
x10outputcontinuousthe second state
der(x1)localcontinuous
mu1parameterfixed
+ +

The plot shows the trajectories of the output variables computed with fmusim.

+ + 
fmusim --interface-type me --solver cvode --output-interval 0.2 --output-file VanDerPol_out.csv VanDerPol.fmu
+ +

plot

+ +