helics  2.8.1
Publications.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 "../core/core-exceptions.hpp"
10 #include "HelicsPrimaryTypes.hpp"
11 #include "ValueFederate.hpp"
12 
13 #include <memory>
14 #include <string>
15 #include <vector>
16 
17 namespace units {
18 class precise_unit;
19 } // namespace units
20 
21 namespace helics {
23 class HELICS_CXX_EXPORT Publication {
24  protected:
25  ValueFederate* fed{nullptr};
27  private:
28  int referenceIndex{-1};
29  void* dataReference{nullptr};
30  double delta{-1.0};
31  protected:
32  data_type pubType{data_type::helics_any};
33  bool changeDetectionEnabled{false};
34  bool disableAssign{false};
35  private:
36  size_t customTypeHash{
37  0};
38  mutable defV prevValue;
39  std::string pubKey;
40  std::string pubUnits;
41  std::shared_ptr<units::precise_unit>
42  pubUnitType;
43  public:
44  Publication() = default;
51  Publication(ValueFederate* valueFed,
52  interface_handle id,
53  const std::string& key,
54  const std::string& type,
55  const std::string& units);
56 
62  Publication(ValueFederate* valueFed,
63  const std::string& key,
64  const std::string& type,
65  const std::string& units = std::string());
66 
73  template<class FedPtr>
74  Publication(FedPtr valueFed,
75  const std::string& key,
76  const std::string& type = std::string(),
77  const std::string& units = std::string()):
78  Publication(std::addressof(*valueFed), key, type, units)
79  {
80  static_assert(
81  std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
82  "first argument must be a pointer to a ValueFederate");
83  }
92  ValueFederate* valueFed,
93  const std::string& key,
94  const std::string& type,
95  const std::string& units = std::string());
104  template<class FedPtr>
106  FedPtr& valueFed,
107  const std::string& key,
108  const std::string& type,
109  const std::string& units = std::string()):
110  Publication(locality, std::addressof(*valueFed), key, type, units)
111  {
112  static_assert(
113  std::is_base_of<ValueFederate, std::remove_reference_t<decltype(*valueFed)>>::value,
114  "first argument must be a pointer to a ValueFederate");
115  }
116 
124  const std::string& key,
125  data_type type,
126  const std::string& units = std::string()):
127  Publication(valueFed, key, typeNameStringRef(type), units)
128  {
129  }
136  template<class FedPtr>
137  Publication(FedPtr& valueFed,
138  const std::string& key,
139  data_type type,
140  const std::string& units = std::string()):
141  Publication(valueFed, key, typeNameStringRef(type), units)
142  {
143  }
152  ValueFederate* valueFed,
153  const std::string& key,
154  data_type type,
155  const std::string& units = std::string()):
156  Publication(locality, valueFed, key, typeNameStringRef(type), units)
157  {
158  }
159 
167  template<class FedPtr>
169  FedPtr& valueFed,
170  const std::string& key,
171  data_type type,
172  const std::string& units = std::string()):
173  Publication(locality, valueFed, key, typeNameStringRef(type), units)
174  {
175  }
176 
179  interface_handle getHandle() const { return handle; }
181  operator interface_handle() const { return handle; }
182 
184  bool isValid() const { return handle.isValid(); }
185  bool operator==(const Publication& pub) const { return (handle == pub.handle); }
186  bool operator!=(const Publication& pub) const { return (handle != pub.handle); }
187  bool operator<(const Publication& pub) const { return (handle < pub.handle); }
188 
190  const std::string& getKey() const { return fed->getInterfaceName(*this); }
192  const std::string& getName() const { return pubKey; }
194  const std::string& getType() const { return fed->getExtractionType(*this); }
196  const std::string& getUnits() const { return pubUnits; }
198  const std::string& getInfo() const { return fed->getInfo(handle); }
200  void setInfo(const std::string& info) { fed->setInfo(handle, info); }
204  void setOption(int32_t option, int32_t value = 1)
205  {
206  fed->setInterfaceOption(handle, option, value);
207  }
208 
210  int32_t getOption(int32_t option) const { return fed->getInterfaceOption(handle, option); }
211 
213  void addTarget(const std::string& target) { fed->addTarget(*this, target); }
215  void removeTarget(const std::string& targetToRemove)
216  {
217  fed->removeTarget(*this, targetToRemove);
218  }
222  void close() { fed->closeInterface(handle); }
225  void publish(double val);
226  void publish(const char* val);
227  void publish(const std::string& val);
228  void publish(const std::vector<double>& val);
229  void publish(const std::vector<std::complex<double>>& val);
230  void publish(const double* vals, int size);
231  void publish(std::complex<double> val);
232  void publish(const defV& val);
233  void publish(bool val);
234  void publish(Time val);
235  void publish(char val);
236  void publish(const NamedPoint& np);
237  void publish(const std::string& name, double val);
238  void publish(const char* name, double val);
244  void publish(double val, const std::string& units);
245  void publish(double val, const units::precise_unit& units);
246 
248  template<class X>
249  std::enable_if_t<(std::is_integral<X>::value && !std::is_same<remove_cv_ref<X>, char>::value),
250  void>
251  publish(X val)
252  {
253  publishInt(static_cast<int64_t>(val));
254  }
255 
257  template<class X>
258  std::enable_if_t<((typeCategory<X>::value == nonConvertibleType) &&
259  (!std::is_convertible<X, std::string>::value) &&
260  (!std::is_same<X, defV>::value) && (!std::is_convertible<X, Time>::value)),
261  void>
262  publish(const X& val)
263  {
264  if ((pubType == data_type::helics_custom) || (pubType == data_type::helics_any)) {
265  fed->publishRaw(*this, ValueConverter<X>::convert(val));
266  }
267  }
270  void setMinimumChange(double deltaV) noexcept
271  {
272  if (delta < 0.0) {
273  changeDetectionEnabled = true;
274  }
275  delta = deltaV;
276  if (delta < 0.0) {
277  changeDetectionEnabled = false;
278  }
279  }
284  void enableChangeDetection(bool enabled = true) noexcept { changeDetectionEnabled = enabled; }
285 
286  private:
292  void publishInt(int64_t val);
293  friend class ValueFederateManager;
294 };
295 
302 template<class X>
303 typename std::enable_if_t<helicsType<X>() != data_type::helics_custom, std::unique_ptr<Publication>>
305  const std::string& key,
306  const std::string& units = std::string())
307 {
308  return std::make_unique<Publication>(valueFed, helicsType<X>(), key, units);
309 }
310 
318 template<class X, class FedPtr>
319 typename std::enable_if_t<helicsType<X>() != data_type::helics_custom, std::unique_ptr<Publication>>
320  make_publication(FedPtr& valueFed,
321  const std::string& key,
322  const std::string& units = std::string())
323 {
324  return std::make_unique<Publication>(valueFed, helicsType<X>(), key, units);
325 }
326 
334 template<class X>
335 typename std::enable_if_t<helicsType<X>() != data_type::helics_custom, std::unique_ptr<Publication>>
337  ValueFederate* valueFed,
338  const std::string& key,
339  const std::string& units = std::string())
340 {
341  return std::make_unique<Publication>(locality, valueFed, key, helicsType<X>(), units);
342 }
343 
352 template<class X, class FedPtr>
353 typename std::enable_if_t<helicsType<X>() != data_type::helics_custom, std::unique_ptr<Publication>>
355  FedPtr& valueFed,
356  const std::string& key,
357  const std::string& units = std::string())
358 {
359  return std::make_unique<Publication>(locality, valueFed, key, helicsType<X>(), units);
360 }
361 
363 template<class X>
364 class PublicationT: public Publication {
365  public:
366  PublicationT() = default;
373  const std::string& key,
374  const std::string& units = std::string()):
375  Publication(valueFed, key, typeNameString<X>(), units)
376  {
377  }
383  template<class FedPtr>
384  PublicationT(FedPtr& valueFed,
385  const std::string& key,
386  const std::string& units = std::string()):
387  Publication(valueFed, key, typeNameString<X>(), units)
388  {
389  }
397  ValueFederate* valueFed,
398  const std::string& key,
399  const std::string& units = std::string()):
400  Publication(locality, valueFed, key, typeNameString<X>(), units)
401  {
402  }
409  template<class FedPtr>
411  FedPtr& valueFed,
412  const std::string& key,
413  const std::string& units = std::string()):
414  Publication(locality, valueFed, key, typeNameString<X>(), units)
415  {
416  }
419  void publish(const X& val) { Publication::publish(val); }
424  void publish(const X& val, const std::string& units)
425  {
426  // TODO(PT): figure out units
427  (void)(units);
429  }
430 };
431 
434 template<class X>
436  private:
437  X publishDelta;
438  mutable X prev;
439  public:
440  PublicationOnChange() = default;
448  const std::string& key,
449  const X& minChange,
450  const std::string& units = std::string()):
451  PublicationT<X>(valueFed, key, units),
452  publishDelta(minChange), prev(X())
453  {
454  }
461  template<class FedPtr>
462  PublicationOnChange(FedPtr& valueFed,
463  const std::string& key,
464  const X& minChange,
465  const std::string& units = std::string()):
466  PublicationT<X>(valueFed, key, units),
467  publishDelta(minChange), prev(X())
468  {
469  }
473  virtual void publish(const X& val) const override
474  {
475  if (std::abs(val - prev) >= publishDelta) {
476  prev = val;
478  }
479  }
480 };
481 
490 template<class... Us>
491 void publish(ValueFederate& fed, const std::string& pubKey, Us... pargs)
492 {
493  fed.getPublication(pubKey).publish(pargs...);
494 }
495 } // namespace helics
helics::operator!=
bool operator!=(const data_block &db1, const data_block &db2)
Definition: core-data.hpp:140
helics::Publication::publish
std::enable_if_t<((typeCategory< X >::value==nonConvertibleType) &&(!std::is_convertible< X, std::string >::value) &&(!std::is_same< X, defV >::value) &&(!std::is_convertible< X, Time >::value)), void > publish(const X &val)
Definition: Publications.hpp:262
helics::PublicationOnChange::PublicationOnChange
PublicationOnChange(FedPtr &valueFed, const std::string &key, const X &minChange, const std::string &units=std::string())
Definition: Publications.hpp:462
helics::Publication::getName
const std::string & getName() const
Definition: Publications.hpp:192
helics::Publication::Publication
Publication(FedPtr valueFed, const std::string &key, const std::string &type=std::string(), const std::string &units=std::string())
Definition: Publications.hpp:74
helics::Publication::getUnits
const std::string & getUnits() const
Definition: Publications.hpp:196
helics::Publication::setInfo
void setInfo(const std::string &info)
Definition: Publications.hpp:200
helics::NamedPoint
Definition: helicsTypes.hpp:111
helics::PublicationT::PublicationT
PublicationT(interface_visibility locality, FedPtr &valueFed, const std::string &key, const std::string &units=std::string())
Definition: Publications.hpp:410
helics::ValueFederate
Definition: application_api/ValueFederate.hpp:25
helics::PublicationT::PublicationT
PublicationT(ValueFederate *valueFed, const std::string &key, const std::string &units=std::string())
Definition: Publications.hpp:372
helics::Publication::getOption
int32_t getOption(int32_t option) const
Definition: Publications.hpp:210
helics::Publication::Publication
Publication(interface_visibility locality, FedPtr &valueFed, const std::string &key, const std::string &type, const std::string &units=std::string())
Definition: Publications.hpp:105
helics::ValueConverter
Definition: ValueConverter.hpp:26
helics::typeNameString
constexpr const char * typeNameString()
Definition: helicsTypes.hpp:149
helics::Time
TimeRepresentation< count_time< 9 > > Time
Definition: helics-time.hpp:27
helics::Publication::getKey
const std::string & getKey() const
Definition: Publications.hpp:190
helics::ValueFederate::publishRaw
void publishRaw(const Publication &pub, data_view block)
Definition: ValueFederate.cpp:401
helics::Publication::Publication
Publication(interface_visibility locality, ValueFederate *valueFed, const std::string &key, data_type type, const std::string &units=std::string())
Definition: Publications.hpp:151
helics::Publication::fed
ValueFederate * fed
the federate construct to interact with
Definition: Publications.hpp:25
helics::Publication::removeTarget
void removeTarget(const std::string &targetToRemove)
Definition: Publications.hpp:215
helics::PublicationT::publish
void publish(const X &val, const std::string &units)
Definition: Publications.hpp:424
helics::Publication::getType
const std::string & getType() const
Definition: Publications.hpp:194
helics::Publication::Publication
Publication(ValueFederate *valueFed, const std::string &key, data_type type, const std::string &units=std::string())
Definition: Publications.hpp:123
helics::PublicationT
Definition: Publications.hpp:364
helics::Publication::Publication
Publication(FedPtr &valueFed, const std::string &key, data_type type, const std::string &units=std::string())
Definition: Publications.hpp:137
helics::PublicationOnChange
Definition: Publications.hpp:435
helics::InvalidConversion
Definition: core-exceptions.hpp:57
helics::RegistrationFailure
Definition: core-exceptions.hpp:85
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::PublicationOnChange::PublicationOnChange
PublicationOnChange(ValueFederate *valueFed, const std::string &key, const X &minChange, const std::string &units=std::string())
Definition: Publications.hpp:447
helics::Publication::setMinimumChange
void setMinimumChange(double deltaV) noexcept
Definition: Publications.hpp:270
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::Publication::isValid
bool isValid() const
Definition: Publications.hpp:184
helics::Publication::getHandle
interface_handle getHandle() const
Definition: Publications.hpp:179
helics::Publication::pubType
data_type pubType
the type of publication
Definition: Publications.hpp:32
helics::ValueFederate::registerGlobalPublication
Publication & registerGlobalPublication(const std::string &key, const std::string &type, const std::string &units=std::string())
Definition: ValueFederate.cpp:107
helics::ValueFederate::getPublication
Publication & getPublication(const std::string &key)
Definition: ValueFederate.cpp:583
helics::Publication::Publication
Publication(interface_visibility locality, FedPtr &valueFed, const std::string &key, data_type type, const std::string &units=std::string())
Definition: Publications.hpp:168
fed
@ fed
special logging command for message coming from a fed
Definition: loggingHelper.hpp:32
helics::Publication::close
void close()
Definition: Publications.hpp:222
helics::Publication::getInfo
const std::string & getInfo() const
Definition: Publications.hpp:198
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::ValueFederateManager
Definition: ValueFederateManager.hpp:66
helics::PublicationT::PublicationT
PublicationT(interface_visibility locality, ValueFederate *valueFed, const std::string &key, const std::string &units=std::string())
Definition: Publications.hpp:396
helics::Publication::changeDetectionEnabled
bool changeDetectionEnabled
the change detection is enabled
Definition: Publications.hpp:33
helics::Publication
Definition: Publications.hpp:23
HelicsPrimaryTypes.hpp
naming a set of types that are interchangeable and recognizable inside the HELICS application API and...
helics::Publication::handle
interface_handle handle
the internal id of the publication
Definition: Publications.hpp:26
helics::Publication::publish
void publish(double val)
Definition: Publications.cpp:70
helics::make_publication
std::enable_if_t< helicsType< X >) !=data_type::helics_custom, std::unique_ptr< Publication > > make_publication(ValueFederate *valueFed, const std::string &key, const std::string &units=std::string())
Definition: Publications.hpp:304
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::Publication::addTarget
void addTarget(const std::string &target)
Definition: Publications.hpp:213
helics::Publication::enableChangeDetection
void enableChangeDetection(bool enabled=true) noexcept
Definition: Publications.hpp:284
helics::getTypeFromString
data_type getTypeFromString(const std::string &typeName)
Definition: helicsTypes.cpp:187
helics::typeConvert
data_block typeConvert(data_type type, double val)
Definition: helicsTypes.cpp:610
helics::publish
void publish(ValueFederate &fed, const std::string &pubKey, Us... pargs)
Definition: Publications.hpp:491
helics::PublicationT::publish
void publish(const X &val)
Definition: Publications.hpp:419
helics::Publication::publish
std::enable_if_t<(std::is_integral< X >::value &&!std::is_same< remove_cv_ref< X >, char >::value), void > publish(X val)
Definition: Publications.hpp:251
helics::interface_visibility
interface_visibility
Definition: helicsTypes.hpp:38
helics::PublicationOnChange::publish
virtual void publish(const X &val) const override
Definition: Publications.hpp:473
helics::Publication::setOption
void setOption(int32_t option, int32_t value=1)
Definition: Publications.hpp:204
helics::ValueFederate::registerPublication
Publication & registerPublication(const std::string &key, const std::string &type, const std::string &units=std::string())
Definition: ValueFederate.cpp:99
helics::PublicationT::PublicationT
PublicationT(FedPtr &valueFed, const std::string &key, const std::string &units=std::string())
Definition: Publications.hpp:384