C grid interpolation for VectorFields by erikvansebille · Pull Request #2152 · Parcels-code/Parcels

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille · 2025-08-18T09:05:05Z

This PR implements C-grid interpolation for VectorFields (and Tracer Fields), building on #2122 (which will need to be merged into v4-dev first)

Chose the correct base branch (main for v3 changes, v4-dev for v4 changes)
Added tests

Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes · 2025-08-18T13:45:57Z

- dxdeta = np.dot(px, dphideta)
- dydxsi = np.dot(py, dphidxsi)
- dydeta = np.dot(py, dphideta)
+ dxdxsi = np.dot(dphidxsi, px)


@erikvansebille, following up on our discussion about these four $n \times n$ matrices, and the possible memory usage that may incur for large particle sets, I think the following code can work (and reduce any need to sparse)
dxdxsi_diag=np.einsum('ij,ji->i', dphidxsi, px) dxdeta_diag=np.einsum('ij,ji->i', dphideta, px) dydxsi_diag=np.einsum('ij,ji->i', dphidxsi, py) dydeta_diag=np.einsum('ij,ji->i', dphideta, py) jac_diag=dxdxsi_diag*dydeta_diag-dxdeta_diag*dydxsi_diagreturnjac_diag

@michaeldenes

Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Since np.where also calculates the parts that are not needed, these often throw a warning

as suggested in #2153 (comment)

VeckoTheGecko

Still need to have a proper look at application_kernels/interpolation.py

VeckoTheGecko · 2025-09-08T12:29:41Z

Do we have any tests that test C-grid vs A grid interpolation?

VeckoTheGecko · 2025-09-08T12:30:54Z

+ with np.errstate(divide="ignore", invalid="ignore"):
+ det = np.where(det2 > 0, np.sqrt(det2), eta)
+
+ eta = np.where(abs(aa) < 1e-12, -cc / bb, np.where(det2 > 0, (-bb + det) / (2 * aa), eta))
+


Which scenarios would produce the errors in particular are we ignoring here? And is the rest of the code robust to the nans/inf values that ignoring the errors would produce?

The way that np.where works is that it always computes both the True and False results (as far as I understand).
That means that it will for example take the np.sqrt(det2) even if det2 < 0, leading to a lot of warnings (have you not seen them in your test results?).
The with np.errstate() filters these warnings out
So yes, the code is robust to NaNs and Infs, because these would not be warnings but errors

one option would be to do:
mask=det2>0det[mask] =np.sqrt(det2[mask])
lets just merge for now and leave this 'unresolved' in the PR - minor thing

erikvansebille added 6 commits August 15, 2025 07:58

Start of implementing C-Grid interpolation
8d025da

Moving C-grid velocity code from v3 to v4
50d9d52

use time_interval type to set default time
3226306

Adding nemo curvilinear test for C-grid
1bd7e0c

Speeding up curvilinear search by dask loading lon and lat
2da436a

Updating c-grid velocity test and algorithm
0e1a221

github-project-automationBot added this to Parcels development Aug 18, 2025

github-project-automationBot moved this to Backlog in Parcels development Aug 18, 2025

erikvansebille added this to Parcels v4 release Aug 18, 2025

github-project-automationBot moved this to Backlog in Parcels v4 release Aug 18, 2025

erikvansebille added this to the Parcels Hackathon milestone Aug 18, 2025

erikvansebille mentioned this pull request Aug 18, 2025
Adding script for benchmarking the curvilinear search function Parcels-code/parcels-benchmarks#5
Draft

Fixing vector interpolation
1ecab22
Using correct mesh_type and conversion Also had to change the yi-indexing. To explore why!

michaeldenes reviewed Aug 18, 2025
View reviewed changes

erikvansebille added 5 commits August 18, 2025 15:59

Fixing CGrid_Velocity interpolation for multiple particles
8b1b830
Using vectorized version of dot-product calculation as suggested by @michaeldenes in #2152 (comment)

Adding better error message handling for CGrid_velocity interpolation
cad34e0

Adding warning suppression for index_search
26cffcc
Since np.where also calculates the parts that are not needed, these often throw a warning

Fixing error when Grid does not have lon or lat
e2376e2

Fixing to keep the maximum Error code in field
6529e13

Base automatically changed from vectorized-kernel to v4-devAugust 19, 2025 18:26

erikvansebille added 4 commits August 19, 2025 20:27

Merge branch 'v4-dev' into c-grid-interpolation
bbc2c30

Adding NEMO3D test
dda469d

Updating CGrid interpolation to not interpolate over depth for U and V
76d015b

Fixing W interpolation for CGrid
196c6e7

erikvansebille mentioned this pull request Aug 22, 2025
Adding the round_and_hash_float_array also to v3 #2156
Merged
1 task

erikvansebille added 5 commits August 22, 2025 10:29

Fixing stommel gyre CGrid interpolation test
1c948dd

Updating failing unit test
df78b62

Further fixing unit test by dropping unused dimensions
cd69147

Temporary fix to spatialhash
1a64033
as suggested in #2153 (comment)

Adding TODO statement about spherical meshes
7c1a87a

erikvansebille added 4 commits August 25, 2025 09:02

merge
f77f5f4

Fixing grid._mesh in interpolator
2924ee0

Merge branch 'feature/morton-hashing' into c-grid-interpolation
9264d8a

Using is_dask_collection to check for dask in interpolation
1a17911

erikvansebille mentioned this pull request Aug 27, 2025
Bug in Morton encoding query #2162
Closed

erikvansebille added 6 commits August 27, 2025 14:45

Merge branch 'v4-dev' into c-grid-interpolation
6753e81

Fixing vector_interp_method
5bdc874

Merge branch 'v4-dev' into c-grid-interpolation
a0962dc

fixing merging bugs
6659a1d

Merge branch 'v4-dev' into c-grid-interpolation
f14e8cb

Using is_dask_collection for c-grid interpolator
2568feb

erikvansebille mentioned this pull request Sep 3, 2025
First attempt at implementing XGrid Interpolators #2081
Closed
4 tasks

erikvansebille added 2 commits September 3, 2025 13:55

Merge branch 'v4-dev' into c-grid-interpolation
525ec71

Merge branch 'v4-dev' into c-grid-interpolation
cebda92

VeckoTheGecko requested changes Sep 8, 2025
View reviewed changes

github-project-automationBot moved this from Backlog to Ready in Parcels v4 release Sep 8, 2025

github-project-automationBot moved this from Backlog to Ready in Parcels development Sep 8, 2025

Removing mesh types check for VectorField
0ac7ae0

This was referenced Sep 9, 2025
Throw warning if _mesh is not the same for all Fields when creating FieldSet #2190
Closed
Using xgcm and axis properties to automatically determine indices offsets in Interpolators #2191
Closed

erikvansebilleand others added 2 commits September 9, 2025 10:52

Setting lon and lat as coordinates
872b75c

Merge branch 'v4-dev' into c-grid-interpolation
0be3404

VeckoTheGecko approved these changes Sep 9, 2025
View reviewed changes

erikvansebille enabled auto-merge September 9, 2025 13:20

Merge branch 'v4-dev' into c-grid-interpolation
38622fc

erikvansebille merged commit 1c8d5e5 into v4-devSep 9, 2025
8 of 9 checks passed

erikvansebille deleted the c-grid-interpolation branch September 9, 2025 13:26

github-project-automationBot moved this from Ready to Done in Parcels v4 release Sep 9, 2025

github-project-automationBot moved this from Ready to Done in Parcels development Sep 9, 2025

erikvansebille mentioned this pull request Sep 9, 2025
Benchmark use of np.where() versus boolean masking in Parcels kernels and interpolators #2197
Closed