1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
"""Class for demonstrating the ASE-calculator interface."""
import numpy as np
class Calculator:
"""ASE calculator.
A calculator should store a copy of the atoms object used for the
last calculation. When one of the *get_potential_energy*,
*get_forces*, or *get_stress* methods is called, the calculator
should check if anything has changed since the last calculation
and only do the calculation if it's really needed. Two sets of
atoms are considered identical if they have the same positions,
atomic numbers, unit cell and periodic boundary conditions."""
def get_potential_energy(self, atoms=None, force_consistent=False):
"""Return total energy.
Both the energy extrapolated to zero Kelvin and the energy
consistent with the forces (the free energy) can be
returned."""
return 0.0
def get_forces(self, atoms):
"""Return the forces."""
return np.zeros((len(atoms), 3))
def get_stress(self, atoms):
"""Return the stress."""
return np.zeros(6)
def calculation_required(self, atoms, quantities):
"""Check if a calculation is required.
Check if the quantities in the *quantities* list have already
been calculated for the atomic configuration *atoms*. The
quantities can be one or more of: 'energy', 'forces', 'stress',
'charges' and 'magmoms'.
This method is used to check if a quantity is available without
further calculations. For this reason, calculators should
react to unknown/unsupported quantities by returning True,
indicating that the quantity is *not* available."""
return False
class DFTCalculator(Calculator):
"""Class for demonstrating the ASE interface to DFT-calculators."""
def get_number_of_bands(self):
"""Return the number of bands."""
return 42
def get_xc_functional(self):
"""Return the XC-functional identifier.
'LDA', 'PBE', ..."""
return 'LDA'
def get_bz_k_points(self):
"""Return all the k-points in the 1. Brillouin zone.
The coordinates are relative to reciprocal latice vectors."""
return np.zeros((1, 3))
def get_number_of_spins(self):
"""Return the number of spins in the calculation.
Spin-paired calculations: 1, spin-polarized calculation: 2."""
return 1
def get_spin_polarized(self):
"""Is it a spin-polarized calculation?"""
return False
def get_ibz_k_points(self):
"""Return k-points in the irreducible part of the Brillouin zone.
The coordinates are relative to reciprocal latice vectors."""
return np.zeros((1, 3))
def get_k_point_weights(self):
"""Weights of the k-points.
The sum of all weights is one."""
return np.ones(1)
def get_pseudo_density(self, spin=None, pad=True):
"""Return pseudo-density array.
If *spin* is not given, then the total density is returned.
Otherwise, the spin up or down density is returned (spin=0 or
1)."""
return np.zeros((40, 40, 40))
def get_effective_potential(self, spin=0, pad=True):
"""Return pseudo-effective-potential array."""
return np.zeros((40, 40, 40))
def get_pseudo_wave_function(self, band=0, kpt=0, spin=0, broadcast=True,
pad=True):
"""Return pseudo-wave-function array."""
return np.zeros((40, 40, 40))
def get_eigenvalues(self, kpt=0, spin=0):
"""Return eigenvalue array."""
return np.arange(42, float)
def get_occupation_numbers(self, kpt=0, spin=0):
"""Return occupation number array."""
return np.ones(42)
def get_fermi_level(self):
"""Return the Fermi level."""
return 0.0
def initial_wannier(self, initialwannier, kpointgrid, fixedstates,
edf, spin, nbands):
"""Initial guess for the shape of wannier functions.
Use initial guess for wannier orbitals to determine rotation
matrices U and C.
"""
raise NotImplementedError
def get_wannier_localization_matrix(self, nbands, dirG, kpoint,
nextkpoint, G_I, spin):
"""Calculate integrals for maximally localized Wannier functions."""
def get_magnetic_moment(self, atoms=None):
"""Return the total magnetic moment."""
return self.occupation.magmom
def get_number_of_grid_points(self):
"""Return the shape of arrays."""
return self.gd.N_c
|
