Line data Source code
1 : !!****m* ABINIT/m_multibinit_cell
2 : !! NAME
3 : !! m_multibinit_cell
4 : !!
5 : !! FUNCTION
6 : !! This module define the m_unitcell type, which defines an atomic structure, with spin, lwf, electron
7 : !!
8 : !! Datatypes:
9 : !!
10 : !!
11 : !! Subroutines:
12 : !!
13 : !! COPYRIGHT !! Copyright (C) 2001-2026 ABINIT group (hexu) !! This file is distributed under the terms of the
14 : !! GNU General Public License, see ~abinit/COPYING
15 : !! or http://www.gnu.org/copyleft/gpl.txt .
16 : !! For the initials of contributors, see ~abinit/doc/developers/contributors.txt .
17 : !!
18 : !! SOURCE
19 :
20 :
21 : #if defined HAVE_CONFIG_H
22 : #include "config.h"
23 : #endif
24 : #include "abi_common.h"
25 :
26 :
27 : module m_multibinit_cell
28 : use defs_basis
29 : use m_abicore
30 : use m_errors
31 : use m_xmpi
32 : use m_mpi_scheduler, only: init_mpi_info
33 : !use m_multibinit_supercell, only: mb_supercell_t
34 : use m_supercell_maker , only: supercell_maker_t
35 : use m_multibinit_dataset, only : multibinit_dtset_type
36 : use m_crystal, only : crystal_t
37 :
38 : use m_spmat_spvec, only: sp_real_vec
39 : use m_lattice_lwf_map, only: lwf_latt_coeff_t
40 : implicit none
41 :
42 : !!***
43 : private
44 : !----------------------------------------------------------------------
45 : !> @brief lattice cell type
46 : !> NOTE: This is used as an example for how to build new potentials.
47 : !> it is used with the lattice_harmonic_potentail.
48 : !> It has contains the zion, masses, xcart, and cell info
49 : ! TODO: use crystal_t or add it as another lattice type.
50 : !----------------------------------------------------------------------
51 : type, public ::mbcell_lattice_t
52 : integer:: natom = 0
53 : integer, allocatable :: zion(:)
54 : real(dp), allocatable :: masses(:), xcart(:,:)
55 : integer, allocatable :: ilatt_prim(:)
56 : integer, allocatable :: rvec(:,:)
57 : real(dp) :: cell(3,3)
58 : contains
59 : procedure :: initialize => latt_initialize
60 : procedure :: finalize => latt_finalize
61 : procedure :: fill_supercell=>latt_fill_supercell
62 : procedure :: from_unitcell => latt_from_unitcell
63 : end type mbcell_lattice_t
64 :
65 : !----------------------------------------------------------------------
66 : !> @brief spin cell type
67 : !----------------------------------------------------------------------
68 : type, public :: mbcell_spin_t
69 : integer :: nspin = 0 ! number of spin
70 : real(dp) :: rprimd(3,3) ! cell parameters
71 : real(dp), allocatable :: ms(:) ! magnetic moments array(nspin)
72 : real(dp), allocatable :: Sref(:,:) ! spin orientation of reference structure, array(3,nspin)
73 : real(dp) :: ref_qpoint(3) ! q point to construct reference spin structure
74 : real(dp) :: ref_rotate_axis(3) ! rotation axis to construct reference spin structure
75 : real(dp), allocatable :: gyro_ratio(:) ! gyromagnetic ratio array(nspin)
76 : real(dp), allocatable :: gilbert_damping(:) ! damping factor defined for each spin
77 : real(dp), allocatable :: spin_positions(:,:) ! positions of spin (cartesian)
78 : integer, allocatable :: ispin_prim(:) ! index of primitive cell
79 : integer, allocatable :: rvec(:,:) ! R cell vectors for each spin (for supercell)
80 : contains
81 : procedure :: initialize => spin_initialize
82 : procedure :: set => spin_set
83 : procedure :: finalize => spin_finalize
84 : procedure :: fill_supercell=>spin_fill_supercell
85 : procedure :: from_unitcell=>spin_from_unitcell
86 : end type mbcell_spin_t
87 :
88 : !----------------------------------------------------------------------
89 : !> @brief lattice wannier function cell type
90 : !----------------------------------------------------------------------
91 : type, public :: mbcell_lwf_t
92 : integer :: nlwf =0 ! number of lattice wannier functions
93 : integer, allocatable :: ilwf_prim(:) ! index of primitive cell
94 : integer, allocatable :: rvec(:,:) ! R cell vectors for each spin (for supercell)
95 : real(dp), allocatable :: lwf_masses(:)
96 : type(lwf_latt_coeff_t) :: lwf_latt_coeffs
97 : contains
98 : Procedure :: initialize => lwf_initialize
99 : procedure :: finalize => lwf_finalize
100 : procedure :: fill_supercell => lwf_fill_supercell
101 : procedure :: from_unitcell => lwf_from_unitcell
102 : end type mbcell_lwf_t
103 :
104 : !----------------------------------------------------------------------
105 : !> @brief cell type
106 : !> NOTE: to add a new kind of cell, add a subtype here and a tag.
107 : !----------------------------------------------------------------------
108 : type ,public :: mbcell_t
109 : logical :: has_lattice=.False.
110 : logical :: has_spin=.False.
111 : logical :: has_lwf=.False.
112 : logical :: has_electron=.False.
113 : type(mbcell_lattice_t) :: lattice
114 : type(mbcell_spin_t) :: spin
115 : type(mbcell_lwf_t) :: lwf
116 : contains
117 : procedure :: initialize
118 : procedure :: finalize
119 : procedure :: set_lattice ! intialize the lattice
120 : procedure :: set_spin ! initilzie the spin
121 : procedure :: set_lwf
122 : procedure :: fill_supercell ! fill supercell.
123 : !procedure :: from_unitcell
124 : end type mbcell_t
125 :
126 : !----------------------------------------------------------------------
127 : !> @brief supercell type, which is unitcell plus some supercell information
128 : !> NOTE: to add a new kind of cell, add a subtype here and a tag.
129 : !----------------------------------------------------------------------
130 : type, public, extends(mbcell_t):: mbsupercell_t
131 : integer :: sc_matrix(3,3) ! supercell matrix
132 : integer :: ncell ! number of cells in supercell !NH: this already exists in supercell_maker!
133 : type(supercell_maker_t), pointer :: supercell_maker ! pointer to a helper class object
134 : class(mbcell_t), pointer :: unitcell ! pointer to the unitcell which the supercell is built from
135 : contains
136 : procedure :: from_unitcell
137 : end type mbsupercell_t
138 :
139 : contains
140 :
141 : !============================ mb_cell_t========================================
142 :
143 : !----------------------------------------------------------------------
144 : !> @brief intialize mb_cell_t
145 : !----------------------------------------------------------------------
146 12 : subroutine initialize(self)
147 : class(mbcell_t), intent(inout) :: self
148 12 : ABI_UNUSED_A(self)
149 12 : end subroutine initialize
150 :
151 : !----------------------------------------------------------------------
152 : !> @brief set the lattice subtype information
153 : !>
154 : !> @param[in] natom: number of atoms
155 : !> @param[in] cell: cell parameter matrix (3,3)
156 : !> @param[in] xcart: cartesion coordinates
157 : !> @param[in] masses: masses
158 : !> @param[in] zion: atomic numbers
159 : !----------------------------------------------------------------------
160 6 : subroutine set_lattice(self, natom, cell, xcart, masses, zion)
161 : class(mbcell_t), intent(inout) :: self
162 : integer, intent(in) :: natom, zion(:)
163 : real(dp), intent(in) :: cell(3,3), xcart(:,:), masses(:)
164 6 : if (.not. self%has_lattice) then
165 6 : self%has_lattice=.True.
166 : call self%lattice%initialize(natom=natom, cell=cell, &
167 6 : &xcart=xcart, masses=masses, zion=zion)
168 : endif
169 6 : end subroutine set_lattice
170 :
171 :
172 : !----------------------------------------------------------------------
173 : !> @brief initialize spin sub type
174 : !>
175 : !> @param[in] nspin: number of spin
176 : !> @param[in] ms: magnetic moments
177 : !> @param[in] rprimd: cell pareters
178 : !> @param[in] spin_positions: the cartesion coordinates of spins
179 : !> @param[in] gyro_ratio: gyromagnetic ratio fro each spin
180 : !> @param[in] gilbert_damping: damping factor for each spin
181 : !> @param[in] rvec: R vectors for cell in supercell
182 : !> @param[in] ispin_prim: id in primitive cell for each spin
183 : !----------------------------------------------------------------------
184 2 : subroutine set_spin(self,nspin, ms, rprimd, spin_positions, gyro_ratio, gilbert_damping, rvec, ispin_prim, &
185 : & Sref, ref_qpoint, ref_rotate_axis)
186 : class(mbcell_t), intent(inout):: self
187 : integer, intent(in) :: nspin
188 : real(dp), intent(in) :: ms(nspin), rprimd(3,3), spin_positions(3, nspin), gyro_ratio(nspin), gilbert_damping(nspin)
189 : real(dp), optional, intent(in) :: Sref(3, nspin), ref_qpoint(3), ref_rotate_axis(3)
190 : integer, optional, intent(in) :: rvec(3, nspin), ispin_prim(nspin)
191 2 : self%has_spin=.True.
192 2 : call self%spin%initialize(nspin)
193 : call self%spin%set(nspin, ms, rprimd, spin_positions, gyro_ratio, gilbert_damping, rvec, ispin_prim, &
194 2 : & Sref, ref_qpoint=ref_qpoint, ref_rotate_axis=ref_rotate_axis)
195 2 : end subroutine set_spin
196 :
197 : !----------------------------------------------------------------------
198 : !> @brief initialize LWF sub type
199 : !----------------------------------------------------------------------
200 1 : subroutine set_lwf(self, nlwf)
201 : class(mbcell_t) , intent(inout):: self
202 : integer, intent(in) :: nlwf
203 1 : self%has_lwf=.True.
204 1 : call self%lwf%initialize(nlwf)
205 1 : end subroutine set_lwf
206 :
207 : !----------------------------------------------------------------------
208 : !> @brief read cell from a file, which is not used in Multibinit
209 : !> since all the primitive potentials are read by the primitive_cell potential reader
210 : !> They have a pointer to the mbcell_t before reading potentials.
211 : !>
212 : !> @param[in] parasm: input parameters
213 : !> @param[in] fnames: the names in files file
214 : !----------------------------------------------------------------------
215 : subroutine read_from_file(self, params, fnames)
216 : class(mbcell_t), intent(inout) :: self
217 : type(multibinit_dtset_type), intent(in) :: params
218 : character(len=fnlen), intent(in) :: fnames(17)
219 :
220 : ABI_UNUSED_A(self)
221 : ABI_UNUSED_A(params)
222 : ABI_UNUSED_A(fnames)
223 : end subroutine read_from_file
224 :
225 :
226 : !----------------------------------------------------------------------
227 : !> @brief finalize
228 : !>
229 : !----------------------------------------------------------------------
230 12 : subroutine finalize(self)
231 : class(mbcell_t), intent(inout) :: self
232 12 : call self%lattice%finalize()
233 12 : call self%spin%finalize()
234 12 : call self%lwf%finalize()
235 12 : end subroutine finalize
236 :
237 : !----------------------------------------------------------------------
238 : !> @brief fill the cell supercell
239 : !>
240 : !> @param[in] sc_maker: the helper to build supercells
241 : !> @param[out]supercell; the supercell to be built
242 : !----------------------------------------------------------------------
243 6 : subroutine fill_supercell(self, sc_maker, supercell)
244 : class(mbcell_t), target, intent(inout) :: self
245 : type(supercell_maker_t), target, intent(inout) :: sc_maker
246 : class(mbsupercell_t), intent(inout) :: supercell
247 6 : call supercell%initialize()
248 6 : supercell%ncell=sc_maker%ncells
249 78 : supercell%sc_matrix=sc_maker%scmat
250 6 : supercell%has_lattice = self%has_lattice
251 6 : supercell%has_spin = self%has_spin
252 6 : supercell%has_lwf =self%has_lwf
253 6 : supercell%supercell_maker => sc_maker
254 6 : supercell%unitcell => self
255 6 : if (self%has_lattice) then
256 6 : call self%lattice%fill_supercell(sc_maker, supercell%lattice)
257 : endif
258 :
259 6 : if (self%has_spin) then
260 2 : call self%spin%fill_supercell(sc_maker, supercell%spin)
261 : endif
262 :
263 6 : if (self%has_lwf) then
264 1 : call self%lwf%fill_supercell(sc_maker, supercell%lwf)
265 : endif
266 :
267 6 : end subroutine fill_supercell
268 :
269 :
270 : !=================== Supercell =====================================
271 : subroutine supercell_initialize(self)
272 : class(mbsupercell_t), intent(inout) :: self
273 : call self%mbcell_t%initialize()
274 : end subroutine supercell_initialize
275 :
276 : !----------------------------------------------------------------------
277 : !> @brief build from unitcell
278 : !> @param[in] sc_maker
279 : !> @param[in] unitcell
280 : !----------------------------------------------------------------------
281 6 : subroutine from_unitcell(self, sc_maker, unitcell)
282 : class(mbsupercell_t), intent(inout) :: self
283 : type(supercell_maker_t), intent(inout) :: sc_maker
284 : class(mbcell_t), intent(inout) :: unitcell
285 6 : call unitcell%fill_supercell(sc_maker, self)
286 6 : end subroutine from_unitcell
287 :
288 : !----------------------------------------------------------------------
289 : !> @brief finalize supercell
290 : !----------------------------------------------------------------------
291 : subroutine supercell_finalize(self)
292 : class(mbsupercell_t), intent(inout) :: self
293 : call self%mbcell_t%finalize()
294 : nullify(self%supercell_maker)
295 : nullify(self%unitcell)
296 : end subroutine supercell_finalize
297 :
298 : !================================Lattice====================================
299 :
300 : !----------------------------------------------------------------------
301 : !> @brief initalize the lattice type
302 : !>
303 : !> @param[in] natom: number of atoms
304 : !> @param[in] cell: cell matrix
305 : !> @param[in] xcart: cartesion
306 : !> @param[in] masses: masses of atoms
307 : !> @param[in] zion: zion of atoms
308 : !----------------------------------------------------------------------
309 12 : subroutine latt_initialize(self, natom, cell, xcart, masses, zion)
310 : class(mbcell_lattice_t), intent(inout) :: self
311 : integer, intent(in) :: natom, zion(:)
312 : real(dp), intent(in) :: cell(3,3), xcart(:,:), masses(:)
313 12 : self%natom=natom
314 36 : ABI_MALLOC(self%zion, (natom))
315 36 : ABI_MALLOC(self%xcart, (3, natom))
316 36 : ABI_MALLOC(self%masses, (natom))
317 :
318 7755 : self%zion(:) = zion(:)
319 156 : self%cell(:,:) =cell(:,:)
320 30984 : self%xcart(:,:) = xcart(:,:)
321 7755 : self%masses(:) = masses(:)
322 12 : end subroutine latt_initialize
323 :
324 :
325 : !----------------------------------------------------------------------
326 : !> @brief finalize lattice
327 : !----------------------------------------------------------------------
328 12 : subroutine latt_finalize(self)
329 : class(mbcell_lattice_t) :: self
330 12 : self%natom=0
331 12 : ABI_SFREE(self%xcart)
332 12 : ABI_SFREE(self%masses)
333 12 : ABI_SFREE(self%zion)
334 12 : end subroutine latt_finalize
335 :
336 :
337 : !-------------------------------------------------------------------!
338 : ! latt_fill_supercell: make a lattice supercell from primitive cell
339 : ! Inputs:
340 : !> sc_maker: supercell maker
341 : ! Output:
342 : !> supercell: supercell
343 : !-------------------------------------------------------------------!
344 6 : subroutine latt_fill_supercell(self, sc_maker, supercell)
345 : class(mbcell_lattice_t), intent(inout):: self
346 : type(supercell_maker_t), intent(inout):: sc_maker
347 : type(mbcell_lattice_t), intent(inout):: supercell
348 :
349 : real(dp) :: sc_cell(3,3)
350 6 : real(dp), allocatable :: sc_xcart(:,:)
351 6 : real(dp), allocatable :: sc_masses(:)
352 6 : integer, allocatable :: sc_zion(:)
353 :
354 6 : sc_cell(:,:) = sc_maker%sc_cell(self%cell)
355 :
356 : ! the trans_xcart and repeat does the allocation
357 6 : call sc_maker%trans_xcart(self%cell, self%xcart, sc_xcart)
358 6 : call sc_maker%repeat(self%masses, sc_masses)
359 6 : call sc_maker%repeat(self%zion, sc_zion)
360 6 : call supercell%initialize(natom=self%natom*sc_maker%ncells, cell=sc_cell, xcart= sc_xcart, masses=sc_masses, zion=sc_zion)
361 :
362 6 : ABI_SFREE(sc_xcart)
363 6 : ABI_SFREE(sc_masses)
364 6 : ABI_SFREE(sc_zion)
365 6 : end subroutine latt_fill_supercell
366 :
367 :
368 : !-------------------------------------------------------------------!
369 : !latt_from_unitcell: build lattice supercell from primitive cell
370 : ! same as above, only the order of argument differs.
371 : !-------------------------------------------------------------------!
372 0 : subroutine latt_from_unitcell(self, sc_maker, unitcell)
373 : class(mbcell_lattice_t), intent(inout):: self
374 : type(supercell_maker_t), intent(inout):: sc_maker
375 : type(mbcell_lattice_t), intent(inout):: unitcell
376 0 : call unitcell%fill_supercell(sc_maker, self)
377 0 : end subroutine latt_from_unitcell
378 :
379 : !========================= SPIN =================================
380 :
381 :
382 : !----------------------------------------------------------------------
383 : !> @brief initialize spin
384 : !> @param[in] nspin: number of spin
385 : !----------------------------------------------------------------------
386 4 : Subroutine spin_initialize(self, nspin)
387 : class(mbcell_spin_t) , intent(inout):: self
388 : integer, intent(in) :: nspin
389 : integer :: master, my_rank, comm, nproc, ierr
390 : logical :: iam_master
391 4 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
392 4 : self%nspin=nspin
393 4 : call xmpi_bcast(self%nspin, master, comm, ierr)
394 12 : ABI_MALLOC(self%spin_positions, (3, self%nspin))
395 12 : ABI_MALLOC(self%ms, (self%nspin))
396 8 : ABI_MALLOC(self%Sref, (3, self%nspin))
397 8 : ABI_MALLOC(self%gyro_ratio, (self%nspin))
398 8 : ABI_MALLOC(self%gilbert_damping, (self%nspin))
399 12 : ABI_MALLOC(self%rvec,(3, self%nspin) )
400 12 : ABI_MALLOC(self%ispin_prim,(self%nspin) )
401 4 : end subroutine spin_initialize
402 :
403 :
404 : !----------------------------------------------------------------------
405 : !> @brief initialize spin sub type
406 : !>
407 : !> @param[in] nspin: number of spin
408 : !> @param[in] ms: magnetic moments
409 : !> @param[in] rprimd: cell pareters
410 : !> @param[in] spin_positions: the cartesion coordinates of spins
411 : !> @param[in] gyro_ratio: gyromagnetic ratio fro each spin
412 : !> @param[in] gilbert_damping: damping factor for each spin
413 : !> @param[in] rvec: R vectors for cell in supercell
414 : !> @param[in] ispin_prim: id in primitive cell for each spin
415 : !----------------------------------------------------------------------
416 16 : subroutine spin_set(self, nspin, ms, rprimd, spin_positions, gyro_ratio, gilbert_damping, &
417 2 : & rvec, ispin_prim, Sref, ref_qpoint, ref_rotate_axis)
418 : class(mbcell_spin_t) , intent(inout):: self
419 : integer, intent(in) :: nspin
420 : real(dp), intent(in) :: ms(nspin), rprimd(3,3), &
421 : &spin_positions(3, nspin), gyro_ratio(nspin), gilbert_damping(nspin)
422 : integer, optional, intent(in) :: rvec(3, nspin), ispin_prim(nspin)
423 : real(dp), optional, intent(in) :: Sref(3, nspin), ref_qpoint(3), ref_rotate_axis(3)
424 :
425 : integer :: i
426 : integer :: master, my_rank, comm, nproc, ierr
427 : logical :: iam_master
428 :
429 2 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
430 2 : if (iam_master) then
431 4 : self%ms(:) = ms(:)
432 26 : self%rprimd(:,:) = rprimd(:,:)
433 10 : self%spin_positions(:,:)=spin_positions(:,:)
434 4 : self%gyro_ratio(:)=gyro_ratio(:)
435 4 : self%gilbert_damping(:)=gilbert_damping(:)
436 2 : if (present(rvec)) then
437 0 : self%rvec(:,:)=rvec(:,:)
438 : else
439 10 : self%rvec(:,:)=0
440 : end if
441 2 : if (present(ispin_prim)) then
442 0 : self%ispin_prim(:)=ispin_prim
443 : else
444 4 : do i =1 , nspin
445 4 : self%ispin_prim(i)=i
446 : end do
447 : end if
448 :
449 2 : if (present(Sref)) then
450 10 : self%Sref(:,:) = Sref
451 : else
452 0 : ABI_WARNING("No reference spin structure specified, using ferromagnetic along z-axis")
453 :
454 0 : self%Sref(1,:) = 0.0_dp
455 0 : self%Sref(2,:) = 0.0_dp
456 0 : self%Sref(3,:) = 1.0_dp
457 : end if
458 :
459 2 : if (present(ref_qpoint)) then
460 8 : self%ref_qpoint(:) = ref_qpoint
461 : else
462 0 : self%ref_qpoint(:)=[0.0_dp, 0.0_dp, 0.0_dp]
463 : end if
464 :
465 2 : if (present(ref_rotate_axis)) then
466 8 : self%ref_rotate_axis(:) = ref_rotate_axis
467 : else
468 0 : self%ref_rotate_axis(:)=[1.0_dp, 0.0_dp, 0.0_dp]
469 : end if
470 :
471 : endif
472 :
473 2 : call xmpi_bcast(self%spin_positions, master, comm, ierr)
474 2 : call xmpi_bcast(self%rprimd, master, comm, ierr)
475 2 : call xmpi_bcast(self%ms, master, comm, ierr)
476 2 : call xmpi_bcast(self%Sref, master, comm, ierr)
477 2 : call xmpi_bcast(self%gyro_ratio, master, comm, ierr)
478 2 : call xmpi_bcast(self%gilbert_damping, master, comm, ierr)
479 2 : call xmpi_bcast(self%rvec, master, comm, ierr)
480 2 : call xmpi_bcast(self%ispin_prim, master, comm, ierr)
481 2 : call xmpi_bcast(self%ref_qpoint, master, comm, ierr)
482 2 : call xmpi_bcast(self%ref_rotate_axis, master, comm, ierr)
483 2 : end Subroutine spin_set
484 :
485 :
486 12 : subroutine spin_finalize(self)
487 : class(mbcell_spin_t) :: self
488 12 : self%nspin=0
489 12 : ABI_SFREE(self%ms)
490 12 : ABI_SFREE(self%Sref)
491 12 : ABI_SFREE(self%spin_positions)
492 12 : ABI_SFREE(self%gyro_ratio)
493 12 : ABI_SFREE(self%gilbert_damping)
494 12 : ABI_SFREE(self%ispin_prim)
495 12 : ABI_SFREE(self%rvec)
496 12 : end subroutine spin_finalize
497 :
498 16 : subroutine spin_fill_supercell(self, sc_maker, supercell)
499 : class(mbcell_spin_t),intent(inout) :: self
500 : type(supercell_maker_t), intent(inout):: sc_maker
501 : type(mbcell_spin_t), intent(inout) :: supercell
502 : integer :: i, nspin
503 : integer :: master, my_rank, comm, nproc, ierr
504 : logical :: iam_master
505 2 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
506 :
507 2 : nspin=sc_maker%ncells*self%nspin
508 2 : call supercell%initialize(nspin=nspin)
509 :
510 2 : if(iam_master) then
511 2 : call sc_maker%repeat(self%ms, supercell%ms)
512 2 : call sc_maker%repeat(self%gyro_ratio, supercell%gyro_ratio)
513 2 : call sc_maker%repeat(self%gilbert_damping, supercell%gilbert_damping)
514 8 : call sc_maker%repeat([(i ,i=1, self%nspin)], supercell%ispin_prim)
515 26 : supercell%rprimd(:,:)=sc_maker%sc_cell(self%rprimd)
516 :
517 2 : call sc_maker%trans_xcart(self%rprimd, self%spin_positions, supercell%spin_positions)
518 2 : call sc_maker%rvec_for_each(self%nspin, supercell%rvec)
519 : call sc_maker%generate_spin_wave_vectorlist( A=self%Sref, kpoint=self%ref_qpoint, &
520 2 : & axis=self%ref_rotate_axis, A_sc=supercell%Sref)
521 8 : supercell%ref_qpoint(:)=[0.0_dp, 0.0_dp, 0.0_dp] ! Qpoint is gamma in supercell
522 8 : supercell%ref_rotate_axis= self%ref_rotate_axis
523 : end if
524 2 : call xmpi_bcast(supercell%nspin, master, comm, ierr)
525 2 : call xmpi_bcast(supercell%ms, master, comm, ierr)
526 2 : call xmpi_bcast(supercell%gyro_ratio, master, comm, ierr)
527 2 : call xmpi_bcast(supercell%gilbert_damping, master, comm, ierr)
528 2 : call xmpi_bcast(supercell%ispin_prim, master, comm, ierr)
529 2 : call xmpi_bcast(supercell%spin_positions, master, comm, ierr)
530 2 : call xmpi_bcast(supercell%rvec, master, comm, ierr)
531 2 : call xmpi_bcast(supercell%rprimd, master, comm, ierr)
532 2 : end subroutine spin_fill_supercell
533 :
534 : !----------------------------------------------------------------------
535 : !> @brief read from netcdf
536 : !>
537 : !> @build from a unitcell
538 : !----------------------------------------------------------------------
539 0 : subroutine spin_from_unitcell(self, sc_maker, unitcell)
540 : class(mbcell_spin_t),intent(inout) :: self
541 : type(supercell_maker_t), intent(inout):: sc_maker
542 : type(mbcell_spin_t), intent(inout) :: unitcell
543 0 : call unitcell%fill_supercell(sc_maker, self)
544 0 : end subroutine spin_from_unitcell
545 :
546 :
547 : !========================= LWF =================================
548 1 : Subroutine lwf_initialize(self, nlwf)
549 : class(mbcell_lwf_t), intent(inout) :: self
550 : integer, intent(in) :: nlwf
551 1 : self%nlwf=nlwf
552 3 : ABI_MALLOC(self%ilwf_prim, (nlwf))
553 3 : ABI_MALLOC(self%rvec, (3, nlwf))
554 3 : ABI_MALLOC(self%lwf_masses, (nlwf))
555 : !ABI_MALLOC(self%lwf_latt_coeffs, (self%nlwf))
556 : !call self%lwf_latt_coeffs%initialize(self%nlwf, wlf)
557 : ! lwf_latt_coeffs is only initialized in primitive potential
558 1 : end subroutine lwf_initialize
559 :
560 12 : subroutine lwf_finalize(self)
561 : class(mbcell_lwf_t), intent(inout) :: self
562 12 : self%nlwf=0
563 12 : ABI_SFREE(self%ilwf_prim)
564 12 : ABI_SFREE(self%rvec)
565 12 : ABI_SFREE(self%lwf_masses)
566 12 : call self%lwf_latt_coeffs%finalize()
567 12 : end subroutine lwf_finalize
568 :
569 1 : subroutine lwf_fill_supercell(self, sc_maker,supercell)
570 : class(mbcell_lwf_t) :: self
571 : type(supercell_maker_t):: sc_maker
572 : type(mbcell_lwf_t) :: supercell
573 1 : call supercell%from_unitcell(sc_maker, self)
574 0 : end subroutine lwf_fill_supercell
575 :
576 1 : subroutine lwf_from_unitcell(self, sc_maker, unitcell)
577 : class(mbcell_lwf_t) :: self
578 : type(supercell_maker_t):: sc_maker
579 : type(mbcell_lwf_t) :: unitcell
580 : integer :: i
581 1 : self%nlwf=sc_maker%ncells*unitcell%nlwf
582 6 : call sc_maker%repeat([(i ,i=1, unitcell%nlwf)], self%ilwf_prim)
583 1 : call sc_maker%rvec_for_each(unitcell%nlwf, self%rvec)
584 1 : call sc_maker%repeat_real1d(unitcell%lwf_masses, self%lwf_masses)
585 1 : end subroutine lwf_from_unitcell
586 :
587 0 : end module m_multibinit_cell
|
