PyGAS/physicshelper.py at master · wenatuhs/PyGAS · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
import numpy as np
import scipy.constants as const

REST_ENERGY = const.m_e * const.c ** 2 / const.e * 1e-6  # 0.511 MeV


def freq2prd(f):
    """ Change frequency to time period.

    Keyword arguments:
    f -- frequency. [MHz]

    Returns:
    p -- time period. [ps]
    """
    p = 1e6 / f

    return p


def freq2lamb(f):
    """ Change frequency to wave length.

    Keyword arguments:
    f -- frequency. [MHz]

    Returns:
    lamb -- wave length. [mm]
    """
    lamb = 1e-3 * const.c / f

    return lamb


def lamb2en(lamb):
    """ Change wave length to energy.

    Keyword arguments:
    lamb -- wave length. [nm]

    Returns:
    energy -- energy. [eV]
    """
    energy = const.h * const.c / (lamb * 1e-9) / const.e

    return energy


def en2lamb(hv):
    """ Change photon energy to wavelength.

    Keyword arguments:
    hv -- photon energy. [eV]

    Returns:
    lamb -- wavelength. [nm]
    """
    lamb = const.h * const.c / (hv * 1e-9) / const.e

    return lamb


def time2len(t, beta):
    """ Change time length of the beam to spatial length.

    Keyword arguments:
    t -- time length. [ps]
    beta -- average relative velocity.

    Returns:
    z -- spatial length. [µm]
    """
    z = beta * const.c * t * 1e-6

    return z


def ek2gamma(ek):
    """ Convert Ekin to gamma.

    Keyword arguments:
    ek -- Ekin. [MeV]

    Returns:
    gamma -- relative energy.
    """
    return 1 + ek / REST_ENERGY


def beta2gamma(beta):
    """ Convert beta to gamma.

    Keyword arguments:
    beta -- relative velocity.

    Returns:
    gamma -- relative energy.
    """
    return 1 / np.sqrt(1 - beta ** 2)


def gamma2beta(gamma):
    """ Convert gamma to beta.

    Keyword arguments:
    gamma -- relative energy.

    Returns:
    beta -- relative velocity.
    """
    return np.sqrt(1 - 1 / gamma ** 2)