build/source/actors/file_access_actor/initOutputStruc.f90

-module summaActors_initOutputStruct
-  USE nrtype
-  implicit none
-  public::initalizeOutput
-  contains
-
-subroutine initalizeOutput(forcFileInfo, maxSteps, nGRU, err)
-  USE globalData,only:outputStructure
-  USE globalData,only:time_meta,forc_meta,attr_meta,type_meta ! metadata structures
-  USE globalData,only:prog_meta,diag_meta,flux_meta,id_meta   ! metadata structures
-  USE globalData,only:mpar_meta,indx_meta                     ! metadata structures
-  USE globalData,only:bpar_meta,bvar_meta                     ! metadata structures
-  USE globalData,only:statForc_meta                           ! child metadata for stats
-  USE globalData,only:statProg_meta                           ! child metadata for stats
-  USE globalData,only:statDiag_meta                           ! child metadata for stats
-  USE globalData,only:statFlux_meta                           ! child metadata for stats
-  USE globalData,only:statIndx_meta                           ! child metadata for stats
-  USE globalData,only:statBvar_meta                           ! child metadata for stats
-  USE globalData,only:gru_struc
-  USE globalData,only:structInfo                              ! information on the data structures
-  USE alloc_file_access,only:alloc_outputStruc
-  USE multiconst,only:secprday               ! number of seconds in a day
-  USE data_types,only:file_info_array
-  USE var_lookup,only:maxvarFreq                ! maximum number of output files
-  
-  implicit none
-  type(file_info_array), pointer        :: forcFileInfo
-  integer(i4b), intent(in)              :: maxSteps
-  integer(i4b), intent(in)              :: nGRU
-  integer(i4b), intent(inout)           :: err 
-
-  ! local variables
-  integer(i4b)                          :: nVars
-  integer(i4b)                          :: iGRU
-  integer(i4b)                          :: iStep
-  integer(i4b)                          :: nSnow
-  integer(i4b)                          :: nSoil
-  integer(i4b)                          :: iStruct
-  character(len=256)                    :: message
-
-  ! Allocate structure to hold output files
-  if (.not.allocated(outputStructure))then
-    allocate(outputStructure(1))
-  end if
-  ! Statistics Structures
-  allocate(outputStructure(1)%forcStat(1))
-  allocate(outputStructure(1)%forcStat(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%progStat(1))
-  allocate(outputStructure(1)%progStat(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%diagStat(1))
-  allocate(outputStructure(1)%diagStat(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%fluxStat(1))
-  allocate(outputStructure(1)%fluxStat(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%indxStat(1))
-  allocate(outputStructure(1)%indxStat(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%bvarStat(1))
-  allocate(outputStructure(1)%bvarStat(1)%gru(nGRU))
-  ! Primary Data Structures (scalars)
-  allocate(outputStructure(1)%timeStruct(1))
-  allocate(outputStructure(1)%timeStruct(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%forcStruct(1))
-  allocate(outputStructure(1)%forcStruct(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%attrStruct(1))
-  allocate(outputStructure(1)%attrStruct(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%typeStruct(1))
-  allocate(outputStructure(1)%typeStruct(1)%gru(nGRU))
-
-  allocate(outputStructure(1)%idStruct(1))
-  allocate(outputStructure(1)%idStruct(1)%gru(nGRU))
-  ! Primary Data Structures (variable length vectors)
-  allocate(outputStructure(1)%indxStruct(1))
-  allocate(outputStructure(1)%mparStruct(1))
-  allocate(outputStructure(1)%progStruct(1))
-  allocate(outputStructure(1)%diagStruct(1))
-  allocate(outputStructure(1)%fluxStruct(1))
-  allocate(outputStructure(1)%indxStruct(1)%gru(nGRU))
-  allocate(outputStructure(1)%mparStruct(1)%gru(nGRU))
-  allocate(outputStructure(1)%progStruct(1)%gru(nGRU))
-  allocate(outputStructure(1)%diagStruct(1)%gru(nGRU))
-  allocate(outputStructure(1)%fluxStruct(1)%gru(nGRU))
-  ! Basin-Average structures
-  allocate(outputStructure(1)%bparStruct(1))
-  allocate(outputStructure(1)%bvarStruct(1))
-  allocate(outputStructure(1)%bparStruct(1)%gru(nGRU))
-  allocate(outputStructure(1)%bvarStruct(1)%gru(nGRU))
-  ! Finalize Stats for writing
-  allocate(outputStructure(1)%finalizeStats(1))
-  allocate(outputStructure(1)%finalizeStats(1)%gru(nGRU))
-  !
-  ! Allocate space for HRUs
-  !
-  do iGRU = 1, nGRU
-
-    ! Get the maximum number of steps needed to initalize the output structure
-    nVars = maxval(forcFileInfo%ffile_list(:)%nVars)
-    nSnow = gru_struc(iGRU)%hruInfo(1)%nSnow
-    nSoil = gru_struc(iGRU)%hruInfo(1)%nSoil
-
-    do iStruct=1,size(structInfo)
-      ! allocate space structures
-      select case(trim(structInfo(iStruct)%structName))    
-        case('time')
-          allocate(outputStructure(1)%timeStruct(1)%gru(iGRU)%hru(1)) 
-          call alloc_outputStruc(time_meta,outputStructure(1)%timeStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,err=err,message=message)     ! model forcing data
-        case('forc')
-          allocate(outputStructure(1)%forcStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(forc_meta,outputStructure(1)%forcStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! model forcing data
-        case('attr')
-          allocate(outputStructure(1)%attrStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(attr_meta,outputStructure(1)%attrStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! local attributes for each HRU
-        case('type')
-          allocate(outputStructure(1)%typeStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(type_meta,outputStructure(1)%typeStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! classification of soil veg etc.
-        case('id'  )
-          allocate(outputStructure(1)%idStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(id_meta,outputStructure(1)%idStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);        ! local values of hru and gru IDs
-        case('mpar')
-          allocate(outputStructure(1)%mparStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(mpar_meta,outputStructure(1)%mparStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! model parameters
-        case('indx')
-          allocate(outputStructure(1)%indxStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(indx_meta,outputStructure(1)%indxStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! model variables
-        case('prog')
-          allocate(outputStructure(1)%progStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(prog_meta,outputStructure(1)%progStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! model prognostic (state) variables
-        case('diag')
-          allocate(outputStructure(1)%diagStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(diag_meta,outputStructure(1)%diagStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! model diagnostic variables
-        case('flux')
-          allocate(outputStructure(1)%fluxStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(flux_meta,outputStructure(1)%fluxStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow,nSoil,err,message);    ! model fluxes
-        case('bpar')
-          call alloc_outputStruc(bpar_meta,outputStructure(1)%bparStruct(1)%gru(iGRU), &
-                        maxSteps,nSnow=0,nSoil=0,err=err,message=message);  ! basin-average params 
-        case('bvar')
-          allocate(outputStructure(1)%bvarStruct(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(bvar_meta,outputStructure(1)%bvarStruct(1)%gru(iGRU)%hru(1), &
-                        maxSteps,nSnow=0,nSoil=0,err=err,message=message);  ! basin-average variables
-        case('deriv'); cycle
-        case default; err=20; message='unable to find structure name: '//trim(structInfo(iStruct)%structName)
-      end select
-      ! check errors
-      if(err/=0)then
-        message=trim(message)//'[structure =  '//trim(structInfo(iStruct)%structName)//']'
-        return
-      endif
-    end do  ! looping through data structures
-
-    do iStruct=1,size(structInfo)
-
-      ! allocate space for statistics structures
-      select case(trim(structInfo(iStruct)%structName))
-        case('forc')
-          allocate(outputStructure(1)%forcStat(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(statForc_meta(:)%var_info,outputStructure(1)%forcStat(1)%gru(iGRU)%hru(1), &
-                                maxSteps,nSnow,nSoil,err,message);    ! model forcing data
-        case('prog')
-          allocate(outputStructure(1)%progStat(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(statProg_meta(:)%var_info,outputStructure(1)%progStat(1)%gru(iGRU)%hru(1), &
-                                maxSteps,nSnow,nSoil,err,message);    ! model prognostic 
-        case('diag')
-          allocate(outputStructure(1)%diagStat(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(statDiag_meta(:)%var_info,outputStructure(1)%diagStat(1)%gru(iGRU)%hru(1), &
-                                maxSteps,nSnow,nSoil,err,message);    ! model diagnostic
-        case('flux')
-          allocate(outputStructure(1)%fluxStat(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(statFlux_meta(:)%var_info,outputStructure(1)%fluxStat(1)%gru(iGRU)%hru(1), &
-                                maxSteps,nSnow,nSoil,err,message);    ! model fluxes
-        case('indx')
-          allocate(outputStructure(1)%indxStat(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(statIndx_meta(:)%var_info,outputStructure(1)%indxStat(1)%gru(iGRU)%hru(1), &
-                                maxSteps,nSnow,nSoil,err,message);    ! index vars
-        case('bvar')
-          allocate(outputStructure(1)%bvarStat(1)%gru(iGRU)%hru(1))
-          call alloc_outputStruc(statBvar_meta(:)%var_info,outputStructure(1)%bvarStat(1)%gru(iGRU)%hru(1), &
-                                maxSteps,nSnow=0,nSoil=0,err=err,message=message);  ! basin-average variables
-        case default; cycle
-      end select
-    
-      ! check errors
-      if(err/=0)then
-        message=trim(message)//'[statistics for =  '//trim(structInfo(iStruct)%structName)//']'
-        return
-      endif
-    
-    end do ! iStruct
-    ! Finalize stats structure for writing to output file
-    allocate(outputStructure(1)%finalizeStats(1)%gru(iGRU)%hru(1))
-    allocate(outputStructure(1)%finalizeStats(1)%gru(iGRU)%hru(1)%tim(maxSteps))
-    do iStep = 1, maxSteps
-      allocate(outputStructure(1)%finalizeStats(1)%gru(iGRU)%hru(1)%tim(iStep)%dat(1:maxVarFreq))
-    end do ! timeSteps
-  end do ! Looping through GRUs
-
-
-end subroutine initalizeOutput
-
-
-end module
\ No newline at end of file

build/source/actors/file_access_actor/output_container.cpp

+#include "output_container.hpp"
+
+
+//###################################################################
+// Output_Partition
+//###################################################################
+Output_Partition::Output_Partition(int start_local_gru_index, int num_local_grus, int num_timesteps_simulation, int num_stored_timesteps) {
+    this->start_local_gru_index = start_local_gru_index;
+    this->num_local_grus = num_local_grus;
+    this->num_timesteps_simulation = num_timesteps_simulation;
+    this->num_stored_timesteps = num_stored_timesteps;
+    this->end_local_gru_index = start_local_gru_index + num_local_grus - 1;
+    this->num_active_grus = num_local_grus;
+
+}
+
+Output_Partition::~Output_Partition() {
+    // TODO Auto-generated destructor stub
+}
+
+void Output_Partition::setGRUReadyToWrite(caf::actor gru_actor) {
+    this->ready_to_write_list.push_back(gru_actor);
+}
+
+bool Output_Partition::isReadyToWrite() {
+    return this->ready_to_write_list.size() == this->num_active_grus;
+}
+
+int Output_Partition::getMaxGRUIndex() {
+    return this->end_local_gru_index;
+}
+
+int Output_Partition::getNumStoredTimesteps() {
+    return this->num_stored_timesteps;
+}
+
+int Output_Partition::getStartGRUIndex() {
+    return this->start_local_gru_index;
+}
+
+void Output_Partition::updateTimeSteps() {
+    
+    // Update the number of timesteps remaining in the simulation
+    this->num_timesteps_simulation -= this->num_stored_timesteps;
+    
+    // Reset the number of timesteps to store for the next run
+    if (this->num_timesteps_simulation < this->num_stored_timesteps) {
+        this->num_stored_timesteps = this->num_timesteps_simulation;
+    }
+
+}
+
+std::vector<caf::actor> Output_Partition::getReadyToWriteList() {
+    return this->ready_to_write_list;
+}
+
+void Output_Partition::resetReadyToWriteList() {
+    this->ready_to_write_list.clear();
+}
+
+void Output_Partition::addFailedGRUIndex(int local_gru_index) {
+
+    // Special case where the failing GRU is the last or first GRU in the partition
+    // This will affect writing of output if a failed GRU is the last or first GRU
+    if (local_gru_index == this->end_local_gru_index) {
+        this->end_local_gru_index -= 1;
+    } else if (local_gru_index == this->start_local_gru_index) {
+        this->start_local_gru_index += 1;
+    }
+
+    this->num_active_grus -= 1;
+
+    this->failed_gru_index_list.push_back(local_gru_index);
+}
+
+int Output_Partition::getNumActiveGRUs() {
+    return this->num_active_grus;
+}
+
+int Output_Partition::getNumLocalGRUs() {
+    return this->num_local_grus;
+}
+
+int Output_Partition::getRemainingTimesteps() {
+    return this->num_timesteps_simulation;
+}
+
+std::vector<int> Output_Partition::getFailedGRUIndexList() {
+    return this->failed_gru_index_list;
+}
+
+bool Output_Partition::isWriteParams() {
+    if (this->write_params) {
+        this->write_params = false;
+        return true;
+    }
+    return this->write_params;
+}
+
+
+//###################################################################
+// Output_Container
+//###################################################################
+
+Output_Container::Output_Container(int num_partitions, int num_grus, int num_stored_timesteps, int num_timesteps_simulation) {
+    this->num_grus = num_grus;
+    this->num_timesteps_simulation = num_timesteps_simulation;
+    this->num_stored_timesteps = num_stored_timesteps;
+
+    // Set the number of partitions - avoiding division with a remainder
+    if (num_partitions > num_grus) {
+        this->num_partitions = num_grus;
+    } else {
+        this->num_partitions = num_partitions;
+    }
+
+    // Initialize the output partitions
+    int start_gru_counter = 1;
+    this->num_grus_per_partition = std::round(this->num_grus / this->num_partitions);
+    for (int i = 0; i < num_partitions - 1; i++) {
+        this->output_partitions.push_back(new Output_Partition(start_gru_counter, this->num_grus_per_partition, this->num_timesteps_simulation, this->num_stored_timesteps));
+        start_gru_counter += this->num_grus_per_partition;
+    }
+    // The last partition will have the remainder of the GRUs
+    this->output_partitions.push_back(new Output_Partition(start_gru_counter, this->num_grus - start_gru_counter + 1, this->num_timesteps_simulation, this->num_stored_timesteps));
+}
+
+Output_Container::~Output_Container() {
+
+    for (int i = 0; i < this->num_partitions; i++) {
+        delete this->output_partitions[i];
+    }
+}
+
+Output_Partition* Output_Container::getOutputPartition(int local_gru_index) {
+    int partition_index = this->findPartition(local_gru_index);
+    return this->output_partitions[partition_index];
+}
+
+int Output_Container::findPartition(int local_gru_index) {
+    // If we are not rerunning failed GRUs, then the partition index can be found within a block of GRUs
+    if (!this->rerunning_failed_hrus) {
+        int partition_index = (local_gru_index - 1) / this->num_grus_per_partition;
+        // correct the value if too large (more than the number of partitions)
+        if (partition_index > this->num_partitions - 1) {
+            partition_index = this->num_partitions - 1;
+        }
+        return partition_index;
+    } else {
+        // If we are rerunning failed GRUs, they may not be grouped in blocks, so we need to use the failed GRU index list
+        std::vector<int>::iterator it = std::find(this->failed_gru_index_list.begin(), this->failed_gru_index_list.end(), local_gru_index);
+        if (it != this->failed_gru_index_list.end()) {
+            return std::distance(this->failed_gru_index_list.begin(), it);
+        } else {
+            throw std::runtime_error("GRU index not found in failed GRU index list");
+        }
+    }
+
+ 
+}
+
+int Output_Container::getNumPartitions() {
+    return this->num_partitions;
+}
+
+std::vector<int> Output_Container::getFailedGRUIndexList() {
+    return this->failed_gru_index_list;
+}
+
+void Output_Container::reconstruct() {
+
+    this->failed_gru_index_list;
+
+    // Loop over all partitions getting the failed GRU index list
+    for (int i = 0; i < this->num_partitions; i++) {
+        std::vector<int> partition_failed_gru_index_list = this->output_partitions[i]->getFailedGRUIndexList();
+        failed_gru_index_list.insert(
+            failed_gru_index_list.end(), 
+            partition_failed_gru_index_list.begin(), 
+            partition_failed_gru_index_list.end());
+        delete this->output_partitions[i];
+    }
+    this->output_partitions.clear();
+
+    std::sort(this->failed_gru_index_list.begin(), this->failed_gru_index_list.end());
+    // Reconstruct the output partitions
+    this->num_partitions = failed_gru_index_list.size();
+    this->num_grus = failed_gru_index_list.size();
+    this->num_grus_per_partition = 1;
+    for (int i = 0; i < failed_gru_index_list.size(); i++){
+        this->output_partitions.push_back(new 
+            Output_Partition(failed_gru_index_list[i], 1, 
+                            this->num_timesteps_simulation, 
+                            this->num_stored_timesteps));
+    }
+
+    this->rerunning_failed_hrus = true;
+}
+
+

build/source/actors/file_access_actor/summaversion.inc

+character(len=64), parameter     :: summaVersion = ''
+character(len=64), parameter     :: buildTime = ''
+character(len=64), parameter     :: gitBranch = ''
+character(len=64), parameter     :: gitHash = ''
\ No newline at end of file