import numpy as np
from enum import Enum
from abc import ABC, abstractmethod
from numba import jit
from pyproj import Transformer
from gtsimulation.particle import CRParticle, Flux
from gtsimulation.particle.generator import distribution, spectrum
from ._consts import Units
class _AbsRegion(ABC):
SaveAdd = dict()
calc_additional = False
@staticmethod
def transform(x, y, z, name):
return x, y, z
@classmethod
def set_params(cls, CalcAdditionalEnergy=False):
cls.calc_additional = CalcAdditionalEnergy
@staticmethod
@abstractmethod
def checkSave(*args, **kwargs):
pass
@classmethod
def CalcAdditional(cls):
return False
@staticmethod
def AdditionalEnergyLosses(r, v, T, M, dt, frwd_tracing, c, ToMeters):
return v, T
@classmethod
def ret_str(cls):
return "\t\tAdditional Energy Losses: False"
@staticmethod
def do_before_loop(*args, **kwargs):
pass
@staticmethod
def do_after_step(simulator,
i, guiding_center,
lon_total, lon_prev, full_revolutions,
max_rev_enabled):
return lon_total, lon_prev, full_revolutions
@staticmethod
def do_after_loop(simulator, result, lon_total, max_rev_enabled):
pass
@staticmethod
def configure_break_conditions(break_conditions, track_params, logger=None):
return break_conditions
class _Undefined(_AbsRegion):
@staticmethod
def additions(*args, **kwargs):
pass
@staticmethod
def checkSave(*args, **kwargs):
pass
class _Heliosphere(_AbsRegion):
@staticmethod
def additions(*args, **kwargs):
pass
@classmethod
def CalcAdditional(cls):
return cls.calc_additional
@staticmethod
@jit(fastmath=True, nopython=True)
def AdditionalEnergyLosses(r, v, T, M, dt, frwd_tracing, c):
r = r / 149.597870700e9 # meters to au
R = np.sqrt(r[0] ** 2 + r[1] ** 2 + r[2] ** 2)
theta = np.arccos(r[2] / R)
div_wind = 2 / R * (300 + 475 * (1 - np.sin(theta) ** 8)) / 149.597870700e6 # km/s to au/s
dE = dt * T / 3 * div_wind * (T + 2 * M) / (T + M)
T -= frwd_tracing * dE
V = c * np.sqrt((T + M) ** 2 - M ** 2) / (T + M)
Vn = np.linalg.norm(v)
v *= V / Vn
return v, T
@classmethod
def ret_str(cls):
return f"\t\tAdditional Energy Losses: {cls.calc_additional}"
class _Galaxy(_AbsRegion):
@staticmethod
def additions(*args, **kwargs):
pass
class _Magnetosphere(_AbsRegion):
SaveAdd = {"Invariants": False, "PitchAngles": False, "MirrorPoints": False, "Lshell": False,
"GuidingCenter": False}
@staticmethod
def configure_break_conditions(break_conditions, track_params, logger=None):
if not (isinstance(track_params, dict) or track_params):
return break_conditions
if break_conditions is None:
break_conditions = {}
if isinstance(break_conditions, list):
radial_conditions = break_conditions[0].copy()
_Magnetosphere._set_minimum_radius(radial_conditions, logger)
return [radial_conditions, break_conditions[1]]
if isinstance(break_conditions, dict):
break_conditions = break_conditions.copy()
_Magnetosphere._set_minimum_radius(break_conditions, logger)
return break_conditions
@staticmethod
def _set_minimum_radius(break_conditions, logger):
if "Rmin" not in break_conditions:
break_conditions["Rmin"] = Units.RE
if logger is not None:
logger.info(
"\t\tTrack parameters require 'Rmin' break condition; setting it to 1 RE (%g m)",
Units.RE,
)
elif break_conditions["Rmin"] < Units.RE:
if logger is not None:
logger.warning(
"\t\t'Rmin' break condition is below 1 RE; using Rmin=%g m",
Units.RE,
)
break_conditions["Rmin"] = Units.RE
@staticmethod
def do_after_step(simulator, i, guiding_center,
lon_total, lon_prev, full_revolutions,
max_rev_enabled):
if not (simulator.ParticleOriginIsOn or max_rev_enabled):
return lon_total, lon_prev, full_revolutions
from gtsimulation.magnetic_field.magnetosphere import Additions
from gtsimulation.magnetic_field.magnetosphere.Functions import transformations
a_, b_, _ = transformations.geo2mag_eccentric(
guiding_center[0][0],
guiding_center[0][1],
guiding_center[0][2],
simulator.Bfield.g,
simulator.Bfield.h,
)
return Additions.AddLon(
lon_total, lon_prev, full_revolutions, i,
np.array([[a_]]),
np.array([[b_]]),
)
@staticmethod
def do_after_loop(simulator, result, lon_total, max_rev_enabled):
from gtsimulation.magnetic_field.magnetosphere import Additions
if simulator.TrackParamsIsOn:
simulator.logger.debug("Calculating additional parameters ...")
track_params = Additions.GetTrackParams(simulator, result)
if simulator.ParticleOriginIsOn or max_rev_enabled:
track_params["LonTotal"] = lon_total
result["Additions"] = track_params
if simulator.ParticleOriginIsOn and simulator.IsFirstRun:
simulator.logger.debug("Finding particle origin ...")
origin = Additions.FindParticleOrigin(simulator, result)
result["Additions"]["ParticleOrigin"] = origin
simulator.logger.debug("Particle origin: %s", origin.name)
@staticmethod
def transform(x, y, z, name):
if name == 'LLA':
# x = lat, y = long, z = altitude
# units = Units.RE2m or Units.km2m
# TODO make more rigorous after units addition in the GT
transformer = Transformer.from_crs({"proj": 'latlong', "ellps": 'WGS84', "datum": 'WGS84'},
{"proj": 'geocent', "ellps": 'WGS84', "datum": 'WGS84'})
# Matlab lla2ecef([lat, long, altitude]) -> python transformer.transform(long, lat, altitude, radians=False)
x, y, z = transformer.transform(y, x, z, radians=False)
# x, y, z = x/units, y/units, z/units
return x, y, z
@staticmethod
def checkSave(Simulator, Nsave):
Nsave_check = (Simulator.TrackParamsIsOn * Simulator.IsFirstRun * Simulator.TrackParams["GuidingCenter"] * (
Nsave != 1))
assert Nsave_check != 1, "To calculate all additions correctly 'Nsave' parameter must be equal to 1"
@staticmethod
def do_before_loop(simulator, gen, prod_tracks):
if simulator.nuclear_interaction is not None and gen > 1:
particle = simulator.Particles[simulator.index]
r = np.array(particle.coordinates)
V_normalized = np.array(particle.velocities)
T = particle.T
geo_to_lla = Transformer.from_crs({"proj": 'geocent', "ellps": 'WGS84', "datum": 'WGS84'},
{"proj": 'latlong', "ellps": 'WGS84', "datum": 'WGS84'})
lon, lat, alt = geo_to_lla.transform(r[0], r[1], r[2], radians=False)
angle = np.arccos(np.dot(-V_normalized, r / np.linalg.norm(r))) / np.pi * 180
if 0 < alt < simulator.nuclear_interaction.atmosphere_height and angle < 70:
primary, secondary = simulator.nuclear_interaction.run_atmosphere(particle.PDG, T, r, V_normalized, simulator.Date)
simulator.IsPrimDeath = True
if secondary.size > 0 and gen < simulator.nuclear_interaction.max_generations:
for p in secondary:
params = simulator.ParamDict.copy()
params["Particles"] = Flux(
Distribution=distribution.UserInput(R0=p['Position'], V0=p['MomentumDirection']),
Spectrum=spectrum.UserInput(energy=p['KineticEnergy']),
PDGcode=p["PDGcode"]
)
if p["PDGcode"] in [12, 14, 16, 18, -12, -14, -16, -18]:
params["Medium"] = None
params["InteractNUC"] = None
new_process = simulator.__class__(**params)
new_process._GTSimulator__gen = gen + 1
track = new_process.CallOneFile()[0]
track["Particle"]["R0"] = p['VertexPosition']
track["Particle"]["V0"] = p['VertexMomentumDirection']
track["Particle"]["T0"] = p['VertexKineticEnergy']
prod_tracks.append(track)
[docs]
class Regions(Enum):
Magnetosphere = _Magnetosphere
Heliosphere = _Heliosphere
Galaxy = _Galaxy
Undefined = _Undefined