def create_halite(self): # NaCl
# Major elements
sodium = PeriodicSystem(name="Na").get_data()
chlorine = PeriodicSystem(name="Cl").get_data()
majors_name = ["Na", "Cl"]
majors_data = np.array([["Na", sodium[1], 1, sodium[2]], ["Cl", chlorine[1], 1, chlorine[2]]], dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = ["I", "Br", "Fe", "O"]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [round(rd.uniform(0., 0.001), 6) for i in range(len(self.traces_list))]
for i in range(len(self.traces_list)):
traces_data.append([str(self.traces_list[i]), int(traces[i][1]), float(x_traces[i])])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
data = []
#
mineral = "Hl"
#
# Molar mass
molar_mass_pure = sodium[2] + chlorine[2]
molar_mass, amounts = MineralChemistry(w_traces=traces_data, molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [PeriodicSystem(name=amounts[i][0]).get_data() for i in range(len(amounts))]
# Density
dataV = CrystalPhysics([[5.6404], [], "cubic"])
V = dataV.calculate_volume()
dataRho = CrystalPhysics([molar_mass, 4, V])
rho = dataRho.calculate_bulk_density()
rho_e = wg(amounts=amounts, elements=element, rho_b=rho).calculate_electron_density()
# Bulk modulus
K = 23*10**9
# Shear modulus
G = 14.33*10**9
# Young's modulus
E = (9*K*G)/(3*K + G)
# Poisson's ratio
nu = (3*K - 2*G)/(2*(3*K + G))
# vP/vS
vPvS = ((K + 4/3*G)/G)**0.5
# P-wave velocity
vP = ((K + 4/3*G)/rho)**0.5
# S-wave velocity
vS = (G/rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe*rho_e*10**(-3)
# Electrical resistivity
p = 5*10**8
#
if self.dict == False:
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([round(K*10**(-9), 2), round(G*10**(-9), 2), round(E*10**(-9), 2), round(nu, 4)])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = molar_mass
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G*10**(-9), 4)
results["K"] = round(K*10**(-9), 4)
results["E"] = round(E*10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_organics_matter(self):
# Major elements
carbohydrates = Organics(data_type=True).create_carbohydrates()
lignin = Organics(data_type=True).create_lignin()
lipid = Organics(data_type=True).create_lipid()
hydrogen = PeriodicSystem(name="H").get_data()
carbon = PeriodicSystem(name="C").get_data()
nitrogen = PeriodicSystem(name="N").get_data()
oxygen = PeriodicSystem(name="O").get_data()
sulfur = PeriodicSystem(name="S").get_data()
majors_name = ["H", "C", "N", "O", "S"]
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "pure":
var_state = "variable"
else:
var_state = "variable"
if self.impurity == "random":
self.traces_list = []
minors = [None]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [
PeriodicSystem(name=i).get_data() for i in self.traces_list
]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
data = []
#
mineral = "Org"
#
# Molar mass
condition = False
while condition == False:
w_ch = round(rd.uniform(0.4, 0.6), 4)
w_lg = round(rd.uniform(0.2, float(1 - w_ch)), 4)
w_lp = round(1 - w_ch - w_lg, 4)
if w_ch + w_lg + w_lp == 1.0:
condition = True
#
majors_data = np.array(
[[
"H", hydrogen[1], w_ch * carbohydrates["chemistry"]["H"] +
w_lg * lignin["chemistry"]["H"] +
w_lp * lipid["chemistry"]["H"], hydrogen[2]
],
[
"C", carbon[1], w_ch * carbohydrates["chemistry"]["C"] +
w_lg * lignin["chemistry"]["C"] +
w_lp * lipid["chemistry"]["C"], carbon[2]
],
["N", nitrogen[1], w_lg * lignin["chemistry"]["N"], nitrogen[2]],
[
"O", oxygen[1], w_ch * carbohydrates["chemistry"]["O"] +
w_lg * lignin["chemistry"]["O"] +
w_lp * lipid["chemistry"]["O"], oxygen[2]
], ["S", sulfur[1], w_lg * lignin["chemistry"]["S"], sulfur[2]]],
dtype=object)
#
molar_mass_pure = w_ch * carbohydrates["M"] + w_lg * lignin[
"M"] + w_lp * lipid["M"]
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
amounts2 = []
w_H = round(
(w_ch * carbohydrates["chemistry"]["H"] +
w_lg * lignin["chemistry"]["H"] + w_lp * lipid["chemistry"]["H"])
* hydrogen[2] / molar_mass_pure, 4)
w_C = round(
(w_ch * carbohydrates["chemistry"]["C"] +
w_lg * lignin["chemistry"]["C"] + w_lp * lipid["chemistry"]["C"])
* carbon[2] / molar_mass_pure, 4)
w_N = round(
(w_lg * lignin["chemistry"]["N"]) * nitrogen[2] / molar_mass_pure,
4)
w_S = round(
(w_lg * lignin["chemistry"]["S"]) * sulfur[2] / molar_mass_pure, 4)
w_O = round(1 - w_H - w_C - w_N - w_S, 4)
data_H = ["H", 1, w_H]
data_C = ["C", 6, w_C]
data_N = ["N", 7, w_N]
data_O = ["O", 8, w_O]
data_S = ["S", 16, w_S]
amounts2.extend([data_H, data_C, data_N, data_O, data_S])
amounts = amounts2
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
rho = w_ch * carbohydrates["rho"] + w_lg * lignin[
"rho"] + w_lp * lipid["rho"]
V_m = molar_mass / rho
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
K = w_ch * carbohydrates["K"] + w_lg * lignin["K"] + w_lp * lipid[
"K"] * 10**9
# Shear modulus
G = w_ch * carbohydrates["G"] + w_lg * lignin["G"] + w_lp * lipid[
"G"] * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.data_type == False:
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = round(molar_mass, 3)
results["state"] = var_state
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V_m, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_allabogdanite(self): # (Fe,Ni)2 P
#
name = "Abgd"
#
# Major elements
phosphorus = PeriodicSystem(name="P").get_data()
iron = PeriodicSystem(name="Fe").get_data()
nickel = PeriodicSystem(name="Ni").get_data()
majors_name = ["P", "Fe", "Ni"]
w_Fe = round(rd.uniform(0.25, 0.75), 4)
majors_data = np.array(
[["P", phosphorus[1], 1, phosphorus[2]],
["Fe", iron[1], round(2 * w_Fe, 4), iron[2]],
["Ni", nickel[1],
round(2 * (1 - w_Fe), 4), nickel[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "pure":
var_state = "variable"
else:
var_state = "variable"
if self.impurity == "random":
self.traces_list = []
minors = [None]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
# Molar mass
molar_mass_pure = 2 * (w_Fe * iron[2] +
(1 - w_Fe) * nickel[2]) + phosphorus[2]
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV_Fe = CrystalPhysics([[5.811, 3.431], [], "hexagonal"])
V_Fe = dataV_Fe.calculate_volume()
Z_Fe = 3
V_m_Fe = MineralChemistry().calculate_molar_volume(volume_cell=V_Fe,
z=Z_Fe)
dataRho_Fe = CrystalPhysics([molar_mass, Z_Fe, V_Fe * 10**(6)])
rho_Fe = dataRho_Fe.calculate_bulk_density()
rho_e_Fe = wg(amounts=amounts, elements=element,
rho_b=rho_Fe).calculate_electron_density()
#
dataV_Ni = CrystalPhysics([[5.873, 3.349], [], "hexagonal"])
V_Ni = dataV_Ni.calculate_volume()
Z_Ni = 3
V_m_Ni = MineralChemistry().calculate_molar_volume(volume_cell=V_Ni,
z=Z_Ni)
dataRho_Ni = CrystalPhysics([molar_mass, Z_Ni, V_Ni * 10**(6)])
rho_Ni = dataRho_Ni.calculate_bulk_density()
rho_e_Ni = wg(amounts=amounts, elements=element,
rho_b=rho_Ni).calculate_electron_density()
#
V_m = w_Fe * V_m_Fe + (1 - w_Fe) * V_m_Ni
rho = w_Fe * rho_Fe + (1 - w_Fe) * rho_Ni
rho_e = w_Fe * rho_e_Fe + (1 - w_Fe) * rho_e_Ni
# Bulk modulus
K_Fe = 216 * 10**9
K_Ni = 194 * 10**9
K = w_Fe * K_Fe + (1 - w_Fe) * K_Ni
# Shear modulus
G_Fe = 89 * 10**9
G_Ni = 42 * 10**9
G = w_Fe * G_Fe + (1 - w_Fe) * G_Ni
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.data_type == False:
data = []
data.append(name)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
results = {}
results["mineral"] = name
results["state"] = var_state
results["M"] = molar_mass
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V_m, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_aptite(self): # Ca5 (F,Cl,OH) (PO4)3
# Major elements
hydrogen = PeriodicSystem(name="H").get_data()
oxygen = PeriodicSystem(name="O").get_data()
fluorine = PeriodicSystem(name="F").get_data()
phosphorus = PeriodicSystem(name="P").get_data()
chlorine = PeriodicSystem(name="Cl").get_data()
calcium = PeriodicSystem(name="Ca").get_data()
majors_name = ["H", "O", "F", "P", "Cl", "Ca"]
a = round(rd.uniform(0, 1), 4)
b = round(rd.uniform(0, (1 - a)), 4)
c = round(1 - a - b, 4)
majors_data = np.array([["H", hydrogen[1], c, hydrogen[2]],
["O", oxygen[1], 12 + c, oxygen[2]],
["F", fluorine[1], a, fluorine[2]],
["P", phosphorus[1], 3, phosphorus[2]],
["Cl", chlorine[1], b, chlorine[2]],
["Ca", calcium[1], 5, calcium[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = [
"La", "Ce", "Pr", "Nd", "Sm", "Eu", "Gd", "Dy", "Y", "Er", "Mn"
]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
data = []
mineral = "Ap"
#
# Molar mass
molar_mass_pure = 5 * calcium[2] + a * fluorine[2] + b * chlorine[
2] + c * (hydrogen[2] + oxygen[2]) + 3 * (phosphorus[2] +
4 * oxygen[2])
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV_F = CrystalPhysics([[9.367, 6.884], [], "hexagonal"])
V_F = dataV_F.calculate_volume()
Z_F = 2
V_m_F = MineralChemistry().calculate_molar_volume(volume_cell=V_F,
z=Z_F)
dataRho_F = CrystalPhysics([molar_mass, Z_F, V_F * 10**(6)])
rho_F = dataRho_F.calculate_bulk_density()
rho_e_F = wg(amounts=amounts, elements=element,
rho_b=rho_F).calculate_electron_density()
#
dataV_Cl = CrystalPhysics([[9.598, 6.776], [], "hexagonal"])
V_Cl = dataV_Cl.calculate_volume()
Z_Cl = 2
V_m_Cl = MineralChemistry().calculate_molar_volume(volume_cell=V_Cl,
z=Z_Cl)
dataRho_Cl = CrystalPhysics([molar_mass, Z_Cl, V_Cl * 10**(6)])
rho_Cl = dataRho_Cl.calculate_bulk_density()
rho_e_Cl = wg(amounts=amounts, elements=element,
rho_b=rho_Cl).calculate_electron_density()
#
dataV_OH = CrystalPhysics([[9.418, 6.875], [], "hexagonal"])
V_OH = dataV_OH.calculate_volume()
Z_OH = 2
V_m_OH = MineralChemistry().calculate_molar_volume(volume_cell=V_OH,
z=Z_OH)
dataRho_OH = CrystalPhysics([molar_mass, Z_OH, V_OH * 10**(6)])
rho_OH = dataRho_OH.calculate_bulk_density()
rho_e_OH = wg(amounts=amounts, elements=element,
rho_b=rho_OH).calculate_electron_density()
#
V_m = a * V_m_F + b * V_m_Cl + c * V_m_OH
rho = a * rho_F + b * rho_Cl + c * rho_OH
rho_e = a * rho_e_F + b * rho_e_Cl + c * rho_e_OH
# Bulk modulus
K_F = 83 * 10**9
K_Cl = 98.70 * 10**9
K_OH = 105.01 * 10**9
K = a * K_F + b * K_Cl + c * K_OH
# Shear modulus
G_F = 41 * 10**9
G_Cl = 61.17 * 10**9
G_OH = 62.69 * 10**9
G = a * G_F + b * G_Cl + c * G_OH
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.data_type == False:
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = molar_mass
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V_m, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_lipid(self):
# Major elements
hydrogen = PeriodicSystem(name="H").get_data()
carbon = PeriodicSystem(name="C").get_data()
oxygen = PeriodicSystem(name="O").get_data()
majors_name = ["H", "C", "O"]
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = [None]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
mineral = "lipid"
#
# Molar mass
molar_mass_pure = 0.10 * hydrogen[2] + 0.80 * carbon[
2] + 0.10 * oxygen[2]
#
majors_data = np.array([["H", hydrogen[1], 0.10, hydrogen[2]],
["C", carbon[1], 0.80, carbon[2]],
["O", oxygen[1], 0.10, oxygen[2]]],
dtype=object)
#
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
rho = 850
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
K = 4 * 10**9
# Shear modulus
G = 2 * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.data_type == False:
data = []
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = molar_mass
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_aptite_f(self): # Ca5 F (PO4)3
# Major elements
oxygen = PeriodicSystem(name="O").get_data()
fluorine = PeriodicSystem(name="F").get_data()
phosphorus = PeriodicSystem(name="P").get_data()
calcium = PeriodicSystem(name="Ca").get_data()
majors_name = ["O", "F", "P", "Ca"]
majors_data = np.array([["O", oxygen[1], 12, oxygen[2]],
["F", fluorine[1], 1, fluorine[2]],
["P", phosphorus[1], 3, phosphorus[2]],
["Ca", calcium[1], 5, calcium[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "pure":
var_state = "fixed"
else:
var_state = "variable"
self.traces_list = []
minors_x = ["Ti", "Zr", "Hf", "Th"] # mainly 4+
minors_y = [
"La", "Ce", "Pr", "Nd", "Sm", "Eu", "Gd", "Dy", "Y", "Er",
"Cr", "As"
] # mainly 3+
minors_z = ["Cl", "H", "Rb"] # mainly 1+
minors_w = ["Mn", "Co", "Sr", "Ba", "Pb"] # mainly 2+
if self.impurity == "random":
n_x = rd.randint(0, len(minors_x))
n_y = rd.randint(0, len(minors_y))
n_w = rd.randint(0, len(minors_w))
if n_x > 0:
selection_x = rd.sample(minors_x, n_x)
self.traces_list.extend(selection_x)
if n_y > 0 and n_w == 0:
n_z = rd.randint(1, n_y)
selection_y = rd.sample(minors_y, n_y)
selection_z = rd.sample(minors_z, n_z)
self.traces_list.extend(selection_y)
self.traces_list.extend(selection_z)
if n_w > 0 and n_y == 0:
n_z = rd.randint(1, n_w)
selection_w = rd.sample(minors_w, n_w)
selection_z = rd.sample(minors_z, n_z)
self.traces_list.extend(selection_w)
self.traces_list.extend(selection_z)
if n_y > 0 and n_w > 0:
if n_y + n_w <= len(minors_z):
n_z = rd.randint(1, (n_y + n_w))
else:
n_z = len(minors_z)
selection_y = rd.sample(minors_y, n_y)
selection_w = rd.sample(minors_w, n_w)
selection_z = rd.sample(minors_z, n_z)
self.traces_list.extend(selection_y)
self.traces_list.extend(selection_w)
self.traces_list.extend(selection_z)
elif self.impurity != "random":
self.traces_list = []
for element in self.impurity:
if element in minors_x:
self.traces_list.append(element)
elif element in minors_y:
self.traces_list.append(element)
elif element in minors_z:
self.traces_list.append(element)
elif element in minors_w:
self.traces_list.append(element)
# minors = ["Cl", "La", "Ce", "Pr", "Nd", "Sm", "Eu", "Gd", "Dy", "Y", "Er", "Mn", "H"]
# n = rd.randint(1, len(minors))
# while len(self.traces_list) < n:
# selection = rd.choice(minors)
# if selection not in self.traces_list and selection not in majors_name:
# self.traces_list.append(selection)
# else:
# continue
traces = [
PeriodicSystem(name=i).get_data() for i in self.traces_list
]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
data = []
mineral = "Ap"
#
# Molar mass
try:
molar_mass_pure = 5 * calcium[2] + fluorine[2] + 3 * (
phosphorus[2] + 4 * oxygen[2])
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
except:
compositon_data = TraceElements(
tracer=self.traces_list).calculate_composition_apatite_f()
molar_mass = 0
amounts = []
for element in compositon_data:
chem_data = PeriodicSystem(name=element).get_data()
molar_mass += compositon_data[element]["x"] * chem_data[2]
amounts.append([
chem_data[0], chem_data[1], compositon_data[element]["w"]
])
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV = CrystalPhysics([[9.367, 6.884], [], "hexagonal"])
V = dataV.calculate_volume()
Z = 2
V_m = MineralChemistry().calculate_molar_volume(volume_cell=V, z=Z)
dataRho = CrystalPhysics([molar_mass, Z, V * 10**(6)])
rho = dataRho.calculate_bulk_density()
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
K = 83 * 10**9
# Shear modulus
G = 41 * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.data_type == False:
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = molar_mass
results["state"] = var_state
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V_m, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_aptite_cl(self): # Ca5 Cl (PO4)3
# Major elements
oxygen = PeriodicSystem(name="O").get_data()
phosphorus = PeriodicSystem(name="P").get_data()
chlorine = PeriodicSystem(name="Cl").get_data()
calcium = PeriodicSystem(name="Ca").get_data()
majors_name = ["O", "P", "Cl", "Ca"]
majors_data = np.array([["O", oxygen[1], 12, oxygen[2]],
["P", phosphorus[1], 3, phosphorus[2]],
["Cl", chlorine[1], 1, chlorine[2]],
["Ca", calcium[1], 5, calcium[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = [
"F", "La", "Ce", "Pr", "Nd", "Sm", "Eu", "Gd", "Dy", "Y", "Er",
"Mn", "H"
]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
data = []
mineral = "Ap"
#
# Molar mass
molar_mass_pure = 5 * calcium[2] + chlorine[2] + 3 * (phosphorus[2] +
4 * oxygen[2])
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV = CrystalPhysics([[9.598, 6.776], [], "hexagonal"])
V = dataV.calculate_volume()
Z = 2
V_m = MineralChemistry().calculate_molar_volume(volume_cell=V, z=Z)
dataRho = CrystalPhysics([molar_mass, Z, V * 10**(6)])
rho = dataRho.calculate_bulk_density()
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
K = 98.70 * 10**9
# Shear modulus
G = 61.17 * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.data_type == False:
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = molar_mass
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V_m, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_illite(self): # (K,H3O) (Al,Mg,Fe)2 (Si,Al)4 O10 [(OH)2,(H2O)]
# Major elements
hydrogen = PeriodicSystem(name="H").get_data()
oxygen = PeriodicSystem(name="O").get_data()
magnesium = PeriodicSystem(name="Mg").get_data()
aluminium = PeriodicSystem(name="Al").get_data()
silicon = PeriodicSystem(name="Si").get_data()
potassium = PeriodicSystem(name="K").get_data()
iron = PeriodicSystem(name="Fe").get_data()
majors_name = ["H", "O", "Mg", "Al", "Si", "K", "Fe"]
#
a = round(rd.uniform(0.6, 0.8), 4)
b = round(rd.uniform(0.75, 1.0), 4)
b2 = round(rd.uniform(0.0, float(1 - b)), 4)
c = round(rd.uniform(0.975, 1.0), 4)
d = round(rd.uniform(0.75, 1.0), 4)
#
majors_data = np.array(
[["H", hydrogen[1], 3 * (1 - a) + 4 * d, hydrogen[2]],
["O", oxygen[1], (1 - a) + 10 + 3 * d, oxygen[2]],
["Mg", magnesium[1], 2 * b2, magnesium[2]],
["Al", aluminium[1], 2 * b + 4 *
(1 - c), aluminium[2]], ["Si", silicon[1], 4 * c, silicon[2]],
["K", potassium[1], a, potassium[2]],
["Fe", iron[1], 2 * (1 - b - b2), iron[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = [None]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
mineral = "Ilt"
#
# Molar mass
molar_mass_pure = a*potassium[2] + (1-a)*(3*hydrogen[2] + oxygen[2]) \
+ 2*(b*aluminium[2] + b2*magnesium[2] + (1-b-b2)*iron[2]) \
+ 4*(c*silicon[2] + (1-c)*aluminium[2]) + 10*oxygen[2] \
+ d*(2*(oxygen[2]+hydrogen[2]) + (2*hydrogen[2]+oxygen[2]))
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV = CrystalPhysics([[5.18, 8.98, 10.32], [101.83], "monoclinic"])
V = dataV.calculate_volume()
dataRho = CrystalPhysics([molar_mass, 2, V])
rho = dataRho.calculate_bulk_density()
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
K = (35.72 + (62.21 - 35.72) / (2.706 - 2.546) *
(rho / 1000 - 2.546)) * 10**9
# Shear modulus
G = (17.80 + (25.70 - 17.80) / (2.706 - 2.546) *
(rho / 1000 - 2.546)) * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.dict == False:
data = []
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = round(molar_mass, 3)
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_montmorillonite(self): # (Na,Ca)0.3(Al,Mg)2Si4O10(OH2)(H2O)10
# Major elements
hydrogen = PeriodicSystem(name="H").get_data()
oxygen = PeriodicSystem(name="O").get_data()
sodium = PeriodicSystem(name="Na").get_data()
magnesium = PeriodicSystem(name="Mg").get_data()
aluminium = PeriodicSystem(name="Al").get_data()
silicon = PeriodicSystem(name="Si").get_data()
calcium = PeriodicSystem(name="Ca").get_data()
majors_name = ["H", "O", "Na", "Mg", "Al", "Si", "Ca"]
#
x = round(rd.uniform(0.6, 0.7), 2)
y = round(rd.uniform(0.9, 1), 2)
n = rd.randint(10, 12)
#
majors_data = np.array(
[["H", hydrogen[1], 2 + 2 * n, hydrogen[2]],
["O", oxygen[1], 10 + 2 + n, oxygen[2]],
["Na", sodium[1], 0.3 * x, sodium[2]],
["Mg", magnesium[1], 2 * (1 - y), magnesium[2]],
["Al", aluminium[1], 2 * y, aluminium[2]],
["Si", silicon[1], 4, silicon[2]],
["Ca", calcium[1], 0.3 * (1 - x), calcium[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = ["Fe", "K"]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
mineral = "Mnt"
#
# Molar mass
molar_mass_pure = 0.3*(x*sodium[2]+(1-x)*calcium[2]) + 2*(y*aluminium[2]+(1-y)*magnesium[2]) + 4*silicon[2] \
+ 10*oxygen[2] + 2*(hydrogen[2]+oxygen[2]) + n*(2*hydrogen[2]+oxygen[2])
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV = CrystalPhysics([[5.17, 8.94, 9.95], [99.9], "monoclinic"])
V = dataV.calculate_volume()
dataRho = CrystalPhysics([molar_mass, 1, V])
rho = dataRho.calculate_bulk_density()
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
x_rho = [2738, 2788, 3250, 2504, 3182]
y_K = [37.30, 35.31, 49.46, 29.71, 66.59]
a_K, b_K, r_value_K, p_value_K, std_err_K = stats.linregress(
x_rho, y_K)
K = (a_K * rho + b_K) * 10**9
# Shear modulus
y_G = [17.00, 20.19, 24.70, 16.30, 27.00]
a_G, b_G, r_value_G, p_value_G, std_err_G = stats.linregress(
x_rho, y_G)
G = (a_G * rho + b_G) * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.dict == False:
data = []
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = round(molar_mass, 3)
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results
def create_kaolinite(self): # Al2(OH)4Si2O5
# Major elements
hydrogen = PeriodicSystem(name="H").get_data()
oxygen = PeriodicSystem(name="O").get_data()
aluminium = PeriodicSystem(name="Al").get_data()
silicon = PeriodicSystem(name="Si").get_data()
majors_name = ["H", "O", "Al", "Si"]
#
majors_data = np.array([["H", hydrogen[1], 4, hydrogen[2]],
["O", oxygen[1], 9, oxygen[2]],
["Al", aluminium[1], 2, aluminium[2]],
["Si", silicon[1], 2, silicon[2]]],
dtype=object)
# Minor elements
traces_data = []
if len(self.traces_list) > 0:
self.impurity = "impure"
if self.impurity == "random":
self.traces_list = []
minors = ["Fe", "Mg", "Na", "K", "Ti", "Ca"]
n = rd.randint(1, len(minors))
while len(self.traces_list) < n:
selection = rd.choice(minors)
if selection not in self.traces_list and selection not in majors_name:
self.traces_list.append(selection)
else:
continue
traces = [PeriodicSystem(name=i).get_data() for i in self.traces_list]
x_traces = [
round(rd.uniform(0., 0.001), 6)
for i in range(len(self.traces_list))
]
for i in range(len(self.traces_list)):
traces_data.append([
str(self.traces_list[i]),
int(traces[i][1]),
float(x_traces[i])
])
if len(traces_data) > 0:
traces_data = np.array(traces_data, dtype=object)
traces_data = traces_data[traces_data[:, 1].argsort()]
#
mineral = "Kln"
#
# Molar mass
molar_mass_pure = 2 * aluminium[2] + 4 * (
oxygen[2] + hydrogen[2]) + 2 * silicon[2] + 5 * oxygen[2]
molar_mass, amounts = MineralChemistry(
w_traces=traces_data,
molar_mass_pure=molar_mass_pure,
majors=majors_data).calculate_molar_mass()
element = [
PeriodicSystem(name=amounts[i][0]).get_data()
for i in range(len(amounts))
]
# Density
dataV = CrystalPhysics([[5.13, 8.89, 7.25], [90.0, 104.5, 89.8],
"triclinic"])
V = dataV.calculate_volume()
dataRho = CrystalPhysics([molar_mass, 2, V])
rho = dataRho.calculate_bulk_density()
rho_e = wg(amounts=amounts, elements=element,
rho_b=rho).calculate_electron_density()
# Bulk modulus
K = 122.54 * 10**9
# Shear modulus
G = 66.63 * 10**9
# Young's modulus
E = (9 * K * G) / (3 * K + G)
# Poisson's ratio
nu = (3 * K - 2 * G) / (2 * (3 * K + G))
# vP/vS
vPvS = ((K + 4 / 3 * G) / G)**0.5
# P-wave velocity
vP = ((K + 4 / 3 * G) / rho)**0.5
# S-wave velocity
vS = (G / rho)**0.5
# Gamma ray
gamma_ray = wg(amounts=amounts, elements=element).calculate_gr()
# Photoelectricity
pe = wg(amounts=amounts, elements=element).calculate_pe()
U = pe * rho_e * 10**(-3)
# Electrical resistivity
p = None
#
if self.dict == False:
data = []
data.append(mineral)
data.append(round(molar_mass, 3))
data.append(round(rho, 2))
data.append([
round(K * 10**(-9), 2),
round(G * 10**(-9), 2),
round(E * 10**(-9), 2),
round(nu, 4)
])
data.append([round(vP, 2), round(vS, 2), round(vPvS, 2)])
data.append([round(gamma_ray, 2), round(pe, 2), round(U, 2), p])
data.append(amounts)
#
return data
else:
#
results = {}
results["mineral"] = mineral
results["M"] = round(molar_mass, 3)
element_list = np.array(amounts)[:, 0]
results["chemistry"] = {}
for index, element in enumerate(element_list, start=0):
results["chemistry"][element] = amounts[index][2]
results["rho"] = round(rho, 4)
results["rho_e"] = round(rho_e, 4)
results["V"] = round(V, 4)
results["vP"] = round(vP, 4)
results["vS"] = round(vS, 4)
results["vP/vS"] = round(vPvS, 4)
results["G"] = round(G * 10**(-9), 4)
results["K"] = round(K * 10**(-9), 4)
results["E"] = round(E * 10**(-9), 4)
results["nu"] = round(nu, 4)
results["GR"] = round(gamma_ray, 4)
results["PE"] = round(pe, 4)
results["U"] = round(U, 4)
if p != None:
results["p"] = round(p, 4)
else:
results["p"] = p
#
return results