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)); }