org.javafmi.wrapper.Simulation Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of fmu-wrapper Show documentation
javaFMI is a Java Library for the functional mock-up interface (or FMI). FMI defines a standardized interface to be used in computer simulations. The FMI Standard has beed developed by a large number of software companies and research centers that have worked in a cooperation project under the name of MODELISAR. This library addresses the connection of a java application with a FMU (functional mock-up unit).
There is a newer version: 2.26.5
Show newest version
/*
 *  Copyright 2013-2016 SIANI - ULPGC
 *
 *  This File is part of JavaFMI Project
 *
 *  JavaFMI Project is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU Lesser General Public License as published by
 *  the Free Software Foundation, either version 3 of the License.
 *
 *  JavaFMI Project is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU Lesser General Public License for more details.
 *
 *  You should have received a copy of the GNU Lesser General Public License
 *  along with JavaFMI. If not, see .
 */

package org.javafmi.wrapper;

import org.javafmi.modeldescription.FmiVersion;
import org.javafmi.modeldescription.ModelDescription;
import org.javafmi.modeldescription.ScalarVariable;
import org.javafmi.proxy.FmuFile;
import org.javafmi.proxy.FmiProxy;
import org.javafmi.proxy.ProxyFactory;
import org.javafmi.proxy.Status;
import org.javafmi.wrapper.variables.BatchRead;
import org.javafmi.wrapper.variables.SingleRead;
import org.javafmi.wrapper.variables.VariableReader;
import org.javafmi.wrapper.variables.VariableWriter;

import java.util.List;


@SuppressWarnings("Convert2MethodRef")
public class Simulation {

    private static final long DEFAULT_TIMEOUT = 1000;
    private FmuFile fmuFile;
    private ModelDescription modelDescription;
    private FmiProxy proxy;
    private VariableWriter variableWriter;
    private VariableReader variableReader;
    private double currentTime;
    private double stopTime;
    private double startTime;

    protected Simulation() {
    }

    public Simulation(String fmuPath) {
        this(fmuPath, DEFAULT_TIMEOUT);
    }

    /**
     * @deprecated timeout is no longer needed
     */
    @Deprecated
    public Simulation(String fmuPath, long timeout) {
        this(new FmuFile(fmuPath));
    }

    Simulation(FmuFile fmuFile) {
        this.proxy = ProxyFactory.createProxy(fmuFile.getModelDescription(), fmuFile.getLibraryPath());
        this.modelDescription = fmuFile.getModelDescription();
        this.fmuFile = fmuFile;
        this.proxy.instantiate(fmuFile.getResourcesDirectoryPath());
        this.createVariableHandlers();
        this.setVariablesWithInitialAsExact();
    }

    protected static FmiProxy getProxy(Simulation simulation) {
        return simulation.proxy;
    }

    private void createVariableHandlers() {
        this.variableWriter = new VariableWriter(proxy, modelDescription);
        this.variableReader = new VariableReader(proxy, modelDescription);
    }

    private void setVariablesWithInitialAsExact() {
        if (!supportsInitial()) return;
        for (ScalarVariable scalarVariable : getModelDescription().getModelVariables()) {
            if (hasInitialAsExact(scalarVariable)) {
                variableWriter.write(scalarVariable.getName(), scalarVariable.getStart());
            }
        }
    }

    private boolean supportsInitial() {
        return proxy.getVersion().equals(FmiVersion.Two);
    }

    private boolean hasInitialAsExact(ScalarVariable scalarVariable) {
        return scalarVariable.getInitial().equals("exact");
    }

    public ModelDescription getModelDescription() {
        return modelDescription;
    }

    public Status init(double startTime) {
        return init(startTime, Double.NaN);
    }

    public Status init(double startTime, double stopTime) {
        this.startTime = startTime;
        this.currentTime = startTime;
        this.stopTime = stopTime;
        return proxy.initialize(startTime, stopTime);
    }

    public Status doStep(double stepSize) {
        Status doStepStatus = proxy.doStep(currentTime, stepSize);
        if (doStepStatus == Status.OK) currentTime += stepSize;
        return doStepStatus;
    }

    public Status cancelStep() {
        return proxy.cancelStep();
    }

    public Status terminate() {
        Status terminateStatus = proxy.terminate();
        proxy.freeInstance();
        return terminateStatus;
    }

    public Status reset() {
        Status resetStatus = proxy.reset();
        if (resetStatus.equals(Status.OK)) currentTime = startTime;
        return resetStatus;
    }

    /**
     * @deprecated better use:
     * double var = simulation.read(name).asDoubles()
     * int var = simulation.read(name).asInteger()
     * bool var = simulation.read(name).asBoolean()
     * String var = simulation.read(name).asString()
     */
    @Deprecated
    public Variable readVariable(String variableName) {
        return variableReader.read(variableName);
    }

    /**
     * @deprecated better use:
     * simulation.write(var1).with(value1)
     * take into account the type of the value should be as defined in the model
     */
    @Deprecated
    public Status writeVariable(String name, Object value) {
        return variableWriter.write(name, value);
    }

    public boolean isTerminated() {
        return proxy.isTerminated() || (!Double.isNaN(stopTime) && currentTime >= stopTime);
    }

    public double getCurrentTime() {
        return currentTime;
    }

    /**
     * @deprecated better use:
     * simulation.write(var1, var2, ...).with(value1, value2, ...)
     * take into account the type of the value should be as defined in the model
     */
    @Deprecated
    public void writeVariables(List variablesToWrite) {
        variableWriter.write(variablesToWrite.toArray(new Variable[variablesToWrite.size()]));
    }

    /**
     * @deprecated better use:
     * double[] var = simulation.read(name1, name2, ...).asDoubles()
     * int[] var = simulation.read(name1, name2, ...).asIntegers()
     * bool[] var = simulation.read(name1, name2, ...).asBooleans()
     * String[] var = simulation.read(name1, name2, ...).asStrings()
     */
    @Deprecated
    public Variable[] readVariables(String[] variableNames) {
        return variableReader.read(variableNames);
    }

    public WriteCall write(String... variablesNames) {
        return new WriteCall(proxy, modelDescription.getValueReferences(variablesNames));
    }

    public BatchRead read(String... variablesNames) {
        return new BatchRead(proxy, modelDescription.getValueReferences(variablesNames));
    }

    public SingleRead read(String variableName) {
        return new SingleRead(proxy, modelDescription.getValueReference(variableName));
    }

    public FmuFile getFmuFile() {
        return fmuFile;
    }

    public class WriteCall {
        private final FmiProxy proxy;
        private final int[] valueReferences;

        public WriteCall(FmiProxy proxy, int[] valueReferences) {
            this.proxy = proxy;
            this.valueReferences = valueReferences;
        }

        public Status with(int... values) {
            return proxy.setInteger(valueReferences, values);
        }

        public Status with(boolean... values) {
            return proxy.setBoolean(valueReferences, values);
        }

        public Status with(String... values) {
            return proxy.setString(valueReferences, values);
        }

        public Status with(double... values) {
            return proxy.setReal(valueReferences, values);
        }
    }

}