private void SelectSnapshot(int offset)
{
if (offset != 0)
{
SimDateTime actualSdt = null;
if (offset == short.MinValue)
{
actualSdt = _min;
}
else if (offset == short.MaxValue)
{
actualSdt = _max;
}
else if (offset == -3)
{
actualSdt = SimulationData.SelectPreviousSnapshot(_crtSnapshot);
}
else if (offset == 3)
{
actualSdt = SimulationData.SelectNextSnapshot(_crtSnapshot);
}
else
{
SimDateTime sdt = _crtSnapshot.AddHours(offset);
actualSdt = SimulationData.SelectNearestSnapshot(sdt);
}
cmbSnapshots.SelectedItem = actualSdt;
}
}
public static float GetRefTemp_ByLatitude_MidLevel(SimDateTime sdt, float lat)
{
float init = 0;
float latRad = lat * (float)Math.PI / 180;
float sunLatRad = References.GetSunLatitude_Radians(sdt);
float sunLat = sunLatRad * 180 / (float)Math.PI;
float deltaLatRad = Math.Abs(latRad - sunLatRad);
float deltaLat = Math.Abs(lat - sunLat);
float dayLen = GetDayLength_ByLatitude(sdt, lat);
float tm = SimulationParameters.Instance._DefaultRefTemp;
init = tm - 0.5f * deltaLat;
float absCosLat = (float)Math.Abs(Math.Cos(deltaLatRad));
float deltaByNight = 4f * absCosLat * (dayLen / AbsoluteConstants.HoursPerDay - 0.5f);
float te = init + deltaByNight;
return(te);
}
public static float GetRefTemp(EarthModel earth, SimDateTime sdt, int r, int c)
{
string key = string.Format("{0}_{1}_{2}", sdt.DayOfYear, r, c);
lock (_refTemp)
{
if (_refTemp.ContainsKey(key) == false)
{
int lat = EarthModel.MaxLat - r;
float rt = GetRefTemp_ByLatitude_MidLevel(sdt, lat) + AbsoluteConstants.WaterFreezePoint;
float dt = rt - AbsoluteConstants.WaterFreezePoint;
float f = 1.2f;
var wl = earth.SFC.WL[r, c];
if (wl == 0)
{
rt = AbsoluteConstants.WaterFreezePoint + dt * f;
}
else
{
rt = AbsoluteConstants.WaterFreezePoint + dt / f;
}
_refTemp.Add(key, rt - AbsoluteConstants.WaterFreezePoint);
}
return(_refTemp[key]);
}
}
protected override void ImportSurface()
{
ImportNcFile <float>(SeaTempNcFile,
"sst", 1, 0,
SeaTempFile,
(d) => (d / 100),
false);
DateTime dt = ImportDateTime(SeaTempNcFile);
SimDateTime sdt = new SimDateTime(dt);
string timeSeedFile = "timeSeed.thd";
CorrectFilePath(ref timeSeedFile);
File.WriteAllText(timeSeedFile, sdt.Title);
if (_sstOnly)
{
return;
}
ImportNcFile <float>(SoilTempNcFile,
"Temperature_depth_below_surface_layer", 1, 0,
SoilTempFile,
(d) => (d > 1000) ? 0 : (d - AbsoluteConstants.WaterFreezePoint));
ImportNcFile <float>(SnowCoverNcFile,
"Water_equivalent_of_accumulated_snow_depth", 1, 0,
SnowCoverFile,
(d) => (d));
}
void ControlPanelModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
case "SelectedSnapshot":
{
SimDateTime snapshot = App.ControlPanelModel.SelectedSnapshot;
if (snapshot != null)
{
this.Title = string.Format("{0} [Data path: {1}], Snapshot: {2}",
App.AppName, SimulationData.DataFolder, snapshot);
}
else
{
this.Title = string.Format("{0} [Data path: {1}], No snapshot currently loaded.",
App.AppName, SimulationData.DataFolder);
}
}
break;
case "AutoSave":
mapView.SaveImage(true);
break;
}
}
public void Run(DateTime dtInit)
{
if (SimulationData.AvailableSnapshots.Count > 0)
{
int rangeSize = _statsRangeLength;
int totalRanges = (int)Math.Round((float)SimulationData.AvailableSnapshots.Count / (float)rangeSize);
SimDateTime firstSnapshotStart = SimulationData.AvailableSnapshots[0];
for (int id = 0; id < totalRanges; id++)
{
_doneEvents.Add(new ManualResetEvent(false));
ThreadPool.QueueUserWorkItem((c) => ProcessSimRange(dtInit, firstSnapshotStart, rangeSize, (int)c), id);
//ProcessSimRange(dtInit, firstSnapshotStart, rangeSize, id);
}
ManualResetEvent.WaitAll(_doneEvents.ToArray());
TimeSpan tsDiff = DateTime.Now - dtInit;
Console.WriteLine($" -> Statistics completed after {(int)tsDiff.TotalMilliseconds} msec.");
}
FileSupport.WaitForPendingWriteOperations();
}
public static float GetRefTempYearlyDelta_MidLevel(EarthModel earth, int r, int c)
{
string key = string.Format("{0}_{1}", r, c);
lock (_refTempYearlyDelta)
{
if (_refTempYearlyDelta.ContainsKey(key) == false)
{
float tRefMin = 100;
float tRefMax = -100;
SimDateTime sdtStart = earth.UTC;
for (int i = 0; i < 365; i += 5)
{
SimDateTime sdt = sdtStart.AddHours((int)AbsoluteConstants.HoursPerDay * i);
float tRef = GetRefTemp(earth, sdt, r, c);
tRefMin = Math.Min(tRefMin, tRef);
tRefMax = Math.Max(tRefMax, tRef);
}
float delta = (tRefMax - tRefMin);
_refTempYearlyDelta.Add(key, delta);
}
}
return(_refTempYearlyDelta[key]);
}
public SimulationEngine(SimDateTime sdtStart, int totalDays, int nofSnapshots)
{
SimDateTime sdtSimEnd = sdtStart.AddHours((int)(AbsoluteConstants.HoursPerDay * totalDays));
Console.WriteLine(string.Format("Simulation params: starting at: {0}, ending at: {1}, total days: {2} ...",
sdtStart, sdtSimEnd, totalDays));
// The length of the baseline is equal to the total number of days.
_simLength = totalDays;
_snapshotLength = (int)(AbsoluteConstants.HoursPerDay / nofSnapshots);
Console.WriteLine(string.Format(" -> snapshot: {0} hrs, total sim length: {1} days...",
_snapshotLength, _simLength));
Console.WriteLine("********");
Console.WriteLine("Using parameters:");
Console.Write(SimulationParameters.Instance.ToString());
Console.WriteLine("********");
_simStart = sdtStart;
SimDateTime sdtBaselineEnd = _simStart.AddHours((int)(AbsoluteConstants.HoursPerDay * _simLength));
_sim = new Simulation(sdtStart, sdtBaselineEnd, _snapshotLength, false);
_sim.ID = 0;
}
public Simulation(SimDateTime sdtStart, SimDateTime sdtEnd, int snaphotLength, bool loadFromStateFiles)
{
Start = sdtStart;
End = sdtEnd;
_earth = new EarthModel(sdtStart, loadFromStateFiles, snaphotLength);
_earth.Save(sdtStart.Title);
}
void ControlPanelModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
switch (e.PropertyName)
{
//case "SelectedViewport":
// {
// this.Model.Axes[0].Minimum = App.ControlPanelModel.SelectedViewport.MinLat;
// this.Model.Axes[0].Maximum = App.ControlPanelModel.SelectedViewport.MaxLat;
// this.Model.Axes[1].Minimum = App.ControlPanelModel.SelectedViewport.MinLon;
// this.Model.Axes[1].Maximum = App.ControlPanelModel.SelectedViewport.MaxLon;
// this.Model.Title = App.ControlPanelModel.SelectedViewport.Name;
// if (App.ControlPanelModel.SelectedViewport.Name == "Romania" &&
// this.Model.Annotations.Contains(_roCounties) == false)
// this.Model.Annotations.Add(_roCounties);
// else if (this.Model.Annotations.Contains(_roCounties))
// this.Model.Annotations.Remove(_roCounties);
// this.Model.InvalidatePlot(true);
// }
// break;
case "ShowContours":
case "SelectedViewport":
case "SelectedSnapshot":
case "SelectedCategory":
case "SelectedDataType":
case "PaletteParams":
case "Offset":
{
if (App.ControlPanelModel.SelectedSnapshot != null)
{
SimDateTime snapshot = App.ControlPanelModel.SelectedSnapshot;
string folder = SimulationData.DataFolder;
if (string.IsNullOrEmpty(App.ControlPanelModel.SelectedCategory) == false)
{
folder = Path.Combine(SimulationData.DataFolder, App.ControlPanelModel.SelectedCategory);
}
string fieldDataFileName = string.Format("{0}_MAP_{1}.thd",
App.ControlPanelModel.SelectedDataType.Name,
snapshot.Title);
string fieldDataFile = System.IO.Path.Combine(folder, fieldDataFileName);
ReloadModel(fieldDataFile, App.ControlPanelModel.SelectedDataType.IsWindMap);
this.Model.InvalidatePlot(true);
App.ControlPanelModel.DoAutoSave();
}
}
break;
}
}
void ControlPanelModel_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
try
{
SimDateTime snapshot = App.ControlPanelModel.SelectedSnapshot;
string folder = SimulationData.DataFolder;
if (string.IsNullOrEmpty(App.ControlPanelModel.SelectedCategory) == false)
{
folder = System.IO.Path.Combine(SimulationData.DataFolder, App.ControlPanelModel.SelectedCategory);
}
string fieldDataFileName = string.Format("{0}_MAP_{1}.thd",
App.ControlPanelModel.SelectedDataType.Name,
snapshot.Title);
string fieldDataFile = System.IO.Path.Combine(folder, fieldDataFileName);
WeatherDataPalette wdp = WeatherDataPaletteFactory.GetPaletteForDataFile(fieldDataFile);
Type baseDataType = null;
switch (e.PropertyName)
{
case "SelectedDataType":
{
if (wdp.GetType().IsSubclassOf(typeof(TemperaturePalette)))
{
baseDataType = typeof(TemperaturePalette);
}
else if (wdp.GetType().IsSubclassOf(typeof(PressurePalette)))
{
baseDataType = typeof(PressurePalette);
}
else if (wdp.GetType().IsSubclassOf(typeof(HumidityPalette)))
{
baseDataType = typeof(HumidityPalette);
}
else
{
baseDataType = wdp.GetType();
}
}
break;
default:
break;
}
this.sliderPrecipOffset.IsEnabled = wdp.ShowHeatmap;
this.sliderPrecipOffset.Visibility = wdp.ShowHeatmap ? Visibility.Visible : Visibility.Hidden;
}
catch (Exception ex)
{
string s = ex.Message;
}
}
public EarthModel(SimDateTime initUtc, bool loadFromStateFiles, int snaphotLength)
{
this.SnapshotLength = snaphotLength;
SetUTC(initUtc);
SimStartUTC = initUtc;
SFC = new SurfaceLevel(this, loadFromStateFiles);
ATM = new Atmosphere(this, loadFromStateFiles);
RebuildState();
}
public static bool SimBreakPoint(int r, int c, EarthModel model = null)
{
SimDateTime compareTo = new SimDateTime("2019-06-20_00");
#if HAVE_TESTSIMBREAKPOINT
if (model == null || model.UTC.GetHoursOffset(compareTo) >= 0)
{
return(r == EarthModel.MaxLat - (int)SimConstants.TEST_Lat &&
c == EarthModel.MaxLon + (int)SimConstants.TEST_Lon);
}
#endif
return(false);
}
public static float GetDayLength_ByLatitude(SimDateTime sdt, float lat)
{
string key = string.Format("{0}_{1}", sdt.DayOfYear, lat);
lock (_dayLengthByLatitude)
{
if (_dayLengthByLatitude.ContainsKey(key) == false)
{
float dayLen = 0;
float latRan = lat * (float)Math.PI / 180;
float p = GetSunLatitude_Radians(sdt);
float sin1 = (float)Math.Sin(0.8333f * (float)Math.PI / 180);
float prod_sin = (float)Math.Sin(latRan) * (float)Math.Sin(p);
float prod_cos = (float)Math.Cos(latRan) * (float)Math.Cos(p);
float arg_acos = (sin1 + prod_sin) / prod_cos;
if (arg_acos < -1)
{
arg_acos = -1;
}
if (arg_acos > 1)
{
arg_acos = 1;
}
float acos_val = (float)Math.Acos(arg_acos);
float nightLen = AbsoluteConstants.HoursPerDay / (float)Math.PI * acos_val;
if (nightLen > AbsoluteConstants.HoursPerDay)
{
dayLen = 0;
}
else if (nightLen < 0)
{
dayLen = AbsoluteConstants.HoursPerDay;
}
else
{
dayLen = AbsoluteConstants.HoursPerDay - nightLen;
}
_dayLengthByLatitude.Add(key, dayLen);
}
return(_dayLengthByLatitude[key]);
}
}
private DenseMatrix ImportLevelData(string dataFile, string paramName, int levelIdx, Func <float, float> conversionFunc)
{
if (string.IsNullOrEmpty(dataFile) == false)
{
if (File.Exists(dataFile))
{
File.Delete(dataFile);
}
}
int level = (levelIdx < 0) ? 0 : _levels[levelIdx];
var messages = _messages.Where(m => m.Name.Contains(paramName) && m.Level == level).First();
var nodes = messages.GeoSpatialValues.Where(gs => gs.IsMissing == false &&
(gs.Latitude >= EarthModel.MinLat && gs.Latitude <= EarthModel.MaxLat) &&
(gs.Longitude >= 180 + EarthModel.MinLon && gs.Longitude <= 180 + EarthModel.MaxLon) &&
(gs.Latitude == Math.Truncate(gs.Latitude)) &&
gs.Longitude == Math.Truncate(gs.Longitude))
.ToArray();
if (!time)
{
DateTime dt = messages.ReferenceTime;
SimDateTime sdt = new SimDateTime(dt);
string timeSeedFile = "timeSeed.thd";
CorrectFilePath(ref timeSeedFile);
File.WriteAllText(timeSeedFile, sdt.Title);
time = true;
}
DenseMatrix mat = MatrixFactory.Init();
foreach (var node in nodes)
{
int r = EarthModel.MaxLat - (int)node.Latitude;
int c = ((int)node.Longitude - EarthModel.MinLon) % 360;
mat[r, c] = conversionFunc((float)node.Value);
}
if (string.IsNullOrEmpty(dataFile) == false)
{
FileSupport.SaveMatrixToFile(mat, dataFile, false);
}
return(mat);
}
private bool CanSelectSnapshot(int offset)
{
if (offset == short.MinValue || offset == short.MaxValue)
{
return(true);
}
if (_crtSnapshot != null && _min != null && _max != null)
{
try
{
SimDateTime sdt = _crtSnapshot.AddHours(offset);
return(_min.GetHoursOffset(sdt) <= 0 && sdt.GetHoursOffset(_max) <= 0);
}
catch { }
}
return(false);
}
public static float GetSunLatitude_Radians(SimDateTime sdt)
{
float delay = SimulationParameters.Instance.Delay * AbsoluteConstants.HoursPerDay;
SimDateTime actualSdt = sdt.AddHours((int)delay);
int yday = actualSdt.DayOfYear;
lock (_sunLatitude)
{
if (_sunLatitude.ContainsKey(yday) == false)
{
float p = (float)Math.Asin(0.39795f * (float)Math.Cos(0.2163108f + 2 * (float)Math.Atan(0.9671396f * (float)Math.Tan(0.00860f * (yday - 182.625f)))));
_sunLatitude.Add(yday, p);
}
}
return(_sunLatitude[yday]);
}
private void ProcessSimRange(DateTime dtInit, SimDateTime firstSnapshotStart, int rangeSize, int idx)
{
//--------------------------------
TimeSpan tsDiff = DateTime.Now - dtInit;
SimDateTime dtStart = firstSnapshotStart.AddHours((int)(AbsoluteConstants.HoursPerDay * rangeSize * (idx)));
Console.WriteLine(string.Format("STAT: Initializing range {0} + {2}days [elapsed {1} msec]",
dtStart, (int)tsDiff.TotalMilliseconds, rangeSize));
SimDateTimeRange sdtr = SimDateTimeRange.BuildRange(dtStart, rangeSize);
if (sdtr == null)
{
return;
}
tsDiff = DateTime.Now - dtInit;
Console.WriteLine(string.Format("STAT: Starting processing on range {0} [elapsed {1} msec]",
sdtr, (int)tsDiff.TotalMilliseconds));
var c1 = sdtr.AtmList.Count;
var c2 = sdtr.SfcList.Count;
if (c1 <= 0 || c2 <= 0 || c1 != c2)
{
return;
}
SimDateTimeRangeStats stats = sdtr.BuildStatistics();
stats.Save(sdtr.Start.Title);
tsDiff = DateTime.Now - dtInit;
Console.WriteLine(string.Format("STAT: Done range {0} [elapsed {1} msec]",
sdtr, (int)tsDiff.TotalMilliseconds));
_doneEvents[idx].Set();
//--------------------------------
}
private void cmbSnapshots_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
try
{
_crtSnapshot = cmbSnapshots.SelectedItem as SimDateTime;
App.ControlPanelModel.SelectedSnapshot = _crtSnapshot;
}
finally
{
if (_tmrDelayedStateChange == null)
{
_tmrDelayedStateChange = new Timer();
_tmrDelayedStateChange.Interval = 500;
_tmrDelayedStateChange.AutoReset = true;
_tmrDelayedStateChange.Elapsed += _tmrDelayedClick_Elapsed;
}
_tmrDelayedStateChange.Start();
}
}
void LoadSnapshots()
{
SimDateTime prevSnapshot = _crtSnapshot;
int prevIndex = cmbSnapshots.SelectedIndex;
try
{
SimulationData.SnapshotListChanged -= SimulationData_SnapshotListChanged;
cmbSnapshots.ItemsSource = SimulationData.AvailableSnapshots;
if (SimulationData.AvailableSnapshots.Count > 0)
{
_min = SimulationData.AvailableSnapshots[0];
_max = SimulationData.AvailableSnapshots[SimulationData.AvailableSnapshots.Count - 1];
}
}
catch (Exception ex)
{
string s = ex.Message;
}
finally
{
SimulationData.SnapshotListChanged += SimulationData_SnapshotListChanged;
if (prevSnapshot != null && SimulationData.AvailableSnapshots.Contains(prevSnapshot))
{
cmbSnapshots.SelectedItem = prevSnapshot;
}
else if (cmbSnapshots.Items.Count > prevIndex)
{
cmbSnapshots.SelectedIndex = Math.Max(0, prevIndex);
}
else
{
cmbSnapshots.SelectedIndex = 0;
}
}
}
public void SetUTC(SimDateTime utc)
{
this.UTC = utc;
}
public void Advance(SimDateTime newUtc)
{
this.SetUTC(newUtc);
ATM.Advance();
}
static void Main(string[] args)
{
DateTime dtInit = DateTime.Now;
// -------------------------
// Parse command line args
bool runStats = false;
int statRangeLen = 1;
if (args.Length < 2)
{
return;
}
int argCnt = 0;
SimDateTime sdtStart = null;
SimDateTime sdtEnd = null;
int totalDays = 0;
int totalDaysArg = 0;
int nofSnapshots = 3;
int totalExpectedArgs = 4;
bool runSim = true;
bool regenerateInitialConditions = Environment.CommandLine.EndsWith(" regen");
if (string.Compare(args[argCnt], "nosim", true) != 0)
{
if (string.Compare(args[argCnt], "0", true) == 0)
{
sdtStart = null;
argCnt++;
}
else
{
try
{
sdtStart = new SimDateTime(args[argCnt++]);
}
catch
{
sdtStart = null;
}
}
string arg = args[argCnt++];
try
{
sdtEnd = new SimDateTime(arg);
totalDaysArg = 0;
}
catch
{
totalDaysArg = int.Parse(arg);
}
// TODO nofSnapshots as part of cmd line
nofSnapshots = 1;
}
else
{
argCnt++;
totalExpectedArgs = 3;
runSim = false;
}
if (args.Length >= totalExpectedArgs)
{
runStats = string.Compare(args[argCnt++], "stat", true) == 0;
statRangeLen = int.Parse(args[argCnt++]);
}
// -------------------------
// This is just for loading the customizable simulation params
var x = SimulationParameters.Instance.JetStreamPeriod;
// -------------------------
// Run simulation engine
if (runSim)
{
if (regenerateInitialConditions)
{
// First Grib, then NetCdf. Otherwise it crashes and I don't know why...
new GribImporter("input.grib").ImportFiles();
new NetCdfImporter(true).ImportFiles();
}
string dataDir = SimulationData.DataFolder;
if (Directory.Exists(dataDir))
{
Directory.Delete(dataDir, true);
}
Directory.CreateDirectory(dataDir);
try
{
string timeSeedFile = "timeSeed.thd";
NetCdfImporter.CorrectFilePath(ref timeSeedFile);
if (sdtStart == null && File.Exists(timeSeedFile))
{
try
{
string timeSeed = File.ReadAllText(timeSeedFile);
sdtStart = new SimDateTime(timeSeed);
}
catch
{
sdtStart = null;
}
}
if (sdtStart == null)
{
sdtStart = new SimDateTime(DateTime.Now);
}
if (totalDaysArg == 0)
{
if (sdtEnd == null)
{
sdtEnd = new SimDateTime(DateTime.Now);
}
totalDays = (int)Math.Round(sdtEnd.GetHoursOffset(sdtStart) / AbsoluteConstants.HoursPerDay);
}
else
{
totalDays = totalDaysArg;
}
SimulationEngine sim = new SimulationEngine(sdtStart, totalDays, nofSnapshots);
sim.Run(dtInit);
}
catch (Exception ex)
{
string s = ex.Message;
}
}
// -------------------------
GC.Collect();
// -------------------------
// Run statistics engine
if (runStats)
{
string statDir = Path.Combine(SimulationData.DataFolder, "stats");
if (Directory.Exists(statDir))
{
Directory.Delete(statDir, true);
}
Directory.CreateDirectory(statDir);
try
{
StatisticsEngine stat = new StatisticsEngine(statRangeLen);
stat.Run(dtInit);
}
catch (Exception ex)
{
string s = ex.Message;
}
}
// -------------------------
Process.GetCurrentProcess().Kill();
}
public static float GetDayLength_ByRowIndex(SimDateTime sdt, int r)
{
int lat = EarthModel.MaxLat - r;
return(GetDayLength_ByLatitude(sdt, lat));
}
