Toolkit/unit_conversions.py at main · jackstrophysics/Toolkit · 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
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np


def cel_to_K(x):
    '''Convert Celsius to Kelvin'''
    if type(x) is np.ndarray:
        if x.any() < -273.15:
            raise ValueError('Cannot have temperature lower than -273.15 Celsius!')
    if type(x) in [int, float, np.int64, np.float64] and x < -273.15:
        raise ValueError('Cannot have temperature lower than -273.15 Celsius!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x + 273.15


def K_to_cel(x):
    '''Convert Kelvin to Celsius'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Cannot have temperature lower than 0 Kelvin!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Cannot have temperature lower than 0 Kelvin!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x - 273.15


def rem_to_sv(x):
    '''Convert Rem to Sievert'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative dosage is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative dosage is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / 100


def sv_to_rem(x):
    '''Convert Sievert to Rem'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative dosage is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative dosage is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 100


def curie_to_bq(x):
    '''Convert Curie to Becquerel'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative activity is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative activity is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 3.7E10


def bq_to_curie(x):
    '''Convert Becquerel to Curie'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative activity is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative activity is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / 3.7E10


def seconds_to_minutes(x):
    '''Convert seconds to minutes'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / 60


def seconds_to_hours(x):
    '''Convert seconds to hours'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / (60*60)


def seconds_to_days(x):
    '''Convert seconds to days'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / (24*60*60)


def seconds_to_years(x):
    '''Convert seconds to years'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / (365.25*24*60*60)


def years_to_days(x):
    '''Convert years to days'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * (365.25)


def years_to_hours(x):
    '''Convert years to hours'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * (365.25*24)


def years_to_minutes(x):
    '''Convert years to minutes'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * (365.25*24*60)


def years_to_seconds(x):
    '''Convert years to seconds'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative time is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative time is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * (365.25*24*60*60)


def ev_to_joule(x):
    '''Convert electron volts to Joules'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative energy is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative energy is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1.602E-19


def joule_to_ev(x):
    '''Convert Joules to electron volts'''
    if type(x) is np.ndarray:
        if x.any() < 0:
            raise ValueError('Negative energy is not physical!')
    if type(x) in [int, float, np.int64, np.float64] and x < 0:
        raise ValueError('Negative energy is not physical!')
    if type(x) not in [int, float, np.ndarray, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x / 1.602E-19


def milli(x):
    '''Convert to milli__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E-3


def micro(x):
    '''Convert to micro__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E-6


def nano(x):
    '''Convert to nano__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E-9


def pico(x):
    '''Convert to pico__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E-12


def kilo(x):
    '''Convert to kilo__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E3


def mega(x):
    '''Convert to mega__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E6


def giga(x):
    '''Convert to giga__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E9


def tera(x):
    '''Convert to tera__'''
    if type(x) not in [int, float, np.int64, np.float64]:
        raise TypeError('Only valid integers or floats can be passed.')
    return x * 1E12