/// <summary>
/// Imports time series data,
/// 1) set flags
/// 2) active alarms (TO DO)
/// 3) compute dependent data (same interval)
/// 4) compute daily data when encountering midnight values
/// </summary>
/// <param name="importSeries"></param>
/// <param name="computeDependencies"></param>
/// <param name="computeDailyDependencies"></param>
public void Import(SeriesList importSeries,
bool computeDependencies = false,
bool computeDailyDependencies = false,
string importTag = "data")
{
var calculationQueue = new List <CalculationSeries>();
var routingList = new SeriesList();
foreach (var s in importSeries)
{
m_db.Quality.SetFlags(s); // to do, log/email flaged data
m_db.Alarms.Check(s); // check for alarms; send email make phone calls
var folderNames = new string[] {}; // TO DO //hydromet/cbtt default.
m_db.ImportSeriesUsingTableName(s, folderNames, m_saveOption);
routingList.Add(s);
if (computeDependencies)
{
var z = ComputeDependenciesSameInterval(s);
routingList.AddRange(z);
}
if (computeDailyDependencies && NeedDailyCalc(s))
{ // daily calcs that depend on instant
GetDailyDependentCalculations(s, calculationQueue);
}
}
if (calculationQueue.Count > 0)
{
PerformDailyComputations(importSeries, calculationQueue, routingList);
}
RouteData(importTag, routingList);
}
/// <summary>
/// Imports list of series
/// </summary>
/// <param name="importSeries"></param>
/// <param name="computeDependencies"></param>
/// <param name="importTag"></param>
/// <returns>list of series including dependent calculations</returns>
private SeriesList Import(SeriesList importSeries, bool computeDependencies, string importTag)
{
Performance p = new Performance();
int calculationCount = 0;
var routingList = new SeriesList();
foreach (var s in importSeries)
{
m_db.Quality.SetFlags(s); // to do, log/email flaged data
m_db.ImportSeriesUsingTableName(s, m_saveOption);
CheckForAlarms(s);
routingList.Add(s);
if (computeDependencies)
{
var z = ComputeDependenciesSameInterval(s);
calculationCount += z.Count;
foreach (var cs in z)
{
CheckForAlarms(cs);
}
routingList.AddRange(z);
}
}
Export(importTag, routingList);
Stats(importSeries.Count(), p.ElapsedSeconds, calculationCount, "instant");
return(routingList);
}
/// <summary>
/// Imports time series data,
/// 1) set flags
/// 2) active alarms (TO DO)
/// 3) compute dependent data (same interval)
/// 4) compute daily data when encountering midnight values
/// </summary>
/// <param name="importSeries"></param>
/// <param name="computeDependencies"></param>
/// <param name="computeDailyDependencies"></param>
public void Import(SeriesList importSeries,
bool computeDependencies = false,
bool computeDailyDependencies = false,
string importTag = "data")
{
var calculationQueue = new List <CalculationSeries>();
var routingList = new SeriesList();
foreach (var s in importSeries)
{
m_db.Quality.SetFlags(s); // to do, log/email flaged data
ProcessAlarms(s);
var folderNames = SetupDefaultFolders(s);
m_db.ImportSeriesUsingTableName(s, folderNames, m_saveOption);
routingList.Add(s);
if (computeDependencies)
{
var z = ComputeDependenciesSameInterval(s);
routingList.AddRange(z);
}
if (computeDailyDependencies && NeedDailyCalc(s))
{ // daily calcs that depend on instant
GetDailyDependentCalculations(s, calculationQueue);
}
}
if (calculationQueue.Count > 0)
{
PerformDailyComputations(importSeries, calculationQueue, routingList);
}
RouteData(importTag, routingList);
}
private SeriesList GetDailyCalculationsIfMidnight(Series s)
{
var calcList = new SeriesList();
// check for midnight values, and initiate daily calculations.
if (s.TimeInterval == TimeInterval.Irregular)
{
for (int i = 0; i < s.Count; i++)
{
var pt = s[i];
if (pt.DateTime.IsMidnight())
{
var x = GetDailyDependents(s.Table.TableName);
foreach (var item in x)
{
if (!calcList.ContainsTableName(item))
{
calcList.AddRange(x);
}
}
}
}
}
return(calcList);
}
public SeriesList SummaryHydrograph(int[] exceedanceLevels, DateTime beginningDate, bool max, bool min, bool avg, bool removeEmptySeries)//, bool removeFeb29)
{
SeriesList rval = new SeriesList();
foreach (Series s in this)
{
SeriesList list = Math.SummaryHydrograph(s, exceedanceLevels, beginningDate, max, min, avg, removeEmptySeries);//,removeFeb29);
rval.AddRange(list);
}
return(rval);
}
/// <summary>
/// gets daily dependents for this series (tablename)
/// </summary>
/// <param name="tableName"></param>
/// <param name="t"></param>
/// <returns></returns>
private SeriesList GetDailyDependents(string tableName)
{
SeriesList rval = new SeriesList();
TimeSeriesName tn = new TimeSeriesName(tableName);
var calcList = GetDependentCalculations(tableName, TimeInterval.Daily);
//if (calcList.Count > 0)
// Logger.WriteLine("Found " + calcList.Count + " daily calculations to update ref:"+tableName);
foreach (var item in calcList)
{
// prevent recursive?
rval.Add(item);
// check for daily that depends on daily.
var x = GetDailyDependents(item.Table.TableName);
rval.AddRange(x);
}
return(rval);
}
public static Series SumSetMissingToZero(Series[] items)
{
var rval = new Series();
if (items.Length > 0)
{
rval = items[0].Copy();
}
SeriesList list = new SeriesList();
list.AddRange(items);
rval = Math.FillMissingWithZero(rval, list.MinDateTime, list.MaxDateTime);
for (int i = 1; i < items.Length; i++)
{
rval = rval + Math.FillMissingWithZero(items[i], list.MinDateTime, list.MaxDateTime);
}
return(rval);
}
/// <summary>
/// Return list of all calculations that may need to be performed
/// based on this inputSeries
/// </summary>
/// <param name="inputSeries"></param>
/// <returns></returns>
public SeriesList LookupCalculations(string tableName, TimeInterval interval)
{
var rval = new SeriesList();
if (inputDictionary == null)
{
inputDictionary = new Dictionary <string, List <CalculationSeries> >();
foreach (CalculationSeries cs in list)
{
var vars = cs.GetDependentVariables();
foreach (var varName in vars)
{
TimeSeriesName tn = new TimeSeriesName(varName, interval);
if (!tn.Valid)
{
Console.WriteLine("Error: Skipped Invalid equation .... " + cs.Expression);
}
else
{
AddToDictionary(tn.GetTableName(), cs);
}
}
}
}
Logger.WriteLine("LookupCalculations(" + tableName + ")");
Logger.WriteLine("inputDictionary.Count = " + inputDictionary.Count);
TimeSeriesName n = new TimeSeriesName(tableName, interval);
var key = n.GetTableName();
if (this.inputDictionary.ContainsKey(key))
{
rval.AddRange(inputDictionary[key].ToArray());
}
return(rval);
}
/// <summary>
/// Imports time series data,
/// 1) set flags
/// 2) active alarms (TO DO)
/// 3) compute dependent data (same interval)
/// 4) compute daily data when encountering midnight values
/// </summary>
/// <param name="inputSeriesList"></param>
/// <param name="computeDependencies"></param>
/// <param name="computeDailyEachMidnight"></param>
public void Import(SeriesList inputSeriesList,
bool computeDependencies = false,
bool computeDailyEachMidnight = false,
string importTag = "data")
{
var calculationQueue = new SeriesList();
var routingList = new SeriesList();
foreach (var s in inputSeriesList)
{
// set flags.
Logger.WriteLine("Checking Flags ");
m_db.Quality.SetFlags(s); // to do, log/email flagged data
// To Do.. check for alarms..
m_db.ImportSeriesUsingTableName(s, "");
routingList.Add(s);
if (computeDependencies)
{
var z = ComputeDependenciesSameInterval(s);
routingList.AddRange(z);
}
if (computeDailyEachMidnight)
{
var x = GetDailyCalculationsIfMidnight(s);
foreach (var item in x)
{
if (!calculationQueue.ContainsTableName(item))
{
calculationQueue.Add(item);
}
}
}
}
if (calculationQueue.Count > 0)
{
// do Actual Computations now. (in proper order...)
var list = new List <CalculationSeries>();
foreach (Series item in calculationQueue)
{
list.Add(item as CalculationSeries);
}
TimeSeriesDependency td = new TimeSeriesDependency(list);
var sortedCalculations = td.Sort();
foreach (CalculationSeries cs in sortedCalculations)
{
Console.Write(">>> " + cs.Table.TableName + ": " + cs.Expression);
//var cs = item as CalculationSeries;
var t1 = inputSeriesList.MinDateTime.Date;
var t2 = inputSeriesList.MaxDateTime;
if (t1.Date == t2.AddDays(-1).Date) // spans midnight, compute yesterday.
{
t1 = t1.Date;
t2 = t1.Date;
}
cs.Calculate(t1, t2);
if (cs.Count > 0)
{
routingList.Add(cs);
if (cs.CountMissing() > 0)
{
Console.WriteLine(" Missing " + cs.CountMissing() + " records");
}
else
{
Console.WriteLine(" OK");
}
}
}
}
SeriesList instantRoute = new SeriesList();
SeriesList dailyRoute = new SeriesList();
// route data to other locations.
foreach (var item in routingList)
{
TimeSeriesName tn = new TimeSeriesName(item.Table.TableName);
item.Parameter = tn.pcode;
item.SiteID = tn.siteid;
if (item.TimeInterval == TimeInterval.Irregular)
{
instantRoute.Add(item);
}
if (item.TimeInterval == TimeInterval.Daily)
{
dailyRoute.Add(item);
}
}
Console.WriteLine("Routing data");
TimeSeriesRouting.RouteInstant(instantRoute, importTag, m_routing);
TimeSeriesRouting.RouteDaily(dailyRoute, importTag, m_routing);
}
