LICENCE.txt

@@ -1,13 +0,0 @@
-Copyright 2025 Institute of Geophysics, Polish Academy of Sciences
-
-Licensed under the Apache License, Version 2.0 (the "License");
-you may not use this file except in compliance with the License.
-You may obtain a copy of the License at
-
-    http://www.apache.org/licenses/LICENSE-2.0
-
-Unless required by applicable law or agreed to in writing, software
-distributed under the License is distributed on an "AS IS" BASIS,
-WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-See the License for the specific language governing permissions and
-limitations under the License.

src/seismic_hazard_forecasting.py

@@ -48,7 +48,7 @@ def main(catalog_file, mc_file, pdf_file, m_file, m_select, mag_label, mc, m_max
     import logging
     from base_logger import getDefaultLogger
     from timeit import default_timer as timer
-    from math import ceil, floor, isnan
+    from math import ceil, floor
     import numpy as np
     import scipy
     import obspy
@@ -70,8 +70,6 @@ def main(catalog_file, mc_file, pdf_file, m_file, m_select, mag_label, mc, m_max
     import matplotlib.pyplot as plt
     from matplotlib.ticker import MultipleLocator
     from matplotlib.contour import ContourSet
-    import xml.etree.ElementTree as ET
-    import json
 
     logger = getDefaultLogger('igfash')
 
@@ -241,9 +239,6 @@ verbose: {verbose}")
         grid_y_max = int(ceil(y_max / grid_dim) * grid_dim)
         grid_y_min = int(floor(y_min / grid_dim) * grid_dim)
 
-        grid_lat_max, grid_lon_max = utm.to_latlon(grid_x_max, grid_y_max, utm_zone_number, utm_zone_letter)
-        grid_lat_min, grid_lon_min = utm.to_latlon(grid_x_min, grid_y_min, utm_zone_number, utm_zone_letter)
-
         # rectangular grid
         nx = int((grid_x_max - grid_x_min) / grid_dim) + 1
         ny = int((grid_y_max - grid_y_min) / grid_dim) + 1
@@ -439,39 +434,22 @@ verbose: {verbose}")
 
         PGA = np.zeros(shape=(nx * ny))
 
+        # use dask parallel computing
         start = timer()
+        pbar = ProgressBar()
+        pbar.register()
+        # iter = range(0,len(distances))
+        iter = indices
+        iml_grid_raw = []  # raw ground motion grids
+        for imt in products:
+            logger.info(f"Estimating {imt}")
 
-        use_pp = False
-
-        if use_pp:         # use dask parallel computing
-            pbar = ProgressBar()
-            pbar.register()
-            # iter = range(0,len(distances))
-            iter = indices
-            iml_grid_raw = []  # raw ground motion grids
-            for imt in products:
-                logger.info(f"Estimating {imt}")
-
-                imls = [dask.delayed(compute_IMT_exceedance)(rx_lat[i], rx_lon[i], distances[i].flatten(), fr, p, lambdas,
-                                                            forecast_len, lambdas_perc, m_range, m_pdf, m_cdf, model,
-                                                            log_level=logging.DEBUG, imt=imt, IMT_min=0.0, IMT_max=2.0, rx_label=i,
-                                                            rtol=0.1, use_cython=False) for i in iter]
-                iml = dask.compute(*imls)
-                iml_grid_raw.append(list(iml))
-
-        else:
-            iml_grid_raw = []
-            iter = indices
-            for imt in products:
-                iml = []
-                for i in iter:
-                    iml_i = compute_IMT_exceedance(rx_lat[i], rx_lon[i], distances[i].flatten(), fr, p, lambdas, forecast_len, 
-                                                    lambdas_perc, m_range, m_pdf, m_cdf, model, imt=imt, IMT_min = 0.0,
-                                                    IMT_max = 2.0, rx_label = i, rtol = 0.1, use_cython=False)
-                    iml.append(iml_i)
-                    logger.info(f"Estimated {imt} at rx {i} is {iml_i}")
-                iml_grid_raw.append(iml)
-
+            imls = [dask.delayed(compute_IMT_exceedance)(rx_lat[i], rx_lon[i], distances[i].flatten(), fr, p, lambdas,
+                                                         forecast_len, lambdas_perc, m_range, m_pdf, m_cdf, model,
+                                                         log_level=logging.DEBUG, imt=imt, IMT_min=0.0, IMT_max=2.0,
+                                                         rx_label=i) for i in iter]
+            iml = dask.compute(*imls)
+            iml_grid_raw.append(list(iml))
         end = timer()
         logger.info(f"Ground motion exceedance computation time: {round(end - start, 1)} seconds")
 
@@ -503,12 +481,6 @@ verbose: {verbose}")
                                  mode='reflect', anti_aliasing=False)
             iml_grid_hd[iml_grid_hd == 0.0] = np.nan  # change zeroes back to nan
 
-            # trim edges so the grid is not so blocky
-            vmin_hd = min(x for x in iml_grid_hd.flatten() if not isnan(x))
-            vmax_hd = max(x for x in iml_grid_hd.flatten() if not isnan(x))
-            trim_thresh = vmin
-            iml_grid_hd[iml_grid_hd < trim_thresh] = np.nan
-
             # generate image overlay
             north, south = lat.max(), lat.min()  # Latitude range
             east, west = lon.max(), lon.min()  # Longitude range
@@ -517,27 +489,17 @@ verbose: {verbose}")
             map_center = [np.mean([north, south]), np.mean([east, west])]
 
             # Create an image from the grid
-            cmap_name = 'YlOrRd'
-            cmap = plt.get_cmap(cmap_name)
             fig, ax = plt.subplots(figsize=(6, 6))
-            ax.imshow(iml_grid_hd, origin='lower', cmap=cmap, vmin=vmin, vmax=vmax)
+            ax.imshow(iml_grid_hd, origin='lower', cmap='viridis')
             ax.axis('off')
 
             # Save the figure
             fig.canvas.draw()
-            overlay_filename = f"overlay_{j}.svg"
-            plt.savefig(overlay_filename, bbox_inches="tight", pad_inches=0, transparent=True)
+            plt.savefig("overlay_" + str(j) + ".svg", bbox_inches="tight", pad_inches=0, transparent=True)
             plt.close(fig)
 
-            # Embed geographic bounding box into the SVG
-            map_bounds = dict(zip(("south", "west", "north", "east"),
-                            map(float, (grid_lat_min, grid_lon_min, grid_lat_max, grid_lon_max))))
-            tree = ET.parse(overlay_filename)
-            tree.getroot().set("data-map-bounds", json.dumps(map_bounds))
-            tree.write(overlay_filename, encoding="utf-8", xml_declaration=True)
-            logger.info(f"Saved geographic bounds to SVG metadata (data-map-bounds): {overlay_filename} → {map_bounds}")
-
             # Make the color bar
+            cmap_name = 'viridis'
             width = 50
             height = 500
 
@@ -545,20 +507,16 @@ verbose: {verbose}")
             gradient = np.vstack((gradient, gradient)).T
             gradient = np.tile(gradient, (1, width))
 
-            colorbar_title = products[j]
-            if "PGA" in colorbar_title or "SA" in colorbar_title:
-                colorbar_title = colorbar_title + "  (g)"
-
             fig, ax = plt.subplots(figsize=((width + 40) / 100.0, (height + 20) / 100.0),
                                    dpi=100)  # Increase fig size for labels
-            ax.imshow(gradient, aspect='auto', cmap=cmap.reversed(),
-                      extent=[0, 1, vmin, vmax_hd])  # Note: extent order is different for vertical
+            ax.imshow(gradient, aspect='auto', cmap=plt.get_cmap(cmap_name),
+                      extent=[0, 1, vmin, vmax])  # Note: extent order is different for vertical
             ax.set_xticks([])  # Remove x-ticks for vertical colorbar
             num_ticks = 11  # Show more ticks
-            tick_positions = np.linspace(vmin, vmax_hd, num_ticks)
+            tick_positions = np.linspace(vmin, vmax, num_ticks)
             ax.set_yticks(tick_positions)
             ax.set_yticklabels([f"{tick:.2f}" for tick in tick_positions])  # format tick labels
-            ax.set_title(colorbar_title, loc='right', pad=15) 
+            ax.set_title(imt, pad=15)
             fig.subplots_adjust(left=0.25, right=0.75, bottom=0.05, top=0.95)  # Adjust Layout
             fig.savefig("colorbar_" + str(j) + ".svg", bbox_inches='tight')
             plt.close(fig)