def __init__(self, context):
super().__init__(context)
self.add_to_cart_button = Element(By.NAME, 'add_cart', context)
self.pdp_title = Element(
By.XPATH, '//h3[contains(@class, "pdp__title")]/parent::div',
context)
def __init__(self, driver):
self.top_item = ElementsList(driver, 'a.nav-menu-item__level-1')
self.sub_item = ElementsList(driver,
'.navigation-nav__subMenuOverLink')
self.head_title_item = Element(driver, '.navigation-nav__HeadTitle')
self.tabs = ElementsList(
driver,
'[data-component="SBIS3.CONTROLS.TabButtons"] .controls-TabButton')
self.controls = ElementsList(driver,
'[data-component^="SBIS3.CONTROLS"]')
self.input_controls = ElementsList(
driver, '[data-component^="SBIS3.CONTROLS"] input')
self.error_txt = Element(driver, '.ws-smp-header')
self.error_2_txt = Element(driver, '.controls-SubmitPopup__message')
self.error_3_txt = Element(driver, '.error-page')
def getMassMatrix(C):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
Me = np.zeros((8, 8))
me(xIP, C, Me, E)
return Me
def Dif_basic_K(Coords, k=1): #let k be an optional arguement
num_nodes = 4 # number of nodes
E = Element("Q4")
# K = np.zeros((num_nodes,num_nodes))
# Now to step through K_mat and integrate each element
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
W_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
G_m = E.G_map()
B, Jdet = G_m(x_ip[i], x_ip[j], Coords)
B_T = np.transpose(B)
Ke = Ke + B_T.dot(B) * k * Jdet * W_ip[i] * W_ip[j]
#print(Ke)
#Ke = Ke + ((np.transpose(B)) * k * B * Jdet * W_ip[i] * W_ip[j])
#Ke = Ke + (np.dot(np.transpose(B_val), k*B_val) * abs(J_d_val)*w_ip[i]*w_ip[j])
#file = open('../outputs/K_elemental.txt', 'w')
#for i in range(4):
# if i != 0:
# file.write('\n')
# for j in range(4):
# file.write(str(K[i, j]))
# file.write(" ")
#file.close()
return Ke
def Dif_basic_F(S, Coords):
E = Element("Q4")
N = E.N()
G_map = E.G_map()
F = np.zeros((len(Coords), 1))
#print(F)
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
W_ip = [1, 1]
for i in range(len(x_ip)):
N_l = N(x_ip[i], x_ip[i]) #N local
N_T = np.transpose(N_l)
B, Jdet = G_map(x_ip[i], x_ip[i], Coords)
#print("N_T is ",N_T)
S_val = S(x_ip[i], x_ip[i])
#print(S_val)
F = F + N_T * S_val * Jdet * W_ip[i] * W_ip[i]
#print(F)
#reference file
file = open('../outputs/f_elemental.txt', 'w')
for i in range(4):
if i != 0:
file.write('\n')
file.write(str(F[i]))
file.write(" ")
file.close()
return F
def VectorF3D(Coords, n, Coefficients, sourceFunc, El_type, Upwinded):
E = Element(El_type)
weights = [1, 1]
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
f_ele = np.zeros((len(Coords), 1))
for i in range(len(x_ip)):
for j in range(len(x_ip)):
for k in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], x_ip[k])
N_T = N.transpose()
B, Jdet = E.G(x_ip[i], x_ip[j], x_ip[k], Coords)
B_T = B.transpose()
x_coord = np.array([Coords[:, 0]]) @ N_T
y_coord = np.array([Coords[:, 1]]) @ N_T
z_coord = np.array([Coords[:, 2]]) @ N_T
source = SourceTerm3D([x_coord, y_coord, z_coord],
Coefficients, sourceFunc)
f_ele += N_T * source * Jdet * weights[i] * weights[
j] * weights[k]
if Upwinded == True:
delta = CalcDelta3D(Coefficients,
[x_coord, y_coord, z_coord], n)
f_ele += delta * np.dot(B_T, n.transpose(
)) * source * Jdet * weights[i] * weights[j] * weights[k]
return f_ele
def MatrixS3D(Coords, n, Coefficients, el_type, Upwinded):
E = Element(el_type)
Se = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
weights = [1, 1]
x_0 = Coefficients[6]
r_c = Coefficients[4]
for i in range(len(x_ip)):
for j in range(len(x_ip)):
for k in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], x_ip[k])
N_T = N.transpose()
B, Jdet, G, J_inv = E.G_ext(x_ip[i], x_ip[j], x_ip[k], Coords)
B_T = B.transpose()
x_coord = np.array([Coords[:, 0]]) @ N_T
y_coord = np.array([Coords[:, 1]]) @ N_T
z_coord = np.array([Coords[:, 2]]) @ N_T
sigma = Coefficients[3](x_coord, y_coord, z_coord, r_c, x_0)
Se += -N_T * (
sigma) * N * Jdet * weights[i] * weights[j] * weights[k]
if Upwinded == True:
delta = CalcDelta3D(Coefficients,
[x_coord, y_coord, z_coord], n)
Se += -delta * np.dot(
B_T, n.transpose()
) * sigma * N * Jdet * weights[i] * weights[j] * weights[k]
return Se
def getStiffnessmatrix(C, D, thickness, el_epsilon, pt):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
Ke = np.zeros((8, 8))
ke(xIP, C, D, el_epsilon, pt, weights, thickness, E, Ke)
return Ke
def getdkdumatrix(C, D_prime, thickness, el_sigma):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
Ke = np.zeros((8, 8))
ke_prime(xIP, C, D_prime, el_sigma, weights, thickness, E, Ke)
return Ke
def __init__(self, context):
super().__init__(context)
self.delete_product_icon = Element(By.ID, 'id_form-0-DELETE', context)
self.confirm_deleting_product_button = Element(
By.XPATH, '//button[contains(text(), "Confirm")]', context)
self.cart_content = Element(By.XPATH,
'//div[@class="checkout__main-content"]',
context)
self.empty_cart_message = Element(
By.XPATH,
'//p[contains(@class, "checkout-container__headline-empty")]',
context)
self.empty_cart_message_text = 'Your cart is empty'
def __init__(self, context):
super().__init__(context)
self.email_field = Element(
By.NAME, 'username', context
)
self.password_field = Element(
By.NAME, 'password', context
)
self.next_button = Element(
By.ID, 'idp-discovery-submit', context
)
self.login_button = Element(
By.ID, 'okta-signin-submit', context
)
def Dif_basic_K(el_type,
Coords,
k=1,
P_type='scalar'): #let k be an optional arguement
El = Element(el_type)
if el_type == 'Q4':
num_nodes = 4 # number of nodes
elif el_type == 'Q8':
num_nodes = 8
else:
print('Please enter a valid element type')
K = np.zeros((num_nodes, num_nodes))
G = El.G() # snag B-matrix for element
if (P_type == 'scalar'
): # calculates B function based on scalar or vector problem!
B = G
elif (P_type == 'vector'):
B = np.zeros((3, 8))
for i in range(2 * num_nodes):
B[0, 2 * i] = G[0, i]
B[1, 2 * i - 1] = G[1, i]
B[2, 2 * i] = G[0, i]
B[2, 2 * i - 1] = G[1, i]
else:
print('Please enter valid problem type')
#calculate jacobian determinant -- take another look at this!!!!!
J = lambda x, y: np.dot(G(x, y), Coords)
J_d = lambda x, y: np.linalg.det(J(x, y))
# K_mat = lambda x, y: np.dot(np.transpose(B(x,y)), k*B(x,y))*abs(Jd_m(x,y)) # Create K_matrix based on definition in scalar problem - heat
#K_mat = lambda x, y: np.dot(K_mat1(x,y), J(x,y)) ##if mapped element, compute jacobian and tack on
#print(K_mat(0,0)[0,0])
# Now to step through K_mat and integrate each element
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
w_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
B_val = G(x_ip[i], x_ip[j])
J_d_val = J_d(x_ip[i], x_ip[j])
#print(B_val)
#print(J_d_val)
Ke = Ke + (np.dot(np.transpose(B_val), k * B_val) * abs(J_d_val) *
w_ip[i] * w_ip[j])
print(Ke)
file = open('../outputs/K_elemental.txt', 'w')
for i in range(4):
if i != 0:
file.write('\n')
for j in range(4):
file.write(str(K[i, j]))
file.write(" ")
file.close()
return Ke
def __init__(self, context):
self.context = context
# MENU OPTIONS
self.login_button = Element(
By.XPATH, '//div[contains(@class, "header-menu__logged-out")]',
context)
self.cart_icon = Element(
By.XPATH, '//div[contains(@class,"js-cart-menu-container")]',
context)
self.go_to_checkout_button = Element(
By.XPATH, '//a[contains(text(),"Go to Checkout")]', context)
self.cookie_button = Element(By.XPATH,
'//input[@value="Agree and Proceed"]',
context)
self.country_modal_accept_button = Element(
By.XPATH, '//a[contains(text(),"I understand")]', context)
def calcStressStrainElemental(d, A, NodalCoord, Connectivity):
#calculate strains in center of element!
E = Element("Q4")
stress = np.zeros((3, len(Connectivity)))
strain = np.zeros((3, len(Connectivity)))
for e in range(0, len(Connectivity)):
Coord_mat_el = getElementCoordinates(e, NodalCoord, Connectivity)
Elemental_disp = getElementDisplacements(e, d, A)
gradN, detJ = E.G_map(0, 0, Coord_mat_el)
B = get_B_plane_stress(gradN)
strain[:, e] = np.dot(B, Elemental_disp)[:, 0]
stress[:, e] = strain[:, e]
return strain, stress
def ES_K(Coords):
num_nodes = 4 # number of nodes
E = Element("Q4")
# Now to step through K_mat and integrate each element
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
print(len(Coords))
W_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
G_m = E.G_map()
B, Jdet = G_m(x_ip[i], x_ip[j], Coords)
def getInternalForces(Coord_mat_el,sigma):
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
fint_pre = np.zeros((1,8))
count = 0
for i in range(len(xIP)):
for j in range(len(xIP)):
gradN, detJ = E.G_map(xIP[i], xIP[j], Coord_mat_el)
B = get_B_plane_stress(gradN)
fint_pre += np.dot(np.transpose(B),sigma[:,count]) * detJ * weights[i] * weights[j]
count += 1
return np.transpose(fint_pre)
def F_GRAV(trac):
f_grav = np.zeros((8, 1))
E = Element("Q4")
weights = [1, 1]
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
for k in range(len(xIP)):
s = xIP[k]
N = E.N(s, s)
J_s = np.matrix(detJsideQ4(s, s))
n_mat = np.matrix(N.transpose())
trac_mat = np.matrix(trac)
f_grav += n_mat * trac_mat * J_s[0, k] * weights[k]
return f_grav
def getStrainElement(Coord_mat_el, d):
E = Element("Q4")
xIP = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
epsilon = np.zeros((3, 4))
count = 0
for i in range(len(xIP)):
for j in range(len(xIP)):
gradN, detJ = E.G_map(xIP[i], xIP[j], Coord_mat_el)
B = get_B_plane_stress(gradN)
val = np.dot(B, d)
for k in range(3):
epsilon[k, count] = val[k]
count += 1
return epsilon
def Dif_basic_K(Coords, k=1): #let k be an optional arguement
E = Element("Q4")
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
W_ip = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)): # now ready to integrate
G_m = E.G_map()
B, Jdet = G_m(x_ip[i], x_ip[j], Coords)
B_T = np.transpose(B)
Ke = Ke + B_T.dot(B) * k * Jdet * W_ip[i] * W_ip[j]
return Ke
def MatrixT(Coords, Coefficients, Upwinded):
E = Element('S2')
Ke = np.zeros((2, 2))
#x_ip = [-np.sqrt(3)/3,np.sqrt(3)/3]
#weights = [1,1]
x_ip = [0]
weights = [2]
h = (Coords[1][0] - Coords[0][0])
Jdet = h / 2
a = Coefficients[0]
for i in range(len(x_ip)):
N = E.N(x_ip[i])
N_T = N.transpose()
B = E.G(x_ip[i], Coords)
B_T = B.transpose()
Ke += a * N_T * B * Jdet * weights[i] + (
h / 2) * a * B_T * B * Jdet * weights[i]
return Ke
def MatrixT2D(Coords, n, Coefficients, el_type, Upwinded):
E = Element(el_type)
Te = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
weights = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], 0)
N_T = N.transpose()
B, Jdet, G, J_inv = E.G_ext(x_ip[i], x_ip[j], 0, Coords)
B_T = B.transpose()
Te += N_T * np.dot(n, B) * Jdet * weights[i] * weights[j]
if Upwinded == True:
x_coord = np.array([Coords[:, 0]]) @ N.transpose()
y_coord = np.array([Coords[:, 1]]) @ N.transpose()
delta = CalcDelta2D(Coefficients, [x_coord, y_coord], n)
Te += delta * np.dot(B_T, n.transpose()) * np.dot(
n, B) * Jdet * weights[i] * weights[j]
return Te
def Dif_basic_F(el_type, S, Coords, P_type='scalar'):
El = Element('Q4')
if el_type == 'Q4':
num_nodes = 4
elif el_type == 'Q8':
num_nodes = 8
else:
print('Please enter a valid element type')
G = El.G() # snag B-matrix for element
if (P_type == 'scalar'
): # calculates B function based on scalar or vector problem!
B = G
elif (P_type == 'vector'):
B = np.zeros((3, 8))
for i in range(2 * num_nodes):
B[0, 2 * i] = G[0, i]
B[1, 2 * i - 1] = G[1, i]
B[2, 2 * i] = G[0, i]
B[2, 2 * i - 1] = G[1, i]
else:
print('Please enter valid problem type')
F = np.zeros(len(Coords))
N = El.N() # snag B-matrix for element
J = lambda x, y: np.dot(G(x, y), Coords)
J_d = lambda x, y: np.linalg.det(J(x, y))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
w_ip = [1, 1]
for i in range(len(x_ip)):
N_val = N(x_ip[i], x_ip[i])
J_d_val = J_d(x_ip[i], x_ip[i])
S_val = S(x_ip[i], x_ip[i])
F = F + np.dot(np.transpose(N_val), S_val * J_d_val * w_ip[i])
#reference file
file = open('../outputs/f_elemental.txt', 'w')
for i in range(4):
if i != 0:
file.write('\n')
file.write(str(F[0, i]))
file.write(" ")
file.close()
return F
def VectorF(Coords, Coefficients, sourceFunc, Upwinded):
E = Element("S2")
#x_ip = [-np.sqrt(3)/3,np.sqrt(3)/3]
#weights = [1,1]
x_ip = [0]
weights = [2]
f_ele = np.zeros((2, 1))
h = (Coords[1][0] - Coords[0][0])
Jdet = h / 2
a = Coefficients[0]
for i in range(len(x_ip)):
N = E.N(x_ip[i])
N_T = N.transpose()
B = E.G(x_ip[i], Coords)
B_T = B.transpose()
x_coord = np.dot(np.array([Coords[:, 0]]), N.transpose())
source = SourceTerm(Coords, Coefficients, sourceFunc)
f_ele += N_T * source * Jdet * weights[
i] #+ (h/2)* a * B_T *source * Jdet * weights[i]
return f_ele
def MatrixK2D(Coords, n, Coefficients, el_type, Upwinded):
E = Element(el_type)
Ke = np.zeros((len(Coords), len(Coords)))
x_ip = [-np.sqrt(3) / 3, np.sqrt(3) / 3]
weights = [1, 1]
for i in range(len(x_ip)):
for j in range(len(x_ip)):
N = E.N(x_ip[i], x_ip[j], 0)
N_T = N.transpose()
B, Jdet, G, J_inv = E.G_ext(x_ip[i], x_ip[j], 0, Coords)
B_T = B.transpose()
x_coord = np.array([Coords[:, 0]]) @ N_T
y_coord = np.array([Coords[:, 1]]) @ N_T
kappa_and_sigma = (Coefficients[0](x_coord, y_coord) +
Coefficients[3](x_coord, y_coord))
Ke += N_T * (kappa_and_sigma) * N * Jdet * weights[i] * weights[j]
if Upwinded == True:
delta = CalcDelta2D(Coefficients, [x_coord, y_coord], n)
Ke += delta * np.dot(B_T, n.transpose(
)) * kappa_and_sigma * N * Jdet * weights[i] * weights[j]
return Ke
def _render(self):
self.element = Element(self.haml, self.attr_wrapper)
self.django_variable = self.element.django_variable
self.before = self._render_before(self.element)
self.after = self._render_after(self.element)
self._render_children()
def _render_tag(self):
self.element = Element(self.haml)
self.django_variable = self.element.django_variable
return self._generate_html(self.element)
def generateEquation():
# ax + bx = c + d
random.seed(datetime.now())
a = random.randint(-10, 10)
if a == 0:
a = random.randint(1, 10)
b = random.randint(-10, 10)
if b == 0:
b = random.randint(1, 10)
x = random.randint(-10, 10)
if x == 0:
x = random.randint(1, 10)
total = a * x + b * x
c = random.randint(-10, 10)
if c == 0:
c = random.randint(1, 10)
d = total - c
#print("{0:3d}X + {1:3d}X = {2:3d} + {3:3d}".format(a, b, c, d))
#print("X = {0:3d}".format(x))
leftSide = ""
rightSide = ""
def trueOrFalse():
if random.randint(1, 100) > 50:
return True
return False
# true ==> move ax to right side of =
moveAX = trueOrFalse()
# true ==> move bx to right side of =
moveBX = trueOrFalse()
# true ==> move C to left side of =
moveC = trueOrFalse()
# true ==> move D to left side of =
moveD = trueOrFalse()
#cannot allow all elements at right
if moveAX == True and moveBX == True and moveC == False:
moveD = True
# cannot allow all elements at left
if moveAX == False and moveBX == False and moveC == True:
moveD = False
# true ==> = mX + ...
# False ==> = ... + mX
rightSideXFirst = trueOrFalse()
# true ==> mX + ... =
# False ==> ... + mX =
leftSideXFirst = trueOrFalse()
leftElements = []
if leftSideXFirst:
if moveAX == False:
leftElements.append(Element(True, a))
if moveBX == False:
leftElements.append(Element(True, b))
if moveC == True:
leftElements.append(Element(False, c * (-1)))
if moveD == True:
leftElements.append(Element(False, d * (-1)))
else:
if moveC == True:
leftElements.append(Element(False, c * (-1)))
if moveD == True:
leftElements.append(Element(False, d * (-1)))
if moveAX == False:
leftElements.append(Element(True, a))
if moveBX == False:
leftElements.append(Element(True, b))
rightElements = []
if rightSideXFirst:
if moveAX == True:
rightElements.append(Element(True, a * (-1)))
if moveBX == True:
rightElements.append(Element(True, b * (-1)))
if moveC == False:
rightElements.append(Element(False, c))
if moveD == False:
rightElements.append(Element(False, d))
else:
if moveC == False:
rightElements.append(Element(False, c))
if moveD == False:
rightElements.append(Element(False, d))
if moveAX == True:
rightElements.append(Element(True, a * (-1)))
if moveBX == True:
rightElements.append(Element(True, b * (-1)))
result = buildEquation(leftElements, rightElements)
#print("debug : {0:3d}X + {1:3d}X = {2:3d} + {3:3d} , x = {4:3d}".format(a, b, c, d, x))
return result + " ; X = {0:3d}".format(x)
def __init__(self):
self.elements = []
with open('elements.csv') as csv_file:
csv_reader = csv.reader(csv_file, delimiter=',')
for row in csv_reader:
self.elements.append(Element(row[0], row[1], row[2], row[3]))
def __init__(self, context):
super().__init__(context)
self.product_title = Element(By.XPATH, '//a[contains(text(), "{}")]',
context)
def __init__(self):
self.table = (
# 1st period
Element(1, 'Hydrogen', 1, 1, 'H'),
Element(2, 'Helium', 1, 18, 'He'),
# 2nd period
Element(3, 'Lithium', 2, 1, 'Li'),
Element(4, 'Beryllium', 2, 2, 'Li'),
Element(5, 'Boron', 2, 13, 'B'),
Element(6, 'Carbon', 2, 14, 'C'),
Element(7, 'Nitrogen', 2, 15, 'N'),
Element(8, 'Oxygen', 2, 16, 'O'),
Element(9, 'Fluorine', 2, 17, 'F'),
Element(10, 'Neon', 2, 18, 'Ne'),
# 3rd period
Element(11, 'Sodium', 3, 1, 'Na'),
Element(12, 'Magnesium', 3, 2, 'Mg'),
Element(13, 'Aluminium', 3, 13, 'Al'),
Element(14, 'Silicon', 3, 14, 'Si'),
Element(15, 'Phosphorus', 3, 15, 'P'),
Element(16, 'Sulfur', 3, 16, 's'),
Element(17, 'Chlorine', 3, 17, 'Cl'),
Element(18, 'Argon', 3, 18, 'Ar'),
# 4th period
Element(19, 'Potassium', 4, 1, 'K'),
Element(20, 'Calcium', 4, 2, 'Ca'),
Element(21, 'Scandium', 4, 3, 'Sc'),
Element(22, 'Titanium', 4, 4, 'Ti'),
Element(23, 'Vanadium', 4, 5, 'V'),
Element(24, 'Chromium', 4, 6, 'Cr'),
Element(25, 'Manganese', 4, 7, 'Mn'),
Element(26, 'Iron', 4, 8, 'Fe'),
Element(27, 'Cobalt', 4, 9, 'Co'),
Element(28, 'Nickel', 4, 10, 'Ni'),
Element(29, 'Copper', 4, 11, 'Cu'),
Element(30, 'Zinc', 4, 12, 'Zn'),
Element(31, 'Gallium', 4, 13, 'Ga'),
Element(32, 'Germanium', 4, 14, 'Ge'),
Element(33, 'Arsenic', 4, 15, 'As'),
Element(34, 'Selenium', 4, 16, 'Se'),
Element(35, 'Bromine', 4, 17, 'Br'),
Element(36, 'Krypton', 4, 18, 'Kr'),
# 5th period
Element(37, 'Rubidium', 5, 1, 'Rb'),
Element(38, 'Strontium', 5, 2, 'Sr'),
Element(39, 'Scandium', 5, 3, 'Sc'),
Element(40, 'Zirconium', 5, 4, 'Zr'),
Element(41, 'Niobium', 5, 5, 'Nb'),
Element(42, 'Molybdenur', 5, 6, 'Mo'),
Element(43, 'Technetium', 5, 7, 'Tc'),
Element(44, 'Ruthenium', 5, 8, 'Ru'),
Element(45, 'Rhodium', 5, 9, 'Rh'),
Element(46, 'Palladium', 5, 10, 'Pd'),
Element(47, 'Silver', 5, 11, 'Ag'),
Element(48, 'Cadmium', 5, 12, 'Cd'),
Element(49, 'Induium', 5, 13, 'In'),
Element(50, 'Tin', 5, 14, 'Sn'),
Element(51, 'Antimony', 5, 15, 'Sb'),
Element(52, 'Tellurium', 5, 16, 'Te'),
Element(53, 'Iodine', 5, 17, 'I'),
Element(54, 'Xenon', 5, 18, 'Xe'),
# 6th period
Element(55, 'Caesium', 6, 1, 'Cs'),
Element(56, 'Barium', 6, 2, 'Ba'),
Element(57, 'Lanthanum', 6, 3, 'La'),
Element(72, 'Hafnium', 6, 4, 'Hf'),
Element(73, 'Tantalum', 6, 5, 'Ta'),
Element(74, 'Tungsten', 6, 6, 'W'),
Element(75, 'Rhenium', 6, 7, 'Re'),
Element(76, 'Osmium', 6, 8, 'Os'),
Element(77, 'Iridium', 6, 9, 'Ir'),
Element(78, 'Platinum', 6, 10, 'Pt'),
Element(79, 'Gold', 6, 11, 'Au'),
Element(80, 'Mercury', 6, 12, 'Hg'),
Element(81, 'Thallium', 6, 13, 'Tl'),
Element(82, 'Lead', 6, 14, 'Pb'),
Element(83, 'Bismuth', 6, 15, 'Bi'),
Element(84, 'Polonium', 6, 16, 'Po'),
Element(85, 'Astatine', 6, 17, 'At'),
Element(86, 'Radeon', 6, 18, 'Rn'),
# 7th period
Element(87, 'Francium', 7, 1, 'Fr'),
Element(88, 'Radium', 7, 2, 'Ra'),
Element(89, 'Actinium', 7, 3, 'Ac'),
Element(104, 'Rutherfordium', 7, 4, 'Rf'),
Element(105, 'Dubnium', 7, 5, 'Db'),
Element(106, 'Seaborgium', 7, 6, 'Sg'),
Element(107, 'Bohrium', 7, 7, 'Bh'),
Element(108, 'Hassium', 7, 8, 'Hs'),
Element(109, 'Meitnerium', 7, 9, 'Mt'),
Element(110, 'Damstadium', 7, 10, 'Ds'),
Element(111, 'Roentgenium', 7, 11, 'Rg'),
Element(112, 'Copernicium', 7, 12, 'Cn'),
Element(113, 'Nihonium', 7, 13, 'Nh'),
Element(114, 'Flerovium', 7, 14, 'Fl'),
Element(115, 'Moscovium', 7, 15, 'Mc'),
Element(116, 'Livermorium', 7, 16, 'Lv'),
Element(117, 'Tennessine', 7, 17, 'Ts'),
Element(118, 'Oganesson', 7, 18, 'Og'))
