public static HydroTimeSeries GetMissingValuesHydro(ITimeSeries ts, DateTime start, DateTime end, TimeStep step)
{
HydroTimeSeries missingTs = new HydroTimeSeries(start, end);
List<int> breakIx = GetDataBreaks(ts);
//TODO missing points before series start
foreach (int begIndex in breakIx)
{
if (begIndex < ts.Count - 1)
{
DateTime begDate = DateTime.FromOADate(ts[begIndex].X);
DateTime endDate = DateTime.FromOADate(ts[begIndex + 1].X);
if (step == TimeStep.Day)
{
int nd = (int)endDate.Subtract(begDate).TotalDays;
for (int i = 0; i < nd; i++)
{
DateTime newTime = begDate.AddDays(i);
missingTs.AddUnknownValue(newTime);
}
}
else
{
int nh = (int)endDate.Subtract(begDate).TotalHours;
for (int i = 0; i < nh; i++)
{
DateTime newTime = begDate.AddHours(i);
missingTs.AddUnknownValue(newTime);
}
}
}
}
return missingTs;
}
/// <summary>
/// Makes a regular time-series with all of the data being equal to NO-DATA
/// </summary>
/// <param name="start">start time</param>
/// <param name="end">end time</param>
/// <param name="step">the time step: TimeStep.Day or TimeStep.Hour</param>
/// <returns>The time-series object with No-Data at all data points</returns>
public static ITimeSeries MakeRegularTimeSeries(DateTime start, DateTime end, TimeStep step)
{
HydroTimeSeries myTs = new HydroTimeSeries(start, end);
if (step == TimeStep.Day)
{
int nd = (int)end.Subtract(start).TotalDays;
for (int i = 0; i < nd; i++)
{
DateTime newTime = start.AddDays(i);
myTs.AddUnknownValue(newTime);
}
}
else
{
int nh = (int)end.Subtract(start).TotalHours;
for (int i = 0; i < nh; i++)
{
DateTime newTime = start.AddHours(i);
myTs.AddUnknownValue(newTime);
}
}
return myTs;
}
/// <summary>
/// Splits a regular time-series with data gaps into two or more sub-series
/// The maximum allowed gap size is determined by GetDefaultTimeStep()
/// Use this function for stage and discharge
/// </summary>
/// <param name="ts">The time series</param>
/// <returns>the list of splitted regular time-series</returns>
public static List<HydroTimeSeries> SplitTimeSeries(ITimeSeries ts)
{
List<HydroTimeSeries> hsList = new List<HydroTimeSeries>();
List<int> breakIx = GetDataBreaks(ts);
if (breakIx.Count > 0)
{
//for the final segment
if (breakIx[breakIx.Count - 1] != ts.Count - 1)
{
breakIx.Add(ts.Count - 1);
}
int begIndex = 0;
for (int i = 0; i < breakIx.Count; i++)
{
//all data before each break
int endIndex = breakIx[i];
DateTime begDate = DateTime.FromOADate(ts[begIndex].X);
DateTime endDate = DateTime.FromOADate(ts[endIndex].X);
HydroTimeSeries newTs = new HydroTimeSeries(begDate, endDate);
for (int j = begIndex; j <= endIndex; j++)
{
newTs.AddObservation(DateTime.FromOADate(ts[j].X), ts[j].Y);
}
begIndex = endIndex + 1;
if (newTs.Count > 0)
{
hsList.Add(newTs);
}
}
}
else
{
hsList.Add((HydroTimeSeries)ts);
}
return hsList;
}
/// <summary>
/// Returns a time series corresponding to the specific channel and interval
/// the 'missing data' (periodList) is also internally loaded for all variables
/// except stage and discharge.
/// </summary>
/// <param name="channel"></param>
/// <param name="interval"></param>
/// <returns></returns>
public static ITimeSeries GetTimeSeries(Channel ch, TimeInterval interval)
{
VariableEnum v = ch.Variable.VarEnum;
TimeStep step = GetDefaultTimeStep(v, interval);
ITimeSeries ts;
if (v == VariableEnum.Stage)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsStage2(ch.StationId, interval.Start,
interval.End, step, (IObservationList)ts);
}
else if (v == VariableEnum.Discharge)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsDischarge2(ch.StationId, interval.Start,
interval.End, step, (IObservationList)ts);
}
else if (v == VariableEnum.Temperature)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
//step = TimeStep.Hour;
TimeSeriesDS.LoadObservationsTemperature2(ch.StationId, interval.Start, interval.End, step, (IObservationList)ts);
}
else if (v == VariableEnum.Snow)
{
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsSnow2(ch.StationId, interval.Start, interval.End, (IObservationList)ts);
}
else if (v == VariableEnum.PrecipHour || v == VariableEnum.Precip || v == VariableEnum.PrecipSum)
{
ts = new MyTimeSeries(interval.Start, interval.End, step);
TimeSeriesDS.LoadObservationsPrecip2(ch.StationId, interval.Start,
interval.End, step, (IObservationList)ts);
}
else
{
//snow
ts = new HydroTimeSeries(interval.Start, interval.End);
TimeSeriesDS.LoadObservationsSnow2(ch.StationId, interval.Start, interval.End, (IObservationList)ts);
}
return ts;
}
public static ITimeSeries MakeCumulative(ITimeSeries ts)
{
HydroTimeSeries ts2 = new HydroTimeSeries(ts.Start, ts.End);
double sum = 0.0;
PointPair curPt;
for ( int i = 0; i < ts.Count; ++i )
{
curPt = ts[i];
if ( curPt.IsMissing )
{
ts2.AddUnknownValue(XDate.XLDateToDateTime(curPt.X));
}
else
{
if (curPt.Y > 0)
{
sum += curPt.Y;
}
ts2.AddObservation(XDate.XLDateToDateTime(curPt.X), sum);
}
}
return ts2;
}
public ITimeSeries ShowUnknown(double valueToDisplay)
{
HydroTimeSeries ts2 = new HydroTimeSeries(_data.Start, _data.End);
for (int i=0; i < Count; ++i)
{
PointPair p = this[i];
if (p.IsMissing)
{
ts2.AddObservation(XDate.XLDateToDateTime(p.X),valueToDisplay);
}
}
return ts2;
}
public ITimeSeries ShowUnknown(double valueToDisplay)
{
HydroTimeSeries ts2 = new HydroTimeSeries(_start, _end);
foreach (PointPair p in ts2._data)
{
if (p.IsMissing)
{
ts2._data.Add(p.X, valueToDisplay);
}
}
return ts2;
}
public object Clone()
{
HydroTimeSeries copy = new HydroTimeSeries();
copy._start = _start;
copy._end = _end;
copy._data = _data.Clone();
return copy;
}
