def test_link_hot_sensible_segments(self):
hot_segments = [make_segment(80, 120, 80), make_segment(120, 80, 20)]
cascade = HeatCascade()
cascade.add_segments(*hot_segments)
self.assertEqual(cascade.intervals, [make_segment(200, 20, 120)])
self.assertEqual(cascade.net_heat_flow(), 200)
self.assertEqual(cascade.cumulative_heat_flow(), ([0, 200], [20, 120]))
def test_make_stream(self):
from_init = Stream(make_segment(-320, 20, 100, 5))
from_make = make_stream(-320, 20, 100, 5)
self.assertEqual(from_init.segments, from_make.segments)
from_init = Stream(make_segment(-400, 100, 100))
from_make = make_stream(-400, 100, 100)
self.assertEqual(from_init.segments, from_make.segments)
def test_neutralized_heat_flow(self):
neutralizing_segments = [
make_segment(-60, 60, 120),
make_segment(60, 120, 60)
]
cascade = HeatCascade()
cascade.add_segments(*neutralizing_segments)
self.assertEqual(cascade.intervals, [])
self.assertEqual(cascade.net_heat_flow(), 0)
self.assertEqual(cascade.cumulative_heat_flow(), ([], []))
def test_hot_sensible_segment(self):
hot_segment = make_segment(180, 150, 50)
cascade = HeatCascade()
cascade.add_segments(hot_segment)
self.assertEqual(cascade.intervals, [make_segment(180, 50, 150)])
self.assertEqual(cascade.net_heat_flow(), 180)
self.assertEqual(cascade.cumulative_heat_flow(), ([0, 180], [50, 150]))
self.assertEqual(cascade.net_heat_flow(), 180)
self.assertEqual(cascade.cumulative_heat_flow(-180),
([-180, 0], [50, 150]))
def test_add_cascades(self):
cold_cascade = HeatCascade()
cold_cascade.add_segments(make_segment(-230, 25, 140))
cold_cascade.add_segments(make_segment(-240, 85, 145))
hot_cascade = HeatCascade()
hot_cascade.add_segments(make_segment(330, 165, 55))
hot_cascade.add_segments(make_segment(180, 145, 25))
mixed_cascade = HeatCascade()
mixed_cascade.add_segments(*cold_cascade.intervals)
mixed_cascade.add_segments(*hot_cascade.intervals)
self.assertEqual(
mixed_cascade.intervals,
[
make_segment(-15, 25, 55),
make_segment(75, 55, 85),
make_segment(-82.5, 85, 140),
make_segment(2.5, 140, 145),
make_segment(60, 145, 165),
],
)
self.assertEqual(mixed_cascade.net_heat_flow(), 40)
self.assertEqual(
mixed_cascade.cumulative_heat_flow(),
([0, -15, 60, -22.5, -20, 40], [25, 55, 85, 140, 145, 165]),
)
self.assertEqual(
mixed_cascade.cumulative_heat_flow(22.5),
([22.5, 7.5, 82.5, 0, 2.5, 62.5], [25, 55, 85, 140, 145, 165]),
)
def test_detached_segments(self):
detached_segments = [
make_segment(-30, 20, 50),
make_segment(-80, 80, 120)
]
cascade = HeatCascade()
cascade.add_segments(*detached_segments)
self.assertEqual(cascade.intervals, detached_segments)
self.assertEqual(cascade.net_heat_flow(), -110)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, -30, -30, -110], [20, 50, 80, 120]))
def test_equality_comparison(self):
cascade = HeatCascade()
self.assertEqual(cascade, HeatCascade())
compare_to = HeatCascade()
compare_to.add_segments(make_segment(-230, 25, 140),
make_segment(-240, 85, 145))
self.assertNotEqual(cascade, compare_to)
cascade.add_segments(make_segment(-230, 25, 140))
self.assertNotEqual(cascade, compare_to)
cascade.add_segments(make_segment(-240, 85, 145))
self.assertEqual(cascade, compare_to)
def test_detached_latent_segments(self):
latent_segments = [
make_segment(-200, 100, 100),
make_segment(-150, 200, 200)
]
cascade = HeatCascade()
cascade.add_segments(*latent_segments)
self.assertEqual(cascade.intervals, latent_segments)
self.assertEqual(cascade.net_heat_flow(), -350)
self.assertEqual(
cascade.cumulative_heat_flow(),
([0, -200, -200, -350], [100, 100, 200, 200]),
)
def test_link_latent_segments(self):
latent_segments = [
make_segment(-200, 100, 100),
make_segment(-150, 100, 100),
make_segment(250, 100, 100),
]
expected_intervals = [make_segment(-100, 100, 100)]
cascade = HeatCascade()
cascade.add_segments(*latent_segments)
self.assertEqual(cascade.intervals, expected_intervals)
self.assertEqual(cascade.net_heat_flow(), -100)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, -100], [100, 100]))
def test_overlapping_hot_segments(self):
hot_segments = [make_segment(60, 120, 60), make_segment(130, 85, 20)]
expected_intervals = [
make_segment(80, 20, 60),
make_segment(75, 60, 85),
make_segment(35, 85, 120),
]
cascade = HeatCascade()
cascade.add_segments(*hot_segments)
self.assertEqual(cascade.intervals, expected_intervals)
self.assertEqual(cascade.net_heat_flow(), 190)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, 80, 155, 190], [20, 60, 85, 120]))
def test_temperature_mismatch(self):
mismatch_first = [make_segment(-150, 50, 200), *self.cold_segments]
with self.assertRaises(ValueError):
Stream(*mismatch_first)
mismatch_middle = self.cold_segments
mismatch_middle[1] = make_segment(-120, 400, 400)
with self.assertRaises(ValueError):
Stream(*mismatch_middle)
mismatch_last = [*self.cold_segments, make_segment(-150, 50, 200)]
with self.assertRaises(ValueError):
Stream(*mismatch_last)
def test_add_latent_then_sensible_segment(self):
latent_then_sensible = HeatCascade()
latent_then_sensible.add_segments(make_segment(-200, 100, 100),
make_segment(-80, 80, 120))
expected_intervals = [
make_segment(-40, 80, 100),
make_segment(-200, 100, 100),
make_segment(-40, 100, 120),
]
self.assertEqual(latent_then_sensible.intervals, expected_intervals)
self.assertEqual(latent_then_sensible.net_heat_flow(), -280)
self.assertEqual(
latent_then_sensible.cumulative_heat_flow(),
([0, -40, -240, -280], [80, 100, 100, 120]),
)
def test_overlapping_cold_segments(self):
cold_segments = [
make_segment(-65, 20, 85),
make_segment(-120, 60, 120)
]
expected_intervals = [
make_segment(-40, 20, 60),
make_segment(-75, 60, 85),
make_segment(-70, 85, 120),
]
cascade = HeatCascade()
cascade.add_segments(*cold_segments)
self.assertEqual(cascade.intervals, expected_intervals)
self.assertEqual(cascade.net_heat_flow(), -185)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, -40, -115, -185], [20, 60, 85, 120]))
def test_neutral_latent_segment(self):
neutral_segment = make_segment(0, 80, 80)
cascade = HeatCascade()
cascade.add_segments(neutral_segment)
self.assertEqual(cascade.intervals, [])
self.assertEqual(cascade.net_heat_flow(), 0)
self.assertEqual(cascade.cumulative_heat_flow(), ([], []))
self.assertEqual(cascade.cumulative_heat_flow(-100), ([], []))
def make_segmented_stream(*segments):
"""
Convenience function to create a segmented stream. Each argument represents
one segment. It must have the following form:
[heat_flow, supply_temp, target_temp, temp_shift=None]
"""
from pina.segments import make_segment
return Stream(*(make_segment(*s) for s in segments))
def test_hot_latent_segment(self):
hot_segment = make_segment(300, 150, 150)
cascade = HeatCascade()
cascade.add_segments(hot_segment)
self.assertEqual(cascade.intervals, [hot_segment])
self.assertEqual(cascade.net_heat_flow(), 300)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, 300], [150, 150]))
self.assertEqual(cascade.cumulative_heat_flow(100),
([100, 400], [150, 150]))
def test_cold_sensible_segment(self):
cold_segment = make_segment(-180, 20, 200)
cascade = HeatCascade()
cascade.add_segments(cold_segment)
self.assertEqual(cascade.intervals, [cold_segment])
self.assertEqual(cascade.net_heat_flow(), -180)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, -180], [20, 200]))
self.assertEqual(cascade.cumulative_heat_flow(50),
([50, -130], [20, 200]))
def test_cold_latent_segment(self):
cold_segment = make_segment(-200, 100, 100)
cascade = HeatCascade()
cascade.add_segments(cold_segment)
self.assertEqual(cascade.intervals, [cold_segment])
self.assertEqual(cascade.net_heat_flow(), -200)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, -200], [100, 100]))
self.assertEqual(cascade.cumulative_heat_flow(-50),
([-50, -250], [100, 100]))
def setUp(self):
self.cold_segments = [
make_segment(-320, 20, 100),
make_segment(-400, 100, 100),
make_segment(-150, 100, 250),
make_segment(-195, 250, 380),
]
self.hot_segments = [
make_segment(300, 250, 100),
make_segment(300, 100, 100),
make_segment(125, 100, 50),
]
self.mixed_segments = [
make_segment(-320, 20, 100),
make_segment(320, 100, 20)
]
self.single_sensible_segment = Stream(*self.cold_segments[:1])
self.single_latent_segment = Stream(*self.hot_segments[1:2])
self.cold_stream = Stream(*self.cold_segments)
self.hot_stream = Stream(*self.hot_segments)
self.neutral_stream = Stream(*self.mixed_segments)
def test_mixed_sensible_segments(self):
mixed_segments = [
make_segment(-60, 60, 120),
make_segment(-10, 60, 70),
make_segment(130, 85, 20),
]
expected_intervals = [
make_segment(80, 20, 60),
make_segment(15, 70, 85),
make_segment(-35, 85, 120),
]
cascade = HeatCascade()
cascade.add_segments(*mixed_segments)
self.assertEqual(cascade.intervals, expected_intervals)
self.assertEqual(cascade.net_heat_flow(), 60)
self.assertEqual(cascade.cumulative_heat_flow(),
([0, 80, 80, 95, 60], [20, 60, 70, 85, 120]))
def test_touching_segments(self):
cold_segments = [make_segment(-60, 20, 80), make_segment(-80, 80, 120)]
cold_cascade = HeatCascade()
cold_cascade.add_segments(*cold_segments)
self.assertEqual(cold_cascade.intervals, cold_segments)
self.assertEqual(cold_cascade.net_heat_flow(), -140)
self.assertEqual(cold_cascade.cumulative_heat_flow(),
([0, -60, -140], [20, 80, 120]))
hot_segments = [make_segment(80, 120, 80), make_segment(60, 80, 20)]
hot_cascade = HeatCascade()
hot_cascade.add_segments(*hot_segments)
self.assertEqual(hot_cascade.intervals,
[make_segment(60, 20, 80),
make_segment(80, 80, 120)])
self.assertEqual(hot_cascade.net_heat_flow(), 140)
self.assertEqual(hot_cascade.cumulative_heat_flow(),
([0, 60, 140], [20, 80, 120]))
def test_make_segmented_stream(self):
from_init = Stream(
make_segment(-320, 20, 100, 5),
make_segment(-400, 100, 100),
make_segment(0, 100, 100, 10),
make_segment(400, 100, 0),
make_segment(300, 0, 0),
make_segment(0, 0, -20),
)
from_make = make_segmented_stream(
[-320, 20, 100, 5],
[-400, 100, 100],
[0, 100, 100, 10],
[400, 100, 0],
[300, 0, 0],
[0, 0, -20],
)
self.assertEqual(from_init.segments, from_make.segments)
def test_segments_by_type(self):
test_segments = [
make_segment(-320, 20, 100),
make_segment(-400, 100, 100),
make_segment(0, 100, 100),
make_segment(400, 100, 0),
make_segment(300, 0, 0),
make_segment(0, 0, -20),
]
stream = Stream(*test_segments)
self.assertEqual(stream.segments, test_segments)
self.assertEqual(
stream.neutral_segments,
[make_segment(0, 100, 100),
make_segment(0, 0, -20)],
)
self.assertEqual(
stream.cold_segments,
[make_segment(-320, 20, 100),
make_segment(-400, 100, 100)],
)
self.assertEqual(stream.hot_segments,
[make_segment(400, 100, 0),
make_segment(300, 0, 0)])
def test_new_latent_segment(self):
self.assertEqual(make_segment(-200, 100, 100), LatentSegment(-200, 100, None))
self.assertEqual(make_segment(150, 80, 80), LatentSegment(150, 80, None))
def test_new_latent_segment_with_temp_shift(self):
self.assertEqual(make_segment(-200, 100, 100, 10), LatentSegment(-200, 100, 10))
self.assertEqual(make_segment(150, 80, 80, 10), LatentSegment(150, 80, 10))
def test_new_sensible_segment(self):
self.assertEqual(make_segment(-150, 20, 80), SensibleSegment(2.5, 20, 80, None))
self.assertEqual(make_segment(150, 100, 50), SensibleSegment(3, 100, 50, None))
def test_new_sensible_segment_with_temp_shift(self):
self.assertEqual(make_segment(-150, 20, 80, 5), SensibleSegment(2.5, 20, 80, 5))
self.assertEqual(make_segment(150, 100, 50, 5), SensibleSegment(3, 100, 50, 5))
