Source code for gtsimulation.common.regions

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