def read(self, filename):
from ase.io.trajectory import read_atoms
self.log('Reading from {}'.format(filename))
self.reader = reader = Reader(filename)
atoms = read_atoms(reader.atoms)
self._set_atoms(atoms)
res = reader.results
self.results = dict((key, res.get(key)) for key in res.keys())
if self.results:
self.log('Read {}'.format(', '.join(sorted(self.results))))
self.log('Reading input parameters:')
# XXX param
self.parameters = self.get_default_parameters()
dct = {}
for key, value in reader.parameters.asdict().items():
if (isinstance(value, dict)
and isinstance(self.parameters[key], dict)):
self.parameters[key].update(value)
else:
self.parameters[key] = value
dct[key] = self.parameters[key]
self.log.print_dict(dct)
self.log()
self.initialize(reading=True)
self.density.read(reader)
self.hamiltonian.read(reader)
self.occupations.read(reader)
self.scf.read(reader)
self.wfs.read(reader)
# We need to do this in a better way: XXX
from gpaw.utilities.partition import AtomPartition
atom_partition = AtomPartition(self.wfs.gd.comm,
np.zeros(len(self.atoms), dtype=int))
self.wfs.atom_partition = atom_partition
self.density.atom_partition = atom_partition
self.hamiltonian.atom_partition = atom_partition
rank_a = self.density.gd.get_ranks_from_positions(self.spos_ac)
new_atom_partition = AtomPartition(self.density.gd.comm, rank_a)
for obj in [self.density, self.hamiltonian]:
obj.set_positions_without_ruining_everything(
self.spos_ac, new_atom_partition)
self.hamiltonian.xc.read(reader)
if self.hamiltonian.xc.name == 'GLLBSC':
# XXX GLLB: See test/lcaotddft/gllbsc.py
self.occupations.calculate(self.wfs)
return reader
def read_gpw(filename):
try:
reader = ulm.open(filename)
except ulm.InvalidULMFileError:
return read_old_gpw(filename)
atoms = read_atoms(reader.atoms, _try_except=False)
wfs = reader.wave_functions
kpts = wfs.get('kpts')
if kpts is None:
ibzkpts = None
bzkpts = None
bz2ibz = None
else:
ibzkpts = kpts.ibzkpts
bzkpts = kpts.get('bzkpts')
bz2ibz = kpts.get('bz2ibz')
if reader.version >= 3:
efermi = reader.wave_functions.fermi_levels.mean()
else:
efermi = reader.occupations.fermilevel
atoms.calc = SinglePointDFTCalculator(atoms,
efermi=efermi,
ibzkpts=ibzkpts,
bzkpts=bzkpts,
bz2ibz=bz2ibz,
**reader.results.asdict())
if kpts is not None:
atoms.calc.kpts = []
spin = 0
for eps_kn, f_kn in zip(wfs.eigenvalues, wfs.occupations):
kpt = 0
for weight, eps_n, f_n in zip(kpts.weights, eps_kn, f_kn):
atoms.calc.kpts.append(
SinglePointKPoint(weight, spin, kpt, eps_n, f_n))
kpt += 1
spin += 1
return atoms
def _read(self, reader, reads):
r = reader
# Test data type
dtype = {'float': float, 'complex': complex}[r.dtype]
if dtype != self.dtype:
raise IOError('Data is an incompatible type.')
# Read dimensions
na = r.na
self.nv = r.nv
nspins = r.nspins
ng = r.ng
# Background electric field
Fbgef_v = r.Fbgef_v
if self.has_paw:
# Test dimensions
if na != self.na:
raise IOError('natoms is incompatible with calculator')
if nspins != self.nspins:
raise IOError('nspins is incompatible with calculator')
if (ng != self.gd.get_size_of_global_array()).any():
raise IOError('grid is incompatible with calculator')
if (Fbgef_v != self.Fbgef_v).any():
raise IOError('kick is incompatible with calculator')
else:
# Construct objects / assign values without paw
self.na = na
self.nspins = nspins
self.Fbgef_v = Fbgef_v
from ase.io.trajectory import read_atoms
self.atoms = read_atoms(r.atoms)
self.world = mpi.world
self.gd = GridDescriptor(ng + 1,
self.atoms.get_cell() / Bohr,
pbc_c=False,
comm=self.world)
self.domain_comm = self.gd.comm
self.band_comm = mpi.SerialCommunicator()
self.kpt_comm = mpi.SerialCommunicator()
# Folding
folding = r.folding
width = r.width
self.set_folding(folding, width)
# Frequencies
self.omega_w = r.omega_w
self.nw = len(self.omega_w)
# Read field
if 'field' in reads:
nfieldg = r.nfieldg
self.has_field = True
self.field_from_density = r.field_from_density
self.fieldgd = self.gd.new_descriptor(N_c=nfieldg + 1)
def readarray(name, shape, dtype):
if name.split('_')[0] in reads:
setattr(self, name, self.fieldgd.empty(shape, dtype=dtype))
self.fieldgd.distribute(r.get(name), getattr(self, name))
readarray('Frho_wg', (self.nw, ), self.dtype)
readarray('Fphi_wg', (self.nw, ), self.dtype)
readarray('Fef_wvg', (self.nw, self.nv), self.dtype)
readarray('Ffe_wg', (self.nw, ), float)
def read(self, reader):
r = reader.hamiltonian.poisson
# FDTDPoissonSolver related data
self.description = r.description
self.time = r.time
self.time_step = r.time_step
# Try to read time-dependent information
self.kick = r.kick
self.maxiter = r.maxiter
# PoissonOrganizer: classical
self.cl = PoissonOrganizer()
self.cl.spacing_def = r.cl_spacing_def
self.cl.spacing = r.cl_spacing
self.cl.cell = np.diag(r.cl_cell)
self.cl.dparsize = None
# TODO: it should be possible to use different
# communicator after restart
if r.cl_world_comm:
self.cl.dcomm = world
else:
self.cl.dcomm = mpi.serial_comm
# Generate classical grid descriptor
self.initialize_clgd()
# Classical materials data
self.classical_material = PolarizableMaterial()
self.classical_material.read(r)
self.classical_material.initialize(self.cl.gd)
# PoissonOrganizer: quantum
self.qm = PoissonOrganizer()
self.qm.corner1 = r.qm_corner1
self.qm.corner2 = r.qm_corner2
self.given_corner_v1 = r.given_corner_1
self.given_corner_v2 = r.given_corner_2
self.given_cell = np.diag(r.given_cell)
self.hratios = r.hratios
self.shift_indices_1 = r.shift_indices_1.astype(int)
self.shift_indices_2 = r.shift_indices_2.astype(int)
self.num_indices = r.num_indices.astype(int)
self.num_refinements = int(r.num_refinements)
# Redefine atoms to suit the cut_cell routine
newatoms = read_atoms(reader.atoms)
newatoms.positions = newatoms.positions + self.qm.corner1 * Bohr
newatoms.set_cell(np.diag(self.given_cell))
self.create_subsystems(newatoms)
# Read self.classical_material.charge_density
if self.cl.gd.comm.rank == 0:
big_charge_density = \
np.array(r.get('classical_material_rho'), dtype=float)
else:
big_charge_density = None
self.cl.gd.distribute(big_charge_density,
self.classical_material.charge_density)
# Read self.classical_material.polarization_total
if self.cl.gd.comm.rank == 0:
big_polarization_total = \
np.array(r.get('polarization_total'), dtype=float)
else:
big_polarization_total = None
self.cl.gd.distribute(big_polarization_total,
self.classical_material.polarization_total)
# Read self.classical_material.polarizations
if self.cl.gd.comm.rank == 0:
big_polarizations = np.array(r.get('polarizations'), dtype=float)
else:
big_polarizations = None
self.cl.gd.distribute(big_polarizations,
self.classical_material.polarizations)
# Read self.classical_material.currents
if self.cl.gd.comm.rank == 0:
big_currents = np.array(r.get('currents'), dtype=float)
else:
big_currents = None
self.cl.gd.distribute(big_currents, self.classical_material.currents)
def read_gpw(filename):
try:
reader = ulm.ulmopen(filename)
except ulm.InvalidULMFileError:
return read_old_gpw(filename)
return read_atoms(reader.atoms)