dueca::TimeWarp Class Reference

Time warp for a triggering device. More...

#include <TimeWarp.hxx>

Inheritance diagram for dueca::TimeWarp:

Collaboration diagram for dueca::TimeWarp:

Public Member Functions
	TimeWarp (TriggerPuller &base, int warp=0)
	Constructor.
virtual	~TimeWarp ()
	Destructor.
void	warpTime (int w2)
	Change the warp time.
virtual const std::string &	getTargetName () const override
	Targets are usually "living" objects.
Public Member Functions inherited from dueca::TargetAndPuller
void	addTerm (TriggerPuller &p)
	Add another puller to this (and, or) combination of triggers.
void	addTerm (const boost::intrusive_ptr< TargetAndPuller > &p)
	Add another puller to this combination.
bool	removeTerm (TriggerPuller &p)
	Remove a term from this TriggerAnd or TriggerOr object.
Public Member Functions inherited from dueca::TriggerPuller
const std::string &	getTriggerName () const
	Find a name.

Additional Inherited Members
Protected Types inherited from dueca::TriggerPuller
typedef list< TargetData >	targetlist_type
	Combination of a target, someone to pull if requested, and the index that target needs to identify this puller.
Protected Member Functions inherited from dueca::TargetAndPuller
	TargetAndPuller (const std::string &name=std::string())
	Constructor.
virtual	~TargetAndPuller ()
	Destructor.
Protected Member Functions inherited from dueca::TriggerPuller
void	pull (const DataTimeSpec &ts)
	activate and notify the targets
	TriggerPuller (const std::string &name=std::string())
	Constructor.
virtual	~TriggerPuller ()
	Destructor.
virtual void	addTarget (const boost::intrusive_ptr< TriggerTarget > &target, unsigned id)
	Add a target to this puller, only called by TriggerTarget's setTrigger.
virtual void	removeTarget (const TriggerTarget *target)
	Remove a target from the puller, only called by destructor.
Protected Attributes inherited from dueca::TargetAndPuller
unsigned	name_psize
	Number of pullers when name calculated.
Protected Attributes inherited from dueca::TriggerPuller
targetlist_type	targets
	List of targets and indices.
std::bitset< MAX_MANAGERS >	activitylevels
	Index of activitymanager levels.
std::string	name
	Name, for debugging purposes.

Detailed Description

Time warp for a triggering device.

Say that you want to calculate your turbulence/wind field or whatever property that does not rely on input ahead of time. You could trigger on the ticker with a time warp:

// make a 'permanent' time warp (element of your class, or with
// 'new', assuming that `span` defines the time span (integer ticks)
// of your model updates:
TimeWarp* tw = new TimeWarp(Ticker::single(), span);
my_activity.setTrigger(*tw);

Now at – say – step 100-101, your activity gets triggered for 120-121, for a logical time that comes later (in the future) than the actual time of triggering. For negative warps the thing works the other way around.

Be careful when doing this with channels. If you timewarp into the (logical) future, the channel will not yet be filled with data from the time span you are referring to, and if you warp too much into the past, a stream channel may have run out of data.

Another use-case is in breaking a logical loop. Suppose you create a controller (autopilot) for your aircraft model. The controller uses the data from the input channel, let's call it ac://u, and the data from the output channel for the aircraft, ac://y. You need to combine the input at time t, with the output from one time step back, at t - span. Create a TimeWarp for the output channel:

TimeWarp* tw = new TimeWarp(r_ac_y, span);
my_activity.setTrigger(*tw && r_ac_u);

Whenever the output channel is written for a time t, it will now trigger your autopilot for a time t + span. As soon as the control input for that time is also available, your autopilot will be triggered.

Now there is a snag with this set-up. When the model is started at a time t0, there will be no output data from the aircraft model for time (t0 - span, t0), which would be used by your timewarp to trigger the autopilot for (t0, t0 + span). You can fix this by adding a manual TriggerPuller and running that one for (t0, t0 + span). The manual puller is 'or-ed' with the timewarp.

InitPuller* ipull = new ManualTriggerPuller("start-up puller");
TimeWarp* tw = new TimeWarp(r_ac_y, span);
my_activity.setTrigger((*tw || *ipull) && r_ac_u);

When you start your module's activities, provide the activation for the first round. Note also that you won't find data in the r_ac_y channel for that time, so make sure you catch the exception that results, and perform appropriately.

MyModule::startModule(const TimeSpec &time)
{
  do_calc.switchOn(time);
  ipull->pull(DataTimeSpec(time.getValidityStart(),
              time.getValidityStart() + span));
}

Another option would be to modify your aircraft simulation code, and provide (dummy) data on the output channel for the span just before the start time. It might be more efficient, but it also requires a code modification in a module that is not related to the autopilot module.

Note that in the examples given above, the TimeWarp and ManualTriggerPuller were created with new. You can of course also create these as members of your module class.

Constructor & Destructor Documentation

TimeWarp()

dueca::TimeWarp::TimeWarp	(	TriggerPuller &	base,
		int	warp = 0 )

Constructor.

Parameters

base	Trigger pulling object whose triggering is to be warped
warp	Warp time, the time added to the triggering time specification. Positive means it becomes "logically" later, negative means it becomes locigally earlier.

Member Function Documentation

getTargetName()

virtual const std::string & dueca::TimeWarp::getTargetName ( ) const

overridevirtual

Targets are usually "living" objects.

To find them, use getName()

---

The documentation for this class was generated from the following file:

• /home/abuild/rpmbuild/BUILD/dueca-4.2.1-build/dueca-4.2.1/dueca/TimeWarp.hxx