def test_radial_histogram():
""" Test circular histogram"""
# Testing vals
dir_vals = [0, 0, 0, 10, 85, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
# Testing
bin_vecs = w.bin_vectors
vec_cpt = (0, 0)
radius_arr = (0., 1.)
ytick_num = 1
hist = w.histogram_data
histstack = w._histogram_data_stacked(hist, ytick_num)
show_stack = False
vecs = WindRose._histogram_array_radial(bin_vecs, vec_cpt, hist, histstack,
radius_arr, show_stack)
def data_collection(self, date=Date(1, 1), schedule_type_limit=None, timestep=1):
"""Get a ladybug DataCollection representing this schedule at a given timestep.
Note that ladybug DataCollections always follow the "Ladybug Tools
Interpretation" of date time values as noted in the values_at_timestep
documentation.
Args:
date: A ladybug Date object for the day of the year the DataCollection
is representing. (Default: 1 Jan)
schedule_type_limit: A ScheduleTypeLimit object that describes the schedule,
which will be used to make the header for the DataCollection. If None,
a generic "Unknown" type will be used. (Default: None)
timestep: An integer for the number of steps per hour at which to make
the resulting DataCollection.
"""
assert isinstance(date, Date), \
'Expected ladybug Date. Got {}.'.format(type(date))
if schedule_type_limit is not None:
assert isinstance(schedule_type_limit, ScheduleTypeLimit), 'Expected ' \
'Honeybee ScheduleTypeLimit. Got {}.'.format(type(schedule_type_limit))
d_type = schedule_type_limit.data_type
unit = schedule_type_limit.unit
else:
d_type = GenericType('Unknown Data Type', 'unknown')
unit = 'unknown'
a_period = AnalysisPeriod(date.month, date.day, 0, date.month, date.day, 23,
timestep, date.leap_year)
header = Header(d_type, unit, a_period, metadata={'schedule': self.identifier})
return HourlyContinuousCollection(header, self.values_at_timestep(timestep))
def test_histogram_data_stacked():
# Testing vals
dir_vals = [0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
w.legend_parameters.segment_count = 3
# Bin values to divide into colors
# 315-45: [10, 10, 10]; 2 intervals
# 45-135: [85, 90, 90, 90, 95]; 3 intervals, [85. , 88.3, 91.7, 95. ]
# 135-225: [170]; 1 intervals
# 225-315: [285, 288]; 2 intervals, [285. , 286.5, 288. ]
# interval_num: [2, 3, 1, 2]
chk_histstack = [[(10 + 10) / 2., (10 + 10) / 2.],
[(85 + 88.3) / 2., (88.3 + 91.7) / 2., (91.7 + 95) / 2.],
[170.], [(285 + 286.5) / 2., (286.5 + 288) / 2.]]
# Testing
histstack = WindRose._histogram_data_stacked(w.histogram_data, 3)
for chkh, h in zip(chk_histstack, histstack):
for c, _h in zip(chkh, h):
assert abs(c - _h) <= 1e-1
def test_interpolate_holes():
"""Test the interoplate holes method on the discontinuous collection."""
a_per = AnalysisPeriod(6, 21, 0, 6, 21, 23)
dt1, dt2 = DateTime(6, 21, 12), DateTime(6, 21, 14)
v1, v2 = 20, 25
dc1 = HourlyDiscontinuousCollection(Header(Temperature(), 'C', a_per),
[v1, v2], [dt1, dt2])
with pytest.raises(Exception):
interp_coll1 = dc1.interpolate_holes()
dc2 = dc1.validate_analysis_period()
interp_coll1 = dc2.interpolate_holes()
assert isinstance(interp_coll1, HourlyContinuousCollection)
assert len(interp_coll1.values) == 24
assert interp_coll1[0] == 20
assert interp_coll1[12] == 20
assert interp_coll1[13] == 22.5
assert interp_coll1[14] == 25
assert interp_coll1[23] == 25
values = list(xrange(24))
test_header = Header(GenericType('Test Type', 'test'), 'test',
AnalysisPeriod(end_month=1, end_day=1))
dc3 = HourlyContinuousCollection(test_header, values)
interp_coll2 = dc3.interpolate_holes()
assert isinstance(interp_coll2, HourlyContinuousCollection)
assert len(interp_coll2.values) == 24
def test_histogram_data_nested():
# Testing vals
dir_vals = [0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple example w segs == bin num
w = WindRose(dir_data, spd_data, 4)
#w.legend_parameters = LegendParameters(segment_count=5)
w.frequency_hours = 1
# Bin values to divide into colors
# 315-45: [10, 10, 10]; 2 intervals, [10, 10, 10]
# 45-135: [85, 90, 90, 90, 95]; 3 intervals, [85, 90, 90, 90, 95]
# 135-225: [170]; 1 intervals, [170];
# 225-315: [285, 288]; 2 intervals, [285, 288]
# interval_num: [2, 3, 1, 2]
chk_histstack = [
[10, 10, 10],
[85, 90, 90, 90, 95],
[170.],
[285, 288]]
# Testing
histstack = WindRose._histogram_data_nested(w.histogram_data, 1)
for chkh, h in zip(chk_histstack, histstack):
for c, _h in zip(chkh, h):
assert abs(c - _h) <= 1e-10
# Init complex dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
w.frequency_hours = 2
# Bin values to divide into colors
# 315-45: [10, 10, 10]; 2 intervals, [10, 10]
# 45-135: [85, 90, 90, 90, 95]; 3 intervals, [87.5, 90, 95. ]
# 135-225: [170]; 1 intervals, [170]
# 225-315: [285, 288]; 2 intervals, [286.5]
# interval_num: [2, 3, 1, 2]
chk_histstack = [
[10, 10],
[87.5, 90, 95.],
[170.],
[286.5]]
# Testing
histstack = WindRose._histogram_data_nested(w.histogram_data, 2)
for chkh, h in zip(chk_histstack, histstack):
for c, _h in zip(chkh, h):
assert abs(c - _h) <= 1e-10
def test_xticks_radial():
"""Test polar coordinate array"""
# Testing vals ensure all histogram heights are equal.
dir_vals = [
3,
3,
10, # 315 - 45
85,
90,
95, # 45 - 135
170,
170,
170, # 135 - 225
230,
285,
288
] # 225 - 315
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
f = _deg2rad
cos, sin = math.cos, math.sin
# Testing
xticks = w.orientation_lines
xticks = [xtick.scale(1 / w.compass_radius) for xtick in xticks]
# w.angles - 90: [225, -45, 45, 135, 225]
# Since frequencies are for xticks, no need to scale vectors.
chk_xticks = [
[(0, 0), (cos(f(225)), -sin(f(225)))], # v0
[(0, 0), (cos(f(-45)), -sin(f(-45)))], # v1 bin 0
[(0, 0), (cos(f(-45)), -sin(f(-45)))], # v2
[(0, 0), (cos(f(45)), -sin(f(45)))], # v3 bin 1
[(0, 0), (cos(f(45)), -sin(f(45)))], # v4
[(0, 0), (cos(f(135)), -sin(f(135)))], # v5 bin 2
[(0, 0), (cos(f(135)), -sin(f(135)))], # v6
[(0, 0), (cos(f(225)), -sin(f(225)))]
] # v7 bin 3
for i, (chk_xtick, xtick) in enumerate(zip(chk_xticks, xticks)):
# Check x, y
# print(chk_xtick[1][0], xtick.to_array()[1][0])
# print(chk_xtick[1][1], xtick.to_array()[1][1])
assert abs(chk_xtick[1][0] - xtick.to_array()[1][0]) < 1e-10
assert abs(chk_xtick[1][1] - xtick.to_array()[1][1]) < 1e-10
def _get_lb_data_type_and_unit(self):
"""Get the ladybug data type and unit from the schedule_type_limit."""
if self.schedule_type_limit is not None:
data_type = self.schedule_type_limit.data_type
unit = self.schedule_type_limit.unit
else:
unit = 'unknown'
data_type = GenericType('Unknown Data Type', unit)
return data_type, unit
def test_radial_histogram_plot():
""" Test circular histogram"""
# Testing vals ensure all histogram heights are equal.
dir_vals = [3, 3, 10, # 315 - 45
85, 90, 95, # 45 - 135
170, 170, 170, # 135 - 225
230, 285, 288] # 225 - 315
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
f = _deg2rad
cos, sin = math.cos, math.sin
# Testing
bin_vecs = w.bin_vectors
vec_cpt = (0, 0)
radius_arr = (0., 1.)
hist = w.histogram_data
speeds = [val for bin in w.histogram_data for val in bin]
min_speed, max_speed = min(speeds), max(speeds)
speed_interval = (max_speed - min_speed) / w.legend_parameters.segment_count
histstack, _ = w._histogram_data_nested(
hist, (min_speed, max_speed), speed_interval)
show_freq = False
vecs = WindRose._histogram_array_radial(bin_vecs, vec_cpt, hist, histstack,
radius_arr, show_freq)
# Make bins of equal height (unit circle)
chk_bin_vecs = [[(cos(f(225)), -sin(f(225))), # 0 west
(cos(f(-45)), -sin(f(-45)))],
[(cos(f(-45)), -sin(f(-45))), # 1 north
(cos(f(45)), -sin(f(45)))],
[(cos(f(45)), -sin(f(45))), # 2 east
(cos(f(135)), -sin(f(135)))],
[(cos(f(135)), -sin(f(135))), # 3 south
(cos(f(225)), -sin(f(225)))]]
for i in range(len(chk_bin_vecs)):
vec2, vec1 = chk_bin_vecs[i][0], chk_bin_vecs[i][1]
chk_pts = [vec1, vec2]
pts = vecs[i][1:] # Get rid of cpt (0, 0)
for p, cp in zip(pts, chk_pts):
assert abs(p[0] - cp[0]) < 1e-10, (p[0], cp[0])
assert abs(p[1] - cp[1]) < 1e-10, (p[1], cp[1])
def test_interpolate_to_timestep():
"""Test the interoplation method on the continuous collection."""
values = list(xrange(24))
test_header = Header(GenericType('Test Type', 'test'), 'test',
AnalysisPeriod(end_month=1, end_day=1))
dc2 = HourlyContinuousCollection(test_header, values)
# check the interpolate data functions
interp_coll1 = dc2.interpolate_to_timestep(2)
interp_coll2 = dc2.interpolate_to_timestep(2, True)
assert interp_coll1[1] == 0.5
assert interp_coll2[1] == 0.25
assert 'Minute' in interp_coll1.timestep_text
def test_bin_vectors():
"""Bin vectors"""
# Testing vals
dir_vals = [3, 3, 3, 10, 85, 90, 95, 170, 230, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
f = _deg2rad
cos, sin = math.cos, math.sin
# Testing
# Check angles
a = w.angles
chk_a = [315, 45, 135, 225, 315]
for _a, _chk_a in zip(a, chk_a):
assert abs(_a - _chk_a) < 1e-10, (_a, _chk_a)
# Check vectors
bin_vecs = w.bin_vectors
a = [_deg2rad(_a) for _a in a]
chk_bin_vecs = [[(cos(f(225)), -sin(f(225))), # 0
(cos(f(-45)), -sin(f(-45)))],
[(cos(f(-45)), -sin(f(-45))), # 1
(cos(f(45)), -sin(f(45)))],
[(cos(f(45)), -sin(f(45))), # 2
(cos(f(135)), -sin(f(135)))],
[(cos(f(135)), -sin(f(135))), # 3
(cos(f(225)), -sin(f(225)))]]
# Check len
assert len(bin_vecs) == len(chk_bin_vecs)
# Check coords
for i, (chk_vec, vec) in enumerate(zip(chk_bin_vecs, bin_vecs)):
# left vec
assert abs(chk_vec[0][0] - vec[0][0]) < 1e-5, (i, chk_vec[0][0], vec[0][0])
assert abs(chk_vec[0][1] - vec[0][1]) < 1e-5, (i, chk_vec[0][1], vec[0][1])
# right vec
assert abs(chk_vec[1][0] - vec[1][0]) < 1e-5, (i, chk_vec[1][0], vec[1][0])
assert abs(chk_vec[1][1] - vec[1][1]) < 1e-5, (i, chk_vec[1][1], vec[1][1])
def test_xticks_radial():
"""Test polar coordinate array"""
# Testing vals
dir_vals = [0, 0, 0, 10, 85, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
def test_bin_vectors():
"""Bin vectors"""
# Testing vals
dir_vals = [0, 0, 0, 10, 85, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
def test_windrose_mesh_size():
# Testing mesh scaling
dir_vals = [0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
w.legend_parameters.segment_count = 3
# Test the size of the windrose
w = WindRose(dir_data, spd_data, 4)
w.legend_parameters.segment_count = 3
w.show_zeros = False
w.show_freq = True
w.frequency_spacing_distance = 200.0
_ = w.colored_mesh
hdist = w.frequency_spacing_hypot_distance
intervals = w.real_freq_max / w.frequency_hours
assert w.mesh_radius == pytest.approx(intervals * hdist, abs=1e-10)
# Add calmrose
w.show_zeros = True
zero_dist = w._zero_mesh_radius
_ = w.colored_mesh
hdist = w.frequency_spacing_hypot_distance
intervals = w.real_freq_max / w.frequency_hours
assert w.mesh_radius == pytest.approx(zero_dist + (intervals * hdist))
# Test size with windrose from actual epw data
epw_path = os.path.join(os.getcwd(), 'tests/fixtures/epw/chicago.epw')
epw = EPW(epw_path)
w = WindRose(epw.wind_direction, epw.wind_speed, 3)
def test_wind_polygons():
"""Test colors for different windrose types."""
# Testing vals
dir_vals = [0, 0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 310]
spd_vals = [0, 0, 0, 0, 1, 145, 189, 15, 10, 150, 300, 259, 100, 5, 301]
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Bin values to divide into 6 intervals = 10 - 310 = 300 / 6 = 50 m/s
# intervals: [1-50, 51-100, 101-150, 151-200, 201-250, 251-300, 301-350]
#
# [[1], [], [145], [189], [], []], # 0-49, 100-149, 150-199
# [[10, 15], [], [150], [], [], [259, 300]], # 0-49, 150-199,, 250-299
# [[], [100], [], [], [], []], # 100-149
# [[5], [], [], [], [], [301]] # 0-49, 300-349
# Check freq=True, zeros=False
w = WindRose(dir_data, spd_data, 4)
w.show_freq, w.show_zeros = True, False
w.frequency_hours = 2
w.legend_parameters = LegendParameters(segment_count=6)
chk_poly_num = sum([3, 3, 1, 2])
assert chk_poly_num == len(w.windrose_lines)
# For averaged
w.show_freq = False
chk_poly_num = 4
w.colored_mesh
assert chk_poly_num == len(w.windrose_lines)
def test_simple_windrose_mesh():
# Testing vals
dir_vals = [0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 288]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
w.legend_parameters.segment_count = 3
w.show_zeros = False
w.show_freq = False
mesh = w.colored_mesh
assert isinstance(mesh, Mesh2D)
# All true
w = WindRose(dir_data, spd_data, 4)
w.legend_parameters.segment_count = 10
w.show_zeros = True
w.show_freq = True
mesh = w.colored_mesh
assert isinstance(mesh, Mesh2D)
# Init simple dir set divided by 8
w = WindRose(dir_data, spd_data, 4)
w.legend_parameters.segment_count = 3
w.show_zeros = False
w.show_freq = False
mesh = w.colored_mesh
assert isinstance(mesh, Mesh2D)
leap_year = True if dts[0].year % 4 == 0 else False
a_period = AnalysisPeriod(dts[0].month,
dts[0].day,
0,
dts[-1].month,
dts[-1].day,
23,
timestep=timestep,
is_leap_year=leap_year)
return a_period
# data types for the various outputs from OpenDSS
is_over = GenericType('Is Overloaded',
'condition',
unit_descr={
1: 'Overloaded',
0: 'Normal'
})
volt_cond = GenericType('Voltage Condition',
'condition',
unit_descr={
-1: 'Undervoltage',
0: 'Normal',
1: 'Overvoltage'
})
if all_required_inputs(ghenv.Component):
factors, condition = [], []
for result_file in _dss_csv:
# parse the data and figure out the timeseries properties
data = csv_to_matrix(result_file)
def test_color_array():
"""Test colors for different windrose types."""
# Testing vals
dir_vals = [0, 0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 310]
spd_vals = [0, 0, 0, 0, 1, 145, 189, 15, 10, 150, 300, 259, 100, 5, 301]
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
data_step = 50.0
min_val = 1
# Bin values to divide into 6 intervals = 10 - 310 = 300 / 6 = 50 m/s
# intervals: [1-50, 51-100, 101-150, 151-200, 201-250, 251-300, 301-350]
#
# [[1], [], [145], [189], [], [], # 0-49, 100-149, 150-199
# [[10, 15], [], [150], [], [], [259, 300]], # 0-49, 150-199,, 250-299
# [[], [100], [], [], [], []], # 100-149
# [[5], [], [], [], [], [301]] # 0-49, 300-349
# Check freq=True, zeros=False
w = WindRose(dir_data, spd_data, 4)
w.show_freq, w.show_zeros = True, False
w.frequency_hours = 2
w.legend_parameters = LegendParameters(segment_count=7)
w.colored_mesh
# color index corresponds to hourly interval indices
# [1-50, 51-100, 101-150, 151-200, 201-250, 251-300, 301-350]
chk_color_array = [0, 2, 3, 0, 2, 5, 1, 0, 5]
chk_color_array = [(c * data_step) + min_val for c in chk_color_array]
assert len(chk_color_array) == len(w._color_array)
for cc, c in zip(chk_color_array, w._color_array):
assert abs(cc - c) < 1e-10
# Check freq=True, zeros=True
# Modify range for easier calcs
dir_vals = [0, 0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 310]
spd_vals = [0, 0, 0, 0, 1, 145, 189, 15, 10, 149, 299, 259, 99, 5, 300]
zero_spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
zero_dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
zero_data_step = 50
zero_min_val = 0
w = WindRose(zero_dir_data, zero_spd_data, 4)
w.show_freq, w.show_zeros = True, True
w.frequency_hours = 2
w.legend_parameters = LegendParameters(segment_count=7)
w.colored_mesh
# color index corresponds to hourly interval indices
chk_color_array = [1, 3, 4, 1, 3, 6, 2, 1, 6]
chk_color_array = [(c * zero_data_step) + zero_min_val for c in chk_color_array]
chk_color_array += [0, 0, 0, 0]
assert len(chk_color_array) == len(w._color_array)
for cc, c in zip(chk_color_array, w._color_array):
assert abs(cc - c) < 1e-10
# Check freq=False, zeros=False
w = WindRose(dir_data, spd_data, 4)
w.show_freq, w.show_zeros = False, False
w.frequency_hours = 2
w.legend_parameters = LegendParameters(segment_count=7)
w.colored_mesh
# color index corresponds to hourly interval indices
chk_color_array = [111 + 2/3, 146.8, 100, 153]
assert len(chk_color_array) == len(w._color_array)
for cc, c in zip(chk_color_array, w._color_array):
assert abs(cc - c) < 1e-10
# Check freq=False, zeros=True
w = WindRose(dir_data, spd_data, 4)
w.show_freq, w.show_zeros = False, True
w.frequency_hours = 2
w.legend_parameters = LegendParameters(segment_count=7)
w.colored_mesh
# color index corresponds to hourly interval indices
chk_color_array = [111 + 2/3, 146.8, 100, 153]
chk_color_array += [0, 0, 0, 0]
assert len(chk_color_array) == len(w._color_array)
for cc, c in zip(chk_color_array, w._color_array):
assert abs(cc - c) < 1e-10
def test_histogram_data_nested():
# Testing vals
dir_vals = [0, 0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 310]
spd_vals = [0, 0, 0, 0, 1, 145, 189, 15, 10, 150, 299, 259, 100, 5, 301]
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init complex dir set divided by 4, and 2 hourly intervals
w = WindRose(dir_data, spd_data, 4)
w.frequency_hours = 2
w.legend_parameters.segment_count = 7
# Bin values to divide into 6 intervals = 10 - 310 = 300 / 6 = 50 m/s
# intervals: [1-50, 51-100, 101-150, 151-200, 201-250, 251-300, 301-350]
#
# each frequency interval = 1/6 ~ 0.166 of total speed
# 315-45: [1, 145, 189]; 3 bands [0-49, 100-149, 150-199]
# 45-135: [15, 10, 150, 299, 259]; 3 bands, [0-49, 150-199,, 250-299]
# 135-225: [100]; 1 bands, [100-149]
# 225-315: [5, 300]; 2 bands, [0-49, 300, 249]
# interval_num: [3, 3, 1, 2]
chk_histstack = [
[[1], [], [145], [189], [], []], # 0-49, 100-149, 150-199
[[10, 15], [], [150], [], [], [259, 299]], # 0-49, 150-199,, 250-299
[[], [100], [], [], [], []], # 100-149
[[5], [], [], [], [], [301]]] # 0-49, 300-349
# Testing
speeds = [val for bin in w.histogram_data for val in bin]
min_speed, max_speed = min(speeds), max(speeds)
histstack, bins = WindRose._histogram_data_nested(
w.histogram_data, (min_speed, max_speed), w.legend_parameters.segment_count)
# Check
assert len(chk_histstack) == len(histstack)
for cbins, bins in zip(chk_histstack, histstack):
assert len(cbins) == len(bins)
for cbin, bin in zip(cbins, bins):
assert len(cbin) == len(bin)
for cval, val in zip(cbin, bin):
assert abs(cval - val) <= 1e-10, (cval, val)
# Check with zeros
w.show_zeros = True
w.frequency_hours = 1.0
w.frequency_spacing_distance = 25.0
hypot_dist = w.frequency_spacing_hypot_distance
assert abs(w._zero_mesh_radius - hypot_dist) < 1e-10
# Check with zeros 2
# Testing vals
dir_vals = [0, 0, 0, 0, 0, 0, 10, 10, 10, 85, 90, 90, 90, 95, 170, 285, 310]
spd_vals = [0, 0, 0, 0, 0, 0, 1, 145, 189, 15, 10, 150, 299, 259, 100, 5, 301]
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init complex dir set divided by 4, and 2 hourly intervals
w = WindRose(dir_data, spd_data, 4)
w.show_zeros = True
w.frequency_hours = 1.0
w.frequency_spacing_distance = 25.0
hypot_dist = w.frequency_spacing_hypot_distance * 1.5
assert abs(w._zero_mesh_radius - hypot_dist) < 1e-10
if slp_info[0] != '99999':
slp.append(float(slp_info[0]) * 10)
slp_dates.append(date_row)
# parse the sky cover info if it exists
if sc_col is not None and row[sc_col] != '':
sc_info = row[sc_col].split(',')
sc_oktas = int(sc_info[0])
sc_tenths = sc_oktas * (10 / 8) if sc_oktas != 9 else 10
sc.append(sc_tenths)
sc_dates.append(date_row)
# get the most predominant year in the file to make sure all data is for one year
dom_yr = int(max(set(all_years), key=all_years.count))
model_year = build_collection(
all_years, all_dates, GenericType('Years', 'yr'), 'yr', t_offset, dom_yr)
# build data collections from the imported values
dry_bulb_temp = build_collection(
db_t, db_t_dates, DryBulbTemperature(), 'C', t_offset, dom_yr)
dew_point_temp = build_collection(
dp_t, dp_t_dates, DewPointTemperature(), 'C', t_offset, dom_yr)
wind_speed = build_collection(
ws, ws_dates, WindSpeed(), 'm/s', t_offset, dom_yr)
wind_direction = build_collection(
wd, wd_dates, WindDirection(), 'degrees', t_offset, dom_yr)
ceiling_height = build_collection(
ceil, ceil_dates, CeilingHeight(), 'm', t_offset, dom_yr)
visibility = build_collection(
vis, vis_dates, Visibility(), 'km', t_offset, dom_yr)
atmos_pressure = build_collection(
of a Ladybug DataCollection.
"""
ghenv.Component.Name = "LB Construct Data Type"
ghenv.Component.NickName = 'ConstrType'
ghenv.Component.Message = '1.0.0'
ghenv.Component.Category = 'Ladybug'
ghenv.Component.SubCategory = '1 :: Analyze Data'
ghenv.Component.AdditionalHelpFromDocStrings = '1'
try:
from ladybug.datatype.generic import GenericType
except ImportError as e:
raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
try:
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# process the categories_ if they are supplied
unit_descr = None
if categories_ != []:
unit_descr = {}
for prop in categories_:
key, value = prop.split(':')
unit_descr[int(key)] = value.strip()
type = GenericType(_name, _unit, unit_descr=unit_descr)
def test_windrose_frequency_distribution():
"""Test frequency distribution"""
# Testing mesh scaling
dir_vals = [1, 2, 3, 4, 5, 6,
90, 91, 92, 93, 94, 95,
180, 181, 182, 183, 184, 185,
270, 271, 272, 273, 274, 275]
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
w.frequency_hours = 3
assert w.frequency_intervals_mesh == 2
assert w.real_freq_max == 6
assert w.frequency_maximum == 6
freqs = WindRose._histogram_data_nested(w.histogram_data, 3)
north_hbin = freqs[0]
assert north_hbin[0] == 2.0 # [1, 2, 3]
assert north_hbin[1] == 5.0 # [4, 5, 6]
assert north_hbin[0] == sum(w.histogram_data[0][:3]) / 3.0
# Test w/ epw
epw_path = os.path.join(os.getcwd(), 'tests/fixtures/epw/tokyo.epw')
epw = EPW(epw_path)
# Test 16 directions
w = WindRose(epw.wind_direction, epw.wind_speed, 3)
w.show_zeros = False
w.show_freq = True
# w.real_freq_max: 4406
# w.frequency_maximum: 4600
# Test w/ no stacking
w.frequency_hours = 4600 # 1 bin
ytick_num = w.frequency_intervals_mesh
assert ytick_num == 1
freqs = WindRose._histogram_data_nested(w.histogram_data, 4600)
hbin = freqs[0]
test_val = sum(w.histogram_data[0]) / len(w.histogram_data[0])
assert hbin[0] == pytest.approx(test_val, abs=1e-10)
# Test w/ stacking
w.frequency_hours = 5 # 1 bin
h = w.frequency_hours
freqs = WindRose._histogram_data_nested(w.histogram_data, h)
hbin = freqs[0]
sort_hist_bar = sorted(w.histogram_data[0])
test_val = sum(sort_hist_bar[:5]) / 5.0
assert hbin[0] == pytest.approx(test_val, abs=1e-10)
ghenv.Component.Message = '1.5.1'
ghenv.Component.Category = 'Ladybug'
ghenv.Component.SubCategory = '1 :: Analyze Data'
ghenv.Component.AdditionalHelpFromDocStrings = '1'
try:
from ladybug.datatype.generic import GenericType
except ImportError as e:
raise ImportError('\nFailed to import ladybug:\n\t{}'.format(e))
try:
from ladybug_rhino.grasshopper import all_required_inputs
except ImportError as e:
raise ImportError('\nFailed to import ladybug_rhino:\n\t{}'.format(e))
if all_required_inputs(ghenv.Component):
# process the categories_ if they are supplied
unit_descr = None
if categories_ != []:
unit_descr = {}
for prop in categories_:
key, value = prop.split(':')
unit_descr[int(key)] = value.strip()
if cumulative_:
type = GenericType(_name, _unit, unit_descr=unit_descr,
point_in_time=False, cumulative=True)
else:
type = GenericType(_name, _unit, unit_descr=unit_descr)
def test_prevailing_direction():
"""Test prevailing direction getter"""
# Test with single prevailing dir
dir_vals = [
0,
3,
10, # 315 - 45
85,
90,
95, # 45 - 135
140,
170,
170,
170, # 135 - 225
230,
285,
288
] # 225 - 315
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
test_prev_dir = 180
assert w.prevailing_direction[0] == test_prev_dir
# Testing with two max prevailing values
dir_vals = [
3,
3,
10, # 315 - 45
85,
90,
90,
100, # 45 - 135
170,
170,
170,
180, # 135 - 225
230,
285,
288
] # 225 - 315
spd_vals = dir_vals
# Make into fake data collections
a_per = AnalysisPeriod(6, 21, 12, 6, 21, 13)
dates = [DateTime(6, 21, i) for i in range(len(dir_vals))]
spd_header = Header(Speed(), 'm/s', a_per)
dir_header = Header(GenericType('Direction', 'deg'), 'deg', a_per)
spd_data = HourlyDiscontinuousCollection(spd_header, spd_vals, dates)
dir_data = HourlyDiscontinuousCollection(dir_header, dir_vals, dates)
# Init simple dir set divided by 4
w = WindRose(dir_data, spd_data, 4)
test_prev_dir = set((90, 180))
assert set(w.prevailing_direction) == test_prev_dir
# Test with epw
epw_path = os.path.join(os.getcwd(), 'tests/fixtures/epw/chicago.epw')
epw = EPW(epw_path)
# Test 5 directions
w = WindRose(epw.wind_direction, epw.wind_speed, 5)
assert w.prevailing_direction[0] == 216.0
