Linux GNU 11.4.0 Code Coverage Report

Directory: ./
Coverage: low: ≥ 0% medium: ≥ 75.0% high: ≥ 90.0%
Coverage Exec / Excl / Total
Lines: 61.5% 158 / 0 / 257
Functions: 56.9% 33 / 0 / 58
Branches: 51.3% 80 / 0 / 156
OMCompiler/SimulationRuntime/cpp/Core/System/SimVars.cpp
Line Branch Exec Source
1 /*
2 * This file belongs to the OpenModelica Run-Time System
3 *
4 * Copyright (c) 1998-2026, Open Source Modelica Consortium (OSMC), c/o Linköpings
5 * universitet, Department of Computer and Information Science, SE-58183 Linköping, Sweden. All rights
6 * reserved.
7 *
8 * THIS PROGRAM IS PROVIDED UNDER THE TERMS OF THE BSD NEW LICENSE OR THE
9 * AGPL VERSION 3 LICENSE OR THE OSMC PUBLIC LICENSE (OSMC-PL) VERSION 1.8. ANY
10 * USE, REPRODUCTION OR DISTRIBUTION OF THIS PROGRAM CONSTITUTES RECIPIENT'S
11 * ACCEPTANCE OF THE BSD NEW LICENSE OR THE OSMC PUBLIC LICENSE OR THE AGPL
12 * VERSION 3, ACCORDING TO RECIPIENTS CHOICE.
13 *
14 * The OpenModelica software and the OSMC (Open Source Modelica Consortium) Public License
15 * (OSMC-PL) are obtained from OSMC, either from the above address, from the URLs:
16 * http://www.openmodelica.org or https://github.com/OpenModelica/ or
17 * http://www.ida.liu.se/projects/OpenModelica, and in the OpenModelica distribution. GNU
18 * AGPL version 3 is obtained from: https://www.gnu.org/licenses/licenses.html#GPL. The BSD NEW
19 * License is obtained from: http://www.opensource.org/licenses/BSD-3-Clause.
20 *
21 * This program is distributed WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, EXCEPT AS EXPRESSLY
23 * SET FORTH IN THE BY RECIPIENT SELECTED SUBSIDIARY LICENSE CONDITIONS OF
24 * OSMC-PL.
25 *
26 */
27
28 /** @addtogroup coreSystem
29 *
30 * @{
31 */
32 #include <Core/ModelicaDefine.h>
33 #include <Core/Modelica.h>
34
35 #include <Core/System/FactoryExport.h>
36 #include <Core/System/SimVars.h>
37
38 /**
39 * Constructor for SimVars, stores all model variable in continuous block of memory
40 * @param dim_real number of all real variables (real algebraic vars,discrete algebraic vars, state vars, der state vars)
41 * @param dim_int number of all integer variables integer algebraic vars
42 * @param dim_bool number of all bool variables (boolean algebraic vars)
43 * @param dim_string number of all string variables (string algebraic vars)
44 * @param dim_pre_vars number of all pre variables (real algebraic vars,discrete algebraic vars, boolean algebraic vars, integer algebraic vars, state vars, der state vars)
45 * @param dim_state_vars number of all state variables
46 * @param state_index start index of state vector in real_vars list
47 */
48 43 SimVars::SimVars(size_t dim_real, size_t dim_int, size_t dim_bool, size_t dim_string, size_t dim_pre_vars, size_t dim_state_vars, size_t state_index)
49 {
50 43 create(dim_real, dim_int, dim_bool, dim_string, dim_pre_vars, dim_state_vars, state_index);
51 43 }
52
53 ✗ SimVars::SimVars(SimVars& instance)
54 {
55 ✗ create(instance.getDimReal(), instance.getDimInt(), instance.getDimBool(), instance.getDimString(), instance.getDimPreVars(), instance.getDimStateVars(), instance.getStateVectorIndex());
56 ✗ setRealVarsVector(instance.getRealVarsVector());
57 ✗ setIntVarsVector(instance.getIntVarsVector());
58 ✗ setBoolVarsVector(instance.getBoolVarsVector());
59 ✗ setStringVarsVector(instance.getStringVarsVector());
60 ✗ }
61
62 43 void SimVars::create(size_t dim_real, size_t dim_int, size_t dim_bool, size_t dim_string, size_t dim_pre_vars, size_t dim_state_vars, size_t state_index)
63 {
64 43 _dim_real = dim_real;
65 43 _dim_int = dim_int;
66 43 _dim_bool = dim_bool;
67 43 _dim_string = dim_string;
68 43 _dim_pre_vars = dim_pre_vars;
69 43 _dim_z = dim_state_vars;
70 43 _z_i = state_index;
71
72
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 43 times.
 43 if (_dim_real + _dim_int + _dim_bool > _dim_pre_vars)
73 ✗ throw std::runtime_error("Wrong pre variable size");
74 //allocate memory for all model variables
75
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 34 times.
 43 if (dim_string > 0) {
76
3/4
✓ Branch 0 taken 9 times.
✗ Branch 1 not taken.
✓ Branch 3 taken 57 times.
✓ Branch 4 taken 9 times.
 66 _string_vars = new string[dim_string];
77
2/2
✓ Branch 1 taken 57 times.
✓ Branch 2 taken 9 times.
 66 _pre_string_vars = new string[dim_string];
78 }
79 else {
80 34 _string_vars = NULL;
81 34 _pre_string_vars = NULL;
82 }
83
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 15 times.
 43 if (dim_bool > 0) {
84 28 _bool_vars = (bool*)alignedMalloc(sizeof(bool) * dim_bool, 64);
85 28 _pre_bool_vars = (bool*)alignedMalloc(sizeof(bool) * dim_bool, 64);
86 }
87 else {
88 15 _bool_vars = NULL;
89 15 _pre_bool_vars = NULL;
90 }
91
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 19 times.
 43 if (dim_int > 0) {
92 24 _int_vars = (int*)alignedMalloc(sizeof(int) * dim_int, 64);
93 24 _pre_int_vars = (int*)alignedMalloc(sizeof(int) * dim_int, 64);
94 }
95 else {
96 19 _int_vars = NULL;
97 19 _pre_int_vars = NULL;
98 }
99
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 time.
 43 if (dim_real > 0) {
100 42 _real_vars = (double*)alignedMalloc(sizeof(double) * dim_real, 64);
101 42 _pre_real_vars = (double*)alignedMalloc(sizeof(double) * dim_real, 64);
102 }
103 else {
104 1 _real_vars = NULL;
105 1 _pre_real_vars = NULL;
106 }
107
108 //initialize all model variables
109
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 34 times.
 43 if(dim_string > 0)
110 18 std::fill(_string_vars, _string_vars + dim_string, string());
111
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 15 times.
 43 if (dim_bool > 0)
112 28 std::fill(_bool_vars, _bool_vars + dim_bool, false);
113
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 19 times.
 43 if (dim_int > 0)
114 24 std::fill(_int_vars, _int_vars + dim_int, 0);
115
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 time.
 43 if (dim_real > 0)
116 42 std::fill(_real_vars, _real_vars + dim_real, 0.0);
117 43 }
118
119 86 SimVars::~SimVars()
120 {
121
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 time.
 43 if(_pre_real_vars)
122 42 alignedFree(_pre_real_vars);
123
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 time.
 43 if(_real_vars)
124 42 alignedFree(_real_vars);
125
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 19 times.
 43 if(_pre_int_vars)
126 24 alignedFree(_pre_int_vars);
127
2/2
✓ Branch 0 taken 24 times.
✓ Branch 1 taken 19 times.
 43 if(_int_vars)
128 24 alignedFree(_int_vars);
129
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 15 times.
 43 if(_pre_bool_vars)
130 28 alignedFree(_pre_bool_vars);
131
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 15 times.
 43 if(_bool_vars)
132 28 alignedFree(_bool_vars);
133
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 34 times.
 43 if(_string_vars)
134
4/4
✓ Branch 0 taken 57 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 55 times.
 66 delete [] _string_vars;
135
2/2
✓ Branch 0 taken 9 times.
✓ Branch 1 taken 34 times.
 43 if(_pre_string_vars)
136
4/4
✓ Branch 0 taken 57 times.
✓ Branch 1 taken 9 times.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 55 times.
 66 delete [] _pre_string_vars;
137 86 }
138
139 ✗ ISimVars* SimVars::clone()
140 {
141 ✗ return new SimVars(*this);
142 }
143
144 //see: http://stackoverflow.com/questions/12504776/aligned-malloc-in-c
145 188 void* SimVars::alignedMalloc(size_t required_bytes, size_t alignment)
146 {
147 void *p1;
148 void **p2;
149
150 188 size_t offset = alignment - 1 + sizeof(void*);
151 188 p1 = malloc(required_bytes + offset);
152 188 p2=(void**)(((size_t)(p1)+offset)&~(alignment-1));
153 188 p2[-1]=p1;
154 188 return p2;
155 }
156
157 188 void SimVars::alignedFree(void* p)
158 {
159 188 void* p1 = ((void**)p)[-1]; // get the pointer to the buffer we allocated
160 188 free( p1 );
161 188 }
162
163 /**
164 * \brief Initialize scalar real model variables in simvars memory
165 * \param [in] i index in simvars memory
166 * \return simvar variable
167 */
168 1151 double& SimVars::initRealVar(size_t i)
169 {
170
1/2
✓ Branch 0 taken 1151 times.
✗ Branch 1 not taken.
 1151 if (i < _dim_real)
171 1151 return _real_vars[i];
172 else
173 ✗ throw std::runtime_error("Wrong variable index");
174 }
175 /**
176 * \brief Initialize scalar integer model variables in simvars memory
177 * \param [in] i index in simvars memory
178 * \return simvar variable
179 */
180 73 int& SimVars::initIntVar(size_t i)
181 {
182
1/2
✓ Branch 0 taken 73 times.
✗ Branch 1 not taken.
 73 if (i < _dim_int)
183 73 return _int_vars[i];
184 else
185 ✗ throw std::runtime_error("Wrong variable index");
186 }
187 /**
188 * \brief Initialize scalar boolean model variables in simvars memory
189 * \param [in] i index in simvars memory
190 * \return simvar variable
191 */
192 134 bool& SimVars::initBoolVar(size_t i)
193 {
194
1/2
✓ Branch 0 taken 134 times.
✗ Branch 1 not taken.
 134 if (i < _dim_bool)
195 134 return _bool_vars[i];
196 else
197 ✗ throw std::runtime_error("Wrong variable index");
198 }
199 /**
200 * \brief read scalar real model variables from simvars memory
201 * \param [in] i index in simvars memory
202 * \return simvar variable
203 */
204 1955 const double& SimVars::getRealVar(size_t i)
205 {
206
1/2
✓ Branch 0 taken 1955 times.
✗ Branch 1 not taken.
 1955 if (i < _dim_real)
207 1955 return _real_vars[i];
208 else
209 ✗ throw std::runtime_error("Wrong variable index");
210 }
211 /**
212 * \brief read scalar integer model variables from simvars memory
213 * \param [in] i index in simvars memory
214 * \return simvar variable
215 */
216 867 const int& SimVars::getIntVar(size_t i)
217 {
218
1/2
✓ Branch 0 taken 867 times.
✗ Branch 1 not taken.
 867 if (i < _dim_int)
219 867 return _int_vars[i];
220 else
221 ✗ throw std::runtime_error("Wrong variable index");
222 }
223 /**
224 * \brief Read scalar boolean model variables from simvars memory
225 * \param [in] i index in simvars memory
226 * \return simvar variable
227 */
228 928 const bool& SimVars::getBoolVar(size_t i)
229 {
230
1/2
✓ Branch 0 taken 928 times.
✗ Branch 1 not taken.
 928 if (i < _dim_bool)
231 928 return _bool_vars[i];
232 else
233 ✗ throw std::runtime_error("Wrong variable index");
234 }
235 ✗ const std::string& SimVars::getStringVar(size_t i)
236 {
237 ✗ if (i < _dim_string)
238 ✗ return _string_vars[i];
239 else
240 ✗ throw std::runtime_error("Wrong variable index");
241 }
242
243 ✗ string& SimVars::initStringVar(size_t i)
244 {
245 ✗ if (i < _dim_string)
246 ✗ return _string_vars[i];
247 else
248 ✗ throw std::runtime_error("Wrong variable index");
249 }
250
251 /**
252 * \brief returns state vector of size dim_z
253 * \return Return_Description
254 * \details pointer to the state variable vector
255 */
256 43 double* SimVars::getStateVector()
257 {
258
1/2
✓ Branch 0 taken 43 times.
✗ Branch 1 not taken.
 43 if (_z_i + _dim_z <= _dim_real)
259
2/2
✓ Branch 0 taken 42 times.
✓ Branch 1 taken 1 time.
 43 return _dim_real > 0 ? &_real_vars[_z_i] : NULL;
260 else
261 ✗ throw std::runtime_error("Wrong state vars start index");
262 }
263 /**
264 * \brief returns der state vector of size dim_z
265 * \return pointer to the der state variable vector
266 * \details Details
267 */
268 83 double* SimVars::getDerStateVector()
269 {
270
1/2
✓ Branch 0 taken 83 times.
✗ Branch 1 not taken.
 83 if (_z_i + 2*_dim_z <= _dim_real)
271
2/2
✓ Branch 0 taken 81 times.
✓ Branch 1 taken 2 times.
 83 return _dim_real > 0 ? &_real_vars[_z_i + _dim_z] : NULL;
272 else
273 ✗ throw std::runtime_error("Wrong der state vars start index");
274 }
275 /**
276 * \brief returns real vars vector of size dim_real
277 * \return pointer to the real variable vector
278 * \details Details
279 */
280 84 double* SimVars::getRealVarsVector() const
281 {
282
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 82 times.
 84 if(!_real_vars)
283 2 return NULL;
284 return _real_vars;
285 }
286 /**
287 * \brief returns int vars vector of size dim_int
288 * \return pointer to the integer variable vector
289 * \details Details
290 */
291 83 int* SimVars::getIntVarsVector() const
292 {
293
2/2
✓ Branch 0 taken 36 times.
✓ Branch 1 taken 47 times.
 83 if(!_int_vars)
294 36 return NULL;
295 return _int_vars;
296 }
297 /**
298 * \brief returns bool vars vector of size dim_bool
299 * \return pointer to the bool variable vector
300 * \details Details
301 */
302 83 bool* SimVars::getBoolVarsVector() const
303 {
304
2/2
✓ Branch 0 taken 28 times.
✓ Branch 1 taken 55 times.
 83 if(!_bool_vars)
305 28 return NULL;
306 return _bool_vars;
307 }
308
309 83 string* SimVars::getStringVarsVector() const
310 {
311
2/2
✓ Branch 0 taken 65 times.
✓ Branch 1 taken 18 times.
 83 if(!_string_vars)
312 65 return NULL;
313 return _string_vars;
314 }
315
316 /**
317 * \brief set real vars vector of size dim_real
318 * \param [in] vars new real vars
319 * \details Details
320 */
321 ✗ void SimVars::setRealVarsVector(const double* vars)
322 {
323 ✗ std::copy(vars, vars + _dim_real, _real_vars);
324 ✗ }
325 /**
326 * \brief set int vars vector of size dim_int
327 * \param [in] vars new int vars
328 * \details Details
329 */
330 ✗ void SimVars::setIntVarsVector(const int* vars)
331 {
332 ✗ std::copy(vars, vars + _dim_int, _int_vars);
333 ✗ }
334 /**
335 * \brief set bool vars vector of size dim_bool
336 * \param [in] vars new boolean vars
337 * \details Details
338 */
339 ✗ void SimVars::setBoolVarsVector(const bool* vars)
340 {
341 ✗ std::copy(vars, vars + _dim_bool, _bool_vars);
342 ✗ }
343
344 ✗ void SimVars::setStringVarsVector(const string* vars)
345 {
346 ✗ std::copy(vars, vars + _dim_string, _string_vars);
347 ✗ }
348
349 /**\brief initialize real model array variable in simvars memory
350 * \param [in] size size of real array
351 * \param [in] start_index index in simvars array
352 * \return pointer to real array in simvars array
353 * \details Details
354 */
355 ✗ double* SimVars::initRealArrayVar(size_t size, size_t start_index)
356 {
357 ✗ size_t length = start_index + (size - 1);
358 ✗ if (length <= _dim_real)
359 {
360 ✗ double* data = &_real_vars[start_index];
361 ✗ return data;
362 }
363 else
364 ✗ throw std::runtime_error("Wrong array size");
365 }
366 /**\brief initialize int model array variable in simvars memory
367 * \param [in] size size of real array
368 * \param [in] start_index index in simvars array
369 * \return pointer to real array in simvars array
370 * \details Details
371 */
372 ✗ int* SimVars::initIntArrayVar(size_t size, size_t start_index)
373 {
374 ✗ size_t length = start_index + (size - 1);
375 ✗ if (length <= _dim_int)
376 {
377 ✗ int* data = &_int_vars[start_index];
378 ✗ return data;
379 }
380 else
381 ✗ throw std::runtime_error("Wrong array size");
382 }
383
384 /**\brief initialize bool model array variable in simvars memory
385 * \param [in] size size of real array
386 * \param [in] start_index index in simvars array
387 * \return pointer to real array in simvars array
388 * \details Details
389 */
390 ✗ bool* SimVars::initBoolArrayVar(size_t size, size_t start_index)
391 {
392 ✗ size_t length = start_index + (size - 1);
393 ✗ if (length <= _dim_bool)
394 {
395 ✗ bool* data = &_bool_vars[start_index];
396 ✗ return data;
397 }
398 else
399 ✗ throw std::runtime_error("Wrong array size");
400 }
401
402 ✗ string* SimVars::initStringArrayVar(size_t size, size_t start_index)
403 {
404 ✗ size_t length = start_index + (size - 1);
405 ✗ if (length <= _dim_string)
406 {
407 ✗ string* data = &_string_vars[start_index];
408 ✗ return data;
409 }
410 else
411 ✗ throw std::runtime_error("Wrong array size");
412 }
413
414 /**\brief initializes real model alias array variable in simvars memory
415 * \param [in] indices indices of orginal variables in simvars memory
416 * \param [in] n size of alias array
417 * \param [out] ref_data pointer array to original array elements in simvars memory
418 * \details Details
419 */
420 200 void SimVars::initRealAliasArray(int indices[], size_t n, double* ref_data[])
421 {
422 833 std::transform(indices,indices+n,ref_data,[this](int i) { return this->getRealVarPtr(i); });
423 200 }
424
425 200 void SimVars::initRealAliasArray(std::vector<int> indices, double* ref_data[])
426 {
427 200 initRealAliasArray(&indices[0], indices.size(), ref_data);
428 200 }
429
430 /**\brief initializes int model alias array variable in simvars memory
431 * \param [in] indices indices of original variables in simvars memory
432 * \param [in] n size of alias array
433 * \param [out] ref_data pointer array to original array elements in simvars memory
434 * \details Details
435 */
436 64 void SimVars::initIntAliasArray(int indices[], size_t n, int* ref_data[])
437 {
438 208 std::transform(indices,indices+n,ref_data,[this](int i) { return this->getIntVarPtr(i); });
439 64 }
440
441 64 void SimVars::initIntAliasArray(std::vector<int> indices, int* ref_data[])
442 {
443 64 initIntAliasArray(&indices[0], indices.size(), ref_data);
444 64 }
445
446 /**\brief initializes bool model alias array variable in simvars memory
447 * \param [in] indices indices of original variables in simvars memory
448 * \param [in] n size of alias array
449 * \param [out] ref_data pointer array to original array elements in simvars memory
450 * \details Details
451 */
452 10 void SimVars::initBoolAliasArray(int indices[], size_t n, bool* ref_data[])
453 {
454 32 std::transform(indices,indices+n,ref_data,[this](int i) { return this->getBoolVarPtr(i); });
455 10 }
456
457 10 void SimVars::initBoolAliasArray(std::vector<int> indices, bool* ref_data[])
458 {
459 10 initBoolAliasArray(&indices[0], indices.size(), ref_data);
460 10 }
461
462 ✗ void SimVars::initStringAliasArray(int indices[], size_t n, string* ref_data[])
463 {
464 ✗ std::transform(indices,indices+n,ref_data,[this](int i) { return this->getStringVarPtr(i); });
465 ✗ }
466
467 ✗ void SimVars::initStringAliasArray(std::vector<int> indices, string* ref_data[])
468 {
469 ✗ initStringAliasArray(&indices[0], indices.size(), ref_data);
470 ✗ }
471
472 /**
473 * \brief Copies all real,int,bool variables to the pre-variables list
474 * \details Details
475 */
476 336757 void SimVars::savePreVariables()
477 {
478
2/2
✓ Branch 0 taken 336176 times.
✓ Branch 1 taken 581 times.
 336757 if(_dim_real>0)
479
1/2
✓ Branch 0 taken 336176 times.
✗ Branch 1 not taken.
 336176 std::copy(_real_vars, _real_vars + _dim_real, _pre_real_vars);
480
2/2
✓ Branch 0 taken 39089 times.
✓ Branch 1 taken 297668 times.
 336757 if(_dim_int>0)
481
1/2
✓ Branch 0 taken 39089 times.
✗ Branch 1 not taken.
 39089 std::copy(_int_vars, _int_vars + _dim_int, _pre_int_vars);
482
2/2
✓ Branch 0 taken 332175 times.
✓ Branch 1 taken 4582 times.
 336757 if (_dim_bool > 0)
483
1/2
✓ Branch 0 taken 332175 times.
✗ Branch 1 not taken.
 332175 std::copy(_bool_vars, _bool_vars + _dim_bool, _pre_bool_vars);
484
2/2
✓ Branch 0 taken 19070 times.
✓ Branch 1 taken 317687 times.
 336757 if (_dim_string > 0)
485 19070 std::copy(_string_vars, _string_vars + _dim_string, _pre_string_vars);
486 336757 }
487 /**
488 * \brief Initializes access to pre variables
489 * \details Details
490 */
491 43 void SimVars::initPreVariables()
492 {
493 // nothing needs to be done, exploiting contiguous vars storage
494 43 }
495
496 3557935 double& SimVars::getPreVar(const double& var)
497 {
498 3557935 size_t i = &var - _real_vars;
499 3557935 return _pre_real_vars[i];
500 }
501
502 182107 int& SimVars::getPreVar(const int& var)
503 {
504 182107 size_t i = &var - _int_vars;
505 182107 return _pre_int_vars[i];
506 }
507
508 184293 bool& SimVars::getPreVar(const bool& var)
509 {
510 184293 size_t i = &var - _bool_vars;
511 184293 return _pre_bool_vars[i];
512 }
513
514 ✗ std::string& SimVars::getPreVar(const std::string& var)
515 {
516 ✗ size_t i = &var - _string_vars;
517 ✗ return _pre_string_vars[i];
518 }
519
520 ✗ WrapArray<double> SimVars::getPreArr(const BaseArray<double>& arr)
521 {
522 ✗ size_t i = arr.getData() - _real_vars;
523 ✗ return WrapArray<double>(_pre_real_vars + i, arr.getNumElems());
524 }
525
526 204 WrapArray<int> SimVars::getPreArr(const BaseArray<int>& arr)
527 {
528 204 size_t i = arr.getData() - _int_vars;
529 204 return WrapArray<int>(_pre_int_vars + i, arr.getNumElems());
530 }
531
532 ✗ WrapArray<bool> SimVars::getPreArr(const BaseArray<bool>& arr)
533 {
534 ✗ size_t i = arr.getData() - _bool_vars;
535 ✗ return WrapArray<bool>(_pre_bool_vars + i, arr.getNumElems());
536 }
537
538 ✗ WrapArray<std::string> SimVars::getPreArr(const BaseArray<std::string>& arr)
539 {
540 ✗ size_t i = arr.getData() - _string_vars;
541 ✗ return WrapArray<std::string>(_pre_string_vars + i, arr.getNumElems());
542 }
543
544 /**\brief returns a pointer to a real simvar variable in simvar array
545 * \param [in] i index of simvar in simvar array
546 * \return pointer to simvar
547 * \details Details
548 */
549 633 double* SimVars::getRealVarPtr(size_t i)
550 {
551
1/2
✓ Branch 0 taken 633 times.
✗ Branch 1 not taken.
 633 if(i<_dim_real)
552 633 return &_real_vars[i];
553 else
554 ✗ throw std::runtime_error("Wrong variable index");
555 }
556 /**\brief returns a pointer to a int simvar variable in simvar array
557 * \param [in] i index of simvar in simvar array
558 * \return pointer to simvar
559 * \details Details
560 */
561 144 int* SimVars::getIntVarPtr(size_t i)
562 {
563
1/2
✓ Branch 0 taken 144 times.
✗ Branch 1 not taken.
 144 if(i<_dim_int)
564 144 return &_int_vars[i];
565 else
566 ✗ throw std::runtime_error("Wrong variable index");
567 }
568
569 /**\brief returns a pointer to a bool simvar variable in simvar array
570 * \param [in] i index of simvar in simvar array
571 * \return pointer to simvar
572 * \details Details
573 */
574 22 bool* SimVars::getBoolVarPtr(size_t i)
575 {
576
1/2
✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
 22 if(i<_dim_bool)
577 22 return &_bool_vars[i];
578 else
579 ✗ throw std::runtime_error("Wrong variable index");
580 }
581
582 ✗ string* SimVars::getStringVarPtr(size_t i)
583 {
584 ✗ if(i<_dim_string)
585 ✗ return &_string_vars[i];
586 else
587 ✗ throw std::runtime_error("Wrong variable index");
588 }
589
590 ✗ size_t SimVars::getDimString() const
591 {
592 ✗ return _dim_string;
593 }
594
595 ✗ size_t SimVars::getDimBool() const
596 {
597 ✗ return _dim_bool;
598 }
599
600 ✗ size_t SimVars::getDimInt() const
601 {
602 ✗ return _dim_int;
603 }
604
605 ✗ size_t SimVars::getDimPreVars() const
606 {
607 ✗ return _dim_pre_vars;
608 }
609
610 ✗ size_t SimVars::getDimReal() const
611 {
612 ✗ return _dim_real;
613 }
614
615 40 size_t SimVars::getDimStateVars() const
616 {
617 40 return _dim_z;
618 }
619
620 ✗ size_t SimVars::getStateVectorIndex() const
621 {
622 ✗ return _z_i;
623 }
624 /** @} */ // end of coreSystem
625