Skip to content

Commit 26f3dfb

Browse files
markarenmarkaren
committed
restructure
1 parent af9dd86 commit 26f3dfb

3 files changed

Lines changed: 125 additions & 83 deletions

File tree

‎export/tests/fmi2/identity_test.cpp‎

Lines changed: 5 additions & 79 deletions
Original file line numberDiff line numberDiff line change
@@ -1,96 +1,22 @@
11

2-
#include "catch2/matchers/catch_matchers_vector.hpp"
3-
#include "fmi2/fmi2Functions.h"
4-
52

63
#include <catch2/catch_approx.hpp>
74
#include <catch2/catch_test_macros.hpp>
5+
#include <catch2/matchers/catch_matchers_vector.hpp>
6+
87
#include <cstdarg>
98
#include <iostream>
109
#include <unordered_set>
1110

12-
#include <fmu4cpp/fmu_base.hpp>
13-
14-
class Model : public fmu4cpp::fmu_base {
15-
16-
public:
17-
FMU4CPP_CTOR(Model) {
18-
19-
register_variable(integer("integerIn", &integer_)
20-
.setCausality(fmu4cpp::causality_t::INPUT)
21-
.setVariability(fmu4cpp::variability_t::DISCRETE));
22-
23-
register_variable(real("realIn", &real_)
24-
.setCausality(fmu4cpp::causality_t::INPUT)
25-
.setVariability(fmu4cpp::variability_t::DISCRETE));
26-
27-
register_variable(boolean("booleanIn", &boolean_)
28-
.setCausality(fmu4cpp::causality_t::INPUT)
29-
.setVariability(fmu4cpp::variability_t::DISCRETE));
30-
31-
register_variable(string("stringIn", &string_)
32-
.setCausality(fmu4cpp::causality_t::INPUT)
33-
.setVariability(fmu4cpp::variability_t::DISCRETE));
34-
35-
36-
register_variable(integer("integerOut", &integer_)
37-
.setCausality(fmu4cpp::causality_t::OUTPUT)
38-
.setVariability(fmu4cpp::variability_t::DISCRETE)
39-
.setInitial(fmu4cpp::initial_t::CALCULATED)
40-
.setDependencies({"integerIn"}));
41-
42-
register_variable(real("realOut", &real_)
43-
.setCausality(fmu4cpp::causality_t::OUTPUT)
44-
.setVariability(fmu4cpp::variability_t::DISCRETE)
45-
.setInitial(fmu4cpp::initial_t::CALCULATED)
46-
.setDependencies({"realIn"}));
47-
48-
register_variable(boolean("booleanOut", &boolean_)
49-
.setCausality(fmu4cpp::causality_t::OUTPUT)
50-
.setVariability(fmu4cpp::variability_t::DISCRETE)
51-
.setInitial(fmu4cpp::initial_t::CALCULATED)
52-
.setDependencies({"booleanIn"}));
53-
54-
register_variable(string("stringOut", [this] { return string_; })
55-
.setCausality(fmu4cpp::causality_t::OUTPUT)
56-
.setVariability(fmu4cpp::variability_t::DISCRETE)
57-
.setInitial(fmu4cpp::initial_t::CALCULATED)
58-
.setDependencies({"stringIn"}));
59-
60-
Model::reset();
61-
}
62-
63-
bool do_step(double dt) override {
64-
return true;
65-
}
11+
#include "fmi2/fmi2Functions.h"
6612

67-
void reset() override {
68-
integer_ = 0;
69-
real_ = 0;
70-
boolean_ = false;
71-
string_ = "empty";
72-
}
73-
74-
private:
75-
int integer_;
76-
double real_;
77-
bool boolean_;
78-
std::string string_;
79-
};
80-
81-
fmu4cpp::model_info fmu4cpp::get_model_info() {
82-
model_info info;
83-
info.modelName = "Identity";
84-
info.description = "A simple feed-trough model";
85-
return info;
86-
}
13+
#include "Identity.hpp"
14+
#include "fmu4cpp/fmu_base.hpp"
8715

8816
std::string fmu4cpp::model_identifier() {
8917
return "identity";
9018
}
9119

92-
FMU4CPP_INSTANTIATE(Model);
93-
9420

9521
int readInt(fmi2Component c, fmi2ValueReference ref) {
9622
fmi2Integer value;

‎export/tests/models/BouncingBall.hpp‎

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -68,7 +68,7 @@ class BouncingBall : public fmu_base {
6868
}
6969

7070
void *getFMUState() override {
71-
State *statePtr = new State(state_);
71+
auto statePtr = new State(state_);
7272
return statePtr;
7373
}
7474

@@ -86,13 +86,13 @@ class BouncingBall : public fmu_base {
8686
}
8787

8888
void serializeFMUState(void *state, std::vector<uint8_t> &serializedState) override {
89-
State *statePtr = static_cast<State *>(state);
89+
const State *statePtr = static_cast<State *>(state);
9090
serializedState.resize(sizeof(State));
9191
std::memcpy(serializedState.data(), statePtr, sizeof(State));
9292
}
9393

9494
void deserializeFMUState(const std::vector<uint8_t> &serializedState, void **state) override {
95-
State *statePtr = new State();
95+
auto statePtr = new State();
9696
std::memcpy(statePtr, serializedState.data(), sizeof(State));
9797
*state = statePtr;
9898
}
@@ -109,7 +109,7 @@ class BouncingBall : public fmu_base {
109109
double bounceFactor_{};// Factor to reduce velocity on bounce
110110

111111
void setFromPtr(const void *ptr) {
112-
const State *src = static_cast<const State *>(ptr);
112+
const auto *src = static_cast<const State *>(ptr);
113113
*this = *src;
114114
}
115115

‎export/tests/models/Identity.hpp‎

Lines changed: 116 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,116 @@
1+
2+
#ifndef IDENTITY_HPP
3+
#define IDENTITY_HPP
4+
5+
#include <fmu4cpp/fmu_base.hpp>
6+
7+
using namespace fmu4cpp;
8+
9+
class Model : public fmu_base {
10+
11+
public:
12+
FMU4CPP_CTOR(Model) {
13+
14+
register_variable(integer(
15+
"integerIn", &state_.integer_)
16+
.setCausality(causality_t::INPUT)
17+
.setVariability(variability_t::DISCRETE));
18+
register_variable(
19+
real(
20+
"realIn", &state_.real_)
21+
.setCausality(causality_t::INPUT)
22+
.setVariability(variability_t::DISCRETE));
23+
24+
register_variable(boolean(
25+
"booleanIn", &state_.boolean_)
26+
.setCausality(causality_t::INPUT)
27+
.setVariability(variability_t::DISCRETE));
28+
29+
register_variable(string(
30+
"stringIn", &state_.string_)
31+
.setCausality(causality_t::INPUT)
32+
.setVariability(variability_t::DISCRETE));
33+
34+
register_variable(integer("integerOut", &state_.integer_)
35+
.setCausality(causality_t::OUTPUT)
36+
.setVariability(variability_t::DISCRETE)
37+
.setInitial(initial_t::CALCULATED)
38+
.setDependencies({"integerIn"}));
39+
40+
register_variable(real("realOut", &state_.real_)
41+
.setCausality(causality_t::OUTPUT)
42+
.setVariability(variability_t::DISCRETE)
43+
.setInitial(initial_t::CALCULATED)
44+
.setDependencies({"realIn"}));
45+
46+
register_variable(boolean("booleanOut", &state_.boolean_)
47+
.setCausality(causality_t::OUTPUT)
48+
.setVariability(variability_t::DISCRETE)
49+
.setInitial(initial_t::CALCULATED)
50+
.setDependencies({"booleanIn"}));
51+
52+
register_variable(string("stringOut", &state_.string_)
53+
.setCausality(causality_t::OUTPUT)
54+
.setVariability(variability_t::DISCRETE)
55+
.setInitial(initial_t::CALCULATED)
56+
.setDependencies({"stringIn"}));
57+
58+
Model::reset();
59+
}
60+
61+
bool do_step(double dt) override {
62+
log(fmiOK, "hello@ " + std::to_string(currentTime()));
63+
return true;
64+
}
65+
66+
void *getFMUState() override {
67+
auto* state = new State(state_);
68+
return state;
69+
}
70+
71+
void setFmuState(void *state) override {
72+
state_ = *static_cast<State *>(state);
73+
}
74+
75+
void freeFmuState(void **state) override {
76+
delete static_cast<State *>(*state);
77+
*state = nullptr;
78+
}
79+
80+
void reset() override {
81+
state_.reset();
82+
}
83+
84+
private:
85+
86+
struct State {
87+
int integer_{};
88+
double real_{};
89+
bool boolean_{};
90+
std::string string_{};
91+
92+
void reset() {
93+
integer_ = 0;
94+
real_ = 0;
95+
boolean_ = false;
96+
string_ = "empty";
97+
}
98+
};
99+
100+
State state_;
101+
};
102+
103+
model_info fmu4cpp::get_model_info() {
104+
model_info info;
105+
info.modelName = "Identity";
106+
info.description = "A simple feed-trough model";
107+
info.defaultExperiment = {0.0, 10};
108+
info.canGetAndSetFMUstate = true;
109+
110+
return info;
111+
}
112+
113+
FMU4CPP_INSTANTIATE(Model);// Entry point for FMI instantiate function.
114+
115+
116+
#endif //IDENTITY_HPP

0 commit comments

Comments
 (0)