public static void GetSolarDataForTodayAsync()
{
DateTime today = DateTime.Today;
double latitude = Double.Parse((string)ApplicationData.Current.LocalSettings.Values["Latitude"]);
double longitude = Double.Parse((string)ApplicationData.Current.LocalSettings.Values["Longitude"]);
SolarTimes solarTimes = new SolarTimes(today, latitude, longitude);
SunRiseToday = solarTimes.Sunrise;
SunSetToday = solarTimes.Sunset;
}
private void Caclulate(DateTime date, int numdays, string id, int studyID, string act_timezone_property)
{
Days = new List <Daylight>();
targetdate = date;
TimeZoneActigraph = LookupTimeZone(act_timezone_property);
var zipCodes = ZipCodeSource.FromMemory().GetRepository();
SQL_utils sql = new SQL_utils("backend");
string code = String.Format("select left(zip,5) from trk.vwMasterStatus_S a where id='{0}' and studyID={1}"
, id, studyID);
string myDBzip = sql.StringScalar_from_SQLstring(code);
sql.Close();
if (myDBzip.Contains("Error"))
{
Zip = "98195";
ZipDerivedFrom = "Default (address in DB is null)";
}
else
{
Zip = myDBzip;
ZipDerivedFrom = "address in DB";
}
var myzipinfo = zipCodes.Get(Zip);
Place = String.Format("{0}, {1}", myzipinfo.PlaceName, myzipinfo.StateAbbreviation);
Lat = myzipinfo.Latitude;
Lng = myzipinfo.Longitude;
TimeZoneApiResultZip = LookupApiTimeZone(Lat, Lng);
//TimeZoneZip = LookupTimeZone(myzipinfo.Latitude, myzipinfo.Longitude);
for (int i = 0; i < numdays; i++)
{
DateTime tempdate = date.AddDays(i);
SolarTimes solarTimes = new SolarTimes(tempdate, myzipinfo.Latitude, myzipinfo.Longitude);
Daylight day = new Daylight()
{
Targetdate = tempdate,
Sunrise = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunrise.ToUniversalTime(), TimeZoneActigraph),
Sunset = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunset.ToUniversalTime(), TimeZoneActigraph)
};
Days.Add(day);
}
}
private void PopulateSunriseSunset(WeatherDto dto, DateTime today)
{
var timesToday = new SolarTimes(DateTimeOffset.Now, Settings.Latitude, Settings.Longitude);
var timesTomorrow = new SolarTimes(DateTimeOffset.Now.AddDays(1), Settings.Latitude, Settings.Longitude);
dto.SunriseTime = $"{timesToday.Sunrise:HH:mm}";
dto.SolarNoonTime = $"{timesToday.SolarNoon:HH:mm}";
dto.SunsetTime = $"{timesToday.Sunset:HH:mm}";
var sunsetDelta = timesTomorrow.Sunset.AddDays(-1) - timesToday.Sunset;
dto.SunsetDeltaTime = (sunsetDelta >= TimeSpan.Zero ? "+" : "−") + $"{Math.Abs(sunsetDelta.TotalMinutes):0.0}m";
}
public void SunsetComparisonTest()
{
SolarTimes solarTimes = TestDirector.SolarTimesInstance(this.TestContext.DataRow);
DateTime expectedValue = Convert.ToDateTime(this.TestContext.DataRow["SunsetTime"]);
DateTime actualValue = solarTimes.Sunset;
TimeSpan difference = expectedValue.TimeOfDay.Subtract(actualValue.TimeOfDay);
if (difference > TestDirector.TimeSpanDelta)
{
Assert.Fail(string.Format("The Sunset (Column Z) calculation does not match Excel. The difference is {0}", difference));
}
}
public void SunlightDurationComparisonTest()
{
SolarTimes solarTimes = TestDirector.SolarTimesInstance(this.TestContext.DataRow);
TimeSpan expectedValue = TimeSpan.FromMinutes(Convert.ToDouble(this.TestContext.DataRow["SunlightDuration"]));
TimeSpan actualValue = solarTimes.SunlightDuration;
TimeSpan difference = expectedValue - actualValue;
if (difference > TestDirector.TimeSpanDelta)
{
Assert.Fail(string.Format("The Sunlight Duration (Column AA) calculation does not match Excel. The difference is {0}", difference));
}
}
public void SunsetComparisonTest(SolarCalculationsTestData item)
{
SolarTimes solarTimes = TestDirector.SolarTimesInstance(item);
DateTime expectedValue = item.SunsetTime;
DateTime actualValue = solarTimes.Sunset;
TimeSpan difference = expectedValue.TimeOfDay.Subtract(actualValue.TimeOfDay);
if (difference > TestDirector.TimeSpanDelta)
{
Assert.Fail($"The Sunset (Column Z) calculation does not match Excel. The difference is {difference}");
}
}
public void SunlightDurationComparisonTest(SolarCalculationsTestData item)
{
SolarTimes solarTimes = TestDirector.SolarTimesInstance(item);
TimeSpan expectedValue = TimeSpan.FromMinutes(item.SunlightDuration);
TimeSpan actualValue = solarTimes.SunlightDuration;
TimeSpan difference = expectedValue - actualValue;
if (difference > TestDirector.TimeSpanDelta)
{
Assert.Fail($"The Sunlight Duration (Column AA) calculation does not match Excel. The difference is {difference}");
}
}
public void I_should_be_able_to_calculate_solar_times_based_on_my_location(
GeoLocation location, DateTimeOffset instant, SolarTimes expectedSolarTimes)
{
// Act
var solarTimes = SolarTimes.Calculate(location, instant);
// Assert
solarTimes.Sunrise.AsTimeSpan().Should()
.BeCloseTo(expectedSolarTimes.Sunrise.AsTimeSpan(), TimeSpan.FromMinutes(3));
solarTimes.Sunset.AsTimeSpan().Should()
.BeCloseTo(expectedSolarTimes.Sunset.AsTimeSpan(), TimeSpan.FromMinutes(3));
}
public static void ShowSunset()
{
// ***
// *** Geo coordinates of Benton Harbor/Benton Heights in Michigan
// ***
TimeZoneInfo est = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
SolarTimes solarTimes = new SolarTimes(DateTime.Now, 42.1543, -86.4459);
DateTime sunset = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunset.ToUniversalTime(), est);
// ***
// *** Display the sunset
// ***
Console.WriteLine($"View the sunset across Lake Michigan from Benton Harbor in Michigan at {sunset.ToLongTimeString()} on {sunset.ToLongDateString()}.");
}
public static void GetSolarDataForTomorrow()
{
ApplicationDataContainer settings = ApplicationData.Current.LocalSettings;
var today = DateTime.Today;
var tomorrow = today.AddDays(1);
string lat = (string)settings.Values["Latitude"];
double latitude = Double.Parse(lat);
string lon = (string)settings.Values["Longitude"];
double longitude = Double.Parse(lon);
SolarTimes solarTimes = new SolarTimes(tomorrow, latitude, longitude);
SunRiseTomorrow = solarTimes.Sunrise;
SunSetTomorrow = solarTimes.Sunset;
}
public static SolarData GetSolarData(string lat, string lon, DateTime date)
{
double latitude = double.Parse(lat, CultureInfo.InvariantCulture);
double longitude = double.Parse(lon, CultureInfo.InvariantCulture);
SolarTimes solarTimes = new SolarTimes(date, latitude, longitude);
SolarData data = new SolarData();
data.SunriseTime = solarTimes.Sunrise;
data.SunsetTime = solarTimes.Sunset;
return(data);
}
public float CalculateHourAhead(string tip, float ConsiderP, float longitude, float latitude)
{
float P = 0;
if (tip == "Wind")
{
if (hourDataPoint.WindSpeed < 3.5)
{
P = 0;
}
else if (hourDataPoint.WindSpeed >= 3.5 && hourDataPoint.WindSpeed < 14)
{
P = (float)((hourDataPoint.WindSpeed - 3.5) * 0.035 * 1000);
}
else if (hourDataPoint.WindSpeed >= 14 && hourDataPoint.WindSpeed < 25)
{
P = ConsiderP;
}
else if (hourDataPoint.WindSpeed >= 25)
{
P = 0;
}
//TODO formula za windTurbine
}
else if (tip == "Solar")
{
double insolation = 0;
insolation = 990 * (1 - hourDataPoint.CloudCover * hourDataPoint.CloudCover * hourDataPoint.CloudCover);
double TCell = hourDataPoint.Temperature + 0.025 * insolation;
if (TCell >= 25)
{
TCell = 25;
}
P = (float)(ConsiderP * insolation * 0.00095 * (1 - 0.005 * (TCell - 25)));
SolarTimes solarTimes = new SolarTimes(DateTime.Now, latitude, longitude);
DateTime sunrise = solarTimes.Sunrise;
DateTime sunset = solarTimes.Sunset;
if (hourDataPoint.Time > sunset || hourDataPoint.Time < sunrise)
{
P = 0;
}
}
return(P);
}
public static async Task GetSolarDataForTodayAsync()
{
ApplicationDataContainer settings = ApplicationData.Current.LocalSettings;
DateTime today = DateTime.Today;
string lat = (string)settings.Values["Latitude"];
double latitude = Double.Parse(lat);
string lon = (string)settings.Values["Longitude"];
double longitude = Double.Parse(lon);
SolarTimes solarTimes = new SolarTimes(today, latitude, longitude);
SunRiseToday = solarTimes.Sunrise;
SunSetToday = solarTimes.Sunset;
await Library.IsItNowDayOrNight.DayORNightAsync();
}
/// <summary>
/// Creates a SolarTimes instance for use in tests from an instance
/// of SolarCalculatorTestData.
/// </summary>
public static SolarTimes SolarTimesInstance(SolarCalculationsTestData item)
{
SolarTimes returnValue = null;
TimeSpan tzOffset = TimeSpan.FromHours(item.TimeZoneOffset);
returnValue = new SolarTimes()
{
Latitude = Convert.ToDouble(item.Latitude),
Longitude = Convert.ToDouble(item.Longitude),
ForDate = new DateTimeOffset(item.Date.Add(item.Time.TimeOfDay), tzOffset)
};
return(returnValue);
}
public static WeatherData GetWeatherData(string lat, string lon, string dateStr)
{
DateTime date = DateTime.Parse(dateStr);
double latitude = Double.Parse(lat, cultureInfo);
double longitude = Double.Parse(lon, cultureInfo);
SolarTimes solarTimes = new SolarTimes(date, latitude, longitude);
WeatherData data = new WeatherData();
data.SunriseTime = solarTimes.Sunrise;
data.SunsetTime = solarTimes.Sunset;
return(data);
}
private static string CalculateDawn(DateTimeOffset date, double latitudeInput, double longitudeInput, long elevation = 0)
{
try
{
SolarTimes solarTimes = new SolarTimes(date, latitudeInput, longitudeInput);
DateTime sr = solarTimes.Sunrise;
DateTime dt = Convert.ToDateTime(sr);
string text = dt.ToString("h:mm:ss");
return(text);
}
catch
{
Console.WriteLine("Enter valid values. Error validation is yet to be written. ");
throw;
}
}
public void Color_configuration_is_calculated_smoothly_throughout_the_whole_cycle()
{
// Arrange
var solarTimes = new SolarTimes(new TimeOfDay(07, 00), new TimeOfDay(18, 00));
var transitionDuration = new TimeSpan(01, 30, 00);
var transitionOffset = 0;
var dayConfiguration = new ColorConfiguration(6600, 1);
var nightConfiguration = new ColorConfiguration(3600, 0.85);
// Act
var lastInstantTime = TimeSpan.Zero;
var lastConfiguration = nightConfiguration;
for (var instantTime = TimeSpan.Zero; instantTime < TimeSpan.FromDays(1); instantTime += TimeSpan.FromMinutes(1))
{
var instant = new DateTimeOffset(
2019, 01, 01,
instantTime.Hours, instantTime.Minutes, instantTime.Seconds,
TimeSpan.Zero
);
var configuration = Cycle.InterpolateConfiguration(
solarTimes,
dayConfiguration,
nightConfiguration,
transitionDuration,
transitionOffset,
instant
);
// Assert
var isHarshJump =
Math.Abs(configuration.Temperature - lastConfiguration.Temperature) >=
Math.Abs(dayConfiguration.Temperature - nightConfiguration.Temperature) / 2
||
Math.Abs(configuration.Brightness - lastConfiguration.Brightness) >=
Math.Abs(dayConfiguration.Brightness - nightConfiguration.Brightness) / 2;
Assert.False(isHarshJump,
$"Detected harsh jump in color configuration from {lastInstantTime} to {instantTime}: " +
$"{lastConfiguration} -> {configuration}."
);
lastInstantTime = instantTime;
lastConfiguration = configuration;
}
}
static void SunriseSunsetDemo()
{
SolarTimes solarTimes = new SolarTimes(DateTime.Now);
// ***
// *** Geo coordinates
// ***
solarTimes.Latitude = 41.6042880444544;
solarTimes.Longitude = -88.03034663200378;
// ***
// *** Display the sunrise and sunset
// ***
Console.WriteLine("Sunrise is at {0} on {1}.", solarTimes.Sunrise.ToLongTimeString(), solarTimes.Sunrise.ToLongDateString());
Console.WriteLine("Sunset is at {0} on {1}.", solarTimes.Sunset.ToLongTimeString(), solarTimes.Sunset.ToLongDateString());
Console.WriteLine("The amount of sunlight on {0} is {1} hours, {2} minutes and {3} seconds.", solarTimes.ForDate.DateTime.ToLongDateString(), solarTimes.SunlightDuration.Hours, solarTimes.SunlightDuration.Minutes, solarTimes.SunlightDuration.Seconds);
}
private void HandleSunrise(EvalNode evalNode, DateTime start, DateTime dateEnd, double addMinutes)
{
if (evalNode.Occurrences == null)
{
evalNode.Occurrences = new List <DateTime>();
}
while (start.Ticks < dateEnd.Ticks)
{
var solarTimes = new SolarTimes(start.ToLocalTime(), Location["latitude"].Value, Location["longitude"].Value);
var sunrise = solarTimes.Sunrise;
sunrise = sunrise.AddMinutes(addMinutes);
if (IsBetween(sunrise, start, dateEnd))
{
sunrise = sunrise.AddSeconds(-sunrise.Second).AddMilliseconds(-sunrise.Millisecond);
evalNode.Occurrences.Add(sunrise);
}
start = start.AddHours(24);
}
}
public static void ShowNauticalDawn()
{
// ***
// *** Geo coordinates of Oak Street Beach in Chicago, IL
// ***
// *** NOTE: the .Date is not necessary but is included to demonstrate that time input
// *** does not affect the output. Time will be returned in the current time zone so it
// *** will need to be adjusted to the time zone where the coordinates are from (there
// *** are services that can be used to get time zone from a latitude and longitude position).
// ***
TimeZoneInfo cst = TimeZoneInfo.FindSystemTimeZoneById("Central Standard Time");
SolarTimes solarTimes = new SolarTimes(DateTime.Now.Date, 41.9032, -87.6224);
DateTime dawn = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.DawnNautical.ToUniversalTime(), cst);
// ***
// *** Display the sunrise
// ***
Console.WriteLine($"View the Nautical Dawn across Lake Michigan from Oak Street Beach in Chicago at {dawn.ToLongTimeString()} on {dawn.ToLongDateString()}.");
}
public void Color_configuration_is_calculated_correctly_around_the_edges()
{
// Arrange
var solarTimes = new SolarTimes(new TimeOfDay(07, 00), new TimeOfDay(18, 00));
var transitionDuration = new TimeSpan(01, 30, 00);
var transitionOffset = 0;
var dayConfiguration = new ColorConfiguration(6600, 1);
var nightConfiguration = new ColorConfiguration(3600, 0.85);
var instant1 = new DateTimeOffset(
2019, 01, 01,
00, 00, 00,
TimeSpan.Zero
);
var instant2 = new DateTimeOffset(
2019, 01, 01,
23, 59, 59,
TimeSpan.Zero
);
// Act
var configuration1 = Cycle.InterpolateConfiguration(
solarTimes,
dayConfiguration,
nightConfiguration,
transitionDuration,
transitionOffset,
instant1
);
var configuration2 = Cycle.InterpolateConfiguration(
solarTimes,
dayConfiguration,
nightConfiguration,
transitionDuration,
transitionOffset,
instant2
);
// Assert
configuration1.Should().Be(configuration2);
}
public static void ShowCivilDusk()
{
// ***
// *** Geo coordinates of Oak Street Beach in Chicago, IL
// ***
// *** NOTE: the .Date is not necessary but is included to demonstrate that time input
// *** does not affect the output. Time will be returned in the current time zone so it
// *** will need to be adjusted to the time zone where the coordinates are from (there
// *** are services that can be used to get time zone from a latitude and longitude position).
// ***
TimeZoneInfo est = TimeZoneInfo.FindSystemTimeZoneById("Eastern Standard Time");
SolarTimes solarTimes = new SolarTimes(DateTime.Now, 42.1543, -86.4459);
DateTime dusk = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.DuskCivil.ToUniversalTime(), est);
// ***
// *** Display the sunrise
// ***
Console.WriteLine($"View the Civil Dusk across Lake Michigan from Benton Harbor in Michigan at {dusk.ToLongTimeString()} on {dusk.ToLongDateString()}.");
}
private void RefreshTransitionTimes(DateTime target)
{
var geolocation = appOptionsDelegate.CurrentValue.Geolocation;
var tz = DetermineTimeZoneId(geolocation.TimeZone);
var solarTimes = new SolarTimes(target, geolocation.Latitude, geolocation.Longitude);
var sunrise = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunrise.ToUniversalTime(), tz);
var sunset = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunset.ToUniversalTime(), tz);
var midnight = sunrise.Date;
var autoTransitionTimeLimits = appOptionsDelegate.CurrentValue.AutoTransitionTimeLimits;
this.transitionTimes = new AutoTransitionTimes(
sunrise.Clamp(midnight + autoTransitionTimeLimits.SunriseLower, midnight + autoTransitionTimeLimits.SunriseUpper),
sunset.Clamp(midnight + autoTransitionTimeLimits.SunsetLower, midnight + autoTransitionTimeLimits.SunsetUpper)
);
if (transitionTimes.Day.Date != transitionTimes.Night.Date)
{
throw new InvalidOperationException();
}
logger.LogInformation($"Auto transition times refreshed | Day: {transitionTimes.Day.ToString(CultureInfo.InvariantCulture)} | Night: {transitionTimes.Night.ToString(CultureInfo.InvariantCulture)}");
}
private void HandleSolarNoon(EvalNode evalNode, DateTime start, DateTime dateEnd, double addMinutes)
{
if (evalNode.Occurrences == null)
{
evalNode.Occurrences = new List <DateTime>();
}
while (start.Ticks < dateEnd.Ticks)
{
var solarTimes = new SolarTimes(start.ToLocalTime(), Location["latitude"].Value,
Location["longitude"].Value);
var solarNoon = solarTimes.SolarNoon;
solarNoon = solarNoon.AddMinutes(addMinutes);
if (IsBetween(solarNoon, start, dateEnd))
{
solarNoon = TruncateDate(solarNoon);
evalNode.Occurrences.Add(solarNoon);
}
start = start.AddHours(24);
}
}
public static SolarCalculatorResult GetSolarTimes(
DateTime date, double latitude, double longitude)
{
var result = new SolarCalculatorResult();
try
{
var solarTimes = new SolarTimes(date, latitude, longitude);
result.results.sunrise = solarTimes.Sunrise.ToLongTimeString();
result.results.sunset = solarTimes.Sunset.ToLongTimeString();
result.results.solar_noon = solarTimes.SolarNoon.ToLongTimeString();
result.results.day_length = solarTimes.SunlightDuration.ToString();
result.status = "OK";
}
catch (Exception)
{
result.results = null;
result.status = "ERROR";
}
return(result);
}
public async Task TestSunSet()
{
DispatcherMock.Instance.Clear();
var driver = CreateDriver <SunDriver>(SunDriverFactory.DriverGuidId, SunDriverFactory.SunSetGuid);
Assert.Equal(1, driver.Children.Count);
var values = DispatcherMock.Instance.GetValues(DispatchableType.NodeInstance);
Assert.True(values.Count > 0);
var busDt = values.First().Value as DateTime?;
Assert.NotNull(busDt);
Assert.IsType <DateTime>(busDt);
var solarTimes = new SolarTimes(DateTime.Now, LatitudeAngle, LongitudeAngle);
Assert.Equal(solarTimes.Sunset, busDt);
await driver.Stop();
DispatcherMock.Instance.Clear();
}
public static TimeSpan TimeToNextSunChange(DateTime time, double lat, double lon)
{
SolarTimes solarTimes = new SolarTimes(time, lat, lon);
DateTime sunrise = solarTimes.Sunrise;
DateTime sunset = solarTimes.Sunset;
var now = time;
if (now < sunrise)
{
return(sunrise - now);
}
if (now < sunset)
{
return(sunset - now);
}
SolarTimes tomorrowSolarTimes = new SolarTimes(time + TimeSpan.FromDays(1), lat, lon);
DateTime tomorrowSunrise = tomorrowSolarTimes.Sunrise;
return(tomorrowSunrise - now);
}
public static bool IsDarkOutside(this DateTime value)
{
var isOSX = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
var timezone = isOSX ? "Europe/Amsterdam" : "W. Europe Standard Time";
var west = TimeZoneInfo.FindSystemTimeZoneById(timezone);
var solarTimes = new SolarTimes(value.Date, 51.8310915, 4.6580213);
var now = TimeZoneInfo.ConvertTimeFromUtc(value.ToUniversalTime(), west);
var sunset = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunset.ToUniversalTime(), west);
var sunrise = TimeZoneInfo.ConvertTimeFromUtc(solarTimes.Sunrise.ToUniversalTime(), west);
if (now > sunset)
{
return(true);
}
if (now < sunrise)
{
return(true);
}
return(false);
}
public void Color_configuration_is_calculated_correctly_during_day_time()
{
// Arrange
var solarTimes = new SolarTimes(new TimeOfDay(07, 00), new TimeOfDay(18, 00));
var transitionDuration = new TimeSpan(01, 30, 00);
var dayConfiguration = new ColorConfiguration(6600, 1);
var nightConfiguration = new ColorConfiguration(3600, 0.85);
var instant = new DateTimeOffset(
2019, 01, 01,
14, 00, 00,
TimeSpan.Zero);
// Act
var configuration = ColorConfiguration.Calculate(
solarTimes,
dayConfiguration,
nightConfiguration,
transitionDuration,
instant);
// Assert
configuration.Should().Be(dayConfiguration);
}
