def _write(self, writer, writes):
# Swap classical and quantum cells, and shift atom positions for
# the time of writing
qmcell = self.atoms.get_cell()
self.atoms.set_cell(self.fdtd.cl.cell * Bohr) # Set classical cell
self.atoms.positions = (self.atoms.get_positions() +
self.fdtd.qm.corner1 * Bohr)
BaseInducedField._write(self, writer, writes)
self.atoms.set_cell(qmcell) # Restore quantum cell to the atoms object
self.atoms.positions = (self.atoms.get_positions() -
self.fdtd.qm.corner1 * Bohr)
# Write time propagation status
writer.write(time=self.time)
# Mask, interpolation approach:
# self.eps0_G = self.fdtd.classical_material.permittivityValue(
# omega=0.0) - self.fdtd.classical_material.epsInfty
# self.eps0_G= -interpolator.apply(self.eps0_G)
# Mask, direct approach:
self.eps0_G = self.fdtd.cl.gd.zeros()
for component in self.fdtd.classical_material.components:
self.eps0_G += 1.0 * component.get_mask(gd=self.fdtd.cl.gd)
# def writearray(name, shape, dtype):
# if name.split('_')[0] in writes:
# writer.add_array(name, shape, dtype)
# a_wxg = getattr(self, name)
# for w in range(self.nw):
# if self.fdtd.cl.gd == self.gd:
# writer.fill(self.gd.collect(a_wxg[w]))
# else:
# writer.fill(self.gd.collect(Transformer(self.fdtd.cl.gd,
# self.gd, self.stencil, self.dtype).apply(a_wxg[w])))
def writearray(name):
if name.split('_')[0] in writes:
a_xg = getattr(self, name)
if self.fdtd.cl.gd != self.gd:
a_xg = Transformer(self.fdtd.cl.gd, self.gd, self.stencil,
a_xg.dtype).apply(a_xg)
writer.write(**{name: self.gd.collect(a_xg)})
# Write time propagation arrays
writearray('n0_G')
writearray('Fn_wG')
writearray('eps0_G')
if hasattr(self.fdtd, 'qm') and hasattr(self.fdtd.qm, 'corner1'):
writer.write(corner1_v=self.fdtd.qm.corner1)
writer.write(corner2_v=self.fdtd.qm.corner2)
self.fdtd.cl.gd.comm.barrier()
def _write(self, writer, writes):
BaseInducedField._write(self, writer, writes)
# Collect np_a to master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
np_a = {}
for a in range(self.na):
np_a[a] = np.empty(1, dtype=int)
else:
np_a = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, np_a, 0, self.np_a, self.rank_a,
range(self.na))
# Write time propagation status
writer.write(time=self.time, np_a=np_a)
def writearray(name, shape, dtype):
if name.split('_')[0] in writes:
writer.add_array(name, shape, dtype)
a_wxg = getattr(self, name)
for w in range(self.nw):
writer.fill(self.gd.collect(a_wxg[w]))
ng = tuple(self.gd.get_size_of_global_array())
# Write time propagation arrays
if 'n0t' in writes:
writer.write(n0t_sG=self.gd.collect(self.n0t_sG))
writearray('Fnt_wsG', (self.nw, self.nspins) + ng, self.dtype)
if 'D0' in writes:
# Collect D0_asp to world master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
D0_asp = {}
for a in range(self.na):
npa = np_a[a]
D0_asp[a] = np.empty((self.nspins, npa[0]),
dtype=float)
else:
D0_asp = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, D0_asp, 0, self.D0_asp,
self.rank_a, range(self.na))
# Write
writer.write(D0_asp=D0_asp)
if 'FD' in writes:
# Collect FD_awsp to world master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
FD_awsp = {}
for a in range(self.na):
npa = np_a[a]
FD_awsp[a] = np.empty((self.nw, self.nspins, npa[0]),
dtype=complex)
else:
FD_awsp = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, FD_awsp, 0, self.FD_awsp,
self.rank_a, range(self.na))
# Write
writer.write(FD_awsp=FD_awsp)
def _write(self, tar, writes, ws, masters):
# Swap classical and quantum cells, and shift atom positions for the time of writing
qmcell = self.atoms.get_cell()
self.atoms.set_cell(self.fdtd.cl.cell*Bohr) # Set classical cell
self.atoms.positions = self.atoms.get_positions() + self.fdtd.qm.corner1*Bohr
BaseInducedField._write(self, tar, writes, ws, masters)
self.atoms.set_cell(qmcell) # Restore quantum cell to the atoms object
self.atoms.positions = self.atoms.get_positions() - self.fdtd.qm.corner1*Bohr
master, domainmaster, bandmaster, kptmaster = masters
# Write time propagation status
if master:
tar['time'] = self.time
# Mask, interpolation approach:
#self.eps0_G = self.fdtd.classical_material.permittivityValue(omega=0.0) - self.fdtd.classical_material.epsInfty
#self.eps0_G= -interpolator.apply(self.eps0_G)
# Mask, direct approach:
self.eps0_G = self.fdtd.cl.gd.zeros()
for component in self.fdtd.classical_material.components:
self.eps0_G += 1.0 * component.get_mask(gd = self.fdtd.cl.gd, verbose = False)
# Write time propagation arrays
if 'n0' in writes:
if master:
tar.add('n0_G',
('ng0', 'ng1', 'ng2'),
dtype=float)
if self.fdtd.cl.gd == self.gd:
big_g = self.gd.collect(self.n0_G)
else:
big_g = self.gd.collect(Transformer(self.fdtd.cl.gd, self.gd, self.stencil, float).apply(self.n0_G))
if master:
tar.fill(big_g)
if 'Fn' in writes:
if master:
tar.add('Fn_wsG',
('nw', 'nspins', 'ng0', 'ng1', 'ng2'),
dtype=self.dtype)
for w in ws:
#big_g = self.gd.collect(self.Fn_wG[w])
if self.fdtd.cl.gd == self.gd:
big_g = self.gd.collect(self.Fn_wsG[w])
else:
big_g = self.gd.collect(Transformer(self.fdtd.cl.gd, self.gd, self.stencil, self.dtype).apply(self.Fn_wsG[w]))
#big_g = self.gd.collect(interpolator_float.apply(self.n0_G.copy()))
if master:
tar.fill(big_g)
if 'eps0' in writes:
if master:
tar.add('eps0_G',
('ng0', 'ng1', 'ng2'),
dtype=float)
#big_g = self.fieldgd.collect(self.eps0_G)
if self.fdtd.cl.gd == self.gd:
big_g = self.gd.collect(self.eps0_G)
else:
big_g = self.gd.collect(Transformer(self.fdtd.cl.gd, self.gd, self.stencil, float).apply(self.eps0_G))
if master:
tar.fill(big_g)
if master and hasattr(self.fdtd, 'qm') and hasattr(self.fdtd.qm, 'corner1'):
tar.add('corner1_v', ('nv',), self.fdtd.qm.corner1, dtype=float)
tar.add('corner2_v', ('nv',), self.fdtd.qm.corner2, dtype=float)
self.fdtd.cl.gd.comm.barrier()
def _write(self, tar, writes, ws, masters):
BaseInducedField._write(self, tar, writes, ws, masters)
master, domainmaster, bandmaster, kptmaster = masters
# Collect np_a to master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
np_a = {}
for a in range(self.na):
np_a[a] = np.empty((1), dtype=int)
else:
np_a = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, np_a, 0,
self.np_a, self.rank_a, range(self.na))
# Write time propagation status
if master:
tar['time'] = self.time
for a in range(self.na):
tar.dimension('np_%d' % a, int(np_a[a]))
# Write time propagation arrays
if 'n0t' in writes:
if master:
tar.add('n0t_sG',
('nspins', 'ng0', 'ng1', 'ng2'),
dtype=float)
for s in range(self.nspins):
big_g = self.gd.collect(self.n0t_sG[s])
if master:
tar.fill(big_g)
if 'Fnt' in writes:
if master:
tar.add('Fnt_wsG',
('nw', 'nspins', 'ng0', 'ng1', 'ng2'),
dtype=self.dtype)
for w in ws:
for s in range(self.nspins):
big_g = self.gd.collect(self.Fnt_wsG[w][s])
if master:
tar.fill(big_g)
if 'D0' in writes:
# Collect D0_asp to world master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
D0_asp = {}
for a in range(self.na):
D0_asp[a] = np.empty((self.nspins, np_a[a]),
dtype=float)
else:
D0_asp = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, D0_asp, 0,
self.D0_asp, self.rank_a, range(self.na))
# Write
if master:
for a in range(self.na):
tar.add('D0_%dsp' % a, ('nspins', 'np_%d' % a),
dtype=float)
tar.fill(D0_asp[a])
if 'FD' in writes:
# Collect FD_awsp to world master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
FD_awsp = {}
for a in range(self.na):
FD_awsp[a] = np.empty((self.nw, self.nspins, np_a[a]),
dtype=complex)
else:
FD_awsp = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, FD_awsp, 0,
self.FD_awsp, self.rank_a, range(self.na))
# Write
if master:
for a in range(self.na):
tar.add('FD_%dwsp' % a, ('nw', 'nspins', 'np_%d' % a),
dtype=self.dtype)
tar.fill(FD_awsp[a][ws])
def _write(self, tar, writes, ws, masters):
BaseInducedField._write(self, tar, writes, ws, masters)
master, domainmaster, bandmaster, kptmaster = masters
# Collect np_a to master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
np_a = {}
for a in range(self.na):
np_a[a] = np.empty((1), dtype=int)
else:
np_a = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, np_a, 0, self.np_a, self.rank_a,
range(self.na))
# Write time propagation status
if master:
tar['time'] = self.time
for a in range(self.na):
tar.dimension('np_%d' % a, int(np_a[a]))
# Write time propagation arrays
if 'n0t' in writes:
if master:
tar.add('n0t_sG', ('nspins', 'ng0', 'ng1', 'ng2'), dtype=float)
for s in range(self.nspins):
big_g = self.gd.collect(self.n0t_sG[s])
if master:
tar.fill(big_g)
if 'Fnt' in writes:
if master:
tar.add('Fnt_wsG', ('nw', 'nspins', 'ng0', 'ng1', 'ng2'),
dtype=self.dtype)
for w in ws:
for s in range(self.nspins):
big_g = self.gd.collect(self.Fnt_wsG[w][s])
if master:
tar.fill(big_g)
if 'D0' in writes:
# Collect D0_asp to world master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
D0_asp = {}
for a in range(self.na):
D0_asp[a] = np.empty((self.nspins, np_a[a]),
dtype=float)
else:
D0_asp = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, D0_asp, 0, self.D0_asp,
self.rank_a, range(self.na))
# Write
if master:
for a in range(self.na):
tar.add('D0_%dsp' % a, ('nspins', 'np_%d' % a),
dtype=float)
tar.fill(D0_asp[a])
if 'FD' in writes:
# Collect FD_awsp to world master
if self.kpt_comm.rank == 0 and self.band_comm.rank == 0:
# Create empty dict on domain master
if self.domain_comm.rank == 0:
FD_awsp = {}
for a in range(self.na):
FD_awsp[a] = np.empty((self.nw, self.nspins, np_a[a]),
dtype=complex)
else:
FD_awsp = {}
# Collect dict to master
sendreceive_dict(self.domain_comm, FD_awsp, 0, self.FD_awsp,
self.rank_a, range(self.na))
# Write
if master:
for a in range(self.na):
tar.add('FD_%dwsp' % a, ('nw', 'nspins', 'np_%d' % a),
dtype=self.dtype)
tar.fill(FD_awsp[a][ws])
