Fixed git conflicts issue

Author: stelliom

python/extpar_art_to_buffer.py

@@ -69,145 +69,38 @@ def generate_memory_map(raw_lus, soiltype_memmap_filename,
     return lus, idxs
 
 
-<<<<<<< Updated upstream
-def calculate_soil_fraction(tg, lus, idxs, ncpu=2):
-    """
-    lus: LU classes from HWSD data
-    idxs: indices corrsponding to icon grid for each grid in HWSD data
-    tg: ICON grid
-    """
-    soil_types = np.arange(1, 14)
-    fracs = np.zeros((tg.lons.size, soil_types.size))
-    grid_ids, grid_counts = np.unique(idxs, return_counts=True)
-
-    def get_fraction_per_soil_type(lu):
-        grid_class, grid_count = np.unique(np.where(lus == lu, idxs, -1),
-                                           return_counts=True)
-        for grid_id in np.arange(tg.lons.size):
-            frac = np.array(grid_count[grid_class == grid_id] /
-                            grid_counts[grid_ids == grid_id])
-            if len(frac) != 0:
-                fracs[grid_id, lu - 1] = frac
-
-    Parallel(n_jobs=ncpu,
-             max_nbytes='100M',
-             mmap_mode='w+',
-             backend='threading')(delayed(get_fraction_per_soil_type)(lu)
-                                  for lu in tqdm(soil_types))
-    return fracs
-
-
-def calculate_soil_fraction_optimized(target_grid,
-                                      soil_types_raw,
-                                      nearest_target_cell_to_raw_cells,
-                                      ncpu=2):
-=======
 def calculate_soil_fraction(target_grid, soil_types_raw, nearest_target_cell_to_raw_cells, ncpu=13):
->>>>>>> Stashed changes
     """
     target_grid: target ICON grid
     soil_types_raw: landuse class for each cell from the HWSD dataset (LU variable)
-    nearest_target_cell_to_raw_cells: indices of the cell from the target ICON grid which is nearest to each cell of the raw grid (from HWSD dataset)
+    nearest_target_cell_to_raw_cell: indices of the cell from the target ICON grid which is nearest to each cell of the raw grid (from HWSD dataset)
     """
     ncells_target = target_grid.lons.size
     nsoil_types = 13
     nthreads = min(nsoil_types, ncpu)
 
-    soil_ids = np.arange(1, nsoil_types + 1)
+    soil_ids = np.arange(1, nsoil_types+1)
     soil_fractions_target = np.zeros((ncells_target, nsoil_types))
 
-<<<<<<< Updated upstream
-    target_cells, n_nearest_raw_cells = np.unique(
-        nearest_target_cell_to_raw_cells, return_counts=True)
-
-    for soil_id in tqdm(soil_ids[:1]):
-
-        target_cells_with_soil_type, n_nearest_raw_cells_with_soil_type = np.unique(
-            np.where(soil_types_raw == soil_id,
-                     nearest_target_cell_to_raw_cells, -1),
-            return_counts=True)
-=======
     n_nearest_raw_cells = np.bincount(nearest_target_cell_to_raw_cells.ravel(), minlength=ncells_target)
 
     def get_fraction_per_soil_type(soil_id):
         n_nearest_raw_cells_with_soil_type = np.bincount(nearest_target_cell_to_raw_cells[soil_types_raw == soil_id], minlength=ncells_target)
->>>>>>> Stashed changes
 
         np.divide( n_nearest_raw_cells_with_soil_type,
                    n_nearest_raw_cells,
                    out = soil_fractions_target[:, soil_id-1],
                    where = n_nearest_raw_cells != 0 )
 
-<<<<<<< Updated upstream
-            soil_fraction = np.array(
-                n_nearest_raw_cells_with_soil_type[target_cells_with_soil_type
-                                                   == target_cell_id] /
-                n_nearest_raw_cells[target_cells == target_cell_id])
-
-            if len(soil_fraction) != 0:
-                soil_fractions_target[target_cell_id,
-                                      soil_id - 1] = soil_fraction
-=======
     Parallel(n_jobs=nthreads,
              max_nbytes='100M',
              mmap_mode='w+',
              backend='threading')(delayed(get_fraction_per_soil_type)(soil_id)
                                   for soil_id in tqdm(soil_ids))
->>>>>>> Stashed changes
 
     return soil_fractions_target
 
 
-<<<<<<< Updated upstream
-def calculate_soil_fraction_test(tg, lus, idxs, ncpu=2):
-    """
-    lus: LU classes from HWSD data
-    idxs: indices corrsponding to icon grid for each grid in HWSD data
-    tg: ICON grid
-    """
-    soil_types = np.arange(1, 14)
-    fracs = np.zeros((tg.lons.size, soil_types.size))
-    grid_ids, grid_counts = np.unique(idxs, return_counts=True)
-    print("soil_types:", soil_types.shape)
-    print("fracs:", fracs.shape)
-    print("grid_ids:", grid_ids.shape)
-    print("grid_counts:", grid_counts.shape)
-
-    def get_fraction_per_soil_type(lu):
-        print("lus:", lus.shape)
-        print("idxs:", idxs.shape)
-        test = np.where(lus == lu, idxs, -1)
-        print("test:", test.shape)
-        start = perf_counter()
-        grid_class, grid_count = np.unique(np.where(lus == lu, idxs, -1),
-                                           return_counts=True)
-        end = perf_counter()
-        print("grid_class:", grid_class.shape)
-        print("grid_count:", grid_count.shape)
-        print("Sect 1:", end - start)
-        start = perf_counter()
-        for grid_id in grid_class:
-            frac = np.array(grid_count[grid_class == grid_id] /
-                            grid_counts[grid_ids == grid_id])
-            if len(frac) != 0:
-                fracs[grid_id, lu - 1] = frac
-        end = perf_counter()
-        print("Sect 2:", end - start)
-
-    #Parallel(n_jobs=13,
-    #         max_nbytes='100M',
-    #         mmap_mode='w+',
-    #         backend='threading')(delayed(get_fraction_per_soil_type)(lu)
-    #                              for lu in tqdm(soil_types))
-
-    for lu in tqdm(soil_types[:1]):
-        get_fraction_per_soil_type(lu)
-
-    return fracs
-
-
-=======
->>>>>>> Stashed changes
 # --------------------------------------------------------------------------
 # --------------------------------------------------------------------------
 # initialize logger