Simbody  3.6
Measure.h
Go to the documentation of this file.
1 #ifndef SimTK_SimTKCOMMON_MEASURE_H_
2 #define SimTK_SimTKCOMMON_MEASURE_H_
3 
4 /* -------------------------------------------------------------------------- *
5  * Simbody(tm): SimTKcommon *
6  * -------------------------------------------------------------------------- *
7  * This is part of the SimTK biosimulation toolkit originating from *
8  * Simbios, the NIH National Center for Physics-Based Simulation of *
9  * Biological Structures at Stanford, funded under the NIH Roadmap for *
10  * Medical Research, grant U54 GM072970. See https://simtk.org/home/simbody. *
11  * *
12  * Portions copyright (c) 2008-13 Stanford University and the Authors. *
13  * Authors: Michael Sherman *
14  * Contributors: *
15  * *
16  * Licensed under the Apache License, Version 2.0 (the "License"); you may *
17  * not use this file except in compliance with the License. You may obtain a *
18  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0. *
19  * *
20  * Unless required by applicable law or agreed to in writing, software *
21  * distributed under the License is distributed on an "AS IS" BASIS, *
22  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
23  * See the License for the specific language governing permissions and *
24  * limitations under the License. *
25  * -------------------------------------------------------------------------- */
26 
37 #include "SimTKcommon/basics.h"
38 #include "SimTKcommon/Simmatrix.h"
39 
40 #include <cassert>
41 
62 // Helper macro shared by SimTK_MEASURE_HANDLE_PREAMBLE and
63 // SimTK_MEASURE_HANDLE_PREAMBLE_ABSTRACT.
64 #define SimTK_MEASURE_HANDLE_PREAMBLE_BASE(MH,PH) \
65  class Implementation; \
66  explicit MH(Implementation* imp) : PH(imp) {} \
67  MH(SimTK::Subsystem& sub, Implementation* imp, \
68  const SimTK::AbstractMeasure::SetHandle& sh) \
69  : PH(sub,imp,sh) {} \
70  MH& operator=(const MH& src) {PH::operator=(src); return *this;}\
71  MH& shallowAssign(const MH& src) {PH::shallowAssign(src); return *this;}\
72  MH& deepAssign(const MH& src) {PH::deepAssign(src); return *this;}
73 
74 
75 // The default constructor for concrete classes should instantiate
76 // a default-constructed Implementation object if no Implementation object
77 // is provided.
78 #define SimTK_MEASURE_HANDLE_PREAMBLE(MH,PH) \
79  SimTK_MEASURE_HANDLE_PREAMBLE_BASE(MH,PH) \
80  MH() : PH(new Implementation()) {} \
81  explicit MH(SimTK::Subsystem& sub) \
82  : PH(sub,new Implementation(), typename PH::SetHandle()) {}
83 
84 
85 
86 // The default constructor for a still-abstract derived class can't
87 // instantiate an Implementation.
88 #define SimTK_MEASURE_HANDLE_PREAMBLE_ABSTRACT(MH,PH) \
89  SimTK_MEASURE_HANDLE_PREAMBLE_BASE(MH,PH) \
90  MH() : PH() {}
91 
111 #define SimTK_MEASURE_HANDLE_POSTSCRIPT(MH,PH) \
112  static bool isA(const SimTK::AbstractMeasure& m) \
113  { return dynamic_cast<const Implementation*>(&m.getImpl()) != 0; } \
114  static const MH& getAs(const SimTK::AbstractMeasure& m) \
115  { assert(isA(m)); return static_cast<const MH&>(m); } \
116  static MH& updAs(SimTK::AbstractMeasure& m) \
117  { assert(isA(m)); return static_cast<MH&>(m); } \
118  const Implementation& getImpl() const \
119  { return SimTK_DYNAMIC_CAST_DEBUG<const Implementation&> \
120  (SimTK::AbstractMeasure::getImpl());} \
121  Implementation& updImpl() \
122  { return SimTK_DYNAMIC_CAST_DEBUG<Implementation&> \
123  (SimTK::AbstractMeasure::updImpl());}
124 
125 namespace SimTK {
126 
127 class State;
128 class Subsystem;
129 class System;
130 class EventId;
131 
133 SimTK_DEFINE_UNIQUE_INDEX_TYPE(MeasureIndex);
134 
135 //==============================================================================
136 // ABSTRACT MEASURE
137 //==============================================================================
152 protected:
156  class SetHandle {};
157 
158 public:
159  class Implementation; // local; name is AbstractMeasure::Implementation
160 
164  explicit AbstractMeasure(Implementation* g=0);
165 
171 
175 
180  { return shallowAssign(source); }
181 
184  ~AbstractMeasure();
185 
191  AbstractMeasure& shallowAssign(const AbstractMeasure&);
192 
197  AbstractMeasure& deepAssign(const AbstractMeasure& source);
198 
206  int getNumTimeDerivatives() const;
207 
216  Stage getDependsOnStage(int derivOrder=0) const;
217 
218 
220  bool isSameMeasure(const AbstractMeasure& other) const
221  { return impl && impl==other.impl;}
222 
223  bool isEmptyHandle() const {return !hasImpl();}
224 
226  bool isInSubsystem() const;
230  const Subsystem& getSubsystem() const;
234  MeasureIndex getSubsystemMeasureIndex() const;
235 
236  // Internal use only
237 
238  // dynamic_cast the returned reference to a reference to your concrete
239  // Implementation class.
240  const Implementation& getImpl() const {assert(impl); return *impl;}
241  Implementation& updImpl() {assert(impl); return *impl;}
242  bool hasImpl() const {return impl!=0;}
243 
244  int getRefCount() const;
245 private:
246  // This is the only data member in this class. Also, any class derived
247  // from AbstractMeasure must have *NO* data members at all (data goes
248  // in the Implementation class).
249  Implementation* impl;
250 
251 friend class Implementation;
252 };
253 
254 
255 //==============================================================================
256 // MEASURE <T>
257 //==============================================================================
260 template <class T>
261 class Measure_ : public AbstractMeasure {
262 public:
266 
274  const T& getValue(const State& s, int derivOrder=0) const
275  { return getImpl().getValue(s,derivOrder); }
276 
283  Measure_& setDefaultValue(const T& defaultValue)
284  { updImpl().setDefaultValue(defaultValue); return *this; }
285 
288  const T& getDefaultValue() const
289  { return getImpl().getDefaultValue(); }
290 
291  // These are built-in Measures with local class names.
292 
293  // Templatized measures may have restrictions on the allowable template
294  // type and may be specialized for particular types.
295  class Zero; // T is any numerical type
296  class One; // T is any numerical type
297  class Constant; // T is any assignable type
298  class Time; // T is any type for which T(t) makes sense.
299  class Variable; // T is any assignable type (state)
300  class Result; // T is any assignable type (cache)
301  class SampleAndHold;// T is any assignable type
302  class Delay; // T is any assignable type
303 
304  // This requires any numerical type.
305  class Plus;
306  class Minus;
307  class Scale;
308  class Differentiate;
309 
310  // These find extreme values *in time*, not among inputs at the same
311  // time. They perform elementwise on aggregate types.
312  class Extreme; // base class for min/max/minabs/maxabs
313  class Minimum; // most positive value
314  class Maximum; // most negative value
315  class MinAbs; // the signed quantity whose absolute value was min
316  class MaxAbs; // the signed quantity whose absolute value was max
317 
318  // These accept floating point numerical template arguments only.
319  class Integrate;
320  class Sinusoid;
321 
323 };
324 
329 
330 
331 //==============================================================================
332 // CONSTANT
333 //==============================================================================
338 template <class T>
339 class Measure_<T>::Constant : public Measure_<T> {
340 public:
342 
345  explicit Constant(const T& value)
346  : Measure_<T>(new Implementation(value)) {}
347 
350  Constant(Subsystem& sub, const T& value)
351  : Measure_<T>(sub, new Implementation(value),
353 
356  Constant& setValue(const T& value)
357  { updImpl().setValue(value); return *this; }
358 
360 };
361 
362 //==============================================================================
363 // ZERO
364 //==============================================================================
368 template <class T>
369 class Measure_<T>::Zero : public Measure_<T>::Constant {
370 public:
371  Zero();
372  explicit Zero(Subsystem& sub);
373 };
374 
375 template <>
376 class Measure_< Vector >::Zero : public Measure_< Vector >::Constant {
377 public:
378  explicit Zero(int size);
379  Zero(Subsystem& sub, int size);
380 };
381 
382 //==============================================================================
383 // ONE
384 //==============================================================================
388 template <class T>
389 class Measure_<T>::One : public Measure_<T>::Constant {
390 public:
391  One();
392  explicit One(Subsystem& sub);
393 };
394 
395 template <>
396 class Measure_< Vector >::One : public Measure_< Vector >::Constant {
397 public:
398  explicit One(int size);
399  One(Subsystem& sub, int size);
400 };
401 
402 //==============================================================================
403 // TIME
404 //==============================================================================
406 template <class T>
407 class Measure_<T>::Time : public Measure_<T> {
408 public:
410 
412 };
413 
414 //==============================================================================
415 // VARIABLE
416 //==============================================================================
419 template <class T>
420 class Measure_<T>::Variable : public Measure_<T> {
421 public:
423 
424  // TODO: should not require invalidated Stage here. Instead,
425  // should have a unique "generation" counter for this variable
426  // and allow subsequent users to check it.
427  Variable(Subsystem& sub, Stage invalidates, const T& defaultValue)
428  : Measure_<T>(sub, new Implementation(invalidates, defaultValue),
430 
431 
432  void setValue(State& state, const T& value) const
433  { getImpl().setValue(state, value); }
434 
436 };
437 
438 //==============================================================================
439 // RESULT
440 //==============================================================================
454 template <class T>
455 class Measure_<T>::Result : public Measure_<T> {
456 public:
458 
459  // TODO: should not require invalidated Stage here. Instead,
460  // should have a unique "generation" counter for this cache entry
461  // and allow subsequent users of the value to check it.
462 
477  Result(Subsystem& sub, Stage dependsOn, Stage invalidated)
478  : Measure_<T>(sub, new Implementation(dependsOn, invalidated),
480 
484  Stage getInvalidatedStage() const {return getImpl().getInvalidatedStage();}
493  { updImpl().setDependsOnStage(dependsOn); return *this; }
500  { updImpl().setInvalidatedStage(invalidated); return *this; }
501 
515  { updImpl().setIsPresumedValidAtDependsOnStage(presume); return *this; }
516 
521 
522 
528  T& updValue(const State& state) const
529  { return getImpl().updValue(state); }
530 
537  void markAsValid(const State& state) const {getImpl().markAsValid(state);}
538 
542  bool isValid(const State& state) const {return getImpl().isValid(state);}
543 
551  void markAsNotValid(const State& state) const
552  { getImpl().markAsNotValid(state); }
553 
557  void setValue(const State& state, const T& value) const
558  { updValue(state) = value; markAsValid(state); }
559 
561 };
562 
563 //==============================================================================
564 // SINUSOID
565 //==============================================================================
572 template <class T>
573 class Measure_<T>::Sinusoid : public Measure_<T> {
574 public:
576 
578  const T& amplitude,
579  const T& frequency,
580  const T& phase=T(0))
581  : Measure_<T>(sub, new Implementation(amplitude,frequency,phase),
583 
585 };
586 
587 //==============================================================================
588 // PLUS
589 //==============================================================================
594 template <class T>
595 class Measure_<T>::Plus : public Measure_<T> {
596 public:
598 
599  Plus(Subsystem& sub, const Measure_<T>& left, const Measure_<T>& right)
600  : Measure_<T>(sub, new Implementation(left, right),
603  ( this->getSubsystem().isSameSubsystem(left.getSubsystem())
604  && this->getSubsystem().isSameSubsystem(right.getSubsystem()),
605  "Measure_<T>::Plus::ctor()",
606  "Arguments must be in the same Subsystem as this Measure.");
607  }
608 
610 };
611 
612 //==============================================================================
613 // MINUS
614 //==============================================================================
619 template <class T>
620 class Measure_<T>::Minus : public Measure_<T> {
621 public:
623 
624  Minus(Subsystem& sub, const Measure_<T>& left, const Measure_<T>& right)
625  : Measure_<T>(sub, new Implementation(left, right),
628  ( this->getSubsystem().isSameSubsystem(left.getSubsystem())
629  && this->getSubsystem().isSameSubsystem(right.getSubsystem()),
630  "Measure_<T>::Minus::ctor()",
631  "Arguments must be in the same Subsystem as this Measure.");
632  }
633 
635 };
636 
637 //==============================================================================
638 // SCALE
639 //==============================================================================
644 template <class T>
645 class Measure_<T>::Scale : public Measure_<T> {
646 public:
648 
649  Scale(Subsystem& sub, Real factor, const Measure_<T>& operand)
650  : Measure_<T>(sub, new Implementation(factor, operand),
653  (this->getSubsystem().isSameSubsystem(operand.getSubsystem()),
654  "Measure_<T>::Scale::ctor()",
655  "Argument must be in the same Subsystem as this Measure.");
656  }
657 
660  { return getImpl().getOperandMeasure(); }
661 
663 };
664 
665 //==============================================================================
666 // INTEGRATE
667 //==============================================================================
674 template <class T>
675 class Measure_<T>::Integrate : public Measure_<T> {
676 public:
678 
685  Integrate(Subsystem& subsystem,
686  const Measure_<T>& deriv,
687  const Measure_<T>& ic,
688  const T& initAlloc=T(0))
689  : Measure_<T>(subsystem, new Implementation(deriv,ic,initAlloc),
691 
694  void setValue(State& s, const T& value) const
695  { return getImpl().setValue(s, value); }
696 
699 
700  { return getImpl().getDerivativeMeasure(); }
704  { return getImpl().getInitialConditionMeasure(); }
705 
707  { updImpl().setDerivativeMeasure(d); return *this; }
709  { updImpl().setInitialConditionMeasure(ic); return *this; }
710 
712 };
713 
714 //==============================================================================
715 // DIFFERENTIATE
716 //==============================================================================
741 template <class T>
742 class Measure_<T>::Differentiate : public Measure_<T> {
743 public:
745 
750  Differentiate(Subsystem& subsystem, const Measure_<T>& operand)
751  : Measure_<T>(subsystem, new Implementation(operand),
753 
758  bool isUsingApproximation() const
759  { return getImpl().isUsingApproximation(); }
760 
764  { return getImpl().getOperandMeasure(); }
765 
770  { updImpl().setOperandMeasure(operand); return *this; }
771 
775  void setForceUseApproximation(bool mustApproximate)
776  { updImpl().setForceUseApproximation(mustApproximate); }
777 
783  { return getImpl().getForceUseApproximation(); }
784 
786 };
787 
788 //==============================================================================
789 // EXTREME, MINIMUM, MAXIMUM, MINABS, MAXABS
790 //==============================================================================
834 template <class T>
835 class Measure_<T>::Extreme : public Measure_<T> {
836 public:
838 
839  enum Operation {
840  MaxAbs, // default
844  };
845 
849  Extreme(Subsystem& sub, const Measure_<T>& operand, Operation op=MaxAbs)
850  : Measure_<T>(sub, new Implementation(operand, op),
852 
855  { updImpl().setOperation(op); return *this; }
856 
858  Operation getOperation() const {return getImpl().getOperation();}
859 
865  Real getTimeOfExtremeValue(const State& state) const
866  { return getImpl().getTimeOfExtremeValue(state); }
867 
868  void setValue(State& s, const T& value) const
869  { return getImpl().setValue(s, value); }
870 
872  { return getImpl().getOperandMeasure(); }
873 
875  { updImpl().setOperandMeasure(s); return *this; }
876 
878 };
879 
882 template <class T>
883 class Measure_<T>::Minimum : public Measure_<T>::Extreme {
884  typedef typename Measure_<T>::Extreme Super;
885 public:
886  Minimum(Subsystem& sub, const Measure_<T>& operand)
887  : Super(sub, operand, Super::Minimum) {}
888 };
889 
892 template <class T>
893 class Measure_<T>::Maximum : public Measure_<T>::Extreme {
894  typedef typename Measure_<T>::Extreme Super;
895 public:
896  Maximum(Subsystem& sub, const Measure_<T>& operand)
897  : Super(sub, operand, Super::Maximum) {}
898 };
899 
902 template <class T>
903 class Measure_<T>::MaxAbs : public Measure_<T>::Extreme {
904  typedef typename Measure_<T>::Extreme Super;
905 public:
906  MaxAbs(Subsystem& sub, const Measure_<T>& operand)
907  : Super(sub, operand, Super::MaxAbs) {}
908 };
909 
913 template <class T>
914 class Measure_<T>::MinAbs : public Measure_<T>::Extreme {
915  typedef typename Measure_<T>::Extreme Super;
916 public:
917  MinAbs(Subsystem& sub, const Measure_<T>& operand)
918  : Super(sub, operand, Super::MinAbs) {}
919 };
920 
921 //==============================================================================
922 // DELAY
923 //==============================================================================
970 template <class T>
971 class Measure_<T>::Delay : public Measure_<T> {
972 public:
979  Delay(Subsystem& sub, const Measure_<T>& source, Real delay)
980  : Measure_<T>(sub, new Implementation(source, delay),
982 
989  { updImpl().setUseLinearInterpolationOnly(linearOnly); return *this; }
990 
1004  Delay& setCanUseCurrentValue(bool canUseCurrentValue)
1005  { updImpl().setCanUseCurrentValue(canUseCurrentValue); return *this; }
1006 
1009  { updImpl().setSourceMeasure(source); return *this; }
1010 
1013  { updImpl().setDelay(delay); return *this; }
1014 
1017  { return getImpl().getUseLinearInterpolationOnly(); }
1018 
1021  { return getImpl().getCanUseCurrentValue(); }
1022 
1025  { return getImpl().getSourceMeasure(); }
1026 
1029  Real getDelay() const
1030  { return getImpl().getDelay(); }
1031 
1035 };
1036 
1037 //==============================================================================
1038 // SAMPLE AND HOLD
1039 //==============================================================================
1054 template <class T>
1055 class Measure_<T>::SampleAndHold : public Measure_<T> {
1056 public:
1058 
1059  SampleAndHold(Subsystem& sub, const Measure_<T>& source, EventId e);
1060 
1063  void setValue(State& s, const T& value) const;
1064 
1066  void sample(State& s) const;
1067 
1068  const Measure_<T>& getSource() const;
1069  EventId getEventId() const;
1070 
1071  SampleAndHold& setSource(const Measure_<T>& s);
1072  SampleAndHold& setEventId(EventId);
1073 
1075 };
1076 
1077 } // namespace SimTK
1078 
1079 #endif // SimTK_SimTKCOMMON_MEASURE_H_
SimTK::Measure_::Result::getIsPresumedValidAtDependsOnStage
bool getIsPresumedValidAtDependsOnStage() const
Return the value of the "presumed valid at dependsOn stage" flag.
Definition: Measure.h:519
SimTK::Measure_::Extreme::MaxAbs
@ MaxAbs
Definition: Measure.h:840
SimTK::State
This object is intended to contain all state information for a SimTK::System, except topological info...
Definition: State.h:280
SimTK::Measure_::setDefaultValue
Measure_ & setDefaultValue(const T &defaultValue)
Change the default value associated with this Measure.
Definition: Measure.h:283
SimTK::Measure_::Extreme::setValue
void setValue(State &s, const T &value) const
Definition: Measure.h:868
SimTK::Measure_::Integrate::getDerivativeMeasure
const Measure_< T > & getDerivativeMeasure() const
Get the integrand (derivative) measure for this integral.
Definition: Measure.h:698
SimTK::Measure_::Scale::Scale
Scale(Subsystem &sub, Real factor, const Measure_< T > &operand)
Definition: Measure.h:649
SimTK::Measure_::Extreme::setOperation
Extreme & setOperation(Operation op)
Set the operation to be performed.
Definition: Measure.h:854
SimTK::Measure_::Result::setValue
void setValue(const State &state, const T &value) const
Set a new value and mark it as valid.
Definition: Measure.h:557
SimTK::Measure_::Delay::getDelay
Real getDelay() const
Get the amount of time by which this Measure is delaying its source Measure.
Definition: Measure.h:1029
SimTK::Measure_::Differentiate::getOperandMeasure
const Measure_< T > & getOperandMeasure() const
Get a reference to the measure that is being differentiated by this measure.
Definition: Measure.h:763
SimTK::Measure_::One
This creates a Measure::Constant whose value is always T(1) and can't be changed.
Definition: Measure.h:389
SimTK::Subsystem
A Subsystem is expected to be part of a larger System and to have interdependencies with other subsys...
Definition: Subsystem.h:55
SimTK::AbstractMeasure::Implementation
The abstract parent of all Measure Implementation classes.
Definition: MeasureImplementation.h:48
SimTK::Measure_::Implementation::getIsPresumedValidAtDependsOnStage
bool getIsPresumedValidAtDependsOnStage() const
Definition: MeasureImplementation.h:418
SimTK::Measure_::MinAbs::MinAbs
MinAbs(Subsystem &sub, const Measure_< T > &operand)
Definition: Measure.h:917
SimTK::Measure_::Result::getDependsOnStage
Stage getDependsOnStage() const
Get the dependsOn stage for this measure's value.
Definition: Measure.h:482
SimTK::Measure_::Differentiate::isUsingApproximation
bool isUsingApproximation() const
Test whether the derivative returned as the value of this measure is being estimated numerically,...
Definition: Measure.h:758
SimTK::AbstractMeasure::updImpl
Implementation & updImpl()
Definition: Measure.h:241
SimTK::Measure_::Delay
(CAUTION: still under development) This is a Measure whose value at time t is the value that its sour...
Definition: Measure.h:971
SimTK::Measure_::MaxAbs::MaxAbs
MaxAbs(Subsystem &sub, const Measure_< T > &operand)
Definition: Measure.h:906
SimTK::Measure_::Delay::setSourceMeasure
Delay & setSourceMeasure(const Measure_< T > &source)
Replace the source measure.
Definition: Measure.h:1008
SimTK::Measure_::Integrate::Integrate
Integrate(Subsystem &subsystem, const Measure_< T > &deriv, const Measure_< T > &ic, const T &initAlloc=T(0))
Create a new measure that will use Measure ic's value for initial conditions, and then integrate the ...
Definition: Measure.h:685
SimTK::Measure_::Variable::Variable
Variable(Subsystem &sub, Stage invalidates, const T &defaultValue)
Definition: Measure.h:427
SimTK::AbstractMeasure::hasImpl
bool hasImpl() const
Definition: Measure.h:242
SimTK::Measure_::SimTK_MEASURE_HANDLE_PREAMBLE_ABSTRACT
SimTK_MEASURE_HANDLE_PREAMBLE_ABSTRACT(Measure_, AbstractMeasure)
This class is still abstract so we don't want it to allocate an Implementation object in its default ...
SimTK
This is a System that represents the dynamics of a particle moving along a smooth surface.
Definition: Assembler.h:37
SimTK::Measure_::Result::isValid
bool isValid(const State &state) const
Check whether the value contained in this Measure is currently valid.
Definition: Measure.h:542
Simmatrix.h
SimTK::Measure_::Delay::setCanUseCurrentValue
Delay & setCanUseCurrentValue(bool canUseCurrentValue)
(Advanced) Allow the Delay measure to refer to the current value when estimating the delayed value.
Definition: Measure.h:1004
SimTK::Measure_::Scale::Implementation
Definition: MeasureImplementation.h:1072
SimTK::Measure_::getValue
const T & getValue(const State &s, int derivOrder=0) const
Retrieve the Value of this Measure or one of its time derivatives, assuming the supplied State has be...
Definition: Measure.h:274
SimTK::Measure_::Delay::setUseLinearInterpolationOnly
Delay & setUseLinearInterpolationOnly(bool linearOnly)
(Advanced) Restrict the Delay measure to use only linear interpolation to estimate delayed values.
Definition: Measure.h:988
SimTK::Measure_::Delay::Delay
Delay(Subsystem &sub, const Measure_< T > &source, Real delay)
Create a Measure whose output is the same as the given source measure but delayed by a time delay.
Definition: Measure.h:979
SimTK::Measure_::SimTK_MEASURE_HANDLE_POSTSCRIPT
SimTK_MEASURE_HANDLE_POSTSCRIPT(Measure_, AbstractMeasure)
SimTK::Measure_::Result::markAsValid
void markAsValid(const State &state) const
Mark the current value as valid.
Definition: Measure.h:537
SimTK::Measure_::Delay::getCanUseCurrentValue
bool getCanUseCurrentValue() const
Return the value of the "can use current value" flag.
Definition: Measure.h:1020
SimTK::Measure_::Constant::setValue
Constant & setValue(const T &value)
Change the value returned by this Measure.
Definition: Measure.h:356
SimTK::Measure_::Constant::Implementation
Definition: MeasureImplementation.h:606
SimTK::AbstractMeasure
This is the base class for all Measure handle classes.
Definition: Measure.h:151
SimTK::Measure_::MinAbs
Track the value of the operand that is of minimum absolute value (not very useful).
Definition: Measure.h:914
SimTK::Measure_::Differentiate
This Measure operator returns the time derivative of its operand measure, or a numerical approximatio...
Definition: Measure.h:742
SimTK::Measure_::Result::markAsNotValid
void markAsNotValid(const State &state) const
Manually mark the contained value as invalid.
Definition: Measure.h:551
SimTK::Measure_::Extreme::getOperation
Operation getOperation() const
Return the operation currently being performed by this measure.
Definition: Measure.h:858
SimTK::Measure_::Extreme::Extreme
Extreme(Subsystem &sub, const Measure_< T > &operand, Operation op=MaxAbs)
Default behavior for the Extreme measure is to find the operand's value that is of maximum absolute v...
Definition: Measure.h:849
SimTK::Measure_::Result::Result
Result(Subsystem &sub, Stage dependsOn, Stage invalidated)
Create a new Result measure and add it to the indicated subsystem.
Definition: Measure.h:477
SimTK_SimTKCOMMON_EXPORT
#define SimTK_SimTKCOMMON_EXPORT
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:224
SimTK::Measure_::Integrate::setDerivativeMeasure
Integrate & setDerivativeMeasure(const Measure_< T > &d)
Definition: Measure.h:706
SimTK::Measure_::Result::setDependsOnStage
Result & setDependsOnStage(Stage dependsOn)
Change the dependsOn stage for this measure's value, which must be strictly less than the current set...
Definition: Measure.h:492
SimTK::Measure_::Scale
This Measure multiplies some other Measure by a Real scale factor.
Definition: Measure.h:645
SimTK::Measure_::Extreme::MinAbs
@ MinAbs
Definition: Measure.h:842
SimTK::Measure_::Differentiate::setForceUseApproximation
void setForceUseApproximation(bool mustApproximate)
Force use of numerical approximation for the derivative, even if the operand measure can supply its o...
Definition: Measure.h:775
SimTK::Measure_::SampleAndHold
NOT IMPLEMENTED YET – This is a Measure operator which, upon occurrence of a designated event,...
Definition: Measure.h:1055
SimTK::Measure_::Extreme::setOperandMeasure
Extreme & setOperandMeasure(const Measure_< T > &s)
Definition: Measure.h:874
SimTK::AbstractMeasure::operator=
AbstractMeasure & operator=(const AbstractMeasure &source)
Shallow assignment operator results in this handle referencing the same Implementation object as does...
Definition: Measure.h:179
SimTK::Measure_::Result::Implementation
Definition: MeasureImplementation.h:786
SimTK::Measure_::Sinusoid::Sinusoid
Sinusoid(Subsystem &sub, const T &amplitude, const T &frequency, const T &phase=T(0))
Definition: Measure.h:577
SimTK::Measure_::Integrate
This measure yields the time integral of a given derivative measure, initializing with an initial con...
Definition: Measure.h:675
SimTK::Measure_::Constant::Constant
Constant(const T &value)
Create a constant measure that is not part of any Subsystem, and provide the constant value.
Definition: Measure.h:345
SimTK::Measure_::Integrate::setInitialConditionMeasure
Integrate & setInitialConditionMeasure(const Measure_< T > &ic)
Definition: Measure.h:708
SimTK::Measure_::Integrate::setValue
void setValue(State &s, const T &value) const
Set the current value of this measure by modifying the state variables that hold the integral.
Definition: Measure.h:694
SimTK_ERRCHK_ALWAYS
#define SimTK_ERRCHK_ALWAYS(cond, whereChecked, msg)
Definition: ExceptionMacros.h:281
SimTK::Measure_::Minus::Implementation
Definition: MeasureImplementation.h:1019
SimTK::Stage
This class is basically a glorified enumerated type, type-safe and range checked but permitting conve...
Definition: Stage.h:66
SimTK::AbstractMeasure::SetHandle
An object of this type is used as a dummy argument to make sure the automatically-generated handle co...
Definition: Measure.h:156
SimTK::AbstractMeasure::Implementation::getDependsOnStage
Stage getDependsOnStage(int derivOrder) const
Definition: MeasureImplementation.h:105
EventId
SimTK::Subsystem::isSameSubsystem
bool isSameSubsystem(const Subsystem &otherSubsystem) const
Determine if this Subsystem handle refers to the same Subsystem::Guts object as handle otherSubsystem...
Definition: Subsystem.h:322
SimTK::Measure_::Constant
This creates a Measure whose value is a Topology-stage constant of any type T.
Definition: Measure.h:339
SimTK::One
const Real One
Real(1)
SimTK::Measure_::Extreme::Implementation
Definition: MeasureImplementation.h:1439
SimTK::Measure_::Plus::Implementation
Definition: MeasureImplementation.h:966
SimTK::AbstractMeasure::isEmptyHandle
bool isEmptyHandle() const
Definition: Measure.h:223
SimTK::Measure_::Implementation::getDefaultValue
const T & getDefaultValue() const
Return a reference to the value that this Measure will use to initialize its value-level state resour...
Definition: MeasureImplementation.h:412
SimTK::Measure_::Plus::Plus
Plus(Subsystem &sub, const Measure_< T > &left, const Measure_< T > &right)
Definition: Measure.h:599
SimTK::Measure_::Differentiate::Implementation
Definition: MeasureImplementation.h:1299
SimTK::Measure_::Minus::Minus
Minus(Subsystem &sub, const Measure_< T > &left, const Measure_< T > &right)
Definition: Measure.h:624
SimTK::Measure_::Minimum
Track the minimum value of the operand (signed).
Definition: Measure.h:883
SimTK::Measure_::Maximum
Track the maximum value of the operand (signed).
Definition: Measure.h:893
SimTK::Measure_::Delay::setDelay
Delay & setDelay(Real delay)
Change the delay time.
Definition: Measure.h:1012
SimTK::Measure_::Maximum::Maximum
Maximum(Subsystem &sub, const Measure_< T > &operand)
Definition: Measure.h:896
Operation
Operation
Definition: Measure.h:839
SimTK_MEASURE_HANDLE_PREAMBLE
#define SimTK_MEASURE_HANDLE_PREAMBLE(MH, PH)
Definition: Measure.h:78
SimTK::Measure_::getDefaultValue
const T & getDefaultValue() const
Obtain a reference to the default value associated with this Measure.
Definition: Measure.h:288
SimTK::Measure_::Implementation::getValue
const T & getValue(const State &s, int derivOrder) const
Definition: MeasureImplementation.h:361
SimTK::Measure_::Plus
This Measure is the sum of two Measures of the same type T.
Definition: Measure.h:595
SimTK::Measure_::Delay::getSourceMeasure
const Measure_< T > & getSourceMeasure() const
Obtain a reference to the source Measure.
Definition: Measure.h:1024
SimTK::Real
SimTK_Real Real
This is the default compiled-in floating point type for SimTK, either float or double.
Definition: SimTKcommon/include/SimTKcommon/internal/common.h:606
SimTK::Measure_::Constant::Constant
Constant(Subsystem &sub, const T &value)
Create a constant measure with the given value and install it into the given Subsystem.
Definition: Measure.h:350
SimTK::Measure_::Result::setIsPresumedValidAtDependsOnStage
Result & setIsPresumedValidAtDependsOnStage(bool presume)
Normally a Result measure's value is not considered valid unless we are notified explicitly that it i...
Definition: Measure.h:514
SimTK::Measure_::Implementation::setIsPresumedValidAtDependsOnStage
void setIsPresumedValidAtDependsOnStage(bool presume)
Definition: MeasureImplementation.h:414
SimTK::Measure_::Implementation::setDefaultValue
void setDefaultValue(const T &defaultValue)
Set a new default value for this Measure.
Definition: MeasureImplementation.h:403
SimTK::Measure_::MaxAbs
Track the value of the operand that is of maximum absolute value.
Definition: Measure.h:903
SimTK::Measure_::Extreme::getTimeOfExtremeValue
Real getTimeOfExtremeValue(const State &state) const
Return the time at which the reported extreme value first occurred.
Definition: Measure.h:865
SimTK::Vector_< Real >
SimTK::Measure_::Differentiate::setOperandMeasure
Differentiate & setOperandMeasure(const Measure_< T > &operand)
Set the measure that is to be differentiated by this measure.
Definition: Measure.h:769
SimTK::Measure_::Integrate::getInitialConditionMeasure
const Measure_< T > & getInitialConditionMeasure() const
Get the measure whose value is used as an initial condition for the integral at the start of an integ...
Definition: Measure.h:703
SimTK::Measure_::Extreme::Maximum
@ Maximum
Definition: Measure.h:841
SimTK::Measure_::Minus
This Measure is the difference of two Measures of the same type T.
Definition: Measure.h:620
SimTK::AbstractMeasure::isSameMeasure
bool isSameMeasure(const AbstractMeasure &other) const
There can be multiple handles on the same Measure.
Definition: Measure.h:220
basics.h
SimTK::Measure_::Extreme
This Measure tracks extreme values attained by the elements of its source operand since the last init...
Definition: Measure.h:835
SimTK::Measure_::Differentiate::getForceUseApproximation
bool getForceUseApproximation() const
Check the current value of the flag which forces this measure to use numerical approximation regardle...
Definition: Measure.h:782
SimTK::SimTK_DEFINE_UNIQUE_INDEX_TYPE
SimTK_DEFINE_UNIQUE_INDEX_TYPE(AssemblyConditionIndex)
SimTK::Measure_::Differentiate::Differentiate
Differentiate(Subsystem &subsystem, const Measure_< T > &operand)
Create a measure whose value is the time derivative of the given operand measure.
Definition: Measure.h:750
SimTK::Measure_
This is the base handle class for all Measures whose value type is known, including all the Simbody b...
Definition: Measure.h:261
SimTK::AbstractMeasure::getImpl
const Implementation & getImpl() const
Definition: Measure.h:240
SimTK::Measure_::Zero
This creates a Measure::Constant whose value is always T(0) and can't be changed.
Definition: Measure.h:369
SimTK::Measure_::Scale::getOperandMeasure
const Measure_< T > & getOperandMeasure() const
Get the operand (thing being scaled) measure for this measure.
Definition: Measure.h:659
SimTK::Measure_::Integrate::Implementation
The implementation for Integrate measures allocates a continuous state variable or variables from the...
Definition: MeasureImplementation.h:1141
SimTK::Measure_::Result::getInvalidatedStage
Stage getInvalidatedStage() const
Get the invalidated stage for this measure's value.
Definition: Measure.h:484
SimTK::Measure_::Minimum::Minimum
Minimum(Subsystem &sub, const Measure_< T > &operand)
Definition: Measure.h:886
SimTK::Measure_::Sinusoid::Implementation
Definition: MeasureImplementation.h:902
SimTK::Measure_::Result::setInvalidatedStage
Result & setInvalidatedStage(Stage invalidated)
Change the invalidated stage for this measure's value, which must be strictly greater than the curren...
Definition: Measure.h:499
SimTK::Measure_::Result::updValue
T & updValue(const State &state) const
Obtain write access to the Measure's value in order to modify it.
Definition: Measure.h:528
SimTK::Measure
Measure_< Real > Measure
This typedef is a convenient abbreviation for the most common kind of Measure – one that returns a si...
Definition: Measure.h:328
SimTK::AbstractMeasure::getSubsystem
const Subsystem & getSubsystem() const
Return a reference to the Subsystem that owns this Measure.
Definition: MeasureImplementation.h:229
SimTK::Measure_::Time
This creates a Measure::Time whose value is always T(time).
Definition: Measure.h:407
SimTK::Measure_::Delay::getUseLinearInterpolationOnly
bool getUseLinearInterpolationOnly() const
Return the value of the "use linear interpolation only" flag.
Definition: Measure.h:1016
SimTK::Measure_::Variable::setValue
void setValue(State &state, const T &value) const
Definition: Measure.h:432
SimTK::Zero
const Real Zero
Real(0)
SimTK::Measure_::Sinusoid
This measure produces a sinusoidal function of time:
Definition: Measure.h:573
SimTK::Measure_::Delay::Implementation
Definition: MeasureImplementation.h:2024
SimTK::Measure_::Extreme::getOperandMeasure
const Measure_< T > & getOperandMeasure() const
Definition: Measure.h:871
SimTK::Measure_::Variable
This creates a Measure whose value is a discrete State variable of any type T.
Definition: Measure.h:420
SimTK::Measure_::Result
This Measure holds the result of some externally-determined computation, and helps to coordinate the ...
Definition: Measure.h:455
SimTK::Measure_::Variable::Implementation
Definition: MeasureImplementation.h:706