ViewVC Help

View File | Revision Log | Show Annotations | View Changeset | Root Listing

root/group/trunk/OOPSE/libmdtools/calc_eam.F90

Comparing trunk/OOPSE/libmdtools/calc_eam.F90 (file contents):
Revision 492 by chuckv, Mon Apr 14 18:19:15 2003 UTC vs.
Revision 669 by chuckv, Thu Aug 7 00:47:33 2003 UTC

#	Line 1 | Line 1
1	<	module calc_eam
2	<	use definitions, ONLY : DP
1	>	module eam
2	>	use definitions, ONLY : DP,default_error
3	>	use simulation
4		use force_globals
5	<	#ifdef MPI
5	>	use status
6	>	use atype_module
7	>	use Vector_class
8	>	#ifdef IS_MPI
9		use mpiSimulation
10		#endif
11	+	implicit none
12	+	PRIVATE
13
14
15	+	logical, save :: EAM_FF_initialized = .false.
16	+	integer, save :: EAM_Mixing_Policy
17	+	real(kind = dp), save :: EAM_rcut
18	+	logical, save :: haveRcut = .false.
19
20	+	character(len = statusMsgSize) :: errMesg
21	+	integer :: eam_err
22
23	<	!! standard eam stuff
24	<	integer                                        :: n_eam_atypes
25	<	integer,           allocatable, dimension(:)   :: eam_atype
26	<	real( kind = DP ), allocatable, dimension(:)   :: eam_dr
27	<	integer, allocatable, dimension(:)   :: eam_nr
16	<	integer, allocatable, dimension(:)   :: eam_nrho
17	<	real( kind = DP ), allocatable, dimension(:)   :: eam_lattice
18	<	real( kind = DP ), allocatable, dimension(:)   :: eam_drho
19	<	integer          , allocatable, dimension(:)   :: eam_atype_map
20	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_rvals
21	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_rhovals
22	<	real( kind = DP ), allocatable, dimension(:)   :: eam_rcut
23	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_F_rho
24	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_Z_r
25	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_rho_r
26	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_phi_r
27	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_F_rho_pp
28	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_Z_r_pp
29	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_rho_r_pp
30	<	real( kind = DP ), allocatable, dimension(:,:) :: eam_phi_r_pp
23	>	character(len = 200) :: errMsg
24	>	character(len=*), parameter :: RoutineName =  "EAM MODULE"
25	>	!! Logical that determines if eam arrays should be zeroed
26	>	logical :: cleanme = .true.
27	>	logical :: nmflag  = .false.
28
29	+
30	+	type, private :: EAMtype
31	+	integer           :: eam_atype
32	+	real( kind = DP ) :: eam_dr
33	+	integer           :: eam_nr
34	+	integer           :: eam_nrho
35	+	real( kind = DP ) :: eam_lattice
36	+	real( kind = DP ) :: eam_drho
37	+	real( kind = DP ) :: eam_rcut
38	+	integer           :: eam_atype_map
39	+
40	+	real( kind = DP ), pointer, dimension(:) :: eam_rvals        => null()
41	+	real( kind = DP ), pointer, dimension(:) :: eam_rhovals      => null()
42	+	real( kind = DP ), pointer, dimension(:) :: eam_F_rho        => null()
43	+	real( kind = DP ), pointer, dimension(:) :: eam_Z_r          => null()
44	+	real( kind = DP ), pointer, dimension(:) :: eam_rho_r        => null()
45	+	real( kind = DP ), pointer, dimension(:) :: eam_phi_r        => null()
46	+	real( kind = DP ), pointer, dimension(:) :: eam_F_rho_pp     => null()
47	+	real( kind = DP ), pointer, dimension(:) :: eam_Z_r_pp       => null()
48	+	real( kind = DP ), pointer, dimension(:) :: eam_rho_r_pp     => null()
49	+	real( kind = DP ), pointer, dimension(:) :: eam_phi_r_pp     => null()
50	+	end type EAMtype
51
33	–	real( kind = DP ), private :: time0,time1,time2,time3
52
53	<	integer, private :: eam_err
53	>	!! Arrays for derivatives used in force calculation
54	>	real( kind = dp),save, dimension(:), allocatable :: frho
55	>	real( kind = dp),save, dimension(:), allocatable :: rho
56
57	<	private :: mass_weight
58	<	private :: allocate_eam_atype,allocate_eam_module,deallocate_eam_module
39	<	private :: read_eam_pot, get_eam_sizes
57	>	real( kind = dp),save, dimension(:), allocatable :: dfrhodrho
58	>	real( kind = dp),save, dimension(:), allocatable :: d2frhodrhodrho
59
60
61	<	contains
62	<	subroutine initialize_eam()
61	>	!! Arrays for MPI storage
62	>	#ifdef IS_MPI
63	>	real( kind = dp),save, dimension(:), allocatable :: dfrhodrho_col
64	>	real( kind = dp),save, dimension(:), allocatable :: dfrhodrho_row
65	>	real( kind = dp),save, dimension(:), allocatable :: frho_row
66	>	real( kind = dp),save, dimension(:), allocatable :: frho_col
67	>	real( kind = dp),save, dimension(:), allocatable :: rho_row
68	>	real( kind = dp),save, dimension(:), allocatable :: rho_col
69	>	real( kind = dp),save, dimension(:), allocatable :: d2frhodrhodrho_col
70	>	real( kind = dp),save, dimension(:), allocatable :: d2frhodrhodrho_row
71	>	#endif
72
73	+	type, private :: EAMTypeList
74	+	integer           :: n_eam_types = 0
75	+	integer           :: currentAddition = 0
76	+
77	+	type (EAMtype), pointer  :: EAMParams(:) => null()
78	+	end type EAMTypeList
79
80
81	<	character(len=80) :: eam_pot_file
48	<	integer :: i, j,  max_size, prev_max_size
49	<	integer :: number_rho, number_r
50	<	integer :: eam_unit
51	<	integer :: this_error
52	<	character(len=300) :: msg
53	<	integer, external :: nfiles
54	<	!for mpi
81	>	type (eamTypeList) :: EAMList
82
83	+	!! standard eam stuff
84
57	–	#ifdef MPI
58	–	if (node == 0)  &
59	–	n_eam_atypes = nfiles(trim(eam_pot_dir)//char(0))
85
86	<	call mpi_bcast(n_eam_atypes,1,mpi_integer,0,mpi_comm_world,mpi_err)
87	<	if (n_eam_atypes == -1) then
88	<	call error("INITIALIZE_EAM","NO EAM potentials found!")
89	<	endif
90	<	write(msg,'(a5,i4,a12,i5,a14)') 'Node: ',node,' reading ...', &
91	<	n_eam_atypes, ' eam atom types'
92	<	call info('INITIALIZE_EAM', trim(msg))
68	<	#else
69	<	n_eam_atypes = nfiles(trim(eam_pot_dir)//char(0))
70	<	if (n_eam_atypes == -1) then
71	<	call error("INITIALIZE_EAM","NO EAM potentials found!")
72	<	endif
86	>	public :: init_EAM_FF
87	>	public :: setCutoffEAM
88	>	public :: do_eam_pair
89	>	public :: newEAMtype
90	>	public :: calc_eam_prepair_rho
91	>	public :: calc_eam_preforce_Frho
92	>
93
94	<	write(msg,'(a12,i5,a14)') ' Reading ...', &
75	<	n_eam_atypes, ' eam atom types'
76	<	call info('INITIALIZE_EAM', trim(msg))
77	<	#endif
94	>	contains
95
96
97	<	call allocate_eam_atype(n_eam_atypes)
97	>	subroutine newEAMtype(lattice_constant,eam_nrho,eam_drho,eam_nr,&
98	>	eam_dr,rcut,eam_Z_r,eam_rho_r,eam_F_rho,&
99	>	eam_ident,status)
100	>	real (kind = dp )                      :: lattice_constant
101	>	integer                                :: eam_nrho
102	>	real (kind = dp )                      :: eam_drho
103	>	integer                                :: eam_nr
104	>	real (kind = dp )                      :: eam_dr
105	>	real (kind = dp )                      :: rcut
106	>	real (kind = dp ), dimension(eam_nr)   :: eam_Z_r
107	>	real (kind = dp ), dimension(eam_nr)   :: eam_rho_r
108	>	real (kind = dp ), dimension(eam_nrho) :: eam_F_rho
109	>	integer                                :: eam_ident
110	>	integer                                :: status
111
112	+	integer                                :: nAtypes
113	+	integer                                :: maxVals
114	+	integer                                :: alloc_stat
115	+	integer                                :: current
116	+	integer,pointer                        :: Matchlist(:) => null()
117
118	+	status = 0
119
120	<	!! get largest number of data points for any potential
121	<	#ifdef MPI
122	<	if (node == 0) then
123	<	#endif
124	<	prev_max_size = 0
125	<	do i = 1, n_eam_atypes
126	<	call getfilename(i, eam_pot_file)
127	<	max_size = max(get_eam_sizes( &
128	<	trim(eam_pot_dir) // '/' // eam_pot_file), &
129	<	prev_max_size)
94	<	prev_max_size = max_size
95	<	end do
96	<	#ifdef MPI
120	>
121	>	!! Assume that atypes has already been set and get the total number of types in atypes
122	>	!! Also assume that every member of atypes is a EAM model.
123	>
124	>
125	>	! check to see if this is the first time into
126	>	if (.not.associated(EAMList%EAMParams)) then
127	>	call getMatchingElementList(atypes, "is_EAM", .true., nAtypes, MatchList)
128	>	EAMList%n_eam_types = nAtypes
129	>	allocate(EAMList%EAMParams(nAtypes))
130		end if
131
132	+	EAMList%currentAddition = EAMList%currentAddition + 1
133	+	current = EAMList%currentAddition
134	+
135
136	<	call mpi_bcast(max_size,1,mpi_integer,0,mpi_comm_world,mpi_err)
137	<	#endif
136	>	call allocate_EAMType(eam_nrho,eam_nr,EAMList%EAMParams(current),stat=alloc_stat)
137	>	if (alloc_stat /= 0) then
138	>	status = -1
139	>	return
140	>	end if
141
142	<	call allocate_eam_module(n_eam_atypes,max_size)
143	<	allocate(eam_atype_map(get_max_atype()))
142	>	! this is a possible bug, we assume a correspondence between the vector atypes and
143	>	! EAMAtypes
144	>
145	>	EAMList%EAMParams(current)%eam_atype    = eam_ident
146	>	EAMList%EAMParams(current)%eam_lattice  = lattice_constant
147	>	EAMList%EAMParams(current)%eam_nrho     = eam_nrho
148	>	EAMList%EAMParams(current)%eam_drho     = eam_drho
149	>	EAMList%EAMParams(current)%eam_nr       = eam_nr
150	>	EAMList%EAMParams(current)%eam_dr       = eam_dr
151	>	EAMList%EAMParams(current)%eam_rcut     = rcut
152	>	EAMList%EAMParams(current)%eam_Z_r      = eam_Z_r
153	>	EAMList%EAMParams(current)%eam_rho_r    = eam_rho_r
154	>	EAMList%EAMParams(current)%eam_F_rho    = eam_F_rho
155
156	<	#ifdef MPI
107	<	if (node == 0) then
108	<	#endif
109	<	do i = 1, n_eam_atypes
110	<	call getfilename(i, eam_pot_file)
111	<	call read_eam_pot(i,trim(eam_pot_dir) // '/' // eam_pot_file, &
112	<	this_error)
156	>	end subroutine newEAMtype
157
114	–	do j = 1, eam_nr(i)
115	–	eam_rvals(j,i) = dble(j-1)*eam_dr(i)
116	–	enddo
158
118	–	do j = 1, eam_nrho(i)
119	–	eam_rhovals(j,i) = dble(j-1)*eam_drho(i)
120	–	enddo
159
160	+	subroutine init_EAM_FF(status)
161	+	integer :: status
162	+	integer :: i,j
163	+	real(kind=dp) :: current_rcut_max
164	+	integer :: alloc_stat
165	+	integer :: number_r, number_rho
166	+
167	+	if (EAMList%currentAddition == 0) then
168	+	call handleError("init_EAM_FF","No members in EAMList")
169	+	status = -1
170	+	return
171	+	end if
172	+
173	+
174	+
175	+	do i = 1, EAMList%currentAddition
176	+
177	+	! Build array of r values
178	+
179	+	do j = 1,EAMList%EAMParams(i)%eam_nr
180	+	EAMList%EAMParams(i)%eam_rvals(j) = &
181	+	real(j-1,kind=dp)* &
182	+	EAMList%EAMParams(i)%eam_dr
183	+	end do
184	+	! Build array of rho values
185	+	do j = 1,EAMList%EAMParams(i)%eam_nrho
186	+	EAMList%EAMParams(i)%eam_rhovals(j) = &
187	+	real(j-1,kind=dp)* &
188	+	EAMList%EAMParams(i)%eam_drho
189	+	end do
190		! convert from eV to kcal / mol:
191	<	do j = 1, eam_nrho(i)
124	<	eam_F_rho(j,i) = eam_F_rho(j,i)*23.06054E0_DP
125	<	enddo
191	>	EAMList%EAMParams(i)%eam_F_rho = EAMList%EAMParams(i)%eam_F_rho * 23.06054E0_DP
192
193		! precompute the pair potential and get it into kcal / mol:
194	<	eam_phi_r(1,i) = 0.0E0_DP
195	<	do j = 2, eam_nr(i)
196	<	eam_phi_r(j,i) = (eam_Z_r(j,i)**2)/eam_rvals(j,i)
197	<	eam_phi_r(j,i) = eam_phi_r(j,i)*331.999296E0_DP
194	>	EAMList%EAMParams(i)%eam_phi_r(1) = 0.0E0_DP
195	>	do j = 2, EAMList%EAMParams(i)%eam_nr
196	>	EAMList%EAMParams(i)%eam_phi_r(j) = (EAMList%EAMParams(i)%eam_Z_r(j)**2)/EAMList%EAMParams(i)%eam_rvals(j)
197	>	EAMList%EAMParams(i)%eam_phi_r(j) =  EAMList%EAMParams(i)%eam_phi_r(j)*331.999296E0_DP
198		enddo
133	–
199		end do
200	<	#ifdef MPI
136	<	call info('INITIALIZE_EAM','NODE 0: Distributing spline arrays')
137	<	endif
200	>
201
202	<	call mpi_bcast(this_error,n_eam_atypes,mpi_integer,0, &
203	<	mpi_comm_world,mpi_err)
204	<	if (this_error /= 0) then
205	<	call error('INITIALIZE_EAM',"Cannot read eam files")
206	<	endif
202	>	do i = 1,  EAMList%currentAddition
203	>	number_r   = EAMList%EAMParams(i)%eam_nr
204	>	number_rho = EAMList%EAMParams(i)%eam_nrho
205	>
206	>	call eam_spline(number_r, EAMList%EAMParams(i)%eam_rvals, &
207	>	EAMList%EAMParams(i)%eam_rho_r, &
208	>	EAMList%EAMParams(i)%eam_rho_r_pp, &
209	>	0.0E0_DP, 0.0E0_DP, 'N')
210	>	call eam_spline(number_r, EAMList%EAMParams(i)%eam_rvals, &
211	>	EAMList%EAMParams(i)%eam_Z_r, &
212	>	EAMList%EAMParams(i)%eam_Z_r_pp, &
213	>	0.0E0_DP, 0.0E0_DP, 'N')
214	>	call eam_spline(number_rho, EAMList%EAMParams(i)%eam_rhovals, &
215	>	EAMList%EAMParams(i)%eam_F_rho, &
216	>	EAMList%EAMParams(i)%eam_F_rho_pp, &
217	>	0.0E0_DP, 0.0E0_DP, 'N')
218	>	call eam_spline(number_r, EAMList%EAMParams(i)%eam_rvals, &
219	>	EAMList%EAMParams(i)%eam_phi_r, &
220	>	EAMList%EAMParams(i)%eam_phi_r_pp, &
221	>	0.0E0_DP, 0.0E0_DP, 'N')
222	>	enddo
223
145	–	call mpi_bcast(eam_atype,n_eam_atypes,mpi_integer,0, &
146	–	mpi_comm_world,mpi_err)
224
225	<	!! distribute values to cluster......
226	<	call mpi_bcast(eam_nr,n_eam_atypes,mpi_integer,&
227	<	0,mpi_comm_world,mpi_err)
228	<	call mpi_bcast(eam_nrho,n_eam_atypes,mpi_integer,&
229	<	0,mpi_comm_world,mpi_err)
153	<	call mpi_bcast(eam_rvals,n_eam_atypes*max_size,mpi_double_precision, &
154	<	0,mpi_comm_world,mpi_err)
155	<	call mpi_bcast(eam_rcut,n_eam_atypes,mpi_double_precision, &
156	<	0,mpi_comm_world,mpi_err)
157	<	call mpi_bcast(eam_rhovals,n_eam_atypes*max_size,mpi_double_precision, &
158	<	0,mpi_comm_world,mpi_err)
225	>	!       current_rcut_max = EAMList%EAMParams(1)%eam_rcut
226	>	!! find the smallest rcut for any eam atype
227	>	!       do i = 2, EAMList%currentAddition
228	>	!          current_rcut_max =max(current_rcut_max,EAMList%EAMParams(i)%eam_rcut)
229	>	!       end do
230
231	<	!! distribute arrays
232	<	call mpi_bcast(eam_rho_r,n_eam_atypes*max_size,mpi_double_precision, &
233	<	0,mpi_comm_world,mpi_err)
234	<	call mpi_bcast(eam_Z_r,n_eam_atypes*max_size,mpi_double_precision, &
235	<	0,mpi_comm_world,mpi_err)
165	<	call mpi_bcast(eam_F_rho,n_eam_atypes*max_size,mpi_double_precision, &
166	<	0,mpi_comm_world,mpi_err)
167	<	call mpi_bcast(eam_phi_r,n_eam_atypes*max_size,mpi_double_precision, &
168	<	0,mpi_comm_world,mpi_err)
231	>	!       EAM_rcut = current_rcut_max
232	>	!       EAM_rcut_orig = current_rcut_max
233	>	!       do i = 1, EAMList%currentAddition
234	>	!          EAMList%EAMParam(i)s%eam_atype_map(eam_atype(i)) = i
235	>	!       end do
236
170	–	#endif
171	–	call info('INITIALIZE_EAM', 'creating splines')
237
238	<	do i = 1, n_eam_atypes
239	<	number_r = eam_nr(i)
240	<	number_rho = eam_nrho(i)
238	>	!! Allocate arrays for force calculation
239	>	call allocateEAM(alloc_stat)
240	>	if (alloc_stat /= 0 ) then
241	>	status = -1
242	>	return
243	>	endif
244
245	<	call eam_spline(i, number_r, eam_rvals, eam_rho_r, eam_rho_r_pp, &
178	<	0.0E0_DP, 0.0E0_DP, 'N')
179	<	call eam_spline(i, number_r, eam_rvals, eam_Z_r, eam_Z_r_pp, &
180	<	0.0E0_DP, 0.0E0_DP, 'N')
181	<	call eam_spline(i, number_rho, eam_rhovals, eam_F_rho, eam_F_rho_pp, &
182	<	0.0E0_DP, 0.0E0_DP, 'N')
183	<	call eam_spline(i, number_r, eam_rvals, eam_phi_r, eam_phi_r_pp, &
184	<	0.0E0_DP, 0.0E0_DP, 'N')
185	<	enddo
245	>	end subroutine init_EAM_FF
246
247	<	do i = 1, n_eam_atypes
248	<	eam_atype_map(eam_atype(i)) = i
249	<	end do
247	>	!! routine checks to see if array is allocated, deallocates array if allocated
248	>	!! and then creates the array to the required size
249	>	subroutine allocateEAM(status)
250	>	integer, intent(out) :: status
251
252	+	integer :: nlocal
253	+	#ifdef IS_MPI
254	+	integer :: nrow
255	+	integer :: ncol
256	+	#endif
257	+	integer :: alloc_stat
258
259
260	<	call info('INITIALIZE_EAM','Done creating splines')
260	>	nlocal = getNlocal()
261
262	<	return
263	<	end subroutine initialize_eam
262	>	#ifdef IS_MPI
263	>	nrow = getNrow(plan_row)
264	>	ncol = getNcol(plan_col)
265	>	#endif
266
267	+	if (allocated(frho)) deallocate(frho)
268	+	allocate(frho(nlocal),stat=alloc_stat)
269	+	if (alloc_stat /= 0) then
270	+	status = -1
271	+	return
272	+	end if
273	+	if (allocated(rho)) deallocate(rho)
274	+	allocate(rho(nlocal),stat=alloc_stat)
275	+	if (alloc_stat /= 0) then
276	+	status = -1
277	+	return
278	+	end if
279
280	<	subroutine allocate_eam_atype(n_size_atype)
281	<	integer, intent(in) :: n_size_atype
280	>	if (allocated(dfrhodrho)) deallocate(dfrhodrho)
281	>	allocate(dfrhodrho(nlocal),stat=alloc_stat)
282	>	if (alloc_stat /= 0) then
283	>	status = -1
284	>	return
285	>	end if
286
287	<	allocate(eam_atype(n_size_atype))
288	<	allocate(eam_drho(n_size_atype))
289	<	allocate(eam_dr(n_size_atype))
290	<	allocate(eam_nr(n_size_atype))
291	<	allocate(eam_nrho(n_size_atype))
292	<	allocate(eam_lattice(n_size_atype))
293	<	allocate(eam_rcut(n_size_atype))
287	>	if (allocated(d2frhodrhodrho)) deallocate(d2frhodrhodrho)
288	>	allocate(d2frhodrhodrho(nlocal),stat=alloc_stat)
289	>	if (alloc_stat /= 0) then
290	>	status = -1
291	>	return
292	>	end if
293	>
294	>	#ifdef IS_MPI
295
296	<	end subroutine allocate_eam_atype
296	>	if (allocated(frho_row)) deallocate(frho_row)
297	>	allocate(frho_row(nrow),stat=alloc_stat)
298	>	if (alloc_stat /= 0) then
299	>	status = -1
300	>	return
301	>	end if
302	>	if (allocated(rho_row)) deallocate(rho_row)
303	>	allocate(rho_row(nrow),stat=alloc_stat)
304	>	if (alloc_stat /= 0) then
305	>	status = -1
306	>	return
307	>	end if
308	>	if (allocated(dfrhodrho_row)) deallocate(dfrhodrho_row)
309	>	allocate(dfrhodrho_row(nrow),stat=alloc_stat)
310	>	if (alloc_stat /= 0) then
311	>	status = -1
312	>	return
313	>	end if
314	>	if (allocated(d2frhodrhodrho_row)) deallocate(d2frhodrhodrho_row)
315	>	allocate(d2frhodrhodrho_row(nrow),stat=alloc_stat)
316	>	if (alloc_stat /= 0) then
317	>	status = -1
318	>	return
319	>	end if
320
212	–	subroutine allocate_eam_module(n_size_atype,n_eam_points)
213	–	integer, intent(in) :: n_eam_points
214	–	integer, intent(in) :: n_size_atype
321
322	<	allocate(eam_rvals(n_eam_points,n_size_atype))
217	<	allocate(eam_rhovals(n_eam_points,n_size_atype))
218	<	allocate(eam_F_rho(n_eam_points,n_size_atype))
219	<	allocate(eam_Z_r(n_eam_points,n_size_atype))
220	<	allocate(eam_rho_r(n_eam_points,n_size_atype))
221	<	allocate(eam_phi_r(n_eam_points,n_size_atype))
222	<	allocate(eam_F_rho_pp(n_eam_points,n_size_atype))
223	<	allocate(eam_Z_r_pp(n_eam_points,n_size_atype))
224	<	allocate(eam_rho_r_pp(n_eam_points,n_size_atype))
225	<	allocate(eam_phi_r_pp(n_eam_points,n_size_atype))
322	>	! Now do column arrays
323
324	<	end subroutine allocate_eam_module
324	>	if (allocated(frho_col)) deallocate(frho_col)
325	>	allocate(frho_col(ncol),stat=alloc_stat)
326	>	if (alloc_stat /= 0) then
327	>	status = -1
328	>	return
329	>	end if
330	>	if (allocated(rho_col)) deallocate(rho_col)
331	>	allocate(rho_col(ncol),stat=alloc_stat)
332	>	if (alloc_stat /= 0) then
333	>	status = -1
334	>	return
335	>	end if
336	>	if (allocated(dfrhodrho_col)) deallocate(dfrhodrho_col)
337	>	allocate(dfrhodrho_col(ncol),stat=alloc_stat)
338	>	if (alloc_stat /= 0) then
339	>	status = -1
340	>	return
341	>	end if
342	>	if (allocated(d2frhodrhodrho_col)) deallocate(d2frhodrhodrho_col)
343	>	allocate(d2frhodrhodrho_col(ncol),stat=alloc_stat)
344	>	if (alloc_stat /= 0) then
345	>	status = -1
346	>	return
347	>	end if
348	>
349	>	#endif
350	>
351	>	end subroutine allocateEAM
352	>
353	>	!! C sets rcut to be the largest cutoff of any atype
354	>	!! present in this simulation. Doesn't include all atypes
355	>	!! sim knows about, just those in the simulation.
356	>	subroutine setCutoffEAM(rcut, status)
357	>	real(kind=dp) :: rcut
358	>	integer :: status
359	>	status = 0
360	>
361	>	EAM_rcut = rcut
362	>
363	>	end subroutine setCutoffEAM
364	>
365	>
366	>
367	>	subroutine clean_EAM()
368	>	! clean non-IS_MPI first
369	>	frho = 0.0_dp
370	>	rho  = 0.0_dp
371	>	dfrhodrho = 0.0_dp
372	>	! clean MPI if needed
373	>	#ifdef IS_MPI
374	>	frho_row = 0.0_dp
375	>	frho_col = 0.0_dp
376	>	rho_row  = 0.0_dp
377	>	rho_col  = 0.0_dp
378	>	dfrhodrho_row = 0.0_dp
379	>	dfrhodrho_col = 0.0_dp
380	>	#endif
381	>	end subroutine clean_EAM
382	>
383	>
384	>
385	>	subroutine allocate_EAMType(eam_n_rho,eam_n_r,thisEAMType,stat)
386	>	integer, intent(in)          :: eam_n_rho
387	>	integer, intent(in)          :: eam_n_r
388	>	type (EAMType)               :: thisEAMType
389	>	integer, optional   :: stat
390	>	integer             :: alloc_stat
391	>
392	>
393	>
394	>	if (present(stat)) stat = 0
395	>
396	>	allocate(thisEAMType%eam_rvals(eam_n_r),stat=alloc_stat)
397	>	if (alloc_stat /= 0 ) then
398	>	if (present(stat)) stat = -1
399	>	return
400	>	end if
401	>	allocate(thisEAMType%eam_rhovals(eam_n_rho),stat=alloc_stat)
402	>	if (alloc_stat /= 0 ) then
403	>	if (present(stat)) stat = -1
404	>	return
405	>	end if
406	>	allocate(thisEAMType%eam_F_rho(eam_n_rho),stat=alloc_stat)
407	>	if (alloc_stat /= 0 ) then
408	>	if (present(stat)) stat = -1
409	>	return
410	>	end if
411	>	allocate(thisEAMType%eam_Z_r(eam_n_r),stat=alloc_stat)
412	>	if (alloc_stat /= 0 ) then
413	>	if (present(stat)) stat = -1
414	>	return
415	>	end if
416	>	allocate(thisEAMType%eam_rho_r(eam_n_r),stat=alloc_stat)
417	>	if (alloc_stat /= 0 ) then
418	>	if (present(stat)) stat = -1
419	>	return
420	>	end if
421	>	allocate(thisEAMType%eam_phi_r(eam_n_r),stat=alloc_stat)
422	>	if (alloc_stat /= 0 ) then
423	>	if (present(stat)) stat = -1
424	>	return
425	>	end if
426	>	allocate(thisEAMType%eam_F_rho_pp(eam_n_rho),stat=alloc_stat)
427	>	if (alloc_stat /= 0 ) then
428	>	if (present(stat)) stat = -1
429	>	return
430	>	end if
431	>	allocate(thisEAMType%eam_Z_r_pp(eam_n_r),stat=alloc_stat)
432	>	if (alloc_stat /= 0 ) then
433	>	if (present(stat)) stat = -1
434	>	return
435	>	end if
436	>	allocate(thisEAMType%eam_rho_r_pp(eam_n_r),stat=alloc_stat)
437	>	if (alloc_stat /= 0 ) then
438	>	if (present(stat)) stat = -1
439	>	return
440	>	end if
441	>	allocate(thisEAMType%eam_phi_r_pp(eam_n_r),stat=alloc_stat)
442	>	if (alloc_stat /= 0 ) then
443	>	if (present(stat)) stat = -1
444	>	return
445	>	end if
446	>
447	>
448	>	end subroutine allocate_EAMType
449	>
450	>
451	>	subroutine deallocate_EAMType(thisEAMType)
452	>	type (EAMtype), pointer :: thisEAMType
453	>
454	>	! free Arrays in reverse order of allocation...
455	>	deallocate(thisEAMType%eam_phi_r_pp)
456	>	deallocate(thisEAMType%eam_rho_r_pp)
457	>	deallocate(thisEAMType%eam_Z_r_pp)
458	>	deallocate(thisEAMType%eam_F_rho_pp)
459	>	deallocate(thisEAMType%eam_phi_r)
460	>	deallocate(thisEAMType%eam_rho_r)
461	>	deallocate(thisEAMType%eam_Z_r)
462	>	deallocate(thisEAMType%eam_F_rho)
463	>	deallocate(thisEAMType%eam_rhovals)
464	>	deallocate(thisEAMType%eam_rvals)
465	>
466	>	end subroutine deallocate_EAMType
467	>
468	>	!! Calculates rho_r
469	>	subroutine calc_eam_prepair_rho(atom1,atom2,d,r,rijsq)
470	>	integer :: atom1,atom2
471	>	real(kind = dp), dimension(3) :: d
472	>	real(kind = dp), intent(inout)               :: r
473	>	real(kind = dp), intent(inout)               :: rijsq
474	>	! value of electron density rho do to atom i at atom j
475	>	real(kind = dp) :: rho_i_at_j
476	>	! value of electron density rho do to atom j at atom i
477	>	real(kind = dp) :: rho_j_at_i
478	>
479	>	! we don't use the derivatives, dummy variables
480	>	real( kind = dp) :: drho,d2rho
481	>	integer :: eam_err
482	>
483	>	integer :: myid_atom1
484	>	integer :: myid_atom2
485	>
486	>	! check to see if we need to be cleaned at the start of a force loop
487	>
488	>	if (cleanme) then
489	>	call clean_EAM
490	>	cleanme = .false.
491	>	end if
492	>
493	>
494	>
495	>
496	>	#ifdef IS_MPI
497	>	myid_atom1 = atid_Row(atom1)
498	>	myid_atom2 = atid_Col(atom2)
499	>	#else
500	>	myid_atom1 = atid(atom1)
501	>	myid_atom2 = atid(atom2)
502	>	#endif
503	>
504	>	if (r.lt.EAMList%EAMParams(myid_atom1)%eam_rcut) then
505	>
506	>
507	>
508	>	call eam_splint(EAMList%EAMParams(myid_atom1)%eam_nr, &
509	>	EAMList%EAMParams(myid_atom1)%eam_rvals, &
510	>	EAMList%EAMParams(myid_atom1)%eam_rho_r, &
511	>	EAMList%EAMParams(myid_atom1)%eam_rho_r_pp, &
512	>	r, rho_i_at_j,drho,d2rho)
513	>
514	>
515	>
516	>	#ifdef  IS_MPI
517	>	rho_col(atom2) = rho_col(atom2) + rho_i_at_j
518	>	#else
519	>	rho(atom2) = rho(atom2) + rho_i_at_j
520	>	#endif
521	>	endif
522	>
523	>	if (r.lt.EAMList%EAMParams(myid_atom2)%eam_rcut) then
524	>	call eam_splint(EAMList%EAMParams(myid_atom2)%eam_nr, &
525	>	EAMList%EAMParams(myid_atom2)%eam_rvals, &
526	>	EAMList%EAMParams(myid_atom2)%eam_rho_r, &
527	>	EAMList%EAMParams(myid_atom2)%eam_rho_r_pp, &
528	>	r, rho_j_at_i,drho,d2rho)
529	>
530	>
531	>
532	>
533	>	#ifdef  IS_MPI
534	>	rho_row(atom1) = rho_row(atom1) + rho_j_at_i
535	>	#else
536	>	rho(atom1) = rho(atom1) + rho_j_at_i
537	>	#endif
538	>	endif
539	>
540	>
541	>
542	>	end subroutine calc_eam_prepair_rho
543	>
544	>
545	>
546	>
547	>	!! Calculate the functional F(rho) for all local atoms
548	>	subroutine calc_eam_preforce_Frho(nlocal,pot)
549	>	integer :: nlocal
550	>	real(kind=dp) :: pot
551	>	integer :: i,j
552	>	integer :: atom
553	>	real(kind=dp) :: U,U1,U2
554	>	integer :: atype1
555	>	integer :: me
556	>	integer :: n_rho_points
557	>	! reset clean forces to be true at top of calc rho.
558	>	cleanme = .true.
559	>
560	>	!! Scatter the electron density from  pre-pair calculation back to local atoms
561	>	#ifdef IS_MPI
562	>	call scatter(rho_row,rho,plan_row,eam_err)
563	>	if (eam_err /= 0 ) then
564	>	write(errMsg,*) " Error scattering rho_row into rho"
565	>	call handleError(RoutineName,errMesg)
566	>	endif
567	>	call scatter(rho_col,rho,plan_col,eam_err)
568	>	if (eam_err /= 0 ) then
569	>	write(errMsg,*) " Error scattering rho_col into rho"
570	>	call handleError(RoutineName,errMesg)
571	>	endif
572	>	#endif
573
229	–	subroutine deallocate_eam_module()
574
575	<	deallocate(eam_atype)
576	<	deallocate(eam_drho)
577	<	deallocate(eam_dr)
578	<	deallocate(eam_nr)
579	<	deallocate(eam_nrho)
580	<	deallocate(eam_lattice)
581	<	deallocate(eam_atype_map)
582	<	deallocate(eam_rvals)
583	<	deallocate(eam_rhovals)
584	<	deallocate(eam_rcut)
585	<	deallocate(eam_Z_r)
586	<	deallocate(eam_rho_r)
587	<	deallocate(eam_phi_r)
588	<	deallocate(eam_F_rho_pp)
589	<	deallocate(eam_Z_r_pp)
590	<	deallocate(eam_rho_r_pp)
591	<	deallocate(eam_phi_r_pp)
575	>	!! Calculate F(rho) and derivative
576	>	do atom = 1, nlocal
577	>	me = atid(atom)
578	>	n_rho_points = EAMList%EAMParams(me)%eam_nrho
579	>	!  Check to see that the density is not greater than the larges rho we have calculated
580	>	if (rho(atom) < EAMList%EAMParams(me)%eam_rhovals(n_rho_points)) then
581	>	call eam_splint(n_rho_points, &
582	>	EAMList%EAMParams(me)%eam_rhovals, &
583	>	EAMList%EAMParams(me)%eam_f_rho, &
584	>	EAMList%EAMParams(me)%eam_f_rho_pp, &
585	>	rho(atom), & ! Actual Rho
586	>	u, u1, u2)
587	>	else
588	>	! Calculate F(rho with the largest available rho value
589	>	call eam_splint(n_rho_points, &
590	>	EAMList%EAMParams(me)%eam_rhovals, &
591	>	EAMList%EAMParams(me)%eam_f_rho, &
592	>	EAMList%EAMParams(me)%eam_f_rho_pp, &
593	>	EAMList%EAMParams(me)%eam_rhovals(n_rho_points), & ! Largest rho
594	>	u,u1,u2)
595	>	end if
596
249	–	end subroutine deallocate_eam_module
597
598	+	frho(i) = u
599	+	dfrhodrho(i) = u1
600	+	d2frhodrhodrho(i) = u2
601	+	pot = pot + u
602	+	enddo
603
604	<	subroutine calc_eam_pair(atom1,atom2,d,rij,r2,pot,f,do_pot,do_stress)
605	<	!Arguments
604	>
605	>
606	>	#ifdef IS_MPI
607	>	!! communicate f(rho) and derivatives back into row and column arrays
608	>	call gather(frho,frho_row,plan_row, eam_err)
609	>	if (eam_err /=  0) then
610	>	call handleError("cal_eam_forces()","MPI gather frho_row failure")
611	>	endif
612	>	call gather(dfrhodrho,dfrhodrho_row,plan_row, eam_err)
613	>	if (eam_err /=  0) then
614	>	call handleError("cal_eam_forces()","MPI gather dfrhodrho_row failure")
615	>	endif
616	>	call gather(frho,frho_col,plan_col, eam_err)
617	>	if (eam_err /=  0) then
618	>	call handleError("cal_eam_forces()","MPI gather frho_col failure")
619	>	endif
620	>	call gather(dfrhodrho,dfrhodrho_col,plan_col, eam_err)
621	>	if (eam_err /=  0) then
622	>	call handleError("cal_eam_forces()","MPI gather dfrhodrho_col failure")
623	>	endif
624	>
625	>
626	>
627	>
628	>
629	>	if (nmflag) then
630	>	call gather(d2frhodrhodrho,d2frhodrhodrho_row,plan_row)
631	>	call gather(d2frhodrhodrho,d2frhodrhodrho_col,plan_col)
632	>	endif
633	>	#endif
634	>
635	>	end subroutine calc_eam_preforce_Frho
636	>
637	>
638	>
639	>
640	>	!! Does EAM pairwise Force calculation.
641	>	subroutine do_eam_pair(atom1,atom2,d,rij,r2,pot,f,do_pot,do_stress)
642	>	!Arguments
643		integer, intent(in) ::  atom1, atom2
644		real( kind = dp ), intent(in) :: rij, r2
645		real( kind = dp ) :: pot
646		real( kind = dp ), dimension(3,getNlocal()) :: f
647		real( kind = dp ), intent(in), dimension(3) :: d
648		logical, intent(in) :: do_pot, do_stress
649	+
650	+	real( kind = dp ) :: drdx,drdy,drdz
651	+	real( kind = dp ) :: d2
652	+	real( kind = dp ) :: phab,pha,dvpdr,d2vpdrdr
653	+	real( kind = dp ) :: rha,drha,d2rha, dpha
654	+	real( kind = dp ) :: rhb,drhb,d2rhb, dphb
655	+	real( kind = dp ) :: dudr
656	+	real( kind = dp ) :: rci,rcj
657	+	real( kind = dp ) :: drhoidr,drhojdr
658	+	real( kind = dp ) :: d2rhoidrdr
659	+	real( kind = dp ) :: d2rhojdrdr
660	+	real( kind = dp ) :: Fx,Fy,Fz
661	+	real( kind = dp ) :: r,d2pha,phb,d2phb
662
663	+	integer :: id1,id2
664	+	integer  :: mytype_atom1
665	+	integer  :: mytype_atom2
666	+
667	+
668		!Local Variables
669
670
671	+
672	+	phab = 0.0E0_DP
673	+	dvpdr = 0.0E0_DP
674	+	d2vpdrdr = 0.0E0_DP
675	+
676		if (rij .lt. EAM_rcut) then
677	+	#ifdef IS_MPI
678	+	!!!!! FIX ME
679	+	mytype_atom1 = atid_row(atom1)
680	+	#else
681	+	mytype_atom1 = atid(atom1)
682	+	#endif
683	+
684	+	drdx = d(1)/rij
685	+	drdy = d(2)/rij
686	+	drdz = d(3)/rij
687	+
688
689	<	r = dsqrt(rijsq)
690	<	efr(1,j) = -rxij
691	<	efr(2,j) = -ryij
692	<	efr(3,j) = -rzij
689	>	call eam_splint(EAMList%EAMParams(mytype_atom1)%eam_nr, &
690	>	EAMList%EAMParams(mytype_atom1)%eam_rvals, &
691	>	EAMList%EAMParams(mytype_atom1)%eam_rho_r, &
692	>	EAMList%EAMParams(mytype_atom1)%eam_rho_r_pp, &
693	>	rij, rha,drha,d2rha)
694
695	+	!! Calculate Phi(r) for atom1.
696	+	call eam_splint(EAMList%EAMParams(mytype_atom1)%eam_nr, &
697	+	EAMList%EAMParams(mytype_atom1)%eam_rvals, &
698	+	EAMList%EAMParams(mytype_atom1)%eam_phi_r, &
699	+	EAMList%EAMParams(mytype_atom1)%eam_phi_r_pp, &
700	+	rij, pha,dpha,d2pha)
701
702	<	call calc_eam_rho(r, rha, drha, d2rha, atype1)
703	<	call calc_eam_phi(r, pha, dpha, d2pha, atype1)
704	<	rci = eam_rcut(eam_atype_map(atype1))
705	<	#ifdef MPI
706	<	atype2 = ident_col(j)
702	>
703	>	! get cutoff for atom 1
704	>	rci = EAMList%EAMParams(mytype_atom1)%eam_rcut
705	>	#ifdef IS_MPI
706	>	mytype_atom2 = atid_col(atom2)
707		#else
708	<	atype2 = ident(j)
708	>	mytype_atom2 = atid(atom2)
709		#endif
710
711	<	call calc_eam_rho(r, rhb, drhb, d2rhb, atype2)
712	<	call calc_eam_phi(r, phb, dphb, d2phb, atype2)
713	<	rcj = eam_rcut(eam_atype_map(atype2))
711	>	! Calculate rho,drho and d2rho for atom1
712	>	call eam_splint(EAMList%EAMParams(mytype_atom2)%eam_nr, &
713	>	EAMList%EAMParams(mytype_atom2)%eam_rvals, &
714	>	EAMList%EAMParams(mytype_atom2)%eam_rho_r, &
715	>	EAMList%EAMParams(mytype_atom2)%eam_rho_r_pp, &
716	>	rij, rhb,drhb,d2rhb)
717
718	<	phab = 0.0E0_DP
719	<	dvpdr = 0.0E0_DP
720	<	d2vpdrdr = 0.0E0_DP
718	>	!! Calculate Phi(r) for atom2.
719	>	call eam_splint(EAMList%EAMParams(mytype_atom2)%eam_nr, &
720	>	EAMList%EAMParams(mytype_atom2)%eam_rvals, &
721	>	EAMList%EAMParams(mytype_atom2)%eam_phi_r, &
722	>	EAMList%EAMParams(mytype_atom2)%eam_phi_r_pp, &
723	>	rij, phb,dphb,d2phb)
724
725	<	if (r.lt.rci) then
725	>
726	>	! get type specific cutoff for atom 2
727	>	rcj = EAMList%EAMParams(mytype_atom1)%eam_rcut
728	>
729	>
730	>
731	>	if (rij.lt.rci) then
732		phab = phab + 0.5E0_DP*(rhb/rha)*pha
733		dvpdr = dvpdr + 0.5E0_DP*((rhb/rha)*dpha + &
734		pha*((drhb/rha) - (rhb*drha/rha/rha)))
#	Line 295 | Line 737 | contains
737		pha*((d2rhb/rha) - 2.0E0_DP*(drhb*drha/rha/rha) + &
738		(2.0E0_DP*rhb*drha*drha/rha/rha/rha) - (rhb*d2rha/rha/rha)))
739		endif
740	+
741
742	<
300	<	if (r.lt.rcj) then
742	>	if (rij.lt.rcj) then
743		phab = phab + 0.5E0_DP*(rha/rhb)*phb
744		dvpdr = dvpdr + 0.5E0_DP*((rha/rhb)*dphb + &
745		phb*((drha/rhb) - (rha*drhb/rhb/rhb)))
#	Line 306 | Line 748 | contains
748		phb*((d2rha/rhb) - 2.0E0_DP*(drha*drhb/rhb/rhb) + &
749		(2.0E0_DP*rha*drhb*drhb/rhb/rhb/rhb) - (rha*d2rhb/rhb/rhb)))
750		endif
751	<
310	<
311	<	#ifdef MPI
312	<
313	<	e_row(i) = e_row(i) + phab*0.5
314	<	e_col(i) = e_col(i) + phab*0.5
315	<	#else
316	<	if (do_pot) pot = pot + phab
317	<	#endif
318	<
751	>
752		drhoidr = drha
753		drhojdr = drhb
754
755		d2rhoidrdr = d2rha
756		d2rhojdrdr = d2rhb
757	<	#ifdef MPI
758	<	dudr = drhojdr*dfrhodrho_row(i)+drhoidr*dfrhodrho_col(j) &
757	>
758	>
759	>	#ifdef IS_MPI
760	>	dudr = drhojdr*dfrhodrho_row(atom1)+drhoidr*dfrhodrho_col(atom2) &
761		+ dvpdr
762
328	–	if (nmflag) then
329	–	d2 = d2vpdrdr + &
330	–	d2rhoidrdr*dfrhodrho_col(j) + &
331	–	d2rhojdrdr*dfrhodrho_row(i) + &
332	–	drhoidr*drhoidr*d2frhodrhodrho_col(j) + &
333	–	drhojdr*drhojdr*d2frhodrhodrho_row(i)
334	–	endif
763		#else
764	<	dudr = drhojdr*dfrhodrho(i)+drhoidr*dfrhodrho(j) &
764	>	dudr = drhojdr*dfrhodrho(atom1)+drhoidr*dfrhodrho(atom2) &
765		+ dvpdr
766	<
339	<	d2 = d2vpdrdr + &
340	<	d2rhoidrdr*dfrhodrho(j) + &
341	<	d2rhojdrdr*dfrhodrho(i) + &
342	<	drhoidr*drhoidr*d2frhodrhodrho(j) + &
343	<	drhojdr*drhojdr*d2frhodrhodrho(i)
766	>	! write(*,*) "Atom1,Atom2, dfrhodrho(atom1) dfrhodrho(atom2): ", atom1,atom2,dfrhodrho(atom1),dfrhodrho(atom2)
767		#endif
768
769	+	fx = dudr * drdx
770	+	fy = dudr * drdy
771	+	fz = dudr * drdz
772
347	–	do dim = 1, 3
773
774	<	drdx1 = efr(dim,j) / r
775	<	ftmp = dudr * drdx1
774	>	#ifdef IS_MPI
775	>	if (do_pot) then
776	>	pot_Row(atom1) = pot_Row(atom1) + phab*0.5
777	>	pot_Col(atom2) = pot_Col(atom2) + phab*0.5
778	>	end if
779
780	<	#ifdef MPI
781	<	f_col(dim,j) = f_col(dim,j) - ftmp
782	<	f_row(dim,i) = f_row(dim,i) + ftmp
780	>	f_Row(1,atom1) = f_Row(1,atom1) + fx
781	>	f_Row(2,atom1) = f_Row(2,atom1) + fy
782	>	f_Row(3,atom1) = f_Row(3,atom1) + fz
783	>
784	>	f_Col(1,atom2) = f_Col(1,atom2) - fx
785	>	f_Col(2,atom2) = f_Col(2,atom2) - fy
786	>	f_Col(3,atom2) = f_Col(3,atom2) - fz
787		#else
356	–	f(dim,j) = f(dim,j) - ftmp
357	–	f(dim,i) = f(dim,i) + ftmp
358	–	#endif
788
789	<	if (nmflag) then
790	<	idim = 3 * (i-1) + dim
791	<	jdim = 3 * (j-1) + dim
789	>	if(do_pot) then
790	>	pot = pot + phab
791	>	end if
792
793	<	do dim2 = 1, 3
793	>	f(1,atom1) = f(1,atom1) + fx
794	>	f(2,atom1) = f(2,atom1) + fy
795	>	f(3,atom1) = f(3,atom1) + fz
796	>
797	>	f(1,atom2) = f(1,atom2) - fx
798	>	f(2,atom2) = f(2,atom2) - fy
799	>	f(3,atom2) = f(3,atom2) - fz
800	>	#endif
801	>
802	>	if (nmflag) then
803
804	<	kt1 = d2 * efr(dim,j) * efr(dim2,j)/r/r
805	<	kt2 = - dudr * efr(dim,j) * efr(dim2,j)/r/r/r
804	>	drhoidr = drha
805	>	drhojdr = drhb
806	>	d2rhoidrdr = d2rha
807	>	d2rhojdrdr = d2rhb
808
809	<	if (dim.eq.dim2) then
810	<	kt3 = dudr / r
811	<	else
812	<	kt3 = 0.0E0_DP
813	<	endif
809	>	#ifdef IS_MPI
810	>	d2 = d2vpdrdr + &
811	>	d2rhoidrdr*dfrhodrho_col(atom2) + &
812	>	d2rhojdrdr*dfrhodrho_row(atom1) + &
813	>	drhoidr*drhoidr*d2frhodrhodrho_col(atom2) + &
814	>	drhojdr*drhojdr*d2frhodrhodrho_row(atom1)
815	>
816	>	#else
817
818	<	! The factor of 2 below is to compensate for
819	<	! overcounting.
820	<	! Mass weighting is done separately...
818	>	d2 = d2vpdrdr + &
819	>	d2rhoidrdr*dfrhodrho(atom2) + &
820	>	d2rhojdrdr*dfrhodrho(atom1) + &
821	>	drhoidr*drhoidr*d2frhodrhodrho(atom2) + &
822	>	drhojdr*drhojdr*d2frhodrhodrho(atom1)
823	>	#endif
824	>	end if
825
379	–	ktmp = (kt1+kt2+kt3)/2.0E0_DP
380	–	idim2 = 3 * (i-1) + dim2
381	–	jdim2 = 3 * (j-1) + dim2
826
827	<	d(idim,  idim2) = d(idim,idim2)  + ktmp
828	<	d(idim2, idim) = d(idim2,idim)   + ktmp
827	>
828	>
829	>	if (do_stress) then
830	>
831	>	#ifdef IS_MPI
832	>	id1 = tagRow(atom1)
833	>	id2 = tagColumn(atom2)
834	>	#else
835	>	id1 = atom1
836	>	id2 = atom2
837	>	#endif
838	>
839	>	if (molMembershipList(id1) .ne. molMembershipList(id2)) then
840	>
841
386	–	d(idim,  jdim2) = d(idim,jdim2)  - ktmp
387	–	d(idim2, jdim) = d(idim2,jdim)   - ktmp
842
389	–	d(jdim,  idim2) = d(jdim,idim2)  - ktmp
390	–	d(jdim2, idim) = d(jdim2,idim)   - ktmp
843
844	<	d(jdim,  jdim2) = d(jdim,jdim2)  + ktmp
845	<	d(jdim2, jdim) = d(jdim2,jdim)   + ktmp
846	<
847	<	enddo
848	<	endif
849	<	enddo
850	<
851	<	endif
852	<	enddo
401	<	endif
402	<
403	<	enddo
844	>	tau_Temp(1) = tau_Temp(1) - d(1) * fx
845	>	tau_Temp(2) = tau_Temp(2) - d(1) * fy
846	>	tau_Temp(3) = tau_Temp(3) - d(1) * fz
847	>	tau_Temp(4) = tau_Temp(4) - d(2) * fx
848	>	tau_Temp(5) = tau_Temp(5) - d(2) * fy
849	>	tau_Temp(6) = tau_Temp(6) - d(2) * fz
850	>	tau_Temp(7) = tau_Temp(7) - d(3) * fx
851	>	tau_Temp(8) = tau_Temp(8) - d(3) * fy
852	>	tau_Temp(9) = tau_Temp(9) - d(3) * fz
853
854	+	virial_Temp = virial_Temp + &
855	+	(tau_Temp(1) + tau_Temp(5) + tau_Temp(9))
856
857	+	endif
858	+	endif
859	+	endif
860
861	+
862	+	end subroutine do_eam_pair
863
408	–	end subroutine calc_eam_pair
864
865	<	subroutine calc_eam_rho(r, rho, drho, d2rho, atype)
865	>	subroutine eam_splint(nx, xa, ya, yppa, x, y, dy, d2y)
866
867	<	!  include 'headers/sizes.h'
867	>	integer :: atype, nx, j
868	>	real( kind = DP ), dimension(:) :: xa
869	>	real( kind = DP ), dimension(:) :: ya
870	>	real( kind = DP ), dimension(:) :: yppa
871	>	real( kind = DP ) :: x, y
872	>	real( kind = DP ) :: dy, d2y
873	>	real( kind = DP ) :: del, h, a, b, c, d
874	>	integer :: pp_arraySize
875
876	+
877	+	! this spline code assumes that the x points are equally spaced
878	+	! do not attempt to use this code if they are not.
879	+
880	+
881	+	! find the closest point with a value below our own:
882	+	j = FLOOR(real((nx-1),kind=dp) * (x - xa(1)) / (xa(nx) - xa(1))) + 1
883
884	<	integer atype, etype, number_r
885	<	real( kind = DP )  :: r, rho, drho, d2rho
886	<	integer :: i
884	>	! check to make sure we're inside the spline range:
885	>	if ((j.gt.nx).or.(j.lt.1)) then
886	>	write(errMSG,*) "EAM_splint: x is outside bounds of spline"
887	>	call handleError(routineName,errMSG)
888	>	endif
889	>	! check to make sure we haven't screwed up the calculation of j:
890	>	if ((x.lt.xa(j)).or.(x.gt.xa(j+1))) then
891	>	if (j.ne.nx) then
892	>	write(errMSG,*) "EAM_splint:",x," x is outside bounding range"
893	>	call handleError(routineName,errMSG)
894	>	endif
895	>	endif
896
897	+	del = xa(j+1) - x
898	+	h = xa(j+1) - xa(j)
899	+
900	+	a = del / h
901	+	b = 1.0E0_DP - a
902	+	c = a*(a*a - 1.0E0_DP)*h*h/6.0E0_DP
903	+	d = b*(b*b - 1.0E0_DP)*h*h/6.0E0_DP
904	+
905	+	y = a*ya(j) + b*ya(j+1) + c*yppa(j) + d*yppa(j+1)
906	+
907	+	dy = (ya(j+1)-ya(j))/h &
908	+	- (3.0E0_DP*a*a - 1.0E0_DP)*h*yppa(j)/6.0E0_DP &
909	+	+ (3.0E0_DP*b*b - 1.0E0_DP)*h*yppa(j+1)/6.0E0_DP
910	+
911	+
912	+	d2y = a*yppa(j) + b*yppa(j+1)
913	+
914
915	<	etype = eam_atype_map(atype)
915	>	end subroutine eam_splint
916
422	–	if (r.lt.eam_rcut(etype)) then
423	–	number_r = eam_nr(etype)
424	–	call eam_splint(etype, number_r, eam_rvals, eam_rho_r, &
425	–	eam_rho_r_pp, r, rho, drho, d2rho)
426	–	else
427	–	rho = 0.0E0_DP
428	–	drho = 0.0E0_DP
429	–	d2rho = 0.0E0_DP
430	–	endif
917
918	<	return
433	<	end subroutine calc_eam_rho
918	>	subroutine eam_spline(nx, xa, ya, yppa, yp1, ypn, boundary)
919
435	–	subroutine calc_eam_frho(dens, u, u1, u2, atype)
920
921	<	! include 'headers/sizes.h'
921	>	! yp1 and ypn are the first derivatives of y at the two endpoints
922	>	! if boundary is 'L' the lower derivative is used
923	>	! if boundary is 'U' the upper derivative is used
924	>	! if boundary is 'B' then both derivatives are used
925	>	! if boundary is anything else, then both derivatives are assumed to be 0
926	>
927	>	integer :: nx, i, k, max_array_size
928	>
929	>	real( kind = DP ), dimension(:)        :: xa
930	>	real( kind = DP ), dimension(:)        :: ya
931	>	real( kind = DP ), dimension(:)        :: yppa
932	>	real( kind = DP ), dimension(size(xa)) :: u
933	>	real( kind = DP ) :: yp1,ypn,un,qn,sig,p
934	>	character(len=*) :: boundary
935	>
936	>	! make sure the sizes match
937	>	if ((nx /= size(xa)) .or. (nx /= size(ya))) then
938	>	call handleWarning("EAM_SPLINE","Array size mismatch")
939	>	end if
940
941	<	integer atype, etype, number_rho
942	<	real( kind = DP ) :: dens, u, u1, u2
943	<	real( kind = DP ) :: rho_vals
941	>	if ((boundary.eq.'l').or.(boundary.eq.'L').or. &
942	>	(boundary.eq.'b').or.(boundary.eq.'B')) then
943	>	yppa(1) = -0.5E0_DP
944	>	u(1) = (3.0E0_DP/(xa(2)-xa(1)))*((ya(2)-&
945	>	ya(1))/(xa(2)-xa(1))-yp1)
946	>	else
947	>	yppa(1) = 0.0E0_DP
948	>	u(1)  = 0.0E0_DP
949	>	endif
950	>
951	>	do i = 2, nx - 1
952	>	sig = (xa(i) - xa(i-1)) / (xa(i+1) - xa(i-1))
953	>	p = sig * yppa(i-1) + 2.0E0_DP
954	>	yppa(i) = (sig - 1.0E0_DP) / p
955	>	u(i) = (6.0E0_DP*((ya(i+1)-ya(i))/(xa(i+1)-xa(i)) - &
956	>	(ya(i)-ya(i-1))/(xa(i)-xa(i-1)))/ &
957	>	(xa(i+1)-xa(i-1)) - sig * u(i-1))/p
958	>	enddo
959	>
960	>	if ((boundary.eq.'u').or.(boundary.eq.'U').or. &
961	>	(boundary.eq.'b').or.(boundary.eq.'B')) then
962	>	qn = 0.5E0_DP
963	>	un = (3.0E0_DP/(xa(nx)-xa(nx-1)))* &
964	>	(ypn-(ya(nx)-ya(nx-1))/(xa(nx)-xa(nx-1)))
965	>	else
966	>	qn = 0.0E0_DP
967	>	un = 0.0E0_DP
968	>	endif
969
970	<	etype = eam_atype_map(atype)
971	<	number_rho = eam_nrho(etype)
972	<	if (dens.lt.eam_rhovals(number_rho, etype)) then
973	<	call eam_splint(etype, number_rho, eam_rhovals, eam_f_rho, &
974	<	eam_f_rho_pp, dens, u, u1, u2)
448	<	else
449	<	rho_vals = eam_rhovals(number_rho,etype)
450	<	call eam_splint(etype, number_rho, eam_rhovals, eam_f_rho, &
451	<	eam_f_rho_pp, rho_vals, u, u1, u2)
452	<	endif
970	>	yppa(nx)=(un-qn*u(nx-1))/(qn*yppa(nx-1)+1.0E0_DP)
971	>
972	>	do k = nx-1, 1, -1
973	>	yppa(k)=yppa(k)*yppa(k+1)+u(k)
974	>	enddo
975
976	<	return
455	<	end subroutine calc_eam_frho
976	>	end subroutine eam_spline
977
457	–	subroutine calc_eam_phi(r, phi, dphi, d2phi, atype)
978
979
980
981	<
462	<	integer atype, etype, number_r
463	<	real( kind = DP ) :: r, phi, dphi, d2phi
464	<
465	<	etype = eam_atype_map(atype)
466	<
467	<	if (r.lt.eam_rcut(etype)) then
468	<	number_r = eam_nr(etype)
469	<	call eam_splint(etype, number_r, eam_rvals, eam_phi_r, &
470	<	eam_phi_r_pp, r, phi, dphi, d2phi)
471	<	else
472	<	phi = 0.0E0_DP
473	<	dphi = 0.0E0_DP
474	<	d2phi = 0.0E0_DP
475	<	endif
476	<
477	<	return
478	<	end subroutine calc_eam_phi
479	<
480	<
481	<	subroutine eam_splint(atype, nx, xa, ya, yppa, x, y, dy, d2y)
482	<
483	<	!  include 'headers/sizes.h'
484	<
485	<	real( kind = DP ), dimension(:,:) :: xa
486	<	real( kind = DP ), dimension(:,:) :: ya
487	<	real( kind = DP ), dimension(:,:) :: yppa
488	<	real( kind = DP ) :: x, y, dy, d2y
489	<	real( kind = DP ) :: del, h, a, b, c, d
490	<
491	<
492	<	integer atype, nx, j
493	<
494	<
495	<	! this spline code assumes that the x points are equally spaced
496	<	! do not attempt to use this code if they are not.
497	<
498	<
499	<	! find the closest point with a value below our own:
500	<	j = FLOOR(dble(nx-1) * (x - xa(1,atype)) / (xa(nx,atype) - xa(1,atype))) + 1
501	<
502	<	! check to make sure we're inside the spline range:
503	<	if ((j.gt.nx).or.(j.lt.1)) call error('eam_splint', &
504	<	'x is outside bounds of spline')
505	<
506	<	! check to make sure we haven't screwed up the calculation of j:
507	<	if ((x.lt.xa(j,atype)).or.(x.gt.xa(j+1,atype))) then
508	<	if (j.ne.nx) then
509	<	call error('eam_splint', &
510	<	'x is outside bounding range')
511	<	endif
512	<	endif
513	<
514	<	del = xa(j+1,atype) - x
515	<	h = xa(j+1,atype) - xa(j,atype)
516	<
517	<	a = del / h
518	<	b = 1.0E0_DP - a
519	<	c = a*(a*a - 1.0E0_DP)*h*h/6.0E0_DP
520	<	d = b*(b*b - 1.0E0_DP)*h*h/6.0E0_DP
521	<
522	<	y = a*ya(j,atype) + b*ya(j+1,atype) + c*yppa(j,atype) + d*yppa(j+1,atype)
523	<
524	<	dy = (ya(j+1,atype)-ya(j,atype))/h &
525	<	- (3.0E0_DP*a*a - 1.0E0_DP)*h*yppa(j,atype)/6.0E0_DP &
526	<	+ (3.0E0_DP*b*b - 1.0E0_DP)*h*yppa(j+1,atype)/6.0E0_DP
527	<
528	<	d2y = a*yppa(j,atype) + b*yppa(j+1,atype)
529	<
530	<	return
531	<	end subroutine eam_splint
532	<
533	<	subroutine eam_spline(atype, nx, xa, ya, yppa, yp1, ypn, boundary)
534	<
535	<	!  include 'headers/sizes.h'
536	<
537	<
538	<	! yp1 and ypn are the first derivatives of y at the two endpoints
539	<	! if boundary is 'L' the lower derivative is used
540	<	! if boundary is 'U' the upper derivative is used
541	<	! if boundary is 'B' then both derivatives are used
542	<	! if boundary is anything else, then both derivatives are assumed to be 0
543	<
544	<	integer nx, i, k, atype, max_array_size
545	<
546	<	real( kind = DP ), dimension(:,:) :: xa
547	<	real( kind = DP ), dimension(:,:) :: ya
548	<	real( kind = DP ), dimension(:,:) :: yppa
549	<	real( kind = DP ), allocatable, dimension(:) :: u
550	<	real( kind = DP ) :: yp1,ypn,un,qn,sig,p
551	<	character boundary
552	<
553	<	max_array_size = size(xa,1)
554	<	allocate(u(max_array_size))
555	<
556	<
557	<	if ((boundary.eq.'l').or.(boundary.eq.'L').or. &
558	<	(boundary.eq.'b').or.(boundary.eq.'B')) then
559	<	yppa(1, atype) = -0.5E0_DP
560	<	u(1) = (3.0E0_DP/(xa(2,atype)-xa(1,atype)))*((ya(2,atype)-&
561	<	ya(1,atype))/(xa(2,atype)-xa(1,atype))-yp1)
562	<	else
563	<	yppa(1,atype) = 0.0E0_DP
564	<	u(1)  = 0.0E0_DP
565	<	endif
566	<
567	<	do i = 2, nx - 1
568	<	sig = (xa(i,atype) - xa(i-1,atype)) / (xa(i+1,atype) - xa(i-1,atype))
569	<	p = sig * yppa(i-1,atype) + 2.0E0_DP
570	<	yppa(i,atype) = (sig - 1.0E0_DP) / p
571	<	u(i) = (6.0E0_DP*((ya(i+1,atype)-ya(i,atype))/(xa(i+1,atype)-xa(i,atype)) - &
572	<	(ya(i,atype)-ya(i-1,atype))/(xa(i,atype)-xa(i-1,atype)))/ &
573	<	(xa(i+1,atype)-xa(i-1,atype)) - sig * u(i-1))/p
574	<	enddo
575	<
576	<	if ((boundary.eq.'u').or.(boundary.eq.'U').or. &
577	<	(boundary.eq.'b').or.(boundary.eq.'B')) then
578	<	qn = 0.5E0_DP
579	<	un = (3.0E0_DP/(xa(nx,atype)-xa(nx-1,atype)))* &
580	<	(ypn-(ya(nx,atype)-ya(nx-1,atype))/(xa(nx,atype)-xa(nx-1,atype)))
581	<	else
582	<	qn = 0.0E0_DP
583	<	un = 0.0E0_DP
584	<	endif
585	<
586	<	yppa(nx,atype)=(un-qn*u(nx-1))/(qn*yppa(nx-1,atype)+1.0E0_DP)
587	<
588	<	do k = nx-1, 1, -1
589	<	yppa(k,atype)=yppa(k,atype)*yppa(k+1,atype)+u(k)
590	<	enddo
591	<
592	<	deallocate(u)
593	<	return
594	<	end subroutine eam_spline
595	<
596	<
597	<
598	<
599	<	end module calc_eam
981	>	end module eam

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines