/// <summary>
/// Compared to <see cref="GetValues(IBaseExchangeItem)"/>,
/// this version adds the values to the targetSet (for reuse or adding to a targetSet)
/// </summary>
public void GetValues(ITimeSpaceValueSet <double> targetSet, IBaseExchangeItem querySpecifier2)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier2 as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("querySpecifier must be an ITimeSpaceExchangeItem - add an adaptor");
}
if (!(timeSpaceQuery is ITimeSpaceInput))
{
throw new OpenMIException("Get Values can only be called with an Input as argument")
{
Component = Adaptee.Component, Output = this
};
}
// Set query time to internal query item
_query.TimeSet = timeSpaceQuery.TimeSet;
ITimeSpaceValueSet incomingValues = _adaptee.GetValues(_query);
// Transform the values from the adaptee
_elementMapper.MapValues(targetSet, incomingValues);
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
// Note (SH): shouldn't a copy be made here?
// Reply (ADH): In EngineWrapper2 I effectivly clone via the Values attribute
// Suggest that standard should require GetValues to return
// cloned IValueSet.
// Maybe, more simply, IVAlueSet should implement IClonable
ITimeSpaceValueSet values = base.GetValues(querySpecifier);
if (values == null)
{
return(values);
}
if (!_initialisedFromArgs)
{
InitialiseFromArgs();
}
for (int m = 0; m < values.Values2D.Count; ++m)
{
for (int n = 0; n < values.Values2D[m].Count; ++n)
{
if (values.Values2D[m][n] is double)
{
values.Values2D[m][n] = _a * (double)values.Values2D[m][n] + _b;
}
}
}
return(values);
}
public ExchangeItem(IBaseExchangeItem openMIItem, bool useBufferedValues)
{
if (openMIItem is ITimeSpaceOutput)
{
_openMIItem = _openMIOutputItem = (ITimeSpaceOutput)openMIItem;
}
else if (openMIItem is ITimeSpaceInput)
{
_openMIItem = _openMIInputItem = (ITimeSpaceInput)openMIItem;
}
else
{
throw new Exception("Unknown exchange item type: " + openMIItem.GetType());
}
if (_openMIItem.TimeSet != null && _openMIItem.TimeSet.HasDurations)
{
throw new Exception("\"" + Id + ": OpenDA Time Spans not covered by OpenDA Exchange items");
}
_useBufferedValues = useBufferedValues;
if (_useBufferedValues)
{
_bufferedValues = new List <List <double> > {
new List <double>()
};
_bufferedTimes = new List <double>();
}
}
public ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("Must be an ITimeSpaceExchangeItem, add an adaptor", "querySpecifier");
}
if (_children.Count == 0)
{
return(null); // TODO: Or throw an exception?
}
TimeSpaceValueSet <double> resultSet = ElementMapper.CreateResultValueSet(timeSpaceQuery.TimeSet.Times.Count, this.ElementSet().ElementCount);
// Get values from all adaptees/children, and add them together
for (int i = 0; i < _children.Count; i++)
{
ITimeSpaceOutputAdder addingChild = _children[i] as ITimeSpaceOutputAdder;
if (addingChild != null)
{
addingChild.GetValues(resultSet, querySpecifier);
}
else
{
ITimeSpaceValueSet values = _children[i].GetValues(querySpecifier);
AddSourceToTarget(resultSet, values);
}
}
return(resultSet);
}
public void AddOut(IBaseExchangeItem openMIo)
{
if (openMIo is ITimeSpaceOutput)
{
_openMIItem = _openMIOutputItem = (ITimeSpaceOutput)openMIo;
}
}
public void AddIn(IBaseExchangeItem openMIo)
{
if (openMIo is ITimeSpaceInput)
{
_openMIItem = _openMIInputItem = (ITimeSpaceInput)openMIo;
}
}
/// <summary>
/// Get the value definition as a quality, throwing an
/// exception if it is not a quality
/// </summary>
public static IQuality Quality(this IBaseExchangeItem item)
{
IQuality quality = item.ValueDefinition as IQuality;
if (quality == null)
{
throw new Exception("ValueDefinition is not a quality");
}
return(quality);
}
/// <summary>
/// Get the <see cref="IElementSet"/> from the <paramref name="baseitem"/>,
/// assuming it is a <see cref="ITimeSpaceExchangeItem"/> with an <see cref="IElementSet"/>
/// as its <see cref="ITimeSpaceExchangeItem.SpatialDefinition"/>. If not, exceptions
/// are thrown.
/// </summary>
public static IElementSet ElementSet(this IBaseExchangeItem baseitem)
{
ITimeSpaceExchangeItem item = baseitem as ITimeSpaceExchangeItem;
if (item == null)
{
throw new Exception("base item is not an ITimeSpaceExchangeItem");
}
return(item.ElementSet());
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("querySpecifier must be an ITimeSpaceExchangeItem - add an adaptor");
}
CheckSpecificationAndTryUpdateIfRequired(timeSpaceQuery);
return(Values);
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier2)
{
CheckBuffer();
List <IList <double> > valuesList = new List <IList <double> >();
for (int i = 0; i < ((ITimeSpaceInput)Consumers[0]).TimeSet.Times.Count; i++)
{
ITime time = ((ITimeSpaceInput)Consumers[0]).TimeSet.Times[i];
valuesList.Add(_buffer.GetValues(time));
}
return(new TimeSpaceValueSet <double>(valuesList));
}
public static bool Update(ITimeSpaceOutput output, IBaseExchangeItem basequerySpecifier)
{
ITimeSpaceExchangeItem querySpecifier = basequerySpecifier as ITimeSpaceExchangeItem;
if (querySpecifier == null)
{
throw new ArgumentException("querySpecifier must be an ITimeSpaceExchangeItem - add an adaptor");
}
// Time set of query must be defined and have at least 1 time
if (querySpecifier.TimeSet == null ||
querySpecifier.TimeSet.Times == null ||
querySpecifier.TimeSet.Times.Count == 0)
{
throw new Exception("Given the TimeSet of output item \"" + output.Id +
"\", it can not produce one set of values for \"" + querySpecifier.Id + "\"");
}
// Output time set must be defined
if (output.TimeSet == null || output.TimeSet.Times == null)
{
throw new Exception("Invalid time specifier in output item \"" + output.Id +
"\" for in updating according to a time specification" + querySpecifier.Id);
}
// Compute until this time is available
double queryTimeMjd = querySpecifier.TimeSet.Times[0].End().StampAsModifiedJulianDay;
// The current available time from the output item
double availableTimeMjd = Double.NegativeInfinity;
if (output.TimeSet.Times.Count > 0)
{
availableTimeMjd = output.TimeSet.Times[output.TimeSet.Times.Count - 1].End().StampAsModifiedJulianDay;
}
// Update component until querytime is available
// If component is "busy" (LinkableComponentStatus.Updating), the
// component will not be updated.
IBaseLinkableComponent component = output.Component;
while ((component.Status == LinkableComponentStatus.Valid ||
component.Status == LinkableComponentStatus.Updated) &&
availableTimeMjd + Time.EpsilonForTimeCompare < queryTimeMjd)
{
component.Update();
availableTimeMjd = output.TimeSet.Times[output.TimeSet.Times.Count - 1].End().StampAsModifiedJulianDay;
}
// Return true if component was updated up until queryTimeMjd
return(availableTimeMjd + Time.EpsilonForTimeCompare >= queryTimeMjd);
}
public void GetValues(ITimeSpaceValueSet <double> targetSet, IBaseExchangeItem querySpecifier)
{
// Copy values from the adaptee to the targetSet
ITimeSpaceValueSet sourceValues = _adaptee.GetValues(querySpecifier);
for (int i = 0; i < targetSet.TimesCount(); i++)
{
double[] sourceTimeValues = sourceValues.GetElementValuesForTime <double>(i);
for (int j = 0; j < targetSet.ElementCount(); j++)
{
targetSet.Values2D[i][j] += sourceTimeValues[j];
}
}
}
bool TreeNodeContains(IBaseExchangeItem item, TreeNode node, out TreeNode outnode)
{
outnode = null;
foreach (TreeNode n in node.Nodes)
{
if (n.Tag != null && n.Tag is IBaseExchangeItem && ((item == (IBaseExchangeItem)n.Tag) || item.Id == ((IBaseExchangeItem)node.Tag).Id))
{
outnode = n;
return(true);
}
}
return(false);
}
public BaseExchangeItem(IBaseExchangeItem item)
: base(item)
{
// _componentId = _component != null ? _component.Id : string.Empty;
BaseExchangeItem e = item as BaseExchangeItem;
if (e != null)
{
// Need to clone e._valueSetConverter?
_valueSetConverter = e._valueSetConverter;
if (_valueSetConverter != null)
_valueSetConverter.ExchangeItem = this;
}
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("Query is not an ITimeSpaceExchangeItem - you may need to add an adaptor");
}
if (timeSpaceQuery.TimeSet != null && timeSpaceQuery.TimeSet.Times.Count == 1)
{
double[] valuesForTimeStep = _timeSeriesComponent.Buffer.GetValues(timeSpaceQuery.TimeSet.Times[0]);
return(new ValueSet(new List <IList> {
valuesForTimeStep
}));
}
throw new Exception("Invalid time specification in querying exchange item \"" + querySpecifier.Id + "\"");
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier2)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier2 as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("querySpecifier must be an ITimeSpaceExchangeItem - add an adaptor");
}
if (!(timeSpaceQuery is ITimeSpaceInput))
{
throw new OpenMIException("Get Values can only be called with an Input as argument")
{
Component = Adaptee.Component, Output = this
};
}
/// Using a _query item in the
/// _adaptee.GetValues(_query)
/// instead of
/// _adaptee.GetValues(this)
///
/// Reason:
/// If using the latter, it would be required to set the internal
/// TimeSet = timeSpaceQuery.TimeSet;
/// but then internal Values (retrieved from adaptee) does not match TimeSet.
/// And also:
/// - the TimeSet is set to override and return _adaptee.TimeSet
/// - the spatial definition would not match the adaptee
// If uncommenting this, comment out also the overidden TimeSet property above
//TimeSet = timeSpaceQuery.TimeSet;
// Set query time to internal query item
_query.TimeSet = timeSpaceQuery.TimeSet;
ITimeSpaceValueSet incomingValues = _adaptee.GetValues(_query);
ITimeSpaceValueSet <double> resultValues = ElementMapper.CreateResultValueSet(incomingValues.TimesCount(), SpatialDefinition.ElementCount);
// Transform the values from the adaptee
_elementMapper.MapValues(ref resultValues, ref incomingValues);
return(resultValues);
}
// Called from source
public ITimeSpaceValueSet GetValues(IBaseExchangeItem exchange)
{
if (!(exchange is ITimeSpaceInput))
{
throw new InvalidOperationException();
}
ITimeSpaceInput source = (ITimeSpaceInput)exchange;
ValidTimeSet(source.TimeSet);
// TODO Check Component.Status befor update ? gridlock issues?
// this.GetValues(source) should
bool unavailable = false;
bool forceCacheUpdate = false;
while (!CacheUpdateSource(source, forceCacheUpdate))
{
// TODO Multithreading sleep and retry
unavailable
= Component.Status != LinkableComponentStatus.Initialized &&
Component.Status != LinkableComponentStatus.Updated &&
Component.Status != LinkableComponentStatus.Valid;
if (unavailable)
{
forceCacheUpdate = true;
}
else
{
Component.Update(new ITimeSpaceOutput[] { this });
}
}
if (ItemChanged != null)
{
ItemChanged(this, new ExchangeItemChangeEventArgs {
ExchangeItem = this, Message = CurrentState()
});
}
return(((ITimeSpaceInput)source).Values);
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem item = (ITimeSpaceExchangeItem)querySpecifier;
TimeSet.SetSingleTime(item.TimeSet.Times[0]);
int count = item.ElementSet().ElementCount;
double[] vals = new double[count];
for (int i = 0; i < count; i++)
{
vals[i] = ConstOutput;
}
ValueSetArray<double> valueset = new ValueSetArray<double>(vals);
return valueset;
}
public virtual ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("Must be an ITimeSpaceExchangeItem - an adaptor may be required");
}
if (!ExchangeItemHelper.OutputAndInputElementSetsFit(this, timeSpaceQuery))
{
throw new Exception("ElementSet of output item \"" + Id +
"\" does not fit the ElementSet of requesting item \"" + querySpecifier.Id);
}
if (!ExchangeItemHelper.OutputAndInputTimeSetsFit(this, timeSpaceQuery))
{
throw new Exception("TimeSet of output item \"" + Id +
"\" does not fit the TimeSet of requesting item \"" + querySpecifier.Id);
}
return(Values);
}
ITimeSpaceValueSet ITimeSpaceOutput.GetValues(IBaseExchangeItem querySpecifier)
{
throw new NotImplementedException();
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
return(Convert((ITimeSpaceValueSet)Adaptee.GetValues(querySpecifier)));
}
/// <summary>
/// Constructor that also initializes the <see cref="ExchangeItem"/>
/// and the <see cref="Message"/> property
/// </summary>
public ExchangeItemChangeEventArgs(IBaseExchangeItem exchangeItem, string message)
{
ExchangeItem = exchangeItem;
Message = message;
}
public abstract override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier);
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
return(CreateValues());
}
/// <summary>
/// Overridden to call convertor.GetValues(...) directly without any calls to Engine.Update()
/// </summary>
/// <param name="querySpecifier"></param>
/// <returns></returns>
protected override ITimeSpaceValueSet GetValuesTimeImplementation(IBaseExchangeItem querySpecifier)
{
var convertor = ValueSetConverter as IValueSetConverterTime;
if (convertor == null)
throw new Exception("ValueSetConverter not a IValueSetConverterTime");
// Non OpenMI special case, handy for checking current values without changing engine state
if (querySpecifier == null)
convertor.GetValueSetLatest();
if (querySpecifier is IBaseInput && !Consumers.Any(c => c.Id == querySpecifier.Id))
throw new Exception("GetValues request from an unregistered Input Item: " + querySpecifier.Id);
else if (querySpecifier is IBaseOutput && !AdaptedOutputs.Any(c => c.Id == querySpecifier.Id))
throw new Exception("GetValues request from an unregistered Adapted Output Item: " + querySpecifier.Id);
if (querySpecifier is IBaseOutput)
throw new NotImplementedException();
if (!(querySpecifier is ITimeSpaceExchangeItem))
return convertor.GetValueSetLatest() as ITimeSpaceValueSet;
ITimeSet requestTimeSet = ((ITimeSpaceExchangeItem)querySpecifier).TimeSet;
return convertor.GetValueSetAt(requestTimeSet) as ITimeSpaceValueSet;
}
/// <summary>
/// Constructor that also initializes the <see cref="ExchangeItem"/>
/// and the <see cref="Message"/> property
/// </summary>
public ExchangeItemChangeEventArgs(IBaseExchangeItem exchangeItem, string message)
{
ExchangeItem = exchangeItem;
Message = message;
}
public virtual ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
return(_adaptee.GetValues(querySpecifier));
}
private static double _lastOutputTime; // HACK, REMOVE
public ExchangeItem(IBaseExchangeItem openMIItem) : this(openMIItem, false)
{
}
IBaseValueSet IBaseOutput.GetValues(IBaseExchangeItem querySpecifier)
{
return GetValues(querySpecifier);
}
protected override IBaseValueSet GetValuesImplementation(IBaseExchangeItem querySpecifier)
{
// Here as non spatial and not temporal
// Special case, handy for checking current values without changing engine state
if (querySpecifier == null)
ValueSetConverter.GetValueSetLatest();
if (querySpecifier is IBaseInput && !Consumers.Any(c => c.Id == querySpecifier.Id))
throw new Exception("GetValues request from an unregistered Input Item: " + querySpecifier.Id);
else if (querySpecifier is IBaseOutput && !AdaptedOutputs.Any(c => c.Id == querySpecifier.Id))
throw new Exception("GetValues request from an unregistered Adapted Output Item: " + querySpecifier.Id);
if (querySpecifier is IBaseOutput)
throw new NotImplementedException();
// Not a time based request just update and return latest
Component.Update(this);
return ValueSetConverter.GetValueSetLatest();
}
public static IValueSetConverter Convertor(IBaseExchangeItem item)
{
var has = item as IHasValueSetConvertor;
if (has == null || has.ValueSetConverter == null)
throw new Exception(item.Caption + " does not have a IValueSetConverter");
return ((IHasValueSetConvertor)item).ValueSetConverter;
}
public abstract override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier);
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem basequerySpecifier)
{
ITimeSpaceExchangeItem querySpecifier = basequerySpecifier as ITimeSpaceExchangeItem;
if (querySpecifier == null)
{
throw new ArgumentException("querySpecifier must be an ITimeSpaceExchangeItem - add an adaptor");
}
//------------------------------------------------------
// Check if we need to update the output component
// Time set of query must be defined and have at least 1 time
if (querySpecifier.TimeSet == null ||
querySpecifier.TimeSet.Times == null ||
querySpecifier.TimeSet.Times.Count == 0)
{
throw new Exception("Invalid query specifier \"" + querySpecifier.Id +
"\" for in GetValues() call to time decorater " + Id);
}
// Determine query time
double queryTimeMjd = querySpecifier.TimeSet.Times[querySpecifier.TimeSet.Times.Count - 1].End().StampAsModifiedJulianDay;
// Determine the times available in the buffer
double availableTimeMjd = Double.NegativeInfinity;
IList <ITime> currentTimes = TimeSet.Times;
if (currentTimes.Count > 0)
{
availableTimeMjd = currentTimes[currentTimes.Count - 1].End().StampAsModifiedJulianDay;
}
// Check if we need to update
// In case the output component is "busy", this may not actually update values
// up to queryTimeMjd, in which case the _buffer.GetValues below will extrapolate.
if (availableTimeMjd < queryTimeMjd)
{
if (ComponentUpdater == null)
{
throw new Exception("Failed when trying to update time buffer (no updater is specified)");
}
ComponentUpdater.Update(querySpecifier);
}
//------------------------------------------------------
// Retrieve values from the buffer
// Return the values for the required time(s)
IList <IList <double> > resultValues = new List <IList <double> >();
if (querySpecifier.TimeSet != null && querySpecifier.TimeSet.Times != null)
{
for (int t = 0; t < querySpecifier.TimeSet.Times.Count; t++)
{
ITime queryTime = querySpecifier.TimeSet.Times[t];
double[] valuesForTimeStep = _buffer.GetValues(queryTime);
resultValues.Add(valuesForTimeStep);
}
}
ITime earliestConsumerTime = ExchangeItemHelper.GetEarliestConsumerTime(this);
if (earliestConsumerTime != null)
{
_buffer.ClearBefore(earliestConsumerTime);
}
return(new TimeSpaceValueSet <double>(resultValues));
}
public override bool CanConnect(IBaseExchangeItem proposed, out string whyNot)
{
whyNot = "Can connect to anything, but cannot be used at runtime.";
return true;
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
throw new ArgumentException("querySpecifier must be an ITimeSpaceExchangeItem - add an adaptor");
if (timeSpaceQuery.TimeSet == null || timeSpaceQuery.TimeSet.Times == null ||
timeSpaceQuery.TimeSet.Times.Count == 0)
{
throw new Exception("Invalid query specifier \"" + timeSpaceQuery.Id +
"\" for in GetValues() call to time decorater " + Id);
}
// Determinee query time and currently available time
double queryTimeAsMJD =
timeSpaceQuery.TimeSet.Times[timeSpaceQuery.TimeSet.Times.Count - 1].StampAsModifiedJulianDay +
timeSpaceQuery.TimeSet.Times[timeSpaceQuery.TimeSet.Times.Count - 1].DurationInDays;
double availableTimeAsMJD = Double.NegativeInfinity;
IList<ITime> currentTimes = TimeSet.Times;
if (currentTimes.Count > 0)
{
availableTimeAsMJD =
currentTimes[currentTimes.Count - 1].StampAsModifiedJulianDay +
currentTimes[currentTimes.Count - 1].DurationInDays;
}
// Check if we need to update
if (availableTimeAsMJD < queryTimeAsMJD)
{
// TODO (JGr): output item should not do the actual update of the component?
if (Adaptee == null)
{
throw new Exception("Can not update, no parent output defined, calling GetValues() of time bufferer " + Id);
}
if (_adaptee.TimeSet == null || _adaptee.TimeSet.Times == null)
{
throw new Exception("Invalid time specifier in decorated output item \"" + Adaptee.Id +
"\" for in GetValues() call to time decorater " + Id);
}
// Update as far as needed.
IBaseLinkableComponent linkableComponent = Adaptee.Component;
while ((linkableComponent.Status == LinkableComponentStatus.Valid ||
linkableComponent.Status == LinkableComponentStatus.Updated) &&
availableTimeAsMJD < queryTimeAsMJD)
{
linkableComponent.Update();
// Determine newly available time
IList<ITime> parentTimes = _adaptee.TimeSet.Times;
availableTimeAsMJD =
parentTimes[parentTimes.Count - 1].StampAsModifiedJulianDay +
parentTimes[parentTimes.Count - 1].DurationInDays;
}
}
// Return the values for the required time(s)
IList<IList<double>> resultValues = new List<IList<double>>();
if (timeSpaceQuery.TimeSet != null && timeSpaceQuery.TimeSet.Times != null)
{
for (int t = 0; t < timeSpaceQuery.TimeSet.Times.Count; t++)
{
resultValues.Add(new List<double>());
ITime queryTime = timeSpaceQuery.TimeSet.Times[t];
List<double> valuesForTimeStep = _buffer.GetValues(queryTime);
foreach (double d in valuesForTimeStep)
{
resultValues[t].Add(d);
}
}
}
return new TimeSpaceValueSet<double>(resultValues);
}
public new IBaseValueSet GetValues(IBaseExchangeItem querySpecifier)
{
return(((ITimeSpaceAdaptedOutput)_item).GetValues(querySpecifier));
}
public virtual ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
{
throw new ArgumentException("Must be an ITimeSpaceExchangeItem - an adaptor may be required");
}
if (!ExchangeItemHelper.OutputAndInputElementSetsFit(this, timeSpaceQuery))
{
throw new Exception("ElementSet of output item \"" + Id +
"\" does not fit the ElementSet of requesting item \"" + querySpecifier.Id);
}
if (!ExchangeItemHelper.OutputAndInputTimeSetsFit(this, timeSpaceQuery))
{
throw new Exception("TimeSet of output item \"" + Id +
"\" does not fit the TimeSet of requesting item \"" + querySpecifier.Id);
}
return Values;
}
public ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
ITimeSpaceExchangeItem timeSpaceQuery = querySpecifier as ITimeSpaceExchangeItem;
if (timeSpaceQuery == null)
throw new ArgumentException("Must be an ITimeSpaceExchangeItem, add an adaptor", "querySpecifier");
if (_children.Count == 0)
return (null); // TODO: Or throw an exception?
TimeSpaceValueSet<double> resultSet = ElementMapper.CreateResultValueSet(timeSpaceQuery.TimeSet.Times.Count, this.ElementSet().ElementCount);
// Get values from all adaptees/children, and add them together
for (int i = 0; i < _children.Count; i++)
{
_children[i].GetValues(resultSet, querySpecifier);
}
return (resultSet);
}
public override ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
return(_tsadaptee.GetValues(querySpecifier).MultiplyElementValues(_factors));
}
public ITimeSpaceValueSet GetValues(IBaseExchangeItem querySpecifier)
{
return (_adaptee.GetValues(querySpecifier));
}
IBaseValueSet IBaseOutput.GetValues(IBaseExchangeItem querySpecifier)
{
return(GetValues(querySpecifier));
}
public void GetValues(ITimeSpaceValueSet<double> targetSet, IBaseExchangeItem querySpecifier)
{
// Copy values from the adaptee to the targetSet
ITimeSpaceValueSet sourceValues = _adaptee.GetValues(querySpecifier);
for (int i = 0; i < targetSet.TimesCount(); i++)
{
double[] sourceTimeValues = sourceValues.GetElementValuesForTime<double>(i);
for (int j = 0; j < targetSet.ElementCount(); j++)
{
targetSet.Values2D[i][j] += sourceTimeValues[j];
}
}
}
protected override IBaseValueSet GetValuesImplementation(IBaseExchangeItem querySpecifier)
{
return GetValuesTimeImplementation(querySpecifier);
}
public IBaseValueSet GetValues(IBaseExchangeItem querySpecifier)
{
throw new NotImplementedException();
}
public static IValueSetConverterTimeEngine EngineConvertor(IBaseExchangeItem item)
{
var convertor = Convertor(item) as IValueSetConverterTimeEngine;
if (convertor == null)
throw new Exception(item.Caption + " does not have a IValueSetConverterEngine");
return convertor;
}
protected override ITimeSpaceValueSet GetValuesTimeImplementation(IBaseExchangeItem querySpecifier)
{
if (!(querySpecifier is ITimeSpaceExchangeItem))
return _valueSetConverterTime.GetValueSetLatest() as ITimeSpaceValueSet;
TimeSet = ((ITimeSpaceExchangeItem)querySpecifier).TimeSet;
TimeSet queryTime = new TimeSet(((ITimeSpaceExchangeItem)querySpecifier).TimeSet);
if (Component == null) // Orphaned Exchange item
return _valueSetConverterTime.GetValueSetAt(TimeSet) as ITimeSpaceValueSet;
int updateCount = 0;
while (!_valueSetConverterTime.CanGetValueSetWithoutExtrapolationAt(queryTime))
{
if (Component.Status == LinkableComponentStatus.Updating)
{
// Bidirectional link and component is busy
string warning = string.Format("WARNING: Component \"{0}\" busy extrapolated for required values", Component.Caption);
Trace.TraceWarning(warning);
SendItemChangedEvent(warning);
return _valueSetConverterTime.GetValueSetAt(queryTime) as ITimeSpaceValueSet;
}
else if (updateCount > _updatelimitBeforeExtrapolating)
{
string error = string.Format(
"ERROR: Component \"{0}\" reached update limit of {1}, aborted updates and extrapolated for required values",
Component.Caption, _updatelimitBeforeExtrapolating);
Trace.TraceError(error);
SendItemChangedEvent(error);
return _valueSetConverterTime.GetValueSetAt(queryTime) as ITimeSpaceValueSet;
}
else
{
Component.Update(this);
++updateCount;
}
}
return _valueSetConverterTime.GetValueSetAt(queryTime) as ITimeSpaceValueSet;
}
