helics  2.8.1
Inputs.hpp
1 /*
2 Copyright (c) 2017-2021,
3 Battelle Memorial Institute; Lawrence Livermore National Security, LLC; Alliance for Sustainable
4 Energy, LLC. See the top-level NOTICE for additional details. All rights reserved.
5 SPDX-License-Identifier: BSD-3-Clause
6 */
7 #pragma once
8 
9 #include "HelicsPrimaryTypes.hpp"
10 #include "ValueFederate.hpp"
11 #include "helicsTypes.hpp"
12 
13 #include <memory>
14 #include <string>
15 #include <utility>
16 #include <vector>
17 
18 namespace units {
19 class precise_unit;
20 } // namespace units
21 
22 namespace helics {
23 
24 enum multi_input_handling_method : uint16_t {
26  vectorize_operation = helics_multi_input_vectorize_operation,
27  and_operation = helics_multi_input_and_operation,
28  or_operation = helics_multi_input_or_operation,
29  sum_operation = helics_multi_input_sum_operation,
30  diff_operation = helics_multi_input_diff_operation,
31  max_operation = helics_multi_input_max_operation,
32  min_operation = helics_multi_input_min_operation,
33  average_operation = helics_multi_input_average_operation
34 };
35 
37 class HELICS_CXX_EXPORT Input {
38  protected:
39  ValueFederate* fed = nullptr;
41  private:
42  int referenceIndex{-1};
43  void* dataReference{nullptr};
44 
45  data_type targetType{data_type::helics_unknown};
46  data_type injectionType{
47  data_type::helics_unknown};
48  bool changeDetectionEnabled{false};
49  bool hasUpdate{false};
50  bool disableAssign{false};
51  bool useThreshold{false};
52  bool multiUnits{false};
53  multi_input_handling_method inputVectorOp{
54  multi_input_handling_method::no_op};
55  int32_t prevInputCount{0};
56  size_t customTypeHash{0U};
57  defV lastValue{invalidDouble};
58  std::shared_ptr<units::precise_unit> outputUnits;
59  std::shared_ptr<units::precise_unit> inputUnits;
60  std::vector<std::pair<data_type, std::shared_ptr<units::precise_unit>>>
61  sourceTypes;
62  double delta{-1.0};
63  double threshold{0.0};
64  std::string actualName;
65  // this needs to match the defV type
66  mpark::variant<std::function<void(const double&, Time)>,
67  std::function<void(const int64_t&, Time)>,
68  std::function<void(const std::string&, Time)>,
69  std::function<void(const std::complex<double>&, Time)>,
70  std::function<void(const std::vector<double>&, Time)>,
71  std::function<void(const std::vector<std::complex<double>>&, Time)>,
72  std::function<void(const NamedPoint&, Time)>,
73  std::function<void(const bool&, Time)>,
74  std::function<void(const Time&, Time)>>
75  value_callback;
76  public:
78  Input() = default;
80  Input(ValueFederate* valueFed,
81  interface_handle id,
82  const std::string& actName,
83  const std::string& unitsOut = std::string{});
84 
85  Input(ValueFederate* valueFed,
86  const std::string& key,
87  const std::string& defaultType = "def",
88  const std::string& units = std::string{});
89 
90  template<class FedPtr>
91  Input(FedPtr& valueFed,
92  const std::string& key,
93  const std::string& defaultType = "def",
94  const std::string& units = std::string{}):
95  Input(std::addressof(*valueFed), key, defaultType, units)
96  {
97  static_assert(
98  std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
99  "first argument must be a pointer to a ValueFederate");
100  }
101 
102  Input(interface_visibility locality,
103  ValueFederate* valueFed,
104  const std::string& key,
105  const std::string& defaultType = "def",
106  const std::string& units = std::string{});
107 
108  template<class FedPtr>
109  Input(interface_visibility locality,
110  FedPtr& valueFed,
111  const std::string& name,
112  const std::string& defaultType = "def",
113  const std::string& units = std::string{}):
114  Input(locality, std::addressof(*valueFed), name, defaultType, units)
115  {
116  static_assert(
117  std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
118  "first argument must be a pointer to a ValueFederate");
119  }
120 
121  Input(ValueFederate* valueFed,
122  const std::string& name,
123  data_type defType,
124  const std::string& units = std::string{}):
125  Input(valueFed, name, typeNameStringRef(defType), units)
126  {
127  }
128 
129  template<class FedPtr>
130  Input(FedPtr& valueFed,
131  const std::string& name,
132  data_type defType,
133  const std::string& units = std::string()):
134  Input(valueFed, name, typeNameStringRef(defType), units)
135  {
136  }
137 
138  Input(interface_visibility locality,
139  ValueFederate* valueFed,
140  const std::string& name,
141  const std::string& units = std::string{}):
142  Input(locality, valueFed, name, "def", units)
143  {
144  }
145 
146  template<class FedPtr>
147  Input(interface_visibility locality,
148  FedPtr& valueFed,
149  const std::string& key,
150  const std::string& units = std::string{}):
151  Input(locality, valueFed, key, "def", units)
152  {
153  }
154 
155  Input(interface_visibility locality,
156  ValueFederate* valueFed,
157  const std::string& name,
158  data_type defType,
159  const std::string& units = std::string{}):
160  Input(locality, valueFed, name, typeNameStringRef(defType), units)
161  {
162  }
163 
164  template<class FedPtr>
165  Input(interface_visibility locality,
166  FedPtr& valueFed,
167  const std::string& name,
168  data_type defType,
169  const std::string& units = std::string{}):
170  Input(locality, valueFed, name, typeNameStringRef(defType), units)
171  {
172  }
173 
177  Time getLastUpdate() const { return fed->getLastUpdateTime(*this); }
180  interface_handle getHandle() const { return handle; }
182  operator interface_handle() const { return handle; }
184  bool isValid() const { return handle.isValid(); }
185  bool operator<(const Input& inp) const { return (handle < inp.handle); }
186  bool operator>(const Input& inp) const { return (handle > inp.handle); }
193  void registerNotificationCallback(std::function<void(Time)> callback)
194  {
195  fed->setInputNotificationCallback(
196  *this, [this, callback = std::move(callback)](const Input& /*inp*/, Time time) {
197  if (isUpdated()) {
198  callback(time);
199  }
200  });
201  }
204  const std::string& getName() const { return actualName; }
207  const std::string& getKey() const { return fed->getInterfaceName(handle); }
210  const std::string& getDisplayName() const
211  {
212  return (actualName.empty() ? getTarget() : actualName);
213  }
214 
216  const std::string& getPublicationType() const
217  {
218  return ((injectionType == data_type::helics_unknown) ||
219  (injectionType == data_type::helics_custom)) ?
220  fed->getInjectionType(*this) :
221  typeNameStringRef(injectionType);
222  }
224  const std::string& getType() const { return fed->getExtractionType(*this); }
226  const std::string& getUnits() const { return fed->getExtractionUnits(*this); }
228  const std::string& getInjectionUnits() const { return fed->getInjectionUnits(*this); }
230  const std::string& getTarget() const { return fed->getTarget(*this); }
232  void addTarget(const std::string& newTarget) { fed->addTarget(*this, newTarget); }
234  void removeTarget(const std::string& targetToRemove)
235  {
236  fed->removeTarget(*this, targetToRemove);
237  }
239  const std::string& getInfo() const { return fed->getInfo(handle); }
241  void setInfo(const std::string& info) { fed->setInfo(handle, info); }
243  void setOption(int32_t option, int32_t value = 1);
244 
246  int32_t getOption(int32_t option) const;
252  bool checkUpdate(bool assumeUpdate = false);
253 
255  void clearUpdate();
258  bool isUpdated();
266  bool isUpdated() const;
267 
273  template<class X>
274  void setInputNotificationCallback(std::function<void(const X&, Time)> callback)
275  {
276  static_assert(
277  helicsType<X>() != data_type::helics_custom,
278  "callback type must be a primary helics type one of \"double, int64_t, named_point, bool, Time "
279  "std::vector<double>, std::vector<std::complex<double>>, std::complex<double>\"");
280  value_callback = std::move(callback);
281  fed->setInputNotificationCallback(*this, [this](Input& /*unused*/, Time time) {
282  handleCallback(time);
283  });
284  }
285 
286  private:
287  template<class X>
288  void setDefault_impl(std::integral_constant<int, 0> /*V*/, X&& val)
289  {
291  lastValue = make_valid(std::forward<X>(val));
292  }
293 
294  template<class X>
295  void setDefault_impl(std::integral_constant<int, 1> /*V*/, X&& val)
296  {
297  lastValue = make_valid(std::forward<X>(val));
298  }
299 
300  template<class X>
301  void setDefault_impl(std::integral_constant<int, 2> /*V*/, X&& val)
302  {
303  fed->setDefaultValue(*this,
304  ValueConverter<remove_cv_ref<X>>::convert(std::forward<X>(val)));
305  }
306 
307  public:
310  template<class X>
311  void setDefault(X&& val)
312  {
313  setDefault_impl<X>(typeCategory<X>(), std::forward<X>(val));
314  }
315 
319  void setMinimumChange(double deltaV) noexcept
320  {
321  // this first check enables change detection if it was disabled via negative delta
322  if (delta < 0.0) {
323  changeDetectionEnabled = true;
324  }
325  delta = deltaV;
326  // the second checks if we should disable from negative delta
327  if (delta < 0.0) {
328  changeDetectionEnabled = false;
329  }
330  }
334  void enableChangeDetection(bool enabled = true) noexcept { changeDetectionEnabled = enabled; }
335 
336  private:
338  void handleCallback(Time time);
339  template<class X>
340  void getValue_impl(std::integral_constant<int, primaryType> /*V*/, X& out);
341 
343  void getValue_impl(std::integral_constant<int, primaryType> /*V*/, char& out)
344  {
345  out = getValueChar();
346  }
347 
349  void getValue_impl(std::integral_constant<int, convertibleType> /*V*/, char& out)
350  {
351  out = getValueChar();
352  }
353 
354  template<class X>
355  void getValue_impl(std::integral_constant<int, convertibleType> /*V*/, X& out)
356  {
357  std::conditional_t<std::is_integral<X>::value,
358  std::conditional_t<std::is_same<X, char>::value, char, int64_t>,
359  double>
360  gval;
361  getValue_impl(std::integral_constant<int, primaryType>(), gval);
362  out = static_cast<X>(gval);
363  }
364 
365  template<class X>
366  void getValue_impl(std::integral_constant<int, nonConvertibleType> /*V*/, X& out)
367  {
368  ValueConverter<X>::interpret(fed->getValueRaw(*this), out);
369  }
370 
371  template<class X>
372  X getValue_impl(std::integral_constant<int, primaryType> /*V*/)
373  {
374  X val; // NOLINT
375  getValue_impl(std::integral_constant<int, primaryType>(), val);
376  return val;
377  }
378 
379  template<class X>
380  X getValue_impl(std::integral_constant<int, convertibleType> /*V*/)
381  {
382  std::conditional_t<std::is_integral<X>::value,
383  std::conditional_t<std::is_same<X, char>::value, char, int64_t>,
384  double>
385  gval;
386  getValue_impl(std::integral_constant<int, primaryType>(), gval);
387  return static_cast<X>(gval);
388  }
389 
390  template<class X>
391  X getValue_impl(std::integral_constant<int, nonConvertibleType> /*V*/)
392  {
393  return ValueConverter<X>::interpret(fed->getValueRaw(*this));
394  }
395 
396  public:
398  int getValue(double* data, int maxsize);
400  int getValue(char* str, int maxsize);
404  template<class X>
405  void getValue(X& out)
406  {
407  getValue_impl<X>(typeCategory<X>(), out);
408  }
411  template<class X>
412  auto getValue()
413  {
414  return getValue_impl<remove_cv_ref<X>>(typeCategory<X>());
415  }
416 
417  template<class X>
418  const X& getValueRef();
419 
421  data_view getRawValue();
423  size_t getRawSize();
425  size_t getStringSize();
427  size_t getVectorSize();
431  void close() { fed->closeInterface(handle); }
433  data_type getHelicsType() const { return targetType; }
434 
436  data_type getHelicsInjectionType() const { return injectionType; }
437 
438  multi_input_handling_method getMultiInputMode() const { return inputVectorOp; }
439 
440  bool vectorDataProcess(const std::vector<std::shared_ptr<const data_block>>& dataV);
441 
442  private:
444  void loadSourceInformation();
446  char getValueChar();
448  bool allowDirectFederateUpdate() const
449  {
450  return hasUpdate && !changeDetectionEnabled &&
451  inputVectorOp == multi_input_handling_method::no_op;
452  }
453  friend class ValueFederateManager;
454 };
455 
457 HELICS_CXX_EXPORT double
458  doubleExtractAndConvert(const data_view& dv,
459  const std::shared_ptr<units::precise_unit>& inputUnits,
460  const std::shared_ptr<units::precise_unit>& outputUnits);
461 
462 HELICS_CXX_EXPORT void
463  integerExtractAndConvert(defV& store,
464  const data_view& dv,
465  const std::shared_ptr<units::precise_unit>& inputUnits,
466  const std::shared_ptr<units::precise_unit>& outputUnits);
467 
469 HELICS_CXX_EXPORT double
470  doubleExtractAndConvert3(const data_view& dv,
471  const std::shared_ptr<units::precise_unit>& inputUnits,
472  const std::shared_ptr<units::precise_unit>& outputUnits);
473 
474 HELICS_CXX_EXPORT void
475  integerExtractAndConvert3(defV& store,
476  const data_view& dv,
477  const std::shared_ptr<units::precise_unit>& inputUnits,
478  const std::shared_ptr<units::precise_unit>& outputUnits);
479 
482 template<class X>
483 class InputT: public Input {
484  private:
485  std::function<void(X, Time)> value_callback;
486  std::function<double(const X& v1, const X& v2)>
487  changeDetectionOperator;
488  // determine if we can convert to a primary type
489  using is_convertible_to_primary_type =
490  std::conditional_t<((helicsType<X>() != data_type::helics_custom) ||
491  (isConvertableType<X>())),
492  std::true_type,
493  std::false_type>;
494 
495  public:
496  InputT() = default;
503  const std::string& name,
504  const std::string& units = std::string()):
505  Input(valueFed, name, ValueConverter<X>::type(), units)
506  {
507  }
513  template<class FedPtr>
514  InputT(FedPtr& valueFed, const std::string& name, const std::string& units = std::string()):
515  Input(valueFed, name, ValueConverter<X>::type(), units)
516  {
517  }
518 
521  X getValue() { return Input::getValue<X>(); }
525  void getValue(X& out) { Input::getValue<X>(out); }
526 
532  void setInputNotificationCallback(std::function<void(X, Time)> callback)
533  {
534  value_callback = callback;
535  fed->setInputNotificationCallback(*this, [=](Input& /*unused*/, Time time) {
536  handleCallback(time);
537  });
538  }
542  void setDefault(const X& val) { Input::setDefault(val); }
543 
544  private:
545  void handleCallback(Time time)
546  {
547  X out;
548  Input::getValue(out);
549  value_callback(out, time);
550  }
551 };
552 
553 template<class X>
554 void Input::getValue_impl(std::integral_constant<int, primaryType> /*V*/, X& out)
555 {
556  if (fed->isUpdated(*this) || allowDirectFederateUpdate()) {
557  auto dv = fed->getValueRaw(*this);
558  if (injectionType == data_type::helics_unknown) {
559  loadSourceInformation();
560  }
561  if (injectionType == helics::data_type::helics_json ||
562  targetType != data_type::helics_json) {
563  if (injectionType == helics::data_type::helics_double) {
564  defV val = doubleExtractAndConvert(dv, inputUnits, outputUnits);
565  valueExtract(val, out);
566  } else if (injectionType == helics::data_type::helics_int) {
567  defV val;
568  integerExtractAndConvert(val, dv, inputUnits, outputUnits);
569  valueExtract(val, out);
570  } else {
571  valueExtract(dv, injectionType, out);
572  }
573  } else {
574  if (injectionType == helics::data_type::helics_double) {
575  defV val = doubleExtractAndConvert3(dv, inputUnits, outputUnits);
576  valueExtract(val, out);
577  } else if (injectionType == helics::data_type::helics_int) {
578  defV val;
579  integerExtractAndConvert3(val, dv, inputUnits, outputUnits);
580  valueExtract(val, out);
581  } else {
582  defV val;
583  valueExtract3(dv, injectionType, val);
584  valueExtract(val, out);
585  }
586  }
587  if (changeDetectionEnabled) {
588  if (changeDetected(lastValue, out, delta)) {
589  lastValue = make_valid(out);
590  } else {
591  valueExtract(lastValue, out);
592  }
593  } else {
594  lastValue = make_valid(out);
595  }
596  } else {
597  valueExtract(lastValue, out);
598  }
599  hasUpdate = false;
600 }
601 
602 template<class X>
603 inline const X& getValueRefImpl(defV& val)
604 {
605  valueConvert(val, helicsType<X>());
606  return mpark::get<X>(val);
607 }
608 
609 template<>
610 inline const std::string& getValueRefImpl(defV& val)
611 {
612  // don't convert a named point to a string
613  if ((val.index() == named_point_loc)) {
614  return mpark::get<NamedPoint>(val).name;
615  }
616  valueConvert(val, data_type::helics_string);
617  return mpark::get<std::string>(val);
618 }
619 
620 template<class X>
621 const X& Input::getValueRef()
622 {
623  static_assert(std::is_same<typeCategory<X>, std::integral_constant<int, primaryType>>::value,
624  "calling getValue By ref must be with a primary type");
625  if (fed->isUpdated(*this) || allowDirectFederateUpdate()) {
626  auto dv = fed->getValueRaw(*this);
627  if (injectionType == data_type::helics_unknown) {
628  loadSourceInformation();
629  }
630  if (injectionType == helics::data_type::helics_json ||
631  targetType != data_type::helics_json) {
632  if (changeDetectionEnabled) {
633  X out;
634  if (injectionType == helics::data_type::helics_double) {
635  defV val = doubleExtractAndConvert(dv, inputUnits, outputUnits);
636  valueExtract(val, out);
637  } else if (injectionType == helics::data_type::helics_int) {
638  defV val;
639  integerExtractAndConvert(val, dv, inputUnits, outputUnits);
640  valueExtract(val, out);
641  } else {
642  valueExtract(dv, injectionType, out);
643  }
644  if (changeDetected(lastValue, out, delta)) {
645  lastValue = make_valid(std::move(out));
646  }
647  } else {
648  valueExtract(dv, injectionType, lastValue);
649  }
650  } else {
651  if (changeDetectionEnabled) {
652  X out;
653  if (injectionType == helics::data_type::helics_double) {
654  defV val = doubleExtractAndConvert3(dv, inputUnits, outputUnits);
655  valueExtract(val, out);
656  } else if (injectionType == helics::data_type::helics_int) {
657  defV val;
658  integerExtractAndConvert3(val, dv, inputUnits, outputUnits);
659  valueExtract(val, out);
660  } else {
661  defV val;
662  valueExtract3(dv, injectionType, val);
663  valueExtract(val, out);
664  }
665  if (changeDetected(lastValue, out, delta)) {
666  lastValue = make_valid(std::move(out));
667  }
668  } else {
669  valueExtract3(dv, injectionType, lastValue);
670  }
671  }
672  } else {
673  // TODO(PT): make some logic that it can get the raw data from the core again if it was
674  // converted already
675  }
676 
677  return getValueRefImpl<remove_cv_ref<X>>(lastValue);
678 }
679 } // namespace helics
helics::Input
Definition: Inputs.hpp:37
generateJsonString
std::string generateJsonString(const Json::Value &block)
Definition: JsonProcessingFunctions.cpp:97
data
@ data
print timing+data transmissions
Definition: loggingHelper.hpp:30
helics::Federate::setInterfaceOption
void setInterfaceOption(interface_handle handle, int32_t option, int32_t option_value=1)
Definition: Federate.cpp:1355
helicsTypes.hpp
helics::Input::getHandle
interface_handle getHandle() const
Definition: Inputs.hpp:180
helics::ValueFederate::clearUpdate
void clearUpdate(const Input &inp)
Definition: ValueFederate.cpp:649
helics::Input::setOption
void setOption(int32_t option, int32_t value=1)
Definition: Inputs.cpp:578
helics::Input::checkUpdate
bool checkUpdate(bool assumeUpdate=false)
Definition: Inputs.cpp:527
helics_multi_input_max_operation
@ helics_multi_input_max_operation
Definition: helics_enums.h:264
helics::ValueFederate
Definition: application_api/ValueFederate.hpp:25
helics::InputT::setInputNotificationCallback
void setInputNotificationCallback(std::function< void(X, Time)> callback)
Definition: Inputs.hpp:532
helics::ValueConverter::interpret
static X interpret(const data_view &block)
Definition: ValueConverter_impl.hpp:317
helics::Input::getOption
int32_t getOption(int32_t option) const
Definition: Inputs.cpp:588
helics::Federate::getExtractionType
const std::string & getExtractionType(interface_handle handle) const
Definition: Federate.cpp:1307
helics::Input::registerNotificationCallback
void registerNotificationCallback(std::function< void(Time)> callback)
Definition: Inputs.hpp:193
helics::Input::isUpdated
bool isUpdated()
Definition: Inputs.cpp:596
helics::Input::removeTarget
void removeTarget(const std::string &targetToRemove)
Definition: Inputs.hpp:234
helics::make_valid
int64_t make_valid(bool obj)
Definition: HelicsPrimaryTypes.hpp:65
helics::InputT::getValue
void getValue(X &out)
Definition: Inputs.hpp:525
helics::Input::getStringSize
size_t getStringSize()
Definition: Inputs.cpp:635
helics::Input::setMinimumChange
void setMinimumChange(double deltaV) noexcept
Definition: Inputs.hpp:319
helics::ValueConverter
Definition: ValueConverter.hpp:26
helics::Input::getRawSize
size_t getRawSize()
Definition: Inputs.cpp:618
helics::doubleExtractAndConvert3
double doubleExtractAndConvert3(const data_view &dv, const std::shared_ptr< units::precise_unit > &inputUnits, const std::shared_ptr< units::precise_unit > &outputUnits)
Definition: Inputs.cpp:775
helics::Input::getValue
auto getValue()
Definition: Inputs.hpp:412
helics::Time
TimeRepresentation< count_time< 9 > > Time
Definition: helics-time.hpp:27
helics::Input::getLastUpdate
Time getLastUpdate() const
Definition: Inputs.hpp:177
helics::Input::getInfo
const std::string & getInfo() const
Definition: Inputs.hpp:239
helics::data_view
Definition: data_view.hpp:22
helics::ValueConverter3::interpret
static X interpret(const data_view &block)
Definition: ValueConverter.hpp:101
helics::InputT::setDefault
void setDefault(const X &val)
Definition: Inputs.hpp:542
helics::Input::getRawValue
data_view getRawValue()
Definition: Inputs.cpp:629
helics::vectorNorm
double vectorNorm(const std::vector< double > &vec)
Definition: helicsTypes.cpp:66
helics_handle_option_multi_input_handling_method
@ helics_handle_option_multi_input_handling_method
Definition: helics_enums.h:298
helics::Input::setInfo
void setInfo(const std::string &info)
Definition: Inputs.hpp:241
helics::Input::Input
Input()=default
helics::InputT
Definition: Inputs.hpp:483
helics::typeNameStringRef
const std::string & typeNameStringRef(data_type type)
Definition: helicsTypes.cpp:27
helics::changeDetected
bool changeDetected(const defV &prevValue, const std::string &val, double)
Definition: helicsPrimaryTypes.cpp:16
helics::typeCategory
std::conditional_t< helicsType< remove_cv_ref< X > >() !=data_type::helics_custom, std::integral_constant< int, primaryType >, std::conditional_t< isConvertableType< remove_cv_ref< X > >(), std::integral_constant< int, convertibleType >, std::integral_constant< int, nonConvertibleType > >> typeCategory
Definition: helicsTypes.hpp:545
helics::ValueFederate::setInputNotificationCallback
void setInputNotificationCallback(std::function< void(Input &, Time)> callback)
Definition: ValueFederate.cpp:623
helics::Input::getHelicsInjectionType
data_type getHelicsInjectionType() const
Definition: Inputs.hpp:436
helics_multi_input_diff_operation
@ helics_multi_input_diff_operation
Definition: helics_enums.h:262
helics::ValueFederate::isUpdated
bool isUpdated(const Input &inp) const
Definition: ValueFederate.cpp:496
helics_multi_input_or_operation
@ helics_multi_input_or_operation
Definition: helics_enums.h:257
helics::invalidDouble
constexpr double invalidDouble
defined constant for an invalid value as a double
Definition: helicsTypes.hpp:491
helics::Input::getTarget
const std::string & getTarget() const
Definition: Inputs.hpp:230
loadJsonStr
Json::Value loadJsonStr(const std::string &jsonString)
Definition: JsonProcessingFunctions.cpp:50
fed
@ fed
special logging command for message coming from a fed
Definition: loggingHelper.hpp:32
helics::Federate::getInjectionUnits
const std::string & getInjectionUnits(interface_handle handle) const
Definition: Federate.cpp:1312
helics::InputT::InputT
InputT(ValueFederate *valueFed, const std::string &name, const std::string &units=std::string())
Definition: Inputs.hpp:502
helics::Input::addTarget
void addTarget(const std::string &newTarget)
Definition: Inputs.hpp:232
helics::Input::getVectorSize
size_t getVectorSize()
Definition: Inputs.cpp:669
helics::interface_handle
Definition: federate_id.hpp:65
helics::defV
mpark::variant< double, int64_t, std::string, std::complex< double >, std::vector< double >, std::vector< std::complex< double > >, NamedPoint > defV
Definition: HelicsPrimaryTypes.hpp:34
helics::Input::getType
const std::string & getType() const
Definition: Inputs.hpp:224
helics::Input::getHelicsType
data_type getHelicsType() const
Definition: Inputs.hpp:433
helics::Input::close
void close()
Definition: Inputs.hpp:431
helics::Input::isValid
bool isValid() const
Definition: Inputs.hpp:184
helics::Federate::getInjectionType
const std::string & getInjectionType(interface_handle handle) const
Definition: Federate.cpp:1302
HelicsPrimaryTypes.hpp
naming a set of types that are interchangeable and recognizable inside the HELICS application API and...
helics::Input::getDisplayName
const std::string & getDisplayName() const
Definition: Inputs.hpp:210
helics::InputT::InputT
InputT(FedPtr &valueFed, const std::string &name, const std::string &units=std::string())
Definition: Inputs.hpp:514
helics_multi_input_average_operation
@ helics_multi_input_average_operation
Definition: helics_enums.h:268
helics
the main namespace for the helics co-simulation library User functions will be in the helics namespac...
Definition: AsyncFedCallInfo.hpp:14
helics::data_type
data_type
Definition: helicsTypes.hpp:275
helics::Federate::getInterfaceOption
int32_t getInterfaceOption(interface_handle handle, int32_t option)
Definition: Federate.cpp:1366
helics::doubleExtractAndConvert
double doubleExtractAndConvert(const data_view &dv, const std::shared_ptr< units::precise_unit > &inputUnits, const std::shared_ptr< units::precise_unit > &outputUnits)
Definition: Inputs.cpp:751
helics::Input::getUnits
const std::string & getUnits() const
Definition: Inputs.hpp:226
helics::ValueFederate::registerInput
Input & registerInput(const std::string &key, const std::string &type, const std::string &units=std::string())
Definition: ValueFederate.cpp:114
helics::Input::getValue
void getValue(X &out)
Definition: Inputs.hpp:405
helics_multi_input_min_operation
@ helics_multi_input_min_operation
Definition: helics_enums.h:266
helics::valueExtract
void valueExtract(const defV &dv, std::string &val)
Definition: helicsPrimaryTypes.cpp:174
helics::getValue
X getValue(ValueFederate &fed, const std::string &key)
Definition: Subscriptions.hpp:67
helics::Input::getInjectionUnits
const std::string & getInjectionUnits() const
Definition: Inputs.hpp:228
helics::getTypeFromString
data_type getTypeFromString(const std::string &typeName)
Definition: helicsTypes.cpp:187
helics::Input::getName
const std::string & getName() const
Definition: Inputs.hpp:204
helics_multi_input_vectorize_operation
@ helics_multi_input_vectorize_operation
Definition: helics_enums.h:253
helics_multi_input_no_op
@ helics_multi_input_no_op
Definition: helics_enums.h:251
helics::Input::setDefault
void setDefault(X &&val)
Definition: Inputs.hpp:311
helics::interface_visibility
interface_visibility
Definition: helicsTypes.hpp:38
helics::Input::getKey
const std::string & getKey() const
Definition: Inputs.hpp:207
helics::InputT::getValue
X getValue()
Definition: Inputs.hpp:521
helics::ValueFederate::getInput
const Input & getInput(const std::string &key) const
Definition: ValueFederate.cpp:535
helics::Input::setInputNotificationCallback
void setInputNotificationCallback(std::function< void(const X &, Time)> callback)
Definition: Inputs.hpp:274
helics_multi_input_sum_operation
@ helics_multi_input_sum_operation
Definition: helics_enums.h:259
helics_multi_input_and_operation
@ helics_multi_input_and_operation
Definition: helics_enums.h:255
helics::Input::handle
interface_handle handle
the id as generated by the Federate
Definition: Inputs.hpp:40
helics::Input::enableChangeDetection
void enableChangeDetection(bool enabled=true) noexcept
Definition: Inputs.hpp:334
helics::Input::clearUpdate
void clearUpdate()
Definition: Inputs.cpp:612
helics::Input::fed
ValueFederate * fed
reference to the value federate
Definition: Inputs.hpp:39
helics::Input::getPublicationType
const std::string & getPublicationType() const
Definition: Inputs.hpp:216
helics::ValueFederate::getValueRaw
data_view getValueRaw(const Input &inp)
Definition: ValueFederate.cpp:386