def notestSpecies(self):
siesta = Siesta()
atoms = ch4.copy()
species, numbers = siesta.species(atoms)
self.assertTrue(all(numbers==np.array([1, 2, 2, 2, 2])))
siesta = Siesta(species=[Specie(symbol='C', tag=1)])
species, numbers = siesta.species(atoms)
self.assertTrue(all(numbers==np.array([1, 2, 2, 2, 2])))
atoms.set_tags([0,0,0,1,0])
species, numbers = siesta.species(atoms)
self.assertTrue(all(numbers==np.array([1, 2, 2, 2, 2])))
siesta = Siesta(species=[Specie(symbol='H', tag=1)])
species, numbers = siesta.species(atoms)
self.assertTrue(all(numbers==np.array([1, 2, 2, 3, 2])))
H2O = Atoms("H2O",
np.array([[0.0, -0.757, 0.587], [0.0, +0.757, 0.587],
[0.0, 0.0, 0.0]]),
cell=np.eye(3, dtype=float))
#H2O.center(vacuum=3.5)
# unit cell 1 0 0
# 0 1 0 => siesta default unit cell use
# 0 0 1
siesta_calc = Siesta(mesh_cutoff=150 * Ry,
basis_set='SZ',
energy_shift=(10 * 10**-3) * eV,
xc="PBE",
fdf_arguments={
'SCFMustConverge': False,
'COOP.Write': True,
'WriteDenchar': True,
'PAO.BasisType': 'split',
'DM.Tolerance': 1e-4,
'DM.MixingWeight': 0.01,
'MaxSCFIterations': 150,
'DM.NumberPulay': 4
})
H2O.set_calculator(siesta_calc)
efree_siesta = H2O.get_potential_energy()
# run gpaw
from gpaw import GPAW, PoissonSolver
H2O_gp = Atoms(
"H2O",
np.array([[0.0, -0.757, 0.587], [0.0, +0.757, 0.587], [0.0, 0.0,
from ase.optimize import BFGS
from ase.units import *
from ase.calculators.siesta import Siesta
# Read initial and final states:
from ase.io.trajectory import Trajectory, PickleTrajectory
traj = Trajectory("final7.traj")
#traj = io.read('last_iteration.traj')
#for images in traj:
# print "hello2"
calc = Siesta(label='pes_neb',
xc='RPBE',
meshcutoff=200 * Ry,
basis='dzp',
mix=0.1,
pulay=12,
kpts=[6, 6, 1])
calc.set_fdf('xc.functional', 'GGA')
calc.set_fdf('PAO.EnergyShift', 0.01 * Ry)
calc.set_fdf('DM.KickMixingWeight', 0.008)
calc.set_fdf('SpinPolarized', 'false')
for images in traj:
# print "hello"
# pprint.pprint(images)
images.set_calculator(calc)
e = images.get_potential_energy()
print e
from ase.calculators.siesta import Siesta
from ase.calculators.siesta.parameters import Species, PAOBasisBlock
from ase.optimize import QuasiNewton
from ase import Atoms
atoms = Atoms('3H', [(0.0, 0.0, 0.0), (0.0, 0.0, 0.5), (0.0, 0.0, 1.0)],
cell=[10, 10, 10])
basis_set = PAOBasisBlock("""1
0 2 S 0.2
0.0 0.0""")
atoms.set_tags([0, 1, 0])
siesta = Siesta(species=[
Species(symbol='H', tag=None, basis_set='SZ'),
Species(symbol='H', tag=1, basis_set=basis_set, ghost=True)
])
atoms.set_calculator(siesta)
dyn = QuasiNewton(atoms, trajectory='h.traj')
dyn.run(fmax=0.02)
from ase.build import bulk
from ase.calculators.siesta import Siesta
from ase.io.siesta import _read_fdf_lines
atoms = bulk('Ti')
calc = Siesta()
atoms.calc = calc
calc.write_input(atoms, properties=['energy'])
# Should produce siesta.fdf but really we should be more explicit
fname = 'siesta.fdf'
with open(fname) as fd:
thing = _read_fdf_lines(fd)
print(thing)
assert thing[0].split() == ['SystemName', 'siesta']
from ase.constraints import FixAtoms
from ase.calculators.siesta import Siesta
from ase.md import VelocityVerlet
from ase import units
# Read in the geometry from a xyz file, set the cell, boundary conditions and center
atoms = read('geom.xyz')
atoms.set_cell([7.66348,7.66348,7.66348*2])
atoms.set_pbc((1,1,1))
atoms.center()
# Set initial velocities for hydrogen atoms along the z-direction
p = atoms.get_momenta()
p[0,2]= -1.5
p[1,2]= -1.5
atoms.set_momenta(p)
# Keep some atoms fixed during the simulation
atoms.set_constraint(FixAtoms(indices=range(18,38)))
# Set the calculator and attach it to the system
calc = Siesta('si001+h2',basis='SZ',xc='PBE',meshcutoff=50*units.Ry)
calc.set_fdf('PAO.EnergyShift', 0.25 * units.eV)
calc.set_fdf('PAO.SplitNorm', 0.15)
atoms.set_calculator(calc)
# Set the VelocityVerlet algorithm and run it
dyn = VelocityVerlet(atoms,dt=1.0 * units.fs,trajectory='si001+h2.traj')
dyn.run(steps=100)
def __init__(self, nodes=1, ppn=8, **kwargs):
Siesta.__init__(self, **kwargs)
self.nodes=nodes
self.ppn=ppn
def calc(self, **kwargs):
from ase.calculators.siesta import Siesta
command = '{} < PREFIX.fdf > PREFIX.out'.format(self.executable)
return Siesta(command=command,
pseudo_path=str(self.pseudo_path),
**kwargs)
from ase import Atoms
from ase.calculators.siesta import Siesta
from ase.units import Ry
a0 = 5.43
bulk = Atoms('Si2', [(0, 0, 0), (0.25, 0.25, 0.25)], pbc=True)
b = a0 / 2
bulk.set_cell([(0, b, b), (b, 0, b), (b, b, 0)], scale_atoms=True)
calc = Siesta(
label='Si',
xc='PBE',
spin='collinear',
mesh_cutoff=200 * Ry,
energy_shift=0.01 * Ry,
basis_set='DZ',
kpts=[1, 2, 3],
fdf_arguments={
'DM.MixingWeight': 0.10,
'MaxSCFIterations': 10,
'SCF.DM.Tolerance': 0.1,
},
)
bulk.calc = calc
e = bulk.get_potential_energy()
print(e)
[-1.90503810, -1.56107288, 0.00000000],
[0.00000000, 0.00000000, 2.08495836],
[0.00000000, 0.00000000, -2.08495836],
[0.00000000, 3.22798122, 2.08495836],
[0.00000000, 3.22798122, -2.08495836]],
cell=[20, 20, 20])
# enter siesta input
siesta = Siesta(mesh_cutoff=150 * Ry,
basis_set='DZP',
pseudo_qualifier='',
energy_shift=(10 * 10**-3) * eV,
fdf_arguments={
'SCFMustConverge': False,
'COOP.Write': True,
'WriteDenchar': True,
'PAO.BasisType': 'split',
'DM.Tolerance': 1e-4,
'DM.MixingWeight': 0.01,
'MaxSCFIterations': 300,
'DM.NumberPulay': 4,
'XML.Write': True
})
Na8.calc = siesta
e = Na8.get_potential_energy()
freq = np.arange(0.0, 5.0, 0.05)
siesta.lrtddft(freq,
label="siesta",
jcutoff=7,
iter_broadening=0.15 / Ha,
CO2 = Atoms('CO2',
positions=[[-0.009026, -0.020241, 0.026760],
[1.167544, 0.012723, 0.071808],
[-1.185592, -0.053316, -0.017945]],
cell=[20, 20, 20])
# enter siesta input
siesta = Siesta(
mesh_cutoff=150 * Ry,
basis_set='DZP',
pseudo_qualifier='',
energy_shift=(10 * 10**-3) * eV,
fdf_arguments={
'SCFMustConverge': False,
'COOP.Write': True,
'WriteDenchar': True,
'PAO.BasisType': 'split',
'DM.Tolerance': 1e-4,
'DM.MixingWeight': 0.01,
'MaxSCFIterations': 300,
'DM.NumberPulay': 4,
'XML.Write': True,
'DM.UseSaveDM': True})
CO2.set_calculator(siesta)
ram = SiestaRaman(CO2, siesta, label="siesta", jcutoff=7, iter_broadening=0.15/Ha,
xc_code='LDA,PZ', tol_loc=1e-6, tol_biloc=1e-7,
freq=np.arange(0.0, 5.0, 0.05))
ram.run()
ram.summary(intensity_unit_ram='A^4 amu^-1')
import matplotlib.pyplot as plt
H2O = Atoms('H2O', positions = [[-0.757, 0.586, 0.000],
[0.757, 0.586, 0.000],
[0.0, 0.0, 0.0]],
cell=[20, 20, 20])
# enter siesta input and run siesta
siesta = Siesta(
mesh_cutoff=150 * Ry,
basis_set='DZP',
pseudo_qualifier='lda',
energy_shift=(10 * 10**-3) * eV,
fdf_arguments={
'SCFMustConverge': False,
'COOP.Write': True,
'WriteDenchar': True,
'PAO.BasisType': 'split',
'DM.Tolerance': 1e-4,
'DM.MixingWeight': 0.01,
'MaxSCFIterations': 300,
'DM.NumberPulay': 4,
'XML.Write': True})
H2O.set_calculator(siesta)
e = H2O.get_potential_energy()
# ### The TDDFT calculations with PySCF-NAO
siesta.pyscf_tddft(label="siesta", jcutoff=7, iter_broadening=0.15/Ha,
(-0.776070, 0.590459, 0.00000),
(0.000000, -0.007702, -0.000001)],
pbc=(1, 1, 1))
# Center the molecule in the cell with some vacuum around
h2o.center(vacuum=6.0)
# Select some energy-shifts for the basis orbitals
e_shifts = [0.01, 0.1, 0.2, 0.3, 0.4, 0.5]
# Run the relaxation for each energy shift, and print out the
# corresponding total energy, bond length and angle
for e_s in e_shifts:
starttime = time.time()
calc = Siesta('h2o', meshcutoff=200.0 * units.Ry, mix=0.5, pulay=4)
calc.set_fdf('PAO.EnergyShift', e_s * units.eV)
calc.set_fdf('PAO.SplitNorm', 0.15)
calc.set_fdf('PAO.BasisSize', 'SZ')
h2o.set_calculator(calc)
# Make a -traj file named h2o_current_shift.traj:
dyn = QuasiNewton(h2o, trajectory='h2o_%s.traj' % e_s)
dyn.run(fmax=0.02) # Perform the relaxation
E = h2o.get_potential_energy()
print # Make the output more readable
print "E_shift: %.2f" % e_s
print "----------------"
print "Total Energy: %.4f" % E # Print total energy
d = h2o.get_distance(0, 2)
print "Bond length: %.4f" % d # Print bond length
p = h2o.positions
def prepare_input(self, struct):
if self.calculator == "VASP":
# POTCAR and POSCAR file generation, INCAR and KPOINTS must be provided in current dir
write(filename="POSCAR", images=struct, format="vasp")
if os.path.isfile('POTCAR'):
os.system("rm POTCAR")
tmp = open("POSCAR", "r")
first_line = tmp.readline()
line_sp = first_line.split()
cat = "cat "
# path from NGOptConfig
for s in line_sp:
cat = cat + self.vasp_pseudo_path + "/POTCAR_" + s + " "
cat = cat + " > POTCAR"
tmp.close()
os.system(cat)
if self.calculator == "siesta":
# head.fdf file generation, tail.fdf must be provided in current dir
calc = Siesta(
label='siesta',
xc='PBE',
basis_set='SZP',
)
f = open("head.fdf", "w")
calc._write_species(f, struct)
calc._write_structure(f, struct)
f.close()
os.system("cat head.fdf tail.fdf > siesta.fdf")
if self.calculator == "openmx":
# center of file generation, head and tail must be provided in current dir
label = "openmx"
input = open("openmx.in.dat", "w")
#
input.write("\n")
input.write("System.Name " + label + "\n")
input.write("\n")
input.write("# \n")
input.write("# Definition of Atomic Species \n")
input.write("# \n")
input.write("\n")
# print openmx species
l = len(struct.get_chemical_symbols())
symbols = struct.get_chemical_symbols()
symbols_dist = set(symbols)
input.write("Species.Number " + str(len(symbols_dist)) +
"\n")
input.write("<Definition.of.Atomic.Species \n")
for symbol in symbols_dist:
basis = get_basis_info_openmx(self.openmx_bases_file, symbol)
pseudo = get_pseudos_openmx(self.openmx_pseudo_file, symbol)
size = str(basis[2])
input.write(
str(symbol) + " " + str(basis[0] + "-" + size) + " " +
str(pseudo) + " \n")
input.write("Definition.of.Atomic.Species> \n")
input.write("\n")
input.write("# \n")
input.write("# Atoms \n")
input.write("# \n")
input.write("\n")
# print openmx positions
positions = struct.get_positions()
input.write("Atoms.Number " + str(l) + "\n")
input.write("Atoms.SpeciesAndCoordinates.Unit Ang # Ang|AU \n")
input.write("<Atoms.SpeciesAndCoordinates \n")
for i in range(l):
symbol = symbols[i]
basis = get_basis_info_openmx(self.openmx_bases_file, symbol)
valence = float(basis[1]) / 2.
if basis[2] == "s2p2d2":
valence1 = valence + self.halfmom
valence2 = valence - self.halfmom
else:
valence1 = valence2 = valence
# valence1 = valence+self.halfmom
# valence2 = valence-self.halfmom
input.write(
str(i + 1) + " " + str(symbols[i]) + " " +
str(format(positions[i][0], '.12f')) + " " +
str(format(positions[i][1], '.12f')) + " " +
str(format(positions[i][2], '.12f')) + " " +
str(valence1) + " " + str(valence2) + "\n")
input.write("Atoms.SpeciesAndCoordinates> \n")
# print openmx unit cell
input.write("Atoms.UnitVectors.Unit Ang # Ang|AU \n"
) # do poprawy!
input.write("<Atoms.UnitVectors \n")
cell = struct.get_cell()
input.write(
str(format(cell[0][0], '.12f')) + " " +
str(format(cell[0][1], '.12f')) + " " +
str(format(cell[0][2], '.12f')) + "\n")
input.write(
str(format(cell[1][0], '.12f')) + " " +
str(format(cell[1][1], '.12f')) + " " +
str(format(cell[1][2], '.12f')) + "\n")
input.write(
str(format(cell[2][0], '.12f')) + " " +
str(format(cell[2][1], '.12f')) + " " +
str(format(cell[2][2], '.12f')) + "\n")
input.write("Atoms.UnitVectors> \n")
input.close()
os.system("cat head openmx.in.dat tail > openmx.dat")
def __init__(self, nodes=1, ppn=8, **kwargs):
Siesta.__init__(self, **kwargs)
self.nodes = nodes
self.ppn = ppn
imagesfinal=[]
for images in traj:
#for image in images:
imagesfinal += [images]
neb = NEB(imagesfinal, k=0.5)
# Interpolate linearly the potisions of the three middle images:
#neb.interpolate()
#view(images)
calc = Siesta(label='pes_neb',
xc='RPBE',
meshcutoff=200 * Ry,
basis='dzp',
mix=0.1,
pulay=12,
kpts=[6, 6, 1])
calc.set_fdf('xc.functional', 'GGA')
calc.set_fdf('PAO.EnergyShift', 0.01 * Ry)
calc.set_fdf('DM.KickMixingWeight', 0.008)
calc.set_fdf('DM.UseSaveDM', 'true')
calc.set_fdf('SpinPolarized', 'true')
#calc.set_fdf('ElectronicTemperature', 500 * C)
# Set calculators:
#for images in traj:
for image in imagesfinal:
def get_potential_energy(self, atoms):
self.prepare_calc_dir()
Siesta.get_potential_energy(self, atoms)
[1.90503810, -1.56107288, 0.00000000],
[-1.90503810, -1.56107288, 0.00000000],
[0.00000000, 0.00000000, 2.08495836],
[0.00000000, 0.00000000, -2.08495836],
[0.00000000, 3.22798122, 2.08495836],
[0.00000000, 3.22798122, -2.08495836]],
cell=[20, 20, 20])
# enter siesta input
siesta = Siesta(
mesh_cutoff=150 * Ry,
basis_set='DZP',
pseudo_qualifier='',
energy_shift=(10 * 10**-3) * eV,
fdf_arguments={
'SCFMustConverge': False,
'COOP.Write': True,
'WriteDenchar': True,
'PAO.BasisType': 'split',
'DM.Tolerance': 1e-4,
'DM.MixingWeight': 0.01,
'MaxSCFIterations': 300,
'DM.NumberPulay': 4})
mbpt_inp = {'prod_basis_type': 'MIXED',
'solver_type': 1,
'gmres_eps': 0.001,
'gmres_itermax': 256,
'gmres_restart': 250,
'gmres_verbose': 20,
'xc_ord_lebedev': 14,
from ase.constraints import FixAtoms
from ase.calculators.siesta import Siesta
from ase.md import VelocityVerlet
from ase import units
# Read in the geometry from a xyz file, set the cell, boundary conditions and center
atoms = read('geom.xyz')
atoms.set_cell([7.66348,7.66348,7.66348*2])
atoms.set_pbc((1,1,1))
atoms.center()
# Set initial velocities for hydrogen atoms along the z-direction
p = atoms.get_momenta()
p[0,2]= -1.5
p[1,2]= -1.5
atoms.set_momenta(p)
# Keep some atoms fixed during the simulation
atoms.set_constraint(FixAtoms(indices=range(18,38)))
# Set the calculator and attach it to the system
calc = Siesta('si001+h2',basis='SZ',xc='PBE',meshcutoff=50*units.Ry)
calc.set_fdf('PAO.EnergyShift', 0.25 * units.eV)
calc.set_fdf('PAO.SplitNorm', 0.15)
atoms.set_calculator(calc)
# Set the VelocityVerlet algorithm and run it
dyn = VelocityVerlet(atoms,dt=1.0 * units.fs,trajectory='si001+h2.traj')
dyn.run(steps=100)
from ase.calculators.siesta import Siesta
from ase.optimize import BFGS
from ase.calculators.socketio import SocketIOCalculator
unixsocket = 'siesta'
fdf_arguments = {'MD.TypeOfRun': 'Master',
'Master.code': 'i-pi',
'Master.interface': 'socket',
'Master.address': unixsocket,
'Master.socketType': 'unix'}
# To connect through INET socket instead, use:
# fdf_arguments['Master.port'] = port
# fdf_arguments['Master.socketType'] = 'inet'
# Optional, for networking:
# fdf_arguments['Master.address'] = <hostname or IP address>
atoms = molecule('H2O', vacuum=3.0)
atoms.rattle(stdev=0.1)
siesta = Siesta(fdf_arguments=fdf_arguments)
opt = BFGS(atoms, trajectory='opt.siesta.traj', logfile='opt.siesta.log')
with SocketIOCalculator(siesta, log=sys.stdout,
unixsocket=unixsocket) as calc:
atoms.calc = calc
opt.run(fmax=0.05)
# Note: Siesta does not exit cleanly - expect nonzero exit codes.
def get_potential_energy(self, atoms):
self.prepare_calc_dir()
Siesta.get_potential_energy(self, atoms)
# In this script the Virtual Crystal approximation is used to model
# a stronger affinity for positive charge on the H atoms.
# This could model interaction with other molecules not explicitly
# handled.
import numpy as np
from ase.calculators.siesta import Siesta
from ase.calculators.siesta.parameters import Species
from ase.optimize import QuasiNewton
from ase import Atoms
atoms = Atoms('CH4', np.array([
[0.000000, 0.000000, 0.000000],
[0.682793, 0.682793, 0.682793],
[-0.682793, -0.682793, 0.682790],
[-0.682793, 0.682793, -0.682793],
[0.682793, -0.682793, -0.682793]]))
siesta = Siesta(
species=[
Species(symbol='H', excess_charge=0.1)])
atoms.set_calculator(siesta)
dyn = QuasiNewton(atoms, trajectory='h.traj')
dyn.run(fmax=0.02)
