pytwinnet.physics

class pytwinnet.physics.Environment(dimensions_m=(100.0, 100.0, 30.0), obstacles=<factory>)

Bases: object

Parameters:

• dimensions_m (Tuple[float, float, float])

• obstacles (List[object])

dimensions_m: Tuple[float, float, float] = (100.0, 100.0, 30.0)

is_within_bounds(position)

Return type:

bool

Parameters:

position (Tuple[float, float, float])

obstacles: List[object]

class pytwinnet.physics.FadedModel(base, kind='rayleigh', K_dB=6.0, seed=0, epoch=None)

Bases: PropagationModel

Wraps a base model and adds small-scale fading (Rayleigh or Rician) as an extra dB term: PL_faded = PL + fading_loss_db where fading_loss_db = -10*log10(|h|^2). Fading is deterministic per (tx, rx, epoch). Change ‘epoch’ to re-sample.

Parameters:

• base (PropagationModel)

• kind (str)

• K_dB (float)

• seed (int)

• epoch (int | None)

K_dB: float = 6.0

base: PropagationModel

calculate_path_loss(tx, rx, environment)

Return type:

float

Parameters:

• tx (WirelessNode)

• rx (WirelessNode)

• environment (Environment)

epoch: Optional[int] = None

kind: str = 'rayleigh'

seed: int = 0

set_epoch(epoch)

Return type:

None

Parameters:

epoch (int | None)

class pytwinnet.physics.FreeSpacePathLoss

Bases: PropagationModel

calculate_path_loss(tx, rx, environment)

Return type:

float

Parameters:

• tx (WirelessNode)

• rx (WirelessNode)

• environment (Environment)

faded_shadowed_model(freq_ghz, tx_power_dbm, n=2.0, sigma=6.0)

Log-distance with lognormal shadowing + Rayleigh fading; returns Rx power (dBm).

Return type:

float

Parameters:

• d (float)

• freq_ghz (float)

• tx_power_dbm (float)

• n (float)

• sigma (float)

class pytwinnet.physics.PropagationModel

Bases: ABC

abstractmethod calculate_path_loss(tx, rx, environment)

Return type:

float

Parameters:

• tx (WirelessNode)

• rx (WirelessNode)

• environment (Environment)

class pytwinnet.physics.RISAugmentedModel(base, ris, extra_loss_db=3.0)

Bases: PropagationModel

Wrap a base PropagationModel and return the min of: - direct path loss - two-hop path loss via RIS: PL(tx->RIS) + PL(RIS->rx) - RIS_gain + extra_loss

Parameters:

• base (PropagationModel)

• ris (RISPanel)

• extra_loss_db (float)

calculate_path_loss(tx, rx, environment)

Return type:

float

Parameters:

• tx (WirelessNode)

• rx (WirelessNode)

• environment (Environment)

class pytwinnet.physics.RISBeamModel(base, ris, extra_loss_db=3.0)

Bases: PropagationModel

Wraps a base PropagationModel. For a configured target UE (by id), the RIS contributes mainlobe gain on the two-hop path; others see sidelobe gain. Effective path loss = min( direct, (tx->RIS + RIS->rx - gain + extra_loss_db) ).

Parameters:

• base (PropagationModel)

• ris (SmartRISPanel)

• extra_loss_db (float)

calculate_path_loss(tx, rx, environment)

Return type:

float

Parameters:

• tx (WirelessNode)

• rx (WirelessNode)

• environment (Environment)

set_beam(rx_node_id)

Point mainlobe toward rx_node_id (or None for no specific target).

Return type:

None

Parameters:

rx_node_id (str | None)

class pytwinnet.physics.RISPanel(position, gain_db=10.0)

Bases: object

Parameters:

• position (Tuple[float, float, float])

• gain_db (float)

gain_db: float = 10.0

position: Tuple[float, float, float]

class pytwinnet.physics.ShadowedModel(base, sigma_db=6.0, seed=0, epoch=None)

Bases: PropagationModel

Wraps a base propagation model and adds log-normal shadowing (Gaussian in dB). Shadowing is deterministic per (tx, rx, epoch) for reproducibility. Change ‘epoch’ (int) to refresh the samples (e.g., per-drop or per-time-slot).

Parameters:

• base (PropagationModel)

• sigma_db (float)

• seed (int)

• epoch (int | None)

base: PropagationModel

calculate_path_loss(tx, rx, environment)

Return type:

float

Parameters:

• tx (WirelessNode)

• rx (WirelessNode)

• environment (Environment)

epoch: Optional[int] = None

seed: int = 0

set_epoch(epoch)

Return type:

None

Parameters:

epoch (int | None)

sigma_db: float = 6.0

class pytwinnet.physics.SmartRISPanel(position, element_count=64, mainlobe_gain_db=None, sidelobe_gain_db=None)

Bases: object

Toy RIS with a steerable mainlobe. Approximates array gain:

mainlobe_gain_db ~= 20*log10(N) sidelobe_gain_db ~= mainlobe - 13 dB (typical)

Parameters:

• position (Tuple[float, float, float])

• element_count (int)

• mainlobe_gain_db (float | None)

• sidelobe_gain_db (float | None)

element_count: int = 64

mainlobe_gain_db: Optional[float] = None

position: Tuple[float, float, float]

sidelobe_gain_db: Optional[float] = None

pytwinnet.physics.calculate_noise_power(bw_hz, noise_figure_db=7.0)

Return type:

float

Parameters:

• bw_hz (float)

• noise_figure_db (float)

pytwinnet.physics.calculate_sinr_db(signal_dbm, interference_dbm_list, noise_dbm)

Return type:

float

Parameters:

• signal_dbm (float)

• noise_dbm (float)

pytwinnet.physics.noise_power_dbm(temperature_k, bandwidth_hz, noise_figure_db=0.0)

Return type:

float

Parameters:

• temperature_k (float)

• bandwidth_hz (float)

• noise_figure_db (float)

pytwinnet.physics.rx_power_dbm(tx_power_dbm, tx_gain_dbi, rx_gain_dbi, path_loss_db)

Return type:

float

Parameters:

• tx_power_dbm (float)

• tx_gain_dbi (float)

• rx_gain_dbi (float)

• path_loss_db (float)

pytwinnet.physics.shannon_capacity(sinr_db, bw_hz, efficiency=0.75)

Return type:

float

Parameters:

• sinr_db (float)

• bw_hz (float)

• efficiency (float)

pytwinnet.physics.shannon_throughput_bps(bandwidth_hz, sinr_db_value, efficiency=1.0)

Return type:

float

Parameters:

• bandwidth_hz (float)

• sinr_db_value (float)

• efficiency (float)

pytwinnet.physics.sinr_db(signal_dbm, interferers_dbm=None, noise_dbm=-100.0)

Return type:

float

Parameters:

• signal_dbm (float)

• interferers_dbm (Iterable[float] | None)

• noise_dbm (float)

Modules

batch
environment
fading
link_budget
propagation
ris
ris_beam
signal	Signal utilities for examples: noise power, SINR, Shannon capacity.