Hierarchical Engine for Large-scale Infrastructure Co-Simulation (HELICS)

Overview

A multi-language, cross-platform library that enables different simulators to easily exchange data and stay synchronized in time. Scalable from two simulators on a laptop to 100,000+ running on supercomputers, the cloud, or a mix of these platforms.

Cirrus Status Drone IO Status Releases pre-commit.ci status

Table of contents

Introduction

Welcome to the repository for the Hierarchical Engine for Large-scale Infrastructure Co-Simulation (HELICS). HELICS provides a general-purpose, modular, highly-scalable co-simulation framework that runs cross-platform and has bindings for multiple languages. It is a library that enables multiple existing simulation tools (and/or instances of the same tool), known as "federates", to exchange data during runtime and stay synchronized in time such that together they act as one large simulation, or "federation". This enables bringing together simulation tools from multiple domains to form a complex software simulation without having to change the individual tools.

It is important to note that HELICS cannot in and of itself simulate anything, rather it is a framework to make it easy to bring together other existing (or novel) simulation tools to tackle problems that can't readily be solved by a single tool alone. After all "simulations are better together," and HELICS is designed to help get you there easily and quickly. HELICS has also already worked out many of the more subtle aspects of synchronizing simulations so you don't have to.

Today the core uses of HELICS are in the energy domain, where there is extensive and growing support for a wide-range of electric power system, natural gas, communications and control-schemes, transportation, buildings, and related domain tools (Supported Tools). However, it is possible to use HELICS for co-simulation in any domain; the HELICS API and language bindings make it straightforward to connect any simulation tool that provides a scripting interface or access to source code.

Previous and existing use cases have stretched across a wide range of scales in time and spatial area, from transient dynamics to long-term planning studies, and from individual appliance behavior to nation-wide simulations.

Getting Started

The users guide has been completely redone for the release of HELICS 3.0. The docs are mostly completed to align with this release. We suggest starting here if you are looking for more information on HELICS, whether it is for getting started, or learning about more advanced features, the new documentation should have something for everyone (Please let us know if it doesn't via or by creating an issue on github).

The Orientation goes through a series of examples that step through the basic usage and concepts of HELICS.

You can also Try HELICS online without having to install any software.

Earlier we also created a series of roughly 10-minute mini-tutorial videos that discuss various design topics, concepts, and interfaces, including how to use the tool. They can be found on our YouTube channel. These videos do not reflect recent HELICS advances but do introduce some basic concepts.

Several examples of HELICS federates and projects are located in HELICS-Examples. This repo provides a number of examples using the different libraries and interfaces, including those used in the user guide.

The HELICS-Tutorial repository provides a series of tutorials using HELICS to build a co-simulation using domain-specific external modeling tools that is built around an electric power system use case with integrated transmission-distribution-market-communication quasi-steady-state-timeseries (QSTS) simulation.

The HELICS-Use-Cases repository includes examples for a growing range of research use cases for inspiration.

A Tutorial was prepared for the IEEE PES General meeting in Atlanta. The example materials are available on Binder.

Language Bindings

HELICS provides a rich set of APIs for other languages including Python, C, Java, Octave, Julia, and Matlab. nim and C# APIs are available on an experimental basis, and with an active open-source community, the set of supported languages is growing all the time.

Documentation

Our ReadTheDocs site provides a set of documentation including a set of introductory examples, a developers guide, complete Doxygen generated API documentation, API references for the supported languages. A few more questions and answers are available on the Wiki.

Installation Guide

Documentation downloads

Additionally, our initial design requirements document can be found here, which describes a number of our early design considerations and some directions that might be possible in the future.

CHANGELOG

A history of changes to HELICS

ROADMAP

A snapshot of some current plans for what is to come.

Installation

A guide to installing HELICS on different platforms

Quick links

Docker

Some of the HELICS apps are available from docker. This image does not include any libraries for linking just the executables. helics_broker, helics_app, helics_recorder, helics_player, and helics_broker_server. Other images are expected to be available in the future. See Docker for a few more details.

Tools with HELICS support

As a co-simulation framework, HELICS is designed to bring together domain-specific modeling tools so they interact during run time. It effectively tries to build on the shoulders of giants by not reinventing trusted simulation tools, but instead, merely acting as a mediator to coordinate such interactions. HELICS's full power is only apparent when you use it to combine these domain-specific tools.

Thankfully the HELICS API is designed to be minimally invasive and make it straightforward to connect most any tool that provides either a scripting interface or access to source code. As listed on Tools using HELICS, a growing set of energy domain tools have HELICS support either natively or through an external interface. We also provide a set of helper apps for various utility and testing purposes.

We are always looking for help adding support for more tools, so please contact us if you have any additions.

Supported Tools

HELICS helper Apps

  • HELICS CLI provides a simple way to automate configuring, starting, and stopping HELICS co-simulations. This helps in overcoming the challenges associated with successfully sequencing and starting simulations of all sizes and is particularly helpful for larger simulations.
  • Broker, which is a command line tool for running a Broker, the core hub in HELICS for data exchange. One or more brokers are what tie the simulation tools together in a HELICS federation. There is also a Broker Server which can generate brokers as needed, and can include a REST API.
  • Player, which acts as a simple send-only federate that simply publishes a stream of timed HELICS messages from a user-defined file. This can be very useful when testing a federate in isolation by mimicking the data that will eventually come from other sources, and in assembling or debugging federations to stand in for any federates which might not be quite ready or that take a long time to run. The Player can also readily playback the files created by the HELICS Recorder (see below). HELICS Player is included in the HELICS distribution.
  • Recorder, which acts as a simple receive-only federate that prints out or saves messages from one or more subscribed streams. This makes it easy to monitor some or all of the data exchanged via HELICS and can also be part of debugging and modular workflows. For example it can record the data exchanged during a (partly?) successful run to play back (see Player above) to other federates without having to launch those parts again or to isolate/test changes to a subset of a federation. HELICS Recorder is included in the HELICS distribution.
  • App is a general app executable which can run a number of other apps including Player and Recorder, as well as a Tracer, Echo, Source, and Clone.

Contributing

Contributors are welcome, see the Contributing guidelines for more details on the process of contributing. See the Code of Conduct for guidelines on the community expectations. All prior contributors can be found here along with a listing of included and optional components to HELICS.

Build Status

Click to expand!
Service Main Develop helics2
Travis CI Build Status Build Status Build Status
Azure Build Status Build Status Build Status
Circle-CI Build Status Build Status Build Status
Docs docs docs docs

Publications

If you use HELICS in your research, please cite:

[1] B. Palmintier, D. Krishnamurthy, P. Top, S. Smith, J. Daily, and J. Fuller, “Design of the HELICS High-Performance Transmission-Distribution-Communication-Market Co-Simulation Framework,” in Proc. of the 2017 Workshop on Modeling and Simulation of Cyber-Physical Energy Systems, Pittsburgh, PA, 2017. pre-print | published

In the News

HELICS was selected as an R&D 100 Award Finalist.

History and Motivation

Brief History: HELICS began as the core software development of the Grid Modernization Laboratory Consortium (GMLC) project on integrated Transmission-Distribution-Communication simulation (TDC, GMLC project 1.4.15) supported by the U.S. Department of Energy's Offices of Electricity (OE) and Energy Efficiency and Renewable Energy (EERE). As such, its first use cases were around modern electric power systems, though today it is used for a much larger range of applications. HELICS's layered, high-performance, co-simulation framework builds on the collective experience of multiple national labs.

Motivation: Energy systems and their associated information and communication technology systems are becoming increasingly intertwined. As a result, effectively designing, analyzing, and implementing modern energy systems increasingly relies on advanced modeling that simultaneously captures both the cyber and physical domains in combined simulations.

Source Repo

The HELICS source code is hosted on GitHub: https://github.com/GMLC-TDC/HELICS

Release

HELICS is distributed under the terms of the BSD-3 clause license. All new contributions must be made under this license. LICENSE

SPDX-License-Identifier: BSD-3-Clause

portions of the code written by LLNL with release number LLNL-CODE-739319

Issues
  • Test labels

    Test labels

    • Adds named labels for ctest invocations instead of test index numbers (#261)
      • Test cases run by using the label should mostly match the tests run when using index numbers
      • Adds continuous, daily (nightly?), and release labels -- broken tests need fixing before these will work
    • Adds boost test labels (#344)
      • Adds ci, daily, release labels to test cases (could get tedious, may not be something we want to do -- or it might be easier to manage with only ci/daily labels, and default to all tests otherwise; doesn't work well with using utf::disabled)
      • Single executable for application api test suite with ctest targets for running key, normal, or extended set of tests
    • Adds a Python label for running the python tests using ctest (#260)
    opened by nightlark 31
  • Add helicsConfigMain.cpp

    Add helicsConfigMain.cpp

    This adds a helics-config as a command line executable.

    $ cmake -DCMAKE_INSTALL_PREFIX=/Users/$(whoami)/local/helics-develop/ .. && make -j 8 && make install
    
    $ helics-config --help
    Usage: helics-config --prefix|--includes|--libs|--help
    
    $ helics-config --prefix
    /Users/$USER/local/helics-develop
    
    $ helics-config --includes                                                                                                  
    /Users/$USER/local/helics-develop/include
     
    $ helics-config --libs
    /Users/$USER/local/helics-develop/lib
    
    
    opened by kdheepak 31
  • Cpp shared lib rework

    Cpp shared lib rework

    Summary

    If merged this pull request will create a c++ shared library as the main export for C++ code. It removes the static libraries from the install

    Proposed changes

    • change the C++ shared library to not include everything, but just the application API.
    • remove the static libs from the install
    • change the libzmq and jsoncpp subfolder to be EXCLUDE_FROM_ALL
    • change the modules to be static libs instead of object files.
    • update units and utilities to be able to exclude the install
    • make sure the different tests actually work exclusivly with the specified component
      • the core tests only the core static lib
    • add cpp shared library tests to verify compilability
    • add an example that uses the cpp shared library
    • add CoreApp and BrokerApp to give broker and core functionality to the application API
    • rework the api headers so they don't include anything they are not supposed to
    • add makeConnections function to the C shared library
    enhancement Installation/build 
    opened by phlptp 30
  • add some system info reporting to the benchmark output, which require…

    add some system info reporting to the benchmark output, which require…

    …d adding a few functions to various components to actually get that information.

    Summary

    If merged this pull request will add some system and compiler info to the benchmark output.

    Proposed changes

    • add system info to the benchmark output
    • add some functions that can retrieve the info in usable form from the various components in cmake and C++
    performance/scalability 
    opened by phlptp 26
  • enable benchmarks to be built by older cmake versions

    enable benchmarks to be built by older cmake versions

    Summary

    If merged this pull request will fix an issue gitUtils that impacted building google benchmark with older cmake versions

    Proposed changes

    • fix issue with gitUtils
    • add building benchmarks on travis gcc 6 build
    • add some more flags to turn off building internal tests on google benchmark on linux systems
    • fix bug trying to build java interface with cmake 3.7.X where X is 1 or 2
    • Add RUN_ALL_BENCHMARKS and RUN_KEY_BENCHMARKS targets to generate benchmark files automatically
    • add circle ci benchmark run
    opened by phlptp 25
  • Fix swig doxygen python documentation

    Fix swig doxygen python documentation

    Summary

    If merged this pull request will autogenerate Python documentation in the source code so users can access it from the REPL.

    This PR takes the following documentation:

        /** create a broker object
        @param type the type of the broker to create
        @param name the name of the broker , may be a nullptr or empty string to have a name automatically assigned
        @param initString an initialization string to send to the core-the format is similar to command line arguments
        typical options include a broker address  --broker="XSSAF" if this is a subbroker or the number of federates or the address
        @forcpponly
        @param[in,out] err an error object that will contain an error code and string if any error occurred during the execution of the function
        @endforcpponly
        @return a helics_broker object, will be NULL if there was an error indicated in the err object
        */
        HELICS_EXPORT helics_broker helicsCreateBroker (const char *type, const char *name, const char *initString, helics_error *err);
    
    

    and generates the following Python documentation:

    def helicsCreateBroker(type: "char const *", name: "char const *", initString: "char const *") -> "helics_broker":
        r"""
        create a broker object
           :type type: string
           :param type: the type of the broker to create
           :type name: string
           :param name: the name of the broker , may be a nullptr or empty string to have a name automatically assigned
           :type initString: string
           :param initString: an initialization string to send to the core-the format is similar to command line arguments
               typical options include a broker address  --broker="XSSAF" if this is a subbroker or the number of federates or the address
    
           :rtype: void
           :return: a helics_broker object, will be NULL if there was an error indicated in the err object
        """
        return _helics.helicsCreateBroker(type, name, initString)
    

    Users can now request for help in a REPL and get the doxygen documentation.

    Screen Shot 2019-11-08 at 10 29 28 AM

    opened by kdheepak 25
  • Git all archive implementation

    Git all archive implementation

    Summary

    add git-all-archive.py to create a tarball with archive source and all submodules source file

    Proposed changes

    python scripts/git-all-archive.py will archive current repository and create a tarball with the branch name. HELIC-.tar.gz

    opened by dnadeau4 25
  • Cmake update

    Cmake update

    Summary

    If merged this pull request will do some refactoring of the cmake

    Proposed changes

    • add a git hash based description for builds not of one of the tagged releases
    • reformat some of the cmake code
    • update cmake with some more modern best practices.
    • test are off by default
    • examples are off by default
    • all references to HELICS_BOOST_TESTS have been removed since they are no longer present
    • change a few more variables and options in CMAKE to have HELICS_ prefix
    Code Improvement Installation/build 
    opened by phlptp 24
  • binding error on internal comms socket

    binding error on internal comms socket

    I'm unable to create a new broker in an interactive session repeatedly.

    # broker.py
    import time
    import helics as h
    
    def main():
        initstring = "2 --name=mainbroker"
        # Create broker #
        print("Creating Broker")
        broker = h.helicsCreateBroker("zmq", "", initstring)
        print("Created Broker")
    
        print("Checking if Broker is connected")
        isconnected = h.helicsBrokerIsConnected(broker)
        print("Checked if Broker is connected")
    
        if isconnected == 1:
            print("Broker created and connected")
    
        try:
    
            while (h.helicsBrokerIsConnected(broker)):
                time.sleep(1)
    
        except KeyboardInterrupt:
            h.helicsCloseLibrary()
    

    If I Ctrl+C this process, this results in the following the next time I try to call the main function.

    In [2]: from broker import main
    In [3]: main()
    Creating Broker
    binding error on internal comms socket
    Created Broker
    Checking if Broker is connected
    Checked if Broker is connected
    
    

    cc @bpalmintier

    opened by kdheepak 24
  • New clang-format

    New clang-format

    I took the existing clang-format file and uploaded it to https://zed0.co.uk/clang-format-configurator/. I then chose values for every field that I had even a minor opinion on, i.e. this clang-format file is highly opinionated. Even if I didn't have a preference, I chose an option other than "default" so that it'd appear in the file. I prioritized for what I thought is better readability.

    You can download the file and upload it to the website above, and tweak settings on the left and see how the code changes on the right.

    Code Improvement 
    opened by kdheepak 23
  • Add timeout test

    Add timeout test

    Summary

    If merged this pull request will add a new timeout test in Python for a value federate. It initializes a federate, enters execution and waits 60 seconds, and then checks if the broker is still connected.

    This test can be run explicitly by using the following:

    pytest -sv tests/python/test_value_federate.py -k test_value_federate_runFederateTimeoutTest
    

    Related to #853

    opened by kdheepak 21
  • Iterations for a single time step are not synchronised on HELICS 3.2.1

    Iterations for a single time step are not synchronised on HELICS 3.2.1

    Describe the bug Iterations out of synchronization if the federates have different speeds.

    What is the expected behavior? Like the time step synchronization, iterations are supposed to be synchronized.

    To Reproduce Steps to reproduce the behavior: Here is the dummy project: https://github.com/Getnet-Ayele/HELICS_SAInt_DummyFederates

    Environment (please complete the following information):

    • Operating System: Windows
    • Language Extension: [c#
    • what compiler or setup process did you use Visual Studio 2019
    • HELICS version:
    $ helics_app --version
    

    Additional context and information (e.g. detailed explanation, stacktraces, related issues, suggestions how to fix, links for us to have context, eg. stackoverflow, gitter, etc)

    bug 
    opened by Getnet-Ayele 3
  • Update macos build images on Azure

    Update macos build images on Azure

    MacOS 10.15 images will be deprecated on Azure.

    The 3.3 release will be the last release to test on MacOS 10.15.

    This issue is to update the CI builds for macOS on Azure to macOS 12 with Xcode 13 if possible, otherwise 12) and macOS 11 (with Xcode 11 if possible)

    After 3.3 release.

    infrastructure/ci 
    opened by phlptp 1
  • Publish check

    Publish check

    Summary

    If merged this pull request will add a time restriction option for publications and subscriptions and some additional checks for connections on targeted endpoints.

    Proposed changes

    enhancement 
    opened by phlptp 0
  • HELICS 2.8 + Matlab Installation

    HELICS 2.8 + Matlab Installation

    Morning Everyone,

    I attempted a helics 2.8 + Matlab installation using the DBUILD_MATLAB_INTERFACE = ON in the cmake.

    The installation worked out perfectly and I got this output during the script execution:

    `-- Found PythonLibs: /usr/lib/x86_64-linux-gnu/libpython3.9.so (found suitable version "3.9.7", minimum required is "3")

    -- Building without swig

    -- Found Matlab: /usr/local/MATLAB/R2022a/extern/include (found version "9.12") found components: MAIN_PROGRAM

    -- Building MATLAB

    -- Building without swig

    -- Extra /home/ali/cosim2_env/sources/helicsv2.8.0/interfaces/matlab/extra/helicsInputSetDefault.m;/home/ali/cosim2_env/sources/helicsv2.8.0/interfaces/matlab/extra/helicsPublicationPublish.m

    -- Git hooks disabled

    -- Configuring done

    -- Generating done

    -- Build files have been written to: /home/ali/cosim2_env/sources/helicsv2.8.0/build`

    My question here is, apparently it found the installation of Matlab, but I am not sure if it is correctly detecting SWIG, which I installed earlier.

    Secondly, as I finished running the complete script, I executed helicsStartup() function in Matlab terminal but came across this error:

    **>> helicsStartup Loading HELICS (from /home/ali/cosim2_env/matlab)... Warning: The library name is not a valid name. The library will be named "libhelicsSharedLib0x2Eso0x2E20x2E8".

    In loadlibrary In helicsStartup (line 56) Error using loadlibrary Could not find file libhelicsSharedLib.so.2.8.

    Error in loadlibrary

    Error in helicsStartup (line 56) loadlibrary(GetFullPath(fullfile(helicsLibPath, libraryName)));**

    I had executed an AddPath() step earlier and my helics/matlab directory actually contains the library file that this is showing as missing.

    It appears that I am close to completing the linkage but something is still missing.

    My reason here to go with the older installation is that I have to perform an integration with Gridlab-D and Gridlab-D team is not currently supporting helics-3. (They plan to do it in the next release, but not now).

    Thanks.

    opened by StormsHalted 2
Releases(v3.2.1)
  • v3.2.1(Jun 16, 2022)

    The Matlab interface to HELICS has been moved to matHELICS, the C++ interface now uses std::string_view in nearly all places, the translator C API and the dataBuffer API to the C interface were fleshed out a bit more and will be finalized in the 3.3 release. Subsequent releases will change the minimum compiler requirements to build HELICS to Visual Studio 2019, GCC 8.0, Clang 7, Xcode 11.0, and CMake 3.11.

    Fixed

    • A bug related to iterations and the wait_for_current_time flag in which a deadlock may occur if the flag were set and another federate was requesting iterations at time zero.
    • A bug which could cause a deadlock if a very large number of iterations occurred
    • A naming bug in the creation of globalInput objects through the C API.
    • Fixed some potential race conditions in the Webserver
    • Fixed some race conditions and potential segmentation faults when running the C shared library tests
    • Fix some tests that were failing when executed without ZMQ support.
    • Fix the symbol visibility on Linux systems to reduce the number of visible symbols in the C shared library
    • Fix an issue with very long file names when used for configuration
    • Fix a race condition and deadlock potential in the log buffer tests.
    • Fix a Typo in HELICS_DEPRECATED use.

    Changed

    • Docker images were updated to be based on Ubuntu 22.04.
    • All string interfaces in the C++ interface were altered to use std::string_view instead of const std::string & this corresponds with updates in some third party libraries to better take advantage of the capabilities of std::string_view. The exception to this is strings which reference file names or file contents. These have been left as std::string to match up with iostreams and other file interfaces.
    • Updated the Google test version in use.
    • Change the symbol visibility for mac systems to be explicitly limited to the HELICS related operations.
    • Changed the signal abort code to match standard SIGINT codes
    • Some enumerations used inside the CoreLibrary were updated to better match the Style Guide
    • Updated the Circle-CI build tests to use more recent compilers and tweak the tests to be more appropriate to test being executed.
    • Update the Units, frozen, asio, filesystem, and spdlog libraries to recent releases.
    • Updated support CMake 3.23, Boost 1.79, and Visual Studio 2022.

    Added

    • Numerous functions in the C data API to support all HELICS supported types
    • helicsFederateProtect method to all federates to be recovered by name if all references to the C HelicsFederate object was freed.
    • Added a callback method for translators in the C API.
    • Added a "--force" option for ZMQ brokers to allow a broker to override an existing broker for the network connection and terminate the existing broker to be replaced by a new one.
    • Added additional documentation and examples for using iterations

    Removed

    • The HELICS_BUILD_MATLAB_INTERFACE has been removed and all HELICS support for Matlab in the future will be through the matHELICS repository.
    Source code(tar.gz)
    Source code(zip)
    Helics-3.2.1-Linux-x86_64.tar.gz(14.57 MB)
    Helics-3.2.1-macOS-universal2.zip(25.01 MB)
    Helics-3.2.1-msvc2019-win64.zip(9.03 MB)
    Helics-3.2.1-msvc2022-win64.zip(9.20 MB)
    Helics-3.2.1-win32.zip(9.17 MB)
    Helics-3.2.1-win64.exe(7.28 MB)
    Helics-3.2.1-win64.zip(10.53 MB)
    Helics-shared-3.2.1-Linux-x86_64.tar.gz(3.16 MB)
    Helics-shared-3.2.1-macOS-universal2.tar.gz(4.27 MB)
    Helics-shared-3.2.1-win32.tar.gz(1.41 MB)
    Helics-shared-3.2.1-win64.tar.gz(1.61 MB)
    Helics-v3.2.1-SHA-256.txt(1.14 KB)
    Helics-v3.2.1-source.tar.gz(21.26 MB)
  • v3.2.0(May 3, 2022)

    Major new features include beta release for Translators, global time coordinator and Data API and the addition of Support for encrypted communication through the TCP and TCP SS core types. Numerous bug fixes were included related to timing in unusual edge cases.

    Fixed

    • Fix some undefined behavior warnings with duplicate named federates.
    • Fix a discrepancy in the way subscriptions were processed for config files to better match how they are handled for inputs.
    • Fix some accidentally disabled test cases testing different network configurations.
    • Fix missing dependency generation when subscribing to publications from Endpoints.
    • Fixed a few sporadic failures in the test cases.
    • Fixed some issues with iterations particularly in initialization mode.
    • Fixed a series of edge cases in timing in unusual communication patterns and configurations mostly related to filters, and more complex iteration schemes.
    • Fixed an issue related to missing source code on the release source archive.

    Changed

    • Docker images were updated to be based on Ubuntu 21.10.
    • Update asio, json_cpp, and units to recent releases.
    • Errors in the networking layer are now propagated through the logging system in HELICS for better diagnostics of networking issues.
    • Benchmark tests are now built with Visual studio 2022.
    • Code coverage tests are now run nightly instead of on develop PR's.
    • Refactored how Apps were handling arguments to the federate to resolve some oddities in argument processing.
    • Update CLI11 to use release 2.2.
    • The callback for a filter to can return a message Object.

    Added

    • Added support for openSSL based encryption on the tcp tcpss cores and some tests using that capability.
    • Added a callback option which triggers when a federate changes mode.
    • Added Translators as a beta API, this is not version locked and likely has a few bugs. The API is subject to minor revisions based on user feedback.
    • Added Data API to the C interface as a beta. API is subject to further revisions based on user feedback in upcoming releases until 3.3.
    • Added support for command operations through the REST API on the webserver.
    • Added swagger documentation for the REST API and queries.
    • Added a global time coordinator(in Beta) for handling some unusual cases.
    • Added additional callbacks in the application API for entry and exit from a timeRequest call.
    • Added support for using external FMT and SPDLOG libraries when linking HELICS.
    • Added additional documentation for complex networking environments

    Deprecated

    • CI tests for visual studio 2017 were deprecated. HELICS still compiles fine on Visual studio 2017. But this is the last release that is specified for. Future releases will not be tested on Visual Studio 2017. HELICS 3.3 will actively change the minimum required to Visual Studio 2019 along with other related minimum compiler updates and requirements
    Source code(tar.gz)
    Source code(zip)
    Helics-3.2.0-Linux-x86_64.tar.gz(14.92 MB)
    Helics-3.2.0-macOS-universal2.zip(25.66 MB)
    Helics-3.2.0-msvc2019-win64.zip(9.10 MB)
    Helics-3.2.0-msvc2022-win64.zip(9.19 MB)
    Helics-3.2.0-win32.zip(9.50 MB)
    Helics-3.2.0-win64.exe(7.36 MB)
    Helics-3.2.0-win64.zip(10.74 MB)
    Helics-shared-3.2.0-Linux-x86_64.tar.gz(3.43 MB)
    Helics-shared-3.2.0-macOS-universal2.tar.gz(4.54 MB)
    Helics-shared-3.2.0-win32.tar.gz(1.46 MB)
    Helics-shared-3.2.0-win64.tar.gz(1.65 MB)
    Helics-v3.2.0-SHA-256.txt(1.14 KB)
    Helics-v3.2.0-source.tar.gz(16.15 MB)
  • v3.1.2(Jan 26, 2022)

    This patch release is primarily to address some build issues on MSYS2, MINGW, and CYGWIN platforms. It also includes some preliminary features for the 3.2 release that were already merged including time monitors, remote logging, and a log buffer.

    Fixed

    • Fixed issue building on CYGWIN with the latest FMT library.
    • Build issues related to MSYS2 and Mingw in the networking submodule (submodule updated).
    • Fixed argument processing issue in the comboFed Example.

    Changed

    • Updates to FMT and SPDLOG
    • Several documentation updates and cleanup
    • Copyright date changed to 2022
    • Targeted endpoints now allow all method calls, with the restriction being that the destination must be in the target list otherwise an error is generated. An empty destination in methods that allow destinations will operate identically to calls which do not specify a destination.
    • Code cleanup for defining the default port numbers for network core types.

    Added

    • A process comms method for federates to instruct HELICS to process messages for a specific amount of wall clock time without granting time or changing state.
    • Added a threaded signal handler to deal with some particular issues with killing processes in python and potentially other language interfaces.
    • Added a log buffer to brokers/cores/federates to store the latest N messages and retrieve it via a query. See log buffer for more details.
    • Added a time monitor object to brokers to use a particular federate as the query time standard for brokers, this does not affect the cosimulation only the logging and queries. See time monitor for more details.
    • Added a callback to be executed when the time is updated and before the value or message interface callbacks are executed.
    • Added remote logging command to mirror logs from one HELICS object to another. See remote logging for more details.
    Source code(tar.gz)
    Source code(zip)
    Helics-3.1.2-Linux-x86_64.tar.gz(14.12 MB)
    Helics-3.1.2-macOS-universal2.zip(24.33 MB)
    Helics-3.1.2-msvc2017-win64.zip(8.62 MB)
    Helics-3.1.2-msvc2019-win64.zip(8.85 MB)
    Helics-3.1.2-msvc2022-win64.zip(8.97 MB)
    Helics-3.1.2-win32.zip(9.02 MB)
    Helics-3.1.2-win64.exe(7.05 MB)
    Helics-3.1.2-win64.zip(10.23 MB)
    Helics-shared-3.1.2-Linux-x86_64.tar.gz(3.29 MB)
    Helics-shared-3.1.2-macOS-universal2.tar.gz(4.35 MB)
    Helics-shared-3.1.2-win32.tar.gz(1.39 MB)
    Helics-shared-3.1.2-win64.tar.gz(1.57 MB)
    Helics-v3.1.2-SHA-256.txt(1.23 KB)
    Helics-v3.1.2-source.tar.gz(9.27 MB)
  • v3.1.1(Dec 16, 2021)

    Primarily a bug fix release to fix a build issue resulting in internal logging messages being disabled for some of the release packages. Also includes a maxcosimduration argument for brokers to kill the co-sim after a certain amount of wall clock time.

    Fixed

    • CMake issue resulting in internal logging messages being disabled for some builds including some package releases.
    • Fixed a few deadlock pathways if the core was killed internally.
    • Fixed some timeout issues in the CI builds.
    • Fixed a potential race condition when setting the log file after execution has started on helics cores.

    Changed

    • CMake version 3.22 tested and used if available.
    • The TCP networking components that were not core to HELICS have been moved to a separate repo and linked as a submodule. See networking.
    • Several documentation fixes and updates.
    • Moved to using the upstream toml11 repo instead of a custom modified version. Customized modifications have now been merged upstream.

    Added

    • '--maxcosimduration' flag added in the broker to specify a max co-sim duration after which the cosimulation will be terminated.
    • helicsGetSystemInfo() function was added to the API to retrieve HELICS version and system info for debugging and diagnostic purposes.
    • Added a threaded signal handler to execute close out operations in a new thread and return control back to the main thread to wait for error signals.
    • Added helicsFederateInfoLoadFromString to better match C++ API available functions. This loads the federateInfo structure from command line arguments contained in a string.
    Source code(tar.gz)
    Source code(zip)
    Helics-3.1.1-Linux-x86_64.tar.gz(13.91 MB)
    Helics-3.1.1-macOS-universal2.zip(23.90 MB)
    Helics-3.1.1-msvc2017-win64.zip(8.51 MB)
    Helics-3.1.1-msvc2019-win64.zip(8.76 MB)
    Helics-3.1.1-msvc2022-win64.zip(8.90 MB)
    Helics-3.1.1-win32.zip(8.88 MB)
    Helics-3.1.1-win64.exe(6.94 MB)
    Helics-3.1.1-win64.zip(10.05 MB)
    Helics-shared-3.1.1-Linux-x86_64.tar.gz(3.25 MB)
    Helics-shared-3.1.1-macOS-universal2.tar.gz(4.28 MB)
    Helics-shared-3.1.1-win32.tar.gz(1.36 MB)
    Helics-shared-3.1.1-win64.tar.gz(1.54 MB)
    Helics-v3.1.1-SHA-256.txt(1.23 KB)
    Helics-v3.1.1-source.tar.gz(9.21 MB)
  • v3.1.0(Nov 29, 2021)

    This release includes some bug fixes and enhancements to HELICS 3 which is now the default. Major new features include the ability to add observer federates to an executing co-simulation, and the ability to specify a grant timeout which can give additional debugging information if the co-simulation is hanging for some reason. More capabilities related to this will be added in a future release. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    Fixed

    • Fixed an issue with null strings lacking a null termination when retrieved from the C API. This primarily affected the Python and other language API's.
    • CMake fix for some older linkers.
    • A fix for ASIO aligned_alloc when used with MinGW.
    • Fix to IPC core to support Boost 1.77.
    • A few issues around the JsonSerialization options for backwards compatibility with HELICS 2, and add some interoperability tests that can be used to check future versions.
    • Fix an issue with the timeCoordinator where a large time value was requested and with certain other configuration parameters the time could overflow and cause a deadlock.

    Changed

    • precommit-ci now used in the CI chain, pre-commit checks were updated, and a check for python formatting inside the docs was added.
    • Update ThirdParty library versions including ASIO, CLI11, toml11, FMT, spdlog, jsoncpp, filesystem.
    • Mac binaries are now universal binaries to support ARM based CPU types.
    • Update some of the TCP helper classes to better support future encrypted communication efforts.

    Added

    • Add the ability to add observer federates which can join a federation after it has started and subscribe to values, or make queries of the federation while in progress.
    • Add a configurable grant timeout which will trigger diagnostic action if a federate has been waiting sufficiently long for a time grant.
    • A document on the Type conversion that HELICS can perform and a series of tests to verify the correct operation of the type conversions.
    • Additional missing functions related to linking targeted endpoints from a core, so it can work similar to dataLink methods. These methods were added to Core and Broker applications.
    • New benchmark based on the Barabasi-Albert network.
    Source code(tar.gz)
    Source code(zip)
    Helics-3.1.0-Linux-x86_64.tar.gz(13.76 MB)
    Helics-3.1.0-macOS-universal2.zip(23.79 MB)
    Helics-3.1.0-msvc2017-win64.zip(8.50 MB)
    Helics-3.1.0-msvc2019-win64.zip(8.75 MB)
    Helics-3.1.0-msvc2022-win64.zip(8.88 MB)
    Helics-3.1.0-win32.zip(8.82 MB)
    Helics-3.1.0-win64.exe(6.90 MB)
    Helics-3.1.0-win64.zip(9.97 MB)
    Helics-shared-3.1.0-Linux-x86_64.tar.gz(3.22 MB)
    Helics-shared-3.1.0-macOS-universal2.tar.gz(4.25 MB)
    Helics-shared-3.1.0-win32.tar.gz(1.35 MB)
    Helics-shared-3.1.0-win64.tar.gz(1.53 MB)
    Helics-v3.1.0-SHA-256.txt(1.23 KB)
    Helics-v3.1.0-source.tar.gz(9.04 MB)
  • v2.8.0(Sep 17, 2021)

    Final Minor release in the 2.X series of HELICS. This includes profiling capabilities and a compatibility layer for future compatibility through the --json flag. There may be more bug fix releases but no major new features will be added to HELICS 2.

    Changed

    • Upgraded Units library to 0.5.0
    • CMAKE 3.20 was tested and verified and used as the baseline version when available.
    • Updated to a newer custom version of JSONCPP to support the json compatibility layer

    Fixed

    • The uninterruptible flag now works with iterations
    • A compile issue with C++20 requiring #include <thread> in a number of files

    Added

    • Added json data type and flag to support interoperability between HELICS 2 and 3
    • Added helicsEndpointPendingMessageCount, helicsFederatePendingMessageCount, and helicsFederateDisconnect[Async|Complete]
    • Added a profiling capability

    Deprecated

    • helicsEndpointPendingMessages and helicsFederatePendingMessages are replaced by helicsEndpointPendingMessageCount andhelicsFederatePendingMessageCount to match HELICS 3 functions
    Source code(tar.gz)
    Source code(zip)
    Helics-2.8.0-Linux-x86_64.tar.gz(13.75 MB)
    Helics-2.8.0-macOS-x86_64.zip(12.20 MB)
    Helics-2.8.0-msvc2017-win64.zip(8.63 MB)
    Helics-2.8.0-msvc2019-win64.zip(8.87 MB)
    Helics-2.8.0-win32.zip(9.84 MB)
    Helics-2.8.0-win64.exe(6.75 MB)
    Helics-2.8.0-win64.zip(11.13 MB)
    Helics-shared-2.8.0-Linux-x86_64.tar.gz(3.13 MB)
    Helics-shared-2.8.0-macOS-x86_64.tar.gz(2.18 MB)
    Helics-shared-2.8.0-win32.tar.gz(1.30 MB)
    Helics-shared-2.8.0-win64.tar.gz(1.47 MB)
    Helics-v2.8.0-SHA-256.txt(1.13 KB)
    Helics-v2.8.0-source.tar.gz(17.53 MB)
  • v3.0.1(Aug 27, 2021)

    This release includes some bug fixes and refinements to the build process for HELICS3, as well as general bug fixes and the addition of a compatibility layer making it possible for HELICS 2 federates to interact with a HELICS 3 broker if absolutely required. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    Fixed

    • Timing issues using UNINTERUPTIBLE_FLAG and iterations together resulted in incorrect timing
    • Some issues with the automated generation of interface files for inclusion in the repository (Java, and Matlab)
    • Fixed several broken links in the documentation pages

    Added

    • JSON serialization method for HELICS supported data types
    • JSON serialization method for HELICS actionMessage to allow some level of backwards compatibility support. The intention is that using the --json flag on a federate will allow full forward compatibility in the future. It is slower but as it is a text stream and it includes a version code, future versions can adapt.
    • Profiling capability, see Profiling
    Source code(tar.gz)
    Source code(zip)
    Helics-3.0.1-Linux-x86_64.tar.gz(13.65 MB)
    Helics-3.0.1-macOS-x86_64.zip(12.43 MB)
    Helics-3.0.1-msvc2017-win64.zip(8.44 MB)
    Helics-3.0.1-msvc2019-win64.zip(8.72 MB)
    Helics-3.0.1-win32.zip(8.75 MB)
    Helics-3.0.1-win64.exe(6.82 MB)
    Helics-3.0.1-win64.zip(9.90 MB)
    Helics-shared-3.0.1-Linux-x86_64.tar.gz(3.20 MB)
    Helics-shared-3.0.1-macOS-x86_64.tar.gz(2.25 MB)
    Helics-shared-3.0.1-win32.tar.gz(1.34 MB)
    Helics-shared-3.0.1-win64.tar.gz(1.51 MB)
    Helics-v3.0.1-SHA-256.txt(1.13 KB)
    Helics-v3.0.1-source.tar.gz(18.99 MB)
  • v3.0.0(Jul 15, 2021)

    HELICS 3.0 is a major update to HELICS. The major features that have been added are the command interface and targeted Endpoints. Internally major changes include updating the minimum compiler to C++17, and updates to internal libraries. The binary serialization protocol was shifted from Cereal to a custom format that embeds the data type so is more suitable to HELICS data types. The initial release is an alpha release for some initial testing. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    NOTE: The installers do not include the pre-built Java 1.8 interface; if you need the Java interface, please use swig to build it.

    Changed

    • Data serialization moved to a custom protocol specific to HELICS.
    • Minimum build requirements to C++17.
    • Minimum boost library for use is 1.67.
    • Many of the API functions now use string_view instead of const std::string &
    • The C shared library now comes with only a single header helics.h this should be included for all uses of the C shared library
    • The name of the C based shared library changed to libhelics.dll/so
    • The name of the C++ shared library changed to libhelicscpp.dll/so
    • The name of the apps library changed to libhelicscpp-apps.dll/so
    • The style of enumerations and structures was changed to match an updated style guide
    • All HELICS specific CMake variables start with HELICS_
    • The format for log messages now includes a simulation time stamp [t=xxxx]
    • Log level numerical values have been expanded (multiplied by 3) to allow more gradations in log levels than was previously allowed
    • The allowed set of string names has been reduced to avoid confusion and remove duplicate entries
    • All queries (except global_value) return a valid json string. Errors from queries return a structure with an HTTP error code and message

    Fixed

    • All bug fixes included in HELICS 2.X are included in HELICS 3

    Added

    • Command interface
    • Targeted Endpoints
    • Interface Tags
    • Federate and Core Tags

    Removed

    • Message structure from C API
    • Deprecated functions from HELICS 2
    • The separate headers for the C shared library are no longer installed. Instead only a single header (helics.h) is needed and includes all functions and operations.
    • The cereal library is no longer installed or used with HELICS
    • The C++ API no longer has generic type support through Cereal.
    Source code(tar.gz)
    Source code(zip)
    Helics-3.0.0-Linux-x86_64.tar.gz(13.58 MB)
    Helics-3.0.0-macOS-x86_64.zip(12.30 MB)
    Helics-3.0.0-msvc2017-win64.zip(8.41 MB)
    Helics-3.0.0-msvc2019-win64.zip(8.59 MB)
    Helics-3.0.0-win32.zip(7.37 MB)
    Helics-3.0.0-win64.exe(6.72 MB)
    Helics-3.0.0-win64.zip(8.37 MB)
    Helics-shared-3.0.0-Linux-x86_64.tar.gz(3.18 MB)
    Helics-shared-3.0.0-macOS-x86_64.tar.gz(2.23 MB)
    Helics-shared-3.0.0-win32.tar.gz(1.33 MB)
    Helics-shared-3.0.0-win64.tar.gz(1.50 MB)
    Helics-v3.0.0-SHA-256.txt(1.13 KB)
    Helics-v3.0.0-source.tar.gz(18.97 MB)
  • v3.0.0-beta.2(Jun 30, 2021)

    HELICS 3.0 is a major update to HELICS. The major features that have been added are the command interface and targeted Endpoints. Internally major changes include updating the minimum compiler to C++17, and updates to internal libraries. The binary serialization protocol was shifted from Cereal to a custom format that embeds the data type so is more suitable to HELICS data types. The initial release is an alpha release for some initial testing. The full change log will be filled out as the release progresses from alpha to beta to final release. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    NOTE For this beta, all public API's are now considered stable, baring a bug report on the API. A final release is expected in 2 weeks, Final steps include code cleanup, and testing of the different language API's. Please make any comments in the discussion page related to this release.

    changes from beta.1

    • addition of federate tags
    • bug fixes from HELICS 2
    • cleanup of doxygen comments
    • update of the language API builder files
    • doc fixes and updates
    • update submodules

    Changed

    • Data serialization moved to a custom protocol specific to HELICS.
    • Minimum build requirements to C++17.
    • Minimum boost library for use is 1.67.
    • Many of the API functions now use string_view instead of const std::string &
    • The C shared library now comes with only a single header helics.h this should be included for all uses of the C shared library
    • The name of the C based shared library changed to libhelics.dll/so
    • The name of the C++ shared library changed to libhelicscpp.dll/so
    • The name of the apps library changed to libhelicscpp-apps.dll/so
    • The style of enumerations and structures was changed to match an updated style guide
    • All HELICS specific CMake variables start with HELICS_
    • The format for log messages now includes a simulation time stamp [t=xxxx]
    • Log level numerical values have been expanded (multiplied by 3) to allow more gradations in log levels than was previously allowed
    • The allowed set of string names has been reduced to avoid confusion and remove duplicate entries

    Fixed

    Added

    • Command interface
    • Targeted Endpoints
    • Interface Tags
    • Federate and core Tags

    Removed

    • Message structure from C API
    • Deprecated functions from HELICS 2
    • The separate headers for the C shared library are no longer installed only a single header is needed and includes all functions and operations.
    • The cereal library is no longer installed or used with HELICS
    Source code(tar.gz)
    Source code(zip)
    Helics-3.0.0-beta.2-Linux-x86_64.tar.gz(13.57 MB)
    Helics-3.0.0-beta.2-macOS-x86_64.zip(12.29 MB)
    Helics-3.0.0-beta.2-msvc2017-win64.zip(8.41 MB)
    Helics-3.0.0-beta.2-msvc2019-win64.zip(8.58 MB)
    Helics-shared-3.0.0-beta.2-Linux-x86_64.tar.gz(3.18 MB)
    Helics-v3.0.0-beta.2-source.tar.gz(18.96 MB)
  • v3.0.0-beta(Jun 12, 2021)

    HELICS 3.0 is a major update to HELICS. The major features that have been added are the command interface and targeted Endpoints. Internally major changes include updating the minimum compiler to C++17, and updates to internal libraries. The binary serialization protocol was shifted from Cereal to a custom format that embeds the data type so is more suitable to HELICS data types. The initial release is an alpha release for some initial testing. The full change log will be filled out as the release progresses from lpha to beta to final release. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    NOTE For this beta, all public API's are now considered stable, baring a bug report on the API. A beta.2 is expected in 2 weeks, with a release 2 weeks later. Final steps include any submodule updates, code cleanup, and testing of the different language API's. Please make any comments in the discussion page related to this release.

    Changed

    • Data serialization moved to a custom protocol specific to HELICS.
    • Minimum build requirements to C++17.
    • Minimum boost library for use is 1.67.
    • Many of the API functions now use string_view instead of const std::string &
    • The C shared library now comes with only a single header helics.h this should be included for all uses of the C shared library
    • The name of the C based shared library changed to libhelics.dll/so
    • The name of the C++ shared library changed to libhelicscpp.dll/so
    • The name of the apps library changed to libhelicscpp-apps.dll/so
    • The style of enumerations and structures was changed to match an updated style guide
    • All HELICS specific CMake variables start with HELICS_
    • The format for log messages now includes a simulation time stamp [t=xxxx]
    • Log level numerical values have been expanded (multiplied by 3) to allow more gradations in log levels than was previously allowed
    • The allowed set of string names has been reduced to avoid confusion and remove duplicate entries

    Fixed

    Added

    • Command interface
    • Targeted Endpoints
    • Interface Tags

    Removed

    • Message structure from C API
    • Deprecated functions from HELICS 2
    • The separate headers for the C shared library are no longer installed only a single header is needed and includes all functionsa and operations.
    • The cereal library is no longer installed or used with HELICS
    Source code(tar.gz)
    Source code(zip)
    Helics-3.0.0-beta-Linux-x86_64.tar.gz(13.65 MB)
    Helics-3.0.0-beta-macOS-x86_64.zip(12.33 MB)
    Helics-3.0.0-beta-msvc2017-win64.zip(8.47 MB)
    Helics-3.0.0-beta-msvc2019-win64.zip(8.63 MB)
    Helics-3.0.0-beta-win32.zip(7.36 MB)
    Helics-3.0.0-beta-win64.exe(6.70 MB)
    Helics-3.0.0-beta-win64.zip(8.34 MB)
    Helics-shared-3.0.0-beta-Linux-x86_64.tar.gz(3.20 MB)
    Helics-shared-3.0.0-beta-macOS-x86_64.tar.gz(2.24 MB)
    Helics-shared-3.0.0-beta-win32.tar.gz(1.32 MB)
    Helics-shared-3.0.0-beta-win64.tar.gz(1.50 MB)
    Helics-v3.0.0-beta-SHA-256.txt(1.19 KB)
    Helics-v3.0.0-beta-source.tar.gz(18.94 MB)
  • v2.7.1(Jun 4, 2021)

    There were several bug fixes in this patch release. Some of them related to changes in 2.7.0 and some new ones that came up from bug reports. Some new enhancements are experimental signal handlers in the C-api, which will be used in the python interface to provide a little better user experience when trying to kill a co-simulation.

    Changed

    • String output on recorders is now always JSON compatible and allows escaped characters. This allows some additional values to be displayed in ascii format vs base 64 encoding. #1910
    • Players read the string fields through a JSON parser unless marked with b64[] to match the string output on recorders #1910
    • The default webserver port is now 8080 to allow user space execution on non-Windows platforms #1936

    Fixed

    • An issue with recorders writing text fields in the incorrect order which could result in incorrect playback #1910
    • Fix an issue with core naming that occasionally resulted in same broker name errors when using default names on federates #1919
    • Fix an issue where queries were not being resolved when a core disconnects which could result in deadlock. #1931
    • The wait_for_current_time flag was not working properly in some cases where time interruption was also taking place #1933
    • Fixed issue with the webserver not responding with the index page when requested or detecting the correct broker for certain trivial requests #1936

    Added

    • Signal handlers for catching SIGINT and optional user callback are available in the C shared API #1915
    • Added support for environment variables for setting some network connection settings and other information #1921
    • Queries now have timeouts #1931
    • Command line and environment variable options for setting the webserver port numbers #1936
    Source code(tar.gz)
    Source code(zip)
    Helics-2.7.1-Linux-x86_64.tar.gz(13.74 MB)
    Helics-2.7.1-macOS-x86_64.zip(12.16 MB)
    Helics-2.7.1-msvc2017-win64.zip(8.61 MB)
    Helics-2.7.1-msvc2019-win64.zip(8.76 MB)
    Helics-2.7.1-win32.zip(9.73 MB)
    Helics-2.7.1-win64.exe(6.72 MB)
    Helics-2.7.1-win64.zip(11.05 MB)
    Helics-shared-2.7.1-Linux-x86_64.tar.gz(3.12 MB)
    Helics-shared-2.7.1-macOS-x86_64.tar.gz(2.17 MB)
    Helics-shared-2.7.1-win32.tar.gz(1.29 MB)
    Helics-shared-2.7.1-win64.tar.gz(1.45 MB)
    Helics-v2.7.1-SHA-256.txt(1.13 KB)
    Helics-v2.7.1-source.tar.gz(17.50 MB)
  • v2.7.0(Apr 30, 2021)

    This release includes a major change internally for filters. Testing and usage revealed some scenarios which could cause deadlock or acausal message arrival. These scenarios were not common so the release was delayed until a fix was in place. As of the 2.7.0 release all the identified issues related to the initial bug have been resolved. There remains some outstanding cases that fail rarely in the CI systems specifically related to rerouting filters that are separate from both the location they are rerouting from and to. The resolution of these is uncertain but will be available in a patch release when resolved. Additional changes include major changes to the CI builds due to changing support of Travis CI and other CI services.

    NOTE There are some known issues with using remote rerouting filters in the timing, which can under some conditions allow messages to be delivered after the the time the message was supposed to be delivered. Though most issues have been resolved in this release there remain a few tests in the CI build which are subject to sporadic failures that have yet to be resolved. It is expected these will be resolved in a future release hopefully 2.7.1

    Changed

    • Update spdlog, fmtlib, filesystem, asio, and units libraries to latest releases (#1798, #1802, #1803)
    • Default HELICS_USE_ZMQ_STATIC_LIB to ON if only the static library is found in the search path #1845
    • Primary CI systems are now on azure instead of travis #1819
    • Only a very limited CI test set is run on formatting PR's #1761

    Fixed

    • Tests and fixes allowing multiple filters on the same endpoint #1852
    • Fixed some failing broker server tests related to input arguments #1825
    • Fixed an issue with barrier and maxTime requests #1788
    • Fixed a timing bug when using offset and some specific time requests immediately after the enterExecutingMode #1759
    • Several fixes and changes to CI systems related to changes in CI infrastructure #1754, #1790, #1828, #1744, #1739
    • Fixed deadlock caused when querying a disconnected HELICS object #1705
    • Fixed major timing bug with the use of filters #1717
    • Fixed issue when sending messages before execution time #1717

    Added

    • Support for ZMQ 4.3.4 (this will become default in the next version) #1841
    • Added a global_flush query to sweep the internal action message queues #1832
    • A vcpkg manifest file for some vcpkg support #1835
    • Added an event triggered flag to better handle timing on federates that are primarily or exclusively triggered by events like filters #1804
    • Added ordered queries which allow queries to run on the normal vs priority pathways for queries that are desired to be synchronous with the other helics messages #1793
    • Added github workflow to compress images #1626
    • Additional and clearer warning messages when a message is sent to an unknown destination #1702
    Source code(tar.gz)
    Source code(zip)
    Helics-2.7.0-Linux-x86_64.tar.gz(13.63 MB)
    Helics-2.7.0-macOS-x86_64.zip(12.18 MB)
    Helics-2.7.0-msvc2017-win64.zip(8.60 MB)
    Helics-2.7.0-msvc2019-win64.zip(8.73 MB)
    Helics-2.7.0-SHA-256.txt(1.13 KB)
    Helics-2.7.0-source.tar.gz(17.30 MB)
    Helics-2.7.0-win32.zip(9.62 MB)
    Helics-2.7.0-win64.exe(6.66 MB)
    Helics-2.7.0-win64.zip(10.94 MB)
    Helics-shared-2.7.0-Linux-x86_64.tar.gz(3.11 MB)
    Helics-shared-2.7.0-macOS-x86_64.tar.gz(2.16 MB)
    Helics-shared-2.7.0-win32.tar.gz(1.27 MB)
    Helics-shared-2.7.0-win64.tar.gz(1.44 MB)
    Helics-v2.7.0-source.tar.gz(17.30 MB)
  • v3.0.0-alpha.2(Nov 9, 2020)

    HELICS 3.0 is a major update to HELICS. The major features that have been added are the command interface and targeted Endpoints. Internally major changes include updating the minimum compiler to C++17, and updates to internal libraries. The binary serialization protocol was shifted from Cereal to a custom format that embeds the data type so is more suitable to HELICS data types. The initial release is an alpha release for some initial testing. The full change log will be filled out as the release progresses from alpha to beta to final release. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    Changes expected for beta.1 which will be the next pre-release

    • matlab interface built and tested again (It is likely a new matlab API will be coming again)
    • more test cases for targetedEndpoints
    • docker image build working

    This is an early alpha release it includes all the major new features and nearly complete API changes(baring bug reports) please use for testing and report any issues.

    Changed

    • Data serialization moved to a custom protocol specific to HELICS.
    • Minimum build requirements to C++17
    • Many of the API functions now use string_view instead of const std::string &
    • Several API calls for messages have been updated for clarity and consistency.

    Fixed

    Added

    • Command interface
    • Targeted Endpoints

    Removed

    • Message structure from C API
    • Deprecated functions from HELICS 2
    Source code(tar.gz)
    Source code(zip)
    Helics-3.0.0-alpha.2-Linux-x86_64.tar.gz(13.19 MB)
    Helics-3.0.0-alpha.2-macOS-x86_64.zip(12.03 MB)
    Helics-3.0.0-alpha.2-msvc2017-win64.zip(8.35 MB)
    Helics-3.0.0-alpha.2-msvc2019-win64.zip(8.45 MB)
    Helics-3.0.0-alpha.2-win32.zip(8.35 MB)
    Helics-3.0.0-alpha.2-win64.exe(6.57 MB)
    Helics-3.0.0-alpha.2-win64.zip(9.47 MB)
    Helics-shared-3.0.0-alpha.2-Linux-x86_64.tar.gz(3.12 MB)
    Helics-shared-3.0.0-alpha.2-macOS-x86_64.tar.gz(2.17 MB)
    Helics-shared-3.0.0-alpha.2-win32.tar.gz(1.28 MB)
    Helics-shared-3.0.0-alpha.2-win64.tar.gz(1.45 MB)
    Helics-v3.0.0-alpha.2-source.tar.gz(16.47 MB)
  • v2.6.1(Oct 16, 2020)

    Several small bug fixes and minor enhancements to query operations

    Changed

    • In helics_enum.h flags were separated into separate enums with the same symbols splitting up flags specific to federates, cores, and those applicable to all entities
    • CMAKE 3.18 was tested and verified and used as the baseline version when available.
    • Default libzmq was updated to 4.3.3

    Fixed

    • A few flags were unable to be queried through getOptionFlag operations #1655
    • The index values for some flags were not able to be retrieved via getFlagIndex operations #1645
    • In some cases specifying a custom port of a number less than the default ports led to federates being unable to bind the appropriate port #1648
    • Duplicate target specification and warnings were improved #1639
    • Certain property strings did not generate the correct property index #1642
    • For large packets in the TCP core on particular operating systems partial buffers may be sent and this was not handled property in the tcp core #1600
    • Boost 1.74 deprecated some interfaces used in the webserver. The code was updated to support the latest release of boost. #1629
    • The requested_time field in the current_time query for federates was missing #1619
    • Some broker queries did not reset properly when changes in the federation occurred #1617
    • Handle cases of empty install prefix #1577

    Added

    • The C api now has a query callback method for responding to federate specific queries. #1634
    • Some tutorials for the hello_world example on visual studio #1621
    • A helicsMessageClear method was added to the C API for clearing the data from a message object #1622
    • A global_state query to actively query the current state of all objects in a federation. #1614
    • A strict config checking flag to generate errors on potentially incorrect configuration files #1607
    Source code(tar.gz)
    Source code(zip)
    Helics-2.6.1-Linux-x86_64.tar.gz(13.19 MB)
    Helics-2.6.1-macOS-x86_64.zip(11.88 MB)
    Helics-2.6.1-msvc2017-win64.zip(8.42 MB)
    Helics-2.6.1-msvc2019-win64.zip(8.53 MB)
    Helics-2.6.1-win32.zip(9.40 MB)
    Helics-2.6.1-win64.exe(6.53 MB)
    Helics-2.6.1-win64.zip(10.70 MB)
    Helics-shared-2.6.1-Linux-x86_64.tar.gz(3.03 MB)
    Helics-shared-2.6.1-macOS-x86_64.tar.gz(2.13 MB)
    Helics-shared-2.6.1-win32.tar.gz(1.25 MB)
    Helics-shared-2.6.1-win64.tar.gz(1.41 MB)
    Helics-v2.6.1-SHA-256.txt(1.13 KB)
    Helics-v2.6.1-source.tar.gz(16.98 MB)
  • v3.0.0-alpha.1(Sep 25, 2020)

    HELICS 3.0 is a major update to HELICS. The major features that have been added are the command interface and targeted Endpoints. Internally major changes include updating the minimum compiler to C++17, and updates to internal libraries. The binary serialization protocol was shifted from Cereal to a custom format that embeds the data type so is more suitable to HELICS data types. The initial release is an alpha release for some initial testing. The full change log will be filled out as the release progresses from alpha to beta to final release. The migrating 2 to 3 page includes some specific details on migrating from HELICS 2 to 3.

    Changes expected for alpha.2

    • travis-ci builds operational
    • more test cases for targetedEndpoints
    • octave build working
    • docker image build working

    This is an early alpha release it includes all the major new features and nearly complete API changes(baring bug reports) please use for testing and report any issues.

    Changed

    • Data serialization moved to a custom protocol specific to HELICS.
    • Minimum build requirements to C++17
    • Many of the API functions now use string_view instead of const std::string &

    Fixed

    Added

    • Command interface
    • Targeted Endpoints

    Removed

    • Message structure from C API
    • Deprecated functions from HELICS 2
    Source code(tar.gz)
    Source code(zip)
    Helics-3.0.0-alpha.1-Linux-x86_64.tar.gz(13.28 MB)
    Helics-3.0.0-alpha.1-msvc2017-win64.zip(8.36 MB)
    Helics-3.0.0-alpha.1-msvc2019-win64.zip(8.41 MB)
    Helics-3.0.0-alpha.1-win32.zip(7.02 MB)
    Helics-3.0.0-alpha.1-win64.exe(6.43 MB)
    Helics-3.0.0-alpha.1-win64.zip(7.94 MB)
    Helics-v3.0.0-alpha.1-source.tar.gz(16.41 MB)
  • v2.6.0(Aug 20, 2020)

    Bug fixes and major logging update

    Changed

    • The build flag function now returns correct debug or release flags depending on the build
    • The debug postfix d is no longer added to the interface libraries
    • Spdlog is now being used for logging inside HELICS and the old logger has been removed this results in fewer thread being generated by HELICS.
    • CMake will now error if the install directory is set to the build directory
    • Some argument names in the C API have been changed for consistency
    • Output a more descriptive error message for mismatched data sizes when converting types #1521
    • Some C++98 API functions were added and changed for consistency, specifically endpoint get type no returns a char * instead of std::string, and a getCurrentTime function was added to Federate
    • logging level properties from a federateInfo structure will be inherited by a core for the first registered federate

    Fixed

    • String with negative numerical values were not acknowledging the negation Issue #1306
    • Config file parsing was not acknowledging "unit" string #1512
    • A performance issue with the tcpss and tcp cores in some cases has been resolved by setting the no_delay option
    • Inconsistency in type returned by endpoint getType in C++98 API #1523
    • a potential segmentation fault when calling some methods in the C shared library after calling helicsCloseLibrary

    Added

    • Flags for dumplog and force_logging_flush were added to the C API
    • Added missing C++98 call to getCurrentTime
    • Added closeLibrary function to the C++98 API
    • Added a Python benchmark file
    • An option to install the benchmark executables has been added
    • Data logging output for both send and receive of messages
    • A GitHub Actions workflow to build packages for Linux with the benchmark executables

    Removed

    • The previous logger including logger.h has been replaced with spdlog
    Source code(tar.gz)
    Source code(zip)
    Helics-2.6.0-Linux-x86_64.tar.gz(13.15 MB)
    Helics-2.6.0-macOS-x86_64.zip(11.82 MB)
    Helics-2.6.0-msvc2017-win64.zip(8.46 MB)
    Helics-2.6.0-msvc2019-win64.zip(7.53 MB)
    Helics-2.6.0-win32.zip(9.24 MB)
    Helics-2.6.0-win64.exe(6.45 MB)
    Helics-2.6.0-win64.zip(10.56 MB)
    Helics-shared-2.6.0-Linux-x86_64.tar.gz(3.01 MB)
    Helics-shared-2.6.0-macOS-x86_64.tar.gz(2.12 MB)
    Helics-shared-2.6.0-win32.tar.gz(1.23 MB)
    Helics-shared-2.6.0-win64.tar.gz(1.39 MB)
    Helics-v2.6.0-SHA-256.txt(1.13 KB)
    Helics-v2.6.0-source.tar.gz(16.30 MB)
  • v2.5.2(Jun 15, 2020)

    Bug fix release for some build issues and a fix to the wait_for_current_time flag

    Fixed

    • Bug in the timing subsystem that was preventing the wait_for_current_time flag from functioning properly
    • Fixed some oddities in the java tests, that were doing confusing things and happened to work because of the bug in the timing subsystem
    • A build system issue that caused the automated generation of python packages to fail on the 2.5.1 release. This was caused by overriding the output build location in all cases, when it should have been limited if the python interface is getting built separately.
    • A few cppcheck issue from the new check (#1414)

    Added

    • Add print_systeminfo flag to root helics_benchmark command (#1417)
    • Added cppcheck github action for PR's
    Source code(tar.gz)
    Source code(zip)
    Helics-2.5.2-Linux-x86_64.tar.gz(12.98 MB)
    Helics-2.5.2-macOS-x86_64.zip(11.51 MB)
    Helics-2.5.2-msvc2017-win64.zip(8.21 MB)
    Helics-2.5.2-msvc2019-win64.zip(7.32 MB)
    Helics-2.5.2-win32.zip(9.04 MB)
    Helics-2.5.2-win64.exe(6.31 MB)
    Helics-2.5.2-win64.zip(10.31 MB)
    Helics-shared-2.5.2-Linux-x86_64.tar.gz(2.97 MB)
    Helics-shared-2.5.2-macOS-x86_64.tar.gz(2.06 MB)
    Helics-shared-2.5.2-win32.tar.gz(1.20 MB)
    Helics-shared-2.5.2-win64.tar.gz(1.36 MB)
    Helics-v2.5.2-SHA-256.txt(1.13 KB)
    Helics-v2.5.2-source.tar.gz(16.01 MB)
  • v2.5.1(Jun 6, 2020)

    Changed

    • All ZeroMQ related files are now located in the network library and under a single namespace
    • Use Python 3.8 instead of 3.6 for any release build installers that include a copy of the Python interface (pip or anaconda are the recommended ways to install the Python interface)
    • Update units library to include some typical natural gas units and conversions
    • Use a separate action for automated pr generation
    • Update the CLI11 library
    • The setOption/getOption functions now take an int32_t as a value instead of a boolean. This does not change the API since in the C library the helics_bool was already an int.
    • In the case of multiple sources, getInjectionType, and getInjectionUnits now will return a json string vector.
    • The CMake build generation now uses a central location for all build artifacts instead of individual directories.
    • Updated the ASIO library to 1-16
    • Minor updates to the clang-format to allow better alignment and comment reflow
    • Numerous code refactorings to simplify and clean up code
    • Move all ZMQ related items to the network library
    • Updated Python packages DLL load failed error to suggest installing the latest Visual C++ Runtime

    Fixed

    • Sporadic failures in the Webserver and websocket tests
    • A bug in the translation of vectors to complex vectors
    • A bug in the copying of vectors into the C shared library
    • Numerous clang-tidy identified issues mostly for code readability
    • Some issues with the exists query not working in certain circumstances and for cores and brokers
    • The nonlings test would fail if the branch name had error in it. A check was put into eliminate this false negative test failure.
    • A few sporadic failure cases in the http and websocket tests
    • A build generation issue with disabling the ZMQ core
    • An error from the config interpreter where some flags were not getting correctly propagated to the Federate configuration.

    Added

    • A helics::zmq target was added for linking with zeromq if using HELICS as a subproject
    • A HELICS_BENCHMARK_SHIFT_FACTOR CMake option was added to allow the benchmarks to scale depending on computational resources
    • "version" and "version_all" queries to get the local version string and the version strings of all the cores/brokers in the federation
    • A few missing operations to the C++98 interface for Message objects, add helicsMessageClone and helicsEndpointCreateMessage functions in the C interface. Add a test case for some of the C++98 message operations.
    • helicsQuerySetTarget and helicsQuerySetQueryString operations to modify an existing query in the C interface
    • A set of reduction operations for multi-input handling on inputs, options for setting input source priority and the number of expected connections
    • A Watts-Strogatz like benchmark
    • A few more parameters that can be handled in the Webserver and support for use of uuid instead of name
    • A few missing message operators to the C++98 API, such as data, append, setFlag, checkFlag, sendMessageZeroCopy
    • Made the Message class return a self Reference for the setters
    • A test to run the helics-broker executable as part of the CI tests
    • A bug in the helics_broker that no longer ran correct defaults
    • A "version_all" query, to retrieve the version of HELICS in use for all cores/brokers, and a "version" query to retrieve the version of a specific target.
    • A series of checks for markdown, spelling, shellcheck, python formatting, cpplint, end-of-line and automated generation of PR scripts for the formatting updates.
    • Some level of automated scaling for benchmarks for small systems
    • API functions for retrieving the build flags used to generate the library
    • Some additional message interpreters to aid in debugging
    • A test using the standalone helics_broker to run an example
    Source code(tar.gz)
    Source code(zip)
    Helics-2.5.1-Linux-x86_64.tar.gz(12.95 MB)
    Helics-2.5.1-macOS-x86_64.zip(11.52 MB)
    Helics-2.5.1-msvc2017-win64.zip(8.20 MB)
    Helics-2.5.1-msvc2019-win64.zip(7.32 MB)
    Helics-2.5.1-win32.zip(9.02 MB)
    Helics-2.5.1-win64.exe(6.30 MB)
    Helics-2.5.1-win64.zip(10.30 MB)
    Helics-shared-2.5.1-Linux-x86_64.tar.gz(2.96 MB)
    Helics-shared-2.5.1-macOS-x86_64.tar.gz(2.06 MB)
    Helics-shared-2.5.1-win32.tar.gz(1.20 MB)
    Helics-shared-2.5.1-win64.tar.gz(1.36 MB)
    Helics-v2.5.1-SHA-256.txt(1.13 KB)
    Helics-v2.5.1-source.tar.gz(16.01 MB)
  • v2.5.0(Apr 27, 2020)

    Some library reorganization, additional static analysis(CppLint and clang-tidy), multiBroker, updates to the webserver including some new capabilities for creating and destroying brokers.

    Note: the helics_broker has a bug when using the implicit default core type; as a temporary workaround either run it with the --coretype argument or use the helics_app broker subcommand.

    Changed

    • Split the HELICS core library into a separate core and network library
    • Update FMT library to version 6.2.0
    • The core and broker Factories use a map instead of a fixed list which is a step toward allowing user defined cores
    • Updated CLI11 included code to customized version to allow configuration of cores and brokers through Json files
    • The ordering of the helics_error_types enum is in ascending order
    • Refactored the Matlab and Java swig interface builds to enable standalone builds

    Fixed

    • Added CPPlint and fixed a number of issues that check identified.

    Added

    • helicsEndpointSendMessageObjectZeroCopy to allow transferring messages with minimal copying.
    • helics<Interface>IsValid functions to the C API
    • helicscpp::cleanHelicsLibrary to the C++98 API.
    • A Comm factory to the Core to enable constructing Comm interfaces directly from the type.
    • The REST API in the webserver was updated to include ability to create and destroy brokers.
    • A websocket server similar to the REST API but will respond to JSON queries.
    • A test suite for the HTTP and websocket servers.
    • A Multibroker that can allow multiple communication types to interact together.
    • Support for HELICS_BUILD_CONFIGURATION cmake variable for building on unique platforms. The only supported one right now is "PI" for building on raspberry pi platforms.

    Deprecated

    • in the C shared library helicsFederateGetMessage, helicsEndpointGetMessage, and helicsEndpointSendMessage are deprecated in favor of the object version These will be removed in HELICS 3.0
    • deprecated helicsEndpointClearMessage this function does nothing right now, all messages are on a federate level.
    • Deprecated error functions in the C++ Federate API in favor of localError and globalError.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.5.0-Linux-x86_64.tar.gz(12.82 MB)
    Helics-2.5.0-macOS-x86_64.zip(11.27 MB)
    Helics-2.5.0-msvc2017-win64.zip(8.12 MB)
    Helics-2.5.0-msvc2019-win64.zip(7.27 MB)
    Helics-2.5.0-win32.zip(8.95 MB)
    Helics-2.5.0-win64.exe(6.32 MB)
    Helics-2.5.0-win64.zip(10.31 MB)
    Helics-shared-2.5.0-Linux-x86_64.tar.gz(2.93 MB)
    Helics-shared-2.5.0-macOS-x86_64.tar.gz(2.01 MB)
    Helics-shared-2.5.0-win32.tar.gz(1.18 MB)
    Helics-shared-2.5.0-win64.tar.gz(1.35 MB)
    Helics-v2.5.0-SHA-256.txt(1.13 KB)
    Helics-v2.5.0-source.tar.gz(15.90 MB)
  • v2.4.2(Mar 28, 2020)

    Increased code coverage and additional bug fixes.

    On March 31, 2020 support for installing HELICS using the Spack develop branch was added

    Changed

    • Update toml11 library to 3.3.1 with some warning fixes for C++17
    • The query handling in the core library was cleaned up to be more extensible and uniform

    Fixed

    • MacOS build with python 2.7 failure
    • Fixed some issues with the build/test process if the ENABLE_ZMQ_CORE=OFF
    • Fixed a potential issue with queries if they are triggered before the connection ack
    • An issue with host name resolution on some systems with restricted DNS lookup
    • Allow camelCase in file parameters from JSON
    • Fixed linking error with default OpenMPI Spack package
    • Fixed timing benchmark federate name

    Added

    • A series of tests for MessageFederate.cpp to increase coverage on that file to 100%
    • Callbacks for custom filters in the C shared library
    • A series of tests for CoreApp, BrokerApp, and FederateInfo and a few fixes for them
    • A few additional tests of helics supports types and conversions
    • CoreApp has a connect() and reset() method and constructor from a Core shared pointer
    • BrokerApp has a connect() method and constructor from a Broker shared pointer
    • Added a data_flow_graph query which gets all the connections in a federation
    Source code(tar.gz)
    Source code(zip)
    Helics-2.4.2-Linux-x86_64.tar.gz(11.87 MB)
    Helics-2.4.2-macOS-x86_64.zip(11.91 MB)
    Helics-2.4.2-msvc2017-win64.zip(8.04 MB)
    Helics-2.4.2-msvc2019-win64.zip(7.24 MB)
    Helics-2.4.2-win32.zip(8.16 MB)
    Helics-2.4.2-win64.exe(5.68 MB)
    Helics-2.4.2-win64.zip(9.40 MB)
    Helics-shared-2.4.2-Linux-x86_64.tar.gz(2.88 MB)
    Helics-shared-2.4.2-macOS-x86_64.tar.gz(1.98 MB)
    Helics-shared-2.4.2-win32.tar.gz(1.17 MB)
    Helics-shared-2.4.2-win64.tar.gz(1.34 MB)
    Helics-v2.4.2-SHA-256.txt(1.13 KB)
    Helics-v2.4.2-source.tar.gz(15.85 MB)
  • v2.4.1(Mar 7, 2020)

    Increased code coverage and additional bug fixes. The error propagation in HELICS was improved such that local errors can be escalated to global errors, and a federate can define errors coming from the federate that are handled appropriately and can halt a co-simulation.

    Note for macOS users there is a bug that will be fixed in the next release that prevents building the Python interface with SWIG -- this mostly impacts the small number of users on Python 2.7.

    Changed

    • The helics webserver will build by default if the conditions are met
    • Update filesystem library to v1.3.0
    • The behavior of the Federate*Complete operations is slightly modified to be uniform and consistent, no API changes
    • Configuration of flags and targets for interfaces in JSON and TOML files can be done in multiple sections
    • The benchmark federates have been changed to use a common base benchmark federate class for more consistent behavior
    • Switched to including netif as a git submodule
    • the error Function in the C++ API is now the same as localError previously it was primary useful for logging and didn't do much, and will be deprecated in the next minor release.
    • Updated the GitHub actions (clang-format, swig interface updates, and release builds) to use actions/[email protected]
    • Cleaned up the Windows installer (better component names/descriptions and groups, link to Gitter, and require installing Headers to install SWIG)
    • Updated the HELICS apps manpages with new options

    Fixed

    • Issue with iterative requests that were not being honored if the federate was acting in isolation
    • A few pathways which would allow segmentation faults if a federate was disconnected and particular functions were called
    • ValueFederate addIndexedTargets, the function template would not work as was written and was unusable, it is now tested and operational.

    Added

    • HELICS_DISABLE_WEBSERVER option to turn off building of the webserver. It will build by default if Boost is enabled and is version 1.70 or higher; otherwise it is disabled.
    • A series of tests for Federate.cpp to increase coverage on that file to 100%
    • A series of tests for ValueFederate.*pp to increase coverage on that file to 100%
    • Docker image for a helics builder which includes build tools and the helics installation
    • helics can be installed on MSYS2 using pacman.
    • Standalone benchmark federates for use in multinode benchmark runs
    • A FreeBSD 12.1 CI build using Cirrus CI
    • Sending an event from GitHub Actions release builds to trigger updating additional HELICS packages when a new release is made
    • localError, and GlobalError function calls the Federate API and in the C++ and sharedLibrary.
    • helics_terminate_on_error flag to escalate what would be a local error into a global one that will halt the co-simulation. This flag can be specified through the flag to federates or to brokers and cores through a command line option --terminate_on_error
    • addDependency function was added to the C++ Federate API and shared library API, it can add a direct dependency between federates manually.
    • A 32-bit Windows zip install archive for releases
    • "global_time", "current_time", and "state" queries for brokers and cores, and "current_time" query for federates.
    • Support for a 'helics-release-build' event trigger to the release build GitHub Actions workflow

    Deprecated

    Removed

    • HELICS_ENABLE_WEBSERVER option to enable the webserver. This option was added as experimental in 2.4.0
    • VS2015 Windows Server 2012 CI build is removed. Azure Pipelines is removing the image because it is outdated and sees little use. VS2015 is still tested through Appveyor for the time being.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.4.1-Linux-x86_64.tar.gz(12.17 MB)
    Helics-2.4.1-macOS-x86_64.zip(12.26 MB)
    Helics-2.4.1-msvc2017-win64.zip(8.01 MB)
    Helics-2.4.1-msvc2019-win64.zip(7.20 MB)
    Helics-2.4.1-win32.zip(8.30 MB)
    Helics-2.4.1-win64.exe(5.82 MB)
    Helics-2.4.1-win64.zip(9.56 MB)
    Helics-shared-2.4.1-Linux-x86_64.tar.gz(2.87 MB)
    Helics-shared-2.4.1-macOS-x86_64.tar.gz(1.97 MB)
    Helics-shared-2.4.1-win32.tar.gz(1.16 MB)
    Helics-shared-2.4.1-win64.tar.gz(1.33 MB)
    Helics-v2.4.1-SHA-256.txt(1.13 KB)
    Helics-v2.4.1-source.tar.gz(15.84 MB)
  • v2.4.0(Feb 5, 2020)

    Important note for macOS 10.15 Catalina users: Apple made running unsigned apps more strict, downloading and running the helics binaries in the macOS package will get blocked. A workaround is to download the package using curl in Terminal instead. e.g. curl -LO https://github.com/GMLC-TDC/HELICS/releases/download/v2.4.0/Helics-2.4.0-macOS-x86_64.zip.

    A few bug fixes, code coverage on the shared library increased to 100%, library updates, Broker server enhancements including an http REST API, and a lot of work on the build systems to enable easier releases and packaging.

    Changed

    • filesystem include updated to 1.2.10
    • CLI11 updated to 1.9
    • fmt updated to 6.1.2
    • variant header updated to latest release
    • Update the units library (v0.3.0)
    • The TOML interpreter used in HELICS was changed to toml11
    • Some unnecessary files were removed from the all source package
    • some internal CMake options and messages were not using new format for message
    • Major updates to the python modules build system including merging the python3 and python 2 builds into the same CMake generator
    • CMake cleanup and formatting
    • A series of changes to the build for more widely supported installations on Linux and MacOS
    • The .clang-format file was modified slightly and the entire code base reformatted to the new specification
    • the metadata information for the benchmarks was updated
    • The FilterOperator class was altered to include a vector output for use with cloning
    • TCP and UDP core types are not by default backwards compatible with <2.4 brokers. The flag "--noack_connect" will need to be passed as part of the coreinitialization string to allow this to work if need be. ZMQ_SS cores are not considered interoperable with <2.4 brokers due to a number of bugs. In a few select cases it might still work.

    Fixed

    • macOS rpath information on the built binaries
    • Some issues with swig include directories to allow it to work in other circumstances
    • an issue with building the java interface in MSYS2
    • an issue with the HELICS_USE_NEW_PYTHON_FIND CMake option
    • Some thread sanitizer identified issues
    • A series of issues from static analyzers
    • an issue in the shared library create core that could emit an exception
    • A series of issues related to remote cloning filters not being inline
    • Several issues with the zmqss core type it is not backwards compatible with <2.4 brokers
    • The code coverage on the C shared library was increased to 100% and a number of small bugs fixed as a result. The overall coverage increased to 71.5%

    Added

    • Several installers for Linux and Mac and builds for pip install
    • Allow standalone builds for the python interface
    • Added a Ring Message benchmark, like the ring Benchmark except using messages as the token
    • Added a Multinode phold benchmark
    • Added a c shared library echo benchmark
    • git logic to check if the submodules are at the correct version
    • an option for a githook to check the formatting
    • git warning if the submodule versions are not at the correct version
    • a timing benchmark similar to the echo benchmark
    • a number of tests for the C shared library including evil tests for testing bad input
    • Hooks to test the coverage builds
    • a feature to mark a broker or federate as slow responding so it doesn't time out automatically
    • EditorConfig and .gitattributes for cleaner diff and automatic editor configuration
    • An incorrect call in the Matlab swig code was fixed
    • Automatic generation of pull requests for source code formatting
    • Add metadata information to the benchmarks for automatic processing
    • Broker server functionality for tcp core, zmqss core, and udp core
    • An experimental web server that can be used with the broker server or the broker executables. (requires boost 1.70+ to build)
    • man pages for the helics applications

    Deprecated

    • The ZMQ_SS core type is not generally compatible between 2.3 and 2.4 Minor releases due to bug fixes.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.4.0-Linux-x86_64.tar.gz(12.11 MB)
    Helics-2.4.0-macOS-x86_64.zip(12.18 MB)
    Helics-2.4.0-msvc2017-win64.zip(7.99 MB)
    Helics-2.4.0-msvc2019-win64.zip(7.16 MB)
    Helics-2.4.0-win64.exe(7.01 MB)
    Helics-2.4.0-win64.zip(11.51 MB)
    Helics-shared-2.4.0-Linux-x86_64.tar.gz(2.86 MB)
    Helics-shared-2.4.0-macOS-x86_64.tar.gz(1.95 MB)
    Helics-shared-2.4.0-win32.tar.gz(1.39 MB)
    Helics-shared-2.4.0-win64.tar.gz(1.58 MB)
    Helics-v2.4.0-SHA-256.txt(1.05 KB)
    Helics-v2.4.0-source.tar.gz(15.70 MB)
  • v2.3.1(Nov 23, 2019)

    Bug Fixes and some code refactoring, pkg-config files have been added to the installs

    Changed

    • Default installation path for MSYS2 is now configured to be part of the system path, typically /mingw64/ or /mingw32/
    • HELICS_ENABLE_SLOW_PACKAGING_TESTS renamed to HELICS_ENABLE_SUBPROJECT_TESTS to better reflect usage
    • filesystem library updated to clear up some warnings
    • The CI system now runs Xcode9 as the oldest release
    • Automatic releases build system was changed to use scripts

    Fixed

    • Some documentation links in the docs
    • Missing helics-enums.h header from the install if HELICS_BUILD_CXX_SHARED_LIB was not enabled
    • ZMQ install locations on Linux and macOS if ZMQ is used as a subproject without the HELICS_USE_ZMQ_STATIC_LIB option enabled
    • The linux shared library release build so it is compatible with a larger number of systems including older ones back to glibc 2.12.
    • Fix some documentation and issues with using the STATIC_STANDARD_LIB CMake option

    Added

    • CMake option for HELICS_DISABLE_ASIO to completely remove the use the ASIO library, turns off the UDP, and TCP core types, all real-time capabilities, and timeout and heartbeat detection for cores and brokers. ASIO doesn't support all version of cygwin.
    • pkg-config files for the shared libraries are now installed to <prefix>/lib/pkg-config on unix like systems
    • Tests and CI builds for installed CMake package files and pkg-config files

    Deprecated

    • Trying to install on linux/macos systems with cmake older than 3.13 and ZMQ used as a subproject with the shared library is no longer supported. It is likely this use scenario was broken before, now it produces a warning.

    Removed

    • If HELICS_BUILD_BENCHMARKS is enabled, the option for ENABLE_INPROC_CORE will not show in the cmake-gui.
    • If HELICS_BUILD_TESTS is enabled, the option for ENABLE_TEST_CORE will not show in the cmake-gui.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.3.1-Darwin.tar.gz(11.21 MB)
    Helics-2.3.1-msvc2017-win64.zip(7.84 MB)
    Helics-2.3.1-msvc2019-win64.zip(7.06 MB)
    Helics-2.3.1-win64.exe(8.64 MB)
    Helics-2.3.1-win64.zip(15.05 MB)
    Helics-shared-2.3.1-Darwin.tar.gz(1.71 MB)
    Helics-shared-2.3.1-Linux.tar.gz(2.65 MB)
    Helics-shared-2.3.1-win32.tar.gz(1.83 MB)
    Helics-shared-2.3.1-win64.tar.gz(2.18 MB)
    Helics-v2.3.1-SHA-256.txt(958 bytes)
    Helics-v2.3.1-source.tar.gz(17.73 MB)
  • v2.3.0(Nov 14, 2019)

    Minor release with lots of CMake updates and build changes and a few fixes and additions. The biggest change is in the C++ shared library and complete removal of boost::test.

    Changed

    • Converted the shared_library_tests and application_api tests to use Google test instead of Boost test
    • Most HELICS CMake options have changed to HELICS_**, with the exception of BUILD_XXX_INTERFACE, and ENABLE_XXX_CORE. These options will not change until HELICS 3.0, at which point all HELICS related CMake options that are not standard CMake options will have a leading HELICS_
    • The version string printed by HELICS will include git hash codes and base version information for non-release builds
    • Some attempts were made to further modernize the usage in CMake. This effort ended up fixing a few bugs in certain conditions and simplifying things, and the CMake code was also run through a formatter
    • The exported C++ shared library has been heavily modified to only include functions in the public API, and is now the recommended way to link with HELICS directly in a C++ program. A HELICS::helics-shared target is now available for linking through CMake. If libraries were previously linking with the installed static library this is a BREAKING Change. Those previously linking with the C++ shared library may also need modifications. Changes include:
      • The coreFactory and brokerFactory headers are deprecated as part of the public headers, they are still used internally but should not be used by linking libraries. The public version will remain stable but show deprecated messages. The internal version used by the core will likely be modified in the future.
      • New headers for CoreApp and BrokerApp can be used to provide nearly all the same capabilities in the application API.
      • New headers typeOperations.hpp and timeOperations.hpp were added to the application_api to provide string operations for the time and core types. In the shared-library core-time, and core-type headers included these headers but that will be deprecated in the future.
      • CMake options for building utilities/units/json as object libraries have been removed as they were no longer needed.
      • The cereal library is moved to the external folder in the helics directory and is now required to be available for the C++ shared library, so a CMake variable making it optional was removed.
      • The reason for this change was partly as a stepping stone for other internal library changes, and to simplify the build complexity and allow more flexibility in linking libraries without impacting the installed interfaces. The previous methods and installed libraries were coming into conflict with other packages and posing increasing challenges in maintenance and linking. This change forced more separation in the HELICS layers, and the installed libraries and simplified a lot of the build generation scripts.
    • CLI11, utilities, filesystem and units libraries were updated with latest revisions.

    Fixed

    • Race condition when removing subscriptions or targets from an interface
    • Fixed mistakenly excluded tests and the resulting failures in the CI builds
    • Some of the interface functions (Python, Java, etc) were generating incorrect code for getting raw data from inputs.
    • The language API's were not handling Ctrl-C user disconnects well, so some fixes were added to handle that situation better.

    Added

    • A set of included HELICS benchmarks using the Google benchmark library.
      • echo benchmark
      • echo message benchmark
      • ring benchmark
      • PHOLD benchmarks for single machine
      • message size and count benchmark
      • filter benchmark based on echo message benchmark
      • actionMessage benchmarks
      • data conversion benchmarks
    • The src, test, benchmarks directory can now be used as a root directory for CMake to do the appropriate build with few options.
    • Dedicated internal functions for conversion of bool operators, strings such as "off", "false", "disabled", "inactive" are now supported as valid bool values that can be passed.
    • Shared libraries for the C++ Application api and apps library are built and installed containing only public API functions and classes. potential breaking change as the CMake library names have changed and the C++ shared library is modified
    • Tests executing and linking with the shared libraries
    • Example linking with the shared libraries
    • a build_flags_target is exported with flags that may effect compilation
    • a compile_flags_target is exported, mostly for seeing which non-abi related flags HELICS was built with.
    • a helicsXXXMakeConnections function which takes a file to establish linkages for Core and Broker to the C shared API.
    • Automated generation of interface code for Python, Matlab, and Java interfaces and automatic PR's with the changes
    • Overloads of federate creation functions in C++ for CoreApp
    • Overloads of filter creation function in C++ to use CoreApp
    • Docstrings were added using swig -doxygen to Python, Python2 and Java interfaces
    • Add "queries" query to core, federate, and broker which gets a list of available queries
    • Add "isconnected", "filters", "inputs" query to core to retrieve list of available filters and inputs, and if the core is connected.
    • Added an INPROC core type, which replaces the TEST core for most user uses, the TEST core does the same thing but has additional functionality to mock network issues for testing, more of these capabilities will be added. The INPROC core will remain simplified and as fast as possible for in process federations.
    • Windows CI builds for visual studio 2019, 2017, 2015 on Azure, reduced workload on Appveyor.
    • Automatic release file generation for a shared library package on macOS and Linux, and a more complete macOS installation archive. Supported versions are macOS Catalina 10.15 and Ubuntu 18.04, though the macOS binaries might work as far back as 10.11 and the Linux binary should work for older versions and different distributions.

    Deprecated

    • Use of coreFactory and brokerFactory when using the C++ shared library (use CoreApp and BrokerApp instead)
    • coreType and helics-time string conversion functions are no longer defined in the helics-time header. They are still there currently but are deprecated and will be removed in HELICS 3.0 use the typeOperations.hpp and timeOperations.hpp header instead which now defines those functions.

    Removed

    • All tests using boost::test have now been replaced with Google test, so references and linking to boost::test has been removed
    • Exporting and installing the static libraries has been removed (they can still be used by using HELICS as a CMake subproject)
    • CMake option to exclude static libs from the install has been removed as no longer needed
    • CMake options for building JSONCPP, Utilities, and units libraries as object libraries have been removed as object libraries are no longer being used
    • JSONCPP, Utilities, and units libraries are no longer installed in any form, libraries or headers.
    • CMake option to install CEREAL headers (they are now required, but are in a different location)
    Source code(tar.gz)
    Source code(zip)
    Helics-2.3.0-Darwin.tar.gz(4.63 MB)
    Helics-2.3.0-msvc2017-win64.zip(7.85 MB)
    Helics-2.3.0-msvc2019-win64.zip(7.08 MB)
    Helics-2.3.0-win64.exe(1.81 MB)
    Helics-2.3.0-win64.zip(4.45 MB)
    Helics-shared-2.3.0-Darwin.tar.gz(1.72 MB)
    Helics-shared-2.3.0-win32.tar.gz(1.29 MB)
    Helics-shared-2.3.0-win64.tar.gz(1.50 MB)
    Helics-v2.3.0-source.tar.gz(17.72 MB)
  • v2.2.2(Oct 28, 2019)

    [2.2.2] ~ 2019-10-27

    Bug fix release for a timeout regression from 2.2.1,

    Fixed

    • Links in the README changed with an automated move to travis-ci.com
    • Fix issue #853, which was causing core connections to timeout if no direct communication was observed for a period of time. This bug fix release fixes that issue where the pings were not being correctly accounted for in the timeout detection.
    • Fix Ctrl-C issue when using HELICS in some language api's (Python and Julia) others may be added in 2.3
    Source code(tar.gz)
    Source code(zip)
    Helics-2.2.2-msvc2017-win64.zip(67.77 MB)
    Helics-2.2.2-msvc2019-win64.zip(60.88 MB)
    Helics-2.2.2-win64.exe(6.08 MB)
    Helics-2.2.2-win64.zip(10.39 MB)
    Helics-shared-2.2.2-win64.tar.gz(1.73 MB)
    Helics-v2.2.2-SHA-256.txt(567 bytes)
    Helics-v2.2.2-source.tar.gz(18.46 MB)
  • v2.2.1(Sep 27, 2019)

    Minor release with bug fixes and a few additional features

    Changed

    • helics apps tests is converted to use Google test and is now being run through the sanitizers
    • BREAKING CHANGE The C interface helics logging callback specifications now include a user data object. This is technically a breaking change, but there were a few issues with the current implementation so it is not entirely clear it was usable as it was. There are now some tests for the functionality. This log callback specification was not available in the language API's and the C++ API has not changed, only the C interface to specifying direct logging callbacks. This is considered a minor change due to no known users of this interface at present and as it was it wasn't entirely operational. No further changes are expected.
    • The use of Boost C++ in the helics core and application api are now limited to the IPC core(there are no plans to remove this usage) and an option to DISABLE_BOOST is available in the CMAKE files. This will turn off the IPC_CORE and any optional uses of boost in some of the libraries. Future features may use Boost but should retain the ability to disable its use.
    • BREAKING CHANGE Some function names in the C++98 API were changed to better match the C++ API and were documented more completely through doxygen, these were listed as potentially changing in the Public API so this is not a consideration for semantic versioning. The C++98 API also has limited numbers of users at this point yet and may not be fully stable until HELICS 3.0 release
    • The doxygen cmake project was renamed from doc to helics_doxygen
    • several variables used by submodules in cmake were hidden
    • updated zmq subproject version to 4.3.2

    Fixed

    • There was a 32 bit issue when using certain vector operation functions in HELICS when compiled with 32 bit, this was preventing the arm 32 from running the tests fully. This issue has been fixed.
    • Fixed a race condition related to queries of subscriptions and inputs of a federate if done remotely. The core could lock or a race condition could occur.
    • some issues related to file logs
    • started to address some recommendations for include-what-you-use
    • The cmake conditions for building the C# interface and Python2 interface were not completely correct and incorrectly showed an error which was also incorrectly ignored, so it all worked unless there was an actual error, but those issues have been resolved.

    Added

    • logMessage functions in the federate for user specified log messages and levels
      • logDebugMessage, logWarningMessage, logErrorMessage, logInfoMessage function in all API's to simplify common logging operations
    • function to set the log file from the core C++ API
    • A CMAKE option to disable BOOST entirely DISABLE_BOOST
    • A CMAKE option HELICS_BINARY_ONLY_INSTALL which will restrict the install to executables and shared libraries with no headers or static libraries.
    • Some CMAKE capabilities to better generate the interface files.
    • Timeouts on the broker for broker connections, more work is likely needed in the future but for now if a path times out, if things were already disconnecting it assumes it is the equivalent of a disconnect, and if not the federation errors and terminates.
    • Automatic release file generation for visual studio builds, windows installers, full source code tar files, and a shared library package.

    Removed

    • The included build files for the Octave interface have been removed. It is now required to use swig to build these files. The interface file was only valid for Octave 4.2 and had potential to break in later versions. Given the 3 versions of octave in common use it was deemed prudent to just remove the included file and require swig to generate the correct interface, this may be added back in the next release if more testing shows this to not be an issue.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.2.1-msvc2017-win64.zip(67.77 MB)
    Helics-2.2.1-msvc2019-win64.zip(60.88 MB)
    Helics-2.2.1-win64.exe(6.08 MB)
    Helics-2.2.1-win64.zip(10.38 MB)
    Helics-shared-2.2.1-win64.tar.gz(1.73 MB)
    Helics-v2.2.1-SHA-256.txt(567 bytes)
    Helics-v2.2.1-source.tar.gz(18.46 MB)
  • v2.2.0(Aug 29, 2019)

    Minor release with some updates to the networking portion of HELICS and some API additions.

    Changed

    • Submodule updates for filesystem, libfmt, and google test
    • A utilities lib containing many string processing and small functions is now used instead of directly including it.

    Fixed

    • A error response to a core registration will immediately generate an error on federates waiting for registration instead of waiting for a timeout
    • HELICS can now compile with standalone mingw and cygwin 32 bit on Windows. ASIO is not compatible with Cygwin 64 bit so no support for that is expected in the near future. Tests in travis exercise the MinGW build.
    • Some issues with the ZMQ core generating an error on close due to incorrect builds of ZMQ in some installations.
    • Some changes to the network interface selection process that cause issues on certain platforms.

    Added

    • The ability to specify a broker key for brokers and cores to limit linking to those cores with the appropriate key
    • A units library into HELICS, mismatched units are checked and units published as a double with units on the publication and subscription converted internally
    • A new API for messages in the C interface. The old interface has difficulties when working with binary data in the message structure. So a message object API was created with appropriate methods to access the data. The previous message API will be deprecated in release 2.3 and removed in 3.0.
    • A clone app for cloning an existing federate including all publications and subscriptions and all data that is being sent out. It is accessible through the helics_app clone subcommand
    • CI tests using docker for clang sanitizers and the octave interface.
    • Scripts for generating a single zip file with all the code including submodules. This will be generated for each new release.
    • A broker server that generate multiple brokers on a single system and handles the port allocation intelligently. (Only ZMQ currently supported, this is not backwards compatible, though regular 2.2 brokers should work with 2.1 federates if needed.)
    • A Docker image containing the HELICS apps (available on Docker Hub for tagged releases and the latest develop branch at https://hub.docker.com/r/helics/helics)

    Removed

    • ENABLE_SWIG option in cmake as always ON. This option will only appear for interfaces that have existing build files. For swig generated interfaces that do not have prebuilt files (octave, python2, and C#) this option will no longer appear as swig is required.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.2.0-win64.7z(10.76 MB)
    Helics-2.2.0-win64.exe(12.68 MB)
    Helics-v2.2.0.tar.gz(18.33 MB)
  • v2.1.1(Jul 17, 2019)

    Minor release which fixes a few bugs and add some JSON related input and queries

    Changed

    • moved concurrency related structures to a standalone library
    • System-tests is now based on google test instead of boost test
    • Shared_libary_cpp tests now based on google_test instead of boost test
    • the deserializer for ActionMessage now uses memcpy to avoid possible undefined behavior
    • The value of helics_time_maxtime has been changed for consistency with the C++ equivalent
    • The return type of the helicsCLI11App is now named parse_output instead of parse_return
    • fmt and googletest were updated to latest version

    Fixed

    • a few possible race conditions found by thread-sanitizer
    • cleared up a couple scenarios that were triggering occasional test failure in the system tests
    • helics_broker and helics_app were returning non-zero return values when --version or --help were used, they now return 0 in those cases
    • a small memory leak when a JSON stream builder was created and not destroyed properly
    • an inconsistency between the helics_time_maxtime in the C shared library and the maxTime value used in C++, this could in some cases result in failing termination conditions

    Added

    • queries for getting all current inputs in JSON format.
    • query for getting all updated inputs in JSON format
    • publication function that accepts a JSON structure for multiple publications
    • registration function that generates publications based on same JSON structure as the function that accepts JSON for group publication
    • function on the inputs to clear the updates, is used from a query
    • a const version of the isUpdated function call on inputs
    • Shared OBJECT (SO) versions to the shared libraries

    Removed

    • libguarded and several concurrency related structures as they are now in a standalone repository that is included through submodules
    Source code(tar.gz)
    Source code(zip)
    Helics-2.1.1-python27-win32.exe(7.18 MB)
    Helics-2.1.1-python27-win64.exe(9.11 MB)
    Helics-2.1.1-win64.7z(9.14 MB)
    Helics-2.1.1-win64.exe(11.32 MB)
  • v2.1.0(Jun 30, 2019)

    The main focus of this minor release is cleaning up the build system and extracting required compiled libraries from the HELICS build process, no changes in the C API, and a few additions and deprecations in the C++ API related to command line arguments.

    Changed

    • remove use of boost::program options and replace usage with CLI11
    • remove boost::asio and replace with a submodule for ASIO
    • remove included fmt code and replace with submodule
    • remove JsonCpp code and replace with a submodule which generates a compiled library - this removed the need to continually regenerate the single header/file with customized namespaces, though if you are using the helics-static library built with a separate JsonCpp static library, the HELICS copy of the jsoncpp static library must be linked with manually (for build systems other than CMake such as waf, meson, premake, etc). Also included is an option to incorporate JsonCpp as an object library within a single helics-static library (default on macOS/Linux), and create a target HELICS::jsoncpp_headers.
    • extract several containers used in HELICS to a separate repository for better maintenance and possible reuse elsewhere. Any reference to the containers library was removed from the Public API.
    • all required references to boost were removed from the public API.
    • the logger headers were split into two sections. The logger.h which includes the logger objects for use in federates was split from the loggerCore which is not publicly accessible.
    • The command line arguments are error checked and the help prints all available options (thanks to CLI11)
    • the core tests and common tests now use google test instead of boost test. More tests are expected to be migrated in the future.
    • updates to the HELICSConfig.cmake file that gets installed to be more resilient to different directory structures.
    • use ZMQ as a subproject if needed instead of an autobuild and install it as a target if needed. The CMake option to enable this is ZMQ_LOCAL_BUILD, replacing AUTOBUILD_ZMQ.
    • the cereal library is not installed by default except on visual studio, and there is a CMAKE option to install it HELICS_INSTALL_CEREAL
    • some updates to the noexcept policy on c++98 interface

    Fixed

    • an issue with the isUpdated function not registering access (mainly an issue in the C and language interfaces), Issue #655
    • certain flags when used with certain brokers could cause errors, Issue #634
    • potential issue with only_update_on_change_flag when used at the federate level, along with some tests

    Added

    • the HELICS library can now operate as a subproject in a larger cmake project if needed
    • tcp cores have a --reuse-address flag to allow multiple brokers on the same port, mostly useful for the test suite to prevent spurious failures due to the OS not releasing tcp ports in a timely manner.
    • several C++ api functions for using a vector of strings as command line arguments, in the federates and in the broker/core factory, this is related to the transition to CLI11
    • tests for building HELICS with musl instead of glibc
    • tests for building HELICS on ARM/ARM64

    Removed

    • tested support of XCode 6.4 and 7.3; these probably still work but we are not testing them anymore.
    Source code(tar.gz)
    Source code(zip)
    Helics-2.1.0-win64.7z(9.08 MB)
    Helics-2.1.0-win64.exe(11.26 MB)
Owner
GMLC-TDC
Repository for the GMLC TDC tool suite - HELICS
GMLC-TDC
LiteX is a Migen/MiSoC based Core/SoC builder that provides the infrastructure to easily create Cores/SoCs (with or without CPU).

LiteX is a Migen/MiSoC based Core/SoC builder that provides the infrastructure to easily create Cores/SoCs (with or without CPU). The common components of a SoC are provided directly: Buses and Streams (Wishbone, AXI, Avalon-ST), Interconnect, Common cores (RAM, ROM, Timer, UART, etc...), CPU wrappers/integration, etc... and SoC creation capabilities can be greatly extended with the ecosystem of LiteX cores (DRAM, PCIe, Ethernet, SATA, etc...) that can be integrated/simulated/build easily with LiteX.

null 1.7k Aug 10, 2022
DICOM images and volumes viewer with advanced processing infrastructure (WPF, ITK, VTK)

DicomViewer DICOM images and volumes viewer with advanced processing infrastructure Stack: WPF (C#) ITK (C++) VTK (C++) Structure: DicomViewer - WPF a

Paweł Piorun 0 Jul 1, 2022
This repo contains source code of our paper presented in IROS2021 "Single-Shot is Enough: Panoramic Infrastructure Based Calibration of Multiple Cameras and 3D LiDARs"

Single-Shot is Enough: Panoramic Infrastructure Based Calibration of Multiple Cameras and 3D LiDARs Updates [2021/09/01] first commit, source code of

Alibaba 62 Jul 23, 2022
Fast, hierarchical, sparse Voxel Grid

Treexy is a library that implements a compact hierarchical data structure that can store and manipulate volumetric data, discretized on a three-dimens

Davide Faconti 288 Aug 16, 2022
Treexy is a library that implements a compact hierarchical data structure that can store and manipulate volumetric data, discretized on a three-dimensional grid

Treexy is a library that implements a compact hierarchical data structure that can store and manipulate volumetric data, discretized on a three-dimens

Davide Faconti 284 Aug 8, 2022
Fast, hierarchical, sparse Voxel Grid

Treexy is a library that implements a compact hierarchical data structure that can store and manipulate volumetric data, discretized on a three-dimens

Davide Faconti 274 Aug 7, 2022
Example code for the research paper "Masked Software Occlusion Culling"; implements an efficient alternative to the hierarchical depth buffer algorithm.

MaskedOcclusionCulling This code accompanies the research paper "Masked Software Occlusion Culling", and implements an efficient alternative to the hi

null 532 Aug 10, 2022
A cheap,simple,Ongeki controller Use Keyboard Simulation and Mouse Simulation to controller the ongeki game. Using Pro-micro control.

N.A.G.E.K.I. A cheap,simple,Ongeki controller Use Keyboard Simulation and Mouse Simulation to controller the ongeki game. Using Pro-micro control. 中文版

NanaNana 28 Jul 21, 2022
A cheap,simple,Ongeki controller Use Keyboard Simulation and Mouse Simulation to controller the ongeki game. Using Pro-micro control.

N.A.G.E.K.I. PLEASE CHECK Main Project A cheap,simple,Ongeki controller Use Keyboard Simulation and Mouse Simulation to controller the ongeki game. Us

NanaNana 11 Dec 30, 2021
A PIC/FLIP fluid simulation based on the methods found in Robert Bridson's "Fluid Simulation for Computer Graphics"

GridFluidSim3d This program is an implementation of a PIC/FLIP liquid fluid simulation written in C++11 based on methods described in Robert Bridson's

Ryan Guy 714 Jul 26, 2022
A Particle Library for the Exa-Scale

PartExa - A Particle Library for the Exa-Scale PartExa is an open-source particle library written in C++ using state-of-the-art programming techniques

null 12 Feb 17, 2022
A Multi-Scale Model for Simulating Liquid-Fabric Interactions

libWetCloth libWetCloth is an open source project for the physical simulation of liquid and wet cloth or yarns. It has been compiled and tested on Mac

Raymond Yun Fei 383 Jul 30, 2022
Offline fluid simulation solver adopted from https://github.com/doyubkim/fluid-engine-dev.

FluidEngine This is a fluid simulation engine for computer graphics applications. I adopt it from Doyub Kim's fluid-engine-dev. It's built on C++11 an

YangWC 53 Jul 20, 2022
Fluid simulation engine for computer graphics applications

Fluid Engine Dev - Jet Jet framework is a fluid simulation engine SDK for computer graphics applications that was created by Doyub Kim as part of the

Doyub Kim 1.4k Aug 9, 2022
A CUDA-accelerated cloth simulation engine based on Extended Position Based Dynamics (XPBD).

Velvet Velvet is a CUDA-accelerated cloth simulation engine based on Extended Position Based Dynamics (XPBD). Why another cloth simulator? There are a

Vital Chen 28 Aug 7, 2022
A C++11 large integer library with effective high performance, simplistic in nature and also clean in the eyes.

BigIntegerCPP BigIntegerCPP is a C++11 port of large integer library used in CryptoLib4Pascal. It allows mostly parsing of numbers as strings in diffe

Telepati 25 Apr 22, 2022
A large mechanical 7-segment clock using cheap stepper motors.

mechanical-7-segment-clock A large mechanical 7-segment clock using cheap stepper motors. Each digit requires its own controller board. The seconds di

null 44 Aug 1, 2022
weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

weggli is a fast and robust semantic search tool for C and C++ codebases. It is designed to help security researchers identify interesting functionality in large codebases.

Google Project Zero 1.8k Aug 12, 2022
Finds problems in C++ source that slow development of large code bases

cppclean Goal cppclean attempts to find problems in C++ source that slow development in large code bases, for example various forms of unused code. Un

Steven Myint 635 Aug 11, 2022