Neko  0.9.0
A portable framework for high-order spectral element flow simulations
chkp_file.f90
Go to the documentation of this file.
1 ! Copyright (c) 2021-2022, The Neko Authors
2 ! All rights reserved.
3 !
4 ! Redistribution and use in source and binary forms, with or without
5 ! modification, are permitted provided that the following conditions
6 ! are met:
7 !
8 ! * Redistributions of source code must retain the above copyright
9 ! notice, this list of conditions and the following disclaimer.
10 !
11 ! * Redistributions in binary form must reproduce the above
12 ! copyright notice, this list of conditions and the following
13 ! disclaimer in the documentation and/or other materials provided
14 ! with the distribution.
15 !
16 ! * Neither the name of the authors nor the names of its
17 ! contributors may be used to endorse or promote products derived
18 ! from this software without specific prior written permission.
19 !
20 ! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
21 ! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
22 ! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
23 ! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
24 ! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
25 ! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
26 ! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 ! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
28 ! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
29 ! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
30 ! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
31 ! POSSIBILITY OF SUCH DAMAGE.
32 !
35 module chkp_file
36  use generic_file
37  use field_series
38  use checkpoint
39  use num_types
40  use field
41  use dofmap, only: dofmap_t
42  use device_math
43  use utils
44  use space
45  use mesh
46  use math
47  use interpolation
48  use neko_mpi_types
49  use comm
50  use global_interpolation
51  implicit none
52  private
53 
55  type, public, extends(generic_file_t) :: chkp_file_t
56  type(space_t), pointer :: chkp_xh
57  type(space_t), pointer :: sim_xh
58  type(interpolator_t) :: space_interp
59  type(global_interpolation_t) :: global_interp
60  logical :: mesh2mesh
61  contains
62  procedure :: read => chkp_file_read
63  procedure :: read_field => chkp_read_field
64  procedure :: write => chkp_file_write
65  end type chkp_file_t
66 
67 contains
68 
70  subroutine chkp_file_write(this, data, t)
71  class(chkp_file_t), intent(inout) :: this
72  class(*), target, intent(in) :: data
73  real(kind=rp), intent(in), optional :: t
74  real(kind=dp) :: time
75  character(len=5) :: id_str
76  character(len=1024) :: fname
77  integer :: ierr, suffix_pos, optional_fields
78  type(field_t), pointer :: u, v, w, p, s
79  type(field_t), pointer :: abx1,abx2
80  type(field_t), pointer :: aby1,aby2
81  type(field_t), pointer :: abz1,abz2
82  type(field_t), pointer :: abs1,abs2
83  type(field_series_t), pointer :: ulag => null()
84  type(field_series_t), pointer :: vlag => null()
85  type(field_series_t), pointer :: wlag => null()
86  type(field_series_t), pointer :: slag => null()
87  real(kind=rp), pointer :: dtlag(:), tlag(:)
88  type(mesh_t), pointer :: msh
89  type(mpi_status) :: status
90  type(mpi_file) :: fh
91  integer (kind=MPI_OFFSET_KIND) :: mpi_offset, byte_offset
92  integer(kind=i8) :: n_glb_dofs, dof_offset
93  logical :: write_lag, write_scalar, write_dtlag, write_scalarlag, write_abvel
94  integer :: i
95 
96  if (present(t)) then
97  time = real(t,dp)
98  else
99  time = 0d0
100  end if
101 
102  select type(data)
103  type is (chkp_t)
104 
105  if ( .not. associated(data%u) .or. &
106  .not. associated(data%v) .or. &
107  .not. associated(data%w) .or. &
108  .not. associated(data%p) ) then
109  call neko_error('Checkpoint not initialized')
110  end if
111 
112  u => data%u
113  v => data%v
114  w => data%w
115  p => data%p
116  msh => u%msh
117 
118  optional_fields = 0
119 
120  if (associated(data%ulag)) then
121  ulag => data%ulag
122  vlag => data%vlag
123  wlag => data%wlag
124  write_lag = .true.
125  optional_fields = optional_fields + 1
126  else
127  write_lag = .false.
128  end if
129 
130  if (associated(data%s)) then
131  s => data%s
132  write_scalar = .true.
133  optional_fields = optional_fields + 2
134  else
135  write_scalar = .false.
136  end if
137 
138  if (associated(data%tlag)) then
139  tlag => data%tlag
140  dtlag => data%dtlag
141  write_dtlag = .true.
142  optional_fields = optional_fields + 4
143  else
144  write_dtlag = .false.
145  end if
146  write_abvel = .false.
147  if (associated(data%abx1)) then
148  abx1 => data%abx1
149  abx2 => data%abx2
150  aby1 => data%aby1
151  aby2 => data%aby2
152  abz1 => data%abz1
153  abz2 => data%abz2
154  optional_fields = optional_fields + 8
155  write_abvel = .true.
156  end if
157  write_scalarlag = .false.
158  if (associated(data%abs1)) then
159  slag => data%slag
160  abs1 => data%abs1
161  abs2 => data%abs2
162  optional_fields = optional_fields + 16
163  write_scalarlag = .true.
164  end if
165  class default
166  call neko_error('Invalid data')
167  end select
168 
169 
170  suffix_pos = filename_suffix_pos(this%fname)
171  write(id_str, '(i5.5)') this%counter
172  fname = trim(this%fname(1:suffix_pos-1))//id_str//'.chkp'
173 
174 
175  dof_offset = int(msh%offset_el, i8) * int(u%Xh%lx * u%Xh%ly * u%Xh%lz, i8)
176  n_glb_dofs = int(u%Xh%lx * u%Xh%ly * u%Xh%lz, i8) * int(msh%glb_nelv, i8)
177 
178  call mpi_file_open(neko_comm, trim(fname), &
179  mpi_mode_wronly + mpi_mode_create, mpi_info_null, fh, ierr)
180  call mpi_file_write_all(fh, msh%glb_nelv, 1, mpi_integer, status, ierr)
181  call mpi_file_write_all(fh, msh%gdim, 1, mpi_integer, status, ierr)
182  call mpi_file_write_all(fh, u%Xh%lx, 1, mpi_integer, status, ierr)
183  call mpi_file_write_all(fh, optional_fields, 1, mpi_integer, status, ierr)
184  call mpi_file_write_all(fh, time, 1, mpi_double_precision, status, ierr)
185 
186 
187  !
188  ! Dump mandatory checkpoint data
189  !
190 
191 
192  byte_offset = 4_i8 * int(mpi_integer_size,i8) + int(mpi_double_precision_size,i8)
193  byte_offset = byte_offset + &
194  dof_offset * int(mpi_real_prec_size, i8)
195  call mpi_file_write_at_all(fh, byte_offset,u%x, u%dof%size(), &
196  mpi_real_precision, status, ierr)
197  mpi_offset = 4_i8 * int(mpi_integer_size,i8) + int(mpi_double_precision_size,i8)
198  mpi_offset = mpi_offset +&
199  n_glb_dofs * int(mpi_real_prec_size, i8)
200 
201  byte_offset = mpi_offset + &
202  dof_offset * int(mpi_real_prec_size, i8)
203  call mpi_file_write_at_all(fh, byte_offset, v%x, v%dof%size(), &
204  mpi_real_precision, status, ierr)
205  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
206 
207  byte_offset = mpi_offset + &
208  dof_offset * int(mpi_real_prec_size, i8)
209  call mpi_file_write_at_all(fh, byte_offset, w%x, w%dof%size(), &
210  mpi_real_precision, status, ierr)
211  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
212 
213  byte_offset = mpi_offset + &
214  dof_offset * int(mpi_real_prec_size, i8)
215  call mpi_file_write_at_all(fh, byte_offset, p%x, p%dof%size(), &
216  mpi_real_precision, status, ierr)
217  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
218 
219  !
220  ! Dump optional payload
221  !
222 
223  if (write_lag) then
224 
225  do i = 1, ulag%size()
226  byte_offset = mpi_offset + &
227  dof_offset * int(mpi_real_prec_size, i8)
228  ! We should not need this extra associate block, ant it works
229  ! great without it for GNU, Intel, NEC and Cray, but throws an
230  ! ICE with NAG.
231  associate(x => ulag%lf(i)%x)
232  call mpi_file_write_at_all(fh, byte_offset, x, &
233  ulag%lf(i)%dof%size(), mpi_real_precision, status, ierr)
234  end associate
235  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
236  end do
237 
238  do i = 1, vlag%size()
239  byte_offset = mpi_offset + &
240  dof_offset * int(mpi_real_prec_size, i8)
241  ! We should not need this extra associate block, ant it works
242  ! great without it for GNU, Intel, NEC and Cray, but throws an
243  ! ICE with NAG.
244  associate(x => vlag%lf(i)%x)
245  call mpi_file_write_at_all(fh, byte_offset, x, &
246  vlag%lf(i)%dof%size(), mpi_real_precision, status, ierr)
247  end associate
248  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
249  end do
250 
251  do i = 1, wlag%size()
252  byte_offset = mpi_offset + &
253  dof_offset * int(mpi_real_prec_size, i8)
254  ! We should not need this extra associate block, ant it works
255  ! great without it for GNU, Intel, NEC and Cray, but throws an
256  ! ICE with NAG.
257  associate(x => wlag%lf(i)%x)
258  call mpi_file_write_at_all(fh, byte_offset, x, &
259  wlag%lf(i)%dof%size(), mpi_real_precision, status, ierr)
260  end associate
261  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
262  end do
263 
264  end if
265 
266  if (write_scalar) then
267  byte_offset = mpi_offset + &
268  dof_offset * int(mpi_real_prec_size, i8)
269  call mpi_file_write_at_all(fh, byte_offset, s%x, p%dof%size(), &
270  mpi_real_precision, status, ierr)
271  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
272  end if
273 
274  if (write_dtlag) then
275  call mpi_file_write_at_all(fh, mpi_offset, tlag, 10, mpi_real_precision, status, ierr)
276  mpi_offset = mpi_offset + 10_i8 * int(mpi_real_prec_size, i8)
277  call mpi_file_write_at_all(fh, mpi_offset, dtlag, 10, mpi_real_precision, status, ierr)
278  mpi_offset = mpi_offset + 10_i8 * int(mpi_real_prec_size, i8)
279  end if
280 
281  if (write_abvel) then
282  byte_offset = mpi_offset + &
283  dof_offset * int(mpi_real_prec_size, i8)
284  call mpi_file_write_at_all(fh, byte_offset, abx1%x, abx1%dof%size(), &
285  mpi_real_precision, status, ierr)
286  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
287  byte_offset = mpi_offset + &
288  dof_offset * int(mpi_real_prec_size, i8)
289  call mpi_file_write_at_all(fh, byte_offset, abx2%x, abx1%dof%size(), &
290  mpi_real_precision, status, ierr)
291  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
292  byte_offset = mpi_offset + &
293  dof_offset * int(mpi_real_prec_size, i8)
294  call mpi_file_write_at_all(fh, byte_offset, aby1%x, abx1%dof%size(), &
295  mpi_real_precision, status, ierr)
296  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
297  byte_offset = mpi_offset + &
298  dof_offset * int(mpi_real_prec_size, i8)
299  call mpi_file_write_at_all(fh, byte_offset, aby2%x, abx1%dof%size(), &
300  mpi_real_precision, status, ierr)
301  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
302  byte_offset = mpi_offset + &
303  dof_offset * int(mpi_real_prec_size, i8)
304  call mpi_file_write_at_all(fh, byte_offset, abz1%x, abx1%dof%size(), &
305  mpi_real_precision, status, ierr)
306  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
307  byte_offset = mpi_offset + &
308  dof_offset * int(mpi_real_prec_size, i8)
309  call mpi_file_write_at_all(fh, byte_offset, abz2%x, abx1%dof%size(), &
310  mpi_real_precision, status, ierr)
311  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
312  end if
313 
314  if (write_scalarlag) then
315  do i = 1, slag%size()
316  byte_offset = mpi_offset + &
317  dof_offset * int(mpi_real_prec_size, i8)
318  ! We should not need this extra associate block, ant it works
319  ! great without it for GNU, Intel, NEC and Cray, but throws an
320  ! ICE with NAG.
321  associate(x => slag%lf(i)%x)
322  call mpi_file_write_at_all(fh, byte_offset, x, &
323  slag%lf(i)%dof%size(), mpi_real_precision, status, ierr)
324  end associate
325  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
326  end do
327 
328  byte_offset = mpi_offset + &
329  dof_offset * int(mpi_real_prec_size, i8)
330  call mpi_file_write_at_all(fh, byte_offset, abs1%x, abx1%dof%size(), &
331  mpi_real_precision, status, ierr)
332  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
333  byte_offset = mpi_offset + &
334  dof_offset * int(mpi_real_prec_size, i8)
335  call mpi_file_write_at_all(fh, byte_offset, abs2%x, abx1%dof%size(), &
336  mpi_real_precision, status, ierr)
337  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
338  end if
339 
340  call mpi_file_close(fh, ierr)
341 
342  this%counter = this%counter + 1
343 
344  end subroutine chkp_file_write
345 
347  subroutine chkp_file_read(this, data)
348  class(chkp_file_t) :: this
349  class(*), target, intent(inout) :: data
350  type(chkp_t), pointer :: chkp
351  character(len=5) :: id_str
352  character(len=1024) :: fname
353  integer :: ierr, suffix_pos
354  type(field_t), pointer :: u, v, w, p, s
355  type(field_series_t), pointer :: ulag => null()
356  type(field_series_t), pointer :: vlag => null()
357  type(field_series_t), pointer :: wlag => null()
358  type(field_series_t), pointer :: slag => null()
359  type(mesh_t), pointer :: msh
360  type(mpi_status) :: status
361  type(mpi_file) :: fh
362  type(field_t), pointer :: abx1,abx2
363  type(field_t), pointer :: aby1,aby2
364  type(field_t), pointer :: abz1,abz2
365  type(field_t), pointer :: abs1,abs2
366  real(kind=rp), allocatable :: x_coord(:,:,:,:)
367  real(kind=rp), allocatable :: y_coord(:,:,:,:)
368  real(kind=rp), allocatable :: z_coord(:,:,:,:)
369  real(kind=rp), pointer :: dtlag(:), tlag(:)
370  integer (kind=MPI_OFFSET_KIND) :: mpi_offset, byte_offset
371  integer(kind=i8) :: n_glb_dofs, dof_offset
372  integer :: glb_nelv, gdim, lx, have_lag, have_scalar, nel, optional_fields, have_dtlag
373  integer :: have_abvel, have_scalarlag
374  logical :: read_lag, read_scalar, read_dtlag, read_abvel, read_scalarlag
375  real(kind=rp) :: tol
376  real(kind=rp) :: center_x, center_y, center_z
377  integer :: i, e
378  type(dofmap_t) :: dof
379 
380  call this%check_exists()
381 
382  select type(data)
383  type is (chkp_t)
384 
385  if ( .not. associated(data%u) .or. &
386  .not. associated(data%v) .or. &
387  .not. associated(data%w) .or. &
388  .not. associated(data%p) ) then
389  call neko_error('Checkpoint not initialized')
390  end if
391 
392  u => data%u
393  v => data%v
394  w => data%w
395  p => data%p
396  this%chkp_Xh => data%previous_Xh
398  if (allocated(data%previous_mesh%elements)) then
399  msh => data%previous_mesh
400  this%mesh2mesh = .true.
401  tol = data%mesh2mesh_tol
402  else
403  msh => u%msh
404  this%mesh2mesh = .false.
405  end if
406 
407  if (associated(data%ulag)) then
408  ulag => data%ulag
409  vlag => data%vlag
410  wlag => data%wlag
411  read_lag = .true.
412  else
413  read_lag = .false.
414  end if
415 
416  if (associated(data%s)) then
417  s => data%s
418  read_scalar = .true.
419  else
420  read_scalar = .false.
421  end if
422  if (associated(data%dtlag)) then
423  dtlag => data%dtlag
424  tlag => data%tlag
425  read_dtlag = .true.
426  else
427  read_dtlag = .false.
428  end if
429  read_abvel = .false.
430  if (associated(data%abx1)) then
431  abx1 => data%abx1
432  abx2 => data%abx2
433  aby1 => data%aby1
434  aby2 => data%aby2
435  abz1 => data%abz1
436  abz2 => data%abz2
437  read_abvel = .true.
438  end if
439  read_scalarlag = .false.
440  if (associated(data%abs1)) then
441  slag => data%slag
442  abs1 => data%abs1
443  abs2 => data%abs2
444  read_scalarlag = .true.
445  end if
446 
447  chkp => data
448 
449  class default
450  call neko_error('Invalid data')
451  end select
452 
453 
454 
455  call mpi_file_open(neko_comm, trim(this%fname), &
456  mpi_mode_rdonly, mpi_info_null, fh, ierr)
457  call mpi_file_read_all(fh, glb_nelv, 1, mpi_integer, status, ierr)
458  call mpi_file_read_all(fh, gdim, 1, mpi_integer, status, ierr)
459  call mpi_file_read_all(fh, lx, 1, mpi_integer, status, ierr)
460  call mpi_file_read_all(fh, optional_fields, 1, mpi_integer, status, ierr)
461  call mpi_file_read_all(fh, chkp%t, 1, mpi_double_precision, status, ierr)
462 
463  have_lag = mod(optional_fields,2)/1
464  have_scalar = mod(optional_fields,4)/2
465  have_dtlag = mod(optional_fields,8)/4
466  have_abvel = mod(optional_fields,16)/8
467  have_scalarlag = mod(optional_fields,32)/16
468 
469  if ( ( glb_nelv .ne. msh%glb_nelv ) .or. &
470  ( gdim .ne. msh%gdim) .or. &
471  ( (have_lag .eq. 0) .and. (read_lag) ) .or. &
472  ( (have_scalar .eq. 0) .and. (read_scalar) ) ) then
473  call neko_error('Checkpoint does not match case')
474  end if
475  nel = msh%nelv
476  this%sim_Xh => u%Xh
477  if (gdim .eq. 3) then
478  call this%chkp_Xh%init(gll, lx, lx, lx)
479  else
480  call this%chkp_Xh%init(gll, lx, lx)
481  end if
482  if (this%mesh2mesh) then
483  call dof%init(msh, this%chkp_Xh)
484  allocate(x_coord(u%Xh%lx,u%Xh%ly,u%Xh%lz,u%msh%nelv))
485  allocate(y_coord(u%Xh%lx,u%Xh%ly,u%Xh%lz,u%msh%nelv))
486  allocate(z_coord(u%Xh%lx,u%Xh%ly,u%Xh%lz,u%msh%nelv))
491  do e = 1, u%dof%msh%nelv
492  center_x = 0d0
493  center_y = 0d0
494  center_z = 0d0
495  do i = 1,u%dof%Xh%lxyz
496  center_x = center_x + u%dof%x(i,1,1,e)
497  center_y = center_y + u%dof%y(i,1,1,e)
498  center_z = center_z + u%dof%z(i,1,1,e)
499  end do
500  center_x = center_x/u%Xh%lxyz
501  center_y = center_y/u%Xh%lxyz
502  center_z = center_z/u%Xh%lxyz
503  do i = 1,u%dof%Xh%lxyz
504  x_coord(i,1,1,e) = u%dof%x(i,1,1,e) - tol*(u%dof%x(i,1,1,e)-center_x)
505  y_coord(i,1,1,e) = u%dof%y(i,1,1,e) - tol*(u%dof%y(i,1,1,e)-center_y)
506  z_coord(i,1,1,e) = u%dof%z(i,1,1,e) - tol*(u%dof%z(i,1,1,e)-center_z)
507  end do
508  end do
509  call this%global_interp%init(dof,tol=tol)
510  call this%global_interp%find_points(x_coord,y_coord,z_coord,u%dof%size())
511  deallocate(x_coord)
512  deallocate(y_coord)
513  deallocate(z_coord)
514  else
515  call this%space_interp%init(this%sim_Xh, this%chkp_Xh)
516  end if
517  dof_offset = int(msh%offset_el, i8) * int(this%chkp_Xh%lxyz, i8)
518  n_glb_dofs = int(this%chkp_Xh%lxyz, i8) * int(msh%glb_nelv, i8)
519 
520  !
521  ! Read mandatory checkpoint data
522  !
523 
524  byte_offset = 4_i8 * int(mpi_integer_size,i8) + int(mpi_double_precision_size,i8)
525  byte_offset = byte_offset + &
526  dof_offset * int(mpi_real_prec_size, i8)
527  call this%read_field(fh, byte_offset, u%x, nel)
528  mpi_offset = 4_i8 * int(mpi_integer_size,i8) + int(mpi_double_precision_size,i8)
529  mpi_offset = mpi_offset +&
530  n_glb_dofs * int(mpi_real_prec_size, i8)
531 
532  byte_offset = mpi_offset + &
533  dof_offset * int(mpi_real_prec_size, i8)
534  call this%read_field(fh, byte_offset, v%x, nel)
535  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
536 
537  byte_offset = mpi_offset + &
538  dof_offset * int(mpi_real_prec_size, i8)
539  call this%read_field(fh, byte_offset, w%x, nel)
540  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
541 
542  byte_offset = mpi_offset + &
543  dof_offset * int(mpi_real_prec_size, i8)
544  call this%read_field(fh, byte_offset, p%x, nel)
545  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
546 
547  !
548  ! Read optional payload
549  !
550 
551  if (read_lag) then
552  do i = 1, ulag%size()
553  byte_offset = mpi_offset + &
554  dof_offset * int(mpi_real_prec_size, i8)
555  call this%read_field(fh, byte_offset, ulag%lf(i)%x, nel)
556  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
557  end do
558 
559  do i = 1, vlag%size()
560  byte_offset = mpi_offset + &
561  dof_offset * int(mpi_real_prec_size, i8)
562  call this%read_field(fh, byte_offset, vlag%lf(i)%x, nel)
563  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
564  end do
565 
566  do i = 1, wlag%size()
567  byte_offset = mpi_offset + &
568  dof_offset * int(mpi_real_prec_size, i8)
569  call this%read_field(fh, byte_offset, wlag%lf(i)%x, nel)
570  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
571  end do
572  end if
573 
574  if (read_scalar) then
575  byte_offset = mpi_offset + &
576  dof_offset * int(mpi_real_prec_size, i8)
577  call this%read_field(fh, byte_offset, s%x, nel)
578  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
579  end if
580 
581  if (read_dtlag .and. have_dtlag .eq. 1) then
582  call mpi_file_read_at_all(fh, mpi_offset, tlag, 10, mpi_real_precision, status, ierr)
583  mpi_offset = mpi_offset + 10_i8 * int(mpi_real_prec_size, i8)
584  call mpi_file_read_at_all(fh, mpi_offset, dtlag, 10, mpi_real_precision, status, ierr)
585  mpi_offset = mpi_offset + 10_i8 * int(mpi_real_prec_size, i8)
586  end if
587 
588  if (read_abvel .and. have_abvel .eq. 1) then
589  byte_offset = mpi_offset + &
590  dof_offset * int(mpi_real_prec_size, i8)
591  call this%read_field(fh, byte_offset, abx1%x, nel)
592  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
593  byte_offset = mpi_offset + &
594  dof_offset * int(mpi_real_prec_size, i8)
595  call this%read_field(fh, byte_offset, abx2%x, nel)
596  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
597  byte_offset = mpi_offset + &
598  dof_offset * int(mpi_real_prec_size, i8)
599  call this%read_field(fh, byte_offset, aby1%x, nel)
600  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
601  byte_offset = mpi_offset + &
602  dof_offset * int(mpi_real_prec_size, i8)
603  call this%read_field(fh, byte_offset, aby2%x, nel)
604  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
605  byte_offset = mpi_offset + &
606  dof_offset * int(mpi_real_prec_size, i8)
607  call this%read_field(fh, byte_offset, abz1%x, nel)
608  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
609  byte_offset = mpi_offset + &
610  dof_offset * int(mpi_real_prec_size, i8)
611  call this%read_field(fh, byte_offset, abz2%x, nel)
612  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
613  end if
614  if (read_scalarlag .and. have_scalarlag .eq. 1) then
615  do i = 1, slag%size()
616  byte_offset = mpi_offset + &
617  dof_offset * int(mpi_real_prec_size, i8)
618  call this%read_field(fh, byte_offset, slag%lf(i)%x, nel)
619  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
620  end do
621  byte_offset = mpi_offset + &
622  dof_offset * int(mpi_real_prec_size, i8)
623  call this%read_field(fh, byte_offset, abs1%x, nel)
624  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
625  byte_offset = mpi_offset + &
626  dof_offset * int(mpi_real_prec_size, i8)
627  call this%read_field(fh, byte_offset, abs2%x, nel)
628  mpi_offset = mpi_offset + n_glb_dofs * int(mpi_real_prec_size, i8)
629  end if
630 
631  call mpi_file_close(fh, ierr)
632 
633  call this%global_interp%free()
634  call this%space_interp%free()
635 
636  end subroutine chkp_file_read
637 
638  subroutine chkp_read_field(this, fh, byte_offset, x, nel)
639  class(chkp_file_t) :: this
640  type(mpi_file) :: fh
641  integer(kind=MPI_OFFSET_KIND) :: byte_offset
642  integer, intent(in) :: nel
643  real(kind=rp) :: x(this%sim_Xh%lxyz, nel)
644  real(kind=rp), allocatable :: read_array(:)
645  integer :: nel_stride, frac_space
646  type(mpi_status) :: status
647  integer :: ierr, i, n
648 
649  n = this%chkp_xh%lxyz*nel
650  allocate(read_array(n))
651 
652  call rzero(read_array,n)
653  call mpi_file_read_at_all(fh, byte_offset, read_array, &
654  n, mpi_real_precision, status, ierr)
655  if (this%mesh2mesh) then
656  x = 0.0_rp
657  call this%global_interp%evaluate(x,read_array)
658 
659  else if (this%sim_Xh%lx .ne. this%chkp_Xh%lx) then
660  call this%space_interp%map_host(x, read_array, nel, this%sim_Xh)
661  else
662  do i = 1,n
663  x(i,1) = read_array(i)
664  end do
665  end if
666  deallocate(read_array)
667  end subroutine chkp_read_field
668 
669 end module chkp_file
real
double real
Definition: device_config.h:12
utils::neko_error
Definition: utils.f90:42
checkpoint
Defines a checkpoint.
Definition: checkpoint.f90:34
chkp_file
Neko checkpoint file format.
Definition: chkp_file.f90:35
chkp_file::chkp_file_write
subroutine chkp_file_write(this, data, t)
Write a Neko checkpoint.
Definition: chkp_file.f90:71
chkp_file::chkp_file_read
subroutine chkp_file_read(this, data)
Load a checkpoint from file.
Definition: chkp_file.f90:348
chkp_file::chkp_read_field
subroutine chkp_read_field(this, fh, byte_offset, x, nel)
Definition: chkp_file.f90:639
comm
Definition: comm.F90:1
comm::neko_comm
type(mpi_comm) neko_comm
MPI communicator.
Definition: comm.F90:16
comm::mpi_real_precision
type(mpi_datatype) mpi_real_precision
MPI type for working precision of REAL types.
Definition: comm.F90:23
device_math
Definition: device_math.F90:33
dofmap
Defines a mapping of the degrees of freedom.
Definition: dofmap.f90:35
field_series
Stores a series fields.
Definition: field_series.f90:34
field
Defines a field.
Definition: field.f90:34
generic_file
Definition: generic_file.f90:33
global_interpolation
Implements global_interpolation given a dofmap.
Definition: global_interpolation.F90:38
interpolation
Routines to interpolate between different spaces.
Definition: interpolation.f90:34
math
Definition: math.f90:60
mesh
Defines a mesh.
Definition: mesh.f90:34
neko_mpi_types
MPI derived types.
Definition: mpi_types.f90:34
neko_mpi_types::mpi_double_precision_size
integer, public mpi_double_precision_size
Size of MPI type double precision.
Definition: mpi_types.f90:61
neko_mpi_types::mpi_real_prec_size
integer, public mpi_real_prec_size
Size of working precision REAL types.
Definition: mpi_types.f90:65
neko_mpi_types::mpi_integer_size
integer, public mpi_integer_size
Size of MPI type integer.
Definition: mpi_types.f90:63
num_types
Definition: num_types.f90:1
num_types::i8
integer, parameter, public i8
Definition: num_types.f90:7
num_types::dp
integer, parameter, public dp
Definition: num_types.f90:9
num_types::rp
integer, parameter, public rp
Global precision used in computations.
Definition: num_types.f90:12
space
Defines a function space.
Definition: space.f90:34
utils
Utilities.
Definition: utils.f90:35
utils::filename_suffix_pos
pure integer function, public filename_suffix_pos(fname)
Find position (in the string) of a filename's suffix.
Definition: utils.f90:56
checkpoint::chkp_t
Definition: checkpoint.f90:46
chkp_file::chkp_file_t
Interface for Neko checkpoint files.
Definition: chkp_file.f90:55
dofmap::dofmap_t
Definition: dofmap.f90:53
field::field_t
Definition: field.f90:46
field_series::field_series_t
Definition: field_series.f90:40
generic_file::generic_file_t
A generic file handler.
Definition: generic_file.f90:38
global_interpolation::global_interpolation_t
Implements global interpolation for arbitrary points in the domain.
Definition: global_interpolation.F90:54
interpolation::interpolator_t
Interpolation between two space::space_t.
Definition: interpolation.f90:51
mesh::mesh_t
Definition: mesh.f90:64
space::space_t
The function space for the SEM solution fields.
Definition: space.f90:62