def test_get_mol_wt(self):
dna1 = core.DnaSpeciesType(id='dna6', sequence_path=self.sequence_path)
gene1 = eukaryote_schema.GeneLocus(polymer=dna1, start=1, end=6)
rna1 = eukaryote_schema.PreRnaSpeciesType(gene=gene1)
exon1 = eukaryote_schema.ExonLocus(start=1, end=1)
transcript1 = eukaryote_schema.TranscriptSpeciesType(rna=rna1,
exons=[exon1])
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript1.get_seq()) \
- (transcript1.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(transcript1.get_mol_wt(), exp_mol_wt, places=1)
exon2 = eukaryote_schema.ExonLocus(start=3, end=3)
transcript2 = eukaryote_schema.TranscriptSpeciesType(rna=rna1,
exons=[exon2])
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript2.get_seq()) \
- (transcript2.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(transcript2.get_mol_wt(), exp_mol_wt, places=1)
exon3 = eukaryote_schema.ExonLocus(start=5, end=5)
transcript3 = eukaryote_schema.TranscriptSpeciesType(rna=rna1,
exons=[exon3])
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript3.get_seq()) \
- (transcript3.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(transcript3.get_mol_wt(), exp_mol_wt, places=1)
def get_atomic_properties(self, atoms):
"""Get the properties of all atoms in the molecule
Arguments:
atoms {list} -- atoms and xyz position
"""
# loop over all atoms
for a in atoms:
atom_data = a.split()
self.atoms.append(atom_data[0])
x, y, z = float(atom_data[1]), float(atom_data[2]), float(
atom_data[3])
conv2bohr = 1
if self.unit == 'angs':
conv2bohr = 1.88973
self.atom_coords.append(
[x * conv2bohr, y * conv2bohr, z * conv2bohr])
self.atomic_number.append(element(atom_data[0]).atomic_number)
self.atomic_nelec.append(element(atom_data[0]).electrons)
self.nelec += element(atom_data[0]).electrons
# size of the system
self.natom = len(self.atoms)
assert self.nelec % 2 == 0, "Only systems with equal up/down electrons allowed so far"
self.nup = math.ceil(self.nelec / 2)
self.ndown = math.floor(self.nelec / 2)
def get_average_vdw_radii(site0, site1):
vdw0 = element(site0.species_string).vdw_radius
vdw1 = element(site1.species_string).vdw_radius
vdw = (vdw0 + vdw1) / 200
return vdw
def formatting(e1, e2):
e1, e2 = mdv.element(e1), mdv.element(e2)
return '\t{}[{} {}] + [{} {}]'.format(
getScoreFormat((e1.atomic_number,
e2.atomic_number)) if config['showScore'] else '',
e1.symbol if not config['fullPrint'] else e1.name, e1.atomic_number,
e2.symbol if not config['fullPrint'] else e2.name, e2.atomic_number)
def drawBonds(coords): Bonds = [] Bondslength = [] for i in range(0, len(coords)): for j in range(i+1, len(coords)): if (i == j): continue (el1, x1, y1, z1) = (mendeleev.element(coords[i][0]), coords[i][1], coords[i][2], coords[i][3]) (el2, x2, y2, z2) = (mendeleev.element(coords[j][0]), coords[j][1], coords[j][2], coords[j][3]) name = coords[i][0] + str(i) + "-" + coords[j][0] + str(j) dist = math.sqrt((x1-x2)**2 + (y1-y2)**2 + (z1-z2)**2) vdW = (el1.vdw_radius_bondi + el2.vdw_radius_bondi)/200 loc = ((x2-x1)/2 + x1, (y2-y1)/2 + y2, (z2-z1)/2 + z2) bpy.ops.mesh.primitive_cylinder_add(radius=0.05, depth=dist, location=loc) Bond = bpy.context.active_object Bond.rotation_mode = 'QUATERNION' Bond.data.materials.append(Materials[3]) rotateCyl(Bond, Atoms[i], Atoms[j], dist) if (dist > vdW): Bond.hide_render = True Bond.hide = True Bonds.append(Bond) Bondslength.append(dist) return Bonds, Bondslength
def _get_atomic_properties(self, atoms):
"""Generates the atomic propeties of the molecule
Args:
atoms (str): atoms given in input
"""
# loop over all atoms
for a in atoms:
atom_data = a.split()
self.atoms.append(atom_data[0])
x, y, z = float(atom_data[1]), float(atom_data[2]), float(
atom_data[3])
conv2bohr = 1
if self.unit == 'angs':
conv2bohr = 1.88973
self.atom_coords.append(
[x * conv2bohr, y * conv2bohr, z * conv2bohr])
self.atomic_number.append(element(atom_data[0]).atomic_number)
self.atomic_nelec.append(element(atom_data[0]).electrons)
self.nelec += element(atom_data[0]).electrons
# size of the system
self.natom = len(self.atoms)
if self.nelec % 2 != 0:
raise ValueError("Only equal spin up/down supported.")
self.nup = math.ceil(self.nelec / 2)
self.ndown = math.floor(self.nelec / 2)
# name of the system
if self.name is None:
self.name = self._get_mol_name(self.atoms)
self.atoms = np.array(self.atoms)
def get_mode(self, mode_idx):
""" Get (mode_idx + 1)-th mode in options['snf_out'].
Parameters
----------
mode_idx : :obj:`int`
index of mode.
Returns
-------
:obj:`pyiets.atoms.vibration.Mode`
Mode object
"""
wavenum, mode_vectors = self._get_mode_vectors(mode_idx)
mode_vectors = np.array(mode_vectors,
dtype=np.float64).reshape(self.natoms, 3)
isotope_masses = [
np.float64(self.options['isotope_masses'][str(
element(m).atomic_number)][str(
element(m).mass_number)]['mass'])
for m in self.molecule.atoms
]
mode = vib.Mode(vectors=mode_vectors,
atoms=self.molecule.atoms,
wavenumber=wavenum,
idx=mode_idx,
weighted=True,
isotope_masses=isotope_masses)
return mode
def write(self, fname, digits=5):
import mendeleev as md
with open(fname, "w") as out:
out.write(self.comment)
out.write("{:5}{:12.6f}{:12.6f}{:12.6f}\n".format(
len(self.geom.atoms),
self.origin[0], self.origin[1], self.origin[2]))
for i in range(3):
out.write("{:5}{:12.6f}{:12.6f}{:12.6f}\n".format(
self.Np_vect[i],
self.Vect_M[i][0], self.Vect_M[i][1], self.Vect_M[i][2]))
for i in range(len(self.geom.atoms)):
out.write('{:5}{:12.6f}{:12.6f}{:12.6f}{:12.6f}\n'.format(
md.element(self.geom.atoms[i]).atomic_number,
md.element(self.geom.atoms[i]).atomic_number,
self.geom.inp_coords[i][0],
self.geom.inp_coords[i][1],
self.geom.inp_coords[i][2]))
for x in range(self.Np_vect[0]):
for y in range(self.Np_vect[1]):
for z in range(self.Np_vect[2]):
if (z+1) % 6 == 0 or z == self.Np_vect[2]-1:
out.write("{:{w}.{dd}e}\n".format(self.values[x][y][z],
w=8+digits, dd=digits))
else:
out.write("{:{w}.{dd}e}".format(self.values[x][y][z],
w=8+digits, dd=digits))
def system_features(self):
"""Computes system-specific features.
:return: pd.DataFrame with features."""
df = pd.DataFrame()
# general
df['natoms'] = [self.natoms]
df['DFT_cohesive_energy'] = [self.cohesive_energy]
# atom-wise
ans = []
evals = []
for i, el in enumerate(self.composition.keys()):
elid = element(el).atomic_number
ans.append(elid)
e_val = element(el).nvalence()
evals.append(e_val)
df['Z' + str(i)] = [elid]
df['n' + str(i)] = self.composition[el]
df['e_val' + str(i)] = [e_val]
# mean
df['Z_mean'] = [np.mean(ans)]
df['e_val_mean'] = [np.mean(evals)]
self._system_features = df
return self._system_features
def test_get_mol_wt(self):
dna1 = core.DnaSpeciesType(id='dna6', sequence_path=self.sequence_path)
gene1 = eukaryote.GeneLocus(polymer=dna1, start=1, end=6)
exon1 = eukaryote.GenericLocus(start=1, end=1)
transcript1 = eukaryote.TranscriptSpeciesType(gene=gene1, exons=[exon1])
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript1.get_seq()) \
- (transcript1.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(transcript1.get_mol_wt(), exp_mol_wt, places=1)
exon2 = eukaryote.GenericLocus(start=3, end=3)
transcript2 = eukaryote.TranscriptSpeciesType(gene=gene1, exons=[exon2])
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript2.get_seq()) \
- (transcript2.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(transcript2.get_mol_wt(), exp_mol_wt, places=1)
exon3 = eukaryote.GenericLocus(start=5, end=5)
transcript3 = eukaryote.TranscriptSpeciesType(gene=gene1, exons=[exon3])
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript3.get_seq()) \
- (transcript3.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(transcript3.get_mol_wt(), exp_mol_wt, places=1)
# Test using input sequence
test_trans = eukaryote.TranscriptSpeciesType()
exp_mol_wt = \
+ Bio.SeqUtils.molecular_weight(transcript1.get_seq()) \
- (transcript1.get_len() + 1) * mendeleev.element('H').atomic_weight
self.assertAlmostEqual(test_trans.get_mol_wt(seq_input=Bio.Seq.Seq('A')), exp_mol_wt, places=1)
def writeinput (mol, atom2basisset, fout, boption):
fout.write("\'TYPE OF BASIS SET; 1 FOR GEOMETRIC, 2 FOR OPTIMIZED\'\n")
fout.write("2\n")
fout.write("\'NUMBER OF CENTERS\'\n" )
fout.write(str(mol.get_num_of_atoms()) + "\n")
totalelectrons = 0
for a in mol.get_atoms():
si = element(a.get_symbol())
totalelectrons += si.electrons - a.get_charge()
for i, a in enumerate(mol.get_atoms()):
si = element(a.get_symbol())
basisset = atom2basisset[a.get_symbol()]
fout.write("\'COORDINATES FOR CENTER %5d \'\n"%(i+1))
x = a.get_coordinates()[0] * boption.convertlengthunit
y = a.get_coordinates()[1] * boption.convertlengthunit
z = a.get_coordinates()[2] * boption.convertlengthunit
fout.write("%12.8f %12.8f %12.8f\n"%(x,y,z))
fout.write("\'Z, N, MAXL AND CHARGE FOR CENTER %5d \'\n"%(i+1))
an = si.atomic_number
aw = si.atomic_weight
maxl = basisset["Dim"]
fout.write("%d,%f,%d,%d\n"%(an, aw, maxl, a.get_charge()))
fout.write("\'BASIS SET FOR CENTER %5d %s %s\'\n"%(i+1, a.get_symbol(),
basisset["Basisname"]))
for h, vs in zip(basisset["Header"], basisset["Values"]):
fout.write(h + "\n")
for v in vs:
fout.write(v + "\n")
fout.write("\'NUMBER OF CLOSED-SHELL ELECTRONS\'"+"\n")
fout.write(str(totalelectrons) + ",0,0"+"\n")
fout.write("\'SPECIFY CLOSED AND OPEN SHELLS AND COUPLING\'"+"\n")
fout.write("0"+"\n")
fout.write("\'ENTER 1 FOR NEW RUN AND 0 FOR RESTART\'"+"\n")
fout.write(str(boption.restarton) + "\n")
fout.write("\'LEVEL SHIFT FACTOR IN STAGE 0, 1, AND 2\'"+ "\n")
fout.write("-2.0,-2.0,-2.0"+ "\n")
fout.write("\'STARTING STAGE (0-2)\'"+ "\n")
fout.write("2"+ "\n")
fout.write("\'PRINT LEVEL FROM 1-2\'"+ "\n")
fout.write("2"+ "\n")
fout.write("\'DAMPING FACTOR AND RELATIVE TRESHOLD FOR INITIATION OF DAMPING\'"+ "\n")
fout.write("0.10D0,1.0D-2"+ "\n")
fout.write("\'ENTER NCORE, MACTVE,NACTVE\'"+ "\n")
fout.write(str(totalelectrons) + ",0,0"+ "\n")
fout.write("\'ENTER GRID QUALITY FROM 1 (COURSE) to 5 (FINE)\'"+ "\n")
fout.write(str(boption.grid)+ "\n")
fout.write("\'EX-POTENTIAL available: LDA,B88P86,HCTH93,BLYP'"+ "\n")
fout.write(boption.functxc+ "\n")
fout.write("\'Fitt 2=standard:fitt2 4=solo_poisson:fitt3 6=both:fitt2+fitt3, USEFITT\'"+ "\n")
fout.write("2 " + str(boption.usefitt) + "\n")
fout.write("\'scalapack\'"+ "\n")
fout.write("2 2 32 2.0"+ "\n")
fout.write("\'maxit\'"+ "\n")
fout.write(str(boption.maxit) + "\n")
def get_atom_properties(atom_list):
for atoms in atom_list:
atomic_number = [element(atom).atomic_number for atom in atoms]
atomic_volume = [element(atom).atomic_volume for atom in atoms]
atomic_weight = [element(atom).atomic_weight for atom in atoms]
all_atom_properties = list(
zip(atomic_number, atomic_volume, atomic_weight))
yield all_atom_properties
def calculate_click(self):
numRows = self.tableInput.rowCount()
density = self.density_input.value()
wavelength = self.wavelength_input.value()
list_of_instances = []
total_mass = 0
passed = 0
for row in range(numRows):
elemInputItem = self.tableInput.item(row, 0)
formulaUnitInputItem = self.tableInput.item(row, 1)
try:
elemInput = str(elemInputItem.text().strip(" "))
print(elemInput)
formulaUnitInput = float(formulaUnitInputItem.text())
print(formulaUnitInput)
if elemInput in self.scattering_dict:
elem_instance = ElementValues(elemInput, self.scattering_dict, formulaUnitInput)
list_of_instances.append(elem_instance)
total_mass += (formulaUnitInput * element(elem_instance.element).atomic_weight)
passed += 1
else:
print("else raised")
self.totalAttBox.setText("ERROR: item not in dictionary")
except: # add TypeError??
print("except raised")
self.totalAttBox.setText("ERROR: input elements")
self.tableOutput.setRowCount(len(list_of_instances))
lin_att_total = 0
for row, current_element in enumerate(list_of_instances):
mendelem = element(current_element.element) # use mendeleev package to get atomic info about element
current_mass_fraction = (mendelem.atomic_weight * float(current_element.multiplier)) / total_mass
current_number_density = (float(density) / mendelem.atomic_weight) * current_mass_fraction
abs_x_section = (current_element.Absxs / 1.7980) * wavelength
# matches NIST by multiplying only inc and abs by 0.6
current_lin_att_fact = 0.6 * current_number_density * (current_element.Incxs + abs_x_section)
lin_att_total += current_lin_att_fact
table_outputs = [current_element.isotope, "{:f}".format(current_element.multiplier),
"{:f}".format(mendelem.atomic_weight), "{:f}".format(current_mass_fraction),
"{:f}".format(current_number_density), "{:f}".format(current_element.Cohxs),
"{:f}".format(current_element.Incxs), "{:f}".format(abs_x_section),
"{:f}".format(current_lin_att_fact)]
for column, data in enumerate(table_outputs):
self.tableOutput.setItem(row, column, QTableWidgetItem(data))
self.tableOutput.resizeColumnsToContents()
self.tableOutput.resizeRowsToContents()
print(passed)
if passed == numRows:
self.totalAttBox.setText("{:f}".format(lin_att_total))
else:
pass
def determine_protein_structure_from_aa(self,
polymer_id, count):
""" Determine the empirical formula, molecular weight and charge of
a protein based on the structural information of its metabolite
amino acid monomers to ensure consistency with the pH
Args:
polymer_id (:obj:`str`): polymer ID
count (:obj:`dict`): dictionary showing the count of each amino
acid in the protein
Returns:
:obj:`wc_utils.util.chem.EmpiricalFormula`: protein empirical formula
:obj:`float`: protein molecular weight
:obj:`int`: protein charge
:obj:`bool`: True if protein structure has been successfully determined
from the metabolite monomer, else False
"""
model = self.model
amino_acid_id_conversion = self.options['amino_acid_id_conversion']
total_empirical_formula = EmpiricalFormula()
total_molecular_weight = 0
total_charge = 0
polymer_len = 0
if not amino_acid_id_conversion:
return EmpiricalFormula(), 0, 0, False
for standard_id, met_id in amino_acid_id_conversion.items():
if standard_id in count:
monomer_species_type = model.species_types.get_one(id=met_id)
if monomer_species_type:
total_empirical_formula += \
monomer_species_type.structure.empirical_formula * count[standard_id]
total_molecular_weight += \
monomer_species_type.structure.molecular_weight * count[standard_id]
total_charge += monomer_species_type.structure.charge * count[standard_id]
polymer_len += count[standard_id]
else:
return EmpiricalFormula(), 0, 0, False
else:
return EmpiricalFormula(), 0, 0, False
protein_empirical_formula = total_empirical_formula - \
EmpiricalFormula('H{}O{}'.format(2 * (polymer_len - 1), polymer_len - 1))
protein_molecular_weight = total_molecular_weight - \
2 * (polymer_len - 1) * mendeleev.element('H').atomic_weight - \
(polymer_len - 1) * mendeleev.element('O').atomic_weight
protein_charge = total_charge
model_species_type = model.species_types.get_one(id=polymer_id)
if model_species_type:
model_species_type.structure.empirical_formula = protein_empirical_formula
model_species_type.structure.molecular_weight = protein_molecular_weight
model_species_type.structure.charge = protein_charge
return protein_empirical_formula, protein_molecular_weight, protein_charge, True
def drde(q, m_dm, sig0, tm='Si'):
"""
The differential event rate of an expected WIMP.
Parameters
----------
q : array_like
The recoil energies at which to calculate the dark matter differential
event rate. Expected units are keV.
m_dm : float
The dark matter mass at which to calculate the expected differential
event rate. Expected units are GeV.
sig0 : float
The dark matter cross section at which to calculate the expected differential
event rate. Expected units are cm^2.
tm : str, int, optional
The target material of the detector. Must be passed as the atomic
symbol. Can also pass a compound, but must be its chemical formula
(e.g. sapphire is 'Al2O3'). Default value is 'Si'.
Returns
-------
rate : ndarray
The expected dark matter differential event rate for the inputted recoil energies,
dark matter mass, and dark matter cross section. Units are events/keV/kg/day,
or "DRU".
Notes
-----
The derivation of the expected dark matter differential event rate is done in Lewin and
Smith's paper "Review of mathematics, numerical factors, and corrections dark matter experiments
based on elastic nuclear recoil", which can be found here:
- https://doi.org/10.1016/S0927-6505(96)00047-3
The derivation by L&S is incomplete, see Eq. 22 of R. Schnee's paper "Introduction to Dark Matter
Experiments", which includes the correct rate for `vmin` in the range (`vesc` - `ve`, `vesc` + `ve`)
- https://arxiv.org/abs/1101.5205
Another citation for this correction can be found in Savage, et. al.'s paper "Compatibility of
DAMA/LIBRA dark matter detection with other searches", see Eq. 19. This is a different parameterization,
but is the same solution.
- https://doi.org/10.1088/1475-7516/2009/04/010
"""
totalmassnum = sum(
[mendeleev.element(t).mass_number * num for t, num in _mixed_tm(tm)])
rate = sum([
mendeleev.element(t).mass_number * num / totalmassnum * _drde(
q,
m_dm,
sig0,
t,
) for t, num in _mixed_tm(tm)
])
return rate
def __init__(self, molecule_map):
self.molecule_map = molecule_map
self.elements = {
'H': element('H'),
'C': element('C'),
'N': element('N'),
'O': element('O'),
'F': element('F')
}
def weight_pc(cls, wt_pc):
wt_pc_2 = cls.check_pc(wt_pc)
mol_pc = {}
mol_tot = 0
for m in wt_pc_2:
mol_tot += wt_pc_2[m] / element(m).mass
for m in wt_pc_2:
mol_pc[m] = round(100 * (wt_pc_2[m] / element(m).mass) / mol_tot,
4)
return cls(mol_pc)
def plot_clementi_both(name, ax=None):
"""Plots Effective nuclear charge and shielding /% (Clementi) per orbital.
Parameters
----------
name : string
String with the element symbol.
ax : matplotlib.axes
Axes for the plot (the default is None).
Returns
-------
None
Plot.
"""
plot_param(ax)
fontsize = 15
linewidth = 4
x = elem_data(name)['Orbital']
y = elem_data(name)['Zef Clementi']
ax.set_ylabel('Effective nuclear charge', size=fontsize, color='blue')
ax.set_xlabel('Orbitals', size=fontsize)
line1 = ax.plot(x,
y,
linewidth=linewidth,
label='Zef Clementi {0}'.format(element(name).symbol),
color='blue')
ax.set_xticks = ([i for i in range(len(elem_data(name).index))])
ax.set_yticks(np.linspace(0, round(ax.get_ybound()[1] + 1), 5))
ax2 = ax.twinx()
plot_param(ax2)
y2 = elem_data(name)['% S Clementi']
line2 = ax2.plot(x,
y2,
linewidth=linewidth,
linestyle='--',
label='Shielding % Clementi {0}'.format(
element(name).symbol),
color='red')
ax2.set_ylabel('Shielding / %', size=fontsize, color='red')
ax2.set_yticks(np.linspace(0, round(ax2.get_ybound()[1] + 1), 5))
lines = line1 + line2
labels = [l.get_label() for l in lines]
ax2.legend(lines,
labels,
fontsize=fontsize - 1,
loc='upper center',
shadow=True,
fancybox=True)
def getElement(element):
if re.match(r'\d+', element):
element = int(element)
if element >= 1 and element <= 118:
return mdv.element(element)
raise ValueError(f'Unknown Element Atomic Number \'{element}\'')
elif re.match(r'\w{1,2}', element):
try:
return mdv.element(element.strip().title())
except:
raise ValueError(f'Unknown Element \'{element}\'')
else:
raise ValueError(f'Unknown Element Format \'{element}\'')
def fetch_neutral_data() -> pd.DataFrame:
"""
Get extensive set of data from multiple database tables as pandas.DataFrame
"""
elements = fetch_table("elements")
series = fetch_table("series")
groups = fetch_table("groups")
elements = pd.merge(
elements,
series,
left_on="series_id",
right_on="id",
how="left",
suffixes=("", "_series"),
)
elements = pd.merge(
elements,
groups,
left_on="group_id",
right_on="group_id",
how="left",
suffixes=("", "_group"),
)
elements.rename(columns={"color": "series_colors"}, inplace=True)
for attr in ["hardness", "softness"]:
elements[attr] = [
getattr(element(row.symbol), attr)() for _, row in elements.iterrows()
]
elements["mass"] = [
element(row.symbol).mass_str() for _, row in elements.iterrows()
]
elements.loc[:, "zeff_slater"] = elements.apply(
lambda x: get_zeff(x["atomic_number"], method="slater"), axis=1
)
elements.loc[:, "zeff_clementi"] = elements.apply(
lambda x: get_zeff(x["atomic_number"], method="clementi"), axis=1
)
ens = fetch_electronegativities()
elements = pd.merge(elements, ens.reset_index(), on="atomic_number", how="left")
ies = fetch_ionization_energies(degree=1)
elements = pd.merge(elements, ies.reset_index(), on="atomic_number", how="left")
return elements
def get_mode(self, mode_idx):
isotope_masses = [
np.float64(self.options['isotope_masses'][str(
element(m).atomic_number)][str(
element(m).mass_number)]['mass'])
for m in self.molecule.atoms
]
mode = vib.Mode(vectors=self.data.vibdisps[mode_idx],
atoms=self.molecule.atoms,
wavenumber=self.data.vibfreqs[mode_idx],
idx=mode_idx,
weighted=True,
isotope_masses=isotope_masses)
return mode
def atomic_number_symbol_dict():
n_elements = 118
an_symbol = {}
for an in range(1, n_elements + 1):
element = mendeleev.element(an)
an_symbol[an] = element.symbol
return an_symbol
def orbitals(name):
"""Extracts n, l, and nl notation from electronic configuration info of
Mendeleev package.
Parameters
----------
name : string
Name or symbol for the chemical element.
Returns
-------
lists
Lists with orbital representation; quantrum principal number; orbital
letter notation and quantum azimutal number.
"""
elem = element(name)
orbital_n = []
orbital_l = []
for k, v in elem.ec.conf.items():
orbital_n.append(k[0])
orbital_l.append(k[1])
dict_l = {'s': 0, 'p': 1, 'd': 2, 'f': 3}
orbital_l_num = []
for i in orbital_l:
if i in dict_l:
orbital_l_num.append(dict_l[i])
orbital = []
for i in range(len(orbital_n)):
orbital.append(str(orbital_n[i]) + orbital_l[i])
return orbital, orbital_n, orbital_l, orbital_l_num
def slater(name):
"""In quantum chemistry, Slater's rules provide numerical values for the
effective nuclear charge concept. In a many-electron atom, each electron is
said to experience less than the actual nuclear charge owing to shielding
or screening by the other electrons.
Parameters
----------
name : string
Name or symbol for the chemical element.
Returns
-------
type list
Three lists. The first one with the screening values, the second with
the effective nuclear charge values and the third one with the
screening percentage for each orbital of the electronic configuration
of the element.
"""
elem = element(name)
slater_s = []
zeff_slater = []
for k, v in elem.ec.conf.items():
slater_s.append(elem.ec.slater_screening(k[0], k[1]))
zeff_slater.append(elem.atomic_number -
elem.ec.slater_screening(k[0], k[1]))
slater_s_percent = [(i / elem.atomic_number) * 100 for i in slater_s]
return slater_s, zeff_slater, slater_s_percent
def plot_clementi_screening(name, ax=None, **kwargs):
"""Plots Shielding /% (Clementi) per orbital.
Parameters
----------
name : string
String with the element symbol.
ax : matplotlib.axes
Axes for the plot (the default is None).
**kwargs : string
kwargs for plot parameters.
Returns
-------
None
Plot.
"""
plot_param(ax)
fontsize = 15
linewidth = 4
x = elem_data(name)['Orbital']
y = elem_data(name)['% S Clementi']
ax.set_ylabel('Shielding / %', size=fontsize)
ax.set_xlabel('Orbitals', size=fontsize)
ax.set_xticks = ([i for i in range(len(elem_data(name).index))])
ax.set_yticks(np.arange(0, round(max(y)) + 5, 10.0))
ax.plot(x,
y,
linewidth=linewidth,
label='Shielding % Clementi {0}'.format(element(name).symbol),
**kwargs)
ax.legend(fontsize=fontsize - 2, loc='best', shadow=True, fancybox=True)
def create_dataframe():
all_data = {}
for number in range(1, 118 + 1):
el = element(number)
data = {
# Group number
'group': get_group(el),
# Period number
'period': get_period(el),
# Pauling's electronegativity
'electronegativity': el.en_pauling,
# Cordero's covalent radius
'covalent_radius': el.covalent_radius_cordero,
# valence electrons
'valence_electrons': el.nvalence(),
# first ionization energy
'first_ionization_energy': el.ionenergies.get(1),
# electron affinity
'electron_affinity': el.electron_affinity,
# block
'block': el.block,
# atomic volume
'atomic_volume': el.atomic_volume,
}
all_data[number] = data
df = pd.DataFrame(all_data).transpose()
# fill with mean
df = df.fillna(df.mean())
# log scale
df['first_ionization_energy'] = np.log(df['first_ionization_energy'])
df['atomic_volume'] = np.log(df['atomic_volume'])
return df
def readMatLabData(dataset, moleculeRow):
mat_contents = sio.loadmat(dataset)
masterAtomMatrix = mat_contents['Z']
masterCartesianMatrix = mat_contents['R']
masterAtomMatrix = np.array(masterAtomMatrix, dtype=object)
masterCartesianMatrix = np.array(masterCartesianMatrix, dtype=object)
#changes the heading rows in masterAtomMatrix to the actual atoms
stopPoint1, stopPoint2 = None, None
for i in range(len(masterAtomMatrix[0])):
if masterAtomMatrix[moleculeRow, i] == float(0):
stopPoint1 = i
break
nonZeros = masterAtomMatrix[moleculeRow, :stopPoint1]
for i in range(len(nonZeros)):
if nonZeros[i] == float(1):
stopPoint2 = i
break
nonZerosAndNonOnes = nonZeros[:stopPoint2]
nonZeros = sorted(nonZerosAndNonOnes) + [1.0] * (
(len(nonZeros)) - stopPoint2)
temp = nonZeros + [0.0] * ((len(masterAtomMatrix[0])) - stopPoint1)
masterAtomMatrix[moleculeRow] = np.array(temp, dtype=object)
for col in range(len(masterAtomMatrix[0])):
atomicNumber = int(masterAtomMatrix[moleculeRow, col])
if atomicNumber != 0:
masterAtomMatrix[moleculeRow, col] = str(
element(atomicNumber).symbol) + str(col + 1)
else:
pass
return [masterAtomMatrix, masterCartesianMatrix]
def max_electronegativity(chemical_formula):
'returns the element symbol with the max electronegatvity'
element_list = re.sub("[\.\(\)0-9]", '', chemical_formula).split()
electronegativities = [
chem.element(i).electronegativity() for i in element_list
]
return element_list[electronegativities.index(max(electronegativities))]
def input_check(inpu):
try:
si = element(inpu)
except:
return ("False")
else:
return ("True")
def extract_xyz(xyz_data):
# Extract atomic nums and coords from xyz data
# remove the first two lines in the xyz file
# (i.e. number of atom and optional comment)
xyz_data = xyz_data.split('\n')[2:]
# Extract the atomic nums and the coords
atomic_symbols = []
coords = []
for line in xyz_data:
line = line.strip()
if not line:
continue
vals = line.split()[:4]
if vals[0].isdigit():
num = int(vals[0])
atomic_symbols.append(element(num).symbol)
else:
atomic_symbols.append(vals[0])
coords.append([float(x) for x in vals[1:]])
return atomic_symbols, coords
