igm-model 3.1.2__tar.gz → 3.2.0__tar.gz

igm_model-3.2.0/PKG-INFO

@@ -0,0 +1,62 @@
+Metadata-Version: 2.4
+Name: igm-model
+Version: 3.2.0
+Summary: IGM - a glacier evolution model
+Home-page: https://igm-model.org/
+Author: IGM authors
+Author-email: guillaume.jouvet@unil.ch
+License: gpl-3.0
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: tensorflow[and-cuda]==2.17.0
+Requires-Dist: matplotlib
+Requires-Dist: scipy
+Requires-Dist: netCDF4>=1.6.5
+Requires-Dist: xarray
+Requires-Dist: rasterio
+Requires-Dist: pyproj
+Requires-Dist: geopandas
+Requires-Dist: oggm
+Requires-Dist: salem
+Requires-Dist: pyyaml
+Requires-Dist: importlib_resources
+Requires-Dist: tqdm
+Requires-Dist: hydra-core
+Requires-Dist: omegaconf
+Requires-Dist: nvtx
+Requires-Dist: typeguard
+Requires-Dist: rich
+Requires-Dist: optuna>=3.0
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: summary
+
+<div align="center">
+
+<h1>The Instructed Glacier Model (IGM)</h1>
+
+<img src="logo/logo_igm.svg" width="40%" alt="IGM logo">
+
+[![CI](https://github.com/instructed-glacier-model/igm/actions/workflows/ci.yml/badge.svg)](https://github.com/instructed-glacier-model/igm/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/igm-model.svg)](https://pypi.org/project/igm-model/)
+[![Python](https://img.shields.io/badge/python-3.9%20|%203.10-blue)](https://pypi.org/project/igm-model/)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![Documentation](https://img.shields.io/badge/docs-igm--model.org-blue)](https://igm-model.org)
+
+</div>
+
+IGM is an accessible, differentiable, modular, and GPU-accelerated ice flow model.
+
+**Full documentation → [igm-model.org](https://igm-model.org)**
+
+---
+Looking for version 2 or earlier? See the [legacy wiki](https://github.com/jouvetg/igm/wiki).

igm_model-3.2.0/README.md

@@ -0,0 +1,20 @@
+<div align="center">
+
+<h1>The Instructed Glacier Model (IGM)</h1>
+
+<img src="logo/logo_igm.svg" width="40%" alt="IGM logo">
+
+[![CI](https://github.com/instructed-glacier-model/igm/actions/workflows/ci.yml/badge.svg)](https://github.com/instructed-glacier-model/igm/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/igm-model.svg)](https://pypi.org/project/igm-model/)
+[![Python](https://img.shields.io/badge/python-3.9%20|%203.10-blue)](https://pypi.org/project/igm-model/)
+[![License: GPL v3](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
+[![Documentation](https://img.shields.io/badge/docs-igm--model.org-blue)](https://igm-model.org)
+
+</div>
+
+IGM is an accessible, differentiable, modular, and GPU-accelerated ice flow model.
+
+**Full documentation → [igm-model.org](https://igm-model.org)**
+
+---
+Looking for version 2 or earlier? See the [legacy wiki](https://github.com/jouvetg/igm/wiki).

{igm_model-3.1.2 → igm_model-3.2.0}/igm/__init__.py

@@ -3,6 +3,7 @@
 # os.environ.setdefault("TF_CPP_MIN_LOG_LEVEL", "3")
 
 from . import processes
+from . import assimilations
 from . import inputs, outputs
 from . import common
 try:

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cook/infer_params_cook.py

@@ -7,6 +7,11 @@ def infer_params_cook(state, cfg):
     #This is probably not a good idea, because the values of both parameters do not depend solely on the velocity at that point. But feel free to try! If you do
     #want to do that, you'll also need to un-comment the code block for smoothing and then converting the smoothed weights back to tensors (you may also want to
     #visualise the figures!), and set up a state.convexity_weights field to act as the 2D array
+    if getattr(state, "da_friction", "slidingco") != "slidingco":
+        raise NotImplementedError(
+            "cook/infer_params is currently slidingco-only; either use "
+            "control_list with 'slidingco' or disable cook.infer_params."
+        )
     import scipy
     
     #Get list of G entities in each C/get multi-valued ice mask
@@ -17,7 +22,7 @@ def infer_params_cook(state, cfg):
     state.convexity_weights = tf.experimental.numpy.copy(state.icemaskobs)
     state.volumes = tf.experimental.numpy.copy(state.icemaskobs)
     state.volume_weights = tf.experimental.numpy.copy(state.icemaskobs)
-    state.volume_weights = tf.where(state.icemaskobs > 0, cfg.processes.data_assimilation.opti_vol_std, 0.0)
+    state.volume_weights = tf.where(state.icemaskobs > 0, cfg.assimilations.data_assimilation.opti_vol_std, 0.0)
     
     
     #Get some initial information
@@ -92,7 +97,7 @@ def infer_params_cook(state, cfg):
         AvgSlope = np.round(tf.reduce_max(state.slopes[state.icemaskobs==i]).numpy(), decimals=1)
         #print("Average Slope is: ", AvgSlope)
         
-        Tidewater = cfg.processes.data_assimilation.opti_tidewater_glacier
+        Tidewater = cfg.assimilations.data_assimilation.opti_tidewater_glacier
         
         #Do regressions
         if hasattr(state, "tidewatermask"):

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/cost_divfluxfcz.py

@@ -10,7 +10,7 @@ from igm.utils.grad.compute_divflux import compute_divflux
 def cost_divfluxfcz(cfg,state,i):
 
     divflux = compute_divflux(
-        state.ubar, state.vbar, state.thk, state.dx, state.dx, method=cfg.processes.data_assimilation.divflux.method
+        state.ubar, state.vbar, state.thk, state.dx, state.dx, method=cfg.assimilations.data_assimilation.divflux.method
     )
  
     ACT = state.icemaskobs > 0.5
@@ -28,12 +28,12 @@ def cost_divfluxfcz(cfg,state,i):
     
     ACT = state.icemaskobs > 0.5
     COST_D = 0.5 * tf.reduce_mean(
-        ((divfluxtar[ACT] - divflux[ACT]) / cfg.processes.data_assimilation.fitting.divfluxobs_std) ** 2
+        ((divfluxtar[ACT] - divflux[ACT]) / cfg.assimilations.data_assimilation.fitting.divfluxobs_std) ** 2
     )
 
-    if cfg.processes.data_assimilation.divflux.force_zero_sum:
+    if cfg.assimilations.data_assimilation.divflux.force_zero_sum:
             ACT = state.icemaskobs > 0.5
-            COST_D += 0.5 * 1000 * tf.reduce_mean(divflux[ACT] / cfg.processes.data_assimilation.fitting.divfluxobs_std) ** 2
+            COST_D += 0.5 * 1000 * tf.reduce_mean(divflux[ACT] / cfg.assimilations.data_assimilation.fitting.divfluxobs_std) ** 2
 
     return COST_D
  

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/cost_divfluxobs.py

@@ -9,21 +9,21 @@ from igm.utils.grad.compute_divflux import compute_divflux
 def cost_divfluxobs(cfg,state,i):
 
     divflux = compute_divflux(
-        state.ubar, state.vbar, state.thk, state.dx, state.dx, method=cfg.processes.data_assimilation.divflux.method
+        state.ubar, state.vbar, state.thk, state.dx, state.dx, method=cfg.assimilations.data_assimilation.divflux.method
     )
  
     divfluxtar = state.divfluxobs
     ACT = ~tf.math.is_nan(divfluxtar)
     COST_D = 0.5 * tf.reduce_mean(
-        ((divfluxtar[ACT] - divflux[ACT]) / cfg.processes.data_assimilation.fitting.divfluxobs_std) ** 2
+        ((divfluxtar[ACT] - divflux[ACT]) / cfg.assimilations.data_assimilation.fitting.divfluxobs_std) ** 2
     )
  
     dddx = (divflux[:, 1:] - divflux[:, :-1])/state.dx
     dddy = (divflux[1:, :] - divflux[:-1, :])/state.dx
-    COST_D += (cfg.processes.data_assimilation.regularization.divflux) * 0.5 * ( tf.reduce_mean(dddx**2) + tf.reduce_mean(dddy**2) )
+    COST_D += (cfg.assimilations.data_assimilation.regularization.divflux) * 0.5 * ( tf.reduce_mean(dddx**2) + tf.reduce_mean(dddy**2) )
 
-    if cfg.processes.data_assimilation.divflux.force_zero_sum:
+    if cfg.assimilations.data_assimilation.divflux.force_zero_sum:
         ACT = state.icemaskobs > 0.5
-        COST_D += 0.5 * 1000 * tf.reduce_mean(divflux[ACT] / cfg.processes.data_assimilation.fitting.divfluxobs_std) ** 2
+        COST_D += 0.5 * 1000 * tf.reduce_mean(divflux[ACT] / cfg.assimilations.data_assimilation.fitting.divfluxobs_std) ** 2
 
     return COST_D

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/misfit_thk.py

@@ -11,6 +11,6 @@ def misfit_thk(cfg,state):
     ACT = ~tf.math.is_nan(state.thkobs)
 
     return 0.5 * tf.reduce_mean( state.dens_thkobs[ACT] * 
-        ((state.thkobs[ACT] - state.thk[ACT]) / cfg.processes.data_assimilation.fitting.thkobs_std) ** 2
+        ((state.thkobs[ACT] - state.thk[ACT]) / cfg.assimilations.data_assimilation.fitting.thkobs_std) ** 2
     )
 

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/misfit_usurf.py

@@ -12,7 +12,7 @@ def misfit_usurf(cfg,state):
     return 0.5 * tf.reduce_mean(
         (
             (state.usurf[ACT] - state.usurfobs[ACT])
-            / cfg.processes.data_assimilation.fitting.usurfobs_std
+            / cfg.assimilations.data_assimilation.fitting.usurfobs_std
         )
         ** 2
     )

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/misfit_velsurf.py

@@ -10,15 +10,15 @@ def misfit_velsurf(cfg,state):
     velsurf    = tf.stack([state.uvelsurf,    state.vvelsurf],    axis=-1) 
     velsurfobs = tf.stack([state.uvelsurfobs, state.vvelsurfobs], axis=-1)
 
-    REL = tf.expand_dims( (tf.norm(velsurfobs,axis=-1) >= cfg.processes.data_assimilation.fitting.velsurfobs_thr ) , axis=-1)
+    REL = tf.expand_dims( (tf.norm(velsurfobs,axis=-1) >= cfg.assimilations.data_assimilation.fitting.velsurfobs_thr ) , axis=-1)
 
     ACT = ~tf.math.is_nan(velsurfobs) 
 
     cost = 0.5 * tf.reduce_mean(
-           ( (velsurfobs[ACT & REL] - velsurf[ACT & REL]) / cfg.processes.data_assimilation.fitting.velsurfobs_std  )** 2
+           ( (velsurfobs[ACT & REL] - velsurf[ACT & REL]) / cfg.assimilations.data_assimilation.fitting.velsurfobs_std  )** 2
     )
 
-    if cfg.processes.data_assimilation.fitting.include_low_speed_term:
+    if cfg.assimilations.data_assimilation.fitting.include_low_speed_term:
 
         # This terms penalize the cost function when the velocity is low
         # Reference : Inversion of basal friction in Antarctica using exact and incompleteadjoints of a higher-order model

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/misfit_vol.py

@@ -11,4 +11,4 @@ def misfit_vol(cfg,state):
 
     volmod = tf.reduce_sum(state.thk)
  
-    return 0.5 * ( ( voltar - volmod ) / (voltar * cfg.processes.data_assimilation.fitting.volobsprop_std ) )** 2
+    return 0.5 * ( ( voltar - volmod ) / (voltar * cfg.assimilations.data_assimilation.fitting.volobsprop_std ) )** 2

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/regu_arrhenius.py

@@ -12,16 +12,16 @@ def regu_arrhenius(cfg,state):
     dadx = (state.arrhenius[:, 1:] - state.arrhenius[:, :-1])/state.dx
     dady = (state.arrhenius[1:, :] - state.arrhenius[:-1, :])/state.dx
 
-    if cfg.processes.data_assimilation.optimization.sole_mask:                
+    if cfg.assimilations.data_assimilation.optimization.sole_mask:                
         dadx = tf.where( (state.icemaskobs[:, 1:] == 1) & (state.icemaskobs[:, :-1] == 1) , dadx, 0.0)
         dady = tf.where( (state.icemaskobs[1:, :] == 1) & (state.icemaskobs[:-1, :] == 1) , dady, 0.0)
     
-    if cfg.processes.data_assimilation.optimization.fix_opti_normalization_issue:
-        REGU_S = (cfg.processes.data_assimilation.regularization.arrhenius) * 0.5 * (
+    if cfg.assimilations.data_assimilation.optimization.fix_opti_normalization_issue:
+        REGU_S = (cfg.assimilations.data_assimilation.regularization.arrhenius) * 0.5 * (
             tf.math.reduce_mean(dadx**2) + tf.math.reduce_mean(dady**2)
         )
     else:
-        REGU_S = (cfg.processes.data_assimilation.regularization.arrhenius) * (
+        REGU_S = (cfg.assimilations.data_assimilation.regularization.arrhenius) * (
             tf.nn.l2_loss(dadx) + tf.nn.l2_loss(dady)
         )
 

igm_model-3.2.0/igm/assimilations/data_assimilation/cost_terms/regu_slidingco.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2021-2025 IGM authors
+# Published under the GNU GPL (Version 3), check at the LICENSE file
+
+import tensorflow as tf
+import numpy as np
+
+
+def regu_slidingco(cfg, state):
+    """Regularization on the friction control (slidingco or tau_ref).
+
+    The control name is resolved at DA init (see resolve_friction_name in
+    data_assimilation/utils.py) and stashed on state.da_friction.
+    The matching weight is read from
+    cfg.assimilations.data_assimilation.regularization[<control_name>].
+    """
+    fric = state.da_friction
+    field = getattr(state, fric)
+    weight = cfg.assimilations.data_assimilation.regularization[fric]
+
+    dadx = (field[:, 1:] - field[:, :-1]) / state.dx
+    dady = (field[1:, :] - field[:-1, :]) / state.dx
+
+    if cfg.assimilations.data_assimilation.optimization.sole_mask:
+        dadx = tf.where((state.icemaskobs[:, 1:] == 1) & (state.icemaskobs[:, :-1] == 1), dadx, 0.0)
+        dady = tf.where((state.icemaskobs[1:, :] == 1) & (state.icemaskobs[:-1, :] == 1), dady, 0.0)
+
+    if cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor_sl == 1:
+        if cfg.assimilations.data_assimilation.optimization.fix_opti_normalization_issue:
+            REGU_S = weight * 0.5 * (
+                tf.math.reduce_mean(dadx**2) + tf.math.reduce_mean(dady**2)
+            )
+        else:
+            REGU_S = weight * (
+                tf.nn.l2_loss(dadx) + tf.nn.l2_loss(dady)
+            )
+    else:
+        dadx = (field[:, 1:] - field[:, :-1]) / state.dx
+        dadx = (dadx[1:, :] + dadx[:-1, :]) / 2.0
+        dady = (field[1:, :] - field[:-1, :]) / state.dx
+        dady = (dady[:, 1:] + dady[:, :-1]) / 2.0
+
+        if cfg.assimilations.data_assimilation.optimization.sole_mask:
+            MASK = (state.icemaskobs[1:, 1:] > 0.5) & (state.icemaskobs[1:, :-1] > 0.5) & (state.icemaskobs[:-1, 1:] > 0.5) & (state.icemaskobs[:-1, :-1] > 0.5)
+            dadx = tf.where(MASK, dadx, 0.0)
+            dady = tf.where(MASK, dady, 0.0)
+
+        if cfg.assimilations.data_assimilation.optimization.fix_opti_normalization_issue:
+            REGU_S = weight * 0.5 * (
+                (1.0 / np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor_sl))
+                * tf.math.reduce_mean((dadx * state.flowdirx + dady * state.flowdiry)**2)
+                + np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor_sl)
+                * tf.math.reduce_mean((dadx * state.flowdiry - dady * state.flowdirx)**2)
+            )
+        else:
+            REGU_S = weight * (
+                (1.0 / np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor_sl))
+                * tf.nn.l2_loss((dadx * state.flowdirx + dady * state.flowdiry))
+                + np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor_sl)
+                * tf.nn.l2_loss((dadx * state.flowdiry - dady * state.flowdirx)))
+
+    return REGU_S

igm_model-3.2.0/igm/assimilations/data_assimilation/cost_terms/regu_thk.py

@@ -0,0 +1,207 @@
+#!/usr/bin/env python3
+
+# Copyright (C) 2021-2025 IGM authors 
+# Published under the GNU GPL (Version 3), check at the LICENSE file
+
+import numpy as np
+import tensorflow as tf
+from igm.assimilations.data_assimilation.utils import ave4
+
+def regu_thk(cfg,state):
+    if cfg.assimilations.data_assimilation.regularization.thk_version == 1:
+        return regu_thk_v1(cfg,state)
+    elif cfg.assimilations.data_assimilation.regularization.thk_version == 2:
+        return regu_thk_v2(cfg,state)
+
+#######################################
+
+def regu_thk_v1(cfg,state):
+
+    areaicemask = tf.reduce_sum(tf.where(state.icemask>0.5,1.0,0.0))*state.dx**2
+
+    # here we had factor 8*np.pi*0.04, which is equal to 1
+    if cfg.assimilations.data_assimilation.cook.infer_params:
+        gamma = tf.zeros_like(state.thk)
+        gamma = state.convexity_weights * areaicemask**(cfg.assimilations.data_assimilation.regularization.convexity_power-2.0)
+    else:
+        gamma = cfg.assimilations.data_assimilation.regularization.convexity_weight * areaicemask**(cfg.assimilations.data_assimilation.regularization.convexity_power-2.0)
+
+    if cfg.assimilations.data_assimilation.regularization.to_regularize == 'topg':
+        field = state.usurf - state.thk
+    elif cfg.assimilations.data_assimilation.regularization.to_regularize == 'thk':
+        field = state.thk
+
+    if cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor == 1:
+        dbdx = (field[:, 1:] - field[:, :-1])/state.dx
+        dbdy = (field[1:, :] - field[:-1, :])/state.dx
+
+        if cfg.assimilations.data_assimilation.optimization.sole_mask:
+            dbdx = tf.where( (state.icemaskobs[:, 1:] > 0.5) & (state.icemaskobs[:, :-1] > 0.5) , dbdx, 0.0)
+            dbdy = tf.where( (state.icemaskobs[1:, :] > 0.5) & (state.icemaskobs[:-1, :] > 0.5) , dbdy, 0.0)
+
+        if cfg.assimilations.data_assimilation.optimization.fix_opti_normalization_issue:
+            REGU_H = (cfg.assimilations.data_assimilation.regularization.thk) * 0.5 * (
+                tf.math.reduce_mean(dbdx**2) + tf.math.reduce_mean(dbdy**2)
+                - gamma * tf.math.reduce_mean(state.thk)
+            )
+        else:
+            REGU_H = (cfg.assimilations.data_assimilation.regularization.thk) * (
+                tf.nn.l2_loss(dbdx) + tf.nn.l2_loss(dbdy)
+                - gamma * tf.math.reduce_sum(state.thk)
+            )
+    else:
+        state.flowdirx = ave4(state.flowdirx)
+        state.flowdiry = ave4(state.flowdiry)
+
+        dbdx = (field[:, 1:] - field[:, :-1])/state.dx
+        dbdx = (dbdx[1:, :] + dbdx[:-1, :]) / 2.0
+        dbdy = (field[1:, :] - field[:-1, :])/state.dx
+        dbdy = (dbdy[:, 1:] + dbdy[:, :-1]) / 2.0
+
+        if cfg.assimilations.data_assimilation.optimization.sole_mask:
+            MASK = (state.icemaskobs[1:, 1:] > 0.5) & (state.icemaskobs[1:, :-1] > 0.5) & (state.icemaskobs[:-1, 1:] > 0.5) & (state.icemaskobs[:-1, :-1] > 0.5)
+            dbdx = tf.where( MASK, dbdx, 0.0)
+            dbdy = tf.where( MASK, dbdy, 0.0)
+ 
+        if cfg.assimilations.data_assimilation.optimization.fix_opti_normalization_issue:
+            REGU_H = (cfg.assimilations.data_assimilation.regularization.thk) * 0.5 * (
+                (1.0/np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor))
+                * tf.math.reduce_mean((dbdx * state.flowdirx + dbdy * state.flowdiry)**2)
+                + np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor)
+                * tf.math.reduce_mean((dbdx * state.flowdiry - dbdy * state.flowdirx)**2)
+                - tf.math.reduce_mean(gamma*state.thk)
+            )
+        else:
+            REGU_H = (cfg.assimilations.data_assimilation.regularization.thk) * (
+                (1.0/np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor))
+                * tf.nn.l2_loss((dbdx * state.flowdirx + dbdy * state.flowdiry))
+                + np.sqrt(cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor)
+                * tf.nn.l2_loss((dbdx * state.flowdiry - dbdy * state.flowdirx))
+                - tf.math.reduce_sum(gamma*state.thk)
+            )
+
+    return REGU_H
+
+#######################################
+
+def regu_thk_v2(cfg,state):
+
+    if cfg.assimilations.data_assimilation.regularization.to_regularize == 'topg':
+        field = state.usurf - state.thk
+    elif cfg.assimilations.data_assimilation.regularization.to_regularize == 'thk':
+        field = state.thk
+
+    # Comupute a rectification factor based on topg to favor 
+    # deep ice in the ablation (against shallow in the accumulation) 
+    if cfg.assimilations.data_assimilation.regularization.abl_acc_balance == 1:
+        rect = 1
+    else:
+        ELA = np.percentile(state.usurf[state.usurf > 0], 66.7, method="linear")       
+        r_acc = cfg.assimilations.data_assimilation.regularization.abl_acc_balance
+        r_abl = 1/cfg.assimilations.data_assimilation.regularization.abl_acc_balance
+        w_acc = 0.5 * (1.0 + tf.math.tanh((state.usurf - ELA) / 100.0)) 
+        rect = (r_acc * w_acc + r_abl * (1.0 - w_acc))
+
+    anis_factor = cfg.assimilations.data_assimilation.regularization.smooth_anisotropy_factor
+
+    # Derivative stencils
+    kx, ky, kxx, kyy, kxy = _kernels(state.dx)
+
+    # 1st derivatives (gradient)
+    if cfg.assimilations.data_assimilation.regularization.thk_1st_der_disc_version == "new":
+        bx  = _conv2(field, kx);  by  = _conv2(field, ky)    # Derivatives of field
+        if cfg.assimilations.data_assimilation.optimization.sole_mask:
+            bx  = tf.where( state.icemaskobs > 0.0, bx, 0.0)
+            by  = tf.where( state.icemaskobs > 0.0, by, 0.0)
+    else:  # do as in regu_thk_v1()
+        if anis_factor == 1:
+            bx = (field[:, 1:] - field[:, :-1])/state.dx
+            by = (field[1:, :] - field[:-1, :])/state.dx
+            if cfg.assimilations.data_assimilation.optimization.sole_mask:
+                bx = tf.where( (state.icemaskobs[:, 1:] > 0.5) & (state.icemaskobs[:, :-1] > 0.5) , bx, 0.0)
+                by = tf.where( (state.icemaskobs[1:, :] > 0.5) & (state.icemaskobs[:-1, :] > 0.5) , by, 0.0)
+        else:
+            bx = (field[:, 1:] - field[:, :-1])/state.dx
+            bx = (bx[1:, :] + bx[:-1, :]) / 2.0
+            by = (field[1:, :] - field[:-1, :])/state.dx
+            by = (by[:, 1:] + by[:, :-1]) / 2.0
+            if cfg.assimilations.data_assimilation.optimization.sole_mask:
+                MASK = (state.icemaskobs[1:, 1:] > 0.5) & (state.icemaskobs[1:, :-1] > 0.5) & (state.icemaskobs[:-1, 1:] > 0.5) & (state.icemaskobs[:-1, :-1] > 0.5)
+                bx = tf.where( MASK, bx, 0.0)
+                by = tf.where( MASK, by, 0.0)
+    
+    # 2nd derivatives (Hessian)
+    bxx = _conv2(field, kxx); byy = _conv2(field, kyy); bxy = _conv2(field, kxy) 
+    if cfg.assimilations.data_assimilation.optimization.sole_mask:
+        bxx = tf.where( state.icemaskobs > 0.0, bxx, 0.0)
+        byy = tf.where( state.icemaskobs > 0.0, byy, 0.0)
+        bxy = tf.where( state.icemaskobs > 0.0, bxy, 0.0)
+
+    alpha_2 = cfg.assimilations.data_assimilation.regularization.thk_2nd_der
+    alpha_1  = cfg.assimilations.data_assimilation.regularization.thk_1st_der
+    gamma = cfg.assimilations.data_assimilation.regularization.convexity_weight
+ 
+    if cfg.assimilations.data_assimilation.optimization.fix_opti_normalization_issue:
+        if anis_factor == 1:
+            R_1 = 0.5 * (tf.reduce_mean(tf.square(bx)) + tf.reduce_mean(tf.square(by)))
+            R_2 = 0.5 * rect * tf.reduce_mean(tf.square(bxx) + 2 * tf.square(bxy) + tf.square(byy))
+        else:
+            ux, uy = state.flowdirx, state.flowdiry
+            if cfg.assimilations.data_assimilation.regularization.thk_1st_der_disc_version == "new":
+                ux1, uy1 = ux, uy
+            else:
+                ux1, uy1 = ave4(ux), ave4(uy)  # so that dims match bx and by
+                
+            R_1 = 0.5 * tf.reduce_mean(tf.square(ux1*bx + uy1*by) + anis_factor * tf.square(uy1*bx - ux1*by))
+            R_2 = 0.5 * tf.reduce_mean(
+                tf.square(ux*ux*bxx + 2*ux*uy*bxy + uy*uy*byy) \
+                + 2 * anis_factor * tf.square(ux*uy*bxx + (uy*uy-ux*ux)*bxy + ux*uy*byy) \
+                + anis_factor * anis_factor * tf.square(uy*uy*bxx - 2*ux*uy*bxy + ux*ux*byy)
+            )
+        convexity_term = tf.reduce_mean(state.thk)
+
+    else:
+        if anis_factor == 1:
+            R_1 = tf.nn.l2_loss(bx) + tf.nn.l2_loss(by)
+            R_2 = tf.nn.l2_loss(bxx) + 2 * tf.nn.l2_loss(bxy) + tf.nn.l2_loss(byy)
+        else:
+            ux, uy = state.flowdirx, state.flowdiry
+            if cfg.assimilations.data_assimilation.regularization.thk_1st_der_disc_version == "new":
+                ux1, uy1 = ux, uy
+            else:
+                ux1, uy1 = ave4(ux), ave4(uy)  # so that dims match bx and by
+            R_1 = tf.nn.l2_loss(ux1*bx + uy1*by) + anis_factor * tf.nn.l2_loss(uy1*bx - ux1*by)
+            R_2 = tf.nn.l2_loss(ux*ux*bxx + 2*ux*uy*bxy + uy*uy*byy) \
+                + 2 * anis_factor * tf.nn.l2_loss(ux*uy*bxx + (uy*uy-ux*ux)*bxy + ux*uy*byy) \
+                + anis_factor * anis_factor * tf.nn.l2_loss(uy*uy*bxx - 2*ux*uy*bxy + ux*ux*byy)
+        convexity_term = tf.reduce_sum(state.thk)
+    
+    R = alpha_1 * R_1 + alpha_2 * R_2 - gamma * convexity_term
+    return R
+    
+def map_range(x,source_min, source_max, target_min, target_max): 
+        return target_min + (x - source_min) / (source_max - source_min) * (target_max - target_min)
+ 
+def _conv2(x, k):
+    """Apply 2D convolution to a 2D tensor."""
+    # Convert 2D tensor to 4D for conv2d: [batch, height, width, channels]
+    x_4d = tf.expand_dims(tf.expand_dims(x, 0), -1)
+    
+    # Apply padding and convolution
+    pad = [[0,0], [1,1], [1,1], [0,0]]  # 1 pixel on H and W
+    x_pad = tf.pad(x_4d, pad, mode="SYMMETRIC")
+    result = tf.nn.conv2d(x_pad, k, strides=1, padding='VALID')
+    
+    # Convert back to 2D
+    return tf.squeeze(result, [0, 3])
+
+def _kernels(dx: float):
+    """3×3 central-difference stencils."""
+    kx  = tf.constant([[0.,0.,0.],[-1.,0.,1.],[0.,0.,0.]], tf.float32) / (2.0*dx)
+    ky  = tf.constant([[0.,-1.,0.],[0., 0.,0.],[0., 1.,0.]], tf.float32) / (2.0*dx)
+    kxx = tf.constant([[0.,0.,0.],[1.,-2.,1.],[0.,0.,0.]], tf.float32) / (dx*dx)
+    kyy = tf.constant([[0.,1.,0.],[0.,-2.,0.],[0.,1.,0.]], tf.float32) / (dx*dx)
+    kxy = tf.constant([[ 1., 0.,-1.],[ 0., 0., 0.],[-1., 0., 1.]], tf.float32) / (4.0*dx*dx)
+    expand = lambda K: tf.reshape(K, [3,3,1,1])
+    return expand(kx), expand(ky), expand(kxx), expand(kyy), expand(kxy)
+ 

{igm_model-3.1.2/igm/processes → igm_model-3.2.0/igm/assimilations}/data_assimilation/cost_terms/total_cost.py

@@ -14,62 +14,65 @@ from .regu_arrhenius import regu_arrhenius
 def total_cost(cfg, state, cost, i):
 
     # misfit between surface velocity
-    if "velsurf" in cfg.processes.data_assimilation.cost_list:
+    if "velsurf" in cfg.assimilations.data_assimilation.cost_list:
         cost["velsurf"] = misfit_velsurf(cfg,state)
 
     # misfit between ice thickness profiles
-    if "thk" in cfg.processes.data_assimilation.cost_list:
+    if "thk" in cfg.assimilations.data_assimilation.cost_list:
         cost["thk"] = misfit_thk(cfg, state)
 
     # misfit between divergence of flux
-    if ("divfluxfcz" in cfg.processes.data_assimilation.cost_list):
+    if ("divfluxfcz" in cfg.assimilations.data_assimilation.cost_list):
         cost["divflux"] = cost_divfluxfcz(cfg, state, i)
-    elif ("divfluxobs" in cfg.processes.data_assimilation.cost_list):
+    elif ("divfluxobs" in cfg.assimilations.data_assimilation.cost_list):
         cost["divflux"] = cost_divfluxobs(cfg, state, i)
 
     # misfit between top ice surfaces
-    if "usurf" in cfg.processes.data_assimilation.cost_list:
+    if "usurf" in cfg.assimilations.data_assimilation.cost_list:
         cost["usurf"] = misfit_usurf(cfg, state) 
  
-    if "volume_init" in cfg.processes.data_assimilation.cost_list:
+    if "volume_init" in cfg.assimilations.data_assimilation.cost_list:
         cost["volume"] = misfit_vol(cfg, state)
 
     # add penalty terms to force obstacle constraints
-    if "penalty" in cfg.processes.data_assimilation.optimization.obstacle_constraint:
+    if "penalty" in cfg.assimilations.data_assimilation.optimization.obstacle_constraint:
 
         # force zero thikness outisde the mask
-        if "icemask" in cfg.processes.data_assimilation.cost_list:
+        if "icemask" in cfg.assimilations.data_assimilation.cost_list:
             cost["icemask"] = 10**10 * tf.math.reduce_mean( tf.where(state.icemaskobs > 0.5, 0.0, state.thk**2) )
 
         # Here one enforces non-negative ice thickness
-        if "thk" in cfg.processes.data_assimilation.control_list:
+        if "thk" in cfg.assimilations.data_assimilation.control_list:
             cost["thk_positive"] = \
             10**10 * tf.math.reduce_mean( tf.where(state.thk >= 0, 0.0, state.thk**2) )
 
-        # Here one enforces non-negative slidinco
-        if ("slidingco" in cfg.processes.data_assimilation.control_list) & \
-            (not cfg.processes.data_assimilation.fitting.log_slidingco):
-            cost["slidingco_positive"] =  \
-            10**10 * tf.math.reduce_mean( tf.where(state.slidingco >= 0, 0.0, state.slidingco**2) ) 
+        # Here one enforces non-negative friction control (slidingco or tau_ref)
+        fric = state.da_friction
+        if (fric in cfg.assimilations.data_assimilation.control_list) & \
+            (not cfg.assimilations.data_assimilation.fitting.log_slidingco):
+            fric_field = getattr(state, fric)
+            cost[f"{fric}_positive"] = \
+            10**10 * tf.math.reduce_mean( tf.where(fric_field >= 0, 0.0, fric_field**2) )
 
         # Here one enforces non-negative arrhenius
-        if ("arrhenius" in cfg.processes.data_assimilation.control_list):
+        if ("arrhenius" in cfg.assimilations.data_assimilation.control_list):
             cost["arrhenius_positive"] =  \
             10**10 * tf.math.reduce_mean( tf.where(state.arrhenius >= 1, 0.0, state.arrhenius**2) ) 
         
-    if cfg.processes.data_assimilation.cook.infer_params:
+    if cfg.assimilations.data_assimilation.cook.infer_params:
         cost["volume"] = cost_vol(cfg, state)
 
     # Here one adds a regularization terms for the bed toporgraphy to the cost function
-    if "thk" in cfg.processes.data_assimilation.control_list:
+    if "thk" in cfg.assimilations.data_assimilation.control_list:
         cost["thk_regu"] = regu_thk(cfg, state)
 
-    # Here one adds a regularization terms for slidingco to the cost function
-    if "slidingco" in cfg.processes.data_assimilation.control_list:
+    # Here one adds a regularization terms for the friction control
+    # (slidingco or tau_ref) to the cost function
+    if state.da_friction in cfg.assimilations.data_assimilation.control_list:
         cost["slid_regu"] = regu_slidingco(cfg, state)
 
     # Here one adds a regularization terms for arrhenius to the cost function
-    if "arrhenius" in cfg.processes.data_assimilation.control_list:
+    if "arrhenius" in cfg.assimilations.data_assimilation.control_list:
         cost["arrh_regu"] = regu_arrhenius(cfg, state) 
 
     return tf.reduce_sum(tf.convert_to_tensor(list(cost.values())))