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