/// <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 ExchangeItem(ITimeSpaceExchangeItem item) : base(item) { _id = item.Id; if (item.ValueDefinition != null) { if (item.ValueDefinition is IQuality) { _valueDefinition = new Quality((IQuality)item.ValueDefinition); } else { _valueDefinition = new Quantity((IQuantity)item.ValueDefinition); } } if (item.ElementSet() != null) { _elementSet = new ElementSet(item.ElementSet()); } if (item.TimeSet != null) { _timeSet = new TimeSet(item.TimeSet); } if (item.Component != null) { _component = new Component(item.Component); } }
public void AddOut(IBaseExchangeItem openMIo) { if (openMIo is ITimeSpaceOutput) { _openMIItem = _openMIOutputItem = (ITimeSpaceOutput)openMIo; } }
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 AddIn(IBaseExchangeItem openMIo) { if (openMIo is ITimeSpaceInput) { _openMIItem = _openMIInputItem = (ITimeSpaceInput)openMIo; } }
public static void CheckValueSizes(ITimeSpaceExchangeItem exchangeItem, ITimeSpaceValueSet valueSet) { int timesCount = 1; if (exchangeItem.TimeSet != null) { if (exchangeItem.TimeSet.Times != null) { timesCount = exchangeItem.TimeSet.Times.Count; } else { timesCount = 0; } } if (ValueSet.GetTimesCount(valueSet) != timesCount) { throw new Exception("ExchangeItem \"" + exchangeItem.Caption + "\": Wrong #times in valueSet (" + ValueSet.GetTimesCount(valueSet) + "), expected #times (" + timesCount + ")"); } int elementCount = 1; if (exchangeItem.ElementSet() != null) { elementCount = exchangeItem.ElementSet().ElementCount; } if (ValueSet.GetElementCount(valueSet) != elementCount) { throw new Exception("ExchangeItem \"" + exchangeItem.Caption + "\": Wrong #times in valueSet (" + ValueSet.GetElementCount(valueSet) + "), expected #times (" + elementCount + ")"); } }
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>(); } }
/// <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 static bool OutputAndInputValuesFit(ITimeSpaceExchangeItem sourceItem, ITimeSpaceExchangeItem targetItem) { bool timeFits = OutputAndInputTimeSetsFit(sourceItem, targetItem); bool elementSetFits = true; if (timeFits) { elementSetFits = OutputAndInputElementSetsFit(sourceItem, targetItem); } return timeFits && elementSetFits; }
public static bool OutputAndInputValuesFit(ITimeSpaceExchangeItem sourceItem, ITimeSpaceExchangeItem targetItem) { bool timeFits = OutputAndInputTimeSetsFit(sourceItem, targetItem); bool elementSetFits = true; if (timeFits) { elementSetFits = OutputAndInputElementSetsFit(sourceItem, targetItem); } return(timeFits && elementSetFits); }
/// <summary> /// Check if the element set and the time set of a provider fit accoring to what the consumer /// requires. This method can be used to check of the providing component yet needs to do another Update() step. /// </summary> /// <param name="provider">The provider</param> /// <param name="consumer">The consumer</param> /// <returns>True if both element set and the time set fit</returns> public static bool OutputAndInputFit(ITimeSpaceExchangeItem provider, ITimeSpaceExchangeItem consumer) { bool timeFits = OutputAndInputTimeSetsFit(provider, consumer); bool elementSetFits = true; if (timeFits) { elementSetFits = OutputAndInputElementSetsFit(provider, consumer); } return(timeFits && elementSetFits); }
public ValueSet(ITimeSpaceExchangeItem item, IEnumerable <T> value) { if (item.TimeSet != null && item.TimeSet.Times.Count > 1) { throw new Exception("Can not handle more than one time step"); } List <T> elementValues = new List <T>(); elementValues.AddRange(value); _values = new List <List <T> >(); _values.Add(elementValues); }
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 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); }
/// <summary> /// Get the <see cref="IElementSet"/> from the <paramref name="item"/>, /// assuming the <see cref="ITimeSpaceExchangeItem.SpatialDefinition"/> is /// an <see cref="IElementSet"/>. If not, an exception is thrown. /// </summary> public static IElementSet ElementSet(this ITimeSpaceExchangeItem item) { if (item.SpatialDefinition == null) { return(null); } IElementSet elmtSet = item.SpatialDefinition as IElementSet; if (elmtSet != null) { return(elmtSet); } throw new NotSupportedException("The SpatialDefinition needs currently to be an IElementSet"); }
public static bool OutputAndInputElementSetsFit(ITimeSpaceExchangeItem sourceItem, ITimeSpaceExchangeItem targetItem) { if (sourceItem == null) { throw new ArgumentNullException("sourceItem"); } if (targetItem == null) { throw new ArgumentNullException("targetItem"); } bool elementSetFits = true; IElementSet sourceElementSet = sourceItem.ElementSet(); IElementSet targetElementSet = targetItem.ElementSet(); if (sourceElementSet == null) { if (targetElementSet != null) { // NOTE: Source has no elementset specification, source has. // Source fits target if target requires only one element. elementSetFits = targetElementSet.ElementCount == 1; } } else { if (targetElementSet == null) { // NOTE: Target has no elementset specification, source has. // Source fits target if source has values for only one element available. elementSetFits = sourceElementSet.ElementCount == 1; } else { // Both source and target have an element set specification // If the source is a regular exchange item, the #elements will fit // (has been checked configuration time) // If it is a spatial extension, we need to check if valeus on the newly required // element set can be delivered if (sourceItem is ITimeSpaceAdaptedOutput) { // TODO: Check how we can find out that it is a spatial adaptedOutput. // TODO: If it is, how do we check whether the values on the target element set can be delivered } } } return(elementSetFits); }
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); }
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; }
/// <summary> /// Checks the <paramref name="querySpecifier"/> if it matches the current values. If not, /// try and update the component and the item. /// /// If failing, this will throw an exception /// </summary> protected void CheckSpecificationAndTryUpdateIfRequired(ITimeSpaceExchangeItem querySpecifier) { if (!ExchangeItemHelper.OutputAndInputElementSetsFit(this, querySpecifier)) { throw new Exception("ElementSet of output item \"" + Id + "\" does not fit the ElementSet of requesting item \"" + querySpecifier.Id); } if (!ExchangeItemHelper.OutputAndInputTimeSetsFit(this, querySpecifier)) { TimeComponentUpdater.Update(this, querySpecifier); // TODO JGR: Remove commented code when tested properly //if (querySpecifier.TimeSet == null || // querySpecifier.TimeSet.Times == null || // querySpecifier.TimeSet.Times.Count != 1) //{ // // Time independent target item, but for some reason this output item's time set does // // not fit (most probably because is has either 0 or more then 1 timesteps). // throw new Exception("Given the TimeSet of output item \"" + Id + // "\", it can not produce one set of values for \"" + querySpecifier.Id + "\""); //} //// Compute until the value are available indeed //// Check the max #of steps, to avoid an eternal loop //double targetTimeAsMJD = querySpecifier.TimeSet.Times[0].End().StampAsModifiedJulianDay; //while ((_linkableEngine.Status == LinkableComponentStatus.Valid || // _linkableEngine.Status == LinkableComponentStatus.Updated) && // _linkableEngine.CurrentTime.StampAsModifiedJulianDay + Time.EpsilonForTimeCompare < targetTimeAsMJD) //{ // _linkableEngine.Update(); //} } if (!ExchangeItemHelper.OutputAndInputTimeSetsFit(this, querySpecifier)) { throw new Exception("Could not update engine \"" + _linkableEngine.Id + "\" to required time for output item \"" + Id + "\" (requiring input item \"" + querySpecifier.Id + "\"). Use a Time Extrapolator."); } }
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 static void CheckValueSizes(ITimeSpaceExchangeItem exchangeItem, ITimeSpaceValueSet valueSet) { int timesCount = 1; if (exchangeItem.TimeSet != null) { if (exchangeItem.TimeSet.Times != null) { timesCount = exchangeItem.TimeSet.Times.Count; } else { timesCount = 0; } } if (ValueSet.GetTimesCount(valueSet) != timesCount) { throw new Exception("ExchangeItem \"" + exchangeItem.Caption + "\": Wrong #times in valueSet (" + ValueSet.GetTimesCount(valueSet) + "), expected #times (" + timesCount + ")"); } int elementCount = 1; if (exchangeItem.ElementSet() != null) { elementCount = exchangeItem.ElementSet().ElementCount; } if (ValueSet.GetElementCount(valueSet) != elementCount) { throw new Exception("ExchangeItem \"" + exchangeItem.Caption + "\": Wrong #times in valueSet (" + ValueSet.GetElementCount(valueSet) + "), expected #times (" + elementCount + ")"); } }
public static bool OutputAndInputTimeSetsFit(ITimeSpaceExchangeItem sourceItem, ITimeSpaceExchangeItem targetItem) { if (sourceItem == null) { throw new ArgumentNullException("sourceItem"); } if (targetItem == null) { throw new ArgumentNullException("targetItem"); } bool timeFits = true; ITimeSet sourceTimeSet = sourceItem.TimeSet; ITimeSet targetTimeSet = targetItem.TimeSet; if (sourceTimeSet == null) { if (targetTimeSet != null) { // NOTE: Source has no timeset specification, source has. // Source fits target if target requires only one time step. timeFits = targetTimeSet.Times.Count == 1; } } else { if (targetTimeSet == null) { // NOTE: Target has no timeset specification, source has. // Source fits target if source has values for only one time step available. timeFits = sourceTimeSet.Times.Count == 1; } else { /* * SH/AM: TODO I Think this code is wrong, IOutput and IAdaptedOutput should be treated the same * (SH: reactivated (if (sourceItem is IAdaptedOutput) code * to make things work for time extrapolators again. */ // Both source and target have time set specification if (sourceItem is ITimeSpaceAdaptedOutput) { // NOTE: Source is an adaptedOutput that has a time set. // Most probably a timeinterpolator, but: // TODO: Check how we can find out that it is a time interpolator. // For now: check if the target's last required time is included in the source's time horizon if (sourceTimeSet.TimeHorizon == null) { throw new Exception("Error when checking if the times of AdaptedOutput \"" + sourceItem.Id + " fits the times required by inputItem \"" + targetItem.Id + "\": no time horizon available in the adaptedOutput"); } ITime lastRequiredTime = targetTimeSet.Times[targetTimeSet.Times.Count - 1]; double lastRequiredTimeAsMJD = lastRequiredTime.StampAsModifiedJulianDay + lastRequiredTime.DurationInDays; double endOfSourceTimeHorizon = sourceTimeSet.TimeHorizon.StampAsModifiedJulianDay + sourceTimeSet.TimeHorizon.DurationInDays; timeFits = lastRequiredTimeAsMJD <= (endOfSourceTimeHorizon + Time.EpsilonForTimeCompare); } else { timeFits = false; // regular (output) exchange item, check if all times fit IList<ITime> sourceTimes = sourceTimeSet.Times; IList<ITime> requiredTimes = targetTimeSet.Times; if (sourceTimes.Count == requiredTimes.Count) { timeFits = true; for (int timeIndex = 0; timeIndex < requiredTimes.Count; timeIndex++) { if ( (requiredTimes[timeIndex].DurationInDays > 0 && !(sourceTimes[timeIndex].DurationInDays>0)) || (sourceTimes[timeIndex].DurationInDays > 0 && !(requiredTimes[timeIndex].DurationInDays>0)) ) { throw new Exception("Incompatible times (stamp versus span) between outputItem \"" + sourceItem.Id + " and inputItem \"" + targetItem.Id + "\""); } if (requiredTimes[timeIndex].Equals(sourceTimes[timeIndex])) continue; timeFits = false; break; } } } } } return timeFits; }
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 static bool OutputAndInputTimeSetsFit(ITimeSpaceExchangeItem sourceItem, ITimeSpaceExchangeItem targetItem) { if (sourceItem == null) { throw new ArgumentNullException("sourceItem"); } if (targetItem == null) { throw new ArgumentNullException("targetItem"); } bool timeFits = true; ITimeSet sourceTimeSet = sourceItem.TimeSet; ITimeSet targetTimeSet = targetItem.TimeSet; if (sourceTimeSet == null) { if (targetTimeSet != null) { // NOTE: Source has no timeset specification, source has. // Source fits target if target requires only one time step. timeFits = targetTimeSet.Times.Count == 1; } } else { if (targetTimeSet == null) { // NOTE: Target has no timeset specification, source has. // Source fits target if source has values for only one time step available. timeFits = sourceTimeSet.Times.Count == 1; } else { /* * SH/AM: TODO I Think this code is wrong, IOutput and IAdaptedOutput should be treated the same * (SH: reactivated (if (sourceItem is IAdaptedOutput) code * to make things work for time extrapolators again. */ // Both source and target have time set specification if (sourceItem is ITimeSpaceAdaptedOutput) { // NOTE: Source is an adaptedOutput that has a time set. // Most probably a timeinterpolator, but: // TODO: Check how we can find out that it is a time interpolator. // For now: check if the target's last required time is included in the source's time horizon if (sourceTimeSet.TimeHorizon == null) { throw new Exception("Error when checking if the times of AdaptedOutput \"" + sourceItem.Id + " fits the times required by inputItem \"" + targetItem.Id + "\": no time horizon available in the adaptedOutput"); } ITime lastRequiredTime = targetTimeSet.Times[targetTimeSet.Times.Count - 1]; double lastRequiredTimeAsMJD = lastRequiredTime.StampAsModifiedJulianDay + lastRequiredTime.DurationInDays; double endOfSourceTimeHorizon = sourceTimeSet.TimeHorizon.StampAsModifiedJulianDay + sourceTimeSet.TimeHorizon.DurationInDays; timeFits = lastRequiredTimeAsMJD <= (endOfSourceTimeHorizon + Time.EpsilonForTimeCompare); } else { timeFits = false; // regular (output) exchange item, check if all times fit IList <ITime> sourceTimes = sourceTimeSet.Times; IList <ITime> requiredTimes = targetTimeSet.Times; if (sourceTimes.Count == requiredTimes.Count) { timeFits = true; for (int timeIndex = 0; timeIndex < requiredTimes.Count; timeIndex++) { if ((requiredTimes[timeIndex].DurationInDays > 0 && !(sourceTimes[timeIndex].DurationInDays > 0)) || (sourceTimes[timeIndex].DurationInDays > 0 && !(requiredTimes[timeIndex].DurationInDays > 0))) { throw new Exception("Incompatible times (stamp versus span) between outputItem \"" + sourceItem.Id + " and inputItem \"" + targetItem.Id + "\""); } if (requiredTimes[timeIndex].Equals(sourceTimes[timeIndex])) { continue; } timeFits = false; break; } } } } } return(timeFits); }
public UIExchangeItem(ITimeSpaceExchangeItem item) { _item = item; }
public static bool OutputAndInputElementSetsFit(ITimeSpaceExchangeItem sourceItem, ITimeSpaceExchangeItem targetItem) { if (sourceItem == null) { throw new ArgumentNullException("sourceItem"); } if (targetItem == null) { throw new ArgumentNullException("targetItem"); } bool elementSetFits = true; IElementSet sourceElementSet = sourceItem.ElementSet(); IElementSet targetElementSet = targetItem.ElementSet(); if (sourceElementSet == null) { if (targetElementSet != null) { // NOTE: Source has no elementset specification, source has. // Source fits target if target requires only one element. elementSetFits = targetElementSet.ElementCount == 1; } } else { if (targetElementSet == null) { // NOTE: Target has no elementset specification, source has. // Source fits target if source has values for only one element available. elementSetFits = sourceElementSet.ElementCount == 1; } else { // Both source and target have an element set specification // If the source is a regular exchange item, the #elements will fit // (has been checked configuration time) // If it is a spatial extension, we need to check if valeus on the newly required // element set can be delivered if (sourceItem is ITimeSpaceAdaptedOutput) { // TODO: Check how we can find out that it is a spatial adaptedOutput. // TODO: If it is, how do we check whether the values on the target element set can be delivered } } } return elementSetFits; }
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)); }