<p><b>dwj07@fsu.edu</b> 2012-06-01 16:36:15 -0600 (Fri, 01 Jun 2012)</p><p><br>
        -- BRANCH COMMIT --<br>
<br>
        Cleaning up mpas_io_output.F, and making the output index conversion more efficient.<br>
<br>
        Fixing some divide-by-zero issues in core ocean.<br>
<br>
        Ocean core runs with RK4 and 2 blocks on 1 processor now.<br>
</p><hr noshade><pre><font color="gray">Modified: branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_advection.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_advection.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_advection.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -275,12 +275,21 @@
   
             iEdge = grid % EdgesOnCell % array (i,iCell)
 
-            xv1 = grid % xVertex % array(grid % verticesOnEdge % array (1,iedge))/grid % sphere_radius
-            yv1 = grid % yVertex % array(grid % verticesOnEdge % array (1,iedge))/grid % sphere_radius
-            zv1 = grid % zVertex % array(grid % verticesOnEdge % array (1,iedge))/grid % sphere_radius
-            xv2 = grid % xVertex % array(grid % verticesOnEdge % array (2,iedge))/grid % sphere_radius
-            yv2 = grid % yVertex % array(grid % verticesOnEdge % array (2,iedge))/grid % sphere_radius
-            zv2 = grid % zVertex % array(grid % verticesOnEdge % array (2,iedge))/grid % sphere_radius
+            if(grid % on_a_sphere) then
+              xv1 = grid % xVertex % array(grid % verticesOnEdge % array (1,iedge))/grid % sphere_radius
+              yv1 = grid % yVertex % array(grid % verticesOnEdge % array (1,iedge))/grid % sphere_radius
+              zv1 = grid % zVertex % array(grid % verticesOnEdge % array (1,iedge))/grid % sphere_radius
+              xv2 = grid % xVertex % array(grid % verticesOnEdge % array (2,iedge))/grid % sphere_radius
+              yv2 = grid % yVertex % array(grid % verticesOnEdge % array (2,iedge))/grid % sphere_radius
+              zv2 = grid % zVertex % array(grid % verticesOnEdge % array (2,iedge))/grid % sphere_radius
+            else
+              xv1 = grid % xVertex % array(grid % verticesOnEdge % array (1,iedge))
+              yv1 = grid % yVertex % array(grid % verticesOnEdge % array (1,iedge))
+              zv1 = grid % zVertex % array(grid % verticesOnEdge % array (1,iedge))
+              xv2 = grid % xVertex % array(grid % verticesOnEdge % array (2,iedge))
+              yv2 = grid % yVertex % array(grid % verticesOnEdge % array (2,iedge))
+              zv2 = grid % zVertex % array(grid % verticesOnEdge % array (2,iedge))
+            end if
   
             if ( grid % on_a_sphere ) then
                call ocn_arc_bisect( xv1, yv1, zv1,  &amp;

Modified: branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_tendency.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_tendency.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_tendency.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -947,7 +947,10 @@
               h_tend_col(k) = - zstarWeight(k)*h(k,iCell)*div_hu_btr(iCell)
               hSum = hSum + zstarWeight(k)*h(k,iCell)
            end do
-           h_tend_col = h_tend_col / hSum
+           if(hSum &gt; 0.0) then
+             h_tend_col = h_tend_col / hSum
+           else
+           end if
 
            ! Vertical velocity through layer interface at top and 
            ! bottom is zero.

Modified: branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_time_average.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_time_average.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_time_average.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -116,14 +116,16 @@
         acc_u =&gt; state % acc_u % array
         acc_uVar =&gt; state % acc_uVar % array
 
-        acc_ssh = acc_ssh / nAccumulate
-        acc_sshVar = acc_sshVar / nAccumulate
-        acc_uReconstructZonal = acc_uReconstructZonal / nAccumulate
-        acc_uReconstructMeridional = acc_uReconstructMeridional / nAccumulate
-        acc_uReconstructZonalVar = acc_uReconstructZonalVar / nAccumulate
-        acc_uReconstructMeridionalVar = acc_uReconstructMeridionalVar / nAccumulate
-        acc_u = acc_u / nAccumulate
-        acc_uVar = acc_uVar / nAccumulate
+        if(nAccumulate &gt; 0) then
+          acc_ssh = acc_ssh / nAccumulate
+          acc_sshVar = acc_sshVar / nAccumulate
+          acc_uReconstructZonal = acc_uReconstructZonal / nAccumulate
+          acc_uReconstructMeridional = acc_uReconstructMeridional / nAccumulate
+          acc_uReconstructZonalVar = acc_uReconstructZonalVar / nAccumulate
+          acc_uReconstructMeridionalVar = acc_uReconstructMeridionalVar / nAccumulate
+          acc_u = acc_u / nAccumulate
+          acc_uVar = acc_uVar / nAccumulate
+        end if
     end subroutine ocn_time_average_normalize!}}}
 
 end module ocn_time_average

Modified: branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_time_integration_split.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_time_integration_split.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/core_ocean/mpas_ocn_time_integration_split.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -419,7 +419,7 @@
                    flux = ((1.0-config_btr_gam1_uWt1) * block % state % time_levs(oldBtrSubcycleTime) % state % uBtrSubcycle % array(iEdge) &amp;
                           + config_btr_gam1_uWt1 * block % state % time_levs(newBtrSubcycleTime) % state % uBtrSubcycle % array(iEdge)) &amp;
                           * hSum 
-      
+
                    block % tend % ssh % array(cell1) = block % tend % ssh % array(cell1) - flux * block % mesh % dvEdge % array(iEdge)
                    block % tend % ssh % array(cell2) = block % tend % ssh % array(cell2) + flux * block % mesh % dvEdge % array(iEdge) 
       

Modified: branches/omp_blocks/multiple_blocks/src/framework/mpas_io_input.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/framework/mpas_io_input.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/framework/mpas_io_input.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -328,8 +328,10 @@
       end if
 
       write(6,*) 'Copy attributes to other blocks.'
-      block_ptr =&gt; domain % blocklist
+      block_ptr =&gt; domain % blocklist % next
       do while (associated(block_ptr))
+        write(6,*) 'Setting sphere radius =', domain % blocklist % mesh % sphere_radius
+        write(6,*) 'Setting on a sphere = ',domain % blocklist % mesh % on_a_sphere
         block_ptr % mesh % sphere_radius = domain % blocklist % mesh % sphere_radius
         block_ptr % mesh % on_a_sphere = domain % blocklist % mesh % on_a_sphere
 

Modified: branches/omp_blocks/multiple_blocks/src/framework/mpas_io_output.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/framework/mpas_io_output.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/framework/mpas_io_output.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -102,30 +102,18 @@
 
       type(block_type), pointer :: block_ptr
 
+      integer :: nCells, nEdges, nVertices, vertexDegree
+      integer :: maxEdges, maxEdges2, nEdgesSolve, nCellsSolve, nVerticesSolve
       integer :: ierr
       integer :: i, j
-      integer, dimension(:,:), pointer :: cellsOnCell, edgesOnCell, verticesOnCell, &amp;
-                                          cellsOnEdge, verticesOnEdge, edgesOnEdge, cellsOnVertex, edgesOnVertex
-      integer, dimension(:,:), pointer :: cellsOnCell_save, edgesOnCell_save, verticesOnCell_save, &amp;
-                                          cellsOnEdge_save, verticesOnEdge_save, edgesOnEdge_save, &amp;
-                                          cellsOnVertex_save, edgesOnVertex_save
-      type (field2dInteger), target :: cellsOnCell1_save, edgesOnCell1_save, verticesOnCell1_save, &amp;
-                               cellsOnEdge1_save, verticesOnEdge1_save, edgesOnEdge1_save, &amp;
-                               cellsOnVertex1_save, edgesOnVertex1_save
+      type (field2dInteger), pointer :: cellsOnCell_save, edgesOnCell_save, verticesOnCell_save, &amp;
+                               cellsOnEdge_save, verticesOnEdge_save, edgesOnEdge_save, &amp;
+                               cellsOnVertex_save, edgesOnVertex_save
 
-      type (field2dInteger), pointer :: cellsOnCell1_ptr, edgesOnCell1_ptr, verticesOnCell1_ptr, &amp;
-                               cellsOnEdge1_ptr, verticesOnEdge1_ptr, edgesOnEdge1_ptr, &amp;
-                               cellsOnVertex1_ptr, edgesOnVertex1_ptr
+      type (field2dInteger), pointer :: cellsOnCell_ptr, edgesOnCell_ptr, verticesOnCell_ptr, &amp;
+                               cellsOnEdge_ptr, verticesOnEdge_ptr, edgesOnEdge_ptr, &amp;
+                               cellsOnVertex_ptr, edgesOnVertex_ptr
 
-      type (field1dInteger) :: int1d
-      type (field2dInteger), pointer :: int2d
-      type (field0dReal) :: real0d
-      type (field1dReal) :: real1d
-      type (field2dReal) :: real2d
-      type (field3dReal) :: real3d
-      type (field0dChar) :: char0d
-      type (field1dChar) :: char1d
-
       output_obj % time = itime
 
       !
@@ -134,197 +122,197 @@
       !
       ! Also, backup local indices to be copied back into blocks after output is complete.
       !
-      cellsOnCell1_ptr =&gt; cellsOnCell1_save
-      edgesOnCell1_ptr =&gt; edgesOnCell1_save 
-      verticesOnCell1_ptr =&gt; verticesOnCell1_save
-      cellsOnEdge1_ptr =&gt; cellsOnEdge1_save 
-      verticesOnEdge1_ptr =&gt; verticesOnEdge1_save 
-      edgesOnEdge1_ptr =&gt; edgesOnEdge1_save
-      cellsOnVertex1_ptr =&gt; cellsOnVertex1_save 
-      edgesOnVertex1_ptr =&gt; edgesOnVertex1_save
+      allocate(cellsOnCell_save)
+      allocate(edgesOnCell_save) 
+      allocate(verticesOnCell_save)
+      allocate(cellsOnEdge_save)
+      allocate(verticesOnEdge_save)
+      allocate(edgesOnEdge_save)
+      allocate(cellsOnVertex_save)
+      allocate(edgesOnVertex_save)
 
+      cellsOnCell_ptr =&gt; cellsOnCell_save
+      edgesOnCell_ptr =&gt; edgesOnCell_save 
+      verticesOnCell_ptr =&gt; verticesOnCell_save
+      cellsOnEdge_ptr =&gt; cellsOnEdge_save 
+      verticesOnEdge_ptr =&gt; verticesOnEdge_save 
+      edgesOnEdge_ptr =&gt; edgesOnEdge_save
+      cellsOnVertex_ptr =&gt; cellsOnVertex_save 
+      edgesOnVertex_ptr =&gt; edgesOnVertex_save
+
       block_ptr =&gt; domain % blocklist
       do while(associated(block_ptr))
-        allocate(cellsOnCell1_ptr % array(block_ptr % mesh % maxEdges, block_ptr % mesh % nCellsSolve))
-        allocate(edgesonCell1_ptr % array(block_ptr % mesh % maxEdges, block_ptr % mesh % nCellsSolve))
-        allocate(verticesOnCell1_ptr % array(block_ptr % mesh % maxEdges, block_ptr % mesh % nCellsSolve))
-        allocate(cellsOnEdge1_ptr % array(2, block_ptr % mesh % nEdgesSolve))
-        allocate(verticesOnEdge1_ptr % array(2, block_ptr % mesh % nEdgesSolve))
-        allocate(edgesOnEdge1_ptr % array(2 * block_ptr % mesh % maxEdges, block_ptr % mesh % nEdgesSolve))
-        allocate(cellsOnVertex1_ptr % array(block_ptr % mesh % vertexDegree, block_ptr % mesh % nVerticesSolve))
-        allocate(edgesOnVertex1_ptr % array(block_ptr % mesh % vertexDegree, block_ptr % mesh % nVerticesSolve))
+        maxEdges = block_ptr % mesh % maxEdges
+        maxEdges2 = block_ptr % mesh % maxEdges2
+        vertexDegree = block_ptr % mesh % vertexDegree
+        nCells = block_ptr % mesh % nCells
+        nEdges = block_ptr % mesh % nEdges
+        nVertices = block_ptr % mesh % nVertices
+        nCellsSolve = block_ptr % mesh % nCellsSolve
+        nEdgesSolve = block_ptr % mesh % nEdgesSolve
+        nVerticesSolve = block_ptr % mesh % nVerticesSolve
 
-        do i=1,block_ptr % mesh % nCellsSolve
-          do j=1,block_ptr % mesh % nEdgesOnCell % array(i)
-            cellsonCell1_ptr % array(j, i) = block_ptr % mesh % cellsOnCell % array(j,i)
-            block_ptr % mesh % cellsOnCell % array(j,i) = block_ptr % mesh % indexToCellID % array(block_ptr % mesh % cellsOnCell % array(j,i))
+        nullify(cellsOncell_ptr % ioinfo)
+        cellsOncell_ptr % array =&gt; block_ptr % mesh % cellsOncell % array
+        allocate(block_ptr % mesh % cellsOnCell % array(maxEdges, nCells+1))
 
-            edgesOnCell1_ptr % array(j, i) = block_ptr % mesh % edgesOnCell % array(j,i)
-            block_ptr % mesh % edgesOnCell % array(j,i) = block_ptr % mesh % indexToEdgeID % array(block_ptr % mesh % edgesOnCell % array(j,i))
+        nullify(edgesOnCell_ptr % ioinfo)
+        edgesOnCell_ptr % array =&gt; block_ptr % mesh % edgesOnCell % array
+        allocate(block_ptr % mesh % edgesOnCell % array(maxEdges, nCells+1))
 
-            verticesOnCell1_ptr % array(j, i) = block_ptr % mesh % verticesOnCell % array(j, i)
-            block_ptr % mesh % verticesOnCell % array(j,i) = block_ptr % mesh % indexToVertexID % array(block_ptr % mesh % verticesOnCell % array(j,i))
-          end do
+        nullify(verticesOnCell_ptr % ioinfo)
+        verticesOnCell_ptr % array =&gt; block_ptr % mesh % verticesOnCell % array
+        allocate(block_ptr % mesh % verticesOnCell % array(maxEdges, nCells+1))
 
-          do j=block_ptr % mesh % nEdgesOnCell % array(i)+1,block_ptr % mesh % maxEdges
-            block_ptr % mesh % cellsOnCell % array(j,i) = block_ptr % mesh % nCellsSolve+1
-            block_ptr % mesh % edgesOnCell % array(j,i) = block_ptr % mesh % nEdgessolve+1
-            block_ptr % mesh % verticesOnCell % array(j,i) = block_ptr % mesh % nVerticesSolve+1
-          end do
-        end do
+        nullify(cellsOnEdge_ptr % ioinfo)
+        cellsOnEdge_ptr % array =&gt; block_ptr % mesh % cellsOnEdge % array
+        allocate(block_ptr % mesh % cellsOnEdge % array(2, nEdges+1))
 
-        do i=1,block_ptr % mesh % nEdgesSolve
-          cellsOnEdge1_ptr % array(1,i) = block_ptr % mesh % cellsOnEdge % array(1,i)
-          cellsOnEdge1_ptr % array(2,i) = block_ptr % mesh % cellsOnEdge % array(2,i)
-          block_ptr % mesh % cellsOnEdge % array(1,i) = block_ptr % mesh % indexToCellID % array(block_ptr % mesh % cellsOnEdge % array(1,i))
-          block_ptr % mesh % cellsOnEdge % array(2,i) = block_ptr % mesh % indexToCellID % array(block_ptr % mesh % cellsOnEdge % array(2,i))
+        nullify(verticesOnEdge_ptr % ioinfo)
+        verticesOnEdge_ptr % array =&gt; block_ptr % mesh % verticesOnEdge % array
+        allocate(block_ptr % mesh % verticesOnEdge % array(2, nEdges+1))
 
-          verticesOnEdge1_ptr % array(1,i) = block_ptr % mesh % verticesOnEdge % array(1,i)
-          verticesOnEdge1_ptr % array(2,i) = block_ptr % mesh % verticesOnEdge % array(2,i)
-          block_ptr % mesh % verticesOnEdge % array(1,i) = block_ptr % mesh % indexToVertexID % array(block_ptr % mesh % verticesOnEdge % array(1,i))
-          block_ptr % mesh % verticesOnEdge % array(2,i) = block_ptr % mesh % indexToVertexID % array(block_ptr % mesh % verticesOnEdge % array(2,i))
+        nullify(edgesOnEdge_ptr % ioinfo)
+        edgesOnEdge_ptr % array =&gt; block_ptr % mesh % edgesOnEdge % array
+        allocate(block_ptr % mesh % edgesOnEdge % array(maxEdges2, nEdges+1))
 
-          do j=1,block_ptr % mesh % nEdgesOnEdge % array(i)
-            edgesOnEdge1_ptr % array(j,i) = block_ptr % mesh % edgesOnEdge % array(j,i)
-            block_ptr % mesh % edgesOnEdge % array(j,i) = block_ptr % mesh % indexToEdgeID % array(block_ptr % mesh % edgesOnEdge % array(j,i))
-          end do
+        nullify(cellsOnVertex_ptr % ioinfo)
+        cellsOnVertex_ptr % array =&gt; block_ptr % mesh % cellsOnVertex % array
+        allocate(block_ptr % mesh % cellsOnVertex % array(vertexDegree, nVertices+1))
 
-          do j=block_ptr % mesh % nEdgesOnEdge % array(i)+1,2*block_ptr % mesh % maxEdges
-            edgesOnEdge1_ptr % array(j,i) = block_ptr % mesh % nEdgesSolve + 1
-            block_ptr % mesh % edgesOnEdge % array(j,i) = block_ptr % mesh % nEdgesSolve + 1
+        nullify(edgesOnVertex_ptr % ioinfo)
+        edgesOnVertex_ptr % array =&gt; block_ptr % mesh % edgesOnVertex % array
+        allocate(block_ptr % mesh % edgesOnVertex % array(vertexDegree, nVertices+1))
+
+        do i = 1, nCellsSolve
+          do j = 1, block_ptr % mesh % nEdgesOnCell % array(i)
+            block_ptr % mesh % cellsOnCell % array(j, i) = block_ptr % mesh % indexToCellID % array(cellsOnCell_ptr % array(j, i))
+            block_ptr % mesh % edgesOnCell % array(j, i) = block_ptr % mesh % indexToEdgeID % array(edgesOnCell_ptr % array(j, i))
+            block_ptr % mesh % verticesOnCell % array(j, i) = block_ptr % mesh % indexToVertexID % array(verticesOnCell_ptr % array(j, i))
           end do
 
+          block_ptr % mesh % cellsOnCell % array(block_ptr % mesh % nEdgesOnCell % array(i) + 1:maxEdges, i) = nCells+1
+          block_ptr % mesh % edgesOnCell % array(block_ptr % mesh % nEdgesOnCell % array(i) + 1:maxEdges, i) = nEdges+1
+          block_ptr % mesh % verticesOnCell % array(block_ptr % mesh % nEdgesOnCell % array(i) + 1:maxEdges, i) = nVertices+1
         end do
 
-        do i=1,block_ptr % mesh % nVerticesSolve
-          do j=1,block_ptr % mesh % vertexDegree
-            cellsOnVertex1_ptr % array(j,i) = block_ptr % mesh % cellsOnVertex % array(j,i)
-            block_ptr % mesh % cellsOnVertex % array(j,i) = block_ptr % mesh % indexToCellID % array(block_ptr % mesh % cellsOnVertex % array(j,i))
+        do i = 1, nEdgesSolve
+          block_ptr % mesh % cellsOnEdge % array(1, i) = block_ptr % mesh % indexToCellID % array(cellsOnEdge_ptr % array(1, i))
+          block_ptr % mesh % cellsOnEdge % array(2, i) = block_ptr % mesh % indexToCellID % array(cellsOnEdge_ptr % array(2, i))
 
-            edgesOnVertex1_ptr % array(j,i) = block_ptr % mesh % edgesOnVertex % array(j,i)
-            block_ptr % mesh % edgesOnVertex % array(j,i) = block_ptr % mesh % indexToEdgeID % array(block_ptr % mesh % edgesOnVertex % array(j,i))
+          block_ptr % mesh % verticesOnedge % array(1, i) = block_ptr % mesh % indexToVertexID % array(verticesOnEdge_ptr % array(1,i))
+          block_ptr % mesh % verticesOnedge % array(2, i) = block_ptr % mesh % indexToVertexID % array(verticesOnEdge_ptr % array(2,i))
+
+          do j = 1, block_ptr % mesh % nEdgesOnEdge % array(i)
+            block_ptr % mesh % edgesOnEdge % array(j, i) = block_ptr % mesh % indexToEdgeID % array(edgesOnEdge_ptr % array(j, i))
           end do
+
+          block_ptr % mesh % edgesOnEdge % array(block_ptr % mesh % nEdgesOnEdge % array(i)+1:maxEdges2, i) = nEdges+1
         end do
 
-        block_ptr =&gt; block_ptr % next
+        do i = 1, nVerticesSolve
+          do j = 1, vertexDegree
+            block_ptr % mesh % cellsOnVertex % array(j, i) = block_ptr % mesh % indexToCellID % array(cellsOnVertex_ptr % array(j, i))
+            block_ptr % mesh % edgesOnVertex % array(j, i) = block_ptr % mesh % indexToEdgeID % array(edgesOnVertex_ptr % array(j, i))
+          end do
+        end do
 
+        block_ptr =&gt; block_ptr % next
         if(associated(block_ptr)) then
-          allocate(cellsOnCell1_ptr % next)
-          allocate(edgesonCell1_ptr % next)
-          allocate(verticesOnCell1_ptr % next)
-          allocate(cellsOnEdge1_ptr % next)
-          allocate(verticesOnEdge1_ptr % next)
-          allocate(edgesOnEdge1_ptr % next)
-          allocate(cellsOnVertex1_ptr % next)
-          allocate(edgesOnVertex1_ptr % next)
+          allocate(cellsOnCell_ptr % next)
+          allocate(edgesOnCell_ptr % next)
+          allocate(verticesOnCell_ptr % next)
+          allocate(cellsOnEdge_ptr % next)
+          allocate(verticesOnEdge_ptr % next)
+          allocate(edgesOnEdge_ptr % next)
+          allocate(cellsOnVertex_ptr % next)
+          allocate(edgesOnVertex_ptr % next)
 
-          cellsOnCell1_ptr =&gt; cellsOnCell1_ptr % next
-          edgesOnCell1_ptr =&gt; edgesOnCell1_ptr % next 
-          verticesOnCell1_ptr =&gt; verticesOnCell1_ptr % next
-          cellsOnEdge1_ptr =&gt; cellsOnEdge1_ptr % next 
-          verticesOnEdge1_ptr =&gt; verticesOnEdge1_ptr % next 
-          edgesOnEdge1_ptr =&gt; edgesOnEdge1_ptr % next
-          cellsOnVertex1_ptr =&gt; cellsOnVertex1_ptr % next 
-          edgesOnVertex1_ptr =&gt; edgesOnVertex1_ptr % next
+          cellsOnCell_ptr =&gt; cellsOnCell_ptr % next
+          edgesOnCell_ptr =&gt; edgesOnCell_ptr % next
+          verticesOnCell_ptr =&gt; verticesOnCell_ptr % next
+          cellsOnEdge_ptr =&gt; cellsOnEdge_ptr % next
+          verticesOnEdge_ptr =&gt; verticesOnEdge_ptr % next
+          edgesOnEdge_ptr =&gt; edgesOnEdge_ptr % next
+          cellsOnVertex_ptr =&gt; cellsOnVertex_ptr % next
+          edgesOnVertex_ptr =&gt; edgesOnVertex_ptr % next
         end if
-        nullify(cellsOnCell1_ptr % next)
-        nullify(edgesonCell1_ptr % next)
-        nullify(verticesOnCell1_ptr % next)
-        nullify(cellsOnEdge1_ptr % next)
-        nullify(verticesOnEdge1_ptr % next)
-        nullify(edgesOnEdge1_ptr % next)
-        nullify(cellsOnVertex1_ptr % next)
-        nullify(edgesOnVertex1_ptr % next)
 
+        nullify(cellsOnCell_ptr % next)
+        nullify(edgesOnCell_ptr % next)
+        nullify(verticesOnCell_ptr % next)
+        nullify(cellsOnEdge_ptr % next)
+        nullify(verticesOnEdge_ptr % next)
+        nullify(edgesOnEdge_ptr % next)
+        nullify(cellsOnVertex_ptr % next)
+        nullify(edgesOnVertex_ptr % next)
       end do
 
       ! Write output file
       call MPAS_writeStream(output_obj % io_stream, output_obj % time, ierr)
 
       ! Converge indices back to local indices, and deallocate all temporary arrays.
-      cellsOnCell1_ptr =&gt; cellsOnCell1_save
-      edgesOnCell1_ptr =&gt; edgesOnCell1_save 
-      verticesOnCell1_ptr =&gt; verticesOnCell1_save
-      cellsOnEdge1_ptr =&gt; cellsOnEdge1_save 
-      verticesOnEdge1_ptr =&gt; verticesOnEdge1_save 
-      edgesOnEdge1_ptr =&gt; edgesOnEdge1_save
-      cellsOnVertex1_ptr =&gt; cellsOnVertex1_save 
-      edgesOnVertex1_ptr =&gt; edgesOnVertex1_save
+      cellsOnCell_ptr =&gt; cellsOnCell_save
+      edgesOnCell_ptr =&gt; edgesOnCell_save 
+      verticesOnCell_ptr =&gt; verticesOnCell_save
+      cellsOnEdge_ptr =&gt; cellsOnEdge_save 
+      verticesOnEdge_ptr =&gt; verticesOnEdge_save 
+      edgesOnEdge_ptr =&gt; edgesOnEdge_save
+      cellsOnVertex_ptr =&gt; cellsOnVertex_save 
+      edgesOnVertex_ptr =&gt; edgesOnVertex_save
 
       block_ptr =&gt; domain % blocklist
       do while(associated(block_ptr))
-        do i=1,block_ptr % mesh % nCellsSolve
-          do j=1,block_ptr % mesh % nEdgesOnCell % array(i)
-            block_ptr % mesh % cellsOnCell % array(j,i) = cellsonCell1_ptr % array(j, i)
-            block_ptr % mesh % edgesOnCell % array(j,i) = edgesOnCell1_ptr % array(j, i)
-            block_ptr % mesh % verticesOnCell % array(j,i) = verticesOnCell1_ptr % array(j, i)
-          end do
-        end do
 
-        do i=1,block_ptr % mesh % nEdgesSolve
-          block_ptr % mesh % cellsOnEdge % array(1,i) = cellsOnEdge1_ptr % array(1,i)
-          block_ptr % mesh % cellsOnEdge % array(2,i) = cellsOnEdge1_ptr % array(2,i)
+        deallocate(block_ptr % mesh % cellsOnCell % array)
+        deallocate(block_ptr % mesh % edgesOnCell % array)
+        deallocate(block_ptr % mesh % verticesOnCell % array)
+        deallocate(block_ptr % mesh % cellsOnEdge % array)
+        deallocate(block_ptr % mesh % verticesOnEdge % array)
+        deallocate(block_ptr % mesh % edgesOnEdge % array)
+        deallocate(block_ptr % mesh % cellsOnVertex % array)
+        deallocate(block_ptr % mesh % edgesOnVertex % array)
 
-          block_ptr % mesh % verticesOnEdge % array(1,i) = verticesOnEdge1_ptr % array(1,i)
-          block_ptr % mesh % verticesOnEdge % array(2,i) = verticesOnEdge1_ptr % array(2,i)
+        block_ptr % mesh % cellsOncell % array =&gt; cellsOnCell_ptr % array
+        block_ptr % mesh % edgesOnCell % array =&gt; edgesOnCell_ptr % array
+        block_ptr % mesh % verticesOnCell % array =&gt; verticesOnCell_ptr % array
+        block_ptr % mesh % cellsOnEdge % array =&gt; cellsOnEdge_ptr % array
+        block_ptr % mesh % verticesOnEdge % array =&gt; verticesOnEdge_ptr % array
+        block_ptr % mesh % edgesOnEdge % array =&gt; edgesOnEdge_ptr % array
+        block_ptr % mesh % cellsOnVertex % array =&gt; cellsOnVertex_ptr % array
+        block_ptr % mesh % edgesOnVertex % array =&gt; edgesOnVertex_ptr % array
 
-          do j=1,block_ptr % mesh % nEdgesOnEdge % array(i)
-            block_ptr % mesh % edgesOnEdge % array(j,i) = edgesOnEdge1_ptr % array(j,i)
-          end do
-        end do
+        nullify(cellsOnCell_ptr % array)
+        nullify(edgesOnCell_ptr % array)
+        nullify(verticesOnCell_ptr % array)
+        nullify(cellsOnEdge_ptr % array)
+        nullify(verticesOnEdge_ptr % array)
+        nullify(edgesOnEdge_ptr % array)
+        nullify(cellsOnVertex_ptr % array)
+        nullify(edgesOnVertex_ptr % array)
 
-        do i=1,block_ptr % mesh % nVerticesSolve
-          do j=1,block_ptr % mesh % vertexDegree
-            block_ptr % mesh % cellsOnVertex % array(j,i) = cellsOnVertex1_ptr % array(j,i)
-            block_ptr % mesh % edgesOnVertex % array(j,i) = edgesOnVertex1_ptr % array(j,i)
-          end do
-        end do
-
-        deallocate(cellsOnCell1_ptr % array)
-        deallocate(edgesOnCell1_ptr % array)
-        deallocate(verticesOnCell1_ptr % array)
-        deallocate(cellsOnedge1_ptr % array)
-        deallocate(verticesOnedge1_ptr % array)
-        deallocate(edgesOnEdge1_ptr % array)
-        deallocate(cellsOnVertex1_ptr % array)
-        deallocate(edgesOnVertex1_ptr % array)
-
         block_ptr =&gt; block_ptr % next
-        if(associated(block_ptr)) then
-          int2d =&gt; cellsOnCell1_ptr % next
-          deallocate(cellsOnCell1_ptr)
-          cellsOnCell1_ptr =&gt; int2d
+        cellsOnCell_ptr =&gt; cellsOnCell_ptr % next
+        edgesOnCell_ptr =&gt; edgesOnCell_ptr % next
+        verticesOnCell_ptr =&gt; verticesOnCell_ptr % next
+        cellsOnEdge_ptr =&gt; cellsOnEdge_ptr % next
+        verticesOnEdge_ptr =&gt; verticesOnEdge_ptr % next
+        edgesOnEdge_ptr =&gt; edgesOnEdge_ptr % next
+        cellsOnVertex_ptr =&gt; cellsOnVertex_ptr % next
+        edgesOnVertex_ptr =&gt; edgesOnVertex_ptr % next
+      end do
 
-          int2d =&gt; edgesOnCell1_ptr % next
-          deallocate(edgesOnCell1_ptr)
-          edgesOnCell1_ptr =&gt; int2d
+      call mpas_deallocate_field(cellsOnCell_save)
+      call mpas_deallocate_field(edgesOnCell_save) 
+      call mpas_deallocate_field(verticesOnCell_save)
+      call mpas_deallocate_field(cellsOnEdge_save)
+      call mpas_deallocate_field(verticesOnEdge_save)
+      call mpas_deallocate_field(edgesOnEdge_save)
+      call mpas_deallocate_field(cellsOnVertex_save)
+      call mpas_deallocate_field(edgesOnVertex_save)
 
-          int2d =&gt; verticesOnCell1_ptr % next
-          deallocate(verticesOnCell1_ptr)
-          verticesOnCell1_ptr =&gt; int2d
-          
-          int2d =&gt; cellsOnEdge1_ptr % next
-          deallocate(cellsOnEdge1_ptr)
-          cellsOnEdge1_ptr =&gt; int2d
 
-          int2d =&gt; verticesOnEdge1_ptr % next
-          deallocate(verticesOnEdge1_ptr)
-          verticesOnEdge1_ptr =&gt; int2d
 
-          int2d =&gt; edgesOnEdge1_ptr % next
-          deallocate(edgesOnEdge1_ptr)
-          edgesOnEdge1_ptr =&gt; int2d
-
-          int2d =&gt; cellsOnVertex1_ptr % next
-          deallocate(cellsOnVertex1_ptr)
-          cellsOnVertex1_ptr =&gt; int2d
-
-          int2d =&gt; edgesOnVertex1_ptr %  next
-          deallocate(edgesOnVertex1_ptr)
-          edgesOnVertex1_ptr =&gt; int2d
-        end if
-      end do
-
    end subroutine mpas_output_state_for_domain!}}}
 
    subroutine mpas_output_state_finalize(output_obj, dminfo)!{{{

Modified: branches/omp_blocks/multiple_blocks/src/framework/mpas_timer.F
===================================================================
--- branches/omp_blocks/multiple_blocks/src/framework/mpas_timer.F        2012-06-01 21:26:16 UTC (rev 1956)
+++ branches/omp_blocks/multiple_blocks/src/framework/mpas_timer.F        2012-06-01 22:36:15 UTC (rev 1957)
@@ -334,7 +334,11 @@
             current % total_time = all_total_time
 
 #ifdef _MPI
-            current % efficiency = all_ave_time / all_total_time
+            if(all_total_time &gt; 0) then
+              current % efficiency = all_ave_time / all_total_time
+            else
+              current % efficiency = 1.0
+            end if
 #else
             current % efficiency = 1.0
 #endif

</font>
</pre>