Line data Source code
1 : !!****m* ABINIT/m_primitive_potential_list
2 : !! NAME
3 : !! m_primitive_potential_list
4 : !!
5 : !! FUNCTION
6 : !! This module define the primitive potential list type, which is a list of primitive potentials
7 : !!
8 : !! Datatypes:
9 : !! primitive_potential_list_t
10 : !!
11 : !! Subroutines:
12 : !!
13 : !! * fill_supercell: use translation symmetry to fill the supercell.
14 : !! * load_from_file: load potential from file.
15 : !! * save_to_file: save to file.
16 : !!
17 : !! COPYRIGHT
18 : !! Copyright (C) 2001-2026 ABINIT group (hexu)
19 : !! This file is distributed under the terms of the
20 : !! GNU General Public License, see ~abinit/COPYING
21 : !! or http://www.gnu.org/copyleft/gpl.txt .
22 : !! For the initials of contributors, see ~abinit/doc/developers/contributors.txt .
23 : !!
24 : !! SOURCE
25 :
26 :
27 : #if defined HAVE_CONFIG_H
28 : #include "config.h"
29 : #endif
30 : #include "abi_common.h"
31 :
32 : module m_primitive_potential_list
33 : use defs_basis
34 : use m_abicore
35 : use m_errors
36 : use m_xmpi
37 :
38 : use m_mpi_scheduler, only: init_mpi_info
39 : use m_multibinit_dataset , only: multibinit_dtset_type
40 : !use m_multibinit_cell, only: mbcell_t
41 : use m_supercell_maker, only: supercell_maker_t
42 : use m_abstract_potential, only: abstract_potential_t
43 : use m_potential_list, only: potential_list_t
44 : use m_primitive_potential, only: primitive_potential_t
45 : use m_multibinit_cell, only: mbsupercell_t
46 : implicit none
47 : private
48 : !!***
49 :
50 : !-------------------------------------------------------------------!
51 : ! primitve_potential_pointer_t
52 : !-------------------------------------------------------------------!
53 : type, public:: primitive_potential_pointer_t ! pointer to effpot
54 : class(primitive_potential_t), pointer :: obj=>null()
55 : end type primitive_potential_pointer_t
56 :
57 :
58 : !-------------------------------------------------------------------!
59 : ! primitive_potential_list_t
60 : ! abstract type for primitive potential list
61 : !-------------------------------------------------------------------!
62 : type, public, extends(primitive_potential_t):: primitive_potential_list_t
63 : type(primitive_potential_pointer_t), allocatable :: data(:) ! list of pointer type
64 : integer :: size=0 ! number of components.
65 : integer :: capacity=0 ! number of slots allocated for saving the pointers.
66 : contains
67 : procedure :: initialize
68 : procedure :: append
69 : procedure :: load_from_files
70 : procedure :: fill_supercell
71 : procedure :: fill_supercell_list
72 : procedure:: finalize
73 : end type primitive_potential_list_t
74 : contains
75 :
76 : !-------------------------------------------------------------------!
77 : ! fill supercell:
78 : !-------------------------------------------------------------------!
79 0 : subroutine fill_supercell(self, scmaker, params, scpot, supercell)
80 : class(primitive_potential_list_t), intent(inout) :: self
81 : type(supercell_maker_t), intent(inout) :: scmaker
82 : type(multibinit_dtset_type), intent(inout) :: params
83 : class(abstract_potential_t), pointer, intent(inout) :: scpot
84 : type(mbsupercell_t), target :: supercell
85 : ! Note that sc_pot is a pointer
86 : ! use a pointer to the specific potential which will be filled
87 : ! e.g. type(spin_potential_t), pointer :: tmp
88 : type(abstract_potential_t), pointer :: tmp
89 0 : ABI_MALLOC_TYPE_SCALAR(abstract_potential_t, tmp)
90 : !call tmp%initialize(....)
91 : ! set tmp
92 0 : ABI_UNUSED_A(self)
93 0 : ABI_UNUSED_A(scmaker)
94 0 : ABI_UNUSED_A(params)
95 0 : ABI_UNUSED_A(scpot)
96 0 : ABI_UNUSED_A(supercell)
97 0 : nullify(tmp)
98 0 : end subroutine fill_supercell
99 :
100 : !-------------------------------------------------------------------!
101 : ! load primitive potential from file
102 : !-------------------------------------------------------------------!
103 0 : subroutine load_from_files(self, params, fnames)
104 : class(primitive_potential_list_t), intent(inout) :: self
105 : type(multibinit_dtset_type), intent(in) :: params
106 : character(len=fnlen), intent(in) :: fnames(:)
107 0 : ABI_UNUSED_A(self)
108 0 : ABI_UNUSED_A(params)
109 0 : ABI_UNUSED_A(fnames)
110 :
111 :
112 0 : end subroutine load_from_files
113 :
114 : !-------------------------------------------------------------------!
115 : ! save primitive potential to file
116 : !-------------------------------------------------------------------!
117 : subroutine save_to_file(self, fname)
118 : class(primitive_potential_list_t), intent(inout) :: self
119 : character(len=fnlen), intent(in) :: fname
120 : ABI_UNUSED_A(self)
121 : ABI_UNUSED_A(fname)
122 :
123 : end subroutine save_to_file
124 :
125 :
126 : !-------------------------------------------------------------------!
127 : ! Initialize
128 : !-------------------------------------------------------------------!
129 6 : subroutine initialize(self)
130 : class(primitive_potential_list_t), intent(inout):: self
131 6 : self%label="ListPotential"
132 6 : self%size=0
133 6 : self%capacity=0
134 6 : end subroutine initialize
135 :
136 : !----------------------------------------------------------------------
137 : !> @brief finalize, all the pots in the list will also be finalized.
138 : !> and the pointers will be nullified.
139 : !----------------------------------------------------------------------
140 12 : subroutine finalize(self)
141 : class(primitive_potential_list_t), intent(inout):: self
142 : integer :: i
143 :
144 : integer :: master, my_rank, comm, nproc, ierr
145 : logical :: iam_master
146 6 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
147 :
148 6 : call xmpi_bcast(self%size, master, comm, ierr)
149 16 : do i=1, self%size
150 10 : call self%data(i)%obj%finalize()
151 10 : if(associated(self%data(i)%obj)) then
152 20 : ABI_FREE(self%data(i)%obj)
153 : endif
154 16 : nullify(self%data(i)%obj)
155 : end do
156 6 : if(allocated(self%data)) then
157 6 : ABI_FREE(self%data)
158 : end if
159 6 : nullify(self%primcell)
160 6 : self%size=0
161 6 : self%capacity=0
162 6 : self%has_displacement=.False.
163 6 : self%has_strain=.False.
164 6 : self%has_spin=.False.
165 6 : self%has_lwf=.False.
166 6 : end subroutine finalize
167 :
168 : !----------------------------------------------------------------------
169 : !> @brief append a potential to the list
170 : !> The meta data will be updated accordingly.
171 : !> @param[in] input
172 : !> @param[out] output
173 : !----------------------------------------------------------------------
174 10 : subroutine append(self, pot)
175 : class(primitive_potential_list_t), intent(inout):: self
176 : class(primitive_potential_t), target, intent(inout) :: pot
177 10 : type(primitive_potential_pointer_t), allocatable :: temp(:)
178 : integer :: master, my_rank, comm, nproc, ierr
179 : logical :: iam_master
180 10 : call init_mpi_info(master, iam_master, my_rank, comm, nproc)
181 :
182 10 : self%size=self%size + 1
183 10 : if(self%size==1) then
184 6 : self%capacity=8
185 54 : ABI_MALLOC(self%data, (self%capacity))
186 4 : else if ( self%size>self%capacity ) then
187 0 : self%capacity = self%size + self%size / 4 + 8
188 0 : ABI_MALLOC(temp, (self%capacity))
189 0 : temp(1:self%size-1) = self%data(:)
190 0 : ABI_MOVE_ALLOC(temp, self%data) !temp gets deallocated
191 : end if
192 :
193 10 : call xmpi_barrier(comm)
194 10 : self%data(self%size)%obj=>pot
195 10 : self%has_spin= (self%has_spin .or. pot%has_spin)
196 10 : self%has_displacement= (self%has_displacement .or. pot%has_displacement)
197 10 : self%has_strain= (self%has_strain.or. pot%has_strain)
198 10 : self%has_lwf= (self%has_lwf.or. pot%has_lwf)
199 10 : call xmpi_bcast(self%size, master, comm, ierr)
200 10 : call xmpi_bcast(self%capacity, master, comm, ierr)
201 10 : call xmpi_bcast(self%has_spin, master, comm, ierr)
202 10 : call xmpi_bcast(self%has_displacement, master, comm, ierr)
203 10 : call xmpi_bcast(self%has_strain, master, comm, ierr)
204 10 : call xmpi_bcast(self%has_lwf, master, comm, ierr)
205 :
206 10 : end subroutine append
207 :
208 :
209 : !----------------------------------------------------------------------
210 : !> @brief build supercell potential for every component in the list
211 : !> Here sc_pot is an pointer.
212 : !> @param[in] sc_maker: the helper class for uilder supercell
213 : !> @param[out] sc_pots: the potential list of supercell pots.
214 : !----------------------------------------------------------------------
215 : subroutine fill_supercell_ptr(self, sc_maker, params, sc_pot, supercell)
216 : class(primitive_potential_list_t), intent(inout) :: self
217 : type(supercell_maker_t), intent(inout) :: sc_maker
218 : type(multibinit_dtset_type), intent(inout) :: params
219 : class(abstract_potential_t), pointer, intent(inout) :: sc_pot
220 : type(mbsupercell_t), target :: supercell
221 :
222 : ! Note that sc_pot is a pointer
223 : ! use a pointer to the specific potential which will be filled
224 : type(potential_list_t), pointer :: tmp
225 : ABI_MALLOC_SCALAR(tmp)
226 : call self%fill_supercell_list( sc_maker, params, tmp, supercell)
227 : sc_pot=>tmp
228 : nullify(tmp)
229 : end subroutine fill_supercell_ptr
230 :
231 : !----------------------------------------------------------------------
232 : !> @brief build supercell potential for every component in the list
233 : !>
234 : !> @param[in] sc_maker: the helper class for uilder supercell
235 : !> @param[out] sc_pots: the potential list of supercell pots.
236 : !----------------------------------------------------------------------
237 6 : subroutine fill_supercell_list(self, sc_maker, params, sc_pots, supercell)
238 : class(primitive_potential_list_t), intent(inout) :: self
239 : type(supercell_maker_t), intent(inout) :: sc_maker
240 : type(multibinit_dtset_type), intent(inout) :: params
241 : type(potential_list_t), intent(inout) :: sc_pots
242 : type(mbsupercell_t), target :: supercell
243 :
244 : ! Note that sc_pot is a pointer
245 : ! use a pointer to the specific potential which will be filled
246 : class(abstract_potential_t), pointer :: tmp
247 : integer :: i
248 6 : tmp=>null()
249 16 : do i =1, self%size
250 10 : call self%data(i)%obj%fill_supercell(sc_maker, params, tmp, supercell)
251 16 : call sc_pots%append(tmp)
252 : end do
253 :
254 6 : ABI_UNUSED_A(params)
255 :
256 6 : end subroutine fill_supercell_list
257 :
258 0 : end module m_primitive_potential_list
259 :
|
