Line data Source code
1 : !!****m* ABINIT/m_potential_list
2 : !! NAME
3 : !! m_potential_list
4 : !!
5 : !! FUNCTION
6 : !! This module contains the potential_list potential. It is made of list of pointers to potentials,
7 : !! and has all the functionality of a potential
8 : !! It is to represent the equation H=\sum_i H_i
9 : !! with dH/dx = \sum_i dH_i/dx
10 : !!
11 : !! Datatypes:
12 : !!
13 : !! * potential_list_t: list of abstract_potential_t, which is essentially a list of pointer to abstract_potential_t
14 : !! itself is also a effpot type, and its energy, 1st derivative to energy are the sum of all items.
15 : !! Subroutines:
16 : !! TODO: add this when F2003 doc style is determined.
17 : !!
18 : !!
19 : !! COPYRIGHT
20 : !! Copyright (C) 2001-2026 ABINIT group (hexu)
21 : !! This file is distributed under the terms of the
22 : !! GNU General Public License, see ~abinit/COPYING
23 : !! or http://www.gnu.org/copyleft/gpl.txt .
24 : !! For the initials of contributors, see ~abinit/doc/developers/contributors.txt .
25 : !!
26 : !! SOURCE
27 :
28 :
29 : #if defined HAVE_CONFIG_H
30 : #include "config.h"
31 : #endif
32 :
33 : #include "abi_common.h"
34 :
35 : module m_potential_list
36 : use defs_basis
37 : use m_abicore
38 : use m_errors
39 : use m_xmpi
40 : use m_mpi_scheduler, only: init_mpi_info
41 : use m_multibinit_dataset, only: multibinit_dtset_type
42 : use m_abstract_potential, only: abstract_potential_t
43 : use m_multibinit_cell, only: mbcell_t, mbsupercell_t
44 : use m_hashtable_strval, only: hash_table_t
45 :
46 : implicit none
47 : !!***
48 :
49 : !!****t* defs_abitypes/effpot_pointer_t
50 : !! NAME
51 : !! effpot_pointer_t
52 : !!
53 : !! FUNCTION
54 : !! class pointer to abstract potentials. Only here because
55 : !! Fortran does not allow array of pointers! So we must put
56 : !! pointer to an type and make an array of this type.
57 : !! It should only be used in potential_list_t.
58 : !!
59 : !! SOURCE
60 : type, private:: effpot_pointer_t ! pointer to effpot
61 : class(abstract_potential_t) , pointer :: ptr=>null()
62 : end type effpot_pointer_t
63 : !!***
64 :
65 : !!****t* defs_abitypes/potential_list_t
66 : !! NAME
67 : !! potential_list_t
68 : !!
69 : !! FUNCTION
70 : !! A potential which is made of a list of potentials.
71 : !! H=\sum_i H_i
72 : !!
73 : !! SOURCE
74 : type, public, extends(abstract_potential_t) :: potential_list_t
75 : integer :: size=0 ! size is the USED number of potentials in the list
76 : integer :: capacity=0 ! capacity is the number of places allocated for potentials
77 : type(effpot_pointer_t), allocatable :: list(:) ! A list of pointer type to potentials
78 : contains
79 : procedure :: initialize ! make an empty list
80 : procedure :: ipot ! return the i'th potential
81 : procedure :: set_supercell ! pointer to supercell and set_supercell for all pot in list
82 : procedure :: set_params
83 : procedure :: finalize
84 : procedure :: append ! add a potential to the list
85 : procedure :: calculate ! each potential in list do calculate and then sum.
86 : procedure :: get_delta_E ! currently only used in spin potential,
87 : ! to calculate energy difference when one spin changes.
88 :
89 : procedure :: get_delta_E_lwf ! currently only used in lwf potential,
90 : end type potential_list_t
91 : !!***
92 :
93 : contains
94 :
95 : !----------------------------------------------------------------------
96 : !> @brief initialize
97 : !>
98 : !----------------------------------------------------------------------
99 6 : subroutine initialize(self)
100 : class (potential_list_t), intent(inout) :: self
101 6 : self%size=0
102 6 : self%capacity=0
103 6 : self%label="ListPotential"
104 6 : end subroutine initialize
105 :
106 : !----------------------------------------------------------------------
107 : !> @brief return the i'th potential in the list
108 : !>
109 : !> @param[in] i: the index of the spin potentails
110 : ! Unfortunately, fortran does not allow things call potlist%ipot(i)%method...
111 : !----------------------------------------------------------------------
112 0 : function ipot(self, i)
113 : class (potential_list_t), target, intent(in) :: self
114 : integer, intent(in) :: i
115 : class(abstract_potential_t), pointer :: ipot
116 0 : ipot=>self%list(i)%ptr
117 0 : end function ipot
118 :
119 : !----------------------------------------------------------------------
120 : !> @brief set_supercell for every member of the potential list
121 : !> @param[in] supercell
122 : !----------------------------------------------------------------------
123 12 : subroutine set_supercell(self, supercell)
124 : class (potential_list_t), intent(inout) :: self
125 : type (mbsupercell_t), target, intent(inout) :: supercell
126 : integer :: i
127 12 : self%supercell => supercell
128 22 : do i=1, self%size
129 22 : call self%list(i)%ptr%set_supercell(supercell)
130 : end do
131 12 : end subroutine set_supercell
132 :
133 : !----------------------------------------------------------------------
134 : !> @brief finalize
135 : !----------------------------------------------------------------------
136 6 : subroutine finalize(self)
137 : class (potential_list_t) ,intent(inout) :: self
138 : integer :: i
139 16 : do i=1, self%size
140 10 : call self%list(i)%ptr%finalize()
141 : ! Intel compiler complains
142 10 : if(associated(self%list(i)%ptr)) then
143 20 : ABI_FREE(self%list(i)%ptr)
144 : endif
145 :
146 16 : nullify(self%list(i)%ptr)
147 : end do
148 6 : if (allocated(self%list)) then
149 6 : ABI_FREE(self%list)
150 : end if
151 6 : self%size=0
152 6 : self%capacity=0
153 6 : self%is_null=.True.
154 6 : self%has_displacement=.False.
155 6 : self%has_strain=.False.
156 6 : self%has_spin=.False.
157 6 : end subroutine finalize
158 :
159 :
160 : !----------------------------------------------------------------------
161 : !> @brief append a potential to the list
162 : !> It also update the has_* according to the added effpot.
163 : !> @param[in] effpot: the effective potential to be added.
164 : !----------------------------------------------------------------------
165 10 : subroutine append(self, effpot)
166 : ! Add a pointer to an effpot term to list.
167 : class (potential_list_t) :: self
168 : class (abstract_potential_t), target :: effpot
169 10 : type(effpot_pointer_t), allocatable :: temp(:)
170 10 : self%size=self%size + 1
171 10 : if(self%size==1) then
172 6 : self%capacity=8
173 54 : ABI_MALLOC(self%list, (self%capacity))
174 4 : else if ( self%size>self%capacity ) then
175 : ! fancy increasing equation to allocate new array.
176 0 : self%capacity = self%size + self%size / 4 + 8
177 0 : ABI_MALLOC(temp, (self%capacity))
178 0 : temp(:self%size-1) = self%list(:)
179 0 : ABI_MOVE_ALLOC(temp, self%list) !temp gets deallocated
180 : end if
181 10 : self%list(self%size)%ptr=>effpot
182 10 : self%is_null= (self%is_null .and. effpot%is_null)
183 10 : self%has_spin= (self%has_spin .or. effpot%has_spin)
184 10 : self%has_displacement= (self%has_displacement .or. effpot%has_displacement)
185 10 : self%has_strain= (self%has_strain.or. effpot%has_strain)
186 10 : self%has_lwf =(self%has_lwf.or. effpot%has_lwf)
187 10 : end subroutine append
188 :
189 6 : subroutine set_params(self, params)
190 : class(potential_list_t), intent(inout) :: self ! the effpot may save the states.
191 : type(multibinit_dtset_type), intent(inout) :: params
192 : integer :: i
193 16 : do i=1, self%size
194 16 : call self%list(i)%ptr%set_params(params)
195 : end do
196 6 : end subroutine set_params
197 :
198 :
199 :
200 : !----------------------------------------------------------------------
201 : !> @brief calculate energy and 1st derivatives
202 : !> The list will add the sum of all the results from its components.
203 : !> If one optional variable is passed to a subroutine, its "presence" will be kept.
204 : !> @param[in] (optional) displacement, strain, spin, lwf
205 : !> @param[out](optional) force, stress, bfield, lwf_force, energy
206 : !----------------------------------------------------------------------
207 108056 : subroutine calculate(self, displacement, strain, spin, lwf, force, stress, bfield, &
208 54028 : & lwf_force, energy, energy_table)
209 : ! calculate energy and its first derivatives.
210 : class(potential_list_t), intent(inout) :: self ! the effpot may save the states.
211 : ! inputs
212 : real(dp), optional, intent(inout) :: displacement(:,:), strain(:,:), spin(:,:), lwf(:)
213 : ! outputs
214 : real(dp), optional, intent(inout) :: force(:,:), stress(:,:), bfield(:,:), lwf_force(:), energy
215 : type(hash_table_t),optional, intent(inout) :: energy_table
216 : integer :: i
217 : ! Note
218 : ! calculate force and strain if asked to
219 34664932 : if(present(force)) force(:,:)=0.0d0
220 158340 : if(present(stress)) stress(:,:)=0.0d0
221 3517488 : if(present(bfield)) bfield(:,:)=0.0d0
222 43104028 : if(present(lwf_force)) lwf_force(:)=0.0d0
223 54028 : if(present(energy)) energy =0.0
224 124072 : do i=1, self%size
225 : call self%list(i)%ptr%calculate(displacement=displacement, strain=strain, &
226 : & spin=spin, lwf=lwf, force=force, stress=stress, bfield=bfield, &
227 488248 : lwf_force=lwf_force, energy=energy, energy_table=energy_table)
228 : end do
229 54028 : end subroutine calculate
230 :
231 : !----------------------------------------------------------------------
232 : !> @brief get_delta_E: calculate the energy difference when a given spin
233 : !> is changed. This is to be used for spin Monte Carlo. Currently the
234 : !> only supported is the spin model.
235 : !>
236 : !> @param[in] S: spin of full structure. array of (3, nspin)
237 : !> @param[in] ispin: the index of spin changed. integer
238 : !> @param[in] snew: the new value of the changed spin.
239 : !> @param[out] deltaE: the energy difference
240 : !----------------------------------------------------------------------
241 0 : subroutine get_delta_E(self, S, ispin, Snew, deltaE)
242 : class(potential_list_t), intent(inout) :: self ! the effpot may save the states.
243 : real(dp), intent(inout) :: S(:,:), Snew(:)
244 : integer, intent(in) :: ispin
245 : real(dp), intent(inout) :: deltaE
246 : integer :: i
247 0 : do i=1, self%size
248 0 : call self%list(i)%ptr%get_delta_E(S=S, ispin=ispin, Snew=Snew, deltaE=deltaE)
249 : end do
250 0 : end subroutine get_delta_E
251 :
252 : !----------------------------------------------------------------------
253 : !> @brief get_delta_E_lwf: calculate the energy difference when a given lwf
254 : !> is changed. This is to be used for spin Monte Carlo. Currently the
255 : !> only supported is the spin model.
256 : !>
257 : !> @param[in] lwf: lwf of full structure. array of (nlwf)
258 : !> @param[in] ilwf: the index of spin changed. integer
259 : !> @param[in] lwf_new: the new value of the changed spin.
260 : !> @param[out] deltaE: the energy difference
261 : !----------------------------------------------------------------------
262 0 : subroutine get_delta_E_lwf(self, lwf, ilwf, lwf_new, deltaE)
263 : ! for spin monte carlo
264 : ! calculate energy difference if one spin is moved.
265 : class(potential_list_t), intent(inout) :: self ! the effpot may save the states.
266 : real(dp), intent(inout) :: lwf(:), lwf_new
267 : integer, intent(in) :: ilwf
268 : real(dp), intent(inout) :: deltaE
269 : integer :: i
270 0 : do i=1, self%size
271 0 : call self%list(i)%ptr%get_delta_E_lwf(lwf=lwf, ilwf=ilwf, lwf_new=lwf_new, deltaE=deltaE)
272 : end do
273 0 : end subroutine get_delta_E_lwf
274 :
275 :
276 :
277 0 : end module m_potential_list
|
