separate files for buffer implementations

Author: wpbonelli

msvs/mf6core.vfproj

@@ -585,6 +585,9 @@
 				<File RelativePath="..\src\Solution\ParticleTracker\Particle\Events\ParticleEvent.f90"/>
 				<File RelativePath="..\src\Solution\ParticleTracker\Particle\Events\ParticleEvents.f90"/>
 				<File RelativePath="..\src\Solution\ParticleTracker\Particle\ParticleReleaseSchedule.f90"/>
+				<File RelativePath="..\src\Solution\ParticleTracker\Particle\ParticleTrackEventBuffer.f90"/>
+				<File RelativePath="..\src\Solution\ParticleTracker\Particle\MemoryBuffer.f90"/>
+				<File RelativePath="..\src\Solution\ParticleTracker\Particle\ScratchFileBuffer.f90"/>
 				<File RelativePath="..\src\Solution\ParticleTracker\Particle\ParticleTracks.f90"/>
 				<File RelativePath="..\src\Solution\ParticleTracker\Particle\Events\ReleaseEvent.f90"/>
 				<File RelativePath="..\src\Solution\SolutionFactory.F90">

src/Solution/ParticleTracker/Particle/MemoryBuffer.f90

@@ -0,0 +1,71 @@
+!> @brief In-memory particle event buffer module.
+!<
+module MemoryBufferModule
+
+  use KindModule, only: I4B
+  use ParticleTrackEventBufferModule, only: ParticleTrackEventBufferType, &
+                                            TrackRecordType, &
+                                            ParticleTrackFileType, &
+                                            save_record
+
+  implicit none
+  private
+  public :: MemoryBufferType
+
+  !> @brief In-memory particle event buffer. Records are held in a
+  !! dynamically growing array that doubles in capacity as needed.
+  type, extends(ParticleTrackEventBufferType) :: MemoryBufferType
+    type(TrackRecordType), allocatable :: records(:) !< buffer
+  contains
+    procedure :: append => memory_append
+    procedure :: flush => memory_flush
+    procedure :: discard => memory_discard
+    procedure :: destroy => memory_destroy
+  end type MemoryBufferType
+
+contains
+
+  subroutine memory_append(this, rec)
+    class(MemoryBufferType) :: this
+    type(TrackRecordType), intent(in) :: rec
+    type(TrackRecordType), allocatable :: tmp(:)
+
+    if (.not. allocated(this%records)) then
+      allocate (this%records(64))
+    else if (this%nrecords == size(this%records)) then
+      allocate (tmp(size(this%records) * 2))
+      tmp(1:this%nrecords) = this%records
+      call move_alloc(tmp, this%records)
+    end if
+    this%nrecords = this%nrecords + 1
+    this%records(this%nrecords) = rec
+  end subroutine memory_append
+
+  subroutine memory_flush(this, files)
+    class(MemoryBufferType) :: this
+    type(ParticleTrackFileType), intent(in) :: files(:)
+    integer(I4B) :: n, i
+    type(TrackRecordType) :: rec
+
+    do n = 1, this%nrecords
+      rec = this%records(n)
+      do i = 1, size(files)
+        if (files(i)%iun > 0 .and. &
+            (files(i)%iprp == -1 .or. files(i)%iprp == rec%iprp)) &
+          call save_record(files(i)%iun, rec, files(i)%csv)
+      end do
+    end do
+    this%nrecords = 0
+  end subroutine memory_flush
+
+  subroutine memory_discard(this)
+    class(MemoryBufferType) :: this
+    this%nrecords = 0
+  end subroutine memory_discard
+
+  subroutine memory_destroy(this)
+    class(MemoryBufferType) :: this
+    if (allocated(this%records)) deallocate (this%records)
+  end subroutine memory_destroy
+
+end module MemoryBufferModule

src/Solution/ParticleTracker/Particle/ParticleTrackEventBuffer.f90

@@ -0,0 +1,98 @@
+!> @brief Particle track event buffer module.
+!!
+!! Defines the abstract ParticleTrackEventBufferType, the TrackRecordType
+!! and ParticleTrackFileType data types, and the save_record helper used
+!! by concrete buffer implementations.
+!<
+module ParticleTrackEventBufferModule
+
+  use KindModule, only: DP, I4B, LGP
+  use ErrorUtilModule, only: pstop
+
+  implicit none
+
+  character(len=*), parameter, public :: TRACKHEADER = &
+    'kper,kstp,imdl,iprp,irpt,ilay,icell,izone,&
+    &istatus,ireason,trelease,t,x,y,z,name'
+
+  character(len=*), parameter, public :: TRACKDTYPES = &
+    '<i4,<i4,<i4,<i4,<i4,<i4,<i4,<i4,&
+    &<i4,<i4,<f8,<f8,<f8,<f8,<f8,|S40'
+
+  !> @brief Flat record of a particle track event.
+  type :: TrackRecordType
+    integer(I4B) :: kper, kstp, imdl, iprp, irpt, ilay, icu, izone
+    integer(I4B) :: istatus, ireason
+    real(DP) :: trelease, ttrack, x, y, z
+    character(len=40) :: name
+  end type TrackRecordType
+
+  !> @brief Output file containing all or some particle pathlines.
+  !!
+  !! Can be associated with a particle release point (PRP) package
+  !! or with an entire model, and can be binary or text (CSV).
+  !<
+  type :: ParticleTrackFileType
+    private
+    integer(I4B), public :: iun = 0 !< file unit number
+    logical(LGP), public :: csv = .false. !< whether the file is binary or CSV
+    integer(I4B), public :: iprp = -1 !< -1 is model-level file, 0 is exchange PRP
+  end type ParticleTrackFileType
+
+  !> @brief Event buffering strategy
+  type, abstract :: ParticleTrackEventBufferType
+    integer(I4B) :: nrecords = 0 !< number of records stored
+  contains
+    procedure :: init => buffer_init !< open/allocate resources
+    procedure(buffer_append), deferred :: append !< buffer one record
+    procedure(buffer_flush), deferred :: flush !< write buffered records, reset
+    procedure(buffer_simple), deferred :: discard !< reset without writing
+    procedure(buffer_simple), deferred :: destroy !< release resources
+  end type ParticleTrackEventBufferType
+
+  abstract interface
+    subroutine buffer_append(this, rec)
+      import ParticleTrackEventBufferType, TrackRecordType
+      class(ParticleTrackEventBufferType) :: this
+      type(TrackRecordType), intent(in) :: rec
+    end subroutine buffer_append
+
+    subroutine buffer_flush(this, files)
+      import ParticleTrackEventBufferType, ParticleTrackFileType
+      class(ParticleTrackEventBufferType) :: this
+      type(ParticleTrackFileType), intent(in) :: files(:)
+    end subroutine buffer_flush
+
+    ! Shared interface for discard and destroy: both take only `this`.
+    subroutine buffer_simple(this)
+      import ParticleTrackEventBufferType
+      class(ParticleTrackEventBufferType) :: this
+    end subroutine buffer_simple
+  end interface
+
+contains
+
+  subroutine buffer_init(this)
+    class(ParticleTrackEventBufferType) :: this
+  end subroutine buffer_init
+
+  !> @brief Save an event record to a binary or CSV file.
+  subroutine save_record(iun, rec, csv)
+    integer(I4B), intent(in) :: iun
+    type(TrackRecordType), intent(in) :: rec
+    logical(LGP), intent(in) :: csv
+
+    if (csv) then
+      write (iun, '(*(G0,:,","))') &
+        rec%kper, rec%kstp, rec%imdl, rec%iprp, rec%irpt, &
+        rec%ilay, rec%icu, rec%izone, rec%istatus, rec%ireason, &
+        rec%trelease, rec%ttrack, rec%x, rec%y, rec%z, trim(rec%name)
+    else
+      write (iun) &
+        rec%kper, rec%kstp, rec%imdl, rec%iprp, rec%irpt, &
+        rec%ilay, rec%icu, rec%izone, rec%istatus, rec%ireason, &
+        rec%trelease, rec%ttrack, rec%x, rec%y, rec%z, rec%name
+    end if
+  end subroutine save_record
+
+end module ParticleTrackEventBufferModule