def _example():
"""Example of using a system"""
from BigDFT.IO import XYZReader
from BigDFT.Fragments import Fragment
safe_print("Read in some files for the fragments..")
reader = XYZReader("SiO")
frag1 = Fragment(xyzfile=reader)
reader = XYZReader("Si4")
frag2 = Fragment(xyzfile=reader)
safe_print("Now we move on to testing the system class.")
sys = System(frag1=frag1, frag2=frag2)
for at in sys["frag1"]:
safe_print(dict(at))
for at in sys["frag2"]:
safe_print(dict(at))
safe_print()
safe_print("What if we want to combine two fragments together?")
sys["frag1"] += sys.pop("frag2")
for at in sys["frag1"]:
safe_print(dict(at))
safe_print("frag2" in sys)
safe_print()
safe_print("What if I want to split a fragment by atom indices?")
temp_frag = sys.pop("frag1")
sys["frag1"], sys["frag2"] = temp_frag[0:3], temp_frag[3:]
for at in sys["frag1"]:
safe_print(dict(at))
for at in sys["frag2"]:
safe_print(dict(at))
safe_print()
def _example():
"""Example of using OpenBabel interoperability"""
from BigDFT.Systems import System
from BigDFT.Fragments import Fragment
from BigDFT.IO import XYZReader
from os.path import join
# Read in a system.
sys = System()
sys["FRA:1"] = Fragment()
with XYZReader("CH4") as ifile:
for at in ifile:
sys["FRA:1"] += Fragment([at])
# We can compute the smiles representation.
print(compute_smiles(sys))
# The energy.
print(system_energy(sys, forcefield="UFF"))
# Extract the forces.
compute_system_forces(sys, forcefield="UFF")
for frag in sys.values():
for at in frag:
print(at["force"])
# Optimize the geometry.
sys2 = optimize_system(sys, forcefield="UFF")
print(system_energy(sys2, forcefield="UFF"))
def _example():
"""Example of using PSI4 interoperability"""
from BigDFT.IO import XYZReader
from BigDFT.Systems import System
from BigDFT.Fragments import Fragment
from os.path import join
from copy import deepcopy
# Create a system.
reader = XYZReader(join("Database", "XYZs", "He.xyz"))
fsys = System()
fsys["FRA:1"] = Fragment(xyzfile=reader)
fsys["FRA:2"] = deepcopy(fsys["FRA:1"])
fsys["FRA:2"].translate([-2, 0, 0])
# Create a calculator.
code = PSI4Calculator()
log = code.run(sys=fsys, action="energy", basis="jun-cc-pvdz",
psi4_options={"scf_type": "direct"}, method="scf",
name="test")
print(log)
# The raw logfile is also available.
print(log.log[4])
# Geometry optimization.
log = code.run(sys=fsys, action="optimize", basis="jun-cc-pvdz",
method="scf", name="test-opt")
print(log)
# SAPT
log = code.run(sys=fsys, action="energy", basis="jun-cc-pvdz",
method="sapt0", name="test-sapt")
print(log)
def _example():
"""Example of using fragments"""
from BigDFT.IO import XYZReader, XYZWriter
from copy import deepcopy
safe_print("Read in an xyz file and build from a list.")
atom_list = []
with XYZReader("SiO") as reader:
for at in reader:
atom_list.append(at)
frag1 = Fragment(atomlist=atom_list)
for at in frag1:
safe_print(at.sym, at.get_position())
safe_print("Centroid", frag1.centroid)
safe_print()
safe_print("Build from an xyz file directly.")
reader = XYZReader("Si4")
frag2 = Fragment(xyzfile=reader)
for at in frag2:
safe_print(at.sym, at.get_position())
safe_print()
safe_print("We can combine two fragments with +=")
frag3 = deepcopy(frag1)
frag3 += frag2
for at in frag3:
safe_print(at.sym, at.get_position())
safe_print("Length of frag3", len(frag3))
safe_print()
safe_print("Since we can iterate easily, we can also write easily.")
with XYZWriter("test.xyz", len(frag3), "angstroem") as writer:
for at in frag3:
writer.write(at)
with open("test.xyz") as ifile:
for line in ifile:
safe_print(line)
safe_print()
safe_print("We can also extract using the indices")
safe_print(dict(frag3[0]))
sub_frag = frag3[1:3]
for at in sub_frag:
safe_print(dict(at))
safe_print()
def _example():
"""Visualization Example"""
from BigDFT.Systems import System
from BigDFT.Fragments import Fragment
from BigDFT.IO import XYZReader
# Read in a system.
sys = System()
with XYZReader("SiO") as ifile:
for i, at in enumerate(ifile):
sys["FRA:" + str(i)] = Fragment([at])
# Display the system.
viz = InlineVisualizer(400, 300)
viz.display_system(sys)
# Change the colors
colordict = get_distinct_colors(list(sys))
viz.display_system(sys, colordict=colordict)
def __init__(self, name):
import os
from BigDFT.Fragments import Fragment
from BigDFT.Systems import System
from BigDFT.IO import XYZReader
# import the positions of the molecules from the XYZ directory
dirXYZ = os.path.join(os.path.dirname(__file__), 'XYZs')
filename = os.path.abspath(os.path.join(dirXYZ, name + '.xyz'))
if not os.path.isfile(filename):
raise ValueError('Molecule not available')
ff = XYZReader(filename)
frag = Fragment(xyzfile=ff)
system = System({'molecule:0': frag})
self.update(system.get_posinp())
# temporary change of the keys 'values' into 'positions'
if 'values' in self:
self['positions'] = self.pop('values')
if 'positions' in self:
for at in self['positions']:
if 'r' in at:
at.pop('r')
def _example():
"""
Postprocessing Example
"""
from BigDFT.Systems import System, FragmentView
from BigDFT.Fragments import Fragment
from BigDFT.IO import XYZReader
from BigDFT.Calculators import SystemCalculator
from BigDFT.Inputfiles import Inputfile
from scipy.linalg import eigh
from copy import deepcopy
# Create a system
sys = System()
sys["FRA:0"] = Fragment()
with XYZReader("CH2") as ifile:
for at in ifile:
sys["FRA:0"].append(at)
sys["FRA:1"] = Fragment()
with XYZReader("CH3") as ifile:
for at in ifile:
sys["FRA:1"].append(at)
sys["FRA:1"].translate([0, 0, -3])
sys["FRA:2"] = deepcopy(sys["FRA:0"])
sys["FRA:2"].translate([0, 0, 3])
sys["FRA:2"].rotate(y=150, units="degrees")
sys["FRA:3"] = deepcopy(sys["FRA:0"])
sys["FRA:3"].translate([3, 0, 1.5])
print(list(sys))
# Run a calculation. `write_support_function_matrices` and `linear` are
# key. You also should be sure to set the atom multipoles.
inp = Inputfile()
inp.set_xc("PBE")
inp.set_hgrid(0.4)
inp.write_support_function_matrices()
inp["import"] = "linear"
code = SystemCalculator()
code.update_global_options(verbose=False)
log = code.run(input=inp, posinp=sys.get_posinp(), run_dir="work")
sys.set_atom_multipoles(log)
# Create the post processing tool.
from BigDFT.PostProcessing import BigDFTool
btool = BigDFTool()
# Purity
purity = btool.run_compute_purity(sys, log)
print(purity)
# Charges
charges = {
fragid: sum(at.nel for at in frag)
for fragid, frag in sys.items()
}
# Bond Orders
bo = btool.fragment_bond_order(sys, sys.keys(), sys.keys(), log)
# Population values.
population = btool.fragment_population(sys, log)
print(population)
# These three things define a fragment view.
view = FragmentView(purity, bo, charges)
# Auto Fragmentation
mapping = btool.auto_fragment(sys, view, 0.10)
print(mapping)
# This defines a new view.
new_view = view.refragment(mapping)
print(new_view.purities)
# Eigenvalues.
H = btool.get_matrix_h(log)
S = btool.get_matrix_s(log)
w = eigh(H.todense(), b=S.todense(), eigvals_only=True)
print(w)
def _example():
"""Example of using ASE interoperability"""
from BigDFT.IO import XYZReader
from BigDFT.Inputfiles import Inputfile
from BigDFT.Calculators import SystemCalculator
from BigDFT.Fragments import Fragment
from BigDFT.Systems import System
from ase.calculators.lj import LennardJones
from BigDFT.UnitCells import UnitCell
from ase.units import Hartree
from ase.optimize import BFGS
from os.path import join
from copy import deepcopy
# Create a system.
sys = System()
reader = XYZReader("Ar")
sys["FRA:1"] = Fragment(xyzfile=reader)
sys["FRA:2"] = deepcopy(sys["FRA:1"])
sys["FRA:2"].translate([-2, 0, 0])
# Skip straight to the potential energy.
print(ase_potential_energy(sys, LennardJones()))
# Advanced used.
asys = bigdft_to_ase(sys)
asys.set_calculator(LennardJones())
dyn = BFGS(asys)
dyn.run(fmax=0.05)
print(asys.get_potential_energy() / Hartree)
# Unit cells
sys.cell = UnitCell([5, 5, 5], units="bohr")
print(ase_potential_energy(sys, LennardJones()))
sys.cell = UnitCell([5, float("inf"), 5], units="bohr")
print(ase_potential_energy(sys, LennardJones()))
sys.cell = UnitCell([float("inf"), float("inf"), 5], units="bohr")
print(ase_potential_energy(sys, LennardJones()))
# We can also use BigDFT with ase.
inp = Inputfile()
inp.set_xc("PBE")
inp.set_hgrid(0.4)
code = SystemCalculator(verbose=False)
sys.cell = UnitCell()
print(
ase_potential_energy(
sys, BigASECalculator(inp,
code,
directory="work",
label="ase-free")))
sys.cell = UnitCell([5, 5, 5], units="bohr")
print(
ase_potential_energy(
sys,
BigASECalculator(inp, code, directory="work",
label="ase-periodic")))
sys.cell = UnitCell([5, float("inf"), 5], units="bohr")
print(
ase_potential_energy(
sys,
BigASECalculator(inp, code, directory="work",
label="ase-surface")))
sys.cell = UnitCell([float("inf"), float("inf"), 5], units="bohr")
print(
ase_potential_energy(
sys, BigASECalculator(inp,
code,
directory="work",
label="ase-wire")))