径向网格构建

代码逻辑

输入：re平衡距离，rmin_obs，rmax_obs(转折点数据)，r_ab(数据点)
收集所有的侯选位置
计算观察到的最小和最大距离
计算边界(带padding)
如果观察数据不足，使用保守地默认边界
使用np.linspace创建均匀的网格
计算网格距离dr
返回：RadialGrid(r_grid,dr,r_lo,r_hi)

定义数据类RadialGrid

python 复制代码

@dataclass(frozen=True)
class RadialGrid:
    """Container for a uniformly spaced radial grid."""

    r_grid: np.ndarray
    dr: float # 网格间距
    r_lo: float # 网格最小值
    r_hi: float # 网格最大值

@dataclass ：装饰器，自动生成__init__, __repr__, __eq__等方法。 frozen=True : 使数据类不可变（创建后不能修改属性）

*装饰器详解

装饰器是Python中的一种设计模式，用于在不修改函数/类原始代码的情况下，为其添加额外功能。

@dataclass 是python3.7引入的标准库装饰器，用于自动为类生成常用方法

python 复制代码

from dataclasses import dataclass
@dataclass
class Person:
	name: str
	age: int
	city: str
#使用
p1 = Person("Zhang",23,"Beijing")
print(p1.name)
print(p1)

"""
如果不用装饰器的等价写法
"""
class Person: 
	# 1. 初始化方法，创建对象时自动调用
	def __init__(self, name:str,age:int,city:str):
		self.name = name
		self.age = age
		self.city = city
	
	# 2. 返回对象的字符串表示(用于调试）
	def __repr__(self):
		return f"Person(name = {self.name!r},age={self.age~r},city={self.city!r})"
	
	#3. 定义相等性比较(==运算符)
	def __eq__(self,other):
		#检车other是否是Pserson类型
		if not isinstance(other,Person):
		return NotImplemented # 返回NotImplemented 让Python 尝试 other.__eq__(self)
		
		#比较所有属性是否相等
		return(self.name==other.name and self.age == other.age and self.city == other.city)


# 使用方式完全相同
p1 = Person("张三", 25, "北京")
print(p1.name)  # 张三
print(p1)       # Person(name='张三', age=25, city='北京')

# 测试相等性比较
p2 = Person("张三", 25, "北京")
p3 = Person("李四", 30, "上海")
print(p1 == p2)  # True
print(p1 == p3)  # False

构建径向网格的方法

python 复制代码

def build_radial_grid(
    re: float,
    rmin_obs: Iterable[float] | None = None, # - Iterable[float] : 可迭代的浮点数序列（列表、数组等）
																				 #- | None : 可以是 None
																				 #- = None : 默认值为 None
    rmax_obs: Iterable[float] | None = None,
    r_ab: Iterable[float] | None = None,
    nr: int = 512,												 # 默认网格数 512
    padding_fraction: float = 0.08,				 # 在观测数据范围外添加额外空间
    min_left_fraction: float = 0.45,				 # 左边界的保守下限（平衡距离的35%）
    max_right_factor: float = 3.5,					 # 右边界的保守上限（平衡距离的4倍）
) -> RadialGrid:
    
    if nr < 2:
        raise ValueError("nr must be at least 2.")
    if not np.isfinite(re) or re <= 0.0:
        raise ValueError(f"re must be a positive finite value, got {re!r}.")
    if padding_fraction < 0.0:
        raise ValueError("padding_fraction must be non-negative.")

    candidates = [float(re)]														#创建列表，目前只有一个元素是平衡位置
    candidates.extend(_finite_positive_values(rmin_obs))		#将可迭代对象的元素添加到列表末尾
    candidates.extend(_finite_positive_values(rmax_obs))
    candidates.extend(_finite_positive_values(r_ab))

    observed_min = min(candidates)
    observed_max = max(candidates)
    span = max(observed_max - observed_min, re)
    pad = padding_fraction * span

    fallback_lo = min_left_fraction * re
    fallback_hi = max_right_factor * re
    r_lo = min(observed_min - pad, fallback_lo)
    r_hi = max(observed_max + pad, fallback_hi)

    r_lo = max(r_lo, 1.0e-6)
    if r_hi <= r_lo:
        raise ValueError(f"Invalid radial grid bounds: r_lo={r_lo}, r_hi={r_hi}.")

    r_grid = np.linspace(r_lo, r_hi, nr, dtype=np.float64)
    dr = float(r_grid[1] - r_grid[0])
    return RadialGrid(r_grid=r_grid, dr=dr, r_lo=float(r_lo), r_hi=float(r_hi))