コード例 #1
0
    def get_imag_self_energy(self,
                             grid_points,
                             frequency_step=1.0,
                             sigmas=[None],
                             temperatures=[0.0],
                             filename=None):
        ise = ImagSelfEnergy(self._interaction, is_thm=self._is_thm)
        for gp in grid_points:
            ise.set_grid_point(gp)
            ise.run_interaction()
            for sigma in sigmas:
                ise.set_sigma(sigma)
                for t in temperatures:
                    ise.set_temperature(t)
                    max_freq = (
                        np.amax(self._interaction.get_phonons()[0]) * 2 +
                        sigma * 4)
                    fpoints = np.arange(0, max_freq + frequency_step / 2,
                                        frequency_step)
                    ise.set_fpoints(fpoints)
                    ise.run()
                    gamma = ise.get_imag_self_energy()

                    for i, bi in enumerate(self._band_indices):
                        pos = 0
                        for j in range(i):
                            pos += len(self._band_indices[j])

                        write_damping_functions(
                            gp,
                            bi,
                            self._mesh,
                            fpoints,
                            gamma[:, pos:(pos + len(bi))].sum(axis=1) /
                            len(bi),
                            sigma=sigma,
                            temperature=t,
                            filename=filename)
コード例 #2
0
ファイル: __init__.py プロジェクト: Johnson-Wang/phonopy
    def get_imag_self_energy(self,
                             grid_points,
                             frequency_step=1.0,
                             sigmas=[None],
                             temperatures=[0.0],
                             filename=None):
        ise = ImagSelfEnergy(self._interaction, is_thm = self._is_thm)
        for gp in grid_points:
            ise.set_grid_point(gp)
            ise.run_interaction()
            for sigma in sigmas:
                ise.set_sigma(sigma)
                for t in temperatures:
                    ise.set_temperature(t)
                    max_freq = (np.amax(self._interaction.get_phonons()[0]) * 2
                                + sigma * 4)
                    fpoints = np.arange(0, max_freq + frequency_step / 2,
                                        frequency_step)
                    ise.set_fpoints(fpoints)
                    ise.run()
                    gamma = ise.get_imag_self_energy()

                    for i, bi in enumerate(self._band_indices):
                        pos = 0
                        for j in range(i):
                            pos += len(self._band_indices[j])

                        write_damping_functions(
                            gp,
                            bi,
                            self._mesh,
                            fpoints,
                            gamma[:, pos:(pos + len(bi))].sum(axis=1) / len(bi),
                            sigma=sigma,
                            temperature=t,
                            filename=filename)
コード例 #3
0
class conductivity_RTA(Conductivity):
    def __init__(self,
                 interaction,
                 symmetry,
                 sigmas=[0.1],
                 asigma_step =1,
                 temperatures=None,
                 mesh_divisors=None,
                 coarse_mesh_shifts=None,
                 grid_points=None,
                 cutoff_lifetime=1e-4,  # in second
                 diff_kappa = 1e-3,  #  W/m-K
                 nu=None,  # is Normal or Umklapp
                 no_kappa_stars=False,
                 gv_delta_q=1e-4,  # finite difference for group velocity
                 log_level=0,
                 write_tecplot=False,
                 kappa_write_step=None,
                 is_thm=False,
                 filename=None):
        Conductivity.__init__(self,
                              interaction,
                              symmetry,
                              grid_points=grid_points,
                              temperatures=temperatures,
                              sigmas=sigmas,
                              mesh_divisors=mesh_divisors,
                              coarse_mesh_shifts=coarse_mesh_shifts,
                              no_kappa_stars=no_kappa_stars,
                              gv_delta_q=gv_delta_q,
                              log_level=log_level,
                              write_tecplot=write_tecplot)
        self._ise = ImagSelfEnergy(self._pp, nu, is_thm=is_thm, cutoff_lifetime= cutoff_lifetime)
        self._max_sigma_step=asigma_step
        self._is_asigma = False if asigma_step==1 else True
        self._sigma_iteration_step = 0
        self._nu=nu
        self._filename = filename
        if asigma_step > 1:
            if self._filename is not None:
                self._filename ="-adapt" + self._filename
            else:
                self._filename = "-adapt"
        self._cutoff_lifetime = cutoff_lifetime
        self._diff_kappa = diff_kappa
        self._is_converge = None
        if self._no_kappa_stars:
            self._kpoint_operations = np.eye(3,dtype="intc")
        else:
            self._kpoint_operations = get_pointgroup_operations(
                self._pp.get_point_group_operations())
        self._gamma_N = [None] * len(sigmas)
        self._gamma_U = [None]*len(sigmas)
        self._read_f = False
        self._read_gv = False
        self._cv = None
        self._wstep=kappa_write_step
        self._sum_num_kstar = 0
        self._scale_bar = 0
        if temperatures is not None:
            self._allocate_values()

    def get_mesh_divisors(self):
        return self._mesh_divisors

    def get_mesh_numbers(self):
        return self._mesh

    def get_group_velocities(self):
        return self._gv

    def get_mode_heat_capacities(self):
        return self._cv

    def get_frequencies(self):
        return self._frequencies

    def get_qpoints(self):
        qpoints = np.double([self._grid_address[gp].astype(float) / self._mesh
                             for gp in self._grid_points])
        return qpoints
            
    def get_grid_points(self):
        return self._grid_points

    def get_grid_weights(self):
        return self._grid_weights
            
    def set_temperatures(self, temperatures):
        self._temperatures = temperatures

    def get_temperatures(self):
        return self._temperatures

    def set_gamma(self, gamma):
        if not self._read_gamma:
            self._gamma = gamma
            self._read_gamma = True

    def set_group_velocity(self, gv):
        if not self._read_gv:
            self._gv = gv
            self._read_gv = True

    def set_frequency(self, frequencies):
        if not self._read_f:
            self._frequencies = frequencies
            for i, freq in enumerate(frequencies):
                self.set_degenerate_at_grid(i)
            self._read_f = True

    def get_kappa(self):
        return self._kappa

    def print_calculation_progress_header(self):
        self._scale_bar = 0 # used for marking the calculation progress
        if self._sigma_iteration_step==0:
            print "Calculation based on constant sigma value"
        else:
            print "Calculation for the %d iteration for sigmas" %self._sigma_iteration_step
        print "Calculation progress..."
        print "%9s%%"*10 %tuple(np.arange(1,11)*10)

    def calculate_kappa(self,write_gamma=False):
        self.set_pp_grid_points_all()
        for self._sigma_iteration_step in np.arange(self._max_sigma_step+1):
            #Avoid multiple writings
            if self._sigma_iteration_step != 0 :
                if self._pp.get_is_write_amplitude():
                    self._pp.set_is_write_amplitude(False)
                    self._pp.set_is_read_amplitude(True)
            # self._gamma_prev[:] = self._gamma[:]
            self._kappa_prev[:] = self._kappa.copy()
            self.print_calculation_progress_header()
            for i, grid_point in enumerate(self._grid_points):
                self._qpoint = (self._grid_address[grid_point].astype('double') /
                                self._mesh)
                self.print_log_information(i, grid_point)
                if not self._read_f:
                    self._frequencies[i] = self._get_phonon_c()
                    self.set_degenerate_at_grid(i)
                if (not self._read_gamma) or (self._max_sigma_step > 1):
                    if self._log_level > 0:
                        print "Number of triplets:",
                    self._ise.set_grid_point(grid_point, i)
                    if self._log_level > 0:
                        print len(self._pp.get_triplets_at_q()[0])
                        print "Calculating interaction..."
                        sys.stdout.flush()
                    log_level = self._log_level if self._sigma_iteration_step ==0 else 0
                    self._ise.run_interaction(log_level=log_level)
                    self._frequencies[i] = self._ise.get_phonon_at_grid_point()[0]
                    self.set_degenerate_at_grid(i)
                    if self._sigma_iteration_step == 0 and not self._read_gamma:
                        self._set_gamma_at_sigmas(i)
                    else:
                        self._set_gamma_at_sigmas(i, is_adapt_sigma=True)
                self._set_kappa_at_sigmas(i)
                if write_gamma:
                    self._write_gamma(i, grid_point)
            self._kappa /=  self._sum_num_kstar
            if self._pp.get_is_write_amplitude() and self._ise._interaction._amplitude_all is not None:
                write_amplitude_to_hdf5_all(self._ise._interaction._amplitude_all, self._mesh, is_nosym=self._pp.is_nosym())
            print
            if self._sigma_iteration_step==0:
                print "Thermal conductivity from constant sigma values is calculated to be"
            else:
                print "After %d iterations for sigma, the thermal conducitvity is recalculated to be" %(self._sigma_iteration_step)
            print_kappa(self._kappa, self._temperatures, self._sigmas)
            if self._wstep is not None:
                if self._sigma_iteration_step % self._wstep == 0:
                    self.write_kappa(filename="adapt-%d"%self._sigma_iteration_step)
            if self.check_sigma_convergence().all() and self._max_sigma_step>0 and self._sigma_iteration_step > 0:
                print "The iterations for adaptive sigma has converged"
                break

        if not self.check_sigma_convergence().all() and self._sigma_iteration_step>0:
            print "The iteration for sigma has ended because it has reached the maximum step"
            print "Note that the iterations has not fully converged"


    def print_log_information(self, i, grid_point):
        if self._log_level:
            print ("===================== Grid point %d (%d/%d) "
                   "=====================" %
                   (grid_point, i + 1, len(self._grid_points)))
            print "q-point: (%5.2f %5.2f %5.2f)" % tuple(self._qpoint)
            print "Lifetime cutoff (sec): %-10.3e" % self._cutoff_lifetime
            sys.stdout.flush()
        else:
            scale = 100./len(self._grid_points)
            num = np.rint(scale)
            self._scale_bar+=(scale-num)
            sys.stdout.write("="*(num+int(self._scale_bar)))
            self._scale_bar-=int(self._scale_bar)
            sys.stdout.flush()

    def check_sigma_convergence(self):
        nsigma = self._kappa.shape[0]
        ntemp = self._kappa.shape[2]
        max_kappa = np.sum(self._kappa, axis=(1,3)).max(axis=-1)
        diff_kappa=np.sum(np.abs(self._kappa - self._kappa_prev), axis=(1,3)) # sum over qpoints and bands
        for i in range(nsigma):
            for j in range(ntemp):
                diff_kappa[i,j] /= max_kappa[i,j]
        is_converge = (np.abs(diff_kappa) < self._diff_kappa)
        self._is_converge = is_converge

        return is_converge

    def _allocate_values(self):
        num_freqs = self._primitive.get_number_of_atoms() * 3
        self._kappa = np.zeros((len(self._sigmas),
                                len(self._grid_points),
                                len(self._temperatures),
                                num_freqs,
                                6), dtype='double')
        self._kappa_prev = np.zeros_like(self._kappa)
        if not self._read_gamma:
            self._gamma = np.zeros((len(self._sigmas),
                                    len(self._grid_points),
                                    len(self._temperatures),
                                    num_freqs), dtype='double')

            if self._nu:
                self._gamma_N = np.zeros_like(self._gamma)
                self._gamma_U = np.zeros_like(self._gamma)
        # self._gamma_prev = self._gamma.copy()
        self._is_converge = np.zeros((len(self._sigmas), len(self._temperatures), 6), dtype="bool")
        if not self._read_gv:
            self._gv = np.zeros((len(self._grid_points),
                                 num_freqs,
                                 3), dtype='double')
        self._cv = np.zeros((len(self._grid_points),
                             len(self._temperatures),
                             num_freqs), dtype='double')
        if not self._read_f:
            self._frequencies = np.zeros((len(self._grid_points),
                                          num_freqs), dtype='double')

    def _set_gamma_at_sigmas(self, i, is_adapt_sigma=False):
        freqs = self._frequencies[i]
        if is_adapt_sigma:
            bz_to_irr_map = self._irr_index_mapping[self._bz_to_pp_map]
            triplets_irre_indices = bz_to_irr_map[self._ise._grid_point_triplets]

        for j, sigma in enumerate(self._sigmas):
            if self._is_converge[j].all():
                continue
            if self._log_level > 0:
                print "Calculating Gamma with initial sigma=%s" % sigma
            if not is_adapt_sigma:
                self._ise.set_sigma(sigma)
            for k, t in enumerate(self._temperatures):
                if self._is_converge[j,k].all():
                    continue
                if is_adapt_sigma:
                    self._ise.set_adaptive_sigma(triplets_irre_indices, self._gamma[j,:,k])
                self._ise.set_temperature(t)
                self._ise.run()
                self._gamma[j, i, k] = self._ise.get_imag_self_energy()
                if self._nu:
                    self._gamma_N[j,i,k]=self._ise.get_imag_self_energy_N()
                    self._gamma_U[j,i,k]=self._ise.get_imag_self_energy_U()

    def get_gamma(self):
        return np.where(self._gamma< 0.5 / self._cutoff_lifetime / THz, -1, self._gamma)

    def write_kappa(self, filename):
        temperatures = self.get_temperatures()
        for i, sigma in enumerate(self._sigmas):
            kappa = self._kappa[i]
            write_kappa_to_hdf5(self._gamma[i],
                                temperatures,
                                self.get_mesh_numbers(),
                                frequency=self.get_frequencies(),
                                group_velocity=self.get_group_velocities(),
                                heat_capacity=self.get_mode_heat_capacities(),
                                kappa=kappa,
                                qpoint=self.get_qpoints(),
                                weight=self.get_grid_weights(),
                                mesh_divisors=self.get_mesh_divisors(),
                                sigma=sigma,
                                filename=filename,
                                gnu=(self._gamma_N[i],self._gamma_U[i]))
            if self._write_tecplot:
                for j,temp in enumerate(temperatures):
                    write_kappa_to_tecplot_BZ(np.where(self._gamma[i,:,j]>1e-8, self._gamma[i,:,j],0),
                                           temp,
                                           self.get_mesh_numbers(),
                                           bz_q_address=self._bz_grid_address / self.get_mesh_numbers().astype(float),
                                           tetrahedrdons=self._unique_vertices,
                                           bz_to_pp_mapping=self._bz_to_pp_map,
                                           rec_lattice=np.linalg.inv(self._primitive.get_cell()),
                                           spg_indices_mapping=self._irr_index_mapping,
                                           spg_rotation_mapping=self._rot_mappings,
                                           frequency=self.get_frequencies(),
                                           group_velocity=self.get_group_velocities(),
                                           heat_capacity=self.get_mode_heat_capacities()[:,j],
                                           kappa=kappa[:,j],
                                           weight=self.get_grid_weights(),
                                           sigma=sigma,
                                           filename=filename+"-bz")


    def _set_kappa_at_sigmas(self, i):
        freqs = self._frequencies[i]
        
        # Group velocity [num_freqs, 3]
        if not self._read_gv:
            gv = get_group_velocity(
                self._qpoint,
                self._dm,
                self._symmetry,
                q_length=self._gv_delta_q,
                frequency_factor_to_THz=self._frequency_factor_to_THz)
            self._gv[i] = gv
        # self._gv[i] = self._get_degenerate_gv(i)

        
        # Heat capacity [num_temps, num_freqs]
        cv = self._get_cv(freqs)
        self._cv[i] = cv
        num_kstar_counted = False
        try:
            import anharmonic._phono3py as phono3c
            rec_lat = np.linalg.inv(self._primitive.get_cell())
            kpt_rotations_at_q = self._get_rotations_for_star(i)
            if self._sigma_iteration_step == 0:
                self._sum_num_kstar += len(kpt_rotations_at_q)
                num_kstar_counted = True
            deg = degenerate_sets(self._frequencies[i])
            degeneracy = np.zeros(len(self._frequencies[i]), dtype="intc")
            for ele in deg:
                for sub_ele in ele:
                    degeneracy[sub_ele]=ele[0]
            for j, sigma in enumerate(self._sigmas):
                kappa_at_qs = np.zeros_like(self._kappa[j,i])
                mfp = np.zeros((len(self._temperatures), self._frequencies.shape[1], 3), dtype="double")
                for t, temp in enumerate(self._temperatures):
                    for k in range(3):
                        mfp[t,:,k] = np.where(self._gamma[j,i,t] > 0.5 / self._cutoff_lifetime / THz,
                                          self._gv[i,:,k] /  self._gamma[j,i,t],
                                          0)
                phono3c.thermal_conductivity_at_grid(kappa_at_qs,
                                                     kpt_rotations_at_q.astype("intc").copy(),
                                                     rec_lat.copy(),
                                                     cv.copy(),
                                                     mfp.copy(),
                                                     self._gv[i].copy(),
                                                     degeneracy.copy())
                self._kappa[j,i] = kappa_at_qs / 2 * self._conversion_factor

        except ImportError:
            print "Warning: kappa calculation (the final step) went wrong in the C implementation. Changing to python instead..."
            # Outer product of group velocities (v x v) [num_k*, num_freqs, 3, 3]
            gv_by_gv_tensor = self._get_gv_by_gv(i)
            if self._sigma_iteration_step == 0 and num_kstar_counted == False:
                self._sum_num_kstar += len(gv_by_gv_tensor)

            # Sum all vxv at k*
            gv_sum2 = np.zeros((6, len(freqs)), dtype='double')
            for j, vxv in enumerate(
                ([0, 0], [1, 1], [2, 2], [1, 2], [0, 2], [0, 1])):
                gv_sum2[j] = gv_by_gv_tensor[:, :, vxv[0], vxv[1]].sum(axis=0)

            # Kappa
            for j, sigma in enumerate(self._sigmas):
                for k, l in list(np.ndindex(len(self._temperatures), len(freqs))):
                    if self._gamma[j, i, k, l] < 0.5 / self._cutoff_lifetime / THz:
                        continue
                    self._kappa[j, i, k, l, :] = (
                        gv_sum2[:, l] * cv[k, l] / (self._gamma[j, i, k, l] * 2) *
                        self._conversion_factor)

    def _get_degenerate_gv(self, i):
        deg_sets = degenerate_sets(self._frequencies[i])
        gv = self._gv[i]
        gvs = np.zeros_like(gv)
        for deg in deg_sets:
            gv_ave = gv[deg].sum(axis=0) / len(deg)
            for j in deg:
                gvs[j] = gv_ave
        return gvs

    def set_degenerate_at_grid(self, i):
        deg_sets = degenerate_sets(self._frequencies[i])
        for ele in deg_sets:
            for sub_ele in ele:
                self._degeneracies[i, sub_ele]=ele[0]

    def _get_rotations_for_star(self, i):
        if self._no_kappa_stars:
            rotations = np.array([np.eye(3, dtype=int)])
        else:
            grid_point = self._grid_points[i]
            rotations = self._kpoint_operations[self._rot_mappings[np.where(self._mappings==grid_point)]]
            if self._grid_weights is not None:
                assert len(rotations) == self._grid_weights[i], \
                    "Num rotations %d, weight %d" % (len(rotations), self._grid_weights[i])
        return rotations

    def _get_phonon_c(self):
        import anharmonic._phono3py as phono3c

        dm = self._dm
        svecs, multiplicity = dm.get_shortest_vectors()
        masses = np.double(dm.get_primitive().get_masses())
        rec_lattice = np.double(
            np.linalg.inv(dm.get_primitive().get_cell())).copy()
        if dm.is_nac():
            born = dm.get_born_effective_charges()
            nac_factor = dm.get_nac_factor()
            dielectric = dm.get_dielectric_constant()
        else:
            born = None
            nac_factor = 0
            dielectric = None
        uplo = self._pp.get_lapack_zheev_uplo()
        num_freqs = len(masses) * 3
        frequencies = np.zeros(num_freqs, dtype='double')
        eigenvectors = np.zeros((num_freqs, num_freqs), dtype='complex128')

        phono3c.phonon(frequencies,
                       eigenvectors,
                       np.double(self._qpoint),
                       dm.get_force_constants(),
                       svecs,
                       multiplicity,
                       masses,
                       dm.get_primitive_to_supercell_map(),
                       dm.get_supercell_to_primitive_map(),
                       self._frequency_factor_to_THz,
                       born,
                       dielectric,
                       rec_lattice,
                       None,
                       nac_factor,
                       uplo)
        # dm.set_dynamical_matrix(self._qpoint)
        # dynmat = dm.get_dynamical_matrix()
        # eigvals = np.linalg.eigvalsh(dynmat).real
        # frequencies = (np.sqrt(np.abs(eigvals)) * np.sign(eigvals) *
        #                self._frequency_factor_to_THz)

        return frequencies

    def _show_log(self,
                  grid_point,
                  frequencies,
                  group_velocity,
                  rotations,
                  rotations_cartesian):
        print "----- Partial kappa at grid address %d -----" % grid_point
        print "Frequency, projected group velocity (x, y, z), norm at k-stars",
        if self._gv_delta_q is None:
            print
        else:
            print " (dq=%3.1e)" % self._gv_delta_q
        q = self._grid_address[grid_point].astype(float) / self._mesh
        for i, (rot, rot_c) in enumerate(zip(rotations, rotations_cartesian)):
            q_rot = np.dot(rot, q)
            q_rot -= np.rint(q_rot)
            print " k*%-2d (%5.2f %5.2f %5.2f)" % ((i + 1,) + tuple(q_rot))
            for f, v in zip(frequencies, np.dot(rot_c, group_velocity.T).T):
                print "%8.3f   (%8.3f %8.3f %8.3f) %8.3f" % (
                    f, v[0], v[1], v[2], np.linalg.norm(v))

        print
    def print_kappa(self):
        temperatures = self.get_temperatures()
        if self._log_level==2:
            directions=['xx', 'yy','zz','xy','yz','zx']
        else:
            directions=['xx']
        for i, sigma in enumerate(self._sigmas):
            kappa = self._kappa[i]
            band = ['band'+str(b+1) for b in range(kappa.shape[2])]
            print "----------- Thermal conductivity (W/m-k) for",
            print "sigma=%s -----------" % sigma
            for j, direction in enumerate(directions):
                print"*direction:%s" %direction
                print ("#%6s%10s" + " %9s" * len(band)) % (("T(K)","Total")+ tuple(band))
                for t, k in zip(temperatures, kappa[...,j].sum(axis=0)):
                    print ("%7.1f%10.3f" + " %9.3f" * len(band)) % ((t,k.sum()) + tuple(k))
                print
        sys.stdout.flush()

    def _write_gamma(self, i, grid_point):
        for j, sigma in enumerate(self._sigmas):
            write_kappa_to_hdf5(
                self._gamma[j, i],
                self._temperatures,
                self._mesh,
                frequency=self._frequencies[i],
                group_velocity=self._gv[i],
                heat_capacity=self._cv[i],
                kappa=self._kappa[j, i],
                mesh_divisors=self._mesh_divisors,
                grid_point=grid_point,
                sigma=sigma,
                filename=self._filename)

    def _write_triplets(self, grid_point):
        triplets, weights = self._pp.get_triplets_at_q()
        grid_address = self._pp.get_grid_address()
        write_triplets(triplets,
                       weights,
                       self._mesh,
                       grid_address,
                       grid_point=grid_point,
                       filename=self._filename)