def plot_10m_max_winds(ncFile, targetDir, windScaleFactor=50):
logger = PyPostTools.pyPostLogger()
fig, ax, X, Y = prepare_plot_object(ncFile)
st, fh, fh_int = getTimeObjects(ncFile)
maxwnd = ncFile["MAX_WIND_SFC"]
u = ncFile["SFC_U"]
v = ncFile["SFC_V"]
wndKT = Conversions.ms_to_kts(maxwnd)
uKT = Conversions.ms_to_kts(u)
vKT = Conversions.ms_to_kts(v)
clevs = np.arange(10, 80, 2)
smooth_wnd = gaussian_filter(to_np(wndKT), sigma=3)
contours = plt.contourf(X,
Y,
smooth_wnd,
clevs,
cmap=get_cmap('rainbow'),
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Wind Speed (Kts)")
SLP = to_np(ncFile["MSLP"])
smooth_slp = gaussian_filter(SLP, sigma=3)
levs = np.arange(950, 1050, 4)
linesC = plt.contour(X,
Y,
smooth_slp,
levs,
colors="black",
transform=ccrs.PlateCarree(),
linewidths=1)
plt.clabel(linesC, inline=1, fontsize=10, fmt="%i")
plt.barbs(to_np(X[::windScaleFactor, ::windScaleFactor]),
to_np(Y[::windScaleFactor, ::windScaleFactor]),
to_np(uKT[::windScaleFactor, ::windScaleFactor]),
to_np(vKT[::windScaleFactor, ::windScaleFactor]),
transform=ccrs.PlateCarree(),
length=6)
plt.title("10m Wax Wind Speed (Kts), MSLP (mb)")
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/10m_maxwnd_F" + str(fh_int))
plt.close(fig)
return True
def appendTimeStatistics(raw_output, _CLASSIFIER, clf, timeFit, x_test, y_test):
_timeFitLin = clf.time_fit_lin # SS_MSMS
_timeFitGauss = clf.time_fit_gauss # MM:SS
_timeFitOver = clf.time_overhead # MSMS
_timeTotal = _timeFitLin + _timeFitGauss + _timeFitOver
_score = clf.score(x_test, y_test)
_error = round((1 - _score) * 100, 2)
_timePredict = clf.time_predict ## SS_MSMS
_percentGaussTotal = round((_timeFitGauss / _timeTotal) * 100, 2)
_percentLinTotal = round((_timeFitLin / _timeTotal * 100), 2)
_percentOverTotal = round((_timeFitOver / _timeTotal * 100), 2)
# Bring Time data in readable format
_timeFit = Conversions.secondsToHourMin(_timeTotal)
_timeFitLin = Conversions.secondsToSecMilsec(_timeFitLin)
_timeFitGauss = Conversions.secondsToMinSec(_timeFitGauss)
_timeFitOver = Conversions.secondsToMilsec(_timeFitOver)
_timePredict = Conversions.secondsToSecMilsec(_timePredict)
raw_output[7].append(str(_timeTotal).replace(".", ",") + "s;")
# raw_output[8].append(_timeFitGauss + "\t(" + str(_percentGaussTotal) + "%)" + ";")
raw_output[8].append(_timeFitGauss + ";")
# raw_output[9].append(_timeFitLin + "\t(" + str(_percentLinTotal) + "%)" + ";")
raw_output[9].append(_timeFitLin + ";")
# raw_output[10].append(_timeFitOver + "\t(" + str(_percentOverTotal) + "%)" + ";")
raw_output[10].append(_timeFitOver + ";")
raw_output[11].append(_timePredict + ";")
raw_output[12].append(str(_error) + "%;")
return raw_output
def getDistance(self, user=None, latlng=None):
"""Returns the distance between two entities
inputs: user - type: User, latlng - type: tuple
-provided a user: return the distance from the park to the user
-provided a latlng: return the distance from the park to the latitude and longitude point
>>> x = Park(name = "Jerdon",state = "Washington", lat = 46.7297771, lng = -117.1817377)
>>> u = User(name = "Jerdon", state = "Washington", addy = "Pullman")
>>> u2 = User(name = "Jerdon", state = "Washington", addy = "Seattle")
>>> x.getDistance(user = u)
0.0
>>> round(x.getDistance(user = u2),2)
249.42
"""
if (user != None):
lat1 = self.lat
lat2 = user.lat
lng1 = self.lng
lng2 = user.lng
else:
lat1 = self.lat
lat2 = latlng[0]
lng1 = self.lng
lng2 = latlng[1]
#(((lat1 - lat2)**2) + ((lng1 - lng2)**2))**0.5
kmDist = CONV.distBetweenCoords(lat1, lng1, lat2, lng2)
mDist = CONV.kmToMiles(kmDist)
self.distance = round(mDist, 2)
return mDist
def inv_mixcolumn(datalist):
# according to the block length we do 2, 4 or 8 times the mix
datalist_unmix = []
for i in range(0, len(datalist) - 1, 2):
xor = Arithmod.xor_bin_str(Conversions.int2bin_str(datalist[i]), Conversions.int2bin_str(datalist[(i + 1)]))
m2 = Util.rotate_left(xor, R)
m1 = Arithmod.subtract_64bits(Conversions.int2bin_str(datalist[i]), Conversions.int2bin_str(m2))
m1 = Conversions.bin_str2int(m1)
datalist_unmix.append(m1)
datalist_unmix.append(m2)
return datalist_unmix
def plot_dewpoint_temperature(ncFile, targetDir, windScaleFactor=50):
logger = PyPostTools.pyPostLogger()
fig, ax, X, Y = prepare_plot_object(ncFile)
st, fh, fh_int = getTimeObjects(ncFile)
TD = ncFile["TD"]
TD_F = Conversions.C_to_F(TD)
clevs = np.linspace(-20, 85, 36)
norm = matplotlib.colors.BoundaryNorm(clevs, 36)
contours = plt.contourf(X,
Y,
TD_F,
clevs,
norm=norm,
cmap=ColorMaps.td_colormap,
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Dewpoint Temperature ($^\circ$ F)")
u = ncFile["SFC_U"]
v = ncFile["SFC_V"]
uKT = Conversions.ms_to_kts(u)
vKT = Conversions.ms_to_kts(v)
plt.barbs(to_np(X[::windScaleFactor, ::windScaleFactor]),
to_np(Y[::windScaleFactor, ::windScaleFactor]),
to_np(uKT[::windScaleFactor, ::windScaleFactor]),
to_np(vKT[::windScaleFactor, ::windScaleFactor]),
transform=ccrs.PlateCarree(),
length=6)
plt.title("Surface Dewpoint Temperature ($^\circ$F), Winds (kts)")
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/TD_F" + str(fh_int))
plt.close(fig)
return True
def run(self):
""" Perform Threaded Action """
# get variables here
path = self.path
validExt = ["jpg","jpeg"]
count = 0
for root, dirs, files in os.walk(path):
for f in files:
if(f.lower()[f.rfind(".")+1:] in validExt):
self.im.append(Images.loader(root,f))
tmpim = Image.open(os.path.join(root,f))
tmpim.thumbnail((125,125))
tmpim = Conversions.padpiltoimage(tmpim,125,125).ConvertToBitmap()
self.il.Add(tmpim)
count += 1
wx.PostEvent(self.frame,ReturnFunction(count,self.id,0))
self.imList.SetImageList(self.il, wx.IMAGE_LIST_SMALL)
#self.imList.SetImageList(self.il, wx.IMAGE_LIST_NORMAL)
self.imList.InsertColumn(0,'',width=130)
for i in range(count):
self.imList.InsertStringItem(i,'')
self.imList.SetItemImage(i,i)
wx.PostEvent(self.frame, ReturnFunction("Ready...",self.id,1))
def decode(ciph_data, keypath, password):
private = Keys.read_key(keypath)
private = Keys.decipher_key(password, private)
k = private[6]
clear_data = decipher_data(ciph_data, private)
file_data = Conversions.int_list2bytes(clear_data, k >> 3)
return file_data
def run(self):
""" Perform Threaded Action """
# get variables here
path = self.path
validExt = ["jpg", "jpeg"]
count = 0
for root, dirs, files in os.walk(path):
for f in files:
if (f.lower()[f.rfind(".") + 1:] in validExt):
self.im.append(Images.loader(root, f))
tmpim = Image.open(os.path.join(root, f))
tmpim.thumbnail((125, 125))
tmpim = Conversions.padpiltoimage(tmpim, 125,
125).ConvertToBitmap()
self.il.Add(tmpim)
count += 1
wx.PostEvent(self.frame, ReturnFunction(count, self.id, 0))
self.imList.SetImageList(self.il, wx.IMAGE_LIST_SMALL)
#self.imList.SetImageList(self.il, wx.IMAGE_LIST_NORMAL)
self.imList.InsertColumn(0, '', width=130)
for i in range(count):
self.imList.InsertStringItem(i, '')
self.imList.SetItemImage(i, i)
wx.PostEvent(self.frame, ReturnFunction("Ready...", self.id, 1))
def encode_with_key(file_data, keypath):
formatted_pb = Keys.read_key(keypath)
public = Keys.deformat_key(formatted_pb)
k = public[6]
clear_data = Conversions.bytes2int_list(file_data, k >> 3)
ciph_data = cipher_data(clear_data, public)
return ciph_data
def getUsrLoc(state, loc):
"""returns tuple containing latitude and longitude
-inputs: state - type:string, loc - type:string
"""
latlng = CONV.getLocToCoords(state, loc)
lat = latlng[0]
lng = latlng[1]
return (lat, lng)
def look(self, board):
""" Additionally to parent class:
- Populates available captures with squares pertaining to captures En Passant
"""
self.clear_vision()
new_row, _ = row, col = self.location
# On their first move they are privileged with a double move should they chose it
if not self.has_moved:
self.steps = 2
else:
self.steps = 1
# PAWNS move straight forward..
for _ in range(self.steps):
new_row += self.direction # look one square ahead..
if not Conversions.legal(new_row, col): # if it's on the board..
continue
square = board.squares[new_row][col]
if square.__class__.__name__ == 'Empty': # ..and empty..
self.avail_moves.add((new_row, col)) # add it to .avail_moves
else:
break
# PAWNS capture diagonally..
for i, j in self.pattern: # for each forward-diagonal-direction..
new_row = self.location[0] + i * self.direction # step once
new_col = self.location[1] + j * self.direction # step once
# if square is on the board..
if not Conversions.legal(new_row, new_col):
continue
self.check_vision.add(
(new_row, new_col)) # ..add coord to .check_vision
# if the square is the en passant location..
if board.passant_loc == (new_row, new_col):
self.avail_captures.add(
(new_row, new_col)) # ..add it to .avail_captures
square = board.squares[new_row][new_col]
# if there is a piece there..
if square.__class__.__name__ == 'Piece':
if square.colour != self.colour: # and it's an opposition piece ..
self.avail_captures.add(
(new_row, new_col)) # ..add coord to .avail_captures
else: # if it's an allied piece..
self.supporting.add(
(new_row, new_col)) # ..add coord to .supporting
def encode_no_key(file_data, keypath, k, password):
private, public = generate_keys(k)
private = Keys.cipher_key(password, private)
formatted_pb = Keys.format_key(public)
Keys.write_key(keypath, "private_key.txt", private)
Keys.write_key(keypath, "public_key.txt", formatted_pb)
clear_data = Conversions.bytes2int_list(file_data, k >> 3)
ciph_data = cipher_data(clear_data, public)
return ciph_data
def blake_hash(m, hash_len, key=""):
if hash_len > 64:
raise ValueError(
"Blake hash does not support hash_length greater than 512 bits.")
m = Conversions.str2bytes(m)
key = Conversions.str2bytes(key)
m_len = len(m)
key_len = len(key)
h = IV.copy()
init_mix = int("0x0101" + hex(key_len)[2:] + hex(hash_len)[2:], 16)
h[0] = h[0] ^ init_mix
bytes_compressed = 0
bytes_remaining = m_len
if key_len > 0:
if key_len > 128:
key = key[:128]
elif key_len < 128:
key = key.zfill(128)
m = key + m
bytes_remaining += 128
while bytes_remaining > 128:
chunk = m[bytes_compressed:bytes_compressed + 128]
bytes_compressed += 128
bytes_remaining -= 128
t = bytes_compressed.to_bytes(128, byteorder='big', signed=False)
h = compress(h, chunk, t, False)
chunk = m[bytes_compressed:]
bytes_compressed = bytes_compressed + bytes_remaining
chunk = chunk.zfill(128)
t = bytes_compressed.to_bytes(128, byteorder='big', signed=False)
h = compress(h, chunk, t, True)
h_bytes = b''
for c in h:
h_bytes += c.to_bytes(8, byteorder='big', signed=False)
return int.from_bytes(h_bytes[:hash_len], byteorder='big', signed=False)
def appendMiscStatsDualSvm(clf, raw_output):
gauss_stat = str(clf.n_gauss) + " (" + str(
round((float(clf.n_gauss) / float(clf.n_gauss + clf.n_lin) * 100), 2)) + "%);"
lin_stat = str(clf.n_lin) + " \t(" + str(
round((float(clf.n_lin) / float(clf.n_gauss + clf.n_lin) * 100), 2)) + "%);"
dec_margin = str(round(clf._gauss_distance, 3)) + ";"
lin_c = Conversions.toPowerOfTen(clf.lin_svc.C) + ";"
gauss_c = Conversions.toPowerOfTen(clf.gauss_svc.C) + ";"
gauss_gamma = Conversions.toPowerOfTen(clf.gauss_svc.gamma) + ";"
try:
n_gaussSVs = str(clf.gauss_svc.n_support_[0] + clf.gauss_svc.n_support_[1]) + ";"
except AttributeError:
n_gaussSVs = "0;"
raw_output[0].append(gauss_stat)
raw_output[1].append(lin_stat)
raw_output[2].append(str(dec_margin).replace(".", ","))
raw_output[3].append(lin_c)
raw_output[4].append(gauss_c)
raw_output[5].append(gauss_gamma)
raw_output[6].append(n_gaussSVs)
def plot_precipitable_water(ncFile, targetDir, withMSLP=True):
logger = PyPostTools.pyPostLogger()
fig, ax, X, Y = prepare_plot_object(ncFile)
st, fh, fh_int = getTimeObjects(ncFile)
titleAdd = ""
PW = Conversions.kgm2_to_in(ncFile["PW"])
clevs = np.linspace(0, 3, 32)
norm = matplotlib.colors.BoundaryNorm(clevs, 32)
contours = plt.contourf(X,
Y,
PW,
clevs,
norm=norm,
cmap=ColorMaps.pw_colormap,
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Precipitable Water (in)")
if (withMSLP):
SLP = to_np(ncFile["MSLP"])
smooth_slp = gaussian_filter(SLP, sigma=3)
levs = np.arange(950, 1050, 4)
linesC = plt.contour(X,
Y,
smooth_slp,
levs,
colors="black",
transform=ccrs.PlateCarree(),
linewidths=1)
plt.clabel(linesC, inline=1, fontsize=10, fmt="%i")
titleAdd += ", MSLP (mb)"
plt.title("Precipitable Water (in)" + titleAdd)
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/PW_F" + str(fh_int))
plt.close(fig)
return True
def Update(self, bitmapHandle=None, listing=None):
""" Updates the Labelled Image using the current parameters and
Listing is a tuple that provides the imlist handle and index"""
bmp = Conversions.piltoimage(self.thumbX.copy()).ConvertToBitmap()
bmp = TEXT.write(self.dateText,bmp,self.align,self.font,self.fontcolor,self.position)
if(bitmapHandle):
bitmapHandle.SetBitmap(bmp)
bitmapHandle.Center()
bitmapHandle.Refresh()
else:
return bmp
def Update(self, bitmapHandle=None, listing=None):
""" Updates the Labelled Image using the current parameters and
Listing is a tuple that provides the imlist handle and index"""
bmp = Conversions.piltoimage(self.thumbX.copy()).ConvertToBitmap()
bmp = TEXT.write(self.dateText, bmp, self.align, self.font,
self.fontcolor, self.position)
if (bitmapHandle):
bitmapHandle.SetBitmap(bmp)
bitmapHandle.Center()
bitmapHandle.Refresh()
else:
return bmp
def getCurrentTemp(lat, lng):
"""Returns the current temperature (int) of the location
-inputs: lat - type:double, lng - type:double
>>> ct = getCurrentTemp(47.53,-122.03)
>>> ct == None
False
"""
url = address + str(lat) + "&lon=" + str(lng)
json_data = requests.get(url).json()
currentTemp = json_data['main']['temp']
currentFTemp = CNVRT.kelvinToFarenheit(currentTemp)
#print()
#print(currentFTemp)
return int(currentFTemp)
def getCurrentWeatherandTemp(lat, lng):
"""Returns the current temperature(int) and weather(string) of the location
-inputs: lat - type:double, lng - type:double
>>> cwt = getCurrentWeatherandTemp(47.53,-122.03)
>>> cwt == (None, None)
False
"""
url = address + str(lat) + "&lon=" + str(lng)
json_data = requests.get(url).json()
currentTemp = json_data['main']['temp']
#print("CURRENT TEMP: ", currentTemp)
#KELVIN TEMP IS CORRECT SOMETHING ABOUT THE CONVERSION IS NOW OFF
currentFTemp = CNVRT.kelvinToFarenheit(currentTemp)
currentWeather = json_data['weather'][0]['main']
return (currentWeather, currentFTemp)
def mixcolumn(datalist):
# according to the block length we do 2, 4 or 8 times the mix
datalistmix = []
for i in range(0, len(datalist) - 1, 2):
m11 = Arithmod.add_64bits(Conversions.int2bin_str(datalist[i]), Conversions.int2bin_str(datalist[i + 1]))
m11 = Conversions.bin_str2int(m11)
rotation = Util.rotate_right(Conversions.int2bin_str(datalist[(i + 1)]), R)
m22 = Arithmod.xor_bin_str(Conversions.int2bin_str(m11), Conversions.int2bin_str(rotation))
m22 = Conversions.bin_str2int(m22)
datalistmix.append(m11)
datalistmix.append(m22)
return datalistmix
def readFile(trainingdatafile, trainingtargetfile, testingdatafile,
testingtargetfile, num_features):
training_features = []
training_targets = []
testing_features = []
testing_targets = []
trainingdatafilep = open(trainingdatafile, 'r')
for line in trainingdatafilep:
if line.strip():
exampleString = [
number for number in line.split("\t") if number is not ""
]
example = []
for exampleStringUnit in exampleString:
example.append(float(exampleStringUnit))
assert len(example) == num_features
training_features.append(example)
trainingdatafilep.close()
trainingtargetfilep = open(trainingtargetfile, 'r')
for line in trainingtargetfilep:
if line.strip():
training_targets.append(int(line))
trainingtargetfilep.close()
training_targets = Conversions.convertIntsToArrs(training_targets)
testingdatafilep = open(testingdatafile, 'r')
for line in testingdatafilep:
if line.strip():
exampleString = [
number for number in line.split("\t") if number is not ""
]
example = []
for exampleStringUnit in exampleString:
example.append(float(exampleStringUnit))
assert len(example) == num_features
testing_features.append(example)
testingdatafilep.close()
testingtargetfilep = open(testingtargetfile, 'r')
for line in testingtargetfilep:
if line.strip():
testing_targets.append(int(line))
testingtargetfilep.close()
testing_targets = Conversions.convertIntsToArrs(testing_targets)
training_features = Conversions.convertListsToArrs(training_features)
training_targets = Conversions.convertListsToArrs(training_targets)
testing_features = Conversions.convertListsToArrs(testing_features)
testing_targets = Conversions.convertListsToArrs(testing_targets)
return training_features, training_targets, testing_features, testing_targets
def look(self, board):
""" Populates:
self.check_vision
self.avail_moves
self.avail_captures
self.supporting
"""
self.clear_vision()
# According to movement rules..
for i, j in self.pattern:
new_row = self.location[0] + i
new_col = self.location[1] + j
# ..and for as far as they can see..
for _ in range(self.steps):
# if the square is on the board..
if not Conversions.legal(new_row, new_col):
break
self.check_vision.add(
(new_row, new_col)) # ..add coord to .check_vision
square = board.squares[new_row][new_col]
# ..and if square is empty..
if square.__class__.__name__ == 'Empty':
self.avail_moves.add(
(new_row, new_col)) # add coord to .avail_moves
new_row += i # and increment for next square
new_col += j # and increment for next square
# if it's an opposition piece..
elif square.colour != self.colour:
self.avail_captures.add(
(new_row, new_col)) # ..add coord to .avail_captures
break
# if it's an allied piece..
else:
self.supporting.add(
(new_row, new_col)) # ..add coord to .supporting
break
def Main():
test = GetProgram()
if test == ('ReduceFraction'):
ReduceFraction.Main()
elif test == ('DivisibleBy'):
num = int( input("What number are you testing: ") )
print ( DivisibleBy.Main(num) )
elif test == ('FactorQuadraticsAddition'):
FactorQuadraticsAddition.Main()
elif test == ('Conversions'):
Conversions.Main()
elif test == ('GCF'):
a = int( input("First number: ") )
b = int( input("Second number: ") )
print ( GCF.Main(a, b) )
else:
print ("Unknown directory")
Main()
def apply(x):
if x < 3:
mode = 0
while mode != 1 and mode != 2:
mode = int(
input("Mode de (dé)chiffrement : \n\t1. ECB\n\t2. CBC\n"))
key_len = 0
while (key_len != 256) and (key_len != 512) and (key_len != 1024):
key_len = int(input("Taille de la clé en bits(256/512/1024): "))
file_key = input("Chemin du fichier de la clé: ")
passwd_user = input("Mot de passe pour chiffrer la clé: ")
file_path = input("Chemin du fichier à (dé)chiffrer : ")
word_len = 64
num_words = int(key_len / word_len)
word_len_bytes = int(word_len / 8)
if x == 1:
file_data = IO.readfile(file_path, word_len, 1)
file_data_list = Util.organize_data_list(file_data, num_words)
encrypted_file = ThreeFish.threefish_chiffrement(
file_data_list, mode, key_len, passwd_user, file_key)
IO.write_2D_list(file_path, encrypted_file, word_len_bytes)
IO.rename_file(file_path, 0)
print("Chiffrement terminé.")
elif x == 2:
ciph_data = IO.readfile(file_path, word_len, 0)
ciph_data_list = Util.organize_data_list(ciph_data, num_words)
clear_file_data, valeur_pad = ThreeFish.threefish_dechiffrement(
ciph_data_list, mode, key_len, word_len, passwd_user, file_key)
IO.write_file_list_pad(file_path, clear_file_data, word_len_bytes,
valeur_pad)
IO.rename_file(file_path, 1)
print("Déchiffrement terminé.")
elif x == 3:
filepath = input("Chemin du fichier à chiffrer:")
file_data = IO.read_bytes(filepath)
ans = ''
while ans != 'y' and ans != 'n' and ans != 'Y' and ans != 'N':
ans = input("Avez-vous un fichier de clé publique ? (y/n) ")
if ans == 'y' or ans == 'Y':
keypath = input("Chemin de la clé publique: ")
ciph_data = CramerShoup.encode_with_key(file_data, keypath)
else:
k = int(input("Taille de clé souhaitée en bits: "))
password = input("Mot de passe pour chiffrer la clé privée: ")
keypath = input("Chemin du répertoire des clés: ")
ciph_data = CramerShoup.encode_no_key(file_data, keypath, k,
password)
ciph_bytes = Conversions.int_list2bytes(ciph_data, 8)
IO.write_bytes(filepath, ciph_bytes)
IO.rename_file(filepath, 0)
print("Chiffrement terminé.")
elif x == 4:
filepath = input("Chemin du fichier à déchiffrer: ")
file_data = IO.read_bytes(filepath)
keypath = input("Chemin de la clé privée: ")
password = input("Mot de passe: ")
ciph_data = Conversions.bytes2int_list(file_data, 8)
clear_data = CramerShoup.decode(ciph_data, keypath, password)
IO.write_bytes(filepath, clear_data)
IO.rename_file(filepath, 1)
print("Déchiffrement terminé.")
elif x == 5:
hash_len = 0
while hash_len != 256 and hash_len != 512 and hash_len != 1 and hash_len != 2:
hash_len = int(input("1. BLAKE-256\n2. BLAKE-512\n"))
if hash_len < 256:
hash_len *= 32
else:
hash_len //= 8
filepath = input("Chemin du fichier: ")
with open(filepath, 'r') as rfile:
file_data = rfile.read()
ans = ''
while ans != 'y' and ans != 'n' and ans != 'Y' and ans != 'N':
ans = input("Protéger l'empreinte ? (y/n) ")
key = ''
if ans == 'y' or ans == 'Y':
key = input("Mot de passe: ")
h = hex(Hash.blake_hash(file_data, hash_len, key)) + '\n'
# Rename file : "name.ext" -> "name~hash.ext"
path = filepath.split('/')
last = len(path) - 1
filename = path[last].split('.')
filename[0] += '~hash'
path[last] = '.'.join(filename)
filepath = '/'.join(path)
with open(filepath, 'w') as wfile:
wfile.write(h)
elif x == 6:
hash_len = 0
while hash_len != 256 and hash_len != 512 and hash_len != 1 and hash_len != 2:
hash_len = int(input("1. BLAKE-256\n2. BLAKE-512\n"))
if hash_len < 256:
hash_len *= 32
else:
hash_len //= 8
filepath = input("Chemin du fichier: ")
with open(filepath, 'r') as rfile:
file_data = rfile.read()
hashpath = input("Chemin du hash: ")
with open(hashpath, 'r') as hfile:
hash = hfile.read()
ans = ''
while ans != 'y' and ans != 'n' and ans != 'Y' and ans != 'N':
ans = input("Empreinte protégée ?(y/n) ")
key = ''
if ans == 'y' or ans == 'Y':
key = input("Mot de passe: ")
h = hex(Hash.blake_hash(file_data, hash_len, key)) + '\n'
if h == hash:
print("Les empreintes sont égales.")
else:
print("Les empreintes ne correspondent pas.")
def look(self, board):
""" Additionally to parent class:
- Populates available moves with squares pertaining to legal Castling maneuvers.
In these cases the Rook has no knowledge of the potential of Castling and is moved
'manually' by the game logic embedded in the Board.move() method.
- Prevents population of available moves and available captures with moves that
would result in the King being in Check.
"""
self.clear_vision()
# NORMAL MOVEMENT
for i, j in self.pattern:
new_row = self.location[0] + i
new_col = self.location[1] + j
# If the square is on the board..
if not Conversions.legal(new_row, new_col):
continue
self.check_vision.add(
(new_row, new_col)) # ..add coord to .check_vision
square = board.squares[new_row][new_col]
# If the coord is empty..
if square.__class__.__name__ == 'Empty':
# and is not covered..
if board.get_pieces(self.opp_colour,
in_check_vision=(new_row, new_col)):
continue
self.avail_moves.add(
(new_row, new_col)) # ..add coord to .avail_moves
# If it's an opposition piece..
elif square.colour != self.colour:
# and is not covered..
if board.get_pieces(self.opp_colour,
in_check_vision=(new_row, new_col)):
continue
self.avail_captures.add(
(new_row, new_col)) # ..add coord to their .avail_captures
# If it's an allied piece..
else:
self.supporting.add(
(new_row, new_col)) # ..add coord to .supporting
# CASTLING MOVEMENT
if not self.has_moved: # if not yet moved..
checks, _ = board.get_checks()
if self.colour not in checks: # ..and not in check..
row = self.location[0]
for _, j in self.castle_pattern: # look in both directions along the rank
new_col = self.location[1] + j
for _ in range(4):
if Conversions.legal(
row, new_col
): # if the next square is on the board..
square = board.squares[row][new_col] # check it
if square.__class__.__name__ == 'Empty': # if it's empty and not visible to opponent..
if board.get_pieces(self.opp_colour,
in_check_vision=square.
location) is not None:
new_col += j # keep going
continue
elif square.__class__.__name__ == 'Rook': # if it's a rook and it's not moved..
if not square.has_moved:
castle_location = (row, self.location[1] +
j * 2)
self.avail_moves.add(
castle_location
) # ..then castling is legal
else: # otherwise: no castling on this side
break
else: # then we are off the board
break
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from random import getrandbits
import Arithmod, Conversions, Keys, IO, Util
# Constants
tweak0 = Conversions.str2int("cogranne")
tweak1 = Conversions.str2int("gs15love")
tweak2 = tweak0 ^ tweak1
tweaks = [tweak0, tweak1, tweak2]
C = 0x1bd11bdaa9fc1a22
R = 49
# Is apply when the user chose the option 1 in the menu which is correspond to ThreeFish cipher
# input :
# file_data_list = 2D array of int
# mode = int, permit to choose between ecb or cbc decipher
# key_len = int, length of the key, 256, 512 or 1024
# output = 2D array of int, correspond to the cipher data
def threefish_chiffrement(file_data_list, mode, key_len, passwd_user, file_key):
key, keyuser = keygen(key_len)
tab_key = keygenturn(key)
# cipher the key using the password given by the user
cipher_key = Keys.cipher_key(passwd_user, key)
# writing cipher key in the specific file
IO.write_2D_list(file_key, cipher_key, 8)
Keys.print_key(key_len, keyuser)
def AddMagneticCoordinates(sourceFilename, resultFilename):
startSecs = time.time()
prev_time = current_time = None
timestep = 0
linenum = 0
CSVfileOUT = open(resultFilename, 'w')
CSVwriter = csv.writer(CSVfileOUT, delimiter=',')
CSVwriter.writerow([
"Epoch(UTCG)", "Lat_GEOD(deg)", "Lon_GEOD(deg)", "Height_WGS84 (km)",
"Daedalus.Magnetic Latitude", "Daedalus.Magnetic Longitude",
"Daedalus.MLT"
])
with open(sourceFilename) as CSVfileIN:
CSVreader = csv.reader(CSVfileIN)
# locate the column numnbers of interest inside the csv file
CSVheader = next(CSVreader)
Time_idx = CSVheader.index(
"Epoch(UTCG)") #CSVheader.index( "Daedalus.EpochText" )
Lat_idx = CSVheader.index(
"Lat_GEOD(deg)") #CSVheader.index( "Daedalus.Latitude" )
Lon_idx = CSVheader.index(
"Lon_GEOD(deg)") #CSVheader.index( "Daedalus.Longitude" )
Alt_idx = CSVheader.index(
"Height_WGS84 (km)") #CSVheader.index( "Daedalus.Longitude" )
# read the orbit file
for row in CSVreader: # for each satellite position
if len(list(row)) == 0: break # <<<<
linenum += 1
resultItems = list()
# add the standard fields to the result file
resultItems.append(row[Time_idx])
resultItems.append(
row[Lat_idx]) # Latitude is geodetic inside the orbit file
resultItems.append(row[Lon_idx])
resultItems.append(row[Alt_idx])
# Calculate the extra fields
prev_time = current_time
current_time = parseDaedalusDate(
row[Time_idx]) # read time for the current orbit position
if current_time == None:
print("ERROR - Wrong time format at line", linenum, ":",
row[Time_idx])
continue
if prev_time is not None:
if timestep == 0:
timestep = calendar.timegm(
current_time.utctimetuple()) - calendar.timegm(
prev_time.utctimetuple())
else:
if calendar.timegm(
current_time.utctimetuple()) - calendar.timegm(
prev_time.utctimetuple()) != timestep:
print(
"Time leap at line", linenum, ":", row, "(",
calendar.timegm(current_time.utctimetuple()) -
calendar.timegm(prev_time.utctimetuple()), "sec)",
"\n", prev_time, "\n", current_time)
# take care of time so that it is compatible with igrf
#if current_time.year > 2024:
# time_for_igrf = current_time - relativedelta(years=13)
#else:
# time_for_igrf = current_time
time_for_igrf = current_time
MagneticLatitude, MagneticLongitude, MagneticLocalTime = Conversions.getMagneticProperties(
time_for_igrf, float(row[Lat_idx]), float(row[Lon_idx]),
float(row[Alt_idx]))
# add the extra fields to the result file
resultItems.append(MagneticLatitude)
resultItems.append(MagneticLongitude)
resultItems.append(MagneticLocalTime)
# write it
CSVwriter.writerow(resultItems)
# clean up
CSVfileOUT.close()
finishSecs = time.time()
print("Processed", linenum, "lines in", finishSecs - startSecs, "sec")
def loop():
convert = input("Would you like to make a conversion? y/n: ")
while convert == "y":
conversion = input("""You can choose from 6 conversions:
Decimal to Binary (type: DTB)
Binary to Decimal (type: BTD)
Decimal to Hexidecimal (type: DTH)
Hexidecimal to Decimal (type: HTD)
Binary to Hexidecimal (type: BTH)
Hexidecimal to Binary (type: HTB)
Which do you choose?
: """)
if conversion == "DTB":
C.dtb()
convert = input("Make another conversion? y/n: ")
if conversion == "BTD":
C.btd()
convert = input("Make another conversion? y/n: ")
if conversion == "DTH":
C.dth()
convert = input("Make another conversion? y/n: ")
if conversion == "HTD":
C.htd()
convert = input("Make another conversion? y/n: ")
if conversion == "BTH":
C.bth()
convert = input("Make another conversion? y/n: ")
if conversion == "HTB":
C.htb()
convert = input("Make another conversion? y/n: ")
def plot_surface_map(ncFile,
targetDir,
withTemperature=True,
withWinds=True,
windScaleFactor=50,
withMSLP=True):
logger = PyPostTools.pyPostLogger()
if (withTemperature == False and withWinds == False and withMSLP == False):
logger.write("Error in plot_surface_map(): Nothing to do.")
return False
fig, ax, X, Y = prepare_plot_object(ncFile)
st, fh, fh_int = getTimeObjects(ncFile)
titleAdd = ""
if (withTemperature):
T = ncFile["SFC_T"]
TF = Conversions.K_to_F(T)
clevs = np.arange(-30, 115, 5)
contours = plt.contourf(X,
Y,
TF,
clevs,
cmap=ColorMaps.temp_colormap,
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Temperature (F)")
titleAdd += "Temperature "
if (withMSLP):
SLP = to_np(ncFile["MSLP"])
smooth_slp = gaussian_filter(SLP, sigma=3)
levs = np.arange(950, 1050, 4)
linesC = plt.contour(X,
Y,
smooth_slp,
levs,
colors="black",
transform=ccrs.PlateCarree(),
linewidths=1)
plt.clabel(linesC, inline=1, fontsize=10, fmt="%i")
titleAdd += "MSLP (mb) "
if (withWinds):
u = ncFile["SFC_U"]
v = ncFile["SFC_V"]
uKT = Conversions.ms_to_kts(u)
vKT = Conversions.ms_to_kts(v)
plt.barbs(to_np(X[::windScaleFactor, ::windScaleFactor]),
to_np(Y[::windScaleFactor, ::windScaleFactor]),
to_np(uKT[::windScaleFactor, ::windScaleFactor]),
to_np(vKT[::windScaleFactor, ::windScaleFactor]),
transform=ccrs.PlateCarree(),
length=6)
titleAdd += "Winds "
# Finish things up, for the title crop off the extra comma at the end, add the time text, and save.
titleAdd = titleAdd.replace(" ", ", ")
titleAdd = titleAdd[:-2]
plt.title("Surface Map (" + titleAdd + ")")
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/sfcmap_F" + str(fh_int))
plt.close(fig)
return True
def plot_theta_e(ncFile,
targetDir,
levels,
withHeights=True,
withWinds=True,
windScaleFactor=50):
logger = PyPostTools.pyPostLogger()
st, fh, fh_int = getTimeObjects(ncFile)
for level in levels:
fig, ax, X, Y = prepare_plot_object(ncFile)
titleAdd = ""
clevs = np.arange(240, 380, 5)
if (level == 0):
# Surface is special in regards to naming and ignoring geo.hgt. argument
eth = ncFile["SFC_THETA_E"]
contours = plt.contourf(X,
Y,
eth,
clevs,
cmap=get_cmap('gist_ncar'),
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Equivalent Potential Temperature (K)")
if (withWinds):
u = ncFile["SFC_U"]
v = ncFile["SFC_V"]
uKT = Conversions.ms_to_kts(u)
vKT = Conversions.ms_to_kts(v)
plt.barbs(to_np(X[::windScaleFactor, ::windScaleFactor]),
to_np(Y[::windScaleFactor, ::windScaleFactor]),
to_np(uKT[::windScaleFactor, ::windScaleFactor]),
to_np(vKT[::windScaleFactor, ::windScaleFactor]),
transform=ccrs.PlateCarree(),
length=6)
titleAdd += ", Winds (Kts)"
plt.title("Surface Theta-E (K)" + titleAdd)
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/ThetaE_SFC_F" + str(fh_int))
plt.close(fig)
else:
eth = ncFile["THETA_E_" + str(level)]
contours = plt.contourf(X,
Y,
eth,
clevs,
cmap=get_cmap('gist_ncar'),
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Equivalent Potential Temperature (K)")
if (withHeights == True):
z = ncFile["GEOHT_" + str(level)]
zDM = z / 10
smooth_lines = gaussian_filter(to_np(zDM), sigma=3)
if (level <= 200):
cont_levels = np.arange(800., 1600., 6.)
elif (level <= 400):
cont_levels = np.arange(600., 1200., 6.)
elif (level <= 600):
cont_levels = np.arange(200., 800., 6.)
elif (level <= 800):
cont_levels = np.arange(100., 600., 6.)
else:
cont_levels = np.arange(0., 400., 6.)
contours = plt.contour(X,
Y,
smooth_lines,
levels=cont_levels,
colors="black",
transform=ccrs.PlateCarree())
plt.clabel(contours, inline=1, fontsize=10, fmt="%i")
titleAdd += ", Geopotential Height (dm)"
if (withWinds):
u = ncFile["U_" + str(level)]
v = ncFile["V_" + str(level)]
uKT = Conversions.ms_to_kts(u)
vKT = Conversions.ms_to_kts(v)
plt.barbs(to_np(X[::windScaleFactor, ::windScaleFactor]),
to_np(Y[::windScaleFactor, ::windScaleFactor]),
to_np(uKT[::windScaleFactor, ::windScaleFactor]),
to_np(vKT[::windScaleFactor, ::windScaleFactor]),
transform=ccrs.PlateCarree(),
length=6)
titleAdd += ", Winds (Kts)"
plt.title(str(level) + "mb Theta-E (K)" + titleAdd)
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/ThetaE_" + str(level) + "_F" +
str(fh_int))
plt.close(fig)
def plot_upper_lv_winds(ncFile,
targetDir,
levels,
windScaleFactor=50,
withHeights=True):
logger = PyPostTools.pyPostLogger()
st, fh, fh_int = getTimeObjects(ncFile)
for level in levels:
fig, ax, X, Y = prepare_plot_object(ncFile)
titleAdd = ""
u = ncFile["U_" + str(level)]
v = ncFile["V_" + str(level)]
uKT = Conversions.ms_to_kts(u)
vKT = Conversions.ms_to_kts(v)
spd = np.sqrt(uKT * uKT + vKT * vKT)
smooth_wnd = gaussian_filter(to_np(spd), sigma=3)
if level >= 850:
clevs = np.arange(10, 120, 5)
elif (level >= 500 and level < 850):
clevs = np.arange(25, 180, 5)
else:
clevs = np.arange(50, 230, 5)
contours = plt.contourf(X,
Y,
smooth_wnd,
clevs,
cmap=get_cmap('rainbow'),
transform=ccrs.PlateCarree())
cbar = plt.colorbar(ax=ax, orientation="horizontal", pad=.05)
cbar.set_label("Wind Speed (Kts)")
plt.barbs(to_np(X[::windScaleFactor, ::windScaleFactor]),
to_np(Y[::windScaleFactor, ::windScaleFactor]),
to_np(uKT[::windScaleFactor, ::windScaleFactor]),
to_np(vKT[::windScaleFactor, ::windScaleFactor]),
transform=ccrs.PlateCarree(),
length=6)
if (withHeights == True):
z = ncFile["GEOHT_" + str(level)]
zDM = z / 10
smooth_lines = gaussian_filter(to_np(zDM), sigma=3)
if (level <= 200):
cont_levels = np.arange(800., 1600., 6.)
elif (level <= 400):
cont_levels = np.arange(600., 1200., 6.)
elif (level <= 600):
cont_levels = np.arange(200., 800., 6.)
elif (level <= 800):
cont_levels = np.arange(100., 600., 6.)
else:
cont_levels = np.arange(0., 400., 6.)
contours = plt.contour(X,
Y,
smooth_lines,
levels=cont_levels,
colors="black",
transform=ccrs.PlateCarree())
plt.clabel(contours, inline=1, fontsize=10, fmt="%i")
titleAdd += ", Geopotential Height (dm)"
plt.title(str(level) + "mb Winds (kts)" + titleAdd)
plt.text(0.02,
-0.02,
"Forecast Time: " + fh.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.text(0.7,
-0.02,
"Initialized: " + st.strftime("%Y-%m-%d %H:%M UTC"),
ha='left',
va='center',
transform=ax.transAxes)
plt.subplots_adjust(bottom=0.1)
plt.savefig(targetDir + "/" + str(level) + "winds_F" + str(fh_int))
plt.close(fig)
def main():
if len(sys.argv) != 5:
print "<python Init.py TrainingData.txt TrainingTarget.txt TestingData.txt TestingTarget.txt>"
sys.exit()
if not os.path.isfile(sys.argv[1]) or not os.path.isfile(
sys.argv[2]) or not os.path.isfile(
sys.argv[3]) or not os.path.isfile(sys.argv[4]):
print "File does not exist"
print "<python Init.py TrainingData.txt TrainingTarget.txt TestingData.txt TestingTarget.txt>"
sys.exit()
#calculating number of features
firstline = open(sys.argv[1]).readline()
first_example = [
numbers for numbers in firstline.split("\t") if numbers is not ""
]
if len(first_example) < 1:
print "There must be more than one feature in the data."
else:
num_features = len(first_example)
#reading from training file
training_features, training_targets, testing_features, testing_targets = FileReader.readFile(
sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4], num_features)
assert len(training_features) == len(training_targets)
assert len(testing_features) == len(testing_targets)
learning_rate = float(raw_input("What is the learning rate? "))
assert learning_rate > 0 and learning_rate < 1
num_iterations = input("How many iterations? ")
assert num_iterations > 0
numHidLayers = input("How many HIDDEN LAYERS? ")
assert isinstance(numHidLayers, int)
numNeuronsInLayer = num_features
numNeuronsOutLayer = len(testing_targets[0])
numNeuronsHidLayers = []
for i in range(0, numHidLayers):
numNeuronsHidLayers.append(
input("How many Neurons Hidden Layer " + str(i + 1) + " : "))
assert isinstance(numNeuronsHidLayers[i], int)
tic = time.time()
numNeurons = []
numNeurons.append(numNeuronsInLayer)
numNeurons.extend(numNeuronsHidLayers)
numNeurons.append(numNeuronsOutLayer)
allWeights = PerceptronLearning.initializeWeights(numNeurons)
allBiases = PerceptronLearning.initializeBiases(numNeurons)
for i in range(0, num_iterations):
predicted_targets = []
for j in range(0, len(training_features)):
allOutputs = PerceptronLearning.forwardProp(
training_features[j], allWeights, allBiases)
predicted_targets.append(allOutputs[-1])
allDeltas = PerceptronLearning.backwardProp(
training_targets[j], predicted_targets[j], allWeights)
allBiases = PerceptronLearning.updateBiases(
allDeltas, allBiases, learning_rate, len(training_features))
allWeights = PerceptronLearning.updateWeights(
allOutputs, allDeltas, allWeights, learning_rate,
len(training_features))
if i % 100 == 99:
error = PerceptronLearning.calculateError(training_targets,
predicted_targets)
print "Error at iteration", i, "is", np.squeeze(error)
predicted_test_targets_arrs = []
for i in range(0, len(testing_features)):
allOutputs = PerceptronLearning.forwardProp(testing_features[i],
allWeights, allBiases)
predicted_test_targets_arrs.append(allOutputs[-1])
testing_targets = Conversions.convertArrsToInts(testing_targets)
predicted_test_targets = Conversions.convertArrsToInts(
predicted_test_targets_arrs)
# print "original"
# print testing_targets
# print "predicted"
# print predicted_test_targets
assert len(testing_targets) == len(predicted_test_targets)
correct = 0
total = 0
for i in range(0, len(testing_targets)):
total += 1
if testing_targets[i] == predicted_test_targets[i]:
correct += 1
print "The accuracy is", correct / float(total)
toc = time.time()
print "Running Time :", (toc - tic)
return 0
def run():
# These have to be in meters
total_radius = Decimal(30)
outer_radius = Decimal(4)
wall_thickness = Decimal(.0254 * 1)
# m/s2
acceleration = Decimal(9.81)
# Must be in kilograms
additional_mass = Decimal(100000)
# Put in terms of g/cm3
density_of_material = Decimal(2.84) # g/cm3 Al alloy 2219
density_of_material = Decimal(
Conversions.g_cm3_to_kg_m3(density_of_material))
# Max tensile strength of the material given in MPa
tensile_strength = Decimal(248)
if wall_thickness > outer_radius:
print(
"Wall thickness cannot be bigger than the outer radius and will be clamped to that number"
)
wall_thickness = outer_radius
# Find a lot of common variables which are used often in other equations
linear_velocity = Formulas.linear_speed_rotational(total_radius,
acceleration)
rpm = Conversions.linear_to_rpm(total_radius, linear_velocity)
volume_of_walls = Formulas.volume_of_torus_wall(total_radius, outer_radius,
wall_thickness)
# Calculate the stress on the torus in MPa
stress = Formulas.stress_on_torus(total_radius, outer_radius,
wall_thickness, density_of_material,
acceleration, additional_mass)
# Volume of torus wall
print('Volume of torus wall(internal): ' +
str(round(volume_of_walls, pretty_round)) +
' m3'.translate(superscript))
# Internal volume of torus for thickness of wall
print('Volume of torus (hollow): ' + str(
round(
Formulas.volume_of_hollow_torus(total_radius, outer_radius,
wall_thickness), pretty_round)) +
' m3'.translate(superscript))
# Speed torus would have to spin linearly to achieve centripetal acceleration
print('Linear speed: ' + str(round(linear_velocity, pretty_round)) +
' m/s'.translate(superscript))
# 2-3 rpm is optimal, 10 rpm max can be trained
print('RPM: ' + str(
round(Conversions.linear_to_rpm(total_radius, linear_velocity),
pretty_round)) + ' rpm')
# Outer circumference of torus
print('Outer circumference: ' + str(
round(Formulas.circumference_of_circle(total_radius), pretty_round)) +
' m')
# Cross section used to calculate force acting on torus
print('Cross Section of torus: ' + str(
round(
Formulas.cross_section_hollow_torus(outer_radius, wall_thickness),
pretty_round)) + ' m2'.translate(superscript))
# Convert to imperial so it's easier to read
print('Internal radius of torus: ' + str(
round(Conversions.meter_to_feet(outer_radius -
wall_thickness), pretty_round)) +
' ft')
# Useful when performing other calculations
print('Angular Velocity: ' +
str(round(Conversions.rpm_to_angular(rpm), pretty_round)) + ' rad/s')
# Give others an idea how big torus would be
print('Stories high: ' +
str(round((total_radius * Decimal(2)) / Decimal(ft_per_story))) +
' (' + str(ft_per_story) + ' ft per story)'.translate(superscript))
# Mass of ring
print('Mass: ' +
str(round(density_of_material * volume_of_walls +
additional_mass, 2)) + ' kg')
print('---------------------')
# Force along cross sectional area in MPa
print('Force on torus: ' + str(round(stress, 2)) + ' MPa')
if stress <= tensile_strength:
print("The torus can hold itself with: " +
str(round(tensile_strength - stress, 2)) + ' MPa remaining (' +
str(100 * (1 - round(
(tensile_strength - stress) / tensile_strength, 2))) +
"% of total applicable)")
else:
print("The torus can't hold itself with: " +
str(round(tensile_strength - stress, 2)) + ' MPa in excess (' +
str(100 * (1 - round(
(tensile_strength - stress) / tensile_strength, 2))) +
"% of total applicable)")
if draw:
Drawing.draw_torus(total_radius,
outer_radius,
kind=GraphType.MPL,
z_ratio=0)
