Predict the future position of the plates

Hi John,
Can you assist me in the execution of a code that will predict the future position of the plates? I need some clues on it and on how I can perform that via Pyglates!

Hi Duke,

GPlates doesn’t directly support geological times in the future (negative times). Throughout its development we have assumed only past times (positive times). However one workaround, if you’re not mixing past and future times together, is to assume positive times are future times (instead of past times) as mentioned in this post.

In terms of predicting future plate positions you can start with an existing plate model for the past and use it in an unconventional manner to find plate positions in the near future. To do this you would calculate the stage rotation of a plate at present day and then use that to position the plate at a future time. This is basically doing an extrapolation of the plate model into the future (there is no actual plate model in the future in this situation) and so the prediction would get worse further in the future.

In pyGPlates this would look something like this:

time_into_future = 5
plate_id = 801

# Rotation forward in time from 1Ma to 0Ma.
# Note that stage rotations typically go backward in time.
# But we made this rotation go forward in time because we
# specified "from_time" as 1Ma and "to_time" as 0Ma (ie, forward in time).
# If we had specified the other way around then the rotation would have gone
# backward in time and we'd also have to invert it to make it go foward in time.
rotation_forward_in_time = rotation_model.get_rotation(
    to_time=0, moving_plate_id=plate_id, from_time=1)

# Rotation is from 1Ma to 0Ma, however we can use it to go
# from 0Ma to -1Ma (ie, extrapolate 1Myr into the future).
# However our "time_into_future" is not 1 (it is 5).
# So increase the rotation angle accordingly so that it goes from 0Ma to -5Ma.
rotation_pole, rotation_angle_radians = \
rotation_forward_in_time = pygplates.FiniteRotation(
    rotation_pole, time_into_future * rotation_angle_radians)

# Extract present day geometry from a feature.
# For example, a plate boundary, or geometry assigned to a plate.
present_day_geometry = feature.get_geometry()

# Rotate the present day geometry into the future.
future_geometry = rotation_forward_in_time * present_day_geometry

Note that this is different than using something like pygplates.reconstruct() which essentially takes the reconstruction time (which should always be positive) and interpolates the plate rotation model (as opposed to extrapolation). For that function, if the plate model is in the past (as all current models typically are) then it reconstructs from present day to the past. Conversely, if the plate model is in the future (which is an unconventional usage of GPlates/pyGPlates) then it reconstructs from present day to the future. In both cases the reconstruction time is positive (and the times in the rotation file are always positive too). It just depends on whether (positive) time is considered to be the past or the future - and that’s why you can’t have a plate model (ie, rotation file) that mixes past and future.

However, with our little code segment above, we got around that by querying the plate rotation model in the past (from 1Ma in the past to present day) and manually reconstructing our geometry into the future (where there is no plate model).