Line data Source code
1 : !!****m* ABINIT/m_spin_potential
2 : !! NAME
3 : !! m_spin_potential
4 : !!
5 : !! FUNCTION
6 : !! This module contains the spin hamiltonian, and the methods for
7 : !! calculating effective magnetic field (torque), dS/dt, and total_energy
8 : !!
9 : !!
10 : !! Datatypes:
11 : !!
12 : !! * spin_potential_t
13 : !!
14 : !! Subroutines:
15 : !!
16 : !! * spin_potential_t_initialize
17 : !! * spin_potential_t_finalize
18 : !! * spin_potential_t_total_Heff : calculate total Heff (no Langevin term)
19 : !! * spin_potential_t_Heff_to_dSdt:
20 : !! * spin_potential_t_get_dSdt : dSdt, Langevin term is an input.
21 : !! * spin_potential_t_get_Langevin_Heff
22 :
23 : !!
24 : !!
25 : !! COPYRIGHT
26 : !! Copyright (C) 2001-2026 ABINIT group (TO, hexu)
27 : !! This file is distributed under the terms of the
28 : !! GNU General Public License, see ~abinit/COPYING
29 : !! or http://www.gnu.org/copyleft/gpl.txt .
30 : !! For the initials of contributors, see ~abinit/doc/developers/contributors.txt .
31 : !!
32 : !! SOURCE
33 :
34 : #if defined HAVE_CONFIG_H
35 : #include "config.h"
36 : #endif
37 : #include "abi_common.h"
38 : module m_spin_potential
39 : use defs_basis
40 : use m_errors
41 : use m_abicore
42 : use m_xmpi
43 : use m_mpi_scheduler, only: mb_mpi_info_t, init_mpi_info, mpi_scheduler_t
44 : use m_multibinit_dataset, only: multibinit_dtset_type
45 : use m_multibinit_cell, only: mbcell_t, mbsupercell_t
46 : use m_spmat_coo, only: coo_mat_t
47 : use m_spmat_lil, only: lil_mat_t
48 : use m_spmat_csr, only : CSR_mat_t
49 : use m_spmat_convert, only : spmat_convert
50 : use m_abstract_potential, only : abstract_potential_t
51 : use m_hashtable_strval, only: hash_table_t
52 : implicit none
53 : !!***
54 : private
55 :
56 : type, public, extends(abstract_potential_t) :: spin_potential_t
57 : integer :: nspin=0
58 : logical :: has_external_hfield, has_dipdip
59 : real(dp) :: eref !energy of reference spin state
60 :
61 : ! Array or scalar?
62 : real(dp), allocatable :: external_hfield(:,:)
63 :
64 : ! Exchange/DMI/dipdip stored like COO sparse matrix form.
65 : type(lil_mat_t) :: coeff_coo
66 : logical :: csr_mat_ready= .False.
67 : logical :: has_onsite = .False.
68 : type(CSR_mat_t) :: bilinear_csr_mat
69 : ! 3, 3, ninit
70 :
71 : ! vector for calculating effective field
72 : real(dp), allocatable :: Htmp(:, :)
73 : real(dp), allocatable :: ms(:)
74 : real(dp), allocatable :: onsite_bilinear_term(:, :, :)
75 : type(mb_mpi_info_t) :: mpiinfo
76 : type(mpi_scheduler_t) :: mps
77 : CONTAINS
78 : procedure :: initialize
79 : procedure :: finalize
80 : procedure :: set_params
81 : procedure :: set_supercell
82 : procedure :: get_Heff => spin_potential_t_total_Heff
83 : procedure :: set_external_hfield
84 : procedure :: calc_bilinear_term_Heff
85 : procedure :: calc_external_Heff
86 : procedure :: calculate => spin_potential_t_calculate
87 : !procedure :: get_energy => spin_potential_t_get_energy
88 : procedure :: get_delta_E => spin_potential_t_get_delta_E
89 : procedure :: add_bilinear_term
90 : procedure :: add_bilinear_term_spin_block
91 : procedure :: set_bilinear_term
92 : procedure, private :: prepare_csr_matrix
93 : procedure :: set_terms
94 : end type spin_potential_t
95 :
96 : contains
97 :
98 2 : subroutine initialize(self, nspin)
99 : !Arguments ------------------------------------
100 : !scalars
101 : class(spin_potential_t), intent(inout) :: self
102 : integer :: nspin
103 :
104 : integer :: master, my_rank, comm, nproc, ierr
105 : logical :: iam_master
106 2 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
107 2 : call self%mps%initialize(ntasks=nspin, master=master, comm=comm)
108 2 : self%label="SpinPotential"
109 2 : self%has_spin=.True.
110 2 : self%has_displacement=.False.
111 2 : self%has_strain=.False.
112 2 : self%is_null=.False.
113 2 : self%nspin=nspin
114 2 : call xmpi_bcast(self%nspin, master, comm, ierr)
115 6 : ABI_MALLOC( self%ms, (self%nspin))
116 2 : if(iam_master) then
117 6 : call self%coeff_coo%initialize([self%nspin*3, self%nspin*3])
118 : endif
119 6 : ABI_MALLOC(self%external_hfield, (3,self%nspin))
120 1730 : self%external_hfield=0.0_dp
121 4 : ABI_MALLOC( self%Htmp, (3, self%nspin))
122 1730 : self%Htmp(:,:)=0.0_dp
123 :
124 2 : self%has_external_hfield=.False.
125 2 : self%has_dipdip=.False.
126 6 : ABI_MALLOC(self%onsite_bilinear_term, (3, 3, self%nspin))
127 5618 : self%onsite_bilinear_term = 0.0_dp
128 2 : end subroutine initialize
129 :
130 8 : subroutine set_supercell(self, supercell)
131 : class(spin_potential_t), intent(inout) :: self
132 : type(mbsupercell_t), target, intent(inout) :: supercell
133 : integer :: master, my_rank, comm, nproc, ierr
134 : logical :: iam_master
135 4 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
136 :
137 4 : self%supercell=>supercell
138 868 : self%ms(:)=supercell%spin%ms(:)
139 4 : call xmpi_bcast(self%ms, master, comm, ierr)
140 4 : end subroutine set_supercell
141 :
142 0 : subroutine set_terms(self, &
143 0 : & external_hfield, &
144 0 : & bilinear_i, bilinear_j, bilinear_val)
145 :
146 : !Arguments ------------------------------------
147 : !scalars
148 : !arrays
149 : class(spin_potential_t), intent(inout) :: self
150 :
151 : ! Terms.
152 : real(dp), optional, intent(in) :: external_hfield(:,:)
153 : integer, optional, intent(in) :: bilinear_i(:), bilinear_j(:)
154 : real(dp), optional,intent(in) :: bilinear_val(:)
155 :
156 : !Local variables-------------------------------
157 : ! *************************************************************************
158 :
159 :
160 0 : if(present(external_hfield)) then
161 0 : call self%set_external_hfield( external_hfield)
162 : end if
163 :
164 0 : if ( present(bilinear_i) .and. present( bilinear_j) .and. present(bilinear_val) ) then
165 0 : call self%set_bilinear_term(bilinear_i, bilinear_j, bilinear_val)
166 : endif
167 :
168 0 : end subroutine set_terms
169 :
170 : !-------------------------------------------------------------------!
171 : !set_params :
172 : !-------------------------------------------------------------------!
173 2 : subroutine set_params(self, params)
174 : class(spin_potential_t), intent(inout) :: self
175 : type(multibinit_dtset_type), intent(inout) :: params
176 4 : real(dp) :: tmp(3, self%nspin)
177 : integer :: i
178 : integer :: master, my_rank, comm, nproc
179 : logical :: iam_master
180 2 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
181 2 : if(iam_master) then
182 434 : do i=1, self%nspin
183 1730 : tmp(:, i)=params%spin_mag_field(:)
184 : end do
185 : endif
186 2 : call self%set_external_hfield(tmp)
187 2 : end subroutine set_params
188 :
189 :
190 2 : subroutine set_external_hfield(self, external_hfield)
191 : class(spin_potential_t), intent(inout) :: self
192 : real(dp), intent(in) :: external_hfield(:,:)
193 : integer :: master, my_rank, comm, nproc, ierr
194 : logical :: iam_master
195 2 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
196 2 : self%has_external_hfield = .true.
197 1732 : self%external_hfield = external_hfield
198 2 : call xmpi_bcast(self%has_external_hfield, master, comm, ierr)
199 2 : call xmpi_bcast(self%external_hfield, master, comm, ierr)
200 2 : end subroutine set_external_hfield
201 :
202 4006 : subroutine calc_external_Heff(self, Heff)
203 : class(spin_potential_t), intent(inout) :: self
204 : real(dp), intent(out) :: Heff(:,:)
205 : integer :: i
206 869302 : do i= self%mps%istart, self%mps%iend
207 3465190 : Heff(:, i)= self%external_hfield(:, i)
208 : end do
209 4006 : end subroutine calc_external_Heff
210 :
211 33696 : subroutine add_bilinear_term(self, i,j, val)
212 : class(spin_potential_t), intent(inout) :: self
213 : integer, intent(in) :: i, j
214 : real(dp), intent(in) :: val
215 : integer :: master, my_rank, comm, nproc
216 : logical :: iam_master
217 33696 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
218 33696 : if(iam_master) then
219 101088 : call self%coeff_coo%add_entry(ind=[i,j],val=val)
220 : endif
221 33696 : end subroutine add_bilinear_term
222 :
223 0 : subroutine set_bilinear_term(self, ilist,jlist, vallist)
224 : class(spin_potential_t), intent(inout) :: self
225 : integer, intent(in) :: ilist(:), jlist(:)
226 : real(dp), intent(in) :: vallist(:)
227 : integer :: i
228 : integer :: master, my_rank, comm, nproc
229 : logical :: iam_master
230 0 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
231 :
232 0 : if (iam_master) then
233 0 : do i = 1, size(ilist)
234 0 : call self%coeff_coo%add_entry(ind=[ilist(i),jlist(i)],val=vallist(i))
235 : end do
236 : endif
237 0 : end subroutine set_bilinear_term
238 :
239 :
240 0 : subroutine add_bilinear_term_spin_block(self, ispin, jspin, val)
241 :
242 : class(spin_potential_t), intent(inout) :: self
243 : integer, intent(in) :: ispin, jspin
244 : real(dp), intent(in) :: val(:,:)
245 : integer :: ia, ib
246 :
247 : integer :: master, my_rank, comm, nproc
248 : logical :: iam_master
249 0 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
250 :
251 0 : if(iam_master) then
252 0 : do ia = 1, 3, 1
253 0 : do ib=1, 3, 1
254 : call self%coeff_coo%add_entry([(ispin-1)*3+ia, &
255 0 : (jspin-1)*3+ib], val=val(ia,ib))
256 : end do
257 : end do
258 0 : if(ispin==jspin) then
259 0 : self%has_onsite = .True.
260 0 : self%onsite_bilinear_term(:, :, ispin) = val(:, :)
261 : end if
262 : endif
263 0 : end subroutine add_bilinear_term_spin_block
264 :
265 4006 : subroutine prepare_csr_matrix(self)
266 : class(spin_potential_t), intent(inout) :: self
267 : integer :: master, my_rank, comm, nproc, ierr
268 : logical :: iam_master
269 : integer :: ispin
270 :
271 4006 : if (.not. self%csr_mat_ready) then
272 2 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
273 2 : if(iam_master) then
274 2 : call spmat_convert(self%coeff_coo, self%bilinear_csr_mat)
275 : endif
276 2 : call self%coeff_coo%finalize()
277 2 : call self%bilinear_csr_mat%sync(master=master, comm=comm, nblock=1)
278 2 : self%csr_mat_ready=.True.
279 2 : call xmpi_bcast(self%csr_mat_ready, master, comm, ierr)
280 : ! also broadcast the onsite terms.
281 434 : do ispin=1, self%nspin
282 434 : call self%bilinear_csr_mat%get_block(ispin*3-2, ispin*3-2, 3, 3, self%onsite_bilinear_term(:, :, ispin))
283 : !print *, "ispin:", ispin
284 : !print *, "oniste", self%onsite_bilinear_term(:, :, ispin)
285 : end do
286 2 : self%has_onsite=.True.
287 :
288 2 : call xmpi_bcast(self%has_onsite, master, comm, ierr)
289 2 : call xmpi_bcast(self%onsite_bilinear_term, master, comm, ierr)
290 : endif
291 4006 : end subroutine prepare_csr_matrix
292 :
293 :
294 4006 : subroutine calc_bilinear_term_Heff(self, S, Heff)
295 : class(spin_potential_t), intent(inout) :: self
296 : real(dp), intent(inout) :: S(:,:)
297 : real(dp), intent(out) :: Heff(3,self%nspin)
298 : integer :: i
299 : !call self%bilinear_csr_mat%mv(S ,Heff)
300 4006 : call self%prepare_csr_matrix()
301 4006 : call self%bilinear_csr_mat%mv_mpi(x=S ,b=Heff, bcastx=.False., syncb=.False.)
302 869302 : do i= self%mps%istart, self%mps%iend
303 3465190 : Heff(:, i)=Heff(:,i)/self%ms(i)*2.0_dp
304 : end do
305 4006 : end subroutine calc_bilinear_term_Heff
306 :
307 8008 : subroutine spin_potential_t_calculate(self, displacement, strain, spin, lwf, &
308 8008 : force, stress, bfield, lwf_force, energy, energy_table)
309 : class(spin_potential_t), intent(inout) :: self
310 : real(dp), optional, intent(inout) :: displacement(:,:), strain(:,:), spin(:,:), lwf(:)
311 : real(dp), optional, intent(inout) :: force(:,:), stress(:,:), bfield(:,:), lwf_force(:), energy
312 : type(hash_table_t),optional, intent(inout) :: energy_table
313 : real(dp) :: etmp
314 : ! if present in input
315 : ! calculate if required
316 :
317 8008 : if (present(bfield) ) then
318 4004 : call self%get_Heff(spin, bfield, etmp)
319 :
320 : ! subtract enery of reference spin configuration
321 4004 : etmp = etmp - self%eref
322 :
323 : ! only update energy when bfield is asked for.
324 4004 : if ( present(energy)) then
325 4004 : energy=energy+etmp
326 : end if
327 4004 : if (present(energy_table)) then
328 4004 : call energy_table%put(self%label, etmp)
329 : end if
330 : end if
331 :
332 :
333 8008 : ABI_UNUSED_A(self)
334 8008 : ABI_UNUSED_A(displacement)
335 8008 : ABI_UNUSED_A(strain)
336 8008 : ABI_UNUSED_A(spin)
337 8008 : ABI_UNUSED_A(lwf)
338 8008 : ABI_UNUSED_A(force)
339 8008 : ABI_UNUSED_A(stress)
340 8008 : ABI_UNUSED_A(bfield)
341 8008 : ABI_UNUSED_A(lwf_force)
342 8008 : ABI_UNUSED_A(energy)
343 8008 : end subroutine spin_potential_t_calculate
344 :
345 :
346 4006 : subroutine spin_potential_t_total_Heff(self,S, Heff, energy)
347 : class(spin_potential_t), intent(inout) :: self
348 : real(dp), intent(inout):: S(3,self%nspin)
349 : real(dp), intent(inout):: Heff(3,self%nspin)
350 : real(dp), intent(inout) :: energy
351 : real(dp) :: etmp
352 : integer :: i, j
353 : integer :: master, my_rank, comm, nproc, ierr
354 : logical :: iam_master
355 4006 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
356 :
357 3465190 : self%Htmp(:,:)=0.0_dp
358 4006 : etmp=0.0_dp
359 :
360 :
361 : ! calculate energy from bilinear terms (all the above ones)
362 4006 : call self%calc_bilinear_term_Heff(S,self%Htmp)
363 869302 : do i= self%mps%istart, self%mps%iend
364 3461184 : Heff(:,i)=Heff(:,i)+self%Htmp(:,i)
365 3465190 : do j=1, 3
366 3461184 : etmp=etmp-(self%Htmp(j, i)*S(j,i)*self%ms(i))*0.5_dp
367 : end do
368 : enddo
369 : if(iam_master) then
370 : if (self%has_dipdip) then
371 : continue
372 : ! TODO implement dipdip and add it
373 : endif
374 : endif
375 :
376 : ! linear terms
377 4006 : if (self%has_external_hfield) then
378 3465190 : self%Htmp(:,:)= 0.0_dp
379 4006 : call self%calc_external_Heff(self%Htmp)
380 869302 : do i= self%mps%istart, self%mps%iend
381 3461184 : Heff(:,i)=Heff(:,i)+self%Htmp(:,i)
382 3465190 : do j=1, 3
383 3461184 : etmp=etmp-(self%Htmp(j, i)*S(j,i)*self%ms(i))
384 : end do
385 : enddo
386 : endif
387 :
388 4006 : call xmpi_sum_master(etmp, 0, xmpi_world, ierr )
389 : ! NOTE: here energy is not added to input energy.
390 4006 : energy=etmp
391 :
392 4006 : end subroutine spin_potential_t_total_Heff
393 :
394 : ! subroutine spin_potential_t_get_energy(self, S, energy)
395 : ! class(spin_potential_t), intent(inout) :: self
396 : ! real(dp), intent(inout):: S(3,self%nspin)
397 : ! real(dp), intent(inout) :: energy
398 : ! integer :: i, j
399 : ! integer :: master, my_rank, comm, nproc, ierr
400 : ! logical :: iam_master
401 : ! call init_mpi_info(master, iam_master, my_rank, comm, nproc)
402 : !
403 : !
404 : ! if (.not. self%csr_mat_ready) then
405 : ! call spmat_convert(self%coeff_coo, self%bilinear_csr_mat)
406 : ! call self%bilinear_csr_mat%sync()
407 : ! self%csr_mat_ready=.True.
408 : ! endif
409 : ! call self%bilinear_csr_mat%mv_mpi(S ,self%Htmp)
410 : ! if(iam_master) then
411 : ! energy=energy - sum(sum(self%Htmp* S, dim=1))
412 : ! endif
413 : ! if(iam_master) then
414 : ! if (self%has_external_hfield) then
415 : ! call self%calc_external_Heff(self%Htmp)
416 : ! do i=1, self%nspin
417 : ! do j=1, 3
418 : ! energy= energy- self%Htmp(j, i)*S(j, i)*self%ms(i)
419 : ! end do
420 : ! end do
421 : ! endif
422 : ! end if
423 : ! end subroutine spin_potential_t_get_energy
424 :
425 :
426 0 : subroutine spin_potential_t_get_delta_E(self, S, ispin, Snew, deltaE)
427 : class(spin_potential_t), intent(inout) :: self
428 : real(dp), intent(inout):: S(:,:), Snew(:)
429 : integer, intent(in) :: ispin
430 : real(dp), intent(inout) ::deltaE
431 : !real(dp) :: Eold, Enew
432 : real(dp) :: tmp(3), dS(3)
433 :
434 : ! naive implementation, for test only
435 : !real(dp) :: Stmp(3,self%nspin), Enew, Eold
436 : !call self%get_Heff(S, self%Htmp, Eold)
437 : !call self%bilinear_csr_mat%mv(S, self%Htmp)
438 : !Eold=-sum(sum(self%Htmp(:,:)*S(:,:), dim=1))
439 :
440 : !Stmp(:,:)=S(:,:)
441 : !Stmp(:, ispin)= Snew(:)
442 : !call self%get_Heff(Stmp, self%Htmp, Enew)
443 : !deltaE=Enew-Eold
444 : !print *, "naive deltaE", deltaE
445 :
446 : ! more efficient one
447 0 : dS(:)=Snew(:)-S(:, ispin)
448 : !S(:, ispin)= S(:, ispin)+ dS
449 :
450 0 : deltaE=0.0_dp
451 :
452 0 : call self%prepare_csr_matrix()
453 0 : call self%bilinear_csr_mat%mv_select_row(3, [3*ispin-2, 3*ispin-1, 3*ispin], S, tmp)
454 0 : deltaE=deltaE-dot_product(tmp, dS ) *2.0
455 0 : if (self%has_onsite) then
456 0 : tmp=matmul(self%onsite_bilinear_term(:, :, ispin), dS)
457 0 : deltaE = deltaE - dot_product(tmp, dS)
458 : !print *, "dS K dS:", dot_product(tmp, dS)
459 : end if
460 : !print *, "smart deltaE", deltaE
461 : !S(:, ispin)=S(:,ispin)-dS
462 : !print *, "diff for ispin:", ispin, Enew-Eold-deltaE
463 :
464 :
465 0 : if(self%has_external_hfield) then
466 0 : deltaE=deltaE - dot_product(self%external_hfield(:, ispin), dS)*self%ms(ispin)
467 : end if
468 0 : end subroutine spin_potential_t_get_delta_E
469 :
470 :
471 2 : subroutine finalize(self)
472 : class(spin_potential_t), intent(inout):: self
473 2 : if (allocated(self%ms)) then
474 2 : ABI_FREE(self%ms)
475 : end if
476 :
477 2 : ABI_SFREE(self%onsite_bilinear_term)
478 :
479 2 : if (allocated(self%Htmp)) then
480 2 : ABI_FREE(self%Htmp)
481 : endif
482 :
483 2 : if (allocated(self%external_hfield)) then
484 2 : ABI_FREE(self%external_hfield)
485 : endif
486 :
487 2 : call self%bilinear_csr_mat%finalize()
488 2 : if (.not. self%csr_mat_ready) then
489 0 : call self%coeff_coo%finalize()
490 : end if
491 :
492 2 : call self%mps%finalize()
493 :
494 2 : end subroutine finalize
495 :
496 6 : end module m_spin_potential
|
