# Mapping Resources > Tutorials/How-To >  [Tutorial] Using GPlates to model continental drift

## Charerg

There’s been a number of ambitious world-building projects recently that have attempted to model tectonic movements in a fictional world. One program that is extremely useful in creating a functional tectonic model for this purpose is GPlates, which allows you to model continental drift across time on a globe. As there aren’t any comprehensive GPlates tutorials on the guild, I thought I’d write one.

*Note:* This isn’t a tutorial about plate tectonics, only about how to use GPlates to model the movements of the continents. To actually figure out which movements make sense and which don’t, you need to familiarise yourself with plate tectonics.

Requirements for this tutorial:
GPlates

GPlates' own user documentary and tutorials:
Link

Before I begin with the tutorial itself, I should note that I’m not going to cover the basic functions of GPlates (like moving the view). However, there are some existent tutorials by Astrographer that cover this, which I recommend:
Using gplates for Realistic Worldbuilding
Continental Drift the gplates Way


Here are the contents of the tutorial planned so far. I’ll probably keep expanding this over time with more sections.

*Basic functionality: creating and moving continents
a. Creating a continentb. Writing a rotation filec. Animating the continental driftAdvanced functionality: locating mid-oceanic ridges and creating oceanic crust
a. Creating flowlinesb. Creating oceanic crustc. Colouring the oceanic crust based on ageAdvanced functionality: using Motion Paths to trace hotspots 
Advanced functionality: checking plate velocity 
Advanced functionality: generating a velocity field 
Advanced functionality: using conjugate plates 
*
Each section will be posted in a separate post (once it’s been written), and linked to the above table of contents. Without further ado, on to the tutorial itself!

----------


## Charerg

*a. CREATING A CONTINENT*

So, first off, the basics. Open GPlates, choose _File->Save Project As_ and then create a new folder for your GPlates model, and save the project there. Assuming that you’ve familiarized yourself with the basic functions like moving the view (_Drag Globe, hotkey D_) and changing projections, we can get started with creating your first continent. To begin with open the “_Digitisation tools_” (hotkey 3). There are three options: digitise point, line and polygon geometry. For drawing the outline of a continent, we want to “_Digitise new polygon geometry (hotkey G)_”:



Go on drawing the outline point-by-point. Once you’ve finished click “_Create feature_”. Now a list will open where you’ll pick what type of feature you’re creating. Choose either _ClosedContinentalBoundary_ or _ContinentalCrust_ as the feature type and click next.



In the next window, we will name the feature we’ve created, define when it exists, and which *Plate ID* it belongs to. The Plate ID *0* represents the planet’s spin axis in GPlates (and should be kept immobile). Since we want our continent to move, pick a different Plate ID (100 in this example). For the “_time of appearance_”, pick a point far in the planet’s past (500 Mya in the example) and 0 Mya (present) for the “_time of disappearance_”.



Then click next. Another window will pop up, but we don’t need to touch anything there, so click Next. Then, create a new feature collection called “Continents” where you’ll save this feature (as well as other similar features) and save it in your project folder.



Btw, ignore that "Landmass" feature in the screenshot (it's an artifact from the tutorial writing, you shouldn't have it). You’ve now created your first continent, congratulations! Next, let’s give it some colour. First, download the following image and save it in your project folder.



Then, choose _File->Import->Import raster_ and import the image you just loaded into GPlates. GPlates will ask about which longitudes and latitudes the raster covers. Since the above image already has the proportions of an equirectangular projection, the default settings are fine. GPlates will now generate a new feature collection from the loaded image in the folder where your image is located (which is why we saved it in the project folder to keep things organised). Now you should have the raster in your layer manager (_Window->Show layers_ if you’ve closed it):



Open the raster, and under the “Inputs” tab, find “Reconstructed polygons” and choose “Continents”. Now your raster should only affect the features defined in the “Continents” feature collection.



Now you’ve created your continent and attached a raster image to it. This is very useful with existing maps, since you can import them as rasters and then draw the continent outlines over the image. If you tie the raster to a feature like we did here, it will also follow the movements of the continent.  Speaking of said movements, the next step is to get the continent we just created moving. For that, we need a* rotation file*.



*b. WRITING A ROTATION FILE*

All motions in GPlates are defined as a rotation around an Euler pole, and relative to a conjugate plate. For that, you need to separately create a text file called the “rotation file”. I recommend using *Notepad++* for this.
So, create a simple text file called “rotation” and copy the following there:



> 100  0.0   90.0    0.0    0.0  000 !Plate A
> 100  2000.0   90.0    0.0    0.0  000 !Plate A


All entries in the rotation file have this format. The different columns have the following meaning:

*Plate ID*
*Time*
*Latitude*
*Longitude*
*Angle*
*Conjugate plate*
*Comment*

100
0.0
90.0
0.0
0.0
000
Plate A



This row describes the position of plate 100 at 0.0 Mya. The latitude and longitude describe the position of the Euler pole, the angle describes the rotation around it, while the conjugate plate tells us that this rotation is relative to plate 000 (which is the planet’s spin axis). So, in this case the Euler pole is the North Pole. The rotations can also be described relative to other plates, but for now we’ll keep this simple and keep the rotations relative to the planet’s spin axis.

The good news is that you won’t actually have to calculate any of this stuff yourself. GPlates can automatically modify the rotation file once you’ve set it up. To do that, we just need to do what we just have: define the plate’s position at present and at some arbitrary point far away in the past. Ideally, both of these “boundary rotations” should be kept at *[90, 0, 0]* values (or *[0, 0, 0]*, but in that case GPlates automatically rewrites it to *[90, 0, 0]* anyway).

So, for now all we need to do is to just copy the lines I gave into a text file. Make sure there is an empty line at the end of the file, otherwise it may not work properly. Then save it as “*rotation.rot*”. With Notepad++, you can do this by choosing “_All types_” and manually typing .rot as the file type.



Now that you have your rotation file, open your GPlates project and choose _File->Open feature collection_ and open the rotation file you just saved. The rotation file should now be in your feature manager (_File->Manage feature collections_ to check), and you’re all set for getting your continent moving!



*c. ANIMATING THE CONTINENTAL DRIFT*

Now we’re ready to get your continent moving. First off, pick a point in the past (type on the *Time* window), say 150 Mya. Then open the “_Pole manipulation_” tools (hotkey 5). “_Choose feature (hotkey F)_” and pick the continent you just created. You’ll note that it’s still in its present-day location. Next, pick “_Move pole (hotkey O)_”, and check “*Enable pole*”. There should now be an arrow representing a pole at the location of the north pole of the planet.



This is the pole that you'll rotate your continent around when you define its new location. The Move pole tool allows you to drag it around. Once you are happy with where the pole is located, pick “_Modify reconstruction pole (hotkey P)_”. Now you can drag the outline of the continent around the pole.



Fiddle around with the location of the continent (you can move the pole around too), and once you’re happy, click _Apply_. This will create a new reconstructed rotation for the continent in the rotation file at 150 Mya. However, it still needs to be saved, so open your Feature manager _(File->Manage feature collections_) and save the rotation file. Now you can click “*Play*” and see how your continent moves from the location you just defined into its present-day location!

However, your continent looks a bit lonely right now. To give it a pal, let’s try that other method of drawing a continent. Download the following picture and import it into GPlates as a raster, just like you did in the earlier parts of this section. 



Depending on how the layers are ordered in the layer manager, your planet should look something like this:



If you need to, you can hide some layers by clicking the eye icon in the layer manager. Set your “Time” back to 0.0 Mya and draw the outline of a new continent from the imported raster, just like you did previously. Then create it as a new feature (as before). Remember to give it a different Plate ID than Plate A (200 in this example), and save it in a new feature collection (say, Continents II), because we want to use a separate raster image for it than continent A.



Again, open your layers manager, open the layer corresponding to the “Continent B” raster, then under input click reconstructed polygons and pick “Continents II” (or whatever name you gave to the new feature collection). Your planet should now look like this:



Now, you need to set up your rotation file to include a separate plate for the continent we just created. First, _File->Manage feature collection_ and make sure you’ve saved the rotations you made previously in GPlates. Then, open the rotation file in a text editor, and “set up” plate B, just like you did previously. Your rotation file should look something like this:



Now that you’ve modified your rotation file, you need to reload it into GPlates. Open your “Manage feature collections” window again, and click the action “Reload” for the rotation file (the recycle icon).



Now, we can create our ancient supercontinent. Move back to 150 Mya in time and arrange continents A and B into a single continent. The result might look something like this:



As you can see, the fit isn’t quite perfect. However, we can fix that. Let’s say you’re really happy with continent B and don’t want to change the shape, so we’ll redraw continent A to fit the model. Basically, just redraw continent A like you’ve done previously, only now do so in 150 Mya. Remember to save the newly created continent A with the Plate ID 100 and save it in the right feature collection ("Continents").



The new outline of the continent should now appear, and you can delete the old one. So, your supercontinent might look something like this:



Then you can play the animation and see the continents breaking apart. A few example pics from this:

75 Mya:


0 Mya:


As you can see, these movements are a bit clunky and overlap a little. You can keep adding new reconstruction poles to new dates and so forth to get the movements right. You could also change the location of the continents in the present day by giving them “non-zero” present-day rotations. However, this should be avoided since it can mess up some of the more advanced features of GPlates (we’ll get to those later). So, that’s it for the first section of this tutorial! You’ve now learned how to create and move continents in GPlates. Give yourself a pat in the back and prepare for more to come, since in the next section we'll proceed into more advanced stuff: modelling the location of mid-oceanic ridges and the creation of new oceanic crust.

This my first tutorial here at the Guild, but I hope everything was clear and understandable. If you have any comments, questions, or ideas about the tutorial, feel free to post them. I'll try to keep track of this thread and answer them as time permits. Oh, and the 2nd section should be up "soonish" so stay tuned  :Wink: !

----------


## Todd Spengo

This looks awesome, thanks!


Sent from my iPhone using Tapatalk

----------


## kacey

Thank you so much! This is so helpful and easy to understand, I only wish you had of posted it earlier. It took me a long time to figure out this much on my own with the lack of good tutorials and I'm still lost on how to find the ridges and oceanic crust so I'm really excited for the next part because I have all but given up on figuring it out on my own...

This couldn't have come at a better time.

----------


## Charerg

> Thank you so much! This is so helpful and easy to understand, I only wish you had of posted it earlier. It took me a long time to figure out this much on my own with the lack of good tutorials and I'm still lost on how to find the ridges and oceanic crust so I'm really excited for the next part because I have all but given up on figuring it out on my own...
> 
> This couldn't have come at a better time.


Actually some of your troubles were kind of useful when writing the tutorial. It's been a few years since I learned the basics myself, so I've totally forgotten the kind of hurdles I came across as a beginner, and would have totally missed the stuff about Notepad++ and saving as .rot, if I was just writing this from my own "point of view", so to speak. So one might say that your suffering wasn't entirely in vain  :Wink: .

----------


## Warlin

I think a lot of people here in the guild were waiting for your tutorial, Charerg. Thanks for that. Will keep an eye on your progress  :Wink: .
Cheers.

----------


## Charerg

*a. CREATING A FLOWLINE*

Okay, so now that we have our continents separating, it’s time to look at modelling the new oceanic crust being created as part of the process. We’re going to use the *flowlines* feature of GPlates to achieve that, but before we start with the actual modelling it’s worthwhile to take a closer look at the behaviour of mid-oceanic ridges.

First off, a mid-oceanic ridge generates new oceanic crust at *equal rate* on both sides of the ridge. This has some implications for the movement of the mid-oceanic ridge that I’ll now try to demonstrate with a few pics taken from the model used in the GPlates tutorials (based on Seton et al. 2012).

First off, I’ve drawn the initial location of the India-Antarctica rift (130 Mya):


And then look at where the present-day ridge is located. You can still see ”the original location” close to where the Kerguelen plateau is.


As you probably noted, there is a rather substantial discrepancy between the location of the initial rift and the present-day location of the mid-oceanic ridge. That is because the distance between a point in India and Antarctica that were once connected is about 9000 km. Of this distance Antarctica has covered 1500 km, and India 7500 km (_very_ rough Google Maps measurements btw, nothing official). However, the ridge has created 4500 km of new crust *both* on the Antarctic and Indian plates. What this means in practice, is that the ridge has migrated 3000 km northwards due to the difference in relative movement between India and Antarctica. Well, actually the reality is a bit more complicated than that in this case, since the ridge in question became extinct around 40 Mya (the extinct mid-oceanic ridge between Indian and Australian plates today is the one initially located between India and Antarctica). Also, a good chunk of that ridge has now been subducted by Eurasia (so maybe not the best example). But you catch my (continental) drift, eh?  :Wink: 

Since I think it’s somewhat intuitive to think of mid-oceanic ridges as static, fixed features I feel the above point needed to be made. The ridges are in fact not static at all, they move depending on the *relative motions* of the plates. So, we need some method to the track the movement of these ridges, and that’s where flowlines come in.

Here, I’ve created a flowline between South America and Africa:


Again, note the “white outline” showing the location of the initial rift and note the discrepancy between its location and the modern ridge.

Here’s a second image, this time showing the actual present-day ridge as well:


As you’ll note, the flowline isn’t an exact match (I wasn’t too careful with point placement), but it does approximately match the shape and location of the mid-oceanic ridge. Also, the flowlines should depict the orientation of the “stretch marks” on the ocean floor, which is an additional useful feature of them.

The previous image with a global gravity anomaly raster on top:


Right, so after that rather long-winded introduction, let’s jump pack to our previous fictional model, and actually create one of these vaunted flowlines. First off, set the *Time* back to the point when the supercontinent starts breaking. Before you start, be aware that creating flowlines *can cause crashes* if you pick the wrong option or something goes wrong. So *always save everything* before attempting to create a flowline.

After you’ve made sure everything is saved, go under the Digitise tools and choose “_Digitise multi-point geometry (Hotkey M)_”. Go ahead and place some points at the seam between the two continents. Once you’re happy, click _Create feature_ and choose _Flowline_ from the list.



Then, click Next and you will be presented with some options. First off, you have the choice between *spreading centres*, *left-plate end points* and *right-plate end points*. Now, this is the critical option for those crashes I mentioned. I believe *left-plate end points* and *right-plate end points* are intended to work with *plates*. And *plates* in GPlates are *not* defined using the Digitisation tools, instead they are defined with the Topology tools (which we haven’t covered yet). This is why in the previous section we chose either _ClosedContinentalBoundary_ or _ContinentalCrust_ as feature type for our continents. Note that in Astrographer’s tutorial one suggestion was to define the continents as _ClosedPlateBoundary_. I wouldn’t recommend this, and it may cause problems with the flowlines we’re attempting to create here.

So, in case you didn’t guess it yet, choose *spreading centres*, otherwise I can almost guarantee you’ll get a crash. Then, type the appropriate Plate IDs in the “Left Plate ID” and “Right Plate ID” slots, set the flowline to exist from 150 Mya to present, and give it an appropriate name.



Next, you’ll have to insert an array of time instants. The flowline calculates the “half-stage rotations” between the two continents at specific intervals, and now you’ll have to define what those intervals are. Click “_Add_” and then under “Insert multiple times”, set it to insert times from 150 to 0 Mya at 10 Mya intervals. Then click “_Insert_” and “_Ok_”.



Click next and create a separate feature collection called “Flowlines” for storing flowline features. If your GPlates is going to crash, it will do so now (okay, it shouldn’t crash as long as you remember to pick spreading centres). Assuming everything went fine, you should now have a nice new feature collection. Go ahead and play the animation, to see the flowline in action. For me, this is the end result:



As you can see by looking at the flowline, something is dreadfully wrong with my rotations here. Apparently, I have a “hinge type rotation” with the hinge in the middle of the ocean! You’ll note that flowlines are a good way to check if your movements are valid, or if they’re total nonsense like my animation here. One way to fix this (in this case), is to redraw Continent A at present:



Then I can fiddle with the rotations a bit, and again redraw the continent at 150 Mya to fit the supercontinent. In this case, I originally redrew the continent at 0 Mya instead of rotating it to avoid giving it a “non-zero” present-day rotation (which will partially mess up flowlines 100% of the time). Flowlines do sort of “auto-update” to changes in rotation, btw. That said, you might have to re-create the flowline if you change continent shapes and location substantially or add a lot of new rotations. After some further redrawing and changing rotations (and recreating the flowline, several times in this case), here’s the result:



Note that I added a few pieces of extra crust to both continents here. You can do that by simply digitising a new polygon, just as we did when drawing the continent outlines. Then simply give it the same Plate ID as the parent continent, and it will stick along. Also, in this case save it in the same feature collection as its parent to give it the same texture. Now, looking at the flowline we see that the movements actually make sense! Note that since those “arrows” along the flowline are generated at 10 Mya intervals, you could directly estimate from this the ages of the oceanic crust, as well as the location of the mid-oceanic ridge!

However, if you want your GPlates model to not only be functional, but also to look pretty, you might want to actually depict the creation and aging of the oceanic crust. The further sub-sections will cover this process (and will fortunately be much shorter as well).



*b. CREATING OCEANIC CRUST*

Right, moving on to drawing the continental crust that is created at the mid-oceanic ridge. This is actually a very simple process, but somewhat time-consuming. Basically, the crust needs to be drawn manually. Now, don’t panic, this is actually fairly quick with the help of that flowline we created earlier. The “time-consuming” part comes in because it needs to be done separately for different ages. Which is why you should *only* consider doing this once your rotations are finished (at least for the two particular continents breaking apart)!

So, first off you need to decide at which intervals you’re going to draw the “new slabs” of oceanic crust. To keep this quick and simple, I’m going to draw them at 50 Mya intervals in this case. So, I need to draw one at 100 Mya (depicting the crust 150-100 old), the next at 50 Mya and a final slab at 0 Mya. So, first set the *Time* to 100 Mya. Then simply _“Digitise new polygon geometry”_, just like you did when drawing the continents, and draw the slab of oceanic crust using the flowline as an indicator. If you want to do this quickly, just click from point-to-point along the flowline. If fancy, you can think about where the strike-slip faults should be located based on the shape of the ridge, and put some “zig-zag” there. Those strike-slip faults (the “stretch marks” we noted earlier) should have the same orientation as the flowline, btw. Once you’re happy, “_Create feature_” and pick _OceanicCrust_ as the type.



Then give it the appropriate Plate ID so it follows the right continent, name it and specify that this slab appears at 100 Mya:



Next, go ahead and click through the final windows and save this in a new feature collection called “Oceanic Crust”. This is important because we want to colour this separately from the continents. Once done, you need to do what you just did for the slab connected to the opposite continent as well, of course. Just remember to give that the Plate ID of the other continent (200 in this case) and save in the feature collection we just created. This is how my continent looks like afterwards:



That done, we can move on 50 Mya. Since this is a tutorial, I’m now going to show you the “quick and dirty” way to draw those slabs faster. Normally, I would of course never consider such underhanded shenanigans, and would draw each slab down to the smallest strike-slip fault. But, you can directly click the flowline (using the “_Choose feature_” tool), and click “_Copy geometry to digitise tool_” to automatically copy-paste the points of the mid-oceanic ridge. Outlined in red in the following image:



Then you can just switch to “_Digitise new polygon geometry_” and finish the outline. Go ahead and create the 50 Mya slabs in this fashion. Again, be careful to give them the right Plate ID and specify that the new slabs appear at 50 Mya. Also, remember to save them in the Oceanic Crust feature collection. This is how the result looks like for me:



And finally, switch to 0 Mya and draw the final slabs. Again, remember the right Plate IDs and specify the time of appearance as 0 Mya. Having done this in the “quick and dirty” way, this is how my crust looks like:



As you can see, it doesn’t look too pretty yet, just the outlines. And if we wanted just the outlines we could have used the “quick and dirty” method to copy the points of the mid-oceanic ridge at various intervals and saved those as lines using “_Digitise new polyline geometry (hotkey L)_”. So, let’s go ahead and colour it, shall we?



*c. COLOURING THE OCEANIC CRUST BASED ON AGE*

To colour the oceanic crust we just created, open your Layers manager, and find the Oceanic Crust feature collection. Under “Reconstruction options” check “Fill polygons”. You might want to also set the “Fill opacity” at 0.5, so the flowlines are still visible.



Next, choose _Features->Manage Colouring_ and a new window pops up which lets you to manage the colouring of your various layers. This is pretty useful for other features besides oceanic crust as well, btw. From “Select layer”, choose “Oceanic Crust” and then pick _FeatureAge_ and _Default_. The result: 



If you play the animation, you can now view new oceanic crust popping up, and the colour changes as it ages. Congratulations, you’ve managed to complete this section of the tutorial!

I should note that this method works best for Atlantic-type situations, where an ocean has two passive margins. For other situations, it’s more tricky, but the method is the same. For example, if you have an ocean with an active and passive margin (meaning the crust is subducted on the other side of the ocean), you’d need to create a sort of “ghost plate” to depict the movements of the subducted crust. Say, create a piece of oceanic crust, give it a unique Plate ID and then use it as an “anchor” for the flowline. Those plates will have to be “set up” in the rotation file, of course. Since it’s going to be tricky to specify the present-day location of these kinds of essentially random slabs, it’s probably best just to terminate the flowline at say, 1.0 Mya (or before) to avoid the need to fiddle with “non-zero” present-day rotations. Here’s a quick example I just made:

150 Mya:


100 Mya:


50 Mya:


Remember that flowlines auto-update to rotation changes, so they’re very useful when attempting something like this. In fact, a good “workflow” is to first set up just initial basic rotations, then make use of flowlines to get them right, inserting new rotations and what-not. However, while with these methods we can already get pretty believable movements, we don’t have any clue yet if the velocities of our plates are plausible at all. Next up, I’m going to quickly cover the use of motion paths to create hotspot tracks (they’re very similar to flowlines), and then we’ll look at some methods to find out the velocity of your plates.

----------


## Tiluchi

So glad this is up now Charerg! Though of course it means many more hours for me wasted on GPlates... but fun hours!

----------


## Charerg

Okay, this section is going to be a quick one. First off, open your model and set the time back to 150 Mya. Go under the _Digitise_ tools, and choose _Digitise new multi-point geometry_. Then simply place a point where you wish a hotspot to be located 150 Mya, _Create feature_ and choose _MotionPath_.



Then choose a name for the hotspot and specify time of appearance (150 Mya in this case). Set the Plate ID as that of the plate that will be travelling over the hotspot, and leave Relative Plate ID at 0 (the planets spin axis).



Next, insert an array of time instants from 150 to 0 Mya at 10 Mya intervals, just as you did with the flowline.



Click next and save the motion path in a new feature collection called Hotspot Trails. Normally, the motion path will be coloured according to the Plate ID we gave it. I recommend changing the colour, in order to make it more visible (changing the colours of feature collections was covered in Section 2c).  Now, go ahead and play the animation. For me, this was the result:



As youll note, the trail is quite different from the flowlines. This is because motion paths represent the *absolute motion* of a plate relative to a fixed point on the globe, whereas the flowlines depict the *relative motion* between two plates. Also, with motion paths its good to remember that the *arrows point away from the present-day position of the point*. As you can see, this feature is extremely useful for tracing hotspot trails!

Thats it for this section! Youve now covered the essentials, and already have the tools to make pretty good use of GPlates. However, in case you want to go the extra mile, and not only want your continents to move, but also want them to move at plausible speed, next Ill cover how you can check the velocities of your continents.

----------


## Charerg

We now have our continents moving and fresh oceanic crust being formed along the way. In most cases, the actual velocity of the pieces probably isnt as important as the movements themselves, but since theres an easy way to check the velocity in GPlates, might as well do that.

First off, the velocity of plate movement is different depending on which point within the plate youre standing on. The velocity of Eurasia would be different in Europe than in Asia. So, all the velocity values you see in this post are measured at a particular point. However, for any velocity measurements regarding our fictional continents and plates to be actually useful, we need some yardstick to compare them to. So, its time to look at Earth and the speed of real tectonic plates. The Wikipedia plate tectonics map includes the present-day velocities of Earths plates relative to Africa (Link).

While the wiki map is a very good resource, ideally wed want the velocities to be measured relative to the planets spin axis and an average over a wider timeframe rather than just present-day velocities. With that in mind, Ive compiled a haphazard list using the model supplied in the GPlates tutorials (based on Seton et al. 2012). The following list includes the average velocities of various plates from 50-0 Mya, including the approximate region where the velocity is measured. All these velocities are *relative to the planets spin axis* (Plate 0 in GPlates). Note that Ive used just 5 Mya steps here to make my calculations quicker, so this is just supposed to give you a rough idea, these arent scientific-level accurate.

*Plate (Region)*
*50-0 Mya Avg. Velocity [cm/year]*

North American (Texas)
3.1

South American (Amazon Basin)
3.1

African (Kongo Basin)
1.9

Antarctic (South Pole)
1.2

Australian (Lake Eyre)
5.0

Indian (Deccan)
6.3

Eurasian (Tibetan Plateau)
1.5

Eurasian (Ukraine)
1.6

Pacific (Hawaii)
7.5

Nazca (Galapagos)
8.9



The speed record is made by India 55 Mya (18.7 cm/year in this model), which might be seen as a maximum velocity of sorts (its far from the average though). Remember that the above values are long term averages, the velocity could be drastically different during a shorter period. Since this is a GPlates tutorial, not a plate tectonics tutorial, I wont go too deep into why the plate speeds vary, but here are a few rules:

Plates that are *being subducted* (slab pull) move swiftly (Indian, Australian, Pacific, Nazca)Plates made of oceanic crust tend to move faster, especially if being subducted (Pacific, Nazca)Plates largely surrounded by divergent boundaries are slow (African, Antarctic)Large plates predominantly made of continental crust tend to move slowly (Eurasian)Continent-continent collisions slow the continents involved (African, Eurasian)Plates that are subducting oceanic crust and made of about 50/50 continental/oceanic crust fall in the middle (the American plates)Smaller plates tend to move faster than large plates (Nazca, Indian, Australian)

Okay, I think thats enough background material to get us started. So, lets fire up our fictional model. Lets say we want to know the velocity of Continent A. First, _Choose feature_ and pick Continent A. Then, _Utilities->Open Kinematics Tool_.



Click _Use focussed feature_ to show the kinematics for our selected feature (Continent A). Then, set the Begin as 150 Mya (since this is when our supercontinent starts breaking apart). You can also set the Step to be what you want. I set it at 10 Mya in this case. Then, choose Velocity magnitude as the Display Type in order to get a graph about the features velocity at the specified coordinates. Speaking of said coordinates, if you want to pick a specific point, you can hover your mouse over it to check what the coordinates are, and then type those in the kinematics tool. The mouse coordinates are outlined in red in the following pic:



And here we can directly see that Continent A has a relatively slow velocity of 1.3 cm/year. And checking Continent B, its even slower, crawling at 0.7 cm/year! So, we can directly see here that my continent movements are considerably slower than what they probably should be in this case (damn those slowpokes).

As a warning example, Ive made a continent here that crosses about a quarter of the globe in 20 million years:



You can see that the speedo-meter is flashing red right now. Better watch out that you dont have one of these scoundrels cruising around in your model, theres penalties for going too fast round this neighbourhood! Remember, the Tectonics Police is watching!

----------


## Charerg

Right, so now we have our continents moving, oceanic crust forming, and we can even check their velocity! However, like I mentioned, the velocity can vary at different points of a plate. So, it can be useful to actually generate a velocity field to see how the velocities differ. A velocity field in GPlates looks like this:



Let’s fire up our model then. I’ve created a new continent for the purpose of this tutorial, but you could also use one of the old ones (they’re just real slow moving in my version, as you noticed in the previous section). Anyway, for velocity fields to work, we need to first create some actual *plates* rather than continents. Since plates deform and change shape over time and we’re only interested in creating a velocity field for the present day, we only need to do so for 0 Mya though.

So, go under the _Digitise_ tool and choose “_Digitise new polyline geometry (hotkey L)_”. We will use this to draw the different boundaries. To start off, draw the mid-oceanic ridge, _Create feature_ and choose _MidOceanicRidge_ as the feature type. Save the line in its own feature collection called “Plate Boundaries” (and remember to give it the *right Plate ID*!). Here are the settings I used (note that I only set this to exist at 0 Mya):



I also gave the “Plate Boundaries” feature collection a unique colour to make it easy to see the lines. Next, if you envision your plate has a subduction boundary like mine has here, draw another line, _Create feature_ again, and choose _SubductionZone_ as the feature type. Again, save the feature in “Plate Boundaries”.



Then we need to define the rest of the plate boundaries. Draw another line to connect the ridge and the subduction zone. Make sure that this line intersects both of the previous lines! I decided that this boundary is a transform fault, and chose _Fault_ as the feature type (depending on the tectonics, could be a different type as well).



And finally draw the 4th line to finish the plate, again making sure it intersects. I picked _MidOceanicRidge_ as the feature type, but it could be something else as well. Your boundaries should now look something like this:



Note that we could have also drawn just two or three lines (or five or nine, you get the idea). The important thing is that the lines *intersect* each other, not the number of lines drawn.

Now we can actually define the plate itself. Go under the “_Topology_“ tools (hotkey 4) and choose “_Build new boundary topology (hotkey B)_”. Remember to check you don’t have any feature selected, otherwise the option will be greyed out. After choosing “_Build new boundary topology_”, click one of your lines. The “Topology Tools” window to the right of your screen should now have some options:



Now click “Add”. Notice how the “Topology boundary selections” window at the bottom of your screen shows your newly added feature:



Now go ahead and add the rest of the lines into your topology, going around the plate in either clockwise or counter clockwise order. Once done, your screen should look something like this:



Then click _Create_ and now you can choose _ClosedPlateBoundary_ as the feature type:



Then give your plate the right Plate ID and the appropriate time of appearance. I used the following settings:



Save your newly created plate in a new feature collection called “Plates”. Congratulations, you’ve now defined your plate! I chose to give the “Plates” feature collection a unique colour, infill at 0.5 opacity, and hid the previously created “Plate Boundaries”. So, my plate looks like this:



Now that we have our plate, we can generate the velocity field. I should warn you that doing so will clutter our “Layers” with something like 20+ extra layers. And as far as I’m aware, there’s no way to organise the layers into several layer groups in GPlates. So, you might want to either create a duplicate model for the sake of generating velocity fields, or only generate them after your tectonics model is finished. But, to generate the velocity field _Features->Generate Velocity Domain Points->CitcomS_. The following window will pop up:



Set the node density at 9x9 and I also recommend making a separate folder (name it Velocity Field or something) for the output directory, since this will generate quite a few files. Once done, click OK, and the velocity field should now appear.



You’ll note that the “Layers” are now very cluttered up. You can define the rest of the plates in exactly the same way, and their movement directions will also be shown on the field (no need to recreate the field). I also recommend hiding the nodes (the “mesh” layers). I created the plates A and B as well, and here’s how my planet looks like in Mollweide:



As you can see, the arrows denote *absolute movement direction* (movement relative to the planet’s spin axis), and the length of the arrows display the velocity. We can see here that Plate B is moving very slowly (0.7 cm/year), whereas Plate C is moving very swiftly relative to the others (about 9.3 cm/year). Generating a velocity field can be a useful tool if you’re using your GPlates model as a basis for creating a map of your present-day tectonic plates.

So, this is the last of the sections planned so far. You’ve essentially now learned all of my tricks! So, I’ll have to learn some new ones before the next update, which might be a while off. Best of luck with building up your models and happy (continental) drifting!  :Wink:

----------


## Charerg

Well, I ended up writing the “next update” a bit faster than planned. That’s because I finally bothered to learn how to use *conjugate plates*. Since this can be a useful feature for more complex reconstructions, I feel it’s a sort of necessary addition to the tutorial before it can be considered complete.

So, as we recall from writing that rotation file, all rotations in GPlates are defined as relative to a *conjugate plate*, which does not necessarily have to be 000 (the planet’s spin axis). Rotations can also be defined relative to other plates. This is especially useful if you want two plates to move as one piece.

Let’s fire up our fictional model and go back to 150 Mya, which is the point when Continents A and B start breaking apart. What if we wanted to model the movements further back in time? In that case, we’d want A and B to “stick together”, and that’s where conjugate plates come in. Let’s say that we want to set up Plate B as conjugated to Plate A. To do that, we need to first find out what is the *150 Mya Euler rotation for Plate B relative to Plate A* (not relative to the spin axis). To find that out, we need to temporarily change the Plate ID of the anchored plate. Click _Reconstruction->Specify Anchored Plate ID…_ and a window will pop up. In my case, I’ll pick Plate ID 100 (Plate A) as the anchored plate.



Click OK and you’ll note the continents change location. That’s because Plate 100 is now anchored (stationary) instead of Plate 000 (spin axis). So, the spin axis rotates relative to Plate 100 now instead of the other way around. But we don’t need to worry about that, we’ll change this back later. Right now, we’re interested in finding out the Euler rotation of Plate B (Plate ID 200 in my model) relative to the anchored plate. To do that, click _Reconstruction->View Total Reconstruction Poles_. Once again, a window will pop up. 



As you’ll note, the window has just a single entry, that of Plate 000 relative to Plate 100. That’s because all the other rotations are described relative to Plate 0, so it is the “parent plate” of all the others. Click the arrow next to “Plate ID” in the window to display the rotations of Plate 0’s children:



Now we can read from the *Equivalent rotation rel. anchored plate*  columns what the rotation of B (200) is relative to A (100) at 150 Mya. Open your rotation file. For me, the relevant entries look like this right now:




> 200  0.0      90.0       0.0           0.0         000 !Plate B
> 200 150.0    45.8413  100.6152  -20.1685  000 !
> 200 2000.0  90.0       0.0           0.0         000 !Plate B


What we need to do now is to add a *step over* at 150 Mya from movement relative to Plate 000 to movement relative to 100. So, fill in the coordinates and the angle that we just picked up (remember to change conjugate plate to 100 too!). Mine looks like the following:

*Plate ID*
*Time*
*Latitude*
*Longitude*
*Angle*
*Conj. Plate*
*Comment*

200
0.0
90.0
0.0
0.0
000
!Plate B

200
150.0
45.8413
100.6152
-20.1685
000
!

200
150.0
33.62
25.67
-23.77
100
!Step over to follow A

200
250.0
33.62
25.67
-23.77
100
!Detach from A

200
2000.0
90.0
0.0
0.0
000
!Plate B



Note that you need to add two entries. In this case, I’ve specified that B (200) does not move relative to A from 250 to 150 Mya. Now save your rotation file and reload it into GPlates. Returning to our model, first set the "Anchored Plate ID" back to 0. You'll notice that now we can give A any rotation between 150 to 250 Mya, and B will automatically follow its movements! Also, any rotation we give B between 150 to 250 Mya will be defined relative to Plate ID 100 (rather than 000). To see the outlines of both continents while rotating them, check the "Highlight children" box (outlined in red in the following image).



And with this addition, I think I’ve well and truly covered my extant knowledge of GPlates. Feel free to ask questions if something was unclear. Comments and ideas are also welcome. Happy drifting!

----------


## cliftonprince

Thanks for all this info. It's running right up my alley, and will help me out some, though I'm not sure I can accomplish my longer-term project (of getting an accurate simulation of Earth's real tectonic plates but moved in fictional directions). Will give it a go.  :Smile:

----------


## shadixdarkkon

Hey Charerg, I'm having a problem with GPlates flowline function.  No matter what I do my flowlines are showing up like the attached image. I've even done a complete reinstall of GPlates.  Do you have any idea what I'm doing wrong?  :Frown:

----------


## Charerg

> Hey Charerg, I'm having a problem with GPlates flowline function.  No matter what I do my flowlines are showing up like the attached image. I've even done a complete reinstall of GPlates.  Do you have any idea what I'm doing wrong?


Looks like one (or both) of the continents have a non-zero present day (0 Mya) rotation. Those tend to mess up the flowlines.

----------


## shadixdarkkon

Ah, gotcha.  So that makes it a bit harder to *start* with a supercontinent and work forward.  :Mad:  Thank you though, I appreciate the help!

----------


## Charerg

> Ah, gotcha.  So that makes it a bit harder to *start* with a supercontinent and work forward.  Thank you though, I appreciate the help!


Not necessarily, you can kind of work around it. For example, treat 1.0 Mya as "present day" (in other words change your current 0 mya poles to be 1 mya instead), that way you can keep the 0 Mya reconstruction poles as zero.

----------


## kacey

Wow, this has come along way since I last checked and I'm just about to dive in to you're tutorial but I wanted to ask a question before I start, I hope that's ok.

I've decided against my better judgement that I'm going to start with a Pangea type continent and break it up. Right now I have the basic land mass setup and the locations of major cratons and weak spots where old mountains ranges used to be, I don't know how they got there or why but that's where I'm going to start. I also have some key areas set up where subduction is going to start to pull it all apart, an ancient ring of fire so to speak, I just have to draw up the plates as they are now a little more clearly then I'll be ready to go but all the G.Plates tutorials I've found start with present day and I really don't want to go backwards...

So how to get my land mass into G.Plates at an earlier date? I would like to start back in time and see where the continents go so I have no idea what the present day situation would look like. Is there an easy way to do this? Or do I need to know where the continents will eventually end up before hand?

Sorry if this has already been asked I haven't gone over the whole thread yet just skimmed through it a little.

----------


## Charerg

> Wow, this has come along way since I last checked and I'm just about to dive in to you're tutorial but I wanted to ask a question before I start, I hope that's ok.
> 
> I've decided against my better judgement that I'm going to start with a Pangea type continent and break it up. Right now I have the basic land mass setup and the locations of major cratons and weak spots where old mountains ranges used to be, I don't know how they got there or why but that's where I'm going to start. I also have some key areas set up where subduction is going to start to pull it all apart, an ancient ring of fire so to speak, I just have to draw up the plates as they are now a little more clearly then I'll be ready to go but all the G.Plates tutorials I've found start with present day and I really don't want to go backwards...
> 
> So how to get my land mass into G.Plates at an earlier date? I would like to start back in time and see where the continents go so I have no idea what the present day situation would look like. Is there an easy way to do this? Or do I need to know where the continents will eventually end up before hand?
> 
> Sorry if this has already been asked I haven't gone over the whole thread yet just skimmed through it a little.


You can just follow the normal procedure, it shouldn't be too problematic. You can import the raster image of your Pangaea, then draw the continents based on that just like you would when starting with the present date arrangement. The only major problem is that some features won't work properly with non-zero 0 Mya pole. Like I mentioned, it should be possible to circumvent that limitation by treating another date (say, 10 Mya) as the "present day".

As an example, if you were to start from 200 Mya, your rotation file for one plate could look something like this:

0 Mya: Zero
10 Mya: Final position
50 Mya: Intermediate position
100 Mya: Intermediate position
150 Mya: Intermediate position
200 Mya: Zero (Starting position)

Let me know how it goes (I might consider adding an extra section to the tutorial about starting from Pangaea if it's too difficult based on the instructions so far).

----------


## kacey

Thanks Charerg, I was also curiouse, could I not just keep the Pangea at present day 0 mya and have the whole time line go from like 200 mya to 200 million years into the future and figure out the before and the after? Is this possible?

----------


## Charerg

> Thanks Charerg, I was also curiouse, could I not just keep the Pangea at present day 0 mya and have the whole time line go from like 200 mya to 200 million years into the future and figure out the before and the after? Is this possible?


I suppose that should be possible, though I have never tried it out.

----------


## Pixie

An alternative way, which I'm using as well these days:

draw your pangaea and set the pieces to start moving at, say, at 200 Ma.
set your rotations.rot so like this:

0    90.0  0.0  0.0    000 ! The end, but you will never get to zero Ma, just letting g.plates use it
1    XX   YY   RR   000 ! This is your real final position, which will happen when the clock shows 1 Ma

latest date worked out...  XX YY RR 000 ! As you work out new positions, you can update the rotation in 1 Ma, and your simulation keeps the plate still in the period you haven't still worked on

200 90.0  0.0  0.0    000  ! Starting position (Pangaea)

So, the basic idea is to aim at 1, while leaving a 0-rotation for the date 0 Ma, which g.plates needs, and at the same time, working with time moving forward, wich makes it easier for us as well.

----------


## kacey

So I've imported a raster image and traced out a couple of continents just for testing, but when I set the reconstruction polygons to continents under the image file it clips out only one plate and leaves the rest blank...wtf! I saved two plate id's under continents so why am I only getting one from my raster. As I can recall this happened last time I tried to figure out G.Plates too but I don't remember how I resolved it that time. 

Any ideas what I've done wrong to cause this?

Sorry for cluttering up this thread with questions.

----------


## Charerg

> So I've imported a raster image and traced out a couple of continents just for testing, but when I set the reconstruction polygons to continents under the image file it clips out only one plate and leaves the rest blank...wtf! I saved two plate id's under continents so why am I only getting one from my raster. As I can recall this happened last time I tried to figure out G.Plates too but I don't remember how I resolved it that time. 
> 
> Any ideas what I've done wrong to cause this?
> 
> Sorry for cluttering up this thread with questions.


Did you remember to update the rotation file as well? Remember that each time you add a new Plate ID you need to set that up in the rotation file.

----------


## kacey

It’s not the rotation file, I think maybe I forgot to save some changes when I made the plates, not really sure but Started fresh and it seems to be working now, sorry for the bother.

----------


## Charerg

As a bit of an inspiration for potential users (I hope), I thought I'd post a WIP video of the tectonic project for my own conworld. It uses most of the toolkit explained in this tutorial, though this remains a work-in-progress, so some pieces are missing, some details are a bit off, and so forth. But without further ado, here is the video:


* *











Feel free to ask any questions, and keep drifting!

----------


## shadixdarkkon

Hey Charerg, I know that this tutorial is pretty old, but I had a quick question.  Do you know if there is any way to create a feature with a conjugate plate ID without having to manually edit the .rot file each time? I've tried setting the conjugate ID when I create the feature, but it doesn't work for some reason, and the feature (in this case of a subduction zone) won't move with the piece of continental crust that it is supposed to be moving with.

----------


## Charerg

> Hey Charerg, I know that this tutorial is pretty old, but I had a quick question.  Do you know if there is any way to create a feature with a conjugate plate ID without having to manually edit the .rot file each time? I've tried setting the conjugate ID when I create the feature, but it doesn't work for some reason, and the feature (in this case of a subduction zone) won't move with the piece of continental crust that it is supposed to be moving with.


You could initialize the feature to be conjugated to begin with.  For example:

*Plate ID*
*Time*
*Latitude*
*Longitude*
*Angle*
*Conjugate plate*
*Comment*

100
0.0
90.0
0.0
0.0
200
Plate A

100
500.0
90.0
0.0
0.0
200
Plate A



In the above case Plate 100 would follow the movements of Plate 200. However, if you're just setting up a feature like a subduction zone, you probably just want to give it the same Plate ID as the plate it's supposed to be moving with (in which case you don't need to touch the rotation file).

----------


## Bobemor

Hi,
Found this tutorial really useful for getting me started on some stuff. Was just wondering if someone could cast there eye over what I've currently got and tell me if it just looks roughly like plates could look. Thought I should get that checked before I even begin moving stuff about.


* *





The little trianlges just mark oceanic crust. The Big light blue one on the south pole is also one but triangle doesn't show up!

----------


## RedKellBell

Hello there!

I was wondering if anyone could help me out with an issue. I got as far as moving the pole around, double checking all of my work, but I am unable to get the "Modify Reconstruction Pole" to light up. It's greyed out, i.e., disabled. I've searched the manual as to why this could be with no clear answer. Thank you for any help you can give!

----------


## Charerg

> Hi,
> Found this tutorial really useful for getting me started on some stuff. Was just wondering if someone could cast there eye over what I've currently got and tell me if it just looks roughly like plates could look. Thought I should get that checked before I even begin moving stuff about.
> 
> 
> * *
> 
> 
> 
> 
> ...


My advice is to not worry about the plate shapes per se, since they aren't very stable features when it comes to reconstructing a planet's tectonic history. Also, what shape they can have is totally dependent on the nature of the tectonic boundaries. A plate surrounded by divergent boundaries (like African and Antarctican) will have a very different shape to one that has a divergent margin on one side, and a convergent margin on the other (the American plates, for example).

It is also likely that the plate arrangement will change as "part of the process" of creating a tectonic history for your world, so you don't want to start off with a rigid present day arrangement. It's better to start off with just a few continents that used to form a supercontinent in the past, for example, and then work out their movements (or some other tectonic scenario you want to incorporate in your world). Eventually you can add more elements to your model as you keep building it up. You might even end up redoing almost everything if you're really into the tectonics side of thing (as I have, the current layout for Aduhr is the third one  :Wink: ).

Unfortunately there isn't an actual tectonics tutorial that would explain all the "rules of tectonic movements", but there are a number conworlds that have had fictional tectonics built up, and they can be a good source of infomation (and inspiration, hopefully). My own creation might provide some insight into the process, and there's also Pixie's Maward off the top of my head (there are many others too, with varying levels of complexity).




> Hello there!
> 
> I was wondering if anyone could help me out with an issue. I got as far as moving the pole around, double checking all of my work, but I am unable to get the "Modify Reconstruction Pole" to light up. It's greyed out, i.e., disabled. I've searched the manual as to why this could be with no clear answer. Thank you for any help you can give!


You need to have a feature selected in order to be able to move said feature around the pole.

----------

