mdtools/libmdCode/forceGlobals.F90

module forceGlobals
  
  use definitions
  use simulation
  use atype_typedefs
  use vector_class
#ifdef IS_MPI
  use mpiSimulation
#endif
    
  logical, save :: atype_vector_initialized = .false.
  logical, save :: ff_initialized = .false.

  
#ifdef IS_MPI
  real( kind = dp ), allocatable, dimension(:,:) :: q_Row
  real( kind = dp ), allocatable, dimension(:,:) :: q_Col
  real( kind = dp ), allocatable, dimension(:,:) :: u_l_Row
  real( kind = dp ), allocatable, dimension(:,:) :: u_l_Col
  real( kind = dp ), allocatable, dimension(:,:) :: A_Row
  real( kind = dp ), allocatable, dimension(:,:) :: A_Col
  
  real( kind = dp ), allocatable, dimension(:) :: pot_Row
  real( kind = dp ), allocatable, dimension(:) :: pot_Col
  real( kind = dp ), allocatable, dimension(:) :: pot_Temp
  real( kind = dp ), allocatable, dimension(:,:) :: f_Row
  real( kind = dp ), allocatable, dimension(:,:) :: f_Col
  real( kind = dp ), allocatable, dimension(:,:) :: f_Temp
  real( kind = dp ), allocatable, dimension(:,:) :: t_Row
  real( kind = dp ), allocatable, dimension(:,:) :: t_Col
  real( kind = dp ), allocatable, dimension(:,:) :: t_Temp
  integer, allocatable, dimension(:) :: atid_Row
  integer, allocatable, dimension(:) :: atid_Col
#else
  integer, allocatable, dimension(:) :: atid
#endif
  
  real(kind = dp) :: pot = 0.0_dp
  real(kind = dp), dimension(9) :: tau_Temp = 0.0_dp
  real(kind = dp) :: virial_Temp = 0.0_dp
  
  public :: new_atype 
  public :: init_FF

contains
  
  subroutine new_atype(c_ident, is_LJ, is_Sticky, is_DP, is_GB, &
       lj_epsilon, lj_sigma, & 
       dipole_moment, &
       sticky_w0, sticky_v0, &
       GB_sigma, GB_l2b_ratio, GB_eps, GB_eps_ratio, GB_mu, GB_nu, &
       status)
    
    real( kind = dp ), intent(in) :: lj_epsilon
    real( kind = dp ), intent(in) :: lj_sigma
    real( kind = dp ), intent(in) :: sticky_w0
    real( kind = dp ), intent(in) :: sticky_v0
    real( kind = dp ), intent(in) :: dipole_moment
    real( kind = dp ), intent(in) :: GB_sigma, GB_l2b_ratio, GB_eps
    real( kind = dp ), intent(in) :: GB_eps_ratio, GB_mu, GB_nu

    integer, intent(in)  :: c_ident
    integer, intent(out) :: status
    integer, intent(in)  :: is_Sticky
    integer, intent(in)  :: is_DP
    integer, intent(in)  :: is_GB
    integer, intent(in)  :: is_LJ
    integer :: me
    logical :: l_is_LJ, l_is_DP, l_is_Sticky, l_is_GB

    status = 0

    if (.not.atype_vector_initialized) then
       !! There are 16 properties to worry about for now.  
       !! Fix this if needed for more atomic properties
       atypes = initialize(16)
       if (.not.associated(atypes)) then
          status = -1
          return
       endif
    endif

    me = addElement(atypes)

    call setElementProperty(atypes, me, "c_ident", c_ident)

    l_is_LJ = (is_LJ .ne. 0)
    l_is_DP = (is_DP .ne. 0)
    l_is_Sticky = (is_Sticky .ne. 0)
    l_is_GB = (is_GB .ne. 0)

    call setElementProperty(atypes, me, "is_LJ", l_is_LJ)
    call setElementProperty(atypes, me, "is_DP", l_is_DP)
    call setElementProperty(atypes, me, "is_Sticky", l_is_Sticky)
    call setElementProperty(atypes, me, "is_GB", l_is_GB)

    if (l_is_LJ) then
       call setElementProperty(atypes, me, "lj_sigma", lj_sigma)
       call setElementProperty(atypes, me, "lj_epsilon", lj_epsilon)
    endif
    if (l_is_DP) then
       call setElementProperty(atypes, me, "dipole_moment", dipole_moment)
    endif
    if (l_is_Sticky) then
       call setElementProperty(atypes, me, "sticky_w0", sticky_w0)
       call setElementProperty(atypes, me, "sticky_v0", sticky_v0)
    endif
    if (l_is_GB) then
       call setElementProperty(atypes, me, "GB_sigma", GB_sigma)
       call setElementProperty(atypes, me, "GB_l2b_ratio", GB_l2b_ratio)
       call setElementProperty(atypes, me, "GB_eps", GB_eps)
       call setElementProperty(atypes, me, "GB_eps_ratio", GB_eps_ratio)
       call setElementProperty(atypes, me, "GB_mu", GB_mu)
       call setElementProperty(atypes, me, "GB_nu", GB_nu)
    endif

  end subroutine new_atype

  
  subroutine init_FF(nComponents, c_idents, nExcludes, excludesLocal, status)
    !! Number of components in c_idents array
    integer, intent(inout) :: nComponents
    !! Array of identities nComponents long corresponding to
    !! ljatype ident.
    integer, dimension(nComponents),intent(inout) :: c_idents
    integer :: nExcludes
    integer, dimension(nExcludes),intent(inout) :: excludesLocal
    !!  Result status, success = 0, error = -1
    integer, intent(out) :: status    
    integer :: i, me, thisStat
    integer :: myNode

#ifdef IS_MPI
    integer, allocatable, dimension(:) :: c_idents_Row
    integer, allocatable, dimension(:) :: c_idents_Col
    integer :: nrow
    integer :: ncol
#endif
 
    status = 0


#ifdef IS_MPI
    ! We can only set up forces if mpiSimulation has been setup.
    if (.not. isMPISimSet()) then
       write(default_error,*) "MPI is not set"
       status = -1
       return
    endif
    nrow = getNrow(plan_row)
    ncol = getNcol(plan_col)
    mynode = getMyNode()
    
    allocate(c_idents_Row(nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       status = -1
       return
    endif

    allocate(c_idents_Col(ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       status = -1
       return
    endif

    call gather(c_idents, c_idents_Row, plan_row)
    call gather(c_idents, c_idents_Col, plan_col)

    allocate(atid_Row(nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       status = -1
       return
    endif

    allocate(atid_Col(ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       status = -1
       return
    endif

    do i = 1, nrow
       me = getFirstMatchingElement(atypes, "c_ident", c_idents_Row(i))
       atid_Row(i) = me
    enddo

    do i = 1, ncol
       me = getFirstMatchingElement(atypes, "c_ident", c_idents_Col(i))
       atid_Col(i) = me
    enddo

    !! free temporary ident arrays
    if (allocated(identCol)) then
       deallocate(identCol)
    end if
    if (allocated(identCol)) then
       deallocate(identRow)
    endif
    
#else
    do i = 1, nComponents

       me = getFirstMatchingElement(atypes, "c_ident", c_idents(i))
       atid(i) = me

    enddo
#endif

    call initForce_Modules(thisStat)
    if (thisStat /= 0) then
       status = -1
       return
    endif
    
    !! Create neighbor lists
    call expandList(thisStat)
    if (thisStat /= 0) then
       status = -1
       return
    endif
    
    call setupGlobals(thisStat)
    if (thisStat /= 0) then
       status = -1
       return
    endif
    
    ff_initialized = .true.
    
    
  end subroutine init_FF
  
  subroutine setupGlobals(thisStat)
    integer, intent(out) :: thisStat
    integer :: nrow
    integer :: ncol
    integer :: nlocal
    integer :: ndim = 3
    integer :: alloc_stat

    thisStat = 0

#ifdef IS_MPI
    nrow = getNrow(plan_row)
    ncol = getNcol(plan_col)
#endif
    nlocal = getNlocal()

    call freeGlobals()

    allocate(q_Row(ndim,nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    
    allocate(q_Col(ndim,ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    
    allocate(u_l_Row(ndim,nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
     
    allocate(u_l_Col(ndim,ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    

    allocate(A_row(9,nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    
    allocate(A_Col(9,ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    

    allocate(pot_row(nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    allocate(pot_Col(ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif

    allocate(pot_Temp(nlocal),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    allocate(f_Row(ndim,nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    allocate(f_Col(ndim,ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    allocate(f_Temp(ndim,nlocal),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    allocate(t_Row(ndim,nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif
    
    allocate(t_Col(ndim,ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif

    allocate(t_temp(ndim,nlocal),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif

    allocate(atid_Row(nrow),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif

    allocate(atid_Col(ncol),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    endif

#else

    allocate(atid(nlocal),stat=alloc_stat)
    if (alloc_stat /= 0 ) then
       thisStat = 0
       return
    end if
#endif

  end subroutine setupGlobals
  
  subroutine freeGlobals()

!We free in the opposite order in which we allocate in.
#ifdef IS_MPI

    if (allocated(atid_Col))   deallocate(atid_Col)
    if (allocated(atid_Row))   deallocate(atid_Row)
    if (allocated(t_Temp))     deallocate(t_Temp)
    if (allocated(t_Col))      deallocate(t_Col)
    if (allocated(t_Row))      deallocate(t_Row)
    if (allocated(f_Temp))     deallocate(f_Temp)
    if (allocated(f_Col))      deallocate(f_Col)
    if (allocated(f_Row))      deallocate(f_Row)
    if (allocated(pot_Temp))   deallocate(pot_Temp)
    if (allocated(pot_Col))    deallocate(pot_Col)
    if (allocated(pot_Row))    deallocate(pot_Row)
    if (allocated(A_Col))      deallocate(A_Col)
    if (allocated(A_Row))      deallocate(A_Row)
    if (allocated(u_l_Col))    deallocate(u_l_Col)
    if (allocated(u_l_Row))    deallocate(u_l_Row)
    if (allocated(q_Col))      deallocate(q_Col)
    if (allocated(q_Row))      deallocate(q_Row)

#else

    if (allocated(atid))       deallocate(atid)

#endif


  end subroutine freeGlobals


  subroutine initForce_Modules(thisStat)
    integer, intent(out) :: thisStat
    integer :: my_status
    
    thisStat = 0
    call init_lj_FF(my_status)
    if (my_status /= 0) then
       thisStat = -1
       return
    end if
    
  end subroutine initForce_Modules
   
end module forceGlobals
Revision:	319
Committed:	Wed Mar 12 14:29:15 2003 UTC (21 years, 6 months ago) by gezelter
File size:	10662 byte(s)
Log Message:	rearranging source files
#	User	Rev	Content
1	chuckv	306	module forceGlobals
2	gezelter	317
3	gezelter	309	use definitions
4			use simulation
5			use atype_typedefs
6	gezelter	317	use vector_class
7	gezelter	309	#ifdef IS_MPI
8			use mpiSimulation
9			#endif
10	gezelter	317
11			logical, save :: atype_vector_initialized = .false.
12			logical, save :: ff_initialized = .false.
13	chuckv	318
14	gezelter	317
15	chuckv	306	#ifdef IS_MPI
16	gezelter	317	real( kind = dp ), allocatable, dimension(:,:) :: q_Row
17			real( kind = dp ), allocatable, dimension(:,:) :: q_Col
18			real( kind = dp ), allocatable, dimension(:,:) :: u_l_Row
19			real( kind = dp ), allocatable, dimension(:,:) :: u_l_Col
20			real( kind = dp ), allocatable, dimension(:,:) :: A_Row
21			real( kind = dp ), allocatable, dimension(:,:) :: A_Col
22
23			real( kind = dp ), allocatable, dimension(:) :: pot_Row
24			real( kind = dp ), allocatable, dimension(:) :: pot_Col
25			real( kind = dp ), allocatable, dimension(:) :: pot_Temp
26			real( kind = dp ), allocatable, dimension(:,:) :: f_Row
27			real( kind = dp ), allocatable, dimension(:,:) :: f_Col
28			real( kind = dp ), allocatable, dimension(:,:) :: f_Temp
29			real( kind = dp ), allocatable, dimension(:,:) :: t_Row
30			real( kind = dp ), allocatable, dimension(:,:) :: t_Col
31			real( kind = dp ), allocatable, dimension(:,:) :: t_Temp
32			integer, allocatable, dimension(:) :: atid_Row
33			integer, allocatable, dimension(:) :: atid_Col
34	chuckv	306	#else
35	gezelter	317	integer, allocatable, dimension(:) :: atid
36	chuckv	306	#endif
37	gezelter	317
38	gezelter	309	real(kind = dp) :: pot = 0.0_dp
39			real(kind = dp), dimension(9) :: tau_Temp = 0.0_dp
40			real(kind = dp) :: virial_Temp = 0.0_dp
41	gezelter	317
42	chuckv	306	public :: new_atype
43			public :: init_FF
44
45	gezelter	317	contains
46	chuckv	306
47	gezelter	317	subroutine new_atype(c_ident, is_LJ, is_Sticky, is_DP, is_GB, &
48			lj_epsilon, lj_sigma, &
49			dipole_moment, &
50			sticky_w0, sticky_v0, &
51			GB_sigma, GB_l2b_ratio, GB_eps, GB_eps_ratio, GB_mu, GB_nu, &
52			status)
53
54			real( kind = dp ), intent(in) :: lj_epsilon
55			real( kind = dp ), intent(in) :: lj_sigma
56			real( kind = dp ), intent(in) :: sticky_w0
57			real( kind = dp ), intent(in) :: sticky_v0
58			real( kind = dp ), intent(in) :: dipole_moment
59			real( kind = dp ), intent(in) :: GB_sigma, GB_l2b_ratio, GB_eps
60			real( kind = dp ), intent(in) :: GB_eps_ratio, GB_mu, GB_nu
61	chuckv	306
62	gezelter	317	integer, intent(in) :: c_ident
63	chuckv	306	integer, intent(out) :: status
64	gezelter	317	integer, intent(in) :: is_Sticky
65			integer, intent(in) :: is_DP
66			integer, intent(in) :: is_GB
67			integer, intent(in) :: is_LJ
68			integer :: me
69			logical :: l_is_LJ, l_is_DP, l_is_Sticky, l_is_GB
70	chuckv	306
71			status = 0
72
73	gezelter	317	if (.not.atype_vector_initialized) then
74			!! There are 16 properties to worry about for now.
75			!! Fix this if needed for more atomic properties
76			atypes = initialize(16)
77			if (.not.associated(atypes)) then
78			status = -1
79			return
80			endif
81			endif
82	chuckv	306
83	gezelter	317	me = addElement(atypes)
84	chuckv	306
85	gezelter	317	call setElementProperty(atypes, me, "c_ident", c_ident)
86	chuckv	306
87	gezelter	317	l_is_LJ = (is_LJ .ne. 0)
88			l_is_DP = (is_DP .ne. 0)
89			l_is_Sticky = (is_Sticky .ne. 0)
90			l_is_GB = (is_GB .ne. 0)
91	gezelter	309
92	gezelter	317	call setElementProperty(atypes, me, "is_LJ", l_is_LJ)
93			call setElementProperty(atypes, me, "is_DP", l_is_DP)
94			call setElementProperty(atypes, me, "is_Sticky", l_is_Sticky)
95			call setElementProperty(atypes, me, "is_GB", l_is_GB)
96	chuckv	306
97	gezelter	317	if (l_is_LJ) then
98			call setElementProperty(atypes, me, "lj_sigma", lj_sigma)
99			call setElementProperty(atypes, me, "lj_epsilon", lj_epsilon)
100	chuckv	306	endif
101	gezelter	317	if (l_is_DP) then
102			call setElementProperty(atypes, me, "dipole_moment", dipole_moment)
103			endif
104			if (l_is_Sticky) then
105			call setElementProperty(atypes, me, "sticky_w0", sticky_w0)
106			call setElementProperty(atypes, me, "sticky_v0", sticky_v0)
107			endif
108			if (l_is_GB) then
109			call setElementProperty(atypes, me, "GB_sigma", GB_sigma)
110			call setElementProperty(atypes, me, "GB_l2b_ratio", GB_l2b_ratio)
111			call setElementProperty(atypes, me, "GB_eps", GB_eps)
112			call setElementProperty(atypes, me, "GB_eps_ratio", GB_eps_ratio)
113			call setElementProperty(atypes, me, "GB_mu", GB_mu)
114			call setElementProperty(atypes, me, "GB_nu", GB_nu)
115			endif
116
117	chuckv	306	end subroutine new_atype
118
119	gezelter	317
120			subroutine init_FF(nComponents, c_idents, nExcludes, excludesLocal, status)
121			!! Number of components in c_idents array
122	chuckv	306	integer, intent(inout) :: nComponents
123	gezelter	317	!! Array of identities nComponents long corresponding to
124			!! ljatype ident.
125			integer, dimension(nComponents),intent(inout) :: c_idents
126	chuckv	306	integer :: nExcludes
127	gezelter	309	integer, dimension(nExcludes),intent(inout) :: excludesLocal
128	gezelter	317	!! Result status, success = 0, error = -1
129			integer, intent(out) :: status
130			integer :: i, me, thisStat
131			integer :: myNode
132	chuckv	306
133			#ifdef IS_MPI
134	gezelter	317	integer, allocatable, dimension(:) :: c_idents_Row
135			integer, allocatable, dimension(:) :: c_idents_Col
136	chuckv	306	integer :: nrow
137			integer :: ncol
138			#endif
139	gezelter	317
140	chuckv	306	status = 0
141
142
143	gezelter	317	#ifdef IS_MPI
144			! We can only set up forces if mpiSimulation has been setup.
145	chuckv	306	if (.not. isMPISimSet()) then
146			write(default_error,*) "MPI is not set"
147			status = -1
148			return
149			endif
150			nrow = getNrow(plan_row)
151			ncol = getNcol(plan_col)
152			mynode = getMyNode()
153	gezelter	317
154			allocate(c_idents_Row(nrow),stat=alloc_stat)
155	chuckv	306	if (alloc_stat /= 0 ) then
156			status = -1
157			return
158			endif
159
160	gezelter	317	allocate(c_idents_Col(ncol),stat=alloc_stat)
161	chuckv	306	if (alloc_stat /= 0 ) then
162			status = -1
163			return
164			endif
165
166	gezelter	317	call gather(c_idents, c_idents_Row, plan_row)
167			call gather(c_idents, c_idents_Col, plan_col)
168
169			allocate(atid_Row(nrow),stat=alloc_stat)
170			if (alloc_stat /= 0 ) then
171	chuckv	306	status = -1
172			return
173			endif
174	gezelter	317
175			allocate(atid_Col(ncol),stat=alloc_stat)
176			if (alloc_stat /= 0 ) then
177	chuckv	306	status = -1
178			return
179			endif
180
181	gezelter	317	do i = 1, nrow
182			me = getFirstMatchingElement(atypes, "c_ident", c_idents_Row(i))
183			atid_Row(i) = me
184			enddo
185
186			do i = 1, ncol
187			me = getFirstMatchingElement(atypes, "c_ident", c_idents_Col(i))
188			atid_Col(i) = me
189			enddo
190
191			!! free temporary ident arrays
192	chuckv	306	if (allocated(identCol)) then
193			deallocate(identCol)
194			end if
195			if (allocated(identCol)) then
196			deallocate(identRow)
197			endif
198	gezelter	317
199			#else
200			do i = 1, nComponents
201	chuckv	306
202	gezelter	317	me = getFirstMatchingElement(atypes, "c_ident", c_idents(i))
203			atid(i) = me
204
205			enddo
206	chuckv	306	#endif
207	gezelter	317
208	chuckv	306	call initForce_Modules(thisStat)
209			if (thisStat /= 0) then
210			status = -1
211			return
212			endif
213	gezelter	317
214			!! Create neighbor lists
215	chuckv	306	call expandList(thisStat)
216			if (thisStat /= 0) then
217			status = -1
218			return
219			endif
220	gezelter	317
221	chuckv	315	call setupGlobals(thisStat)
222			if (thisStat /= 0) then
223			status = -1
224			return
225			endif
226	gezelter	309
227	gezelter	317	ff_initialized = .true.
228	gezelter	309
229	gezelter	317
230	chuckv	306	end subroutine init_FF
231	gezelter	317
232	chuckv	315	subroutine setupGlobals(thisStat)
233			integer, intent(out) :: thisStat
234	chuckv	318	integer :: nrow
235			integer :: ncol
236			integer :: nlocal
237			integer :: ndim = 3
238			integer :: alloc_stat
239
240			thisStat = 0
241
242			#ifdef IS_MPI
243			nrow = getNrow(plan_row)
244			ncol = getNcol(plan_col)
245			#endif
246			nlocal = getNlocal()
247
248			call freeGlobals()
249
250			allocate(q_Row(ndim,nrow),stat=alloc_stat)
251			if (alloc_stat /= 0 ) then
252			thisStat = 0
253			return
254			endif
255	gezelter	317
256	chuckv	318
257			allocate(q_Col(ndim,ncol),stat=alloc_stat)
258			if (alloc_stat /= 0 ) then
259			thisStat = 0
260			return
261			endif
262
263
264			allocate(u_l_Row(ndim,nrow),stat=alloc_stat)
265			if (alloc_stat /= 0 ) then
266			thisStat = 0
267			return
268			endif
269	gezelter	319
270	chuckv	318	allocate(u_l_Col(ndim,ncol),stat=alloc_stat)
271			if (alloc_stat /= 0 ) then
272			thisStat = 0
273			return
274			endif
275
276
277			allocate(A_row(9,nrow),stat=alloc_stat)
278			if (alloc_stat /= 0 ) then
279			thisStat = 0
280			return
281			endif
282
283
284			allocate(A_Col(9,ncol),stat=alloc_stat)
285			if (alloc_stat /= 0 ) then
286			thisStat = 0
287			return
288			endif
289
290
291			allocate(pot_row(nrow),stat=alloc_stat)
292			if (alloc_stat /= 0 ) then
293			thisStat = 0
294			return
295			endif
296
297			allocate(pot_Col(ncol),stat=alloc_stat)
298			if (alloc_stat /= 0 ) then
299			thisStat = 0
300			return
301			endif
302
303			allocate(pot_Temp(nlocal),stat=alloc_stat)
304			if (alloc_stat /= 0 ) then
305			thisStat = 0
306			return
307			endif
308
309			allocate(f_Row(ndim,nrow),stat=alloc_stat)
310			if (alloc_stat /= 0 ) then
311			thisStat = 0
312			return
313			endif
314
315			allocate(f_Col(ndim,ncol),stat=alloc_stat)
316			if (alloc_stat /= 0 ) then
317			thisStat = 0
318			return
319			endif
320
321			allocate(f_Temp(ndim,nlocal),stat=alloc_stat)
322			if (alloc_stat /= 0 ) then
323			thisStat = 0
324			return
325			endif
326
327			allocate(t_Row(ndim,nrow),stat=alloc_stat)
328			if (alloc_stat /= 0 ) then
329			thisStat = 0
330			return
331			endif
332
333			allocate(t_Col(ndim,ncol),stat=alloc_stat)
334			if (alloc_stat /= 0 ) then
335			thisStat = 0
336			return
337			endif
338
339			allocate(t_temp(ndim,nlocal),stat=alloc_stat)
340			if (alloc_stat /= 0 ) then
341			thisStat = 0
342			return
343			endif
344
345			allocate(atid_Row(nrow),stat=alloc_stat)
346			if (alloc_stat /= 0 ) then
347			thisStat = 0
348			return
349			endif
350
351			allocate(atid_Col(ncol),stat=alloc_stat)
352			if (alloc_stat /= 0 ) then
353			thisStat = 0
354			return
355			endif
356
357			#else
358
359			allocate(atid(nlocal),stat=alloc_stat)
360			if (alloc_stat /= 0 ) then
361			thisStat = 0
362			return
363			end if
364			#endif
365
366	chuckv	315	end subroutine setupGlobals
367	gezelter	317
368	chuckv	318	subroutine freeGlobals()
369
370			!We free in the opposite order in which we allocate in.
371			#ifdef IS_MPI
372
373			if (allocated(atid_Col)) deallocate(atid_Col)
374			if (allocated(atid_Row)) deallocate(atid_Row)
375			if (allocated(t_Temp)) deallocate(t_Temp)
376			if (allocated(t_Col)) deallocate(t_Col)
377			if (allocated(t_Row)) deallocate(t_Row)
378			if (allocated(f_Temp)) deallocate(f_Temp)
379			if (allocated(f_Col)) deallocate(f_Col)
380			if (allocated(f_Row)) deallocate(f_Row)
381			if (allocated(pot_Temp)) deallocate(pot_Temp)
382			if (allocated(pot_Col)) deallocate(pot_Col)
383			if (allocated(pot_Row)) deallocate(pot_Row)
384			if (allocated(A_Col)) deallocate(A_Col)
385			if (allocated(A_Row)) deallocate(A_Row)
386			if (allocated(u_l_Col)) deallocate(u_l_Col)
387			if (allocated(u_l_Row)) deallocate(u_l_Row)
388			if (allocated(q_Col)) deallocate(q_Col)
389			if (allocated(q_Row)) deallocate(q_Row)
390
391			#else
392
393			if (allocated(atid)) deallocate(atid)
394
395			#endif
396
397
398			end subroutine freeGlobals
399
400
401
402
403	gezelter	317
404	chuckv	306	subroutine initForce_Modules(thisStat)
405			integer, intent(out) :: thisStat
406			integer :: my_status
407
408			thisStat = 0
409	gezelter	317	call init_lj_FF(my_status)
410	chuckv	306	if (my_status /= 0) then
411			thisStat = -1
412			return
413			end if
414	gezelter	317
415	chuckv	306	end subroutine initForce_Modules
416	gezelter	317
417	chuckv	306	end module forceGlobals