},
"active": "04094233c3d02ad2",
"lastOpenFiles": [
+ "Nebulous Command/calc.py~",
+ "Nebulous Command/calc.py",
+ "Nebulous Command/Notes on Mechanics.md~",
"List of things to do.md",
"Nebulous Command/Notes on Mechanics.md",
"Nebulous Command/ANS/My Fleets/ANS Dedicated/Battle Report 1.md",
"University/Algorithm Design/Full Notes - Run 2.md",
"Pasted image 20251207164533.png",
"Daily/16-01-2025.md",
- "Dead Poet's Society/Some Notes.md",
"Bundesverfassungsgericht/Urteil_des_Ersten_Senats_vom_5_November_2019.pdf",
"Poems that I like",
- "Robert's Opsec Policy",
"Pasted image 20251106230015.png",
"Pasted image 20251106225651.png",
"Pasted image 20251106225645.png",
"Pasted image 20251106224445.png",
"Pasted image 20251106224411.png",
"Pasted image 20251106224329.png",
- "Pasted image 20251106223635.png",
- "Diary and thoughts"
+ "Pasted image 20251106223635.png"
]
}
\ No newline at end of file
+Why does this document exist? Basically I just wanna explore what is the best way to build a solid _combat_ fleet in Nebulous. I.e. capable of winning fair 3000 point on 3000 point 1v1s, and perhapsperforming supporting roles in a match.
+
+
+for all of this, btw, i am using the "hoodedhorse" version of the wiki, at least for the initial research
+
+# E-War
+
+the first thing that I want to deal with is ewar, as in Nebulous the concept of seeing first, or being seen first can do a lot to make a difference in a battle. At what range your missiles are detected, or can be intercepted.
+If the person is able to find the launch platform, providing intel for your carriers, all that kinda stuff and as far as I am aware the two main mechanics on this are _comms_ and _radar_.
+
+## Cross-sections
+The cross sections of different ships
+| Ship | Cross Section (m^2) | -10% | -25% | -35% |
+| -------------------- | ------------------- | -------- | -------- | -------- |
+| Sprinter (Corvette) | 2890 | 2601 | 2167.5 | 1878.5 |
+| Raines (FF) | 3783 | 3404.7 | 2837.25 | 2458.95 |
+| Keystone (DD) | 6281 | 5652.9 | 4710.75 | 4082.65 |
+| Vauxhall (CL) | 11727 | 10554.30 | 8795.25 | 7622.55 |
+| Axford (HC) | 14332 | 12898.80 | 10749.00 | 9315.80 |
+| Solomon (BB) | 27876 | 25088.40 | 20907.00 | 18119.40 |
+| Ferryman (Corvette) | 2890 | 2601 | 2167.5 | 1878.5 |
+| Draugr (FF) | 4685 | 4216.50 | 3513.75 | 3045.25 |
+| Flathead (DD) | 9869 | 8882.10 | 7401.75 | 6414.85 |
+| Ocello (HC) | 15745 | 14170.50 | 11808.75 | 10234.25 |
+| Marauder (BB) | 15745 | 14170.50 | 11808.75 | 10234.25 |
+| Moorline (BB) | 15745 | 14170.50 | 11808.75 | 10234.25 |
+
+
+Turning off the radar: -25% signature
+Turning comms to RECEIVE: -10% signature
+(in the table Im assuming that this basically results in a total 35% reduction, if both are combined)
+
+Radars have factors:
+
+Radiated Power $P_t$
+Gain $G$
+Aperture Size $A$
+Sensitivitry $S$
+Noise Filtering $v$
+and for fire control radars: minimum signal-to-noise, $SNR$
+
+
+(there is a weird note at the top of the document, it reads: "The units are omitted here; use the values as you see them in-game, except divide the radar signature (cross-section) by 10) - check this, this may be outdated.
+
+Given the Radar Cross Section (RCS) of a ship $\sigma$ at distance $d$, the reutrned power density $P_r$ is calculated using
+
+$$P_r = \frac{\left ( \frac{P_tG\sigma A}{4\pi d^2}\right )G}{4\pi d^2}=\frac{P_tG^2\sigma A}{16\pi^2d^4}$$
+Burn through: $P_t$ = $P_t * \text{Burn-Through Power Multiplier}$
+Check every frame for new targets. Update and Recalc. every 0.25 seconds.
+
+also is according to the formula P_r in kWdB? weird unit but aight. probably works into noise calculations or something
+
+i also assume here that distances is in meters (see the code I guess for why this is semi importa,t but that is the main way the units cancel out like that which would also make sense to me)
+
+Some stats for the relevant radars on these things:
+
+| Radar | Radiated Power (kW) | Gain (dB) | Aperture Size (m^2) | Sensitivity (dBm) | Noise Filtering (dB) | Min. Signal to Noise | BRN Multiplier | Max. Range (km) |
+| --------------- | ------------------- | --------- | ------------------- | ----------------- | -------------------- | -------------------- | -------------- | --------------- |
+| RF101 | 1500 | 80 | 20 | - | 0 | - | - | 9 |
+| RM50 | 4100 | 50 | 30 | -38.5 | 0 | - | 12 | 9.5 |
+| RS35 | 3500 | 40 | 25 | -36 | 0 | - | 8 | 8 |
+| RS41 | 4500 | 60 | 40 | -38.5 | 0 | - | - | 11.5 |
+| R400 LRT | 5000 | 70 | 100 | -38 | 0 | - | - | 14 |
+| R550 EWR | 3500 | 50 | 250 | -36 | 0 | - | - | 18 |
+| RF44 | 1500 | 60 | 40 | - | 0 | - | - | 6.5 |
+| Bulwak Huntress | 4000 | 40 | 60 | -38 | 0 | - | 4 | 10 |
+| Ithaca | 3100 | 40 | 60 | -34 | 0 | - | - | 8.5 |
+(do note that not all radars can lock targets)
+
+Make sure not to forget the existence of the neb calculator in this folder
+
+## noise
+
+Effective radar range is often limited by noise. Wow.
+Return power vs. Background noise:
+Background noise 1 x 10^-7
+if the return power is less than that, the target is not seen. Noise filtering doesn't reduce this.
+
+It also has to be able to distinguish real signals from jamming
+
+the noise this adds to the radar (at the effective jamming power at that distance for the ship + for every jammer added up - we call that $J$ here.)
+the felt noise is:
+$$N=(1\times10^{-7}+JG)\times10^{v/10}$$
+
+Search Radars need higher return power than the felt noise $P_r > N$ to see targets. If the return signal from the target also beats signal loss, the target is seen and a track appears.
+
+Fire Control Radars (FCRs) require a higher siganl return power than noise ratio (SNR) than the min. required SNR to lock $$10\log_{10}\left(\frac{P_r}{N}\right)>SNR$$
+FCRs are not restricted by background noise floors so noise filtering will reduce background noise for locking and increase range. Wow.
+
+## signal loss
+search radarsalso need enough sensitivity (S) to distinguish targets and beat signal loss in order to see them
+Signal loss is calculated from return power
+$$S_L=10\log_{10}\left(\frac{P_r}{0.001}\right)$$
+If the sensitivty is less than signal loss $S < S_L$ then the target is seen.
+
+therefore max benefit is at -40dB, as at that point background noise becomes the limiting factor.
+FCR has no sensitivity stat, therefore not affected by signal loss. Cool.
+
+you can lock multiple missiles if you have multiple fcrs. locks function mostlyl ike regular traacks. Can only lock max. 1 ship though.
+
+
+
--- /dev/null
+from dataclasses import dataclass
+import math
+# Data / Data-Sheets basically
+# --- ships ---
+
+padding = 16
+
+
+@dataclass
+class Ship:
+ name: str
+ rcs_m2: float
+
+
+ships = [
+ Ship("Sprinter", 2601),
+ Ship("Raines", 3783),
+ Ship("Keystone", 6281),
+ Ship("Vauxhall", 11727),
+ Ship("Axford", 14332),
+ Ship("Solomon", 27876),
+ Ship("Ferryman", 2601),
+ Ship("Draugr", 4685),
+ Ship("Flathead", 9869),
+ Ship("Ocello", 15745),
+ Ship("Marauder", 15745),
+ Ship("Moorline", 15745)
+]
+
+
+@dataclass
+class Radar:
+ name: str
+ radiated_power_kw: int
+ gain_db: int
+ aperture_size_m2: int
+ sensitivity_dBm: float
+ noise_filtering_dB: int
+ burnthrough_multiplier: int
+ max_range_km: float
+
+
+# for Return Power Density Calculations
+radars = [
+ Radar("RF101", 1500, 80, 20, 0, 0, 0, 9),
+ Radar("RM50", 4100, 50, 30, -38.5, 0, 12, 9.5),
+ Radar("RS35", 3500, 40, 25, -36, 0, 8, 8),
+ Radar("RS41", 4500, 60, 40, -38.5, 0, 0, 11.5),
+ Radar("R400", 5000, 70, 100, -38, 0, 0, 14),
+ Radar("R550", 3500, 50, 250, -36, 0, 0, 18),
+ Radar("RF44", 1500, 60, 40, 0, 0, 0, 6.5),
+ Radar("Bulwark Huntress", 4000, 40, 60, -38, 0, 4, 10),
+ Radar("Ithaca", 3100, 40, 60, -34, 0, 4, 8.5),
+]
+
+
+def select_ship() -> Ship:
+ print("Select the index of the ship you want")
+ for i, ship in enumerate(ships):
+ print(f"{i+1}: {ship.name}")
+ i = int(input(":"))
+ return ships[i - 1]
+
+
+def select_radar() -> Radar:
+ print("Select the index of the radar you want")
+ for i, radar in enumerate(radars):
+ print(f"{i+1}: {radar.name}")
+ i = int(input(":"))
+ return radars[i - 1]
+
+
+def calculate_raw_return_power(
+ radiated_power, gain, rcs, aperture_size, distance):
+ top_half = radiated_power * (gain ** 2) * (rcs / 10) * aperture_size
+ bottom_half = 16 * (math.pi ** 2) * (distance ** 4)
+
+ return top_half / bottom_half
+
+
+def calc_rpd():
+ default_distances = [500, 2000, 5000, 8000, 10000]
+ s = select_ship()
+ r = select_radar()
+
+ d = int(input("Select a specific distance you want to calculate for: "))
+
+ # the formula for the return power density:
+ # will be dividing rcs by 10, according to the one note
+ print(f"Return power at distances for {s.name} using {r.name}")
+ for distance in default_distances:
+ print(f"""{str(calculate_raw_return_power(
+ r.radiated_power_kw, r.gain_db, s.rcs_m2,
+ r.aperture_size_m2, distance
+ )).ljust(padding)} | {distance}""")
+
+ print(f"""{str(calculate_raw_return_power(
+ r.radiated_power_kw, r.gain_db, s.rcs_m2,
+ r.aperture_size_m2, d
+ )).ljust(padding)} | {d}""")
+
+
+def calculate_distance_noise_floor_radar(radiated_power, gain, rcs, aperture_size):
+ top_half = radiated_power * (gain ** 2) * (rcs / 10) * aperture_size
+ bottom_half = (1 * (10 ** -7) * 16 * (math.pi ** 2))
+ return ((top_half / bottom_half) ** 0.25)
+
+
+def calculate_distance_signal_loss_floor_radar(radiated_power, gain, rcs, aperture_size, sensitivity):
+ if sensitivity == 0:
+ return 0
+
+ alpha = (10 ** (sensitivity / 10)) / 1000
+
+ top_half = radiated_power * (gain ** 2) * (rcs / 10) * aperture_size
+ bottom_half = 16 * (math.pi ** 2) * alpha
+ return (top_half / bottom_half) ** 0.25
+
+
+def calculate_distance_hidden():
+ # we want to calculate the distance at which
+ # we will be hidden from an enemy ships
+ # that is using a certain radar. Assuming no jamming and no burn throughs.
+ s = select_ship()
+ r = select_radar()
+
+ rcs_modifiers = [1, 0.9, 0.75, 0.65]
+
+ print(f"The noise floor distance for {s.name} using {r.name}")
+ for m in rcs_modifiers:
+ print(f"""{
+ calculate_distance_noise_floor_radar(
+ r.radiated_power_kw, r.gain_db, s.rcs_m2 * m,
+ r.aperture_size_m2
+ ):.2f}m with rcs modifier: {m}""")
+
+ print(f"The sensitivity distance floor for {s.name} using {r.name}")
+ for m in rcs_modifiers:
+ print(f"""{
+ calculate_distance_signal_loss_floor_radar(
+ r.radiated_power_kw, r.gain_db, s.rcs_m2 * m,
+ r.aperture_size_m2, r.sensitivity_dBm
+ ):.2f}m with rcs modifier: {m}""")
+
+
+def print_options():
+ for i, o in enumerate(options):
+ print(f"{i+1}: {o[0]}")
+
+
+options = [
+ ["Calculate Return Power Density for Ship and Radar", calc_rpd],
+ ["Calculate the distance at which the ship should be hidden",
+ calculate_distance_hidden]
+]
+
+
+def main():
+ # find out what the person wants to calculate, then call that
+ print_options()
+ i = int(input(":"))
+ options[i - 1][1]()
+
+
+if __name__ == "__main__":
+ main()
projects / research-obsidian.git / commitdiff