PyGPlates 1.0.0 released

PyGPlates enables access to GPlates functionality via the Python programming language.

Install PyGPlates 1.0.0:-

PyGPlates can now be installed using conda or pip.

Please see the installation instructions in the pyGPlates documentation.

Note: The old method of installing a pre-compiled binary package is no longer available. This involved extracting a zip file (or installing a Debian package) and then manually adding the installed location to the PYTHONPATH environment variable.

What's new in PyGPlates 1.0.0:-

• Can now install pyGPlates using conda:
  • PyGPlates conda-forge packages can be installed with:
    conda install -c conda-forge pygplates
• Can now install pyGPlates using pip:
  • PyGPlates pip wheels can be installed with:
    pip install pygplates
• Added a new Primer chapter in the pyGPlates documentation:
  • Currently documents how to use topologies and deformation.
    • Still a work in progress.
  • Purpose is to show users how to use pyGPlates.
    • Aim to comprehensively cover functionality in pyGPlates.
    • Complements the sample codes.
• Added pickle support:
  • This means pyGPlates can now be used in multi-processing workflows,
    • where a multi-processing module will serialise pyGPlates objects into queues, and
    • de-serialise back into pyGPlates objects for processing on a different CPUs/nodes.
  • Most pyGPlates classes can be pickled.
    • This includes feature collections, features, and feature properties.
    • However, any classes containing reconstructed geometries cannot be pickled.
    • Each class will document whether it can be pickled or not.
• Filenames in pyGPlates can be os.PathLike in addition to strings:
  • Such as pathlib.Path.
• Added ReconstructModel and ReconstructSnapshot classes:
  • Similar to TopologicalModel and TopologicalSnapshot,
    • but for regular reconstruction instead of resolving topologies.
  • Better than using the reconstruct() function.
    • Just like TopologicalModel and TopologicalSnapshot are better than using the resolve_topologies() function.
• Added net rotation:
  • Create a NetRotationModel from a TopologicalModel.
    • And optionally specify your own point distribution (defaults to uniform lat-lon grid of points).
  • Use NetRotationModel to generate a NetRotationSnapshot at a reconstruction time.
  • Use NetRotationSnapshot to calculate a NetRotation.
    • This can be:
      • the total net rotation (over all topologies), or
      • the net rotation of a specific topology.
    • See the sample code.
  • Manually accumulate your own net rotation from points and their finite rotations.
• Can generate statistics along plate boundaries (at uniformly spaced points):
  • TopologicalSnapshot.calculate_plate_boundary_statistics() returns a PlateBoundaryStatistic at each point that contains:
    • boundary normal/length/velocity,
    • convergence velocity/obliquity/etc,
    • left/right plate velocity/etc (including strain rate), and
    • distances to start/end of plate boundary section (eg, trench).
  • See the sample code.
• Improved velocities and deformation:
  • Added Strain and StrainRate classes.
    • Can query strain quantities like dilatation and principal strain.
    • Can query strain rate quantities like dilatation rate and total strain rate.
    • And documented the underlying deformation theory.
  • Can query the deforming triangulation of a resolved network topology.
    • And rigid interior blocks.
  • Added Feature.create_topological_network_feature():
    • Enables rift network parameters to be specified.
  • Can query a TopologicalSnapshot at static points to:
    • Find intersected plates/networks, velocities and strain rates.
  • Can query a ReconstructSnapshot at static points to:
    • Find intersected static polygons and velocities.
  • Improved topologically reconstructed points:
    • Can directly extract crustal thickness, stretching factor, thinning factor and tectonic subsidence.
    • Can calculate velocities.
    • Can query strain rate and strain.
    • See the sample code.
  • Can incrementally reconstruct a point using a deforming network (or using a rigid plate):
    • Same functionality as TopologicalModel.reconstruct_geometry() but at a finer granularity:
      • One network (or plate) topology reconstructs one point over one time step, rather than
      • multiple topologies (eg, a global model) reconstructing multiple points over multiple time steps.
    • Gives user more control over the reconstruction.
  • All reconstructed/resolved geometries can calculate velocities at their vertices:
    • Reconstructed geometries:
      • ReconstructedFeatureGeometry, ReconstructedMotionPath, ReconstructedFlowline.
      • Eg, ReconstructedFeatureGeometry.get_reconstructed_geometry_point_velocities().
    • Resolved topologies:
      • ResolvedTopologicalLine, ResolvedTopologicalBoundary, ResolvedTopologicalNetwork
      • Eg, ResolvedTopologicalLine.get_resolved_geometry_point_velocities().
      • And their sub-segments:
        • ResolvedTopologicalSharedSubSegment, ResolvedTopologicalSubSegment.
        • Eg, ResolvedTopologicalSharedSubSegment.get_resolved_geometry_point_velocities().
  • Fixed quering overriding/subducting plates/networks (at shared boundary segments):

Documentation:-

Documentation and tutorials are available on the User Documentation page.

The pyGPlates Documentation includes:

• an Introduction to pyGPlates,
• a Getting Started chapter with an installation guide and a tutorial,
• a Primer chapter covering the main areas of pyGPlates,
• documented Examples, and
• a detailed Reference of pyGPlates functions and classes.

Note: The Primer chapter is new and is a work in progress.

The pyGPlates Tutorials are Jupyter Notebooks that analyse and visualise real-world data using pyGPlates. These tutorials complement the sample code in the pyGPlates documentation by providing a more research-oriented focus.