From 6ba061e11dc45dce43c66096545479280732cfba Mon Sep 17 00:00:00 2001 From: mn3981 Date: Wed, 4 Feb 2026 11:37:02 +0000 Subject: [PATCH 1/6] Add method to calculate D-shaped inboard blanket segment poloidal length --- process/models/blankets/blanket_library.py | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/process/models/blankets/blanket_library.py b/process/models/blankets/blanket_library.py index 857fb6312..c1214183c 100644 --- a/process/models/blankets/blanket_library.py +++ b/process/models/blankets/blanket_library.py @@ -1013,6 +1013,26 @@ def thermo_hydraulic_model_pressure_drop_calculations(self, output: bool): dpres_blkt_outboard_coolant, ] + @staticmethod + def calculate_dshaped_inboard_blkt_segment_poloidal( + dz_blkt_half: float, n_blkt_inboard_modules_poloidal: int + ) -> float: + """Calculations for D-shaped inboard blanket module poloidal segment length + + :param dz_blkt_half: Half-height of the blanket module (m) + :type dz_blkt_half: float + :param n_blkt_inboard_modules_poloidal: Number of inboard blanket modules in poloidal direction + :type n_blkt_inboard_modules_poloidal: int + + :return: Segment length of inboard blanket module in poloidal direction (m) + :rtype: float + + """ + + # D-shaped machine + # Segment vertical inboard surface (m) + return (2.0 * dz_blkt_half) / n_blkt_inboard_modules_poloidal + def blanket_module_poloidal_height(self): """Calculations for blanket module poloidal height From de19334b1fff50ea17a9eccb00dcfe065155134c Mon Sep 17 00:00:00 2001 From: mn3981 Date: Wed, 4 Feb 2026 11:40:42 +0000 Subject: [PATCH 2/6] Add method to calculate D-shaped outboard blanket segment poloidal length --- process/models/blankets/blanket_library.py | 64 ++++++++++++++++++++++ 1 file changed, 64 insertions(+) diff --git a/process/models/blankets/blanket_library.py b/process/models/blankets/blanket_library.py index c1214183c..d3ed67fac 100644 --- a/process/models/blankets/blanket_library.py +++ b/process/models/blankets/blanket_library.py @@ -1033,6 +1033,70 @@ def calculate_dshaped_inboard_blkt_segment_poloidal( # Segment vertical inboard surface (m) return (2.0 * dz_blkt_half) / n_blkt_inboard_modules_poloidal + @staticmethod + def calculate_dshaped_outboard_blkt_segment_poloidal( + n_blkt_outboard_modules_poloidal: int, + dr_fw_plasma_gap_inboard: float, + rminor: float, + dr_fw_plasma_gap_outboard: float, + dz_blkt_half: float, + n_divertors: int, + f_ster_div_single: float, + ) -> float: + """ + Calculations for D-shaped outboard blanket module poloidal segment length + + :param n_blkt_outboard_modules_poloidal: Number of outboard blanket modules in poloidal direction + :type n_blkt_outboard_modules_poloidal: int + :param dr_fw_plasma_gap_inboard: Radial gap between inboard first wall and plasma (m) + :type dr_fw_plasma_gap_inboard: float + :param rminor: Minor radius of the plasma (m) + :type rminor: float + :param dr_fw_plasma_gap_outboard: Radial gap between outboard first wall and plasma (m) + :type dr_fw_plasma_gap_outboard: float + :param dz_blkt_half: Half-height of the blanket module (m) + :type dz_blkt_half: float + :param n_divertors: Number of divertors (1 for single null, 2 for double null) + :type n_divertors: int + :param f_ster_div_single: Fractional poloidal length of the divertor in single null configuration + :type f_ster_div_single: float + + :return: Segment length of outboard blanket module in poloidal direction (m) + :rtype: float + + + """ + + # Calculate perimeter of ellipse that defines the internal + # surface of the outboard first wall / blanket + + # Mid-plane distance from inboard to outboard side (m) + a = dr_fw_plasma_gap_inboard + 2.0 * rminor + dr_fw_plasma_gap_outboard + + # Internal half-height of blanket (m) + b = dz_blkt_half + + # Calculate ellipse circumference using Ramanujan approximation (m) + ptor = np.pi * (3.0 * (a + b) - np.sqrt((3.0 * a + b) * (a + 3.0 * b))) + + # Calculate blanket poloidal length and segment, subtracting divertor length (m) + # kit hcll version only had the single null option + if n_divertors == 2: + # Double null configuration + len_blkt_outboard_segment_poloidal = ( + 0.5 + * ptor + * (1.0 - 2.0 * f_ster_div_single) + / n_blkt_outboard_modules_poloidal + ) + else: + # single null configuration + len_blkt_outboard_segment_poloidal = ( + 0.5 * ptor * (1.0 - f_ster_div_single) / n_blkt_outboard_modules_poloidal + ) + + return len_blkt_outboard_segment_poloidal + def blanket_module_poloidal_height(self): """Calculations for blanket module poloidal height From d531da7c8fa50187ece637f5dbda3604192d8792 Mon Sep 17 00:00:00 2001 From: mn3981 Date: Thu, 5 Feb 2026 09:22:49 +0000 Subject: [PATCH 3/6] Add method to calculate elliptical inboard blanket segment poloidal length --- process/models/blankets/blanket_library.py | 68 ++++++++++++++++++++++ 1 file changed, 68 insertions(+) diff --git a/process/models/blankets/blanket_library.py b/process/models/blankets/blanket_library.py index d3ed67fac..ebc470c59 100644 --- a/process/models/blankets/blanket_library.py +++ b/process/models/blankets/blanket_library.py @@ -1097,6 +1097,74 @@ def calculate_dshaped_outboard_blkt_segment_poloidal( return len_blkt_outboard_segment_poloidal + @staticmethod + def calculate_elliptical_inboard_blkt_segment_poloidal( + rmajor: float, + rminor: float, + triang: float, + dr_fw_plasma_gap_inboard: float, + dz_blkt_half: float, + n_blkt_inboard_modules_poloidal: int, + n_divertors: int, + f_ster_div_single: float, + ) -> float: + """ + Calculations for elliptical inboard blanket module poloidal segment length + + :param rmajor: Major radius of the plasma (m) + :type rmajor: float + :param rminor: Minor radius of the plasma (m) + :type rminor: float + :param triang: Triangularity of the plasma + :type triang: float + :param dr_fw_plasma_gap_inboard: Radial gap between inboard first wall and plasma (m) + :type dr_fw_plasma_gap_inboard: float + :param dz_blkt_half: Half-height of the blanket module (m) + :type dz_blkt_half: float + :param n_blkt_inboard_modules_poloidal: Number of inboard blanket modules in poloidal direction + :type n_blkt_inboard_modules_poloidal: int + :param n_divertors: Number of divertors (1 for single null, 2 for double null) + :type n_divertors: int + :param f_ster_div_single: Fractional poloidal length of the divertor in single null configuration + :type f_ster_div_single: float + + :return: Segment length of inboard blanket module in poloidal direction (m) + :rtype: float + + """ + + # Major radius where half-ellipses 'meet' (m) + r1 = rmajor - rminor * triang + + # Internal half-height of blanket (m) + b = dz_blkt_half + + # Distance between r1 and nearest edge of inboard first wall / blanket (m) + a = r1 - (rmajor - rminor - dr_fw_plasma_gap_inboard) + + # Calculate ellipse circumference using Ramanujan approximation (m) + ptor = np.pi * (3.0 * (a + b) - np.sqrt((3.0 * a + b) * (a + 3.0 * b))) + + # Calculate inboard blanket poloidal length and segment, subtracting divertor length (m) + # Assume divertor lies between the two ellipses, so fraction f_ster_div_single still applies + + # kit hcll version only had the single null option + if n_divertors == 2: + # Double null configuration + len_blkt_inboard_segment_poloidal = ( + 0.5 + * ptor + * (1.0 - 2.0 * f_ster_div_single) + / n_blkt_inboard_modules_poloidal + ) + else: + # single null configuration + len_blkt_inboard_segment_poloidal = ( + 0.5 * ptor * (1.0 - f_ster_div_single) / n_blkt_inboard_modules_poloidal + ) + + return len_blkt_inboard_segment_poloidal + def blanket_module_poloidal_height(self): """Calculations for blanket module poloidal height From daddcdd1cd4e0f70ef2ce481a9880d7060a4e211 Mon Sep 17 00:00:00 2001 From: mn3981 Date: Thu, 5 Feb 2026 09:31:28 +0000 Subject: [PATCH 4/6] Add method to calculate elliptical outboard blanket segment poloidal length --- process/models/blankets/blanket_library.py | 66 ++++++++++++++++++++++ 1 file changed, 66 insertions(+) diff --git a/process/models/blankets/blanket_library.py b/process/models/blankets/blanket_library.py index ebc470c59..bffe8ec6f 100644 --- a/process/models/blankets/blanket_library.py +++ b/process/models/blankets/blanket_library.py @@ -1165,6 +1165,72 @@ def calculate_elliptical_inboard_blkt_segment_poloidal( return len_blkt_inboard_segment_poloidal + @staticmethod + def calculate_elliptical_outboard_blkt_segment_poloidal( + rmajor: float, + rminor: float, + triang: float, + dz_blkt_half: float, + dr_fw_plasma_gap_outboard: float, + n_blkt_outboard_modules_poloidal: int, + n_divertors: int, + f_ster_div_single: float, + ) -> float: + """ + Calculations for elliptical outboard blanket module poloidal segment length + + :param rmajor: Major radius of the plasma (m) + :type rmajor: float + :param rminor: Minor radius of the plasma (m) + :type rminor: float + :param triang: Triangularity of the plasma + :type triang: float + :param dz_blkt_half: Half-height of the blanket module (m) + :type dz_blkt_half: float + :param dr_fw_plasma_gap_outboard: Radial gap between outboard first wall and plasma (m) + :type dr_fw_plasma_gap_outboard: float + :param n_blkt_outboard_modules_poloidal: Number of outboard blanket modules in poloidal direction + :type n_blkt_outboard_modules_poloidal: int + :param n_divertors: Number of divertors (1 for single null, 2 for double null) + :type n_divertors: int + :param f_ster_div_single: Fractional poloidal length of the divertor in single null configuration + :type f_ster_div_single: float + + :return: Segment length of outboard blanket module in poloidal direction (m) + :rtype: float + + + """ + + # Major radius where half-ellipses 'meet' (m) + r1 = rmajor - rminor * triang + + # Internal half-height of blanket (m) + b = dz_blkt_half + + # Distance between r1 and inner edge of outboard first wall / blanket (m) + a = rmajor + rminor + dr_fw_plasma_gap_outboard - r1 + + # Calculate ellipse circumference using Ramanujan approximation (m) + ptor = np.pi * (3.0 * (a + b) - np.sqrt((3.0 * a + b) * (a + 3.0 * b))) + + # kit hcll version only had the single null option + # Calculate outboard blanket poloidal length and segment, subtracting divertor length (m) + if n_divertors == 2: + # Double null configuration + len_blkt_outboard_segment_poloidal = ( + 0.5 + * ptor + * (1.0 - 2.0 * f_ster_div_single) + / n_blkt_outboard_modules_poloidal + ) + else: + # single null configuration + len_blkt_outboard_segment_poloidal = ( + 0.5 * ptor * (1.0 - f_ster_div_single) / n_blkt_outboard_modules_poloidal + ) + return len_blkt_outboard_segment_poloidal + def blanket_module_poloidal_height(self): """Calculations for blanket module poloidal height From c7cab13679bee14b44702519def939fc39fc32fb Mon Sep 17 00:00:00 2001 From: mn3981 Date: Thu, 5 Feb 2026 09:55:26 +0000 Subject: [PATCH 5/6] Refactor blanket module poloidal height calculations to support D-shaped and elliptical configurations --- process/models/blankets/blanket_library.py | 39 ++++++++++++++++++++-- 1 file changed, 37 insertions(+), 2 deletions(-) diff --git a/process/models/blankets/blanket_library.py b/process/models/blankets/blanket_library.py index bffe8ec6f..12e06b8c4 100644 --- a/process/models/blankets/blanket_library.py +++ b/process/models/blankets/blanket_library.py @@ -478,8 +478,43 @@ def set_blanket_module_geometry(self): fwbs_variables.n_blkt_inboard_modules_poloidal = 1 fwbs_variables.n_blkt_outboard_modules_poloidal = 1 - # Calculate poloidal height of blanket modules - self.blanket_module_poloidal_height() + if physics_variables.itart == 1 or fwbs_variables.i_fw_blkt_vv_shape == 1: + blanket_library.len_blkt_inboard_segment_poloidal = self.calculate_dshaped_inboard_blkt_segment_poloidal( + dz_blkt_half=blanket_library.dz_blkt_half, + n_blkt_inboard_modules_poloidal=fwbs_variables.n_blkt_inboard_modules_poloidal, + ) + + blanket_library.len_blkt_outboard_segment_poloidal = self.calculate_dshaped_outboard_blkt_segment_poloidal( + n_blkt_outboard_modules_poloidal=fwbs_variables.n_blkt_outboard_modules_poloidal, + dr_fw_plasma_gap_inboard=build_variables.dr_fw_plasma_gap_inboard, + rminor=physics_variables.rminor, + dr_fw_plasma_gap_outboard=build_variables.dr_fw_plasma_gap_outboard, + dz_blkt_half=blanket_library.dz_blkt_half, + n_divertors=divertor_variables.n_divertors, + f_ster_div_single=fwbs_variables.f_ster_div_single, + ) + else: + blanket_library.len_blkt_inboard_segment_poloidal = self.calculate_elliptical_inboard_blkt_segment_poloidal( + rmajor=physics_variables.rmajor, + rminor=physics_variables.rminor, + triang=physics_variables.triang, + dr_fw_plasma_gap_inboard=build_variables.dr_fw_plasma_gap_inboard, + dz_blkt_half=blanket_library.dz_blkt_half, + n_blkt_inboard_modules_poloidal=fwbs_variables.n_blkt_inboard_modules_poloidal, + n_divertors=divertor_variables.n_divertors, + f_ster_div_single=fwbs_variables.f_ster_div_single, + ) + + blanket_library.len_blkt_outboard_segment_poloidal = self.calculate_elliptical_outboard_blkt_segment_poloidal( + rmajor=physics_variables.rmajor, + rminor=physics_variables.rminor, + triang=physics_variables.triang, + dz_blkt_half=blanket_library.dz_blkt_half, + dr_fw_plasma_gap_outboard=build_variables.dr_fw_plasma_gap_outboard, + n_blkt_outboard_modules_poloidal=fwbs_variables.n_blkt_outboard_modules_poloidal, + n_divertors=divertor_variables.n_divertors, + f_ster_div_single=fwbs_variables.f_ster_div_single, + ) # If liquid breeder or dual coolant blanket then calculate if fwbs_variables.i_blkt_dual_coolant > 0: From 11d343ca6e35425dd252890aeb52253f3c49e77d Mon Sep 17 00:00:00 2001 From: mn3981 Date: Sat, 21 Feb 2026 15:29:48 +0000 Subject: [PATCH 6/6] Add tests for D-shaped and elliptical blanket segment poloidal length calculations --- process/models/blankets/blanket_library.py | 120 ---------- tests/unit/test_blanket_library.py | 246 ++++++++++++--------- 2 files changed, 139 insertions(+), 227 deletions(-) diff --git a/process/models/blankets/blanket_library.py b/process/models/blankets/blanket_library.py index 12e06b8c4..7d1bfcb7e 100644 --- a/process/models/blankets/blanket_library.py +++ b/process/models/blankets/blanket_library.py @@ -1266,126 +1266,6 @@ def calculate_elliptical_outboard_blkt_segment_poloidal( ) return len_blkt_outboard_segment_poloidal - def blanket_module_poloidal_height(self): - """Calculations for blanket module poloidal height - - Calculations for blanket module poloidal height for D shaped and elliptical machines - """ - if ( - physics_variables.itart == 1 or fwbs_variables.i_fw_blkt_vv_shape == 1 - ): # D-shaped machine - # Segment vertical inboard surface (m) - blanket_library.len_blkt_inboard_segment_poloidal = ( - 2.0 * blanket_library.dz_blkt_half - ) / fwbs_variables.n_blkt_inboard_modules_poloidal - - # Calculate perimeter of ellipse that defines the internal - # surface of the outboard first wall / blanket - - # Mid-plane distance from inboard to outboard side (m) - a = ( - build_variables.dr_fw_plasma_gap_inboard - + 2.0 * physics_variables.rminor - + build_variables.dr_fw_plasma_gap_outboard - ) - - # Internal half-height of blanket (m) - b = blanket_library.dz_blkt_half - - # Calculate ellipse circumference using Ramanujan approximation (m) - ptor = np.pi * (3.0 * (a + b) - np.sqrt((3.0 * a + b) * (a + 3.0 * b))) - - # Calculate blanket poloidal length and segment, subtracting divertor length (m) - # kit hcll version only had the single null option - if divertor_variables.n_divertors == 2: - # Double null configuration - blanket_library.len_blkt_outboard_segment_poloidal = ( - 0.5 - * ptor - * (1.0 - 2.0 * fwbs_variables.f_ster_div_single) - / fwbs_variables.n_blkt_outboard_modules_poloidal - ) - else: - # single null configuration - blanket_library.len_blkt_outboard_segment_poloidal = ( - 0.5 - * ptor - * (1.0 - fwbs_variables.f_ster_div_single) - / fwbs_variables.n_blkt_outboard_modules_poloidal - ) - - # shape defined by two half-ellipses - else: - # Major radius where half-ellipses 'meet' (m) - r1 = ( - physics_variables.rmajor - - physics_variables.rminor * physics_variables.triang - ) - - # Internal half-height of blanket (m) - b = blanket_library.dz_blkt_half - - # Distance between r1 and nearest edge of inboard first wall / blanket (m) - a = r1 - ( - physics_variables.rmajor - - physics_variables.rminor - - build_variables.dr_fw_plasma_gap_inboard - ) - - # Calculate ellipse circumference using Ramanujan approximation (m) - ptor = np.pi * (3.0 * (a + b) - np.sqrt((3.0 * a + b) * (a + 3.0 * b))) - - # Calculate inboard blanket poloidal length and segment, subtracting divertor length (m) - # Assume divertor lies between the two ellipses, so fraction f_ster_div_single still applies - - # kit hcll version only had the single null option - if divertor_variables.n_divertors == 2: - # Double null configuration - blanket_library.len_blkt_inboard_segment_poloidal = ( - 0.5 - * ptor - * (1.0 - 2.0 * fwbs_variables.f_ster_div_single) - / fwbs_variables.n_blkt_inboard_modules_poloidal - ) - else: - # single null configuration - blanket_library.len_blkt_inboard_segment_poloidal = ( - 0.5 - * ptor - * (1.0 - fwbs_variables.f_ster_div_single) - / fwbs_variables.n_blkt_inboard_modules_poloidal - ) - - # Distance between r1 and inner edge of outboard first wall / blanket (m) - a = ( - physics_variables.rmajor - + physics_variables.rminor - + build_variables.dr_fw_plasma_gap_outboard - - r1 - ) - - # Calculate ellipse circumference using Ramanujan approximation (m) - ptor = np.pi * (3.0 * (a + b) - np.sqrt((3.0 * a + b) * (a + 3.0 * b))) - - # kit hcll version only had the single null option - # Calculate outboard blanket poloidal length and segment, subtracting divertor length (m) - if divertor_variables.n_divertors == 2: - # Double null configuration - blanket_library.len_blkt_outboard_segment_poloidal = ( - 0.5 - * ptor - * (1.0 - 2.0 * fwbs_variables.f_ster_div_single) - / fwbs_variables.n_blkt_outboard_modules_poloidal - ) - else: - # single null configuration - blanket_library.len_blkt_outboard_segment_poloidal = ( - 0.5 - * ptor - * (1.0 - fwbs_variables.f_ster_div_single) - / fwbs_variables.n_blkt_outboard_modules_poloidal - ) - def liquid_breeder_properties(self, output: bool = False): """Calculates the fluid properties of the Liquid Metal Breeder/Coolant in the Blanket BZ Uses middle value of input and output temperatures of Liquid Metal Breeder/Coolant diff --git a/tests/unit/test_blanket_library.py b/tests/unit/test_blanket_library.py index 118e01b77..abbca9fdc 100644 --- a/tests/unit/test_blanket_library.py +++ b/tests/unit/test_blanket_library.py @@ -1125,138 +1125,170 @@ def test_apply_coverage_factors( ) -class BlanketModPolHeightParam(NamedTuple): - dr_fw_plasma_gap_inboard: Any = None - dr_fw_plasma_gap_outboard: Any = None - i_fw_blkt_vv_shape: Any = None +class DshapedInboardBlktSegmentParam(NamedTuple): + dz_blkt_half: Any = None n_blkt_inboard_modules_poloidal: Any = None - f_ster_div_single: Any = None + expected_len_blkt_inboard_segment_poloidal: Any = None + + +@pytest.mark.parametrize( + "dshaped_inboard_param", + ( + DshapedInboardBlktSegmentParam( + dz_blkt_half=8.25, + n_blkt_inboard_modules_poloidal=7, + expected_len_blkt_inboard_segment_poloidal=2.3571428571428572, + ), + ), +) +def test_calculate_dshaped_inboard_blkt_segment_poloidal( + dshaped_inboard_param, blanket_library_fixture +): + """Test for calculate_dshaped_inboard_blkt_segment_poloidal.""" + result = blanket_library_fixture.calculate_dshaped_inboard_blkt_segment_poloidal( + dz_blkt_half=dshaped_inboard_param.dz_blkt_half, + n_blkt_inboard_modules_poloidal=dshaped_inboard_param.n_blkt_inboard_modules_poloidal, + ) + assert result == pytest.approx( + dshaped_inboard_param.expected_len_blkt_inboard_segment_poloidal + ) + + +class DshapedOutboardBlktSegmentParam(NamedTuple): n_blkt_outboard_modules_poloidal: Any = None - itart: Any = None + dr_fw_plasma_gap_inboard: Any = None rminor: Any = None - n_divertors: Any = None - rmajor: Any = None - triang: Any = None - len_blkt_inboard_segment_poloidal: Any = None - len_blkt_outboard_segment_poloidal: Any = None + dr_fw_plasma_gap_outboard: Any = None dz_blkt_half: Any = None - expected_len_blkt_inboard_segment_poloidal: Any = None + n_divertors: Any = None + f_ster_div_single: Any = None expected_len_blkt_outboard_segment_poloidal: Any = None @pytest.mark.parametrize( - "blanketmodpolheightparam", + "dshaped_outboard_param", ( - BlanketModPolHeightParam( - dr_fw_plasma_gap_inboard=0.25, - dr_fw_plasma_gap_outboard=0.25, - i_fw_blkt_vv_shape=2, - n_blkt_inboard_modules_poloidal=7, - f_ster_div_single=0.115, + DshapedOutboardBlktSegmentParam( n_blkt_outboard_modules_poloidal=8, - itart=0, - rminor=2.6666666666666665, - n_divertors=1, - rmajor=8, - triang=0.5, - len_blkt_inboard_segment_poloidal=0, - len_blkt_outboard_segment_poloidal=0, - dz_blkt_half=5.9532752487304119, - expected_len_blkt_inboard_segment_poloidal=1.6252823720672551, - expected_len_blkt_outboard_segment_poloidal=1.7853902013340495, - ), - BlanketModPolHeightParam( dr_fw_plasma_gap_inboard=0.10000000000000001, - dr_fw_plasma_gap_outboard=0.10000000000000001, - i_fw_blkt_vv_shape=1, - n_blkt_inboard_modules_poloidal=7, - f_ster_div_single=0.115, - n_blkt_outboard_modules_poloidal=8, - itart=1, rminor=2.5, - n_divertors=2, - rmajor=4.5, - triang=0.5, - len_blkt_inboard_segment_poloidal=0, - len_blkt_outboard_segment_poloidal=0, + dr_fw_plasma_gap_outboard=0.10000000000000001, dz_blkt_half=8.25, - expected_len_blkt_inboard_segment_poloidal=2.3571428571428572, + n_divertors=2, + f_ster_div_single=0.115, expected_len_blkt_outboard_segment_poloidal=2.0597205347177807, ), ), ) -def test_blanket_mod_pol_height( - blanketmodpolheightparam, - monkeypatch, - blanket_library_fixture, +def test_calculate_dshaped_outboard_blkt_segment_poloidal( + dshaped_outboard_param, blanket_library_fixture ): - """ - Automatically generated Regression Unit Test for blanket_mod_pol_height. + """Test for calculate_dshaped_outboard_blkt_segment_poloidal.""" + result = blanket_library_fixture.calculate_dshaped_outboard_blkt_segment_poloidal( + n_blkt_outboard_modules_poloidal=dshaped_outboard_param.n_blkt_outboard_modules_poloidal, + dr_fw_plasma_gap_inboard=dshaped_outboard_param.dr_fw_plasma_gap_inboard, + rminor=dshaped_outboard_param.rminor, + dr_fw_plasma_gap_outboard=dshaped_outboard_param.dr_fw_plasma_gap_outboard, + dz_blkt_half=dshaped_outboard_param.dz_blkt_half, + n_divertors=dshaped_outboard_param.n_divertors, + f_ster_div_single=dshaped_outboard_param.f_ster_div_single, + ) + assert result == pytest.approx( + dshaped_outboard_param.expected_len_blkt_outboard_segment_poloidal + ) - This test was generated using data from blanket_files/large_tokamak_primary_pumping2.IN.DAT. - :param blanketmodpolheightparam: the data used to mock and assert in this test. - :type blanketmodpolheightparam: blanketmodpolheightparam +class EllipticalInboardBlktSegmentParam(NamedTuple): + rmajor: Any = None + rminor: Any = None + triang: Any = None + dr_fw_plasma_gap_inboard: Any = None + dz_blkt_half: Any = None + n_blkt_inboard_modules_poloidal: Any = None + n_divertors: Any = None + f_ster_div_single: Any = None + expected_len_blkt_inboard_segment_poloidal: Any = None - :param monkeypatch: pytest fixture used to mock module/class variables - :type monkeypatch: _pytest.monkeypatch.monkeypatch - """ - monkeypatch.setattr( - build_variables, - "dr_fw_plasma_gap_inboard", - blanketmodpolheightparam.dr_fw_plasma_gap_inboard, - ) - monkeypatch.setattr( - build_variables, - "dr_fw_plasma_gap_outboard", - blanketmodpolheightparam.dr_fw_plasma_gap_outboard, - ) - monkeypatch.setattr( - fwbs_variables, - "i_fw_blkt_vv_shape", - blanketmodpolheightparam.i_fw_blkt_vv_shape, - ) - monkeypatch.setattr( - fwbs_variables, - "n_blkt_inboard_modules_poloidal", - blanketmodpolheightparam.n_blkt_inboard_modules_poloidal, - ) - monkeypatch.setattr( - fwbs_variables, "f_ster_div_single", blanketmodpolheightparam.f_ster_div_single - ) - monkeypatch.setattr( - fwbs_variables, - "n_blkt_outboard_modules_poloidal", - blanketmodpolheightparam.n_blkt_outboard_modules_poloidal, - ) - monkeypatch.setattr(physics_variables, "itart", blanketmodpolheightparam.itart) - monkeypatch.setattr(physics_variables, "rminor", blanketmodpolheightparam.rminor) - monkeypatch.setattr( - divertor_variables, "n_divertors", blanketmodpolheightparam.n_divertors - ) - monkeypatch.setattr(physics_variables, "rmajor", blanketmodpolheightparam.rmajor) - monkeypatch.setattr(physics_variables, "triang", blanketmodpolheightparam.triang) - monkeypatch.setattr( - blanket_library, - "len_blkt_inboard_segment_poloidal", - blanketmodpolheightparam.len_blkt_inboard_segment_poloidal, - ) - monkeypatch.setattr( - blanket_library, - "len_blkt_outboard_segment_poloidal", - blanketmodpolheightparam.len_blkt_outboard_segment_poloidal, + +@pytest.mark.parametrize( + "elliptical_inboard_param", + ( + EllipticalInboardBlktSegmentParam( + rmajor=8, + rminor=2.6666666666666665, + triang=0.5, + dr_fw_plasma_gap_inboard=0.25, + dz_blkt_half=5.9532752487304119, + n_blkt_inboard_modules_poloidal=7, + n_divertors=1, + f_ster_div_single=0.115, + expected_len_blkt_inboard_segment_poloidal=1.6252823720672551, + ), + ), +) +def test_calculate_elliptical_inboard_blkt_segment_poloidal( + elliptical_inboard_param, blanket_library_fixture +): + """Test for calculate_elliptical_inboard_blkt_segment_poloidal.""" + result = blanket_library_fixture.calculate_elliptical_inboard_blkt_segment_poloidal( + rmajor=elliptical_inboard_param.rmajor, + rminor=elliptical_inboard_param.rminor, + triang=elliptical_inboard_param.triang, + dr_fw_plasma_gap_inboard=elliptical_inboard_param.dr_fw_plasma_gap_inboard, + dz_blkt_half=elliptical_inboard_param.dz_blkt_half, + n_blkt_inboard_modules_poloidal=elliptical_inboard_param.n_blkt_inboard_modules_poloidal, + n_divertors=elliptical_inboard_param.n_divertors, + f_ster_div_single=elliptical_inboard_param.f_ster_div_single, ) - monkeypatch.setattr( - blanket_library, "dz_blkt_half", blanketmodpolheightparam.dz_blkt_half + assert result == pytest.approx( + elliptical_inboard_param.expected_len_blkt_inboard_segment_poloidal ) - blanket_library_fixture.blanket_module_poloidal_height() - assert blanket_library.len_blkt_inboard_segment_poloidal == pytest.approx( - blanketmodpolheightparam.expected_len_blkt_inboard_segment_poloidal - ) - assert blanket_library.len_blkt_outboard_segment_poloidal == pytest.approx( - blanketmodpolheightparam.expected_len_blkt_outboard_segment_poloidal +class EllipticalOutboardBlktSegmentParam(NamedTuple): + rmajor: Any = None + rminor: Any = None + triang: Any = None + dz_blkt_half: Any = None + dr_fw_plasma_gap_outboard: Any = None + n_blkt_outboard_modules_poloidal: Any = None + n_divertors: Any = None + f_ster_div_single: Any = None + expected_len_blkt_outboard_segment_poloidal: Any = None + + +@pytest.mark.parametrize( + "elliptical_outboard_param", + ( + EllipticalOutboardBlktSegmentParam( + rmajor=8, + rminor=2.6666666666666665, + triang=0.5, + dz_blkt_half=5.9532752487304119, + dr_fw_plasma_gap_outboard=0.25, + n_blkt_outboard_modules_poloidal=8, + n_divertors=1, + f_ster_div_single=0.115, + expected_len_blkt_outboard_segment_poloidal=1.7853902013340495, + ), + ), +) +def test_calculate_elliptical_outboard_blkt_segment_poloidal( + elliptical_outboard_param, blanket_library_fixture +): + """Test for calculate_elliptical_outboard_blkt_segment_poloidal.""" + result = blanket_library_fixture.calculate_elliptical_outboard_blkt_segment_poloidal( + rmajor=elliptical_outboard_param.rmajor, + rminor=elliptical_outboard_param.rminor, + triang=elliptical_outboard_param.triang, + dz_blkt_half=elliptical_outboard_param.dz_blkt_half, + dr_fw_plasma_gap_outboard=elliptical_outboard_param.dr_fw_plasma_gap_outboard, + n_blkt_outboard_modules_poloidal=elliptical_outboard_param.n_blkt_outboard_modules_poloidal, + n_divertors=elliptical_outboard_param.n_divertors, + f_ster_div_single=elliptical_outboard_param.f_ster_div_single, + ) + assert result == pytest.approx( + elliptical_outboard_param.expected_len_blkt_outboard_segment_poloidal )