internal TimeIntegratorBasedAverager(IStorageContext storageContext, ITimeAxisAvgProcessing timeIntegrator, IStationLocator stationLocator, double[] lats, double[] lons, string stationsDimName)
{
this.timeIntegrator = timeIntegrator;
this.stationLocator = stationLocator;
this.dataStorage = storageContext;
this.stationsLats = lats;
this.stationsLons = lons;
IDataStorageDefinition storageDef = storageContext.StorageDefinition;
//determining dimension order
var varDimensions = storageContext.StorageDefinition.VariablesDimensions;
foreach (string dataVarName in varDimensions.Where(a => a.Value.Length == 2).Select(b => b.Key))
{
if (varDimensions[dataVarName][0] == stationsDimName)
{
stationsDimNumber.Add(dataVarName, 0);
timeDimNumber.Add(dataVarName, 1);
}
else
{
stationsDimNumber.Add(dataVarName, 1);
timeDimNumber.Add(dataVarName, 0);
}
}
dataRepresentationDictionary = new DataRepresentationDictionary(storageContext.StorageDefinition);
missingValuesDict = new MissingValuesDictionary(storageContext.StorageDefinition);
varTypes = new Dictionary <string, Type>(storageContext.StorageDefinition.VariablesTypes);
}
private TimeIntegratorBasedAveragerFactory(IStorageContext context, ITimeAxisAvgProcessing timeIntegrator, IStationLocator stationLocator, double[] stationsLats, double[] stationsLons, string stationDimName)
{
this.timeIntegrator = timeIntegrator;
this.stationLocator = stationLocator;
this.stationsLats = stationsLats;
this.stationsLons = stationsLons;
this.stationDimName = stationDimName;
this.storageContext = context;
}
public TimeAxisIntegratorThinningDecorator(ITimeAxisAvgProcessing component, int countConstraint = 100)
{
this.component = component;
this.countConstraint = countConstraint;
if (countConstraint < 2)
{
throw new ArgumentException("Minimum allowed countConstreint is 2");
}
}
public SequentialTimeSpatialUncertaintyEvaluatorFacade(
ITimeAxisAvgProcessing timeAxisIntegrator,
IGridAxisAvgProcessing latAxisIntegrator,
IGridAxisAvgProcessing lonAxisIntegrator,
ILinearCombination1DVarianceCalculator temporalVarianceCalculator,
ILinearCombinationOnSphereVarianceCalculator spatialVarianceCalculator,
INodeUncertaintyProvider baseNodeUncertatintyProvider)
{
this.temporalVarianceCalculator = temporalVarianceCalculator;
this.spatialVarianceCalculator = spatialVarianceCalculator;
this.baseNodeUncertatintyProvider = baseNodeUncertatintyProvider;
timeAggregator2 = timeAxisIntegrator;
latIntegrator2 = latAxisIntegrator;
lonIntegrator2 = lonAxisIntegrator;
}
/// <param name="permittedYearsLength">The minimum length of the requested years range for wich the uncertainty is returned</param>
public MonthlyMeansOverEnoughYearsStepIntegratorFacade(int permittedYearsLength)
{
this.component = new MonthlyMeansOverYearsStepIntegratorFacade();
this.decoratedProvider = new TimeCoverageProviders.YearsRangeLengthDecorator(component, permittedYearsLength);
}
public static async Task <TimeIntegratorBasedAveragerFactory> CreateAsync(IStorageContext storageContext, ITimeAxisAvgProcessing timeIntegrator, IStationLocator stationLocator, string latAxisName = "autodetect", string lonAxisName = "autodetect")
{
if (latAxisName == "autodetect")
{
latAxisName = IntegratorsFactoryHelpers.AutodetectLatName(storageContext.StorageDefinition);
}
if (lonAxisName == "autodetect")
{
lonAxisName = IntegratorsFactoryHelpers.AutodetectLonName(storageContext.StorageDefinition);
}
//preparing virtual observation axes
var latsTask = storageContext.GetDataAsync(latAxisName);
var lonsTask = storageContext.GetDataAsync(lonAxisName);
var stationsLatsAxis = await latsTask;
var stationsLonsAxis = await lonsTask;
int stationsCount = stationsLatsAxis.Length;
Type latsArrType = stationsLatsAxis.GetType().GetElementType();
Type lonsArrType = stationsLonsAxis.GetType().GetElementType();
double[] stationsLats, stationsLons;
if (latsArrType == typeof(double))
{
stationsLats = (double[])stationsLatsAxis;
}
else if (latsArrType == typeof(float))
{
stationsLats = ((float[])stationsLatsAxis).Select(v => (double)v).ToArray();
}
else
{
throw new InvalidOperationException("The latitude coordinates of points are neither double nor float type");
}
if (lonsArrType == typeof(double))
{
stationsLons = (double[])stationsLonsAxis;
}
else if (lonsArrType == typeof(float))
{
stationsLons = ((float[])stationsLonsAxis).Select(v => (double)v).ToArray();
}
else
{
throw new InvalidOperationException("The longatude coordinates of points are neither double nor float type");
}
return(new TimeIntegratorBasedAveragerFactory(storageContext, timeIntegrator, stationLocator, stationsLats, stationsLons, storageContext.StorageDefinition.VariablesDimensions[latAxisName][0]));
}
/// <param name="firstYear">The first year for which data corresponds</param>
/// <param name="lastYear">The last year for which data corresponds</param>
public MonthlyMeansOverExactYearsStepIntegratorFacade(int firstYear, int lastYear)
{
this.component = new MonthlyMeansOverYearsStepIntegratorFacade();
this.decoratedProvider = new TimeCoverageProviders.ExactYearsDecorator(component, firstYear, lastYear);
}
/// <summary>
/// Performs "default" dependency injection to assable general purpuse grid data handler with specified time axis interpolator""
/// </summary>
/// <param name="dataContext"></param>
/// <param name="timeIntegrator"></param>
/// <returns></returns>
public static async Task <Tuple <IBatchUncertaintyEvaluator, IBatchValueAggregator> > EasyConstructAsync(IStorageContext dataContext, ITimeAxisAvgProcessing timeIntegrator)
{
var storageDefinition = dataContext.StorageDefinition;
var latIntegratorTask = LinearIntegratorsFactory.SmartConstructAsync(dataContext, IntegratorsFactoryHelpers.AutodetectLatName(storageDefinition));
var lonIntegratorTask = LinearIntegratorsFactory.SmartConstructAsync(dataContext, IntegratorsFactoryHelpers.AutodetectLonName(storageDefinition));
var latIntegrator = await latIntegratorTask;
var lonIntegrator = await lonIntegratorTask;
var baseNodeUncertainty = new NoBaseUncertaintyProvider();
var temporalVarianceCalculaator = new LinearCombination1DVarianceCalc(new StorageContextMetadataTimeVarianceExtractor(storageDefinition), timeIntegrator);
var spatialVarianceCalculator = new LinearCombinationOnSphereVarianceCalculator(new StorageContextMetadataSpatialVarianceExtractor(storageDefinition), latIntegrator, lonIntegrator);
var gaussianFieldUncertaintyEvaluator = new SequentialTimeSpatialUncertaintyEvaluatorFacade(timeIntegrator, latIntegrator, lonIntegrator, temporalVarianceCalculaator, spatialVarianceCalculator, baseNodeUncertainty);
var coverageCheckUncertaintyEvaluator = new GridUncertaintyConventionsDecorator(gaussianFieldUncertaintyEvaluator, latIntegrator, lonIntegrator, timeIntegrator);
var scaledUncertaintyEvaluator = new Microsoft.Research.Science.FetchClimate2.UncertaintyEvaluators.LinearTransformDecorator(coverageCheckUncertaintyEvaluator);
var variablePresenceCheckEvaluator = new VariablePresenceCheckDecorator(dataContext.StorageDefinition, scaledUncertaintyEvaluator);
var gridAggregator = new GridMeanAggregator(dataContext, timeIntegrator, latIntegrator, lonIntegrator, true);
var clusteringAggregator = new GridClusteringDecorator(dataContext.StorageDefinition, gridAggregator, timeIntegrator, latIntegrator, lonIntegrator);
var scaledAggregator = new Microsoft.Research.Science.FetchClimate2.ValueAggregators.LinearTransformDecorator(dataContext, clusteringAggregator);
return(Tuple.Create((IBatchUncertaintyEvaluator)variablePresenceCheckEvaluator, (IBatchValueAggregator)scaledAggregator));
}
